claude-flow-novice 2.0.3 → 2.0.4

package/dist/src/cli/simple-commands/init/validation/index.js

@@ -1,388 +1,332 @@
 // validation/index.js - Comprehensive validation system for SPARC initialization
-
-import { PreInitValidator } from './pre-init-validator.js';
-import { PostInitValidator } from './post-init-validator.js';
-import { ConfigValidator } from './config-validator.js';
-import { ModeValidator } from './mode-validator.js';
-import { HealthChecker } from './health-checker.js';
-
+import { PreInitValidator } from "./pre-init-validator.js";
+import { PostInitValidator } from "./post-init-validator.js";
+import { ConfigValidator } from "./config-validator.js";
+import { ModeValidator } from "./mode-validator.js";
+import { HealthChecker } from "./health-checker.js";
 /**
  * Main validation orchestrator
- */
-export class ValidationSystem {
-  constructor(workingDir) {
-    this.workingDir = workingDir;
-    this.preInitValidator = new PreInitValidator(workingDir);
-    this.postInitValidator = new PostInitValidator(workingDir);
-    this.configValidator = new ConfigValidator(workingDir);
-    this.modeValidator = new ModeValidator(workingDir);
-    this.healthChecker = new HealthChecker(workingDir);
-  }
-
-  /**
+ */ export class ValidationSystem {
+    /**
    * Run all pre-initialization checks
    * @returns {Object} Validation result with status and details
-   */
-  async validatePreInit(options = {}) {
-    const results = {
-      success: true,
-      checks: {},
-      errors: [],
-      warnings: [],
-    };
-
-    try {
-      // Check permissions
-      const permissionCheck = await this.preInitValidator.checkPermissions();
-      results.checks.permissions = permissionCheck;
-      if (!permissionCheck.success) {
-        results.success = false;
-        results.errors.push(...permissionCheck.errors);
-      }
-
-      // Check disk space
-      const spaceCheck = await this.preInitValidator.checkDiskSpace();
-      results.checks.diskSpace = spaceCheck;
-      if (!spaceCheck.success) {
-        results.success = false;
-        results.errors.push(...spaceCheck.errors);
-      }
-
-      // Check for conflicts
-      const conflictCheck = await this.preInitValidator.checkConflicts(options.force);
-      results.checks.conflicts = conflictCheck;
-      if (!conflictCheck.success && !options.force) {
-        results.success = false;
-        results.errors.push(...conflictCheck.errors);
-      } else if (conflictCheck.warnings.length > 0) {
-        results.warnings.push(...conflictCheck.warnings);
-      }
-
-      // Check dependencies
-      const depCheck = await this.preInitValidator.checkDependencies();
-      results.checks.dependencies = depCheck;
-      if (!depCheck.success) {
-        results.warnings.push(...depCheck.errors);
-      }
-
-      // Check environment
-      const envCheck = await this.preInitValidator.checkEnvironment();
-      results.checks.environment = envCheck;
-      if (!envCheck.success) {
-        results.warnings.push(...envCheck.errors);
-      }
-    } catch (error) {
-      results.success = false;
-      results.errors.push(`Pre-initialization validation failed: ${error.message}`);
+   */ async validatePreInit(options = {}) {
+        const results = {
+            success: true,
+            checks: {},
+            errors: [],
+            warnings: []
+        };
+        try {
+            // Check permissions
+            const permissionCheck = await this.preInitValidator.checkPermissions();
+            results.checks.permissions = permissionCheck;
+            if (!permissionCheck.success) {
+                results.success = false;
+                results.errors.push(...permissionCheck.errors);
+            }
+            // Check disk space
+            const spaceCheck = await this.preInitValidator.checkDiskSpace();
+            results.checks.diskSpace = spaceCheck;
+            if (!spaceCheck.success) {
+                results.success = false;
+                results.errors.push(...spaceCheck.errors);
+            }
+            // Check for conflicts
+            const conflictCheck = await this.preInitValidator.checkConflicts(options.force);
+            results.checks.conflicts = conflictCheck;
+            if (!conflictCheck.success && !options.force) {
+                results.success = false;
+                results.errors.push(...conflictCheck.errors);
+            } else if (conflictCheck.warnings.length > 0) {
+                results.warnings.push(...conflictCheck.warnings);
+            }
+            // Check dependencies
+            const depCheck = await this.preInitValidator.checkDependencies();
+            results.checks.dependencies = depCheck;
+            if (!depCheck.success) {
+                results.warnings.push(...depCheck.errors);
+            }
+            // Check environment
+            const envCheck = await this.preInitValidator.checkEnvironment();
+            results.checks.environment = envCheck;
+            if (!envCheck.success) {
+                results.warnings.push(...envCheck.errors);
+            }
+        } catch (error) {
+            results.success = false;
+            results.errors.push(`Pre-initialization validation failed: ${error.message}`);
+        }
+        return results;
     }
-
-    return results;
-  }
-
-  /**
+    /**
    * Run all post-initialization verification checks
    * @returns {Object} Verification result with status and details
-   */
-  async validatePostInit() {
-    const results = {
-      success: true,
-      checks: {},
-      errors: [],
-      warnings: [],
-    };
-
-    try {
-      // Check file integrity
-      const integrityCheck = await this.postInitValidator.checkFileIntegrity();
-      results.checks.fileIntegrity = integrityCheck;
-      if (!integrityCheck.success) {
-        results.success = false;
-        results.errors.push(...integrityCheck.errors);
-      }
-
-      // Check completeness
-      const completenessCheck = await this.postInitValidator.checkCompleteness();
-      results.checks.completeness = completenessCheck;
-      if (!completenessCheck.success) {
-        results.success = false;
-        results.errors.push(...completenessCheck.errors);
-      }
-
-      // Validate structure
-      const structureCheck = await this.postInitValidator.validateStructure();
-      results.checks.structure = structureCheck;
-      if (!structureCheck.success) {
-        results.success = false;
-        results.errors.push(...structureCheck.errors);
-      }
-
-      // Check permissions on created files
-      const permissionCheck = await this.postInitValidator.checkPermissions();
-      results.checks.permissions = permissionCheck;
-      if (!permissionCheck.success) {
-        results.warnings.push(...permissionCheck.errors);
-      }
-    } catch (error) {
-      results.success = false;
-      results.errors.push(`Post-initialization validation failed: ${error.message}`);
+   */ async validatePostInit() {
+        const results = {
+            success: true,
+            checks: {},
+            errors: [],
+            warnings: []
+        };
+        try {
+            // Check file integrity
+            const integrityCheck = await this.postInitValidator.checkFileIntegrity();
+            results.checks.fileIntegrity = integrityCheck;
+            if (!integrityCheck.success) {
+                results.success = false;
+                results.errors.push(...integrityCheck.errors);
+            }
+            // Check completeness
+            const completenessCheck = await this.postInitValidator.checkCompleteness();
+            results.checks.completeness = completenessCheck;
+            if (!completenessCheck.success) {
+                results.success = false;
+                results.errors.push(...completenessCheck.errors);
+            }
+            // Validate structure
+            const structureCheck = await this.postInitValidator.validateStructure();
+            results.checks.structure = structureCheck;
+            if (!structureCheck.success) {
+                results.success = false;
+                results.errors.push(...structureCheck.errors);
+            }
+            // Check permissions on created files
+            const permissionCheck = await this.postInitValidator.checkPermissions();
+            results.checks.permissions = permissionCheck;
+            if (!permissionCheck.success) {
+                results.warnings.push(...permissionCheck.errors);
+            }
+        } catch (error) {
+            results.success = false;
+            results.errors.push(`Post-initialization validation failed: ${error.message}`);
+        }
+        return results;
     }
-
-    return results;
-  }
-
-  /**
+    /**
    * Validate configuration files
    * @returns {Object} Configuration validation result
-   */
-  async validateConfiguration() {
-    const results = {
-      success: true,
-      checks: {},
-      errors: [],
-      warnings: [],
-    };
-
-    try {
-      // Validate roomodes config
-      const roomodesCheck = await this.configValidator.validateRoomodes();
-      results.checks.roomodes = roomodesCheck;
-      if (!roomodesCheck.success) {
-        results.success = false;
-        results.errors.push(...roomodesCheck.errors);
-      }
-
-      // Validate CLAUDE.md
-      const claudeMdCheck = await this.configValidator.validateClaudeMd();
-      results.checks.claudeMd = claudeMdCheck;
-      if (!claudeMdCheck.success) {
-        results.warnings.push(...claudeMdCheck.errors);
-      }
-
-      // Validate memory configuration
-      const memoryCheck = await this.configValidator.validateMemoryConfig();
-      results.checks.memory = memoryCheck;
-      if (!memoryCheck.success) {
-        results.warnings.push(...memoryCheck.errors);
-      }
-
-      // Validate coordination configuration
-      const coordinationCheck = await this.configValidator.validateCoordinationConfig();
-      results.checks.coordination = coordinationCheck;
-      if (!coordinationCheck.success) {
-        results.warnings.push(...coordinationCheck.errors);
-      }
-    } catch (error) {
-      results.success = false;
-      results.errors.push(`Configuration validation failed: ${error.message}`);
+   */ async validateConfiguration() {
+        const results = {
+            success: true,
+            checks: {},
+            errors: [],
+            warnings: []
+        };
+        try {
+            // Validate roomodes config
+            const roomodesCheck = await this.configValidator.validateRoomodes();
+            results.checks.roomodes = roomodesCheck;
+            if (!roomodesCheck.success) {
+                results.success = false;
+                results.errors.push(...roomodesCheck.errors);
+            }
+            // Validate CLAUDE.md
+            const claudeMdCheck = await this.configValidator.validateClaudeMd();
+            results.checks.claudeMd = claudeMdCheck;
+            if (!claudeMdCheck.success) {
+                results.warnings.push(...claudeMdCheck.errors);
+            }
+            // Validate memory configuration
+            const memoryCheck = await this.configValidator.validateMemoryConfig();
+            results.checks.memory = memoryCheck;
+            if (!memoryCheck.success) {
+                results.warnings.push(...memoryCheck.errors);
+            }
+            // Validate coordination configuration
+            const coordinationCheck = await this.configValidator.validateCoordinationConfig();
+            results.checks.coordination = coordinationCheck;
+            if (!coordinationCheck.success) {
+                results.warnings.push(...coordinationCheck.errors);
+            }
+        } catch (error) {
+            results.success = false;
+            results.errors.push(`Configuration validation failed: ${error.message}`);
+        }
+        return results;
     }
-
-    return results;
-  }
-
-  /**
+    /**
    * Test SPARC mode functionality
    * @returns {Object} Mode functionality test results
-   */
-  async testModeFunctionality() {
-    const results = {
-      success: true,
-      modes: {},
-      errors: [],
-      warnings: [],
-    };
-
-    try {
-      // Test each SPARC mode
-      const modeTests = await this.modeValidator.testAllModes();
-      results.modes = modeTests.modes;
-
-      if (!modeTests.success) {
-        results.success = false;
-        results.errors.push(...modeTests.errors);
-      }
-
-      if (modeTests.warnings.length > 0) {
-        results.warnings.push(...modeTests.warnings);
-      }
-    } catch (error) {
-      results.success = false;
-      results.errors.push(`Mode functionality testing failed: ${error.message}`);
+   */ async testModeFunctionality() {
+        const results = {
+            success: true,
+            modes: {},
+            errors: [],
+            warnings: []
+        };
+        try {
+            // Test each SPARC mode
+            const modeTests = await this.modeValidator.testAllModes();
+            results.modes = modeTests.modes;
+            if (!modeTests.success) {
+                results.success = false;
+                results.errors.push(...modeTests.errors);
+            }
+            if (modeTests.warnings.length > 0) {
+                results.warnings.push(...modeTests.warnings);
+            }
+        } catch (error) {
+            results.success = false;
+            results.errors.push(`Mode functionality testing failed: ${error.message}`);
+        }
+        return results;
     }
-
-    return results;
-  }
-
-  /**
+    /**
    * Run comprehensive health checks
    * @returns {Object} Health check results
-   */
-  async runHealthChecks() {
-    const results = {
-      success: true,
-      health: {},
-      errors: [],
-      warnings: [],
-    };
-
-    try {
-      // Check SPARC mode availability
-      const modeHealth = await this.healthChecker.checkModeAvailability();
-      results.health.modes = modeHealth;
-      if (!modeHealth.success) {
-        results.warnings.push(...modeHealth.errors);
-      }
-
-      // Check template integrity
-      const templateHealth = await this.healthChecker.checkTemplateIntegrity();
-      results.health.templates = templateHealth;
-      if (!templateHealth.success) {
-        results.success = false;
-        results.errors.push(...templateHealth.errors);
-      }
-
-      // Check configuration consistency
-      const configHealth = await this.healthChecker.checkConfigConsistency();
-      results.health.configuration = configHealth;
-      if (!configHealth.success) {
-        results.warnings.push(...configHealth.errors);
-      }
-
-      // Check system resources
-      const resourceHealth = await this.healthChecker.checkSystemResources();
-      results.health.resources = resourceHealth;
-      if (!resourceHealth.success) {
-        results.warnings.push(...resourceHealth.errors);
-      }
-    } catch (error) {
-      results.success = false;
-      results.errors.push(`Health check failed: ${error.message}`);
+   */ async runHealthChecks() {
+        const results = {
+            success: true,
+            health: {},
+            errors: [],
+            warnings: []
+        };
+        try {
+            // Check SPARC mode availability
+            const modeHealth = await this.healthChecker.checkModeAvailability();
+            results.health.modes = modeHealth;
+            if (!modeHealth.success) {
+                results.warnings.push(...modeHealth.errors);
+            }
+            // Check template integrity
+            const templateHealth = await this.healthChecker.checkTemplateIntegrity();
+            results.health.templates = templateHealth;
+            if (!templateHealth.success) {
+                results.success = false;
+                results.errors.push(...templateHealth.errors);
+            }
+            // Check configuration consistency
+            const configHealth = await this.healthChecker.checkConfigConsistency();
+            results.health.configuration = configHealth;
+            if (!configHealth.success) {
+                results.warnings.push(...configHealth.errors);
+            }
+            // Check system resources
+            const resourceHealth = await this.healthChecker.checkSystemResources();
+            results.health.resources = resourceHealth;
+            if (!resourceHealth.success) {
+                results.warnings.push(...resourceHealth.errors);
+            }
+        } catch (error) {
+            results.success = false;
+            results.errors.push(`Health check failed: ${error.message}`);
+        }
+        return results;
     }
-
-    return results;
-  }
-
-  /**
+    /**
    * Generate validation report
-   */
-  generateReport(validationResults) {
-    const report = [];
-    report.push('=== SPARC Initialization Validation Report ===\n');
-
-    // Summary
-    const totalChecks = Object.keys(validationResults).reduce((acc, key) => {
-      if (typeof validationResults[key] === 'object' && validationResults[key].checks) {
-        return acc + Object.keys(validationResults[key].checks).length;
-      }
-      return acc;
-    }, 0);
-
-    const failedChecks = validationResults.errors?.length || 0;
-    const warnings = validationResults.warnings?.length || 0;
-
-    report.push(`Summary: ${totalChecks} checks performed`);
-    report.push(`Status: ${validationResults.success ? '✅ PASSED' : '❌ FAILED'}`);
-    report.push(`Errors: ${failedChecks}`);
-    report.push(`Warnings: ${warnings}\n`);
-
-    // Detailed results
-    for (const [phase, results] of Object.entries(validationResults)) {
-      if (typeof results === 'object' && results.checks) {
-        report.push(`\n${phase.toUpperCase()} Phase:`);
-        for (const [check, result] of Object.entries(results.checks)) {
-          const status = result.success ? '✓' : '✗';
-          report.push(`  ${status} ${check}: ${result.message || 'Completed'}`);
+   */ generateReport(validationResults) {
+        const report = [];
+        report.push('=== SPARC Initialization Validation Report ===\n');
+        // Summary
+        const totalChecks = Object.keys(validationResults).reduce((acc, key)=>{
+            if (typeof validationResults[key] === 'object' && validationResults[key].checks) {
+                return acc + Object.keys(validationResults[key].checks).length;
+            }
+            return acc;
+        }, 0);
+        const failedChecks = validationResults.errors?.length || 0;
+        const warnings = validationResults.warnings?.length || 0;
+        report.push(`Summary: ${totalChecks} checks performed`);
+        report.push(`Status: ${validationResults.success ? '✅ PASSED' : '❌ FAILED'}`);
+        report.push(`Errors: ${failedChecks}`);
+        report.push(`Warnings: ${warnings}\n`);
+        // Detailed results
+        for (const [phase, results] of Object.entries(validationResults)){
+            if (typeof results === 'object' && results.checks) {
+                report.push(`\n${phase.toUpperCase()} Phase:`);
+                for (const [check, result] of Object.entries(results.checks)){
+                    const status = result.success ? '✓' : '✗';
+                    report.push(`  ${status} ${check}: ${result.message || 'Completed'}`);
+                }
+            }
         }
-      }
-    }
-
-    // Errors
-    if (validationResults.errors?.length > 0) {
-      report.push('\n❌ ERRORS:');
-      validationResults.errors.forEach((error) => {
-        report.push(`  - ${error}`);
-      });
+        // Errors
+        if (validationResults.errors?.length > 0) {
+            report.push('\n❌ ERRORS:');
+            validationResults.errors.forEach((error)=>{
+                report.push(`  - ${error}`);
+            });
+        }
+        // Warnings
+        if (validationResults.warnings?.length > 0) {
+            report.push('\n⚠️  WARNINGS:');
+            validationResults.warnings.forEach((warning)=>{
+                report.push(`  - ${warning}`);
+            });
+        }
+        report.push('\n=== End of Report ===');
+        return report.join('\n');
     }
-
-    // Warnings
-    if (validationResults.warnings?.length > 0) {
-      report.push('\n⚠️  WARNINGS:');
-      validationResults.warnings.forEach((warning) => {
-        report.push(`  - ${warning}`);
-      });
+    constructor(workingDir){
+        this.workingDir = workingDir;
+        this.preInitValidator = new PreInitValidator(workingDir);
+        this.postInitValidator = new PostInitValidator(workingDir);
+        this.configValidator = new ConfigValidator(workingDir);
+        this.modeValidator = new ModeValidator(workingDir);
+        this.healthChecker = new HealthChecker(workingDir);
     }
-
-    report.push('\n=== End of Report ===');
-    return report.join('\n');
-  }
 }
-
 /**
  * Run full validation suite
- */
-export async function runFullValidation(workingDir, options = {}) {
-  const validator = new ValidationSystem(workingDir);
-  const results = {
-    success: true,
-    errors: [],
-    warnings: [],
-  };
-
-  // Pre-init validation
-  if (!options.skipPreInit) {
-    const preInitResults = await validator.validatePreInit(options);
-    results.preInit = preInitResults;
-    if (!preInitResults.success) {
-      results.success = false;
-      results.errors.push(...preInitResults.errors);
-      results.warnings.push(...preInitResults.warnings);
-      return results; // Stop if pre-init fails
+ */ export async function runFullValidation(workingDir, options = {}) {
+    const validator = new ValidationSystem(workingDir);
+    const results = {
+        success: true,
+        errors: [],
+        warnings: []
+    };
+    // Pre-init validation
+    if (!options.skipPreInit) {
+        const preInitResults = await validator.validatePreInit(options);
+        results.preInit = preInitResults;
+        if (!preInitResults.success) {
+            results.success = false;
+            results.errors.push(...preInitResults.errors);
+            results.warnings.push(...preInitResults.warnings);
+            return results; // Stop if pre-init fails
+        }
+    }
+    // Post-init validation (if applicable)
+    if (options.postInit) {
+        const postInitResults = await validator.validatePostInit();
+        results.postInit = postInitResults;
+        if (!postInitResults.success) {
+            results.success = false;
+            results.errors.push(...postInitResults.errors);
+        }
+        results.warnings.push(...postInitResults.warnings);
     }
-  }
-
-  // Post-init validation (if applicable)
-  if (options.postInit) {
-    const postInitResults = await validator.validatePostInit();
-    results.postInit = postInitResults;
-    if (!postInitResults.success) {
-      results.success = false;
-      results.errors.push(...postInitResults.errors);
+    // Configuration validation
+    if (!options.skipConfig) {
+        const configResults = await validator.validateConfiguration();
+        results.configuration = configResults;
+        if (!configResults.success) {
+            results.success = false;
+            results.errors.push(...configResults.errors);
+        }
+        results.warnings.push(...configResults.warnings);
     }
-    results.warnings.push(...postInitResults.warnings);
-  }
-
-  // Configuration validation
-  if (!options.skipConfig) {
-    const configResults = await validator.validateConfiguration();
-    results.configuration = configResults;
-    if (!configResults.success) {
-      results.success = false;
-      results.errors.push(...configResults.errors);
+    // Mode functionality testing
+    if (!options.skipModeTest) {
+        const modeResults = await validator.testModeFunctionality();
+        results.modeFunctionality = modeResults;
+        if (!modeResults.success) {
+            results.success = false;
+            results.errors.push(...modeResults.errors);
+        }
+        results.warnings.push(...modeResults.warnings);
     }
-    results.warnings.push(...configResults.warnings);
-  }
-
-  // Mode functionality testing
-  if (!options.skipModeTest) {
-    const modeResults = await validator.testModeFunctionality();
-    results.modeFunctionality = modeResults;
-    if (!modeResults.success) {
-      results.success = false;
-      results.errors.push(...modeResults.errors);
+    // Health checks
+    const healthResults = await validator.runHealthChecks();
+    results.health = healthResults;
+    if (!healthResults.success) {
+        results.success = false;
+        results.errors.push(...healthResults.errors);
     }
-    results.warnings.push(...modeResults.warnings);
-  }
-
-  // Health checks
-  const healthResults = await validator.runHealthChecks();
-  results.health = healthResults;
-  if (!healthResults.success) {
-    results.success = false;
-    results.errors.push(...healthResults.errors);
-  }
-  results.warnings.push(...healthResults.warnings);
-
-  // Generate report
-  results.report = validator.generateReport(results);
-
-  return results;
+    results.warnings.push(...healthResults.warnings);
+    // Generate report
+    results.report = validator.generateReport(results);
+    return results;
 }