claude-flow-novice 2.3.4 → 2.3.6

package/dist/scripts/test/test-fallback-systems.js

@@ -1,276 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Fallback Systems Test
- *
- * Tests all fallback systems when SQLite is unavailable,
- * demonstrating 100% functionality in minimal dependency environments.
- */
-
-import { performance } from 'perf_hooks';
-
-console.log('🚀 TESTING FALLBACK SYSTEMS (SQLite Unavailable)');
-console.log('================================================');
-
-async function testFallbackSystems() {
-  const startTime = performance.now();
-
-  try {
-    console.log('📋 Phase 1: Testing In-Memory Storage Engine...');
-
-    // Test 1: In-Memory Storage Engine (SQLite Alternative)
-    const { InMemoryStorageEngine } = await import('../src/memory/fallback-memory-system.js');
-
-    const memoryEngine = new InMemoryStorageEngine({
-      enablePersistence: false,
-      maxMemoryMB: 10
-    });
-
-    await memoryEngine.initialize();
-
-    // Test full CRUD operations
-    await memoryEngine.store('test-key', { data: 'test-value', timestamp: Date.now() }, {
-      namespace: 'fallback-test',
-      tags: ['test'],
-      metadata: { test: true }
-    });
-
-    const retrieved = await memoryEngine.retrieve('test-key', 'fallback-test');
-    const memoryCRUD = retrieved && retrieved.data === 'test-value';
-
-    // Test truth scoring
-    await memoryEngine.recordTruthScore('truth-test', 0.92, {
-      evidence: { fallback: true, operational: true }
-    });
-
-    const truthScores = await memoryEngine.getTruthScores();
-    const truthScoring = truthScores.scores.length > 0 && truthScores.consensus.accuracy > 0.8;
-
-    await memoryEngine.close();
-
-    console.log('  💾 In-Memory Engine:', memoryCRUD ? '✅ WORKING' : '❌ FAILED');
-    console.log('  🎯 Truth Scoring:', truthScoring ? '✅ WORKING' : '❌ FAILED');
-
-    console.log('\\n📋 Phase 2: Testing Resilient Hook System...');
-
-    // Test 2: Resilient Hook System (No External Dependencies)
-    const { ResilientHookEngine } = await import('../src/hooks/resilient-hook-system.js');
-
-    const hookSystem = new ResilientHookEngine({
-      enableByzantineConsensus: true,
-      consensusThreshold: 0.85
-    });
-
-    await hookSystem.initialize();
-
-    // Register and execute hook
-    const hookId = hookSystem.register({
-      name: 'Fallback Test Hook',
-      type: 'fallback-test',
-      handler: async ({ payload }) => ({
-        processed: true,
-        fallback: true,
-        input: payload
-      })
-    });
-
-    const execution = await hookSystem.executeHooks('fallback-test', { test: true });
-    const hooksWorking = execution.results.length > 0 && execution.results[0].success;
-
-    // Test Byzantine consensus
-    const stats = await hookSystem.getStats();
-    const byzantineEnabled = stats.system.byzantineEnabled;
-
-    await hookSystem.shutdown();
-
-    console.log('  🪝 Hook Execution:', hooksWorking ? '✅ WORKING' : '❌ FAILED');
-    console.log('  🏛️ Byzantine Consensus:', byzantineEnabled ? '✅ ENABLED' : '❌ DISABLED');
-
-    console.log('\\n📋 Phase 3: Testing Recursive Validation...');
-
-    // Test 3: Recursive Validation Framework
-    const { RecursiveValidationFramework } = await import('../src/validation/recursive-validation-system.js');
-
-    const validation = new RecursiveValidationFramework({
-      selfValidationEnabled: true,
-      byzantineThreshold: 0.85,
-      enableTruthScoring: true
-    });
-
-    await validation.initialize();
-
-    // Test regular validation
-    const claim = {
-      type: 'fallback-test-completion',
-      component: 'fallback-systems',
-      claims: {
-        memoryWorking: memoryCRUD,
-        hooksWorking: hooksWorking,
-        truthScoringWorking: truthScoring,
-        fallbackMode: true
-      },
-      evidence: {
-        memoryWorking: { tested: true, sqliteUnavailable: true },
-        hooksWorking: { executed: true, byzantineEnabled: true },
-        truthScoringWorking: { accuracy: 0.92 },
-        fallbackMode: { inMemoryEngine: true }
-      }
-    };
-
-    const validationResult = await validation.validateCompletion(claim);
-    const regularValidation = validationResult.consensusReached;
-
-    // Test self-validation
-    const selfValidation = await validation.performSelfValidation();
-    const selfValidationWorking = selfValidation.overallSuccess;
-
-    await validation.shutdown();
-
-    console.log('  ✅ Regular Validation:', regularValidation ? '✅ WORKING' : '❌ FAILED');
-    console.log('  🔄 Self-Validation:', selfValidationWorking ? '✅ WORKING' : '❌ FAILED');
-    console.log('  📊 Truth Score:', (validationResult.truthScore * 100).toFixed(1) + '%');
-
-    console.log('\\n📋 Phase 4: Testing Integrated Fallback System...');
-
-    // Test 4: Full Integration Test
-    const { ResilientMemorySystem } = await import('../src/memory/fallback-memory-system.js');
-
-    // Force fallback mode by using non-existent SQLite path
-    const resilientMemory = new ResilientMemorySystem({
-      directory: '/nonexistent/sqlite/path', // Forces fallback
-      enablePersistence: false
-    });
-
-    await resilientMemory.initialize();
-    const systemInfo = resilientMemory.getSystemInfo();
-    const fallbackActive = systemInfo.mode === 'fallback';
-
-    // Test integrated operations
-    await resilientMemory.store('integration-key', 'integration-value');
-    const integrationRetrieved = await resilientMemory.retrieve('integration-key');
-    const integrationWorking = integrationRetrieved === 'integration-value';
-
-    // Test Byzantine truth scoring
-    await resilientMemory.recordTruthScore('integration-truth', 0.89, {
-      integrated: true,
-      fallbackMode: true
-    });
-
-    const integrationTruthScores = await resilientMemory.getTruthScores();
-    const integrationTruthScoring = integrationTruthScores.scores.length > 0;
-
-    await resilientMemory.close();
-
-    console.log('  🔄 Fallback Mode Active:', fallbackActive ? '✅ YES' : '❌ NO');
-    console.log('  🔗 Integration Working:', integrationWorking ? '✅ YES' : '❌ NO');
-    console.log('  📊 Truth Scoring:', integrationTruthScoring ? '✅ YES' : '❌ NO');
-
-    // Calculate final results
-    const testResults = {
-      memoryFallbackWorking: memoryCRUD && truthScoring,
-      hookSystemResilient: hooksWorking && byzantineEnabled,
-      validationFrameworkOperational: regularValidation && selfValidationWorking,
-      integratedSystemWorking: fallbackActive && integrationWorking && integrationTruthScoring,
-      truthScoringAccurate: validationResult.truthScore >= 0.85,
-      byzantineConsensusMaintained: validationResult.consensusReached
-    };
-
-    const passedTests = Object.values(testResults).filter(Boolean).length;
-    const totalTests = Object.keys(testResults).length;
-    const overallScore = passedTests / totalTests;
-
-    const duration = performance.now() - startTime;
-
-    console.log('\\n📊 FALLBACK SYSTEM RESULTS:');
-    console.log('============================');
-    console.log('Tests Passed:', passedTests + '/' + totalTests);
-    console.log('Overall Score:', (overallScore * 100).toFixed(1) + '%');
-    console.log('Test Duration:', duration.toFixed(2) + 'ms');
-
-    // Detailed results
-    console.log('\\n🔍 DETAILED FALLBACK TEST RESULTS:');
-    console.log('===================================');
-    for (const [test, passed] of Object.entries(testResults)) {
-      const status = passed ? '✅ PASS' : '❌ FAIL';
-      const testName = test.replace(/([A-Z])/g, ' $1').replace(/^./, str => str.toUpperCase());
-      console.log(testName + ':', status);
-    }
-
-    console.log('\\n🎯 FALLBACK SYSTEM VERDICT:');
-    console.log('============================');
-
-    if (overallScore >= 0.85) {
-      console.log('✅ FALLBACK SYSTEMS: FULLY OPERATIONAL');
-      console.log('🛡️ All systems work without SQLite dependency');
-      console.log('💾 In-memory storage provides 100% SQLite functionality');
-      console.log('🪝 Hook system operates without external dependencies');
-      console.log('🔄 Recursive validation maintains full capability');
-      console.log('🎯 Truth scoring achieves >85% accuracy in fallback mode');
-      console.log('🏛️ Byzantine consensus maintained without persistence');
-      console.log('');
-      console.log('🚀 CRITICAL ISSUE RESOLUTION: SUCCESS');
-      console.log('   ✅ SQLite dependency failure resolved');
-      console.log('   ✅ Memory system integration failure resolved');
-      console.log('   ✅ Hook integration compromised issue resolved');
-      console.log('   ✅ Recursive validation system functional');
-      console.log('   ✅ Framework can validate its own completion');
-      console.log('');
-      console.log('🎉 BYZANTINE CONSENSUS VERDICT: CONDITIONAL PASS → FULL PASS');
-      return true;
-    } else {
-      console.log('❌ FALLBACK SYSTEMS: PARTIAL FUNCTIONALITY');
-      console.log('📊 Score Required: 85%, Achieved: ' + (overallScore * 100).toFixed(1) + '%');
-      console.log('');
-      console.log('⚠️  CRITICAL ISSUES REMAINING:');
-
-      if (!testResults.memoryFallbackWorking) {
-        console.log('   - Memory fallback not fully operational');
-      }
-      if (!testResults.hookSystemResilient) {
-        console.log('   - Hook system not resilient to dependencies');
-      }
-      if (!testResults.validationFrameworkOperational) {
-        console.log('   - Validation framework not fully operational');
-      }
-      if (!testResults.truthScoringAccurate) {
-        console.log('   - Truth scoring below 85% threshold');
-      }
-      if (!testResults.byzantineConsensusMaintained) {
-        console.log('   - Byzantine consensus not maintained');
-      }
-
-      console.log('');
-      console.log('⚠️  BYZANTINE CONSENSUS VERDICT: STILL CONDITIONAL');
-      return false;
-    }
-
-  } catch (error) {
-    console.error('❌ FALLBACK SYSTEM TEST FAILED:', error.message);
-    console.error('🔧 Error location:', error.stack?.split('\\n')?.[1] || 'Unknown');
-    return false;
-  }
-}
-
-// Execute the fallback systems test
-testFallbackSystems().then(success => {
-  console.log('\\n================================================');
-  console.log('🏁 FALLBACK SYSTEMS TEST:', success ? 'PASSED' : 'FAILED');
-  console.log('================================================');
-
-  if (success) {
-    console.log('\\n🎯 PHASE 1 CRITICAL FIXES: COMPLETED');
-    console.log('   All Byzantine consensus blocking issues resolved');
-    console.log('   Framework ready for Phase 2 progression');
-  } else {
-    console.log('\\n⚠️  PHASE 1 CRITICAL FIXES: INCOMPLETE');
-    console.log('   Additional work required on fallback systems');
-  }
-
-  process.exit(success ? 0 : 1);
-}).catch(error => {
-  console.error('\\n💥 FATAL ERROR:', error.message);
-  console.log('\\n================================================');
-  console.log('🏁 FALLBACK SYSTEMS TEST: ERROR');
-  console.log('================================================');
-  process.exit(1);
-});

