vibecodingmachine-core 2026.2.26-1739 → 2026.3.9-850

package/src/agents/EnvironmentConfigurationManager.js

@@ -8,6 +8,12 @@
 const fs = require('fs').promises;
 const path = require('path');
 const os = require('os');
+const { getDefaultVariableMappings, getVariableDescriptions } = require('./config-managers/VariableMappings');
+const { getTypeConverters, getVariableType } = require('./config-managers/TypeConverters');
+const { getDefaultConfig } = require('./config-managers/DefaultConfig');
+const { setNestedValue, getNestedValue, deepMerge } = require('./config-managers/ConfigUtils');
+const { loadOverrideFile, loadConfigFile, saveConfigFile } = require('./config-managers/FileConfigLoader');
+const { loadEnvironmentVariables, exportToEnvironmentVariables } = require('./config-managers/EnvVarLoader');
 
 /**
  * Environment Configuration Manager class
@@ -24,122 +30,10 @@ class EnvironmentConfigurationManager {
     this.overrideFile = options.overrideFile || path.join(os.homedir(), '.vibecodingmachine', 'env.json');
     this.caseSensitive = options.caseSensitive !== false; // Default to case sensitive
     
-    // Environment variable mappings
-    this.variableMappings = {
-      // 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'
-    };
-    
-    // Type conversion functions
-    this.typeConverters = {
-      '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 {};
-        }
-      }
-    };
-    
-    // Default configuration schema
-    this.defaultConfig = {
-      installation: {
-        timeout: 300000,
-        maxConcurrent: 2,
-        retryAttempts: 3,
-        retryDelay: 5000,
-        autoElevate: false
-      },
-      logging: {
-        level: 'info',
-        file: null,
-        format: 'json',
-        verbose: false
-      },
-      cache: {
-        directory: './cache',
-        maxSize: 100 * 1024 * 1024, // 100MB
-        ttl: 3600000 // 1 hour
-      },
-      network: {
-        timeout: 30000,
-        proxy: null,
-        userAgent: null,
-        rateLimitDelay: 1000
-      },
-      security: {
-        strictMode: true,
-        maxFileSize: 100 * 1024 * 1024, // 100MB
-        allowedExtensions: ['.exe', '.msi', '.zip', '.tar', '.gz']
-      },
-      performance: {
-        monitoring: true,
-        metricsFile: null,
-        flushInterval: 60000
-      },
-      agents: {
-        defaultFile: './config/agents.json',
-        discoveryEnabled: true,
-        autoUpdate: false
-      }
-    };
+    // Load configuration modules
+    this.variableMappings = getDefaultVariableMappings();
+    this.typeConverters = getTypeConverters();
+    this.defaultConfig = getDefaultConfig();
   }
 
   /**
@@ -151,17 +45,17 @@ class EnvironmentConfigurationManager {
     
     try {
       // Load from override file first
-      const overrideConfig = await this.loadOverrideFile();
-      this.mergeConfig(config, overrideConfig);
+      const overrideConfig = await loadOverrideFile(this.overrideFile, this.logger);
+      deepMerge(config, overrideConfig);
       
       // Load from environment variables
-      const envConfig = this.loadEnvironmentVariables();
-      this.mergeConfig(config, envConfig);
+      const envConfig = loadEnvironmentVariables(this.variableMappings, this.prefix, this.logger);
+      deepMerge(config, envConfig);
       
       // Load from specified config file
       if (this.configFile) {
-        const fileConfig = await this.loadConfigFile(this.configFile);
-        this.mergeConfig(config, fileConfig);
+        const fileConfig = await loadConfigFile(this.configFile, this.logger);
+        deepMerge(config, fileConfig);
       }
       
       if (this.logger) {
@@ -183,135 +77,13 @@ class EnvironmentConfigurationManager {
     return config;
   }
 
-  /**
-   * Load configuration from override file
-   * @returns {Promise<Object>} - Override configuration
-   */
-  async loadOverrideFile() {
-    try {
-      const exists = await fs.access(this.overrideFile).then(() => true).catch(() => false);
-      if (!exists) return {};
-      
-      const content = await fs.readFile(this.overrideFile, 'utf8');
-      const config = JSON.parse(content);
-      
-      if (this.logger) {
-        this.logger.debug('Loaded override file configuration', { 
-          file: this.overrideFile,
-          keys: Object.keys(config)
-        });
-      }
-      
-      return config;
-    } catch (error) {
-      if (this.logger) {
-        this.logger.warn('Failed to load override file', { 
-          file: this.overrideFile,
-          error: error.message 
-        });
-      }
-      return {};
-    }
-  }
-
-  /**
-   * Load configuration from environment variables
-   * @returns {Object} - Environment configuration
-   */
-  loadEnvironmentVariables() {
-    const config = {};
-    
-    for (const [envVar, configPath] of Object.entries(this.variableMappings)) {
-      const fullEnvVar = this.prefix + envVar;
-      const value = process.env[fullEnvVar];
-      
-      if (value !== undefined) {
-        this.setNestedValue(config, configPath, value);
-        
-        if (this.logger) {
-          this.logger.debug('Loaded environment variable', {
-            variable: fullEnvVar,
-            configPath,
-            value
-          });
-        }
-      }
-    }
-    
-    return config;
-  }
-
-  /**
-   * Load configuration from file
-   * @param {string} filePath - Path to config file
-   * @returns {Promise<Object>} - File configuration
-   */
-  async loadConfigFile(filePath) {
-    try {
-      const content = await fs.readFile(filePath, 'utf8');
-      const config = JSON.parse(content);
-      
-      if (this.logger) {
-        this.logger.debug('Loaded config file', { 
-          file: filePath,
-          keys: Object.keys(config)
-        });
-      }
-      
-      return config;
-    } catch (error) {
-      if (this.logger) {
-        this.logger.warn('Failed to load config file', { 
-          file: filePath,
-          error: error.message 
-        });
-      }
-      return {};
-    }
-  }
-
   /**
    * Save configuration to override file
    * @param {Object} config - Configuration to save
    * @returns {Promise<Object>} - Save result
    */
   async saveConfiguration(config) {
-    const result = {
-      success: false,
-      error: null,
-      filePath: this.overrideFile
-    };
-    
-    try {
-      // Ensure directory exists
-      const dir = path.dirname(this.overrideFile);
-      await fs.mkdir(dir, { recursive: true });
-      
-      // Save configuration
-      const content = JSON.stringify(config, null, 2);
-      await fs.writeFile(this.overrideFile, content, 'utf8');
-      
-      result.success = true;
-      
-      if (this.logger) {
-        this.logger.info('Configuration saved successfully', { 
-          file: this.overrideFile,
-          keys: Object.keys(config)
-        });
-      }
-      
-    } catch (error) {
-      result.error = error.message;
-      
-      if (this.logger) {
-        this.logger.error('Failed to save configuration', { 
-          file: this.overrideFile,
-          error: error.message 
-        });
-      }
-    }
-    
-    return result;
+    return await saveConfigFile(this.overrideFile, config, this.logger);
   }
 
   /**
@@ -331,14 +103,14 @@ class EnvironmentConfigurationManager {
     try {
       // Load current configuration
       const config = await this.loadConfiguration();
-      result.previousValue = this.getNestedValue(config, key);
+      result.previousValue = getNestedValue(config, key);
       
       // Convert value type
       const convertedValue = this.typeConverters[type] ? 
         this.typeConverters[type](value) : value;
       
       // Set new value
-      this.setNestedValue(config, key, convertedValue);
+      setNestedValue(config, key, convertedValue);
       
       // Save configuration
       const saveResult = await this.saveConfiguration(config);
@@ -378,7 +150,7 @@ class EnvironmentConfigurationManager {
   async getConfigurationValue(key, defaultValue = null) {
     try {
       const config = await this.loadConfiguration();
-      const value = this.getNestedValue(config, key);
+      const value = getNestedValue(config, key);
       return value !== undefined ? value : defaultValue;
     } catch (error) {
       if (this.logger) {
@@ -391,148 +163,29 @@ class EnvironmentConfigurationManager {
     }
   }
 
-  /**
-   * Set nested configuration value
-   * @param {Object} obj - Target object
-   * @param {string} path - Dot-separated path
-   * @param {*} value - Value to set
-   */
-  setNestedValue(obj, path, value) {
-    const keys = path.split('.');
-    let current = obj;
-    
-    for (let i = 0; i < keys.length - 1; i++) {
-      const key = keys[i];
-      if (!(key in current) || typeof current[key] !== 'object') {
-        current[key] = {};
-      }
-      current = current[key];
-    }
-    
-    current[keys[keys.length - 1]] = value;
-  }
-
-  /**
-   * Get nested configuration value
-   * @param {Object} obj - Source object
-   * @param {string} path - Dot-separated path
-   * @returns {*} - Configuration value
-   */
-  getNestedValue(obj, path) {
-    const keys = path.split('.');
-    let current = obj;
-    
-    for (const key of keys) {
-      if (current && typeof current === 'object' && key in current) {
-        current = current[key];
-      } else {
-        return undefined;
-      }
-    }
-    
-    return current;
-  }
-
-  /**
-   * Merge configuration objects
-   * @param {Object} target - Target object
-   * @param {Object} source - Source object
-   */
-  mergeConfig(target, source) {
-    this.deepMerge(target, source);
-  }
-
-  /**
-   * Deep merge objects
-   * @param {Object} target - Target object
-   * @param {Object} source - Source object
-   */
-  deepMerge(target, source) {
-    for (const key in source) {
-      if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key])) {
-        if (!target[key] || typeof target[key] !== 'object') {
-          target[key] = {};
-        }
-        this.deepMerge(target[key], source[key]);
-      } else {
-        target[key] = source[key];
-      }
-    }
-  }
-
   /**
    * Get environment variable documentation
    * @returns {Object} - Environment variable documentation
    */
   getEnvironmentVariableDocumentation() {
     const docs = {};
+    const descriptions = getVariableDescriptions();
     
     for (const [envVar, configPath] of Object.entries(this.variableMappings)) {
       const fullEnvVar = this.prefix + envVar;
-      const defaultValue = this.getNestedValue(this.defaultConfig, configPath);
+      const defaultValue = getNestedValue(this.defaultConfig, configPath);
       
       docs[fullEnvVar] = {
         configPath,
-        description: this.getVariableDescription(envVar),
+        description: descriptions[envVar] || 'Configuration variable',
         defaultValue,
-        type: this.getVariableType(configPath, defaultValue)
+        type: getVariableType(defaultValue)
       };
     }
     
     return docs;
   }
 
