aios-core/.aios-core/development/scripts/modification-validator.js

Synkra AIOS: AI-Orchestrated System for Full Stack Development - Core Framework

const fs = require('fs').promises;
const path = require('path');
const yaml = require('js-yaml');
const { validateYAML } = require('./yaml-validator');
const DependencyAnalyzer = require('./dependency-analyzer');
const SecurityChecker = require('./security-checker');

/**
 * Validates component modifications before applying them
 */
class ModificationValidator {
  constructor() {
    this.dependencyAnalyzer = new DependencyAnalyzer();
    this.securityChecker = new SecurityChecker();
    this.validationRules = {
      agent: this.validateAgentModification.bind(this),
      task: this.validateTaskModification.bind(this),
      workflow: this.validateWorkflowModification.bind(this),
      template: this.validateTemplateModification.bind(this)
    };
  }

  /**
   * Validate a component modification
   * @param {string} componentType - Type of component (agent, task, workflow, etc.)
   * @param {string} originalContent - Original component content
   * @param {string} modifiedContent - Modified component content
   * @param {Object} options - Validation options
   * @returns {Object} Validation result with errors and warnings
   */
  async validateModification(_componentType, originalContent, modifiedContent, options = {}) {
    const result = {
      valid: true,
      errors: [],
      warnings: [],
      suggestions: [],
      breakingChanges: []
    };

    // Basic validation
    if (!originalContent || !modifiedContent) {
      result.valid = false;
      result.errors.push('Original or modified content is empty');
      return result;
    }

    // Run type-specific validation
    if (this.validationRules[componentType]) {
      const typeResult = await this.validationRules[componentType](
        originalContent,
        modifiedContent,
        options
      );
      this.mergeResults(result, typeResult);
    } else {
      result.warnings.push(`No specific validation rules for component type: ${componentType}`);
    }

    // Run security validation
    const securityResult = await this.validateSecurity(modifiedContent, componentType);
    this.mergeResults(result, securityResult);

    // Check for breaking changes
    const breakingChanges = await this.detectBreakingChanges(
      _componentType,
      originalContent,
      modifiedContent
    );
    result.breakingChanges = breakingChanges;

    result.valid = result.errors.length === 0;
    return result;
  }

  /**
   * Validate agent modifications
   * @private
   */
  async validateAgentModification(originalContent, modifiedContent, options) {
    const result = {
      valid: true,
      errors: [],
      warnings: [],
      suggestions: []
    };

    try {
      // Parse agent content
      const originalParts = this.parseAgentContent(originalContent);
      const modifiedParts = this.parseAgentContent(modifiedContent);

      // Validate YAML structure
      const yamlValidation = validateYAML(modifiedParts.yaml);
      if (!yamlValidation.valid) {
        result.valid = false;
        result.errors.push(`YAML validation failed: ${yamlValidation.error}`);
        return result;
      }

      const originalMeta = yaml.load(originalParts.yaml);
      const modifiedMeta = yaml.load(modifiedParts.yaml);

      // Check required fields
      const requiredFields = ['name', 'id', 'title', 'icon', 'whenToUse'];
      for (const field of requiredFields) {
        if (!modifiedMeta[field]) {
          result.errors.push(`Required field missing: ${field}`);
        }
      }

      // Validate dependencies
      if (modifiedMeta.dependencies) {
        const depValidation = await this.validateDependencies(modifiedMeta.dependencies);
        this.mergeResults(result, depValidation);
      }

      // Check command structure
      if (modifiedMeta.commands) {
        for (const [cmd, desc] of Object.entries(modifiedMeta.commands)) {
          if (!desc || typeof desc !== 'string') {
            result.errors.push(`Invalid command description for: ${cmd}`);
          }
        }
      }

      // Check for removed commands (breaking change)
      if (originalMeta.commands && modifiedMeta.commands) {
        const removedCommands = Object.keys(originalMeta.commands)
          .filter(cmd => !modifiedMeta.commands[cmd]);
        
        if (removedCommands.length > 0) {
          result.warnings.push(`Commands removed: ${removedCommands.join(', ')}`);
        }
      }

      // Validate markdown content
      const markdownValidation = this.validateMarkdown(modifiedParts.markdown);
      this.mergeResults(result, markdownValidation);

    } catch (_error) {
      result.valid = false;
      result.errors.push(`Failed to parse agent content: ${error.message}`);
    }

    return result;
  }

