vibecodingmachine-core 2026.2.26-1739 → 2026.3.9-850

package/src/agents/config-managers/FileConfigLoader.js

@@ -0,0 +1,124 @@
+/**
+ * File Configuration Loader Module
+ * 
+ * Handles loading and saving configuration files.
+ * Follows constitutional requirements: <555 lines, test-first approach.
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+
+/**
+ * Load configuration from override file
+ * @param {string} overrideFile - Path to override file
+ * @param {Object} logger - Logger instance
+ * @returns {Promise<Object>} - Override configuration
+ */
+async function loadOverrideFile(overrideFile, logger) {
+  try {
+    const exists = await fs.access(overrideFile).then(() => true).catch(() => false);
+    if (!exists) return {};
+    
+    const content = await fs.readFile(overrideFile, 'utf8');
+    const config = JSON.parse(content);
+    
+    if (logger) {
+      logger.debug('Loaded override file configuration', { 
+        file: overrideFile,
+        keys: Object.keys(config)
+      });
+    }
+    
+    return config;
+  } catch (error) {
+    if (logger) {
+      logger.warn('Failed to load override file', { 
+        file: overrideFile,
+        error: error.message 
+      });
+    }
+    return {};
+  }
+}
+
+/**
+ * Load configuration from file
+ * @param {string} filePath - Path to config file
+ * @param {Object} logger - Logger instance
+ * @returns {Promise<Object>} - File configuration
+ */
+async function loadConfigFile(filePath, logger) {
+  try {
+    const content = await fs.readFile(filePath, 'utf8');
+    const config = JSON.parse(content);
+    
+    if (logger) {
+      logger.debug('Loaded config file', { 
+        file: filePath,
+        keys: Object.keys(config)
+      });
+    }
+    
+    return config;
+  } catch (error) {
+    if (logger) {
+      logger.warn('Failed to load config file', { 
+        file: filePath,
+        error: error.message 
+      });
+    }
+    return {};
+  }
+}
+
+/**
+ * Save configuration to file
+ * @param {string} filePath - Path to save file
+ * @param {Object} config - Configuration to save
+ * @param {Object} logger - Logger instance
+ * @returns {Promise<Object>} - Save result
+ */
+async function saveConfigFile(filePath, config, logger) {
+  const result = {
+    success: false,
+    error: null,
+    filePath
+  };
+  
+  try {
+    // Ensure directory exists
+    const dir = path.dirname(filePath);
+    await fs.mkdir(dir, { recursive: true });
+    
+    // Save configuration
+    const content = JSON.stringify(config, null, 2);
+    await fs.writeFile(filePath, content, 'utf8');
+    
+    result.success = true;
+    
+    if (logger) {
+      logger.info('Configuration saved successfully', { 
+        file: filePath,
+        keys: Object.keys(config)
+      });
+    }
+    
+  } catch (error) {
+    result.error = error.message;
+    
+    if (logger) {
+      logger.error('Failed to save configuration', { 
+        file: filePath,
+        error: error.message 
+      });
+    }
+  }
+  
+  return result;
+}
+
+module.exports = {
+  loadOverrideFile,
+  loadConfigFile,
+  saveConfigFile
+};

package/src/agents/config-managers/TypeConverters.js

@@ -0,0 +1,61 @@
+/**
+ * Type Converters Module
+ * 
+ * Provides type conversion functions for configuration values.
+ * Follows constitutional requirements: <555 lines, test-first approach.
+ */
+
+/**
+ * Get type converters
+ * @returns {Object} - Type conversion functions
+ */
+function getTypeConverters() {
+  return {
+    'boolean': (value) => {
+      if (typeof value === 'boolean') return value;
+      const str = String(value).toLowerCase();
+      return str === 'true' || str === '1' || str === 'yes' || str === 'on';
+    },
+    'number': (value) => {
+      const num = Number(value);
+      return isNaN(num) ? 0 : num;
+    },
+    'string': (value) => String(value),
+    'array': (value) => {
+      if (Array.isArray(value)) return value;
+      const str = String(value);
+      try {
+        return JSON.parse(str);
+      } catch {
+        return str.split(',').map(s => s.trim()).filter(s => s);
+      }
+    },
+    'object': (value) => {
+      if (typeof value === 'object' && value !== null) return value;
+      const str = String(value);
+      try {
+        return JSON.parse(str);
+      } catch {
+        return {};
+      }
+    }
+  };
+}
+
+/**
+ * Get variable type from default value
+ * @param {*} defaultValue - Default value
+ * @returns {string} - Variable type
+ */
+function getVariableType(defaultValue) {
+  if (typeof defaultValue === 'boolean') return 'boolean';
+  if (typeof defaultValue === 'number') return 'number';
+  if (Array.isArray(defaultValue)) return 'array';
+  if (typeof defaultValue === 'object' && defaultValue !== null) return 'object';
+  return 'string';
+}
+
+module.exports = {
+  getTypeConverters,
+  getVariableType
+};