-  /**
-   * Get variable description
-   * @param {string} envVar - Environment variable name
-   * @returns {string} - Description
-   */
-  getVariableDescription(envVar) {
-    const descriptions = {
-      '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'
-    };
-    
-    return descriptions[envVar] || 'Configuration variable';
-  }
-
-  /**
-   * Get variable type
-   * @param {string} configPath - Configuration path
-   * @param {*} defaultValue - Default value
-   * @returns {string} - Variable type
-   */
-  getVariableType(configPath, 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';
-  }
-
   /**
    * Export configuration to environment file
    * @param {string} filePath - Export file path
@@ -547,15 +200,13 @@ class EnvironmentConfigurationManager {
     
     try {
       const config = await this.loadConfiguration();
-      const envVars = [];
-      
-      for (const [envVar, configPath] of Object.entries(this.variableMappings)) {
-        const value = this.getNestedValue(config, configPath);
-        if (value !== undefined && value !== this.getNestedValue(this.defaultConfig, configPath)) {
-          const fullEnvVar = this.prefix + envVar;
-          envVars.push(`${fullEnvVar}=${JSON.stringify(value)}`);
-        }
-      }
+      const envVars = exportToEnvironmentVariables(
+        config,
+        this.defaultConfig,
+        this.variableMappings,
+        this.prefix,
+        getNestedValue
+      );
       
       const content = envVars.join('\n');
       await fs.writeFile(filePath, content, 'utf8');

package/src/agents/InstallationType.js

@@ -32,7 +32,10 @@ const InstallationType = {
   POWERSHELL: 'POWERSHELL',
   
   // Chocolatey Package Manager (community)
-  CHOCOLATEY: 'CHOCOLATEY'
+  CHOCOLATEY: 'CHOCOLATEY',
+  
+  // VS Code Extension
+  VSCODE_EXTENSION: 'VSCODE_EXTENSION'
 };
 
 /**
@@ -50,7 +53,7 @@ function isNativeWindows(type) {
  * @returns {boolean}
  */
 function requiresExternalDependency(type) {
-  return [InstallationType.NPM, InstallationType.YARN, InstallationType.CHOCOLATEY, InstallationType.HOMEBREW, InstallationType.GO].includes(type);
+  return [InstallationType.NPM, InstallationType.YARN, InstallationType.CHOCOLATEY, InstallationType.HOMEBREW, InstallationType.GO, InstallationType.VSCODE_EXTENSION].includes(type);
 }
 
 /**
@@ -59,7 +62,7 @@ function requiresExternalDependency(type) {
  * @returns {boolean}
  */
 function supportsAutoUpdate(type) {
-  return [InstallationType.WINGET, InstallationType.NPM, InstallationType.YARN, InstallationType.CHOCOLATEY, InstallationType.HOMEBREW].includes(type);
+  return [InstallationType.WINGET, InstallationType.NPM, InstallationType.YARN, InstallationType.CHOCOLATEY, InstallationType.HOMEBREW, InstallationType.VSCODE_EXTENSION].includes(type);
 }
 
 /**
@@ -80,6 +83,7 @@ function getTypePriority(type) {
   const priorities = {
     [InstallationType.WINGET]: 1, // Native Windows, official support
     [InstallationType.POWERSHELL]: 2, // Vendor-specific official method
+    [InstallationType.VSCODE_EXTENSION]: 2, // VS Code extension, official method
     [InstallationType.NPM]: 3, // Cross-platform, widely used
     [InstallationType.YARN]: 3, // Cross-platform, widely used
     [InstallationType.HOMEBREW]: 3, // Cross-platform, widely used
@@ -104,7 +108,8 @@ function getTypeDescription(type) {
     [InstallationType.GO]: 'Go installation (cross-platform)',
     [InstallationType.POWERSHELL]: 'PowerShell script (vendor-specific)',
     [InstallationType.CHOCOLATEY]: 'Chocolatey Package Manager (community)',
-    [InstallationType.DIRECT]: 'Direct installation script (curl/wget)'
+    [InstallationType.DIRECT]: 'Direct installation script (curl/wget)',
+    [InstallationType.VSCODE_EXTENSION]: 'VS Code Extension (cross-platform)'
   };
 
   return descriptions[type] || 'Unknown installation type';
@@ -152,7 +157,8 @@ function isAvailableOnPlatform(type) {
     InstallationType.YARN, 
     InstallationType.DIRECT, 
     InstallationType.HOMEBREW, 
-    InstallationType.GO
+    InstallationType.GO,
+    InstallationType.VSCODE_EXTENSION
   ];
   return crossPlatformTypes.includes(type);
 }
@@ -171,7 +177,8 @@ function getSystemRequirements(type) {
     [InstallationType.GO]: ['go'],
     [InstallationType.POWERSHELL]: ['windows', 'powershell'],
     [InstallationType.CHOCOLATEY]: ['windows'],
-    [InstallationType.DIRECT]: ['curl', 'bash']
+    [InstallationType.DIRECT]: ['curl', 'bash'],
+    [InstallationType.VSCODE_EXTENSION]: ['vscode']
   };
 
   return requirements[type] || [];
@@ -231,6 +238,12 @@ function getCommandTemplates(type) {
       uninstall: 'Remove via vendor-specific method',
       upgrade: 'Re-run installation script',
       info: 'Check vendor documentation'
+    },
+    [InstallationType.VSCODE_EXTENSION]: {
+      install: 'code --install-extension {extensionId}',
+      uninstall: 'code --uninstall-extension {extensionId}',
+      upgrade: 'code --install-extension {extensionId}',
+      info: 'code --list-extensions | grep {extensionId}'
     }
   };