vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1642

package/src/agents/ConfigurationSchemaValidator.js

@@ -0,0 +1,543 @@
+/**
+ * Configuration Schema Validator
+ * 
+ * Provides JSON schema validation for agent configurations.
+ * Follows constitutional requirements: <555 lines, test-first approach.
+ */
+
+/**
+ * Configuration Schema Validator class
+ */
+class ConfigurationSchemaValidator {
+  /**
+   * Create schema validator instance
+   * @param {Object} options - Validator options
+   */
+  constructor(options = {}) {
+    this.logger = options.logger || null;
+    this.strictMode = options.strictMode !== false; // Default to strict
+    
+    // Define JSON schemas
+    this.schemas = {
+      agent: this.getAgentSchema(),
+      agentsConfig: this.getAgentsConfigSchema(),
+      installationMethod: this.getInstallationMethodSchema(),
+      verificationTest: this.getVerificationTestSchema()
+    };
+  }
+
+  /**
+   * Validate agent configuration
+   * @param {Object} agentConfig - Agent configuration to validate
+   * @returns {Object} - Validation result
+   */
+  validateAgent(agentConfig) {
+    return this.validate(agentConfig, this.schemas.agent, 'agent');
+  }
+
+  /**
+   * Validate agents configuration file
+   * @param {Object} agentsConfig - Agents configuration to validate
+   * @returns {Object} - Validation result
+   */
+  validateAgentsConfig(agentsConfig) {
+    return this.validate(agentsConfig, this.schemas.agentsConfig, 'agents config');
+  }
+
+  /**
+   * Validate installation method
+   * @param {Object} installationMethod - Installation method to validate
+   * @returns {Object} - Validation result
+   */
+  validateInstallationMethod(installationMethod) {
+    return this.validate(installationMethod, this.schemas.installationMethod, 'installation method');
+  }
+
+  /**
+   * Validate verification test
+   * @param {Object} verificationTest - Verification test to validate
+   * @returns {Object} - Validation result
+   */
+  validateVerificationTest(verificationTest) {
+    return this.validate(verificationTest, this.schemas.verificationTest, 'verification test');
+  }
+
+  /**
+   * Generic validation method
+   * @param {*} data - Data to validate
+   * @param {Object} schema - JSON schema to validate against
+   * @param {string} dataType - Type of data being validated
+   * @returns {Object} - Validation result
+   */
+  validate(data, schema, dataType) {
+    const result = {
+      valid: true,
+      errors: [],
+      warnings: [],
+      dataType,
+      timestamp: new Date().toISOString()
+    };
+
+    try {
+      // Basic type checking
+      if (data === null || data === undefined) {
+        result.valid = false;
+        result.errors.push(`${dataType} cannot be null or undefined`);
+        return result;
+      }
+
+      // Validate against schema
+      this.validateAgainstSchema(data, schema, '', result);
+      
+      // Additional business logic validation
+      this.validateBusinessRules(data, dataType, result);
+
+    } catch (error) {
+      result.valid = false;
+      result.errors.push(`Validation error: ${error.message}`);
+      
+      if (this.logger) {
+        this.logger.error('Schema validation failed', {
+          dataType,
+          error: error.message,
+          data: this.sanitizeData(data)
+        });
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Validate data against JSON schema
+   * @param {*} data - Data to validate
+   * @param {Object} schema - Schema to validate against
+   * @param {string} path - Current path in data structure
+   * @param {Object} result - Validation result object
+   */
+  validateAgainstSchema(data, schema, path, result) {
+    // Check required properties
+    if (schema.required) {
+      for (const requiredProp of schema.required) {
+        if (!(requiredProp in data)) {
+          result.valid = false;
+          result.errors.push(`Missing required property: ${path}${requiredProp}`);
+        }
+      }
+    }
+
+    // Check each property
+    if (schema.properties) {
+      for (const [propName, propSchema] of Object.entries(schema.properties)) {
+        const propPath = path ? `${path}.${propName}` : propName;
+        const propValue = data[propName];
+
+        if (propValue === undefined || propValue === null) {
+          if (schema.required && schema.required.includes(propName)) {
+            result.valid = false;
+            result.errors.push(`Missing required property: ${propPath}`);
+          }
+          continue;
+        }
+
+        this.validateProperty(propValue, propSchema, propPath, result);
+      }
+    }
+
+    // Check additional properties
+    if (schema.additionalProperties === false && this.strictMode) {
+      for (const propName of Object.keys(data)) {
+        if (!schema.properties || !(propName in schema.properties)) {
+          result.warnings.push(`Additional property not allowed: ${path}${propName}`);
+        }
+      }
+    }
+  }
+
+  /**
+   * Validate individual property
+   * @param {*} value - Property value
+   * @param {Object} schema - Property schema
+   * @param {string} path - Property path
+   * @param {Object} result - Validation result
+   */
+  validateProperty(value, schema, path, result) {
+    // Type validation
+    if (schema.type) {
+      if (!this.validateType(value, schema.type)) {
+        result.valid = false;
+        result.errors.push(`Invalid type for ${path}: expected ${schema.type}, got ${typeof value}`);
+        return;
+      }
+    }
+
+    // String validation
+    if (schema.type === 'string' && value !== null && value !== undefined) {
+      if (schema.minLength !== undefined && value.length < schema.minLength) {
+        result.valid = false;
+        result.errors.push(`${path} is too short: minimum ${schema.minLength} characters`);
+      }
+      
+      if (schema.maxLength !== undefined && value.length > schema.maxLength) {
+        result.valid = false;
+        result.errors.push(`${path} is too long: maximum ${schema.maxLength} characters`);
+      }
+      
+      if (schema.pattern && !new RegExp(schema.pattern).test(value)) {
+        result.valid = false;
+        result.errors.push(`${path} does not match required pattern: ${schema.pattern}`);
+      }
+    }
+
+    // Array validation
+    if (schema.type === 'array' && Array.isArray(value)) {
+      if (schema.minItems !== undefined && value.length < schema.minItems) {
+        result.valid = false;
+        result.errors.push(`${path} has too few items: minimum ${schema.minItems}`);
+      }
+      
+      if (schema.maxItems !== undefined && value.length > schema.maxItems) {
+        result.valid = false;
+        result.errors.push(`${path} has too many items: maximum ${schema.maxItems}`);
+      }
+
+      // Validate array items
+      if (schema.items) {
+        value.forEach((item, index) => {
+          this.validateProperty(item, schema.items, `${path}[${index}]`, result);
+        });
+      }
+    }
+
+    // Enum validation
+    if (schema.enum && !schema.enum.includes(value)) {
+      result.valid = false;
+      result.errors.push(`Invalid value for ${path}: must be one of [${schema.enum.join(', ')}]`);
+    }
+  }
+
+  /**
+   * Validate data type
+   * @param {*} value - Value to check
+   * @param {string|Array} expectedType - Expected type(s)
+   * @returns {boolean} - Whether type matches
+   */
+  validateType(value, expectedType) {
+    if (Array.isArray(expectedType)) {
+      return expectedType.some(type => this.checkType(value, type));
+    }
+    return this.checkType(value, expectedType);
+  }
+
+  /**
+   * Check single type
+   * @param {*} value - Value to check
+   * @param {string} type - Expected type
+   * @returns {boolean} - Whether type matches
+   */
+  checkType(value, type) {
+    switch (type) {
+      case 'string':
+        return typeof value === 'string';
+      case 'number':
+        return typeof value === 'number' && !isNaN(value);
+      case 'boolean':
+        return typeof value === 'boolean';
+      case 'object':
+        return typeof value === 'object' && value !== null && !Array.isArray(value);
+      case 'array':
+        return Array.isArray(value);
+      default:
+        return typeof value === type;
+    }
+  }
+
+  /**
+   * Validate business rules
+   * @param {*} data - Data to validate
+   * @param {string} dataType - Type of data
+   * @param {Object} result - Validation result
+   */
+  validateBusinessRules(data, dataType, result) {
+    switch (dataType) {
+      case 'agent':
+        this.validateAgentBusinessRules(data, result);
+        break;
+      case 'installation method':
+        this.validateInstallationMethodBusinessRules(data, result);
+        break;
+      case 'verification test':
+        this.validateVerificationTestBusinessRules(data, result);
+        break;
+    }
+  }
+
+  /**
+   * Validate agent business rules
+   * @param {Object} agent - Agent data
+   * @param {Object} result - Validation result
+   */
+  validateAgentBusinessRules(agent, result) {
+    // Check agent ID format
+    if (agent.id && !/^[a-z0-9-]+$/.test(agent.id)) {
+      result.warnings.push('Agent ID should contain only lowercase letters, numbers, and hyphens');
+    }
+
+    // Check priority range
+    if (agent.priority !== undefined && (agent.priority < 1 || agent.priority > 100)) {
+      result.valid = false;
+      result.errors.push('Agent priority must be between 1 and 100');
+    }
+
+    // Check installation methods
+    if (agent.installationMethods && Array.isArray(agent.installationMethods)) {
+      if (agent.installationMethods.length === 0) {
+        result.valid = false;
+        result.errors.push('Agent must have at least one installation method');
+      }
+
+      // Check for duplicate priorities
+      const priorities = agent.installationMethods.map(m => m.priority).filter(p => p !== undefined);
+      const duplicatePriorities = priorities.filter((p, i) => priorities.indexOf(p) !== i);
+      if (duplicatePriorities.length > 0) {
+        result.valid = false;
+        result.errors.push(`Duplicate installation method priorities: ${duplicatePriorities.join(', ')}`);
+      }
+    }
+  }
+
+  /**
+   * Validate installation method business rules
+   * @param {Object} method - Installation method data
+   * @param {Object} result - Validation result
+   */
+  validateInstallationMethodBusinessRules(method, result) {
+    // Check priority range
+    if (method.priority !== undefined && (method.priority < 1 || method.priority > 10)) {
+      result.valid = false;
+      result.errors.push('Installation method priority must be between 1 and 10');
+    }
+
+    // Validate command template
+    if (method.command && typeof method.command === 'string') {
+      if (!method.command.includes('{') && !method.command.includes('[')) {
+        result.warnings.push('Installation command should contain placeholders for dynamic values');
+      }
+    }
+  }
+
+  /**
+   * Validate verification test business rules
+   * @param {Object} test - Verification test data
+   * @param {Object} result - Validation result
+   */
+  validateVerificationTestBusinessRules(test, result) {
+    // Check timeout range
+    if (test.timeout !== undefined && (test.timeout < 1 || test.timeout > 600)) {
+      result.valid = false;
+      result.errors.push('Verification test timeout must be between 1 and 600 seconds');
+    }
+
+    // Check test ID format
+    if (test.id && !/^[a-z0-9-_]+$/.test(test.id)) {
+      result.warnings.push('Test ID should contain only lowercase letters, numbers, hyphens, and underscores');
+    }
+  }
+
+  /**
+   * Get agent schema
+   * @returns {Object} - Agent JSON schema
+   */
+  getAgentSchema() {
+    return {
+      type: 'object',
+      required: ['id', 'name', 'description', 'enabled', 'type', 'priority', 'installationMethods'],
+      properties: {
+        id: {
+          type: 'string',
+          minLength: 1,
+          maxLength: 50,
+          pattern: '^[a-z0-9-]+$'
+        },
+        name: {
+          type: 'string',
+          minLength: 1,
+          maxLength: 100
+        },
+        description: {
+          type: 'string',
+          minLength: 10,
+          maxLength: 500
+        },
+        enabled: {
+          type: 'boolean'
+        },
+        type: {
+          type: 'string',
+          enum: ['ai-assistant', 'cli-tool', 'service', 'extension']
+        },
+        priority: {
+          type: 'number',
+          minimum: 1,
+          maximum: 100
+        },
+        installationMethods: {
+          type: 'array',
+          minItems: 1,
+          items: { $ref: '#/definitions/installationMethod' }
+        },
+        verificationCommands: {
+          type: 'array',
+          items: {
+            type: 'string',
+            minLength: 1
+          }
+        },
+        verificationTests: {
+          type: 'array',
+          items: { $ref: '#/definitions/verificationTest' }
+        }
+      },
+      additionalProperties: false
+    };
+  }
+
+  /**
+   * Get agents configuration schema
+   * @returns {Object} - Agents config JSON schema
+   */
+  getAgentsConfigSchema() {
+    return {
+      type: 'object',
+      required: ['agents'],
+      properties: {
+        agents: {
+          type: 'object',
+          patternProperties: {
+            '^[a-z0-9-]+$': { $ref: '#/definitions/agent' }
+          }
+        },
+        settings: {
+          type: 'object',
+          properties: {
+            defaultTimeout: { type: 'number', minimum: 30000 },
+            maxConcurrentInstallations: { type: 'number', minimum: 1, maximum: 10 },
+            retryAttempts: { type: 'number', minimum: 0, maximum: 10 },
+            retryDelay: { type: 'number', minimum: 1000, maximum: 60000 },
+            logLevel: {
+              type: 'string',
+              enum: ['error', 'warn', 'info', 'debug']
+            }
+          }
+        }
+      }
+    };
+  }
+
+  /**
+   * Get installation method schema
+   * @returns {Object} - Installation method JSON schema
+   */
+  getInstallationMethodSchema() {
+    return {
+      type: 'object',
+      required: ['type', 'command', 'priority'],
+      properties: {
+        type: {
+          type: 'string',
+          enum: ['WINGET', 'NPM', 'POWERSHELL', 'CHOCOLATEY', 'DIRECT']
+        },
+        command: {
+          type: 'string',
+          minLength: 1
+        },
+        packageId: {
+          type: ['string', 'null']
+        },
+        priority: {
+          type: 'number',
+          minimum: 1,
+          maximum: 10
+        },
+        requirements: {
+          type: 'array',
+          items: {
+            type: 'string'
+          }
+        },
+        verificationCommand: {
+          type: 'string',
+          minLength: 1
+        }
+      },
+      additionalProperties: false
+    };
+  }
+
+  /**
+   * Get verification test schema
+   * @returns {Object} - Verification test JSON schema
+   */
+  getVerificationTestSchema() {
+    return {
+      type: 'object',
+      required: ['id', 'type', 'description', 'command', 'timeout'],
+      properties: {
+        id: {
+          type: 'string',
+          minLength: 1,
+          maxLength: 50,
+          pattern: '^[a-z0-9-_]+$'
+        },
+        type: {
+          type: 'string',
+          enum: ['FILE_OPERATION', 'API_CALL', 'COMMAND_EXECUTION', 'NETWORK_TEST']
+        },
+        description: {
+          type: 'string',
+          minLength: 5,
+          maxLength: 200
+        },
+        command: {
+          type: 'string',
+          minLength: 1
+        },
+        expectedResult: {
+          type: 'string',
+          minLength: 1
+        },
+        timeout: {
+          type: 'number',
+          minimum: 1,
+          maximum: 600
+        }
+      },
+      additionalProperties: false
+    };
+  }
+
+  /**
+   * Sanitize data for logging
+   * @param {*} data - Data to sanitize
+   * @returns {*} - Sanitized data
+   */
+  sanitizeData(data) {
+    if (typeof data !== 'object' || data === null) {
+      return data;
+    }
+
+    const sanitized = {};
+    for (const [key, value] of Object.entries(data)) {
+      if (key.toLowerCase().includes('password') || 
+          key.toLowerCase().includes('secret') ||
+          key.toLowerCase().includes('token')) {
+        sanitized[key] = '[REDACTED]';
+      } else {
+        sanitized[key] = value;
+      }
+    }
+    return sanitized;
+  }
+}
+
+module.exports = ConfigurationSchemaValidator;