vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/agents/config/AgentDefaultsRegistry.js

@@ -0,0 +1,373 @@
+/**
+ * Agent Defaults Registry
+ *
+ * Manages default agent configurations and global settings.
+ * Follows constitutional requirements: <555 lines, test-first approach.
+ */
+
+const Agent = require('../Agent');
+const InstallationMethod = require('../InstallationMethod');
+const { InstallationType } = require('../InstallationType');
+
+/**
+ * Agent defaults registry class
+ */
+class AgentDefaultsRegistry {
+  /**
+   * Create registry instance
+   */
+  constructor() {
+    this.defaultAgents = new Map();
+    this.globalDefaults = {};
+    this.initializeDefaults();
+  }
+
+  /**
+   * Initialize default agent configurations
+   */
+  initializeDefaults() {
+    this.setupDefaultAgents();
+    this.setupGlobalDefaults();
+  }
+
+  /**
+   * Setup default agent configurations
+   */
+  setupDefaultAgents() {
+    const defaultAgentConfigs = {
+      'claude-code': {
+        id: 'claude-code',
+        name: 'Claude Code',
+        description: 'Anthropic Claude CLI assistant',
+        enabled: true,
+        verificationCommands: ['claude --version'],
+        installationMethods: [
+          new InstallationMethod({
+            type: InstallationType.NPM,
+            packageId: '@anthropic-ai/claude-cli',
+            command: 'npm install -g @anthropic-ai/claude-cli',
+            verificationCommand: 'claude --version',
+            priority: 1
+          })
+        ]
+      },
+      'github-copilot': {
+        id: 'github-copilot',
+        name: 'GitHub Copilot',
+        description: 'GitHub Copilot CLI assistant',
+        enabled: true,
+        verificationCommands: ['gh copilot --version'],
+        installationMethods: [
+          new InstallationMethod({
+            type: InstallationType.NPM,
+            packageId: 'github/gh-copilot',
+            command: 'gh extension install github/gh-copilot',
+            verificationCommand: 'gh copilot --version',
+            priority: 1
+          })
+        ]
+      },
+      'gemini-cli': {
+        id: 'gemini-cli',
+        name: 'Gemini CLI',
+        description: 'Google Gemini CLI assistant',
+        enabled: true,
+        verificationCommands: ['gemini --version'],
+        installationMethods: [
+          new InstallationMethod({
+            type: InstallationType.NPM,
+            packageId: '@google/gemini-cli',
+            command: 'npm install -g @google/gemini-cli',
+            verificationCommand: 'gemini --version',
+            priority: 1
+          })
+        ]
+      },
+      'cursor-cli': {
+        id: 'cursor-cli',
+        name: 'Cursor CLI',
+        description: 'Cursor AI assistant CLI',
+        enabled: false, // Disabled by default due to WSL requirement
+        verificationCommands: ['cursor --version'],
+        installationMethods: [
+          new InstallationMethod({
+            type: InstallationType.WINGET,
+            packageId: 'Cursor.Cursor',
+            command: 'winget install Cursor.Cursor',
+            verificationCommand: 'cursor --version',
+            priority: 1
+          })
+        ]
+      },
+      'opencode-cli': {
+        id: 'opencode-cli',
+        name: 'OpenCode CLI',
+        description: 'OpenCode.ai command-line interface for AI-powered coding',
+        enabled: true,
+        verificationCommands: ['opencode --version'],
+        installationMethods: [
+          new InstallationMethod({
+            type: InstallationType.DIRECT,
+            packageId: 'opencode',
+            command: 'curl -fsSL https://raw.githubusercontent.com/opencode-ai/opencode/refs/heads/main/install | bash',
+            verificationCommand: 'opencode --version',
+            priority: 1
+          }),
+          new InstallationMethod({
+            type: InstallationType.HOMEBREW,
+            packageId: 'opencode-ai/tap/opencode',
+            command: 'brew install opencode-ai/tap/opencode',
+            verificationCommand: 'opencode --version',
+            priority: 2
+          }),
+          new InstallationMethod({
+            type: InstallationType.GO,
+            packageId: 'github.com/opencode-ai/opencode@latest',
+            command: 'go install github.com/opencode-ai/opencode@latest',
+            verificationCommand: 'opencode --version',
+            priority: 3
+          })
+        ]
+      }
+    };
+
+    Object.entries(defaultAgentConfigs).forEach(([id, config]) => {
+      this.defaultAgents.set(id, new Agent(config));
+    });
+  }
+
+  /**
+   * Setup global default settings
+   */
+  setupGlobalDefaults() {
+    this.globalDefaults = {
+      version: '1.0.0',
+      global: {
+        parallelInstallation: true,
+        timeoutSeconds: 300,
+        retryAttempts: 3,
+        logLevel: 'info'
+      }
+    };
+  }
+
+  /**
+   * Get default agent configuration by ID (raw config, not Agent instance)
+   * @param {string} agentId - Agent identifier
+   * @returns {Object|null} - Default agent configuration or null
+   */
+  getDefaultAgentConfig(agentId) {
+    return this.defaultAgents.get(agentId) || null;
+  }
+
+  /**
+   * Get all default agent configurations (raw configs, not Agent instances)
+   * @returns {Object[]} - Array of default agent configurations
+   */
+  getAllDefaultAgentConfigs() {
+    return Array.from(this.defaultAgents.entries()).map(([agentId, config]) => ({
+      id: agentId,
+      ...config
+    }));
+  }
+
+  /**
+   * Get default agent by ID
+   * @param {string} agentId - Agent identifier
+   * @returns {Agent|null} - Default agent or null
+   */
+  getDefaultAgent(agentId) {
+    const config = this.defaultAgents.get(agentId);
+    if (!config) {
+      return null;
+    }
+
+    // Convert installation method configs to InstallationMethod instances
+    const installationMethods = (config.installationMethods || []).map(methodConfig =>
+      new InstallationMethod(methodConfig)
+    );
+
+    return new Agent({
+      id: agentId,
+      ...config,
+      installationMethods
+    });
+  }
+
+  /**
+   * Get all default agents
+   * @returns {Agent[]} - Array of default agents
+   */
+  getAllDefaultAgents() {
+    return Array.from(this.defaultAgents.entries()).map(([agentId, config]) => {
+      // Convert installation method configs to InstallationMethod instances
+      const installationMethods = (config.installationMethods || []).map(methodConfig =>
+        new InstallationMethod(methodConfig)
+      );
+
+      return new Agent({
+        id: agentId,
+        ...config,
+        installationMethods
+      });
+    });
+  }
+
+  /**
+   * Get default agent IDs
+   * @returns {string[]} - Array of default agent IDs
+   */
+  getDefaultAgentIds() {
+    return Array.from(this.defaultAgents.keys());
+  }
+
+  /**
+   * Check if agent ID is a default agent
+   * @param {string} agentId - Agent identifier
+   * @returns {boolean} - True if agent is a default
+   */
+  isDefaultAgent(agentId) {
+    return this.defaultAgents.has(agentId);
+  }
+
+  /**
+   * Get global default settings
+   * @returns {Object} - Global default settings
+   */
+  getGlobalDefaults() {
+    return { ...this.globalDefaults };
+  }
+
+  /**
+   * Get default configuration for new setup
+   * @returns {Object} - Complete default configuration
+   */
+  getDefaultConfiguration() {
+    return {
+      version: this.globalDefaults.version,
+      lastUpdated: new Date().toISOString(),
+      global: { ...this.globalDefaults.global },
+      agents: this.getAllDefaultAgents().map(agent => agent.toJSON())
+    };
+  }
+
+  /**
+   * Validate default configuration
+   * @returns {Object} - Validation result
+   */
+  validateDefaults() {
+    const result = {
+      valid: true,
+      errors: [],
+      warnings: []
+    };
+
+    try {
+      // Validate each default agent configuration
+      for (const [agentId, config] of this.defaultAgents) {
+        try {
+          // Create temporary agent instance for validation
+          const agent = new Agent({
+            id: agentId,
+            ...config
+          });
+          agent.validate();
+        } catch (error) {
+          result.valid = false;
+          result.errors.push(`Default agent ${agentId}: ${error.message}`);
+        }
+      }
+
+      // Validate global defaults
+      if (!this.globalDefaults.version) {
+        result.valid = false;
+        result.errors.push('Global defaults missing version');
+      }
+
+      if (!this.globalDefaults.global) {
+        result.valid = false;
+        result.errors.push('Global defaults missing global settings');
+      }
+
+      // Check for required default agents
+      const requiredAgents = ['claude-code', 'github-copilot'];
+      requiredAgents.forEach(agentId => {
+        if (!this.defaultAgents.has(agentId)) {
+          result.warnings.push(`Required default agent ${agentId} is missing`);
+        }
+      });
+
+    } catch (error) {
+      result.valid = false;
+      result.errors.push(`Default validation failed: ${error.message}`);
+    }
+
+    return result;
+  }
+
+  /**
+   * Get missing default agents compared to current configuration
+   * @param {Object[]} existingAgents - Existing agents or agent configurations
+   * @returns {Object[]} - Missing default agent configurations
+   */
+  getMissingDefaultAgents(existingAgents = []) {
+    const existingIds = new Set(existingAgents.map(agent => agent.id || agent));
+    const missingIds = this.getDefaultAgentIds().filter(id => !existingIds.has(id));
+
+    return missingIds.map(id => this.getDefaultAgentConfig(id)).filter(config => config !== null);
+  }
+
+  /**
+   * Check if default configuration needs update
+   * @param {Object} existingConfig - Existing configuration
+   * @returns {Object} - Update analysis
+   */
+  analyzeConfiguration(existingConfig) {
+    const analysis = {
+      needsUpdate: false,
+      missingAgents: [],
+      outdatedSettings: false,
+      recommendations: []
+    };
+
+    try {
+      // Check for missing default agents
+      const existingAgents = (existingConfig.agents || [])
+        .map(data => Agent.fromJSON(data));
+
+      analysis.missingAgents = this.getMissingDefaultAgents(existingAgents);
+
+      if (analysis.missingAgents.length > 0) {
+        analysis.needsUpdate = true;
+        analysis.recommendations.push(`Add ${analysis.missingAgents.length} missing default agents`);
+      }
+
+      // Check global settings
+      if (!existingConfig.global) {
+        analysis.needsUpdate = true;
+        analysis.outdatedSettings = true;
+        analysis.recommendations.push('Add global default settings');
+      } else {
+        // Compare with current defaults
+        const currentDefaults = this.globalDefaults.global;
+        const existingSettings = existingConfig.global;
+
+        Object.keys(currentDefaults).forEach(key => {
+          if (existingSettings[key] === undefined) {
+            analysis.needsUpdate = true;
+            analysis.outdatedSettings = true;
+            analysis.recommendations.push(`Update global setting: ${key}`);
+          }
+        });
+      }
+
+    } catch (error) {
+      analysis.needsUpdate = true;
+      analysis.recommendations.push('Configuration appears corrupted, recommend full reset');
+    }
+
+    return analysis;
+  }
+}
+
+module.exports = AgentDefaultsRegistry;

