claude-flow-novice 1.3.0 → 1.3.2

package/src/cli/simple-commands/init/validation/test-runner.js

@@ -0,0 +1,488 @@
+// test-runner.js - Test runner for validation and rollback systems
+
+import { ValidationSystem } from './index.js';
+import { promises as fs } from 'fs';
+import { RollbackSystem } from '../rollback/index.js';
+import { printSuccess, printError, printWarning } from '../../../utils.js';
+
+/**
+ * Test runner for validation and rollback systems
+ */
+export class ValidationTestRunner {
+  constructor(workingDir) {
+    this.workingDir = workingDir;
+    this.validationSystem = new ValidationSystem(workingDir);
+    this.rollbackSystem = new RollbackSystem(workingDir);
+    this.testResults = [];
+  }
+
+  /**
+   * Run all validation and rollback tests
+   */
+  async runAllTests() {
+    console.log('🧪 Running validation and rollback system tests...');
+
+    const tests = [
+      { name: 'Pre-init Validation', test: () => this.testPreInitValidation() },
+      { name: 'Post-init Validation', test: () => this.testPostInitValidation() },
+      { name: 'Configuration Validation', test: () => this.testConfigValidation() },
+      { name: 'Mode Functionality', test: () => this.testModeFunctionality() },
+      { name: 'Health Checks', test: () => this.testHealthChecks() },
+      { name: 'Backup System', test: () => this.testBackupSystem() },
+      { name: 'Rollback System', test: () => this.testRollbackSystem() },
+      { name: 'State Tracking', test: () => this.testStateTracking() },
+      { name: 'Recovery Procedures', test: () => this.testRecoveryProcedures() },
+      { name: 'Atomic Operations', test: () => this.testAtomicOperations() },
+    ];
+
+    for (const testCase of tests) {
+      console.log(`\n🔬 Testing: ${testCase.name}`);
+
+      try {
+        const result = await testCase.test();
+        this.testResults.push({
+          name: testCase.name,
+          success: result.success,
+          details: result,
+        });
+
+        if (result.success) {
+          printSuccess(`✅ ${testCase.name} passed`);
+        } else {
+          printError(`❌ ${testCase.name} failed`);
+          if (result.errors) {
+            result.errors.forEach((error) => console.error(`  - ${error}`));
+          }
+        }
+      } catch (error) {
+        this.testResults.push({
+          name: testCase.name,
+          success: false,
+          error: error.message,
+        });
+        printError(`❌ ${testCase.name} threw exception: ${error.message}`);
+      }
+    }
+
+    this.generateTestReport();
+  }
+
+  /**
+   * Test pre-initialization validation
+   */
+  async testPreInitValidation() {
+    const result = { success: true, errors: [], details: {} };
+
+    try {
+      // Test with normal conditions
+      const normalValidation = await this.validationSystem.validatePreInit();
+      result.details.normal = normalValidation;
+
+      if (!normalValidation.success && normalValidation.errors.length > 0) {
+        // Some failures are expected in test environment
+        result.details.expectedFailures = normalValidation.errors;
+      }
+
+      // Test with force flag
+      const forceValidation = await this.validationSystem.validatePreInit({ force: true });
+      result.details.force = forceValidation;
+
+      result.success = true; // Pre-init validation tested successfully
+    } catch (error) {
+      result.success = false;
+      result.errors.push(`Pre-init validation test failed: ${error.message}`);
+    }
+
+    return result;
+  }
+
+  /**
+   * Test post-initialization validation
+   */
+  async testPostInitValidation() {
+    const result = { success: true, errors: [], details: {} };
+
+    try {
+      // Create minimal test files for validation
+      await this.createTestFiles();
+
+      const postValidation = await this.validationSystem.validatePostInit();
+      result.details.postValidation = postValidation;
+
+      // Clean up test files
+      await this.cleanupTestFiles();
+
+      result.success = true;
+    } catch (error) {
+      result.success = false;
+      result.errors.push(`Post-init validation test failed: ${error.message}`);
+    }
+
+    return result;
+  }
+
+  /**
+   * Test configuration validation
+   */
+  async testConfigValidation() {
+    const result = { success: true, errors: [], details: {} };
+
+    try {
+      // Create test configuration files
+      await this.createTestConfigs();
+
+      const configValidation = await this.validationSystem.validateConfiguration();
+      result.details.configValidation = configValidation;
+
+      // Clean up test configs
+      await this.cleanupTestConfigs();
+
+      result.success = true;
+    } catch (error) {
+      result.success = false;
+      result.errors.push(`Config validation test failed: ${error.message}`);
+    }
+
+    return result;
+  }
+
+  /**
+   * Test mode functionality
+   */
+  async testModeFunctionality() {
+    const result = { success: true, errors: [], details: {} };
+
+    try {
+      // Create test SPARC configuration
+      await this.createTestSparcConfig();
+
+      const modeTests = await this.validationSystem.testModeFunctionality();
+      result.details.modeTests = modeTests;
+
+      // Clean up test SPARC config
+      await this.cleanupTestSparcConfig();
+
+      result.success = true;
+    } catch (error) {
+      result.success = false;
+      result.errors.push(`Mode functionality test failed: ${error.message}`);
+    }
+
+    return result;
+  }
+
+  /**
+   * Test health checks
+   */
+  async testHealthChecks() {
+    const result = { success: true, errors: [], details: {} };
+
+    try {
+      const healthChecks = await this.validationSystem.runHealthChecks();
+      result.details.healthChecks = healthChecks;
+
+      result.success = true;
+    } catch (error) {
+      result.success = false;
+      result.errors.push(`Health checks test failed: ${error.message}`);
+    }
+
+    return result;
+  }
+
+  /**
+   * Test backup system
+   */
+  async testBackupSystem() {
+    const result = { success: true, errors: [], details: {} };
+
+    try {
+      // Test backup creation
+      const backupResult = await this.rollbackSystem.backupManager.createBackup(
+        'test',
+        'Test backup',
+      );
+      result.details.backupCreation = backupResult;
+
+      if (!backupResult.success) {
+        result.success = false;
+        result.errors.push('Backup creation failed');
+        return result;
+      }
+
+      // Test backup listing
+      const backups = await this.rollbackSystem.backupManager.listBackups();
+      result.details.backupListing = { count: backups.length };
+
+      // Test backup deletion
+      if (backupResult.id) {
+        const deleteResult = await this.rollbackSystem.backupManager.deleteBackup(backupResult.id);
+        result.details.backupDeletion = deleteResult;
+
+        if (!deleteResult.success) {
+          result.errors.push('Backup deletion failed');
+        }
+      }
+    } catch (error) {
+      result.success = false;
+      result.errors.push(`Backup system test failed: ${error.message}`);
+    }
+
+    return result;
+  }
+
+  /**
+   * Test rollback system
+   */
+  async testRollbackSystem() {
+    const result = { success: true, errors: [], details: {} };
+
+    try {
+      // Test rollback system validation
+      const rollbackValidation = await this.rollbackSystem.validateRollbackSystem();
+      result.details.rollbackValidation = rollbackValidation;
+
+      if (!rollbackValidation.success) {
+        result.errors.push(...rollbackValidation.errors);
+      }
+
+      // Test rollback point listing
+      const rollbackPoints = await this.rollbackSystem.listRollbackPoints();
+      result.details.rollbackPoints = {
+        count: rollbackPoints.rollbackPoints.length,
+        checkpoints: rollbackPoints.checkpoints.length,
+      };
+    } catch (error) {
+      result.success = false;
+      result.errors.push(`Rollback system test failed: ${error.message}`);
+    }
+
+    return result;
+  }
+
+  /**
+   * Test state tracking
+   */
+  async testStateTracking() {
+    const result = { success: true, errors: [], details: {} };
+
+    try {
+      const stateTracker = this.rollbackSystem.stateTracker;
+
+      // Test checkpoint creation
+      const checkpoint = await stateTracker.createCheckpoint('test-phase', { test: true });
+      result.details.checkpointCreation = checkpoint;
+
+      if (!checkpoint.success) {
+        result.errors.push('Checkpoint creation failed');
+      }
+
+      // Test rollback point recording
+      const rollbackPoint = await stateTracker.recordRollbackPoint('test', { testData: true });
+      result.details.rollbackPointCreation = rollbackPoint;
+
+      if (!rollbackPoint.success) {
+        result.errors.push('Rollback point creation failed');
+      }
+
+      // Test state validation
+      const stateValidation = await stateTracker.validateStateTracking();
+      result.details.stateValidation = stateValidation;
+
+      if (!stateValidation.success) {
+        result.errors.push(...stateValidation.errors);
+      }
+    } catch (error) {
+      result.success = false;
+      result.errors.push(`State tracking test failed: ${error.message}`);
+    }
+
+    return result;
+  }
+
+  /**
+   * Test recovery procedures
+   */
+  async testRecoveryProcedures() {
+    const result = { success: true, errors: [], details: {} };
+
+    try {
+      const recoveryManager = this.rollbackSystem.recoveryManager;
+
+      // Test recovery system validation
+      const recoveryValidation = await recoveryManager.validateRecoverySystem();
+      result.details.recoveryValidation = recoveryValidation;
+
+      if (!recoveryValidation.success) {
+        result.errors.push(...recoveryValidation.errors);
+      }
+
+      // Test generic recovery
+      const genericRecovery = await recoveryManager.performRecovery('test-failure', { test: true });
+      result.details.genericRecovery = genericRecovery;
+    } catch (error) {
+      result.success = false;
+      result.errors.push(`Recovery procedures test failed: ${error.message}`);
+    }
+
+    return result;
+  }
+
+  /**
+   * Test atomic operations
+   */
+  async testAtomicOperations() {
+    const result = { success: true, errors: [], details: {} };
+
+    try {
+      const { createAtomicOperation } = await import('../rollback/index.js');
+
+      // Test atomic operation creation
+      const atomicOp = createAtomicOperation(this.rollbackSystem, 'test-operation');
+
+      // Test begin
+      const beginResult = await atomicOp.begin();
+      result.details.atomicBegin = { success: beginResult };
+
+      if (!beginResult) {
+        result.errors.push('Atomic operation begin failed');
+        return result;
+      }
+
+      // Test commit
+      await atomicOp.commit();
+      result.details.atomicCommit = { success: true };
+    } catch (error) {
+      result.success = false;
+      result.errors.push(`Atomic operations test failed: ${error.message}`);
+    }
+
+    return result;
+  }
+
+  /**
+   * Generate test report
+   */
+  generateTestReport() {
+    console.log('\n' + '='.repeat(60));
+    console.log('🧪 VALIDATION & ROLLBACK SYSTEM TEST REPORT');
+    console.log('='.repeat(60));
+
+    const passed = this.testResults.filter((test) => test.success).length;
+    const failed = this.testResults.filter((test) => !test.success).length;
+    const total = this.testResults.length;
+
+    console.log(`\n📊 Summary: ${passed}/${total} tests passed`);
+
+    if (failed === 0) {
+      printSuccess('🎉 All tests passed!');
+    } else {
+      printError(`❌ ${failed} tests failed`);
+    }
+
+    console.log('\n📋 Test Results:');
+    this.testResults.forEach((test) => {
+      const status = test.success ? '✅' : '❌';
+      console.log(`  ${status} ${test.name}`);
+
+      if (!test.success && test.error) {
+        console.log(`    Error: ${test.error}`);
+      }
+    });
+
+    console.log('\n' + '='.repeat(60));
+
+    // Overall system health assessment
+    const healthScore = (passed / total) * 100;
+    console.log(`\n🏥 System Health Score: ${healthScore.toFixed(1)}%`);
+
+    if (healthScore >= 90) {
+      printSuccess('🟢 Excellent - System is fully operational');
+    } else if (healthScore >= 70) {
+      printWarning('🟡 Good - System is mostly operational with minor issues');
+    } else if (healthScore >= 50) {
+      printWarning('🟠 Fair - System has some significant issues');
+    } else {
+      printError('🔴 Poor - System has major issues requiring attention');
+    }
+  }
+
+  // Helper methods for creating test files
+
+  async createTestFiles() {
+    try {
+      await fs.mkdir(`${this.workingDir}/test-temp`, { recursive: true });
+      await fs.writeFile(`${this.workingDir}/test-temp/CLAUDE.md`, '# Test CLAUDE.md', 'utf8');
+      await fs.writeFile(
+        `${this.workingDir}/test-temp/memory-bank.md`,
+        '# Test Memory Bank',
+        'utf8',
+      );
+    } catch {
+      // Test files creation failed - not critical for testing
+    }
+  }
+
+  async cleanupTestFiles() {
+    try {
+      await fs.unlink(`${this.workingDir}/test-temp`, { recursive: true });
+    } catch {
+      // Cleanup failed - not critical
+    }
+  }
+
+  async createTestConfigs() {
+    try {
+      const testConfig = {
+        version: '1.0',
+        modes: {
+          'test-mode': {
+            description: 'Test mode for validation',
+          },
+        },
+      };
+
+      await fs.writeFile(
+        `${this.workingDir}/test-roomodes`,
+        JSON.stringify(testConfig, null, 2, 'utf8'),
+      );
+    } catch {
+      // Test config creation failed - not critical
+    }
+  }
+
+  async cleanupTestConfigs() {
+    try {
+      await fs.unlink(`${this.workingDir}/test-roomodes`);
+    } catch {
+      // Cleanup failed - not critical
+    }
+  }
+
+  async createTestSparcConfig() {
+    try {
+      await this.createTestConfigs();
+      await fs.mkdir(`${this.workingDir}/test-roo`, { recursive: true });
+    } catch {
+      // Test SPARC config creation failed - not critical
+    }
+  }
+
+  async cleanupTestSparcConfig() {
+    try {
+      await this.cleanupTestConfigs();
+      await fs.unlink(`${this.workingDir}/test-roo`, { recursive: true });
+    } catch {
+      // Cleanup failed - not critical
+    }
+  }
+}
+
+/**
+ * Run validation and rollback tests
+ */
+export async function runValidationTests(workingDir) {
+  const testRunner = new ValidationTestRunner(workingDir);
+  await testRunner.runAllTests();
+  return testRunner.testResults;
+}

