@loxia-labs/loxia-autopilot-one 1.0.1

package/src/index.js

@@ -0,0 +1,631 @@
+/**
+ * Loxia Autopilot One - Main Application Entry Point
+ * 
+ * Purpose:
+ * - Initialize all system components
+ * - Setup dependency injection
+ * - Start interface handlers
+ * - Handle graceful shutdown
+ */
+
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { createLogger } from './utilities/logger.js';
+import { createConfigManager } from './utilities/configManager.js';
+import Orchestrator from './core/orchestrator.js';
+import AgentPool from './core/agentPool.js';
+import MessageProcessor from './core/messageProcessor.js';
+import AgentScheduler from './core/agentScheduler.js';
+import ContextManager from './core/contextManager.js';
+import StateManager from './core/stateManager.js';
+import AIService from './services/aiService.js';
+import BudgetService from './services/budgetService.js';
+import ErrorHandler from './services/errorHandler.js';
+import BenchmarkService from './services/benchmarkService.js';
+import ModelRouterService from './services/modelRouterService.js';
+import ModelsService from './services/modelsService.js';
+import ApiKeyManager from './services/apiKeyManager.js';
+import FileAttachmentService from './services/fileAttachmentService.js';
+import { ToolsRegistry } from './tools/baseTool.js';
+import AgentDelayTool from './tools/agentDelayTool.js';
+import TerminalTool from './tools/terminalTool.js';
+import FileSystemTool from './tools/fileSystemTool.js';
+import BrowserTool from './tools/browserTool.js';
+import JobDoneTool from './tools/jobDoneTool.js';
+import AgentCommunicationTool from './tools/agentCommunicationTool.js';
+import TaskManagerTool from './tools/taskManagerTool.js';
+import ImportAnalyzerTool from './tools/importAnalyzerTool.js';
+import DependencyResolverTool from './tools/dependencyResolverTool.js';
+import ImageTool from './tools/imageTool.js';
+import StaticAnalysisTool from './tools/staticAnalysisTool.js';
+import CloneDetectionTool from './tools/cloneDetectionTool.js';
+import FileTreeTool from './tools/fileTreeTool.js';
+import FileContentReplaceTool from './tools/fileContentReplaceTool.js';
+import SeekTool from './tools/seekTool.js';
+import WebTool from './tools/webTool.js';
+import AsyncToolManager from './tools/asyncToolManager.js';
+import WebServer from './interfaces/webServer.js';
+
+import {
+  SYSTEM_VERSION,
+  INTERFACE_TYPES
+} from './utilities/constants.js';
+
+class LoxiaApplication {
+  constructor() {
+    this.logger = null;
+    this.config = null;
+    this.orchestrator = null;
+    this.interfaces = new Map();
+    this.isShuttingDown = false;
+    
+    // Bind shutdown handler
+    this.shutdown = this.shutdown.bind(this);
+  }
+
+  /**
+   * Initialize the application
+   * @param {Object} options - Initialization options
+   * @returns {Promise<void>}
+   */
+  async initialize(options = {}) {
+    try {
+      console.log(`🚀 Starting Loxia Autopilot One v${SYSTEM_VERSION}`);
+      
+      // Initialize configuration
+      await this.initializeConfig(options);
+      
+      // Initialize logging
+      await this.initializeLogging();
+      
+      this.logger.info('Loxia Autopilot One starting up', {
+        version: SYSTEM_VERSION,
+        nodeVersion: process.version,
+        platform: process.platform,
+        projectDir: options.projectDir || process.cwd()
+      });
+      
+      // Initialize core components
+      await this.initializeCoreComponents();
+      
+      // Initialize tools
+      await this.initializeTools();
+      
+      this.logger.info('Starting interface initialization...');
+      
+      // Initialize interfaces
+      await this.initializeInterfaces(options);
+      
+      this.logger.info('Interface initialization completed');
+      
+      // Setup shutdown handlers
+      this.setupShutdownHandlers();
+      
+      this.logger.info('Loxia Autopilot One startup complete');
+      console.log('✅ Loxia Autopilot One is ready!');
+      
+    } catch (error) {
+      console.error('❌ Failed to initialize Loxia Autopilot One:', error.message);
+      if (this.logger) {
+        this.logger.error('Application initialization failed', {
+          error: error.message,
+          stack: error.stack
+        });
+      }
+      process.exit(1);
+    }
+  }
+
+  /**
+   * Initialize configuration management
+   * @private
+   */
+  async initializeConfig(options) {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+    
+    const configPaths = [
+      path.join(__dirname, '../config/default.json'),
+      ...(options.configPaths || [])
+    ];
+    
+    this.configManager = createConfigManager({
+      configPaths,
+      envPrefix: 'LOXIA'
+    });
+    
+    this.config = await this.configManager.loadConfig();
+    
+    // Enable config watching if requested
+    if (options.watchConfig) {
+      await this.configManager.watchConfig(true);
+    }
+  }
+
+  /**
+   * Initialize logging system
+   * @private
+   */
+  async initializeLogging() {
+    const loggingConfig = this.config.logging || {};
+    
+    this.logger = createLogger({
+      level: loggingConfig.level || 'info',
+      outputs: loggingConfig.outputs || ['console'],
+      colors: loggingConfig.colors !== false,
+      timestamp: loggingConfig.timestamp !== false,
+      logFile: loggingConfig.logFile,
+      maxFileSize: loggingConfig.maxFileSize,
+      maxFiles: loggingConfig.maxFiles
+    });
+    
+    await this.logger.initialize();
+  }
+
+  /**
+   * Initialize core system components
+   * @private
+   */
+  async initializeCoreComponents() {
+    this.logger.info('Initializing core components...');
+    
+    // State Manager
+    this.stateManager = new StateManager(this.config, this.logger);
+
+    // File Attachment Service
+    this.fileAttachmentService = new FileAttachmentService(this.config, this.logger);
+    await this.fileAttachmentService.initialize();
+
+    // Context Manager
+    this.contextManager = new ContextManager(this.config, this.logger);
+    
+    // Tools Registry and Async Tool Manager
+    this.toolsRegistry = new ToolsRegistry(this.logger);
+    this.asyncToolManager = new AsyncToolManager(this.config, this.logger);
+    
+    // Agent Pool (with tools registry for prompt enhancement)
+    this.agentPool = new AgentPool(
+      this.config,
+      this.logger,
+      this.stateManager,
+      this.contextManager,
+      this.toolsRegistry
+    );
+    
+    // Initialize Budget Service and Error Handler
+    this.budgetService = new BudgetService(this.config, this.logger);
+    this.errorHandler = new ErrorHandler(this.config, this.logger);
+    
+    // API Key Manager
+    this.apiKeyManager = new ApiKeyManager(this.logger);
+    
+    // AI Service
+    this.aiService = new AIService(
+      this.config,
+      this.logger,
+      this.budgetService,
+      this.errorHandler
+    );
+    
+    // Set API Key Manager reference in AI Service
+    this.aiService.setApiKeyManager(this.apiKeyManager);
+    
+    // Set Agent Pool reference in AI Service
+    this.aiService.setAgentPool(this.agentPool);
+    
+    // Initialize Model Routing Services
+    this.benchmarkService = new BenchmarkService(this.config, this.logger);
+    this.modelsService = new ModelsService(this.config, this.logger);
+    this.modelRouterService = new ModelRouterService(
+      this.config,
+      this.logger,
+      this.benchmarkService,
+      this.aiService
+    );
+    
+    // Set API Key Manager reference in ModelsService
+    this.modelsService.setApiKeyManager(this.apiKeyManager);
+    
+    // Initialize services
+    await this.benchmarkService.initialize();
+    await this.modelsService.initialize();
+    
+    // Message Processor
+    this.messageProcessor = new MessageProcessor(
+      this.config,
+      this.logger,
+      this.toolsRegistry,
+      this.agentPool,
+      this.contextManager,
+      this.aiService,
+      this.modelRouterService,
+      this.modelsService
+    );
+    
+    // Agent Scheduler - NEW ARCHITECTURE
+    this.agentScheduler = new AgentScheduler(
+      this.agentPool,
+      this.messageProcessor,
+      this.aiService,
+      this.logger,
+      null, // webSocketManager will be set later
+      this.modelRouterService,
+      this.modelsService
+    );
+    
+    // Note: Scheduler will be started after WebSocketManager is initialized
+    
+    // Orchestrator
+    this.orchestrator = new Orchestrator(
+      this.config,
+      this.logger,
+      this.agentPool,
+      this.messageProcessor,
+      this.aiService,
+      this.stateManager
+    );
+
+    // Set cross-references between components
+    this.messageProcessor.orchestrator = this.orchestrator;
+    this.messageProcessor.setScheduler(this.agentScheduler);
+    this.agentPool.setMessageProcessor(this.messageProcessor);
+    this.agentPool.setScheduler(this.agentScheduler);
+    this.agentPool.setFileAttachmentService(this.fileAttachmentService);
+
+    // Attach FileAttachmentService to orchestrator for webServer access
+    this.orchestrator.fileAttachmentService = this.fileAttachmentService;
+
+    this.logger.info('Core components initialized');
+  }
+
+  /**
+   * Initialize tools system
+   * @private
+   */
+  async initializeTools() {
+    this.logger.info('Initializing tools...');
+    
+    // Register Agent Delay Tool
+    await this.toolsRegistry.registerTool(AgentDelayTool);
+    
+    // Register Terminal Tool
+    await this.toolsRegistry.registerTool(TerminalTool);
+    
+    // Register File System Tool
+    await this.toolsRegistry.registerTool(FileSystemTool);
+    
+    // Register Job Done Tool
+    await this.toolsRegistry.registerTool(JobDoneTool);
+    
+    // Register Agent Communication Tool
+    await this.toolsRegistry.registerTool(AgentCommunicationTool);
+    
+    // Register Task Manager Tool
+    await this.toolsRegistry.registerTool(TaskManagerTool);
+
+    // Register Import Analyzer Tool
+    await this.toolsRegistry.registerTool(ImportAnalyzerTool);
+
+    // Register Dependency Resolver Tool
+    await this.toolsRegistry.registerTool(DependencyResolverTool);
+
+    // Register Image Generation Tool
+    await this.toolsRegistry.registerTool(ImageTool);
+
+    // Register Static Analysis Tool
+    await this.toolsRegistry.registerTool(StaticAnalysisTool);
+
+    // Register Clone Detection Tool
+    await this.toolsRegistry.registerTool(CloneDetectionTool);
+
+    // Register File Tree Tool
+    await this.toolsRegistry.registerTool(FileTreeTool);
+
+    // Register File Content Replace Tool
+    await this.toolsRegistry.registerTool(FileContentReplaceTool);
+
+    // Register Seek Tool
+    await this.toolsRegistry.registerTool(SeekTool);
+
+    // Register Web Tool
+    await this.toolsRegistry.registerTool(WebTool);
+
+    // Register Browser Tool (if enabled)
+    if (this.config.tools?.browser?.enabled !== false) {
+      try {
+        await this.toolsRegistry.registerTool(BrowserTool);
+        this.logger.info('Browser tool registered (requires puppeteer)');
+      } catch (error) {
+        this.logger.warn('Browser tool registration skipped', {
+          reason: error.message,
+          suggestion: 'Install puppeteer to enable browser automation'
+        });
+      }
+    }
+    
+    // Set AgentPool dependency for AgentDelayTool
+    const agentDelayTool = this.toolsRegistry.getTool('agentdelay');
+    if (agentDelayTool && typeof agentDelayTool.setAgentPool === 'function') {
+      agentDelayTool.setAgentPool(this.agentPool);
+    }
+    
+    // Set AgentPool dependency for JobDoneTool
+    const jobDoneTool = this.toolsRegistry.getTool('jobdone');
+    if (jobDoneTool && typeof jobDoneTool.setAgentPool === 'function') {
+      jobDoneTool.setAgentPool(this.agentPool);
+    }
+    
+    // Set AgentPool and Scheduler dependencies for TaskManagerTool
+    const taskManagerTool = this.toolsRegistry.getTool('taskmanager');
+    if (taskManagerTool && typeof taskManagerTool.setAgentPool === 'function') {
+      taskManagerTool.setAgentPool(this.agentPool);
+    }
+    if (taskManagerTool && typeof taskManagerTool.setScheduler === 'function') {
+      taskManagerTool.setScheduler(this.scheduler);
+    }
+    
+    // Note: AgentCommunicationTool receives agentPool through execution context
+    // No need to set it directly as it's passed in the context parameter
+    const agentCommTool = this.toolsRegistry.getTool('agentcommunication');
+    if (agentCommTool) {
+      this.logger.info('Agent Communication Tool registered successfully');
+    }
+
+    // Set AIService dependency for ImageTool
+    const imageTool = this.toolsRegistry.getTool('image-gen');
+    if (imageTool && typeof imageTool.setAIService === 'function') {
+      imageTool.setAIService(this.aiService);
+      this.logger.info('AIService set for Image Generation Tool');
+    }
+
+    // Set AgentPool dependency for ImageTool (for conversation history persistence)
+    if (imageTool && typeof imageTool.setAgentPool === 'function') {
+      imageTool.setAgentPool(this.agentPool);
+      this.logger.info('AgentPool set for Image Generation Tool');
+    }
+
+    const toolCapabilities = this.toolsRegistry.getToolCapabilities();
+    this.logger.info('Tools initialized', {
+      toolCount: Object.keys(toolCapabilities).length,
+      enabledTools: Object.keys(toolCapabilities).filter(id => toolCapabilities[id].capabilities.enabled),
+      registeredTools: this.toolsRegistry.listTools()
+    });
+    
+    // Log tool descriptions for debugging
+    if (this.logger.level === 'debug') {
+      for (const [toolId, tool] of toolCapabilities.entries()) {
+        this.logger.debug(`Tool ${toolId} capabilities`, tool.capabilities);
+      }
+    }
+  }
+
+  /**
+   * Initialize interface handlers
+   * @private
+   */
+  async initializeInterfaces(options) {
+    this.logger.info('Initializing interfaces...');
+    
+    const interfaceConfig = this.config.interfaces || {};
+    
+    // CLI Interface (basic implementation)
+    if (interfaceConfig.cli?.enabled !== false) {
+      const { default: CLIInterface } = await import('./interfaces/cli.js');
+      const cliInterface = new CLIInterface(
+        this.orchestrator,
+        this.logger,
+        interfaceConfig.cli || {}
+      );
+      
+      await cliInterface.initialize();
+      this.interfaces.set(INTERFACE_TYPES.CLI, cliInterface);
+      
+      this.logger.info('CLI interface initialized');
+    }
+    
+    // Web Interface - now implemented
+    if (interfaceConfig.web?.enabled !== false) {
+      const webServer = new WebServer(
+        this.orchestrator,
+        this.logger,
+        interfaceConfig.web || { port: 8080, host: 'localhost' }
+      );
+      
+      // Pass toolsRegistry to webServer for the /api/tools endpoint
+      webServer.toolsRegistry = this.toolsRegistry;
+      
+      // Set API Key Manager reference in Web Server
+      webServer.setApiKeyManager(this.apiKeyManager);
+      
+      await webServer.initialize();
+      this.interfaces.set(INTERFACE_TYPES.WEB, webServer);
+      
+      // Attach WebServer to orchestrator for MessageProcessor broadcasting
+      this.orchestrator.webServer = webServer;
+      
+      // Connect MessageProcessor to WebServer for real-time updates
+      this.messageProcessor.setWebSocketManager(webServer);
+      
+      // Connect AgentScheduler to WebServer for real-time updates
+      this.agentScheduler.webSocketManager = webServer;
+      
+      // Start the scheduler now that WebSocketManager is available
+      this.agentScheduler.start();
+      this.logger.info('Agent Scheduler started with WebSocket integration');
+      
+      // Set global reference for tools that need to broadcast
+      global.loxiaWebServer = webServer;
+      
+      const status = webServer.getStatus();
+      this.logger.info('Web interface initialized', { url: status.url });
+      console.log(`🌐 Web Server running at ${status.url}`);
+      console.log(`📱 Web UI available at: http://localhost:3001 (if running)`);
+    }
+    
+    // VSCode Extension Interface (placeholder)
+    if (interfaceConfig.vscode?.enabled === true) {
+      this.logger.info('VSCode interface configured but not implemented yet');
+      // TODO: Initialize VSCode extension interface
+    }
+  }
+
+  /**
+   * Setup graceful shutdown handlers
+   * @private
+   */
+  setupShutdownHandlers() {
+    // Handle SIGINT (Ctrl+C)
+    process.on('SIGINT', async () => {
+      console.log('\n📋 Received SIGINT, shutting down gracefully...');
+      await this.shutdown();
+    });
+    
+    // Handle SIGTERM
+    process.on('SIGTERM', async () => {
+      console.log('\n📋 Received SIGTERM, shutting down gracefully...');
+      await this.shutdown();
+    });
+    
+    // Handle uncaught exceptions
+    process.on('uncaughtException', async (error) => {
+      console.error('❌ Uncaught exception:', error);
+      if (this.logger) {
+        this.logger.error('Uncaught exception', {
+          error: error.message,
+          stack: error.stack
+        });
+      }
+      
+      await this.shutdown();
+      process.exit(1);
+    });
+    
+    // Handle unhandled promise rejections
+    process.on('unhandledRejection', async (reason, promise) => {
+      console.error('❌ Unhandled promise rejection:', reason);
+      if (this.logger) {
+        this.logger.error('Unhandled promise rejection', {
+          reason: reason?.message || reason,
+          promise: promise.toString()
+        });
+      }
+      
+      await this.shutdown();
+      process.exit(1);
+    });
+  }
+
+  /**
+   * Gracefully shutdown the application
+   * @returns {Promise<void>}
+   */
+  async shutdown() {
+    if (this.isShuttingDown) {
+      return;
+    }
+    
+    this.isShuttingDown = true;
+    
+    try {
+      console.log('🛑 Shutting down Loxia Autopilot One...');
+      
+      if (this.logger) {
+        this.logger.info('Application shutdown initiated');
+      }
+      
+      // Shutdown interfaces
+      for (const [type, interface_] of this.interfaces) {
+        try {
+          if (interface_.shutdown) {
+            await interface_.shutdown();
+          }
+          this.logger?.info(`${type} interface shutdown complete`);
+        } catch (error) {
+          console.error(`Failed to shutdown ${type} interface:`, error.message);
+        }
+      }
+      
+      // Shutdown async tool manager
+      if (this.asyncToolManager) {
+        await this.asyncToolManager.shutdown();
+        this.logger?.info('Async tool manager shutdown complete');
+      }
+      
+      // Shutdown orchestrator
+      if (this.orchestrator) {
+        await this.orchestrator.shutdown();
+        this.logger?.info('Orchestrator shutdown complete');
+      }
+      
+      // Cleanup configuration manager
+      if (this.configManager) {
+        this.configManager.cleanup();
+      }
+      
+      // Close logger
+      if (this.logger) {
+        await this.logger.close();
+      }
+      
+      console.log('✅ Loxia Autopilot One shutdown complete');
+      
+    } catch (error) {
+      console.error('❌ Error during shutdown:', error.message);
+    } finally {
+      process.exit(0);
+    }
+  }
+
+  /**
+   * Get application status
+   * @returns {Object} Application status
+   */
+  getStatus() {
+    return {
+      version: SYSTEM_VERSION,
+      uptime: process.uptime(),
+      memoryUsage: process.memoryUsage(),
+      interfaces: Array.from(this.interfaces.keys()),
+      isShuttingDown: this.isShuttingDown
+    };
+  }
+}
+
+/**
+ * Main application entry point
+ */
+async function main() {
+  const app = new LoxiaApplication();
+  
+  // Parse command line arguments
+  const args = process.argv.slice(2);
+  const options = {
+    projectDir: process.cwd(),
+    watchConfig: args.includes('--watch-config'),
+    configPaths: []
+  };
+  
+  // Look for custom config file
+  const configIndex = args.indexOf('--config');
+  if (configIndex !== -1 && args[configIndex + 1]) {
+    options.configPaths.push(args[configIndex + 1]);
+  }
+  
+  await app.initialize(options);
+  
+  // Keep the application running
+  return app;
+}
+
+// Start the application if this file is run directly
+const __filename = fileURLToPath(import.meta.url);
+if (process.argv[1] === __filename) {
+  console.log('🚀 Starting Loxia Autopilot One...');
+  main().catch(error => {
+    console.error('❌ Failed to start Loxia Autopilot One:', error.message);
+    console.error('Stack trace:', error.stack);
+    process.exit(1);
+  });
+}
+
+export { LoxiaApplication, main };