package/src/agents/config-managers/VariableMappings.js

@@ -0,0 +1,92 @@
+/**
+ * Variable Mappings Module
+ * 
+ * Defines environment variable to configuration path mappings.
+ * Follows constitutional requirements: <555 lines, test-first approach.
+ */
+
+/**
+ * Get default variable mappings
+ * @returns {Object} - Variable mappings
+ */
+function getDefaultVariableMappings() {
+  return {
+    // Installation settings
+    'INSTALL_TIMEOUT': 'installation.timeout',
+    'MAX_CONCURRENT_INSTALLATIONS': 'installation.maxConcurrent',
+    'RETRY_ATTEMPTS': 'installation.retryAttempts',
+    'RETRY_DELAY': 'installation.retryDelay',
+    'AUTO_ELEVATE': 'installation.autoElevate',
+    
+    // Logging settings
+    'LOG_LEVEL': 'logging.level',
+    'LOG_FILE': 'logging.file',
+    'LOG_FORMAT': 'logging.format',
+    'VERBOSE_LOGGING': 'logging.verbose',
+    
+    // Cache settings
+    'CACHE_DIR': 'cache.directory',
+    'CACHE_SIZE': 'cache.maxSize',
+    'CACHE_TTL': 'cache.ttl',
+    
+    // Network settings
+    'HTTP_TIMEOUT': 'network.timeout',
+    'HTTP_PROXY': 'network.proxy',
+    'HTTP_USER_AGENT': 'network.userAgent',
+    'RATE_LIMIT_DELAY': 'network.rateLimitDelay',
+    
+    // Security settings
+    'SECURITY_STRICT_MODE': 'security.strictMode',
+    'SECURITY_MAX_FILE_SIZE': 'security.maxFileSize',
+    'SECURITY_ALLOWED_EXTENSIONS': 'security.allowedExtensions',
+    
+    // Performance settings
+    'PERFORMANCE_MONITORING': 'performance.monitoring',
+    'PERFORMANCE_METRICS_FILE': 'performance.metricsFile',
+    'PERFORMANCE_FLUSH_INTERVAL': 'performance.flushInterval',
+    
+    // Agent settings
+    'DEFAULT_AGENTS_FILE': 'agents.defaultFile',
+    'AGENT_DISCOVERY_ENABLED': 'agents.discoveryEnabled',
+    'AGENT_AUTO_UPDATE': 'agents.autoUpdate'
+  };
+}
+
+/**
+ * Get variable descriptions
+ * @returns {Object} - Variable descriptions
+ */
+function getVariableDescriptions() {
+  return {
+    'INSTALL_TIMEOUT': 'Installation timeout in milliseconds',
+    'MAX_CONCURRENT_INSTALLATIONS': 'Maximum concurrent installations',
+    'RETRY_ATTEMPTS': 'Number of retry attempts for failed operations',
+    'RETRY_DELAY': 'Delay between retry attempts in milliseconds',
+    'AUTO_ELEVATE': 'Automatically request administrator privileges',
+    'LOG_LEVEL': 'Logging level (error, warn, info, debug)',
+    'LOG_FILE': 'Path to log file',
+    'LOG_FORMAT': 'Log format (json, text)',
+    'VERBOSE_LOGGING': 'Enable verbose logging',
+    'CACHE_DIR': 'Cache directory path',
+    'CACHE_SIZE': 'Maximum cache size in bytes',
+    'CACHE_TTL': 'Cache time-to-live in milliseconds',
+    'HTTP_TIMEOUT': 'HTTP request timeout in milliseconds',
+    'HTTP_PROXY': 'HTTP proxy URL',
+    'HTTP_USER_AGENT': 'HTTP user agent string',
+    'RATE_LIMIT_DELAY': 'Delay for rate limiting in milliseconds',
+    'SECURITY_STRICT_MODE': 'Enable strict security mode',
+    'SECURITY_MAX_FILE_SIZE': 'Maximum allowed file size in bytes',
+    'SECURITY_ALLOWED_EXTENSIONS': 'Comma-separated list of allowed file extensions',
+    'PERFORMANCE_MONITORING': 'Enable performance monitoring',
+    'PERFORMANCE_METRICS_FILE': 'Path to performance metrics file',
+    'PERFORMANCE_FLUSH_INTERVAL': 'Performance metrics flush interval in milliseconds',
+    'DEFAULT_AGENTS_FILE': 'Path to default agents configuration file',
+    'AGENT_DISCOVERY_ENABLED': 'Enable automatic agent discovery',
+    'AGENT_AUTO_UPDATE': 'Enable automatic agent updates'
+  };
+}
+
+module.exports = {
+  getDefaultVariableMappings,
+  getVariableDescriptions
+};