package/src/cli/simple-commands/init.js

@@ -0,0 +1,4 @@
+// init.js - Initialize Claude Code integration files
+// This file now re-exports from the modular init structure
+
+export { initCommand } from './init/index.js';

package/src/cli/simple-commands/mcp-health.js

@@ -0,0 +1,163 @@
+// MCP Health Check Command
+// Provides comprehensive health monitoring for MCP configuration
+// Uses the bulletproof MCP configuration manager for diagnostics
+
+import { printSuccess, printWarning, printError } from '../utils.js';
+
+/**
+ * MCP Health Check Command
+ * Provides detailed health assessment of MCP configuration
+ */
+export async function mcpHealthCommand(subArgs, flags) {
+  // Show help if requested
+  if (flags.help || flags.h || subArgs.includes('--help') || subArgs.includes('-h')) {
+    console.log(`
+🏥 MCP Health Check
+
+Usage: claude-flow-novice mcp health [options]
+
+Options:
+  --verbose         Show detailed diagnostic information
+  --fix             Automatically fix detected issues
+  --dry-run         Preview fixes without applying changes
+  --help, -h        Show this help message
+
+This command performs a comprehensive health check of your MCP configuration:
+  • Detects broken server configurations
+  • Identifies conflicts between local and project configs
+  • Validates Claude Code CLI installation
+  • Tests MCP server connectivity
+  • Provides actionable recommendations
+
+The health check is safe and read-only by default. Use --fix to automatically
+resolve detected issues with full backup and rollback protection.
+    `.trim());
+    return;
+  }
+
+  const options = {
+    verbose: flags.verbose || false,
+    autoFix: flags.fix || false,
+    dryRun: flags['dry-run'] || false
+  };
+
+  console.log('🏥 Running MCP health check...');
+
+  try {
+    // Import the bulletproof MCP configuration manager
+    const { quickMcpHealthCheck, enhancedMcpInit } = await import('../mcp/mcp-config-manager.js');
+
+    // Run comprehensive health check
+    const healthResult = await quickMcpHealthCheck(options);
+
+    // Display results using the enhanced UX
+    try {
+      const { displayHealthCheckResults } = await import('./mcp-user-experience.js');
+      displayHealthCheckResults(healthResult, options);
+    } catch (uxError) {
+      // Fallback to basic output if UX module isn't available
+      displayBasicHealthResults(healthResult, options);
+    }
+
+    // If issues were found and fix is requested, run the bulletproof setup
+    if (!healthResult.healthy && options.autoFix) {
+      console.log('\n🛠️  Attempting to fix detected issues...');
+
+      const fixResult = await enhancedMcpInit({
+        verbose: options.verbose,
+        autoFix: true,
+        dryRun: options.dryRun,
+        enhancedUx: true
+      });
+
+      if (fixResult.success) {
+        printSuccess('🎉 All issues have been automatically resolved!');
+        console.log('   • Run health check again to verify: npx claude-flow-novice mcp health');
+      } else {
+        printWarning('⚠️  Some issues could not be automatically resolved');
+        if (fixResult.recovery && fixResult.recovery.recommendedActions) {
+          console.log('\n🛠️  Manual actions required:');
+          fixResult.recovery.recommendedActions.slice(0, 3).forEach((action, i) => {
+            console.log(`   ${i + 1}. ${action}`);
+          });
+        }
+      }
+    } else if (!healthResult.healthy && !options.autoFix) {
+      console.log('\n💡 To automatically fix issues, run:');
+      console.log('   npx claude-flow-novice mcp health --fix');
+      console.log('\n   Or preview fixes with:');
+      console.log('   npx claude-flow-novice mcp health --fix --dry-run');
+    }
+
+    // Exit with appropriate code
+    process.exit(healthResult.healthy ? 0 : 1);
+
+  } catch (error) {
+    printError(`Health check failed: ${error.message}`);
+
+    if (options.verbose) {
+      console.error('\n📋 Stack trace:');
+      console.error(error.stack);
+    }
+
+    console.log('\n🆘 Troubleshooting:');
+    console.log('   • Ensure claude-flow-novice is properly installed');
+    console.log('   • Check if Claude Code CLI is installed: claude --version');
+    console.log('   • Try running: npx claude-flow-novice init --force');
+
+    process.exit(1);
+  }
+}
+
+/**
+ * Basic health results display (fallback when UX module isn't available)
+ */
+function displayBasicHealthResults(results, options) {
+  console.log('\n📊 Health Check Results:');
+  console.log('━'.repeat(40));
+
+  const healthIcon = results.healthy ? '✅' : results.needsAttention ? '⚠️' : '❌';
+  const healthStatus = results.healthy ? 'Healthy' : 'Needs Attention';
+
+  console.log(`Overall Status: ${healthIcon} ${healthStatus}`);
+
+  if (results.healthScore !== undefined) {
+    console.log(`Health Score: ${results.healthScore}/100`);
+  }
+
+  if (results.state) {
+    console.log('\nConfiguration Status:');
+    console.log(`  Claude Code: ${results.state.claudeCodeInstalled ? '✅' : '❌'}`);
+    console.log(`  Local Config: ${results.state.hasLocalConfig ? '✅' : '❌'}`);
+    console.log(`  Project Config: ${results.state.hasProjectConfig ? '✅' : '❌'}`);
+
+    if (results.state.brokenPaths && results.state.brokenPaths.length > 0) {
+      console.log('\n❌ Issues Found:');
+      results.state.brokenPaths.forEach(broken => {
+        console.log(`  • ${broken.serverName}: ${broken.issues ? broken.issues.join(', ') : 'Configuration issues'}`);
+      });
+    }
+
+    if (results.state.conflictingServers && results.state.conflictingServers.length > 0) {
+      console.log('\n⚠️  Configuration Conflicts:');
+      results.state.conflictingServers.forEach(conflict => {
+        console.log(`  • ${conflict.serverName}: Local vs Project configuration`);
+      });
+    }
+  }
+
+  if (results.verification && results.verification.tests) {
+    console.log('\n🧪 Verification Tests:');
+    results.verification.tests.forEach(test => {
+      const status = test.passed ? '✅' : '❌';
+      console.log(`  ${status} ${test.name}`);
+      if (options.verbose && test.details) {
+        console.log(`      ${test.details}`);
+      }
+    });
+  }
+
+  console.log('━'.repeat(40));
+}
+
+export default mcpHealthCommand;