Add support for UNC and SNC naming conventions

source/cpp/init.cpp

@@ -3,6 +3,9 @@
 #include "logging.hpp"
 #include "performance.hpp"
 #include "security/anti_tamper.hpp"
+#include "naming_conventions/naming_conventions.h"
+#include "naming_conventions/function_resolver.h"
+#include "naming_conventions/script_preprocessor.h"
 
 namespace RobloxExecutor {
 
@@ -75,6 +78,33 @@ bool SystemState::Initialize(const InitOptions& options) {
             s_status.performanceInitialized = true;
         }
 
+        // Initialize naming conventions system
+        if (options.enableNamingConventions) {
+            // Initialize naming convention manager
+            auto& namingConventionManager = NamingConventions::NamingConventionManager::GetInstance();
+            if (!namingConventionManager.Initialize()) {
+                Logging::LogError("System", "Failed to initialize naming convention manager");
+                // Continue despite naming convention initialization failure
+            } else {
+                // Initialize function resolver
+                auto& functionResolver = NamingConventions::FunctionResolver::GetInstance();
+                if (!functionResolver.Initialize()) {
+                    Logging::LogError("System", "Failed to initialize function resolver");
+                    // Continue despite function resolver initialization failure
+                } else {
+                    // Initialize script preprocessor
+                    auto& scriptPreprocessor = NamingConventions::ScriptPreprocessor::GetInstance();
+                    if (!scriptPreprocessor.Initialize()) {
+                        Logging::LogError("System", "Failed to initialize script preprocessor");
+                        // Continue despite script preprocessor initialization failure
+                    } else {
+                        Logging::LogInfo("System", "Naming conventions system initialized");
+                        s_status.namingConventionsInitialized = true;
+                    }
+                }
+            }
+        }
+
         // Initialize execution engine
         s_executionEngine = std::make_shared<iOS::ExecutionEngine>();
         if (!s_executionEngine->Initialize()) {

source/cpp/init.hpp

@@ -1,166 +1,189 @@
-// init.hpp - Main initialization and shutdown functions for the library
-
 #pragma once
 
-#include <memory>
 #include <string>
 #include <functional>
-#include <vector>
+#include <memory>
+#include <atomic>
 
-#include "security/anti_tamper.hpp"
-#include "performance.hpp"
-#include "logging.hpp"
-#include "ios/ExecutionEngine.h"
-#include "ios/UIController.h"
-#include "ios/ScriptManager.h"
-#include "ios/PatternScanner.h"
-#include "ios/ai_features/AIIntegrationManager.h"
-#include "ios/ai_features/ScriptAssistant.h"
-#include "ios/ai_features/SignatureAdaptation.h"
+// Forward declarations
+namespace iOS {
+    class ExecutionEngine;
+    class ScriptManager;
+    class UIController;
+
+    namespace AIFeatures {
+        class AIIntegrationManager;
+        class ScriptAssistant;
+        class SignatureAdaptation;
+    }
+}
 
-// Public API for the executor library
 namespace RobloxExecutor {
 
-// Pre-initialization options
-struct InitOptions {
-    // Features to enable
-    bool enableLogging = true;                // Enable logging
-    bool enableErrorReporting = true;         // Enable error reporting
-    bool enableSecurity = true;               // Enable security features
-    bool enableJailbreakBypass = false;       // Enable jailbreak bypass
-    bool enablePerformanceMonitoring = false; // Enable performance monitoring
-    bool enableUI = true;                     // Enable UI features
-    bool enableScriptCaching = true;          // Enable script caching
-    bool enableAI = false;                    // Enable AI features
-
-    // Feature configurations
-    bool showFloatingButton = true;            // Show floating button
-    bool startSecurityMonitoring = true;       // Start security monitoring
-    bool enableCrashReporting = true;          // Enable crash reporting
-    bool enableAutoPerformanceLogging = false; // Enable automatic performance logging
-
-    // Paths
-    std::string crashReportDir;               // Crash report directory
-
-    // Thresholds
-    uint32_t performanceThresholdMs = 16;     // Performance threshold in milliseconds (1/60 second)
-
-    // Callbacks
-    using Callback = std::function<void()>;
-    using ValidationCallback = std::function<bool()>;
-
-    Callback preInitCallback;                 // Called before initialization
-    Callback postInitCallback;                // Called after initialization
-    ValidationCallback customValidationCallback; // Custom validation callback
-};
-
-// System status
+/**
+ * @struct SystemStatus
+ * @brief Tracks the initialization status of various system components
+ */
 struct SystemStatus {
-    bool loggingInitialized = false;          // Logging initialized
-    bool errorHandlingInitialized = false;    // Error handling initialized
-    bool securityInitialized = false;         // Security initialized
-    bool jailbreakBypassInitialized = false;  // Jailbreak bypass initialized
-    bool performanceInitialized = false;      // Performance monitoring initialized
-    bool scriptManagerInitialized = false;    // Script manager initialized
-    bool executionEngineInitialized = false;  // Execution engine initialized
-    bool uiInitialized = false;               // UI initialized
-    bool aiInitialized = false;               // AI initialized
-    bool allSystemsInitialized = false;       // All systems initialized
+    bool loggingInitialized = false;
+    bool errorHandlingInitialized = false;
+    bool securityInitialized = false;
+    bool jailbreakBypassInitialized = false;
+    bool performanceInitialized = false;
+    bool executionEngineInitialized = false;
+    bool scriptManagerInitialized = false;
+    bool uiInitialized = false;
+    bool aiInitialized = false;
+    bool namingConventionsInitialized = false;
+    bool allSystemsInitialized = false;
 };
 
-// Global system state
-class SystemState {
-
-// Make members public so they can be accessed from anywhere
-public:
-    static bool s_initialized;            // Whether the system is initialized
-    static InitOptions s_options;         // Initialization options
-    static SystemStatus s_status;         // Current system status
-    static std::shared_ptr<iOS::ExecutionEngine> s_executionEngine;
-    static std::shared_ptr<iOS::ScriptManager> s_scriptManager;
-    static std::unique_ptr<iOS::UIController> s_uiController;
-
-    // AI Components
-    static void* s_aiIntegration;
-    static std::shared_ptr<iOS::AIFeatures::AIIntegrationManager> s_aiManager;
-    static std::shared_ptr<iOS::AIFeatures::ScriptAssistant> s_scriptAssistant;
-    static std::shared_ptr<iOS::AIFeatures::SignatureAdaptation> s_signatureAdaptation;
+/**
+ * @struct InitOptions
+ * @brief Options for initializing the RobloxExecutor system
+ */
+struct InitOptions {
+    // Logging options
+    bool enableLogging = true;
+    std::string logDir = "";
 
-    // Public API
-    // Get system status
-    static const SystemStatus& GetStatus() {
-        return s_status;
-    }
+    // Error handling options
+    bool enableErrorReporting = true;
+    bool enableCrashReporting = true;
+    std::string crashReportDir = "";
 
-    // Check if initialized
-    static bool IsInitialized() {
-        return s_initialized;
-    }
-
-    // Get execution engine
-    static std::shared_ptr<iOS::ExecutionEngine> GetExecutionEngine() {
-        return s_executionEngine;
-    }
+    // Security options
+    bool enableSecurity = true;
+    bool startSecurityMonitoring = true;
 
-    // Get script manager
-    static std::shared_ptr<iOS::ScriptManager> GetScriptManager() {
-        return s_scriptManager;
-    }
+    // Bypass options
+    bool enableJailbreakBypass = true;
 
-    // Get UI controller
-    static iOS::UIController* GetUIController() {
-        return s_uiController.get();
-    }
+    // Performance options
+    bool enablePerformanceMonitoring = true;
+    bool enableAutoPerformanceLogging = false;
+    int performanceThresholdMs = 100;
 
-    // Get AI integration
-    static void* GetAIIntegration() {
-        return s_aiIntegration;
-    }
+    // Script options
+    bool enableScriptCaching = true;
 
-    // Get AI manager
-    static std::shared_ptr<iOS::AIFeatures::AIIntegrationManager> GetAIManager() {
-        return s_aiManager;
-    }
+    // UI options
+    bool enableUI = true;
+    bool showFloatingButton = true;
 
-    // Get script assistant
-    static std::shared_ptr<iOS::AIFeatures::ScriptAssistant> GetScriptAssistant() {
-        return s_scriptAssistant;
-    }
+    // AI options
+    bool enableAI = true;
 
-    // Get signature adaptation
-    static std::shared_ptr<iOS::AIFeatures::SignatureAdaptation> GetSignatureAdaptation() {
-        return s_signatureAdaptation;
-    }
+    // Naming conventions options
+    bool enableNamingConventions = true;
 
-    // Initialize the system with options - implementation in init.cpp
+    // Callback to run after initialization
+    std::function<void()> postInitCallback = nullptr;
+};
+
+/**
+ * @class SystemState
+ * @brief Manages the global state of the RobloxExecutor system
+ * 
+ * This class provides static methods to initialize and shutdown the system,
+ * as well as access to shared components like the execution engine and script manager.
+ */
+class SystemState {
+public:
+    /**
+     * @brief Initialize the RobloxExecutor system
+     * @param options Initialization options
+     * @return True if initialization succeeded, false otherwise
+     */
     static bool Initialize(const InitOptions& options = InitOptions());
 
-    // Clean up and shutdown all systems - implementation in init.cpp
+    /**
+     * @brief Shutdown the RobloxExecutor system
+     */
     static void Shutdown();
+
+    /**
+     * @brief Check if the system is initialized
+     * @return True if initialized, false otherwise
+     */
+    static bool IsInitialized() { return s_initialized; }
+
+    /**
+     * @brief Get the current system status
+     * @return System status
+     */
+    static const SystemStatus& GetStatus() { return s_status; }
+
+    /**
+     * @brief Get the current initialization options
+     * @return Initialization options
+     */
+    static const InitOptions& GetOptions() { return s_options; }
+
+    /**
+     * @brief Get the execution engine
+     * @return Shared pointer to the execution engine
+     */
+    static std::shared_ptr<iOS::ExecutionEngine> GetExecutionEngine() { return s_executionEngine; }
+
+    /**
+     * @brief Get the script manager
+     * @return Shared pointer to the script manager
+     */
+    static std::shared_ptr<iOS::ScriptManager> GetScriptManager() { return s_scriptManager; }
+
+    /**
+     * @brief Get the UI controller
+     * @return Unique pointer to the UI controller
+     */
+    static std::unique_ptr<iOS::UIController>& GetUIController() { return s_uiController; }
+
+    /**
+     * @brief Get the AI integration manager
+     * @return Shared pointer to the AI integration manager
+     */
+    static std::shared_ptr<iOS::AIFeatures::AIIntegrationManager> GetAIManager() { return s_aiManager; }
+
+    /**
+     * @brief Get the script assistant
+     * @return Shared pointer to the script assistant
+     */
+    static std::shared_ptr<iOS::AIFeatures::ScriptAssistant> GetScriptAssistant() { return s_scriptAssistant; }
+
+    /**
+     * @brief Get the signature adaptation
+     * @return Shared pointer to the signature adaptation
+     */
+    static std::shared_ptr<iOS::AIFeatures::SignatureAdaptation> GetSignatureAdaptation() { return s_signatureAdaptation; }
+
+private:
+    // Private static members
+    static std::atomic<bool> s_initialized;
+    static SystemStatus s_status;
+    static InitOptions s_options;
+
+    // Shared components
+    static std::shared_ptr<iOS::ExecutionEngine> s_executionEngine;
+    static std::shared_ptr<iOS::ScriptManager> s_scriptManager;
+    static std::unique_ptr<iOS::UIController> s_uiController;
+
+    // AI components
+    static std::shared_ptr<iOS::AIFeatures::AIIntegrationManager> s_aiManager;
+    static std::shared_ptr<iOS::AIFeatures::ScriptAssistant> s_scriptAssistant;
+    static std::shared_ptr<iOS::AIFeatures::SignatureAdaptation> s_signatureAdaptation;
+    static void* s_aiIntegration; // Placeholder for future AI integration
 };
 
-// Static member variable definitions
-bool SystemState::s_initialized = false;
-InitOptions SystemState::s_options;
-SystemStatus SystemState::s_status;
-std::shared_ptr<iOS::ExecutionEngine> SystemState::s_executionEngine;
-std::shared_ptr<iOS::ScriptManager> SystemState::s_scriptManager;
-std::unique_ptr<iOS::UIController> SystemState::s_uiController;
-
-// AI Components
-void* SystemState::s_aiIntegration = nullptr;
-std::shared_ptr<iOS::AIFeatures::AIIntegrationManager> SystemState::s_aiManager = nullptr;
-std::shared_ptr<iOS::AIFeatures::ScriptAssistant> SystemState::s_scriptAssistant = nullptr;
-std::shared_ptr<iOS::AIFeatures::SignatureAdaptation> SystemState::s_signatureAdaptation = nullptr;
-
-// Convenience function for global initialization
-inline bool Initialize(const InitOptions& options = InitOptions()) {
-    return SystemState::Initialize(options);
-}
-
-// Convenience function for global shutdown
-inline void Shutdown() {
-    SystemState::Shutdown();
-}
+// Initialize static members
+inline std::atomic<bool> SystemState::s_initialized(false);
+inline SystemStatus SystemState::s_status;
+inline InitOptions SystemState::s_options;
+inline std::shared_ptr<iOS::ExecutionEngine> SystemState::s_executionEngine;
+inline std::shared_ptr<iOS::ScriptManager> SystemState::s_scriptManager;
+inline std::unique_ptr<iOS::UIController> SystemState::s_uiController;
+inline std::shared_ptr<iOS::AIFeatures::AIIntegrationManager> SystemState::s_aiManager;
+inline std::shared_ptr<iOS::AIFeatures::ScriptAssistant> SystemState::s_scriptAssistant;
+inline std::shared_ptr<iOS::AIFeatures::SignatureAdaptation> SystemState::s_signatureAdaptation;
+inline void* SystemState::s_aiIntegration = nullptr;
 
 } // namespace RobloxExecutor