  /**
   * Validate task modifications
   * @private
   */
  async validateTaskModification(originalContent, modifiedContent, options) {
    const result = {
      valid: true,
      errors: [],
      warnings: [],
      suggestions: []
    };

    // Check for required sections
    const requiredSections = ['## Purpose', '## Task Execution'];
    for (const section of requiredSections) {
      if (!modifiedContent.includes(section)) {
        result.errors.push(`Required section missing: ${section}`);
      }
    }

    // Validate elicitation blocks
    const elicitationBlocks = modifiedContent.match(/\[\[LLM:([\s\S]*?)\]\]/g) || [];
    for (const block of elicitationBlocks) {
      if (!block.includes(']]')) {
        result.errors.push('Unclosed elicitation block found');
      }
    }

    // Check for task flow consistency
    const taskSteps = modifiedContent.match(/###\s+\d+\.\s+/g) || [];
    const expectedSteps = taskSteps.length;
    for (let i = 1; i <= expectedSteps; i++) {
      if (!modifiedContent.includes(`### ${i}.`)) {
        result.warnings.push(`Task step ${i} appears to be missing or misnumbered`);
      }
    }

    // Validate output format if specified
    const outputMatch = modifiedContent.match(/## Output Format[\s\S]*?```([\s\S]*?)```/);
    if (outputMatch) {
      const outputFormat = outputMatch[1].trim();
      if (outputFormat.startsWith('json')) {
        try {
          // Extract JSON and validate
          const jsonContent = outputFormat.replace(/^json\s*/, '');
          JSON.parse(jsonContent);
        } catch (_error) {
          result.warnings.push('Output format contains invalid JSON example');
        }
      }
    }

    return result;
  }

  /**
   * Validate workflow modifications
   * @private
   */
  async validateWorkflowModification(originalContent, modifiedContent, options) {
    const result = {
      valid: true,
      errors: [],
      warnings: [],
      suggestions: []
    };

    try {
      const _originalWorkflow = yaml.load(originalContent);
      const modifiedWorkflow = yaml.load(modifiedContent);

      // Validate YAML structure
      const yamlValidation = validateYAML(modifiedContent);
      if (!yamlValidation.valid) {
        result.valid = false;
        result.errors.push(`YAML validation failed: ${yamlValidation.error}`);
        return result;
      }

      // Check required fields
      if (!modifiedWorkflow.name) {
        result.errors.push('Workflow name is required');
      }

      if (!modifiedWorkflow.phases || Object.keys(modifiedWorkflow.phases).length === 0) {
        result.errors.push('Workflow must have at least one phase');
      }

      // Validate phase structure
      const phaseSequences = [];
      for (const [phaseName, phase] of Object.entries(modifiedWorkflow.phases || {})) {
        if (!phase.sequence) {
          result.errors.push(`Phase '${phaseName}' missing sequence number`);
        } else {
          phaseSequences.push(phase.sequence);
        }

        if (!phase.agents || phase.agents.length === 0) {
          result.errors.push(`Phase '${phaseName}' must have at least one agent`);
        }

        // Validate agent references
        for (const agent of phase.agents || []) {
          const agentExists = await this.checkAgentExists(agent);
          if (!agentExists) {
            result.warnings.push(`Agent '${agent}' referenced in phase '${phaseName}' not found`);
          }
        }
      }

      // Check for sequence gaps
      phaseSequences.sort((a, b) => a - b);
      for (let i = 1; i < phaseSequences.length; i++) {
        if (phaseSequences[i] - phaseSequences[i-1] > 2) {
          result.warnings.push('Large gap in phase sequences detected');
        }
      }

      // Validate entry/exit criteria references
      for (const [phaseName, phase] of Object.entries(modifiedWorkflow.phases || {})) {
        if (phase.entry_criteria) {
          for (const criteria of phase.entry_criteria) {
            // Check if criteria references valid artifacts or phases
            const referencesValid = this.validateCriteriaReferences(
              criteria,
              modifiedWorkflow
            );
            if (!referencesValid) {
              result.warnings.push(
                `Entry criteria '${criteria}' in phase '${phaseName}' may reference non-existent artifact`
              );
            }
          }
        }
      }

    } catch (_error) {
      result.valid = false;
      result.errors.push(`Failed to parse workflow: ${error.message}`);
    }

    return result;
  }

  /**
   * Validate template modifications
   * @private
   */
  async validateTemplateModification(originalContent, modifiedContent, options) {
    const result = {
      valid: true,
      errors: [],
      warnings: [],
      suggestions: []
    };

    // Check for placeholder consistency
    const placeholders = modifiedContent.match(/\{\{[^}]+\}\}/g) || [];
    const uniquePlaceholders = [...new Set(placeholders)];

    // Warn about unreplaced placeholders
    if (uniquePlaceholders.length > 0) {
      result.suggestions.push(
        `Template contains ${uniquePlaceholders.length} placeholders: ${uniquePlaceholders.join(', ')}`
      );
    }

    // Validate LLM instruction blocks
    const llmBlocks = modifiedContent.match(/\[\[LLM:([\s\S]*?)\]\]/g) || [];
    for (const block of llmBlocks) {
      if (block.length > 1000) {
        result.warnings.push('LLM instruction block exceeds recommended length (1000 chars)');
      }
    }

    return result;
  }

  /**
   * Validate dependencies exist
   * @private
   */
  async validateDependencies(dependencies) {
    const result = {
      valid: true,
      errors: [],
      warnings: []
    };

    const baseDir = path.join(process.cwd(), 'aios-core');

    for (const [type, files] of Object.entries(dependencies)) {
      if (!Array.isArray(files)) continue;

      const typeDir = path.join(baseDir, type);
      
      for (const file of files) {
        const filePath = path.join(typeDir, file);
        try {
          await fs.access(filePath);
        } catch (_error) {
          result.warnings.push(`Dependency not found: ${type}/${file}`);
        }
      }
    }

    return result;
  }

  /**
   * Validate markdown content
   * @private
   */
  validateMarkdown(content) {
    const result = {
      valid: true,
      errors: [],
      warnings: []
    };

    // Check for broken internal links
    const internalLinks = content.match(/\[([^\]]+)\]\(#[^)]+\)/g) || [];
    for (const link of internalLinks) {
      const anchor = link.match(/#([^)]+)/)[1];
      const headingRegex = new RegExp(`^#+.*${anchor}`, 'mi');
      if (!headingRegex.test(content)) {
        result.warnings.push(`Broken internal link: ${link}`);
      }
    }

    // Check for code block closure
    const codeBlocks = content.split('```');
    if (codeBlocks.length % 2 === 0) {
      result.errors.push('Unclosed code block detected');
    }

    return result;
  }

  /**
   * Validate security concerns
   * @private
   */
  async validateSecurity(content, componentType) {
    const result = {
      valid: true,
      errors: [],
      warnings: []
    };

    const securityIssues = await this.securityChecker.checkContent(content);
    
    if (securityIssues.length > 0) {
      for (const issue of securityIssues) {
        if (issue.severity === 'high') {
          result.errors.push(`Security issue: ${issue.message}`);
        } else {
          result.warnings.push(`Security concern: ${issue.message}`);
        }
      }
    }

    return result;
  }

  /**
   * Detect breaking changes
   * @private
   */
  async detectBreakingChanges(_componentType, originalContent, modifiedContent) {
    const breakingChanges = [];

    switch (_componentType) {
      case 'agent':
        // Check for removed commands
        try {
          const originalParts = this.parseAgentContent(originalContent);
          const modifiedParts = this.parseAgentContent(modifiedContent);
          const originalMeta = yaml.load(originalParts.yaml);
          const modifiedMeta = yaml.load(modifiedParts.yaml);

          if (originalMeta.commands && modifiedMeta.commands) {
            const removedCommands = Object.keys(originalMeta.commands)
              .filter(cmd => !modifiedMeta.commands[cmd]);
            
            if (removedCommands.length > 0) {
              breakingChanges.push({
                type: 'removed_commands',
                items: removedCommands,
                impact: 'Users relying on these commands will need to update their workflows'
              });
            }
          }
        } catch (_error) {
          // Ignore parsing errors here
        }
        break;

      case 'task':
        // Check for changed output format
        const originalOutput = originalContent.match(/## Output Format[\s\S]*?```[\s\S]*?```/);
        const modifiedOutput = modifiedContent.match(/## Output Format[\s\S]*?```[\s\S]*?```/);
        
        if (originalOutput && modifiedOutput && originalOutput[0] !== modifiedOutput[0]) {
          breakingChanges.push({
            type: 'output_format_changed',
            impact: 'Components consuming this task output may need updates'
          });
        }
        break;

      case 'workflow':
        // Check for removed phases
        try {
          const _originalWorkflow = yaml.load(originalContent);
          const modifiedWorkflow = yaml.load(modifiedContent);

          const originalPhases = Object.keys(originalWorkflow.phases || {});
          const modifiedPhases = Object.keys(modifiedWorkflow.phases || {});

          const removedPhases = originalPhases.filter(p => !modifiedPhases.includes(p));
          
          if (removedPhases.length > 0) {
            breakingChanges.push({
              type: 'removed_phases',
              items: removedPhases,
              impact: 'Projects using this workflow may fail at removed phases'
            });
          }
        } catch (_error) {
          // Ignore parsing errors here
        }
        break;
    }

    return breakingChanges;
  }

  /**
   * Parse agent content into YAML and markdown sections
   * @private
   */
  parseAgentContent(content) {
    const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
    if (!match) {
      throw new Error('Invalid agent content format');
    }

    return {
      yaml: match[1],
      markdown: match[2]
    };
  }

  /**
   * Check if an agent exists
   * @private
   */
  async checkAgentExists(agentName) {
    const agentPath = path.join(process.cwd(), 'aios-core', 'agents', `${agentName}.md`);
    try {
      await fs.access(agentPath);
      return true;
    } catch {
      return false;
    }
  }

  /**
   * Validate criteria references
   * @private
   */
  validateCriteriaReferences(criteria, workflow) {
    // Simple check - could be enhanced
    const artifacts = new Set();
    
    for (const phase of Object.values(workflow.phases || {})) {
      if (phase.artifacts) {
        phase.artifacts.forEach(a => artifacts.add(a));
      }
    }

    // Check if criteria mentions any known artifact
    for (const artifact of artifacts) {
      if (criteria.toLowerCase().includes(artifact.toLowerCase())) {
        return true;
      }
    }

    return false;
  }

  /**
   * Merge validation results
   * @private
   */
  mergeResults(target, source) {
    target.errors.push(...(source.errors || []));
    target.warnings.push(...(source.warnings || []));
    target.suggestions.push(...(source.suggestions || []));
    
    if (source.valid === false) {
      target.valid = false;
    }
  }
}

module.exports = ModificationValidator;