vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/agents/config/AgentConfigManager.js

@@ -0,0 +1,393 @@
+/**
+ * Agent Configuration Manager
+ *
+ * Manages agent configurations and settings.
+ * Follows constitutional requirements: <555 lines, test-first approach.
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const Agent = require('../Agent');
+const AgentDefaultsRegistry = require('./AgentDefaultsRegistry');
+
+/**
+ * Agent configuration manager class
+ */
+class AgentConfigManager {
+  /**
+   * Create configuration manager instance
+   * @param {Object} options - Configuration options
+   * @param {string} options.configPath - Path to configuration file
+   * @param {string} options.projectRoot - Project root directory
+   */
+  constructor(options = {}) {
+    this.configPath = options.configPath || path.join(process.cwd(), 'config', 'agents.json');
+    this.projectRoot = options.projectRoot || process.cwd();
+    this.agents = new Map();
+    this.defaultsRegistry = new AgentDefaultsRegistry();
+    this.loaded = false;
+  }
+
+  /**
+   * Load agent configurations from file
+   * @returns {Promise<void>}
+   */
+  async load() {
+    try {
+      const configData = await this.readConfigFile();
+      this.parseConfig(configData);
+      this.loaded = true;
+    } catch (error) {
+      // If config file doesn't exist, create default config
+      if (error.code === 'ENOENT') {
+        await this.createDefaultConfig();
+        this.loaded = true;
+      } else if (error instanceof SyntaxError || error.message.includes('JSON')) {
+        // Handle corrupted configuration files
+        console.warn(`Configuration file is corrupted: ${error.message}. Creating fresh defaults.`);
+        await this.createDefaultConfig();
+        this.loaded = true;
+      } else {
+        throw new Error(`Failed to load agent configuration: ${error.message}`);
+      }
+    }
+  }
+
+  /**
+   * Read configuration file
+   * @returns {Promise<Object>} - Configuration data
+   */
+  async readConfigFile() {
+    const data = await fs.readFile(this.configPath, 'utf8');
+    return JSON.parse(data);
+  }
+
+  /**
+   * Parse configuration data and create agent instances
+   * @param {Object} configData - Configuration data
+   */
+  parseConfig(configData) {
+    this.agents.clear();
+
+    // Handle both object format (agents.agents) and array format (agents)
+    let agentsData = [];
+    if (configData.agents) {
+      if (Array.isArray(configData.agents)) {
+        agentsData = configData.agents;
+      } else if (typeof configData.agents === 'object') {
+        // Convert object format to array
+        agentsData = Object.values(configData.agents);
+      }
+    }
+
+    agentsData.forEach(agentData => {
+      try {
+        const agent = Agent.fromJSON(agentData);
+        this.agents.set(agent.id, agent);
+      } catch (error) {
+        console.warn(`Failed to load agent ${agentData.id || 'unknown'}: ${error.message}`);
+      }
+    });
+
+    // Add default agents if not present
+    this.addDefaultAgents();
+  }
+
+  /**
+   * Add default agents to configuration using AgentDefaultsRegistry
+   */
+  addDefaultAgents() {
+    const existingAgents = Array.from(this.agents.values());
+    const missingDefaults = this.defaultsRegistry.getMissingDefaultAgents(existingAgents);
+
+    // Add missing default agents
+    missingDefaults.forEach(agent => {
+      this.agents.set(agent.id, agent);
+    });
+  }
+
+  /**
+   * Create default configuration file using AgentDefaultsRegistry
+   * @returns {Promise<void>}
+   */
+  async createDefaultConfig() {
+    const defaultConfig = this.defaultsRegistry.getDefaultConfiguration();
+    await this.saveConfig(defaultConfig);
+    this.parseConfig(defaultConfig);
+  }
+
+  /**
+   * Save configuration to file
+   * @param {Object} configData - Configuration data to save
+   * @returns {Promise<void>}
+   */
+  async saveConfig(configData = null) {
+    const dataToSave = configData || this.getCurrentConfig();
+
+    // Ensure directory exists
+    const configDir = path.dirname(this.configPath);
+    await fs.mkdir(configDir, { recursive: true });
+
+    await fs.writeFile(this.configPath, JSON.stringify(dataToSave, null, 2), 'utf8');
+  }
+
+  /**
+   * Get current configuration as object
+   * @returns {Object} - Current configuration
+   */
+  getCurrentConfig() {
+    return {
+      version: '1.0.0',
+      lastUpdated: new Date().toISOString(),
+      global: this.getGlobalSettings(),
+      agents: Array.from(this.agents.values()).map(agent => agent.toJSON())
+    };
+  }
+
+  /**
+   * Get global settings from AgentDefaultsRegistry
+   * @returns {Object} - Global settings
+   */
+  getGlobalSettings() {
+    const globalDefaults = this.defaultsRegistry.getGlobalDefaults();
+    return globalDefaults.global || {
+      parallelInstallation: true,
+      timeoutSeconds: 300,
+      retryAttempts: 3,
+      logLevel: 'info'
+    };
+  }
+
+  /**
+   * Get all agents
+   * @returns {Agent[]} - Array of all agents
+   */
+  getAllAgents() {
+    return Array.from(this.agents.values());
+  }
+
+  /**
+   * Get agent by ID
+   * @param {string} agentId - Agent identifier
+   * @returns {Agent|null} - Agent instance or null
+   */
+  getAgent(agentId) {
+    return this.agents.get(agentId) || null;
+  }
+
+  /**
+   * Get enabled agents
+   * @returns {Agent[]} - Array of enabled agents
+   */
+  getEnabledAgents() {
+    return this.getAllAgents().filter(agent => agent.enabled);
+  }
+
+  /**
+   * Add or update agent
+   * @param {Agent} agent - Agent to add/update
+   * @returns {Promise<void>}
+   */
+  async saveAgent(agent) {
+    if (!(agent instanceof Agent)) {
+      throw new Error('Agent must be an instance of Agent class');
+    }
+
+    this.agents.set(agent.id, agent);
+    await this.saveConfig();
+  }
+
+  /**
+   * Remove agent
+   * @param {string} agentId - Agent identifier to remove
+   * @returns {Promise<boolean>} - True if agent was removed
+   */
+  async removeAgent(agentId) {
+    const removed = this.agents.delete(agentId);
+    if (removed) {
+      await this.saveConfig();
+    }
+    return removed;
+  }
+
+  /**
+   * Enable agent
+   * @param {string} agentId - Agent identifier
+   * @returns {Promise<boolean>} - True if agent was enabled
+   */
+  async enableAgent(agentId) {
+    const agent = this.agents.get(agentId);
+    if (agent) {
+      agent.enabled = true;
+      await this.saveConfig();
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Disable agent
+   * @param {string} agentId - Agent identifier
+   * @returns {Promise<boolean>} - True if agent was disabled
+   */
+  async disableAgent(agentId) {
+    const agent = this.agents.get(agentId);
+    if (agent) {
+      agent.enabled = false;
+      await this.saveConfig();
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Add installation method to agent
+   * @param {string} agentId - Agent identifier
+   * @param {InstallationMethod} method - Installation method to add
+   * @returns {Promise<boolean>} - True if method was added
+   */
+  async addInstallationMethod(agentId, method) {
+    const agent = this.agents.get(agentId);
+    if (agent) {
+      try {
+        agent.addInstallationMethod(method);
+        await this.saveConfig();
+        return true;
+      } catch (error) {
+        throw new Error(`Failed to add installation method: ${error.message}`);
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Remove installation method from agent
+   * @param {string} agentId - Agent identifier
+   * @param {string} methodType - Installation method type to remove
+   * @returns {Promise<boolean>} - True if method was removed
+   */
+  async removeInstallationMethod(agentId, methodType) {
+    const agent = this.agents.get(agentId);
+    if (agent) {
+      const removed = agent.removeInstallationMethod(methodType);
+      if (removed) {
+        await this.saveConfig();
+      }
+      return removed;
+    }
+    return false;
+  }
+
+  /**
+   * Update agent status
+   * @param {string} agentId - Agent identifier
+   * @param {string} newStatus - New status
+   * @param {string} message - Status message
+   * @returns {Promise<boolean>} - True if status was updated
+   */
+  async updateAgentStatus(agentId, newStatus, message = '') {
+    const agent = this.agents.get(agentId);
+    if (agent) {
+      agent.updateStatus(newStatus, message);
+      await this.saveConfig();
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Validate configuration using AgentDefaultsRegistry
+   * @returns {Object} - Validation result
+   */
+  validateConfig() {
+    const result = {
+      valid: true,
+      errors: [],
+      warnings: []
+    };
+
+    try {
+      // Validate using defaults registry
+      const defaultsValidation = this.defaultsRegistry.validateDefaults();
+      if (!defaultsValidation.valid) {
+        result.valid = false;
+        result.errors.push(...defaultsValidation.errors);
+      }
+      result.warnings.push(...defaultsValidation.warnings);
+
+      // Validate each agent
+      for (const [agentId, agent] of this.agents) {
+        try {
+          agent.validate();
+        } catch (error) {
+          result.valid = false;
+          result.errors.push(`Agent ${agentId}: ${error.message}`);
+        }
+      }
+
+      // Check for missing default agents
+      const missingDefaults = this.defaultsRegistry.getMissingDefaultAgents(Array.from(this.agents.values()));
+      missingDefaults.forEach(agent => {
+        result.warnings.push(`Default agent ${agent.id} is missing from configuration`);
+      });
+
+    } catch (error) {
+      result.valid = false;
+      result.errors.push(`Configuration validation failed: ${error.message}`);
+    }
+
+    return result;
+  }
+
+  /**
+   * Reload configuration from file
+   * @returns {Promise<void>}
+   */
+  async reload() {
+    await this.load();
+  }
+
+  /**
+   * Get configuration summary
+   * @returns {Object} - Configuration summary
+   */
+  getSummary() {
+    const agents = this.getAllAgents();
+    const enabled = agents.filter(agent => agent.enabled);
+    const installed = agents.filter(agent => agent.isInstalled());
+    const verified = agents.filter(agent => agent.isVerified());
+
+    return {
+      totalAgents: agents.length,
+      enabledAgents: enabled.length,
+      installedAgents: installed.length,
+      verifiedAgents: verified.length,
+      configPath: this.configPath,
+      lastLoaded: this.loaded ? new Date().toISOString() : null
+    };
+  }
+
+  /**
+   * Export configuration to file
+   * @param {string} exportPath - Path to export file
+   * @returns {Promise<void>}
+   */
+  async exportConfig(exportPath) {
+    const config = this.getCurrentConfig();
+    await fs.writeFile(exportPath, JSON.stringify(config, null, 2), 'utf8');
+  }
+
+  /**
+   * Import configuration from file
+   * @param {string} importPath - Path to import file
+   * @returns {Promise<void>}
+   */
+  async importConfig(importPath) {
+    const data = await fs.readFile(importPath, 'utf8');
+    const config = JSON.parse(data);
+    this.parseConfig(config);
+    await this.saveConfig();
+  }
+}
+
+module.exports = AgentConfigManager;