package/src/agents/config/ConfigValidator.js

@@ -0,0 +1,281 @@
+/**
+ * Agent Configuration Validator
+ *
+ * Validates agent configurations.
+ * Follows constitutional requirements: <555 lines, test-first approach.
+ */
+
+/**
+ * Agent Configuration Validator class
+ */
+class ConfigValidator {
+  /**
+   * Create configuration validator instance
+   * @param {Object} options - Validator options
+   */
+  constructor(options = {}) {
+    this.requiredFields = options.requiredFields || ['id', 'name', 'path', 'version', 'description', 'type'];
+    this.optionalFields = options.optionalFields || ['capabilities', 'author', 'homepage', 'license', 'tags'];
+    this.agentTypes = options.agentTypes || ['CLI', 'GUI', 'Service'];
+    this.maxNameLength = options.maxNameLength || 50;
+    this.maxDescriptionLength = options.maxDescriptionLength || 200;
+    this.maxPathLength = options.maxPathLength || 255;
+    this.maxVersionLength = options.maxVersionLength || 20;
+    this.maxCapabilitiesCount = options.maxCapabilitiesCount || 10;
+    this.logger = options.logger || null;
+  }
+
+  /**
+   * Validate agent configuration
+   * @param {Object} agent - Agent configuration to validate
+   * @returns {Object} - Validation result
+   */
+  validateAgent(agent) {
+    const errors = [];
+    const warnings = [];
+
+    // Check required fields
+    for (const field of this.requiredFields) {
+      if (!agent[field] || (typeof agent[field] !== 'string' || agent[field].trim() === '')) {
+        errors.push(`${field} is required and cannot be empty`);
+      }
+    }
+
+    // Check field lengths
+    if (agent.name && agent.name.length > this.maxNameLength) {
+      errors.push(`Name cannot exceed ${this.maxNameLength} characters`);
+      warnings.push(`Name truncated to ${this.maxNameLength} characters`);
+    }
+
+    if (agent.description && agent.description.length > this.maxDescriptionLength) {
+      errors.push(`Description cannot exceed ${this.maxDescriptionLength} characters`);
+      warnings.push(`Description truncated to ${this.maxDescriptionLength} characters`);
+    }
+
+    if (agent.version && agent.version.length > this.maxVersionLength) {
+      errors.push(`Version cannot exceed ${this.maxVersionLength} characters`);
+      warnings.push(`Version truncated to ${this.maxVersionLength} characters`);
+    }
+
+    if (agent.path && agent.path.length > this.maxPathLength) {
+      errors.push(`Path cannot exceed ${this.maxPathLength} characters`);
+      warnings.push(`Path truncated to ${this.maxPathLength} characters`);
+    }
+
+    // Validate agent type
+    if (!this.agentTypes.includes(agent.type)) {
+      errors.push(`Type must be one of: ${this.agentTypes.join(', ')}`);
+    }
+
+    // Validate version format
+    if (agent.version && !this.isValidVersion(agent.version)) {
+      errors.push('Version must be in format: major.minor.patch');
+      warnings.push('Version should follow semantic versioning');
+    }
+
+    // Validate path format
+    if (agent.path && !this.isValidPath(agent.path)) {
+      errors.push('Path must be absolute or relative path');
+      warnings.push('Path should be absolute or relative path');
+    }
+
+    // Validate capabilities
+    if (agent.capabilities && !Array.isArray(agent.capabilities)) {
+      errors.push('Capabilities must be an array');
+      warnings.push('Capabilities must be an array');
+    }
+
+    // Validate optional fields
+    for (const field of this.optionalFields) {
+      if (agent[field] && typeof agent[field] !== 'string') {
+        errors.push(`${field} must be a string if provided`);
+      }
+    }
+
+    // Validate homepage URL
+    if (agent.homepage && !this.isValidUrl(agent.homepage)) {
+      errors.push('Homepage must be a valid URL');
+      warnings.push('Homepage must be a valid URL');
+    }
+
+    // Validate license
+    if (agent.license && !this.isValidLicense(agent.license)) {
+      errors.push('License must be a valid license identifier');
+      warnings.push('License must be a valid license identifier');
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings,
+      agent
+    };
+  }
+
+  /**
+   * Check if version string is valid
+   * @param {string} version - Version string
+   * @returns {boolean} - Whether version is valid
+   */
+  isValidVersion(version) {
+    if (!version || typeof version !== 'string') {
+      return false;
+    }
+
+    // Check semantic version format: major.minor.patch
+    const versionPattern = /^(\d+)\.(\d+)(\.\d+)(\d+)([a-zA-Z0-9])/;
+    return versionPattern.test(version);
+  }
+
+  /**
+   * Check if path is valid
+   * @param {string} path - Path to validate
+   * @returns {boolean} - Whether path is valid
+   */
+  isValidPath(path) {
+    if (!path || typeof path !== 'string') {
+      return false;
+    }
+
+    // Check if it's a valid file path (basic validation)
+    return /^[a-zA-Z]:\\|^[./]|^\//.test(path) || /^[^\\/:*?"<>|]+$/.test(path);
+  }
+
+  /**
+   * Check if URL is valid
+   * @param {string} url - URL to validate
+   * @returns {boolean} - Whether URL is valid
+   */
+  isValidUrl(url) {
+    if (!url || typeof url !== 'string') {
+      return false;
+    }
+
+    try {
+      new URL(url);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Check if license is valid
+   * @param {string} license - License string
+   * @returns {boolean} - Whether license is valid
+   */
+  isValidLicense(license) {
+    if (!license || typeof license !== 'string') {
+      return false;
+    }
+
+    // Common license identifiers
+    const validLicenses = [
+      'MIT', 'Apache-2.0', 'GPL-3.0', 'BSD-3-Clause', 'ISC', 'MPL-2.0',
+      'LGPL-2.1', 'LGPL-3.0', 'Apache-2.0',
+      'BSD-2-Clause', 'Boost Software License 1.0'
+    ];
+
+    return validLicenses.includes(license);
+  }
+
+  /**
+   * Get validation rules for a field
+   * @param {string} field - Field name
+   * @returns {Object} - Validation rules
+   */
+  getValidationRules(field) {
+    const rules = {
+      required: this.requiredFields.includes(field),
+      optional: this.optionalFields.includes(field),
+      maxLength: field === 'name' ? this.maxNameLength :
+                 field === 'description' ? this.maxDescriptionLength :
+                 field === 'version' ? this.maxVersionLength :
+                 field === 'path' ? this.maxPathLength : 0,
+      minLength: field === 'id' ? 1 :
+                 field === 'description' ? 10 : 0
+    };
+
+    return rules;
+  }
+
+  /**
+   * Get validation error message
+   * @param {string} field - Field name
+   * @param {string} error - Error type
+   * @returns {string} - Error message
+   */
+  getErrorMessage(field, error) {
+    switch (field) {
+      case 'id':
+        return 'Agent ID is required';
+      case 'name':
+        return 'Agent name is required';
+      case 'path':
+        return 'Agent path is required';
+      case 'version':
+        return 'Agent version is required';
+      case 'description':
+        return 'Agent description is required';
+      default:
+        return `${field} is invalid`;
+    }
+  }
+
+  /**
+   * Get validation warning message
+   * @param {string} field - Field name
+   * @param {string} warning - Warning type
+   * @returns {string} - Warning message
+   */
+  getWarningMessage(field, value) {
+    switch (field) {
+      case 'name':
+        return `Agent name is too long (${value.length} characters, max: ${this.maxNameLength})`;
+      case 'description':
+        return `Agent description is too long (${value.length} characters, max: ${this.maxDescriptionLength})`;
+      case 'version':
+        return `Version format is invalid`;
+      case 'path':
+        return `Agent path is too long (${value.length} characters, max: ${this.maxPathLength})`;
+      case 'capabilities':
+        return `Too many capabilities (max: ${this.maxCapabilitiesCount})`;
+      default:
+        return `${field} is invalid`;
+    }
+  }
+
+  /**
+   * Get validation info for field
+   * @param {string} field - Field name
+   * @returns {Object} - Validation info
+   */
+  getFieldInfo(field) {
+    const rules = this.getValidationRules(field);
+
+    return {
+      field,
+      required: rules.required,
+      optional: rules.optional,
+      maxLength: rules.maxLength,
+      minLength: rules.minLength,
+      description: rules.description
+    };
+  }
+
+  /**
+   * Get all validation rules
+   * @returns {Object} - All validation rules
+   */
+  getAllValidationRules() {
+    const allRules = {};
+
+    for (const field of [...this.requiredFields, ...this.optionalFields]) {
+      allRules[field] = this.getValidationRules(field);
+    }
+
+    return allRules;
+  }
+}
+
+module.exports = ConfigValidator;