package/src/agents/discovery/AgentDiscoveryService-refactored.js

@@ -0,0 +1,272 @@
+/**
+ * Agent Discovery Service
+ * 
+ * Discovers and manages new agent CLI tools.
+ * Follows constitutional requirements: <555 lines, test-first approach.
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const DiscoveryScanner = require('./discovery-scanner');
+const { DiscoveryResult } = require('./discovery-results');
+
+/**
+ * Agent Discovery Service class
+ */
+class AgentDiscoveryService {
+  /**
+   * Create discovery service instance
+   * @param {Object} options - Service options
+   */
+  constructor(options = {}) {
+    this.configManager = options.configManager || null;
+    this.logger = options.logger || null;
+    this.fileManager = options.fileManager || null;
+    this.discoveryPaths = options.discoveryPaths || ['/usr/local/bin', '/opt/bin', '/usr/bin/local/bin', '/snap/bin'];
+    this.timeout = options.timeout || 30000;
+    this.maxConcurrency = options.maxConcurrency || 3;
+    this.discoveryHistoryFile = options.discoveryHistoryFile || './discovery-history.json';
+    this.discoveryStatusFile = options.discoveryStatusFile || './discovery-status.json';
+    
+    // Create scanner instance
+    this.scanner = new DiscoveryScanner({
+      discoveryPaths: this.discoveryPaths,
+      timeout: this.timeout,
+      maxConcurrency: this.maxConcurrency,
+      logger: this.logger
+    });
+  }
+
+  /**
+   * Discover agents from configured paths
+   * @returns {Promise<Object>} - Discovery result
+   */
+  async discoverAgents() {
+    const startTime = Date.now();
+    
+    try {
+      if (this.logger) {
+        await this.logger.info('Starting agent discovery', {
+          paths: this.discoveryPaths,
+          timeout: this.timeout
+        });
+      }
+
+      // Run discovery scan
+      const result = await this.scanner.scanAllPaths();
+
+      // Save discovery history
+      await this.saveDiscoveryHistory(result);
+
+      // Update discovery status
+      await this.updateDiscoveryStatus(result);
+
+      const duration = Date.now() - startTime;
+
+      if (this.logger) {
+        await this.logger.info('Agent discovery completed', {
+          duration,
+          ...result.getSummary()
+        });
+      }
+
+      return {
+        success: true,
+        result: result.toJSON(),
+        duration,
+        timestamp: new Date().toISOString()
+      };
+
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      
+      if (this.logger) {
+        await this.logger.error('Agent discovery failed', {
+          error: error.message,
+          duration
+        });
+      }
+
+      return {
+        success: false,
+        error: error.message,
+        duration,
+        timestamp: new Date().toISOString()
+      };
+    }
+  }
+
+  /**
+   * Get discovery history
+   * @param {number} limit - Maximum number of entries
+   * @returns {Promise<Array>} - Discovery history
+   */
+  async getDiscoveryHistory(limit = 50) {
+    try {
+      const data = await fs.readFile(this.discoveryHistoryFile, 'utf8');
+      const history = JSON.parse(data);
+      return Array.isArray(history) ? history.slice(-limit) : [];
+    } catch (error) {
+      return [];
+    }
+  }
+
+  /**
+   * Get current discovery status
+   * @returns {Promise<Object>} - Current status
+   */
+  async getDiscoveryStatus() {
+    try {
+      const data = await fs.readFile(this.discoveryStatusFile, 'utf8');
+      return JSON.parse(data);
+    } catch (error) {
+      return {
+        status: 'idle',
+        lastDiscovery: null,
+        totalDiscovered: 0
+      };
+    }
+  }
+
+  /**
+   * Save discovery history
+   * @param {DiscoveryResult} result - Discovery result
+   * @returns {Promise<void>}
+   */
+  async saveDiscoveryHistory(result) {
+    try {
+      const history = await this.getDiscoveryHistory(1000); // Get more for internal use
+      const newEntry = {
+        timestamp: new Date().toISOString(),
+        sessionId: result.sessionId,
+        summary: result.getSummary()
+      };
+      
+      history.push(newEntry);
+      
+      // Keep only last 100 entries
+      const trimmedHistory = history.slice(-100);
+      
+      await fs.writeFile(
+        this.discoveryHistoryFile,
+        JSON.stringify(trimmedHistory, null, 2),
+        'utf8'
+      );
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.warn('Failed to save discovery history', {
+          error: error.message
+        });
+      }
+    }
+  }
+
+  /**
+   * Update discovery status
+   * @param {DiscoveryResult} result - Discovery result
+   * @returns {Promise<void>}
+   */
+  async updateDiscoveryStatus(result) {
+    try {
+      const status = {
+        status: 'completed',
+        lastDiscovery: new Date().toISOString(),
+        sessionId: result.sessionId,
+        totalDiscovered: result.agents.length,
+        summary: result.getSummary()
+      };
+
+      await fs.writeFile(
+        this.discoveryStatusFile,
+        JSON.stringify(status, null, 2),
+        'utf8'
+      );
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.warn('Failed to update discovery status', {
+          error: error.message
+        });
+      }
+    }
+  }
+
+  /**
+   * Clear discovery history
+   * @returns {Promise<void>}
+   */
+  async clearDiscoveryHistory() {
+    try {
+      await fs.writeFile(this.discoveryHistoryFile, '[]', 'utf8');
+      
+      if (this.logger) {
+        await this.logger.info('Discovery history cleared');
+      }
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.error('Failed to clear discovery history', {
+          error: error.message
+        });
+      }
+    }
+  }
+
+  /**
+   * Get service information
+   * @returns {Object} - Service info
+   */
+  getServiceInfo() {
+    return {
+      discoveryPaths: this.discoveryPaths,
+      timeout: this.timeout,
+      maxConcurrency: this.maxConcurrency,
+      historyFile: this.discoveryHistoryFile,
+      statusFile: this.discoveryStatusFile,
+      features: [
+        'filesystem scanning',
+        'agent verification',
+        'confidence scoring',
+        'discovery history',
+        'status tracking'
+      ],
+      limitations: [
+        'limited to configured paths',
+        'depends on file system permissions',
+        'confidence scoring based on heuristics'
+      ]
+    };
+  }
+
+  /**
+   * Create discovery service with default configuration
+   * @param {Object} config - Configuration overrides
+   * @returns {AgentDiscoveryService} - Service instance
+   */
+  static createDefault(config = {}) {
+    return new AgentDiscoveryService({
+      discoveryPaths: ['/usr/local/bin', '/opt/bin', '/usr/bin/local/bin', '/snap/bin'],
+      timeout: 30000,
+      maxConcurrency: 3,
+      discoveryHistoryFile: './discovery-history.json',
+      discoveryStatusFile: './discovery-status.json',
+      ...config
+    });
+  }
+
+  /**
+   * Create discovery service for development
+   * @param {Object} config - Configuration overrides
+   * @returns {AgentDiscoveryService} - Development service instance
+   */
+  static createForDevelopment(config = {}) {
+    return new AgentDiscoveryService({
+      discoveryPaths: ['./test-agents', '/usr/local/bin'],
+      timeout: 10000,
+      maxConcurrency: 2,
+      discoveryHistoryFile: './dev-discovery-history.json',
+      discoveryStatusFile: './dev-discovery-status.json',
+      ...config
+    });
+  }
+}
+
+module.exports = AgentDiscoveryService;