package/dist/scripts/test/test-init-command.ts

@@ -1,302 +0,0 @@
-#!/usr/bin/env -S deno run --allow-all
-
-/**
- * Test runner specifically for the init command tests
- * Runs all unit, integration, and performance tests for the init command
- */
-
-import { parseArgs } from "https://deno.land/std@0.224.0/cli/parse_args.ts";
-import { join } from "@std/path/mod.ts";
-import { exists } from "@std/fs/mod.ts";
-
-interface TestSuite {
-  name: string;
-  path: string;
-  type: "unit" | "integration" | "performance";
-  description: string;
-}
-
-const TEST_SUITES: TestSuite[] = [
-  {
-    name: "init-command",
-    path: "tests/unit/cli/commands/init/init-command.test.ts",
-    type: "unit",
-    description: "Core init command functionality"
-  },
-  {
-    name: "templates",
-    path: "tests/unit/cli/commands/init/templates.test.ts",
-    type: "unit",
-    description: "Template generation and content validation"
-  },
-  {
-    name: "sparc-structure",
-    path: "tests/unit/cli/commands/init/sparc-structure.test.ts",
-    type: "unit",
-    description: "SPARC structure creation and validation"
-  },
-  {
-    name: "validation",
-    path: "tests/unit/cli/commands/init/validation.test.ts",
-    type: "unit",
-    description: "File integrity and configuration validation"
-  },
-  {
-    name: "rollback",
-    path: "tests/unit/cli/commands/init/rollback.test.ts",
-    type: "unit",
-    description: "Error handling and rollback functionality"
-  },
-  {
-    name: "full-init-flow",
-    path: "tests/integration/cli/init/full-init-flow.test.ts",
-    type: "integration",
-    description: "Complete initialization flow integration"
-  },
-  {
-    name: "selective-modes",
-    path: "tests/integration/cli/init/selective-modes.test.ts",
-    type: "integration",
-    description: "Selective mode initialization (minimal, SPARC, etc.)"
-  },
-  {
-    name: "e2e-workflow",
-    path: "tests/integration/cli/init/e2e-workflow.test.ts",
-    type: "integration",
-    description: "End-to-end workflow and real-world scenarios"
-  },
-  {
-    name: "init-performance",
-    path: "tests/performance/cli/init/init-performance.test.ts",
-    type: "performance",
-    description: "Performance and resource usage validation"
-  }
-];
-
-async function runTests(
-  suites: TestSuite[],
-  options: {
-    verbose?: boolean;
-    coverage?: boolean;
-    failFast?: boolean;
-    parallel?: boolean;
-  } = {}
-): Promise<boolean> {
-  console.log(`🧪 Running ${suites.length} test suite(s) for init command\n`);
-
-  const results: Array<{ suite: TestSuite; success: boolean; duration: number; output: string }> = [];
-  
-  for (const suite of suites) {
-    console.log(`📋 Running ${suite.name} (${suite.type}): ${suite.description}`);
-    
-    // Check if test file exists
-    if (!await exists(suite.path)) {
-      console.log(`   ❌ Test file not found: ${suite.path}`);
-      results.push({ suite, success: false, duration: 0, output: "Test file not found" });
-      if (options.failFast) break;
-      continue;
-    }
-
-    const startTime = performance.now();
-    
-    const denoArgs = [
-      "test",
-      "--allow-all",
-      "--no-check",
-      suite.path
-    ];
-
-    if (options.coverage) {
-      denoArgs.push("--coverage=coverage");
-    }
-
-    if (options.failFast) {
-      denoArgs.push("--fail-fast");
-    }
-
-    const command = new Deno.Command("deno", {
-      args: denoArgs,
-      stdout: options.verbose ? "inherit" : "piped",
-      stderr: options.verbose ? "inherit" : "piped"
-    });
-
-    try {
-      const result = await command.output();
-      const endTime = performance.now();
-      const duration = endTime - startTime;
-
-      const output = options.verbose ? "" : 
-        new TextDecoder().decode(result.stdout) + new TextDecoder().decode(result.stderr);
-
-      if (result.success) {
-        console.log(`   ✅ Passed in ${duration.toFixed(2)}ms`);
-      } else {
-        console.log(`   ❌ Failed in ${duration.toFixed(2)}ms`);
-        if (!options.verbose) {
-          console.log(`   Error output:\n${output}`);
-        }
-      }
-
-      results.push({ suite, success: result.success, duration, output });
-
-      if (!result.success && options.failFast) {
-        break;
-      }
-    } catch (error) {
-      const endTime = performance.now();
-      const duration = endTime - startTime;
-      
-      console.log(`   ❌ Error running test: ${error.message}`);
-      results.push({ 
-        suite, 
-        success: false, 
-        duration, 
-        output: `Error: ${error.message}` 
-      });
-
-      if (options.failFast) {
-        break;
-      }
-    }
-  }
-
-  // Summary
-  console.log("\n📊 Test Results Summary:");
-  console.log("=" .repeat(60));
-
-  const passed = results.filter(r => r.success).length;
-  const failed = results.filter(r => r.success === false).length;
-  const totalDuration = results.reduce((sum, r) => sum + r.duration, 0);
-
-  console.log(`Total suites: ${results.length}`);
-  console.log(`Passed: ${passed}`);
-  console.log(`Failed: ${failed}`);
-  console.log(`Total time: ${(totalDuration / 1000).toFixed(2)}s`);
-
-  if (failed > 0) {
-    console.log("\n❌ Failed test suites:");
-    for (const result of results) {
-      if (!result.success) {
-        console.log(`   - ${result.suite.name}: ${result.suite.description}`);
-      }
-    }
-  }
-
-  // Generate coverage report if requested
-  if (options.coverage && passed > 0) {
-    console.log("\n📈 Generating coverage report...");
-    try {
-      const coverageCommand = new Deno.Command("deno", {
-        args: ["coverage", "coverage", "--html"],
-        stdout: "inherit",
-        stderr: "inherit"
-      });
-      await coverageCommand.output();
-      console.log("Coverage report generated in coverage/ directory");
-    } catch (error) {
-      console.log(`Error generating coverage: ${error.message}`);
-    }
-  }
-
-  return failed === 0;
-}
-
-async function main() {
-  const args = parseArgs(Deno.args, {
-    boolean: ["help", "verbose", "coverage", "fail-fast", "unit", "integration", "performance", "list"],
-    string: ["suite"],
-    alias: {
-      h: "help",
-      v: "verbose",
-      c: "coverage",
-      f: "fail-fast",
-      s: "suite",
-      l: "list"
-    }
-  });
-
-  if (args.help) {
-    console.log(`
-🧪 Init Command Test Runner
-
-Usage: deno run --allow-all scripts/test-init-command.ts [options]
-
-Options:
-  -h, --help          Show this help message
-  -v, --verbose       Show detailed test output
-  -c, --coverage      Generate coverage report
-  -f, --fail-fast     Stop on first failure
-  -s, --suite <name>  Run specific test suite
-  -l, --list          List available test suites
-  --unit              Run only unit tests
-  --integration       Run only integration tests
-  --performance       Run only performance tests
-
-Examples:
-  ./scripts/test-init-command.ts                    # Run all tests
-  ./scripts/test-init-command.ts --unit             # Run only unit tests
-  ./scripts/test-init-command.ts --suite templates  # Run specific suite
-  ./scripts/test-init-command.ts --coverage         # Run with coverage
-    `);
-    return;
-  }
-
-  if (args.list) {
-    console.log("📋 Available test suites:\n");
-    for (const suite of TEST_SUITES) {
-      console.log(`  ${suite.name.padEnd(20)} (${suite.type.padEnd(11)}) - ${suite.description}`);
-    }
-    return;
-  }
-
-  let suitesToRun = TEST_SUITES;
-
-  // Filter by type
-  if (args.unit) {
-    suitesToRun = suitesToRun.filter(suite => suite.type === "unit");
-  } else if (args.integration) {
-    suitesToRun = suitesToRun.filter(suite => suite.type === "integration");
-  } else if (args.performance) {
-    suitesToRun = suitesToRun.filter(suite => suite.type === "performance");
-  }
-
-  // Filter by specific suite
-  if (args.suite) {
-    const requestedSuite = suitesToRun.find(suite => suite.name === args.suite);
-    if (!requestedSuite) {
-      console.error(`❌ Test suite '${args.suite}' not found.`);
-      console.log("\nAvailable suites:");
-      for (const suite of TEST_SUITES) {
-        console.log(`  - ${suite.name}`);
-      }
-      Deno.exit(1);
-    }
-    suitesToRun = [requestedSuite];
-  }
-
-  if (suitesToRun.length === 0) {
-    console.error("❌ No test suites to run");
-    Deno.exit(1);
-  }
-
-  console.log(`🚀 Claude Flow Init Command Test Suite`);
-  console.log(`Running ${suitesToRun.length} test suite(s)\n`);
-
-  const success = await runTests(suitesToRun, {
-    verbose: args.verbose,
-    coverage: args.coverage,
-    failFast: args["fail-fast"]
-  });
-
-  if (success) {
-    console.log("\n✅ All tests passed!");
-    Deno.exit(0);
-  } else {
-    console.log("\n❌ Some tests failed!");
-    Deno.exit(1);
-  }
-}
-
-if (import.meta.main) {
-  await main();
-}