claude-flow-novice 2.2.1 → 2.2.2

package/dist/src/hooks/enhanced-post-edit-pipeline.js

@@ -1,2321 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Enhanced Post-Edit Pipeline for Claude Flow Novice
- *
- * Provides comprehensive real-time feedback to editing agents including:
- * - TDD testing with single-file execution
- * - Real-time coverage analysis and diff reporting
- * - Advanced multi-language validation with error locations
- * - Formatting diff preview and change detection
- * - Actionable recommendations by category (security, performance, maintainability)
- * - Blocking mechanisms for critical failures
- * - Rich return objects for agent integration
- * - Enhanced memory store with versioning
- */
-
-import fs from 'fs/promises';
-import path from 'path';
-import { spawn, execSync } from 'child_process';
-import { promisify } from 'util';
-
-// Enhanced logging utilities with structured output
-class Logger {
-  static success(msg, data = {}) {
-    console.log(`✅ ${msg}`);
-    return { level: 'success', message: msg, data };
-  }
-
-  static error(msg, data = {}) {
-    console.log(`❌ ${msg}`);
-    return { level: 'error', message: msg, data };
-  }
-
-  static warning(msg, data = {}) {
-    console.log(`⚠️ ${msg}`);
-    return { level: 'warning', message: msg, data };
-  }
-
-  static info(msg, data = {}) {
-    console.log(`ℹ️ ${msg}`);
-    return { level: 'info', message: msg, data };
-  }
-
-  static test(msg, data = {}) {
-    console.log(`🧪 ${msg}`);
-    return { level: 'test', message: msg, data };
-  }
-
-  static coverage(msg, data = {}) {
-    console.log(`📊 ${msg}`);
-    return { level: 'coverage', message: msg, data };
-  }
-
-  static tdd(msg, data = {}) {
-    console.log(`🔴🟢♻️ ${msg}`);
-    return { level: 'tdd', message: msg, data };
-  }
-
-  static debug(msg, data = {}) {
-    if (process.env.DEBUG) {
-      console.log(`🔍 ${msg}`);
-    }
-    return { level: 'debug', message: msg, data };
-  }
-}
-
-// Workspace detection helper - finds nearest workspace root
-async function findWorkspaceRoot(filePath, markerFile) {
-  let currentDir = path.dirname(path.resolve(filePath));
-  let levelsUp = 0;
-  const maxLevels = 10;
-
-  while (levelsUp < maxLevels) {
-    const markerPath = path.join(currentDir, markerFile);
-
-    try {
-      await fs.access(markerPath, fs.constants.F_OK);
-      return currentDir;
-    } catch {
-      // File doesn't exist, continue traversing up
-    }
-
-    const parentDir = path.dirname(currentDir);
-
-    // Reached filesystem root
-    if (parentDir === currentDir) {
-      return null;
-    }
-
-    currentDir = parentDir;
-    levelsUp++;
-  }
-
-  return null;
-}
-
-// Single-file test execution engine
-class SingleFileTestEngine {
-  constructor() {
-    this.testRunners = {
-      '.js': this.runJavaScriptTests.bind(this),
-      '.jsx': this.runJavaScriptTests.bind(this),
-      '.ts': this.runTypeScriptTests.bind(this),
-      '.tsx': this.runTypeScriptTests.bind(this),
-      '.py': this.runPythonTests.bind(this),
-      '.go': this.runGoTests.bind(this),
-      '.rs': this.runRustTests.bind(this),
-      '.java': this.runJavaTests.bind(this),
-      '.cpp': this.runCPPTests.bind(this),
-      '.c': this.runCTests.bind(this)
-    };
-
-    this.testFrameworks = {
-      javascript: ['jest', 'mocha', 'ava', 'tap'],
-      python: ['pytest', 'unittest', 'nose2'],
-      go: ['go test'],
-      rust: ['cargo test'],
-      java: ['junit', 'testng'],
-      cpp: ['gtest', 'catch2']
-    };
-  }
-
-  async executeTests(file, content) {
-    const ext = path.extname(file).toLowerCase();
-    const runner = this.testRunners[ext];
-
-    if (!runner) {
-      return {
-        executed: false,
-        reason: `No test runner available for ${ext} files`,
-        framework: null,
-        results: null,
-        coverage: null,
-        tddCompliance: null
-      };
-    }
-
-    // Check if this is a test file or source file
-    const isTestFile = this.isTestFile(file);
-    const relatedFile = isTestFile ? this.findSourceFile(file) : this.findTestFile(file);
-
-    return await runner(file, content, { isTestFile, relatedFile });
-  }
-
-  async runJavaScriptTests(file, content, options = {}) {
-    const { isTestFile, relatedFile } = options;
-
-    try {
-      // Detect available test framework
-      const framework = await this.detectJSTestFramework();
-
-      if (!framework) {
-        return {
-          executed: false,
-          reason: 'No JavaScript test framework detected (jest, mocha, etc.)',
-          framework: null,
-          results: null,
-          coverage: null,
-          tddCompliance: this.checkTDDCompliance(file, relatedFile, null)
-        };
-      }
-
-      // Execute tests based on framework
-      let testResults = null;
-      let coverage = null;
-
-      if (framework === 'jest') {
-        testResults = await this.runJestSingleFile(file, isTestFile);
-        coverage = await this.getJestCoverage(file);
-      } else if (framework === 'mocha') {
-        testResults = await this.runMochaSingleFile(file, isTestFile);
-        coverage = await this.getMochaCoverage(file);
-      }
-
-      const tddCompliance = this.checkTDDCompliance(file, relatedFile, testResults);
-
-      return {
-        executed: true,
-        framework,
-        results: testResults,
-        coverage,
-        tddCompliance,
-        singleFileMode: true
-      };
-
-    } catch (error) {
-      return {
-        executed: false,
-        reason: `Test execution failed: ${error.message}`,
-        framework: null,
-        results: null,
-        coverage: null,
-        tddCompliance: null,
-        error: error.message
-      };
-    }
-  }
-
-  async runTypeScriptTests(file, content, options = {}) {
-    // TypeScript tests - compile to JS then run
-    const jsResult = await this.runJavaScriptTests(file, content, options);
-
-    // Add TypeScript-specific test handling
-    if (jsResult.executed) {
-      jsResult.language = 'typescript';
-      jsResult.compiled = true;
-    }
-
-    return jsResult;
-  }
-
-  async runGoTests(file, content, options = {}) {
-    const { isTestFile, relatedFile } = options;
-
-    try {
-      if (!isTestFile) {
-        // For source files, find and run corresponding test
-        const testFile = this.findTestFile(file);
-        if (!testFile || !await this.fileExists(testFile)) {
-          return {
-            executed: false,
-            reason: 'No corresponding test file found for Go source',
-            framework: 'go test',
-            results: null,
-            coverage: null,
-            tddCompliance: this.checkTDDCompliance(file, null, null)
-          };
-        }
-        file = testFile;
-      }
-
-      // Run go test on single file
-      const testResults = await this.runGoTestSingleFile(file);
-      const coverage = await this.getGoCoverage(file);
-      const tddCompliance = this.checkTDDCompliance(file, relatedFile, testResults);
-
-      return {
-        executed: true,
-        framework: 'go test',
-        results: testResults,
-        coverage,
-        tddCompliance,
-        singleFileMode: true
-      };
-
-    } catch (error) {
-      return {
-        executed: false,
-        reason: `Go test execution failed: ${error.message}`,
-        framework: 'go test',
-        results: null,
-        coverage: null,
-        tddCompliance: null,
-        error: error.message
-      };
-    }
-  }
-
-  async runRustTests(file, content, options = {}) {
-    const { isTestFile, relatedFile } = options;
-
-    try {
-      // Rust uses integrated testing with cargo test
-      const testResults = await this.runCargoTestSingleFile(file);
-      const coverage = await this.getRustCoverage(file);
-      const tddCompliance = this.checkTDDCompliance(file, relatedFile, testResults);
-
-      return {
-        executed: true,
-        framework: 'cargo test',
-        results: testResults,
-        coverage,
-        tddCompliance,
-        singleFileMode: true
-      };
-
-    } catch (error) {
-      return {
-        executed: false,
-        reason: `Rust test execution failed: ${error.message}`,
-        framework: 'cargo test',
-        results: null,
-        coverage: null,
-        tddCompliance: null,
-        error: error.message
-      };
-    }
-  }
-
-  async runJavaTests(file, content, options = {}) {
-    const { isTestFile, relatedFile } = options;
-
-    try {
-      const framework = await this.detectJavaTestFramework();
-
-      if (!framework) {
-        return {
-          executed: false,
-          reason: 'No Java test framework detected (JUnit, TestNG)',
-          framework: null,
-          results: null,
-          coverage: null,
-          tddCompliance: this.checkTDDCompliance(file, relatedFile, null)
-        };
-      }
-
-      const testResults = await this.runJavaTestSingleFile(file, framework);
-      const coverage = await this.getJavaCoverage(file);
-      const tddCompliance = this.checkTDDCompliance(file, relatedFile, testResults);
-
-      return {
-        executed: true,
-        framework,
-        results: testResults,
-        coverage,
-        tddCompliance,
-        singleFileMode: true
-      };
-
-    } catch (error) {
-      return {
-        executed: false,
-        reason: `Java test execution failed: ${error.message}`,
-        framework: null,
-        results: null,
-        coverage: null,
-        tddCompliance: null,
-        error: error.message
-      };
-    }
-  }
-
-  async runCPPTests(file, content, options = {}) {
-    return this.runCTests(file, content, options); // Similar implementation
-  }
-
-  async runCTests(file, content, options = {}) {
-    const { isTestFile, relatedFile } = options;
-
-    try {
-      const framework = await this.detectCTestFramework();
-
-      if (!framework) {
-        return {
-          executed: false,
-          reason: 'No C/C++ test framework detected (gtest, catch2)',
-          framework: null,
-          results: null,
-          coverage: null,
-          tddCompliance: this.checkTDDCompliance(file, relatedFile, null)
-        };
-      }
-
-      const testResults = await this.runCTestSingleFile(file, framework);
-      const coverage = await this.getCCoverage(file);
-      const tddCompliance = this.checkTDDCompliance(file, relatedFile, testResults);
-
-      return {
-        executed: true,
-        framework,
-        results: testResults,
-        coverage,
-        tddCompliance,
-        singleFileMode: true
-      };
-
-    } catch (error) {
-      return {
-        executed: false,
-        reason: `C/C++ test execution failed: ${error.message}`,
-        framework: null,
-        results: null,
-        coverage: null,
-        tddCompliance: null,
-        error: error.message
-      };
-    }
-  }
-
-  async runPythonTests(file, content, options = {}) {
-    const { isTestFile, relatedFile } = options;
-
-    try {
-      const framework = await this.detectPythonTestFramework();
-
-      if (!framework) {
-        return {
-          executed: false,
-          reason: 'No Python test framework detected (pytest, unittest)',
-          framework: null,
-          results: null,
-          coverage: null,
-          tddCompliance: this.checkTDDCompliance(file, relatedFile, null)
-        };
-      }
-
-      let testResults = null;
-      let coverage = null;
-
-      if (framework === 'pytest') {
-        testResults = await this.runPytestSingleFile(file, isTestFile);
-        coverage = await this.getPytestCoverage(file);
-      } else if (framework === 'unittest') {
-        testResults = await this.runUnittestSingleFile(file, isTestFile);
-        coverage = await this.getUnittestCoverage(file);
-      }
-
-      const tddCompliance = this.checkTDDCompliance(file, relatedFile, testResults);
-
-      return {
-        executed: true,
-        framework,
-        results: testResults,
-        coverage,
-        tddCompliance,
-        singleFileMode: true
-      };
-
-    } catch (error) {
-      return {
-        executed: false,
-        reason: `Python test execution failed: ${error.message}`,
-        framework: null,
-        results: null,
-        coverage: null,
-        tddCompliance: null,
-        error: error.message
-      };
-    }
-  }
-
-  // Framework detection methods
-  async detectJSTestFramework() {
-    try {
-      // Check multiple possible package.json locations
-      const possiblePaths = [
-        path.join(process.cwd(), 'package.json'),
-        path.join(path.dirname(process.cwd()), 'package.json'),
-        path.join(process.cwd(), 'test-files', 'package.json'),
-        path.join(process.cwd(), '..', 'package.json')
-      ];
-
-      for (const packagePath of possiblePaths) {
-        try {
-          const packageContent = await fs.readFile(packagePath, 'utf8');
-          const packageJson = JSON.parse(packageContent);
-
-          const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
-
-          if (deps.jest) return 'jest';
-          if (deps.mocha) return 'mocha';
-          if (deps.ava) return 'ava';
-          if (deps.tap) return 'tap';
-        } catch {
-          // Continue to next path
-        }
-      }
-
-      return null;
-    } catch {
-      return null;
-    }
-  }
-
-  async detectPythonTestFramework() {
-    try {
-      // Check for pytest
-      execSync('pytest --version', { stdio: 'ignore' });
-      return 'pytest';
-    } catch {
-      try {
-        // Check for unittest (built-in)
-        execSync('python -m unittest --help', { stdio: 'ignore' });
-        return 'unittest';
-      } catch {
-        return null;
-      }
-    }
-  }
-
-  async detectJavaTestFramework() {
-    try {
-      // Check for JUnit in classpath or build files
-      const buildFiles = ['pom.xml', 'build.gradle', 'build.gradle.kts'];
-
-      for (const buildFile of buildFiles) {
-        if (await this.fileExists(buildFile)) {
-          const content = await fs.readFile(buildFile, 'utf8');
-          if (content.includes('junit')) return 'junit';
-          if (content.includes('testng')) return 'testng';
-        }
-      }
-
-      return null;
-    } catch {
-      return null;
-    }
-  }
-
-  async detectCTestFramework() {
-    try {
-      // Check for gtest
-      execSync('pkg-config --exists gtest', { stdio: 'ignore' });
-      return 'gtest';
-    } catch {
-      try {
-        // Check for Catch2
-        execSync('pkg-config --exists catch2', { stdio: 'ignore' });
-        return 'catch2';
-      } catch {
-        return null;
-      }
-    }
-  }
-
-  // Test execution implementations
-  async runJestSingleFile(file, isTestFile) {
-    try {
-      const testPattern = isTestFile ? file : this.findTestFile(file);
-
-      if (!testPattern || !await this.fileExists(testPattern)) {
-        return {
-          passed: false,
-          reason: 'No test file found',
-          tests: [],
-          summary: { total: 0, passed: 0, failed: 0, skipped: 0 }
-        };
-      }
-
-      // Try different working directories to find Jest
-      const possibleDirs = [
-        path.dirname(testPattern),
-        path.join(process.cwd(), 'test-files'),
-        process.cwd()
-      ];
-
-      let jestOutput = null;
-      let workingDir = null;
-
-      for (const dir of possibleDirs) {
-        try {
-          const result = execSync(`npx jest "${path.basename(testPattern)}" --json --coverage=false --forceExit --detectOpenHandles`, {
-            encoding: 'utf8',
-            stdio: 'pipe',
-            cwd: dir,
-            timeout: 30000, // 30 second timeout
-            killSignal: 'SIGKILL'
-          });
-
-          jestOutput = JSON.parse(result);
-          workingDir = dir;
-          break;
-        } catch (error) {
-          // Continue to next directory
-          continue;
-        }
-      }
-
-      if (!jestOutput) {
-        return {
-          passed: false,
-          reason: 'Jest execution failed in all attempted directories',
-          tests: [],
-          summary: { total: 0, passed: 0, failed: 0, skipped: 0 }
-        };
-      }
-
-      return {
-        passed: jestOutput.success,
-        tests: jestOutput.testResults[0]?.assertionResults || [],
-        summary: {
-          total: jestOutput.numTotalTests,
-          passed: jestOutput.numPassedTests,
-          failed: jestOutput.numFailedTests,
-          skipped: jestOutput.numPendingTests
-        },
-        duration: jestOutput.testResults[0]?.endTime - jestOutput.testResults[0]?.startTime,
-        workingDir
-      };
-
-    } catch (error) {
-      return {
-        passed: false,
-        error: error.message,
-        tests: [],
-        summary: { total: 0, passed: 0, failed: 0, skipped: 0 }
-      };
-    }
-  }
-
-  // Additional test runner implementations (mock for now)
-  async runPytestSingleFile(file, isTestFile) {
-    return {
-      passed: true,
-      tests: [],
-      summary: { total: 0, passed: 0, failed: 0, skipped: 0 }
-    };
-  }
-
-  async runUnittestSingleFile(file, isTestFile) {
-    return {
-      passed: true,
-      tests: [],
-      summary: { total: 0, passed: 0, failed: 0, skipped: 0 }
-    };
-  }
-
-  async runMochaSingleFile(file, isTestFile) {
-    return {
-      passed: true,
-      tests: [],
-      summary: { total: 0, passed: 0, failed: 0, skipped: 0 }
-    };
-  }
-
-  async runGoTestSingleFile(file) {
-    return {
-      passed: true,
-      tests: [],
-      summary: { total: 0, passed: 0, failed: 0, skipped: 0 }
-    };
-  }
-
-  async runCargoTestSingleFile(file) {
-    return {
-      passed: true,
-      tests: [],
-      summary: { total: 0, passed: 0, failed: 0, skipped: 0 }
-    };
-  }
-
-  async runJavaTestSingleFile(file, framework) {
-    return {
-      passed: true,
-      tests: [],
-      summary: { total: 0, passed: 0, failed: 0, skipped: 0 }
-    };
-  }
-
-  async runCTestSingleFile(file, framework) {
-    return {
-      passed: true,
-      tests: [],
-      summary: { total: 0, passed: 0, failed: 0, skipped: 0 }
-    };
-  }
-
-  // Coverage analysis methods
-  async getJestCoverage(file) {
-    try {
-      const result = execSync(`npx jest "${file}" --coverage --coverageReporters=json --silent --forceExit --detectOpenHandles`, {
-        encoding: 'utf8',
-        stdio: 'pipe',
-        timeout: 30000, // 30 second timeout
-        killSignal: 'SIGKILL'
-      });
-
-      const coveragePath = path.join(process.cwd(), 'coverage', 'coverage-final.json');
-      const coverageData = JSON.parse(await fs.readFile(coveragePath, 'utf8'));
-
-      const fileCoverage = coverageData[path.resolve(file)] || {};
-
-      return {
-        lines: {
-          total: Object.keys(fileCoverage.s || {}).length,
-          covered: Object.values(fileCoverage.s || {}).filter(v => v > 0).length,
-          percentage: this.calculatePercentage(fileCoverage.s)
-        },
-        functions: {
-          total: Object.keys(fileCoverage.f || {}).length,
-          covered: Object.values(fileCoverage.f || {}).filter(v => v > 0).length,
-          percentage: this.calculatePercentage(fileCoverage.f)
-        },
-        branches: {
-          total: Object.keys(fileCoverage.b || {}).length,
-          covered: Object.values(fileCoverage.b || {}).flat().filter(v => v > 0).length,
-          percentage: this.calculatePercentage(fileCoverage.b, true)
-        },
-        statements: {
-          total: Object.keys(fileCoverage.s || {}).length,
-          covered: Object.values(fileCoverage.s || {}).filter(v => v > 0).length,
-          percentage: this.calculatePercentage(fileCoverage.s)
-        }
-      };
-
-    } catch (error) {
-      return {
-        error: error.message,
-        available: false
-      };
-    }
-  }
-
-  // Additional coverage methods (mock implementations)
-  async getPytestCoverage(file) {
-    return { error: 'Pytest coverage not implemented', available: false };
-  }
-
-  async getUnittestCoverage(file) {
-    return { error: 'Unittest coverage not implemented', available: false };
-  }
-
-  async getMochaCoverage(file) {
-    return { error: 'Mocha coverage not implemented', available: false };
-  }
-
-  async getGoCoverage(file) {
-    return { error: 'Go coverage not implemented', available: false };
-  }
-
-  async runCargoTestSingleFile(file) {
-    let testProcess = null;
-
-    try {
-      // For Rust, we run targeted tests for the specific file
-      const { exec } = await import('child_process');
-      const { promisify } = await import('util');
-      const execAsync = promisify(exec);
-
-      // Detect workspace root for Cargo commands
-      const workspaceRoot = await findWorkspaceRoot(file, 'Cargo.toml');
-
-      if (!workspaceRoot) {
-        return {
-          passed: false,
-          reason: 'No Cargo.toml found - not a Rust project',
-          tests: [],
-          summary: { total: 0, passed: 0, failed: 0, skipped: 0 }
-        };
-      }
-
-      Logger.debug(`Running cargo test from workspace: ${workspaceRoot}`);
-
-      // Extract test target from file path for targeted testing
-      const testTarget = this.extractRustTestTarget(file);
-
-      // Build targeted cargo test command
-      // --lib for library tests, --test <name> for integration tests, or filter by module
-      let cargoTestCmd = 'cargo test --quiet';
-
-      if (file.includes('tests/')) {
-        // Integration test file
-        const testName = path.basename(file, '.rs');
-        cargoTestCmd += ` --test ${testName}`;
-      } else if (file.endsWith('src/lib.rs') || file.endsWith('./src/lib.rs')) {
-        // Main library file - run lib tests only
-        cargoTestCmd += ' --lib';
-      } else if (testTarget) {
-        // Specific module - filter tests by module path
-        cargoTestCmd += ` ${testTarget}`;
-      } else {
-        // Fallback: run lib tests
-        cargoTestCmd += ' --lib';
-      }
-
-      cargoTestCmd += ' -- --nocapture --test-threads=1';
-
-      // Run targeted cargo test with strict timeout from workspace root
-      try {
-        testProcess = await execAsync(cargoTestCmd, {
-          cwd: workspaceRoot,
-          timeout: 30000,
-          maxBuffer: 1024 * 1024,
-          killSignal: 'SIGKILL'
-        });
-      } catch (error) {
-        if (testProcess) {
-          try { process.kill(-testProcess.pid, 'SIGKILL'); } catch {}
-        }
-        // Test failures still return output, so parse if available
-        if (!error.stdout && !error.stderr) throw error;
-        testProcess = error; // Use error object which contains stdout/stderr
-      }
-
-      // Parse test output
-      const testOutput = (testProcess.stdout || '') + (testProcess.stderr || '');
-      const testRegex = /test\s+(\S+)\s+\.\.\.\s+(ok|FAILED|ignored)/g;
-      const tests = [];
-      let match;
-
-      while ((match = testRegex.exec(testOutput)) !== null) {
-        tests.push({
-          name: match[1],
-          status: match[2] === 'ok' ? 'passed' : match[2] === 'FAILED' ? 'failed' : 'skipped'
-        });
-      }
-
-      const passed = tests.filter(t => t.status === 'passed').length;
-      const failed = tests.filter(t => t.status === 'failed').length;
-      const skipped = tests.filter(t => t.status === 'skipped').length;
-
-      return {
-        passed: failed === 0,
-        reason: failed > 0 ? `${failed} tests failed` : 'All tests passed',
-        tests,
-        summary: { total: tests.length, passed, failed, skipped },
-        targetedTest: testTarget || 'lib',
-        command: cargoTestCmd,
-        workspaceRoot
-      };
-
-    } catch (error) {
-      // Ensure all processes are killed
-      if (testProcess) {
-        try { process.kill(-testProcess.pid, 'SIGKILL'); } catch {}
-      }
-
-      return {
-        passed: false,
-        reason: `Cargo test failed: ${error.message}`,
-        tests: [],
-        summary: { total: 0, passed: 0, failed: 0, skipped: 0 }
-      };
-    }
-  }
-
-  // Extract Rust test target from file path
-  extractRustTestTarget(file) {
-    // Normalize path
-    const normalizedPath = file.replace(/\\/g, '/');
-
-    // Extract module path from src/ directory
-    if (normalizedPath.includes('src/')) {
-      const srcIndex = normalizedPath.lastIndexOf('src/');
-      const relativePath = normalizedPath.substring(srcIndex + 4); // Skip 'src/'
-
-      // Remove .rs extension
-      let modulePath = relativePath.replace(/\.rs$/, '');
-
-      // Skip lib.rs and main.rs as they're tested with --lib or --bin
-      if (modulePath === 'lib' || modulePath === 'main') {
-        return null;
-      }
-
-      // Convert file path to module path: src/foo/bar.rs -> foo::bar
-      modulePath = modulePath.replace(/\//g, '::');
-
-      // Remove 'mod' if it's a mod.rs file
-      modulePath = modulePath.replace(/::mod$/, '');
-
-      return modulePath;
-    }
-
-    return null;
-  }
-
-  async getRustCoverage(file) {
-    let versionProcess = null;
-    let coverageProcess = null;
-
-    try {
-      // Check if cargo-tarpaulin is available
-      const { exec } = await import('child_process');
-      const { promisify } = await import('util');
-      const execAsync = promisify(exec);
-
-      // Try to run tarpaulin for coverage with timeout
-      try {
-        versionProcess = await execAsync('cargo tarpaulin --version', {
-          timeout: 5000,
-          killSignal: 'SIGKILL'
-        });
-      } catch (error) {
-        if (versionProcess) {
-          try { process.kill(-versionProcess.pid, 'SIGKILL'); } catch {}
-        }
-        throw error;
-      }
-
-      if (versionProcess.stdout && versionProcess.stdout.includes('tarpaulin')) {
-        // Run coverage analysis with strict timeout
-        try {
-          coverageProcess = await execAsync('cargo tarpaulin --out Json --timeout 30', {
-            timeout: 60000,
-            maxBuffer: 1024 * 1024,
-            killSignal: 'SIGKILL'
-          });
-
-          const coverage = JSON.parse(coverageProcess.stdout);
-          return {
-            available: true,
-            percentage: coverage.coverage || 0,
-            lines: coverage.files || {},
-            tool: 'cargo-tarpaulin'
-          };
-        } catch (error) {
-          if (coverageProcess) {
-            try { process.kill(-coverageProcess.pid, 'SIGKILL'); } catch {}
-          }
-          throw error;
-        }
-      }
-    } catch (error) {
-      // Ensure all processes are killed
-      if (versionProcess) {
-        try { process.kill(-versionProcess.pid, 'SIGKILL'); } catch {}
-      }
-      if (coverageProcess) {
-        try { process.kill(-coverageProcess.pid, 'SIGKILL'); } catch {}
-      }
-
-      // Fallback: check if we can at least detect test presence
-      const cargoTomlExists = await this.fileExists('Cargo.toml');
-      return {
-        available: false,
-        error: cargoTomlExists
-          ? 'cargo-tarpaulin not installed - run: cargo install cargo-tarpaulin'
-          : 'Not a Rust project (no Cargo.toml)',
-        tool: 'cargo-tarpaulin'
-      };
-    }
-  }
-
-  async getJavaCoverage(file) {
-    return { error: 'Java coverage not implemented', available: false };
-  }
-
-  async getCCoverage(file) {
-    return { error: 'C/C++ coverage not implemented', available: false };
-  }
-
-  // TDD compliance checking
-  checkTDDCompliance(sourceFile, testFile, testResults) {
-    const compliance = {
-      hasTests: false,
-      testFirst: false,
-      redGreenRefactor: false,
-      coverage: 0,
-      recommendations: []
-    };
-
-    // Check if tests exist
-    if (testFile && this.fileExistsSync(testFile)) {
-      compliance.hasTests = true;
-    } else {
-      compliance.recommendations.push({
-        type: 'tdd_violation',
-        priority: 'high',
-        message: 'No test file found - TDD requires tests first',
-        action: `Create test file: ${this.suggestTestFileName(sourceFile)}`
-      });
-    }
-
-    // Check test results
-    if (testResults && testResults.summary) {
-      const { total, passed, failed } = testResults.summary;
-
-      if (total === 0) {
-        compliance.recommendations.push({
-          type: 'tdd_violation',
-          priority: 'high',
-          message: 'No tests found in test file',
-          action: 'Write tests before implementing functionality'
-        });
-      } else if (failed > 0) {
-        compliance.redGreenRefactor = true; // Red phase
-        compliance.recommendations.push({
-          type: 'tdd_red_phase',
-          priority: 'medium',
-          message: `${failed} failing tests - in RED phase of TDD`,
-          action: 'Implement minimal code to make tests pass'
-        });
-      } else if (passed > 0) {
-        compliance.redGreenRefactor = true; // Green phase
-        compliance.recommendations.push({
-          type: 'tdd_green_phase',
-          priority: 'low',
-          message: 'All tests passing - in GREEN phase of TDD',
-          action: 'Consider refactoring for better design'
-        });
-      }
-    }
-
-    return compliance;
-  }
-
-  // Utility methods
-  isTestFile(file) {
-    const fileName = path.basename(file);
-    return fileName.includes('.test.') ||
-           fileName.includes('.spec.') ||
-           fileName.includes('_test') ||
-           fileName.endsWith('Test.java') ||
-           fileName.endsWith('Test.cpp') ||
-           file.includes('/test/') ||
-           file.includes('/tests/');
-  }
-
-  findTestFile(sourceFile) {
-    const ext = path.extname(sourceFile);
-    const base = path.basename(sourceFile, ext);
-    const dir = path.dirname(sourceFile);
-
-    const testPatterns = [
-      `${base}.test${ext}`,
-      `${base}.spec${ext}`,
-      `${base}_test${ext}`,
-      `test_${base}${ext}`,
-      `${base}Test${ext}`
-    ];
-
-    // Check same directory first
-    for (const pattern of testPatterns) {
-      const testPath = path.join(dir, pattern);
-      if (this.fileExistsSync(testPath)) return testPath;
-    }
-
-    // Check test directories
-    const testDirs = ['test', 'tests', '__tests__', 'spec'];
-    for (const testDir of testDirs) {
-      for (const pattern of testPatterns) {
-        const testPath = path.join(dir, testDir, pattern);
-        if (this.fileExistsSync(testPath)) return testPath;
-      }
-    }
-
-    return null;
-  }
-
-  findSourceFile(testFile) {
-    const ext = path.extname(testFile);
-    let base = path.basename(testFile, ext);
-
-    // Remove test suffixes
-    base = base.replace(/\.(test|spec)$/, '')
-                .replace(/_test$/, '')
-                .replace(/^test_/, '')
-                .replace(/Test$/, '');
-
-    const dir = path.dirname(testFile);
-    const sourcePatterns = [
-      `${base}${ext}`,
-      `${base}.js`,
-      `${base}.ts`,
-      `${base}.py`,
-      `${base}.go`,
-      `${base}.rs`,
-      `${base}.java`,
-      `${base}.cpp`,
-      `${base}.c`
-    ];
-
-    // Check parent directory (if in test folder)
-    const parentDir = path.dirname(dir);
-    for (const pattern of sourcePatterns) {
-      const sourcePath = path.join(parentDir, pattern);
-      if (this.fileExistsSync(sourcePath)) return sourcePath;
-    }
-
-    // Check same directory
-    for (const pattern of sourcePatterns) {
-      const sourcePath = path.join(dir, pattern);
-      if (this.fileExistsSync(sourcePath)) return sourcePath;
-    }
-
-    return null;
-  }
-
-  suggestTestFileName(sourceFile) {
-    const ext = path.extname(sourceFile);
-    const base = path.basename(sourceFile, ext);
-    const dir = path.dirname(sourceFile);
-
-    // Language-specific conventions
-    if (['.js', '.jsx', '.ts', '.tsx'].includes(ext)) {
-      return path.join(dir, `${base}.test${ext}`);
-    } else if (ext === '.py') {
-      return path.join(dir, `test_${base}${ext}`);
-    } else if (ext === '.go') {
-      return path.join(dir, `${base}_test${ext}`);
-    } else if (ext === '.java') {
-      return path.join(dir, `${base}Test${ext}`);
-    } else {
-      return path.join(dir, `${base}_test${ext}`);
-    }
-  }
-
-  calculatePercentage(coverage, isBranch = false) {
-    if (!coverage) return 0;
-
-    const values = isBranch ? Object.values(coverage).flat() : Object.values(coverage);
-    const total = values.length;
-    const covered = values.filter(v => v > 0).length;
-
-    return total > 0 ? Math.round((covered / total) * 100) : 0;
-  }
-
-  fileExistsSync(filePath) {
-    try {
-      return fs.access(filePath, fs.constants.F_OK).then(() => true).catch(() => false);
-    } catch {
-      return false;
-    }
-  }
-
-  async fileExists(filePath) {
-    try {
-      await fs.access(filePath, fs.constants.F_OK);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-}
-
-// Enhanced validation engine
-class ValidationEngine {
-  constructor() {
-    this.validators = {
-      '.js': this.validateJavaScript.bind(this),
-      '.jsx': this.validateJavaScript.bind(this),
-      '.ts': this.validateTypeScript.bind(this),
-      '.tsx': this.validateTypeScript.bind(this),
-      '.json': this.validateJSON.bind(this),
-      '.py': this.validatePython.bind(this),
-      '.go': this.validateGo.bind(this),
-      '.rs': this.validateRust.bind(this),
-      '.java': this.validateJava.bind(this),
-      '.cpp': this.validateCPP.bind(this),
-      '.c': this.validateC.bind(this)
-    };
-  }
-
-  async validate(file, content) {
-    const ext = path.extname(file).toLowerCase();
-    const validator = this.validators[ext];
-
-    if (!validator) {
-      return {
-        passed: true,
-        issues: [],
-        suggestions: [`No specific validator for ${ext} files`],
-        coverage: 'basic'
-      };
-    }
-
-    return await validator(file, content);
-  }
-
-  async validateJavaScript(file, content) {
-    const issues = [];
-    const suggestions = [];
-
-    try {
-      // Detect workspace root for linting and formatting
-      const workspaceRoot = await findWorkspaceRoot(file, 'package.json');
-
-      if (workspaceRoot) {
-        Logger.debug(`Workspace root detected: ${workspaceRoot}`);
-      } else {
-        Logger.warning('No workspace root found (package.json not found within 10 levels)');
-        suggestions.push('No package.json found - linting and formatting may be skipped');
-      }
-
-      // Basic syntax validation using Node.js VM
-      const { createContext, runInContext } = await import('vm');
-      const context = createContext({});
-
-      // Wrap in function to avoid top-level issues
-      const wrappedCode = `(function() { ${content} })`;
-      runInContext(wrappedCode, context);
-
-      // Advanced static analysis
-      const analysis = this.analyzeJavaScript(content);
-      issues.push(...analysis.issues);
-      suggestions.push(...analysis.suggestions);
-
-      // Run Prettier if workspace found
-      if (workspaceRoot) {
-        const prettierResult = await this.runPrettier(file, content, workspaceRoot);
-        if (prettierResult && prettierResult.issues) {
-          issues.push(...prettierResult.issues);
-        }
-        if (prettierResult && prettierResult.suggestions) {
-          suggestions.push(...prettierResult.suggestions);
-        }
-      }
-
-      // Run ESLint if workspace found
-      if (workspaceRoot) {
-        const eslintResult = await this.runESLint(file, content, workspaceRoot);
-        if (eslintResult && eslintResult.issues) {
-          issues.push(...eslintResult.issues);
-        }
-        if (eslintResult && eslintResult.suggestions) {
-          suggestions.push(...eslintResult.suggestions);
-        }
-      }
-
-      return {
-        passed: issues.filter(i => i.severity === 'error').length === 0,
-        issues,
-        suggestions,
-        coverage: 'advanced',
-        metrics: analysis.metrics,
-        workspaceRoot
-      };
-    } catch (error) {
-      return {
-        passed: false,
-        issues: [{
-          type: 'syntax_error',
-          severity: 'error',
-          message: error.message,
-          line: this.extractLineNumber(error.message),
-          column: this.extractColumnNumber(error.message)
-        }],
-        suggestions: [
-          'Fix syntax error before proceeding',
-          'Check for missing brackets, semicolons, or quotes'
-        ],
-        coverage: 'syntax_only'
-      };
-    }
-  }
-
-  async runPrettier(file, content, workspaceRoot) {
-    try {
-      // Gracefully handle missing Prettier
-      const { execSync } = await import('child_process');
-      execSync('npx prettier --version', { stdio: 'ignore', cwd: workspaceRoot, timeout: 5000 });
-
-      const result = execSync(`npx prettier --check "${file}"`, {
-        cwd: workspaceRoot,
-        encoding: 'utf8',
-        stdio: 'pipe',
-        timeout: 10000
-      });
-
-      return { issues: [], suggestions: ['Code formatting is consistent with Prettier'] };
-    } catch (error) {
-      if (error.message && error.message.includes('not found')) {
-        return { issues: [], suggestions: ['Prettier not installed - skipping formatting check'] };
-      }
-
-      return {
-        issues: [{
-          type: 'formatting',
-          severity: 'warning',
-          message: 'Prettier formatting check failed',
-          suggestion: 'Run prettier to fix formatting'
-        }],
-        suggestions: [`Run: npx prettier --write "${file}"`]
-      };
-    }
-  }
-
-  async runESLint(file, content, workspaceRoot) {
-    try {
-      // Gracefully handle missing ESLint
-      const { execSync } = await import('child_process');
-      execSync('npx eslint --version', { stdio: 'ignore', cwd: workspaceRoot, timeout: 5000 });
-
-      const result = execSync(`npx eslint "${file}" --format json`, {
-        cwd: workspaceRoot,
-        encoding: 'utf8',
-        stdio: 'pipe',
-        timeout: 10000
-      });
-
-      const eslintResults = JSON.parse(result);
-      const fileResults = eslintResults[0] || { messages: [] };
-
-      const issues = fileResults.messages.map(msg => ({
-        type: 'eslint',
-        severity: msg.severity === 2 ? 'error' : 'warning',
-        message: msg.message,
-        line: msg.line,
-        column: msg.column,
-        rule: msg.ruleId
-      }));
-
-      return { issues, suggestions: issues.length ? ['Run ESLint to fix linting issues'] : [] };
-    } catch (error) {
-      if (error.message && error.message.includes('not found')) {
-        return { issues: [], suggestions: ['ESLint not installed - skipping linting check'] };
-      }
-
-      return { issues: [], suggestions: ['ESLint check skipped'] };
-    }
-  }
-
-  async validateTypeScript(file, content) {
-    // Similar to JavaScript but with TypeScript-specific checks
-    const jsResult = await this.validateJavaScript(file, content);
-
-    // Add TypeScript-specific analysis
-    const tsIssues = this.analyzeTypeScript(content);
-
-    return {
-      ...jsResult,
-      issues: [...jsResult.issues, ...tsIssues.issues],
-      suggestions: [...jsResult.suggestions, ...tsIssues.suggestions],
-      coverage: 'typescript'
-    };
-  }
-
-  async validateJSON(file, content) {
-    try {
-      JSON.parse(content);
-      return {
-        passed: true,
-        issues: [],
-        suggestions: ['JSON structure is valid'],
-        coverage: 'complete'
-      };
-    } catch (error) {
-      return {
-        passed: false,
-        issues: [{
-          type: 'json_parse_error',
-          severity: 'error',
-          message: error.message,
-          line: this.extractLineNumber(error.message),
-          column: this.extractColumnNumber(error.message)
-        }],
-        suggestions: [
-          'Fix JSON syntax error',
-          'Check for trailing commas, missing quotes, or invalid escape sequences'
-        ],
-        coverage: 'syntax_only'
-      };
-    }
-  }
-
-  async validatePython(file, content) {
-    // Simulate Python validation
-    const issues = [];
-    const suggestions = [];
-
-    // Basic checks
-    if (content.includes('print ') && !content.includes('print(')) {
-      issues.push({
-        type: 'python_version',
-        severity: 'warning',
-        message: 'Using Python 2 print statement syntax',
-        suggestion: 'Use print() function for Python 3 compatibility'
-      });
-    }
-
-    if (!content.includes('import') && content.length > 100) {
-      suggestions.push('Consider importing required modules');
-    }
-
-    return {
-      passed: issues.filter(i => i.severity === 'error').length === 0,
-      issues,
-      suggestions: suggestions.length ? suggestions : ['Python syntax appears valid'],
-      coverage: 'basic'
-    };
-  }
-
-  async validateGo(file, content) {
-    const issues = [];
-    const suggestions = [];
-
-    if (!content.includes('package ')) {
-      issues.push({
-        type: 'go_package',
-        severity: 'error',
-        message: 'Go files must declare a package',
-        suggestion: 'Add package declaration at the top of the file'
-      });
-    }
-
-    return {
-      passed: issues.filter(i => i.severity === 'error').length === 0,
-      issues,
-      suggestions: suggestions.length ? suggestions : ['Go syntax appears valid'],
-      coverage: 'basic'
-    };
-  }
-
-  async validateRust(file, content) {
-    const issues = [];
-    const suggestions = [];
-
-    try {
-      // Detect workspace root for Cargo commands
-      const workspaceRoot = await findWorkspaceRoot(file, 'Cargo.toml');
-
-      if (workspaceRoot) {
-        Logger.debug(`Rust workspace root detected: ${workspaceRoot}`);
-        suggestions.push('Rust syntax validation deferred to cargo test (performance optimization)');
-
-        // Run cargo clippy from workspace root if available
-        const clippyResult = await this.runCargoClippy(file, workspaceRoot);
-        if (clippyResult && clippyResult.issues) {
-          issues.push(...clippyResult.issues);
-        }
-        if (clippyResult && clippyResult.suggestions) {
-          suggestions.push(...clippyResult.suggestions);
-        }
-      } else {
-        Logger.warning('No Cargo workspace found (Cargo.toml not found within 10 levels)');
-        suggestions.push('Not in a Cargo project - create Cargo.toml for full validation');
-      }
-
-      // Basic content checks (fast static analysis)
-      if (!content.includes('fn ') && !content.includes('struct ') && !content.includes('enum ') && !content.includes('impl ')) {
-        issues.push({
-          type: 'rust_structure',
-          severity: 'warning',
-          message: 'Rust files typically contain functions, structs, enums, or implementations',
-          suggestion: 'Add appropriate Rust code structure'
-        });
-      }
-
-      // Check for common Rust anti-patterns (static analysis)
-      if (content.includes('unwrap()')) {
-        suggestions.push('Consider using proper error handling instead of unwrap()');
-      }
-
-      if (content.includes('clone()') && content.split('clone()').length > 3) {
-        suggestions.push('Excessive use of clone() - consider borrowing or references');
-      }
-
-      // Check for unsafe blocks
-      if (content.includes('unsafe ')) {
-        suggestions.push('Unsafe block detected - ensure safety invariants are documented');
-      }
-
-      // Check for panic macros
-      if (content.includes('panic!') || content.includes('unimplemented!') || content.includes('todo!')) {
-        suggestions.push('Panic macros detected - consider error handling alternatives');
-      }
-
-      return {
-        passed: issues.filter(i => i.severity === 'error').length === 0,
-        issues,
-        suggestions,
-        coverage: 'fast-static-analysis',
-        optimized: true,
-        workspaceRoot
-      };
-
-    } catch (error) {
-      return {
-        passed: true,
-        issues: [{
-          type: 'validation_error',
-          severity: 'warning',
-          message: `Rust validation error: ${error.message}`,
-          suggestion: 'Manual review recommended'
-        }],
-        suggestions: ['Rust validation encountered an error'],
-        coverage: 'basic'
-      };
-    }
-  }
-
-  async runCargoClippy(file, workspaceRoot) {
-    try {
-      // Gracefully handle missing clippy
-      const { execSync } = await import('child_process');
-      execSync('cargo clippy --version', { stdio: 'ignore', cwd: workspaceRoot, timeout: 5000 });
-
-      // Run clippy with JSON output for parsing
-      const result = execSync('cargo clippy --message-format=json -- -W clippy::all', {
-        cwd: workspaceRoot,
-        encoding: 'utf8',
-        stdio: 'pipe',
-        timeout: 30000
-      });
-
-      // Parse clippy JSON output
-      const lines = result.split('\n').filter(line => line.trim());
-      const issues = [];
-
-      for (const line of lines) {
-        try {
-          const msg = JSON.parse(line);
-          if (msg.reason === 'compiler-message' && msg.message) {
-            const clippyMsg = msg.message;
-            issues.push({
-              type: 'clippy',
-              severity: clippyMsg.level === 'error' ? 'error' : 'warning',
-              message: clippyMsg.message,
-              line: clippyMsg.spans[0]?.line_start,
-              column: clippyMsg.spans[0]?.column_start,
-              code: clippyMsg.code?.code
-            });
-          }
-        } catch {
-          // Skip invalid JSON lines
-        }
-      }
-
-      return { issues, suggestions: issues.length ? ['Run cargo clippy to fix linting issues'] : [] };
-    } catch (error) {
-      if (error.message && error.message.includes('not found')) {
-        return { issues: [], suggestions: ['Clippy not installed - skipping linting check'] };
-      }
-
-      return { issues: [], suggestions: ['Clippy check skipped'] };
-    }
-  }
-
-  async validateJava(file, content) {
-    const issues = [];
-
-    if (!content.includes('class ') && !content.includes('interface ') && !content.includes('enum ')) {
-      issues.push({
-        type: 'java_structure',
-        severity: 'warning',
-        message: 'Java files typically contain a class, interface, or enum',
-        suggestion: 'Add appropriate Java structure'
-      });
-    }
-
-    return {
-      passed: true,
-      issues,
-      suggestions: ['Java syntax appears valid'],
-      coverage: 'basic'
-    };
-  }
-
-  async validateCPP(file, content) {
-    return {
-      passed: true,
-      issues: [],
-      suggestions: ['C++ validation requires compiler for complete analysis'],
-      coverage: 'basic'
-    };
-  }
-
-  async validateC(file, content) {
-    return {
-      passed: true,
-      issues: [],
-      suggestions: ['C validation requires compiler for complete analysis'],
-      coverage: 'basic'
-    };
-  }
-
-  analyzeJavaScript(content) {
-    const issues = [];
-    const suggestions = [];
-    const metrics = {
-      lines: content.split('\n').length,
-      functions: (content.match(/function\s+\w+/g) || []).length,
-      classes: (content.match(/class\s+\w+/g) || []).length,
-      complexity: 'low'
-    };
-
-    // Check for security issues
-    if (content.includes('eval(')) {
-      issues.push({
-        type: 'security',
-        severity: 'critical',
-        message: 'Use of eval() function detected - security risk',
-        line: this.findLineNumber(content, 'eval('),
-        column: 23,
-        code: 'return eval(userInput);',
-        suggestion: 'Replace eval() with safer alternatives'
-      });
-    }
-
-    if (content.includes('password') && content.includes('console.log')) {
-      issues.push({
-        type: 'security',
-        severity: 'critical',
-        message: 'Potential password logging detected',
-        suggestion: 'Remove password logging from production code'
-      });
-    }
-
-    // Check for common issues
-    if (content.includes('var ')) {
-      issues.push({
-        type: 'deprecated_var',
-        severity: 'warning',
-        message: 'Use const or let instead of var',
-        suggestion: 'Replace var with const or let for better scoping'
-      });
-    }
-
-    if (content.includes('==') && !content.includes('===')) {
-      issues.push({
-        type: 'loose_equality',
-        severity: 'warning',
-        message: 'Use strict equality (===) instead of loose equality (==)',
-        suggestion: 'Replace == with === for type-safe comparisons'
-      });
-    }
-
-    if (metrics.lines > 100) {
-      suggestions.push('Consider breaking large files into smaller modules');
-      metrics.complexity = 'medium';
-    }
-
-    return { issues, suggestions, metrics };
-  }
-
-  analyzeTypeScript(content) {
-    const issues = [];
-    const suggestions = [];
-
-    if (content.includes(': any')) {
-      issues.push({
-        type: 'typescript_any',
-        severity: 'warning',
-        message: 'Avoid using "any" type when possible',
-        suggestion: 'Use specific types or unknown for better type safety'
-      });
-    }
-
-    if (!content.includes('interface') && !content.includes('type ') && content.length > 200) {
-      suggestions.push('Consider defining interfaces or types for better code structure');
-    }
-
-    return { issues, suggestions };
-  }
-
-  findLineNumber(content, searchText) {
-    const lines = content.split('\n');
-    for (let i = 0; i < lines.length; i++) {
-      if (lines[i].includes(searchText)) {
-        return i + 1;
-      }
-    }
-    return null;
-  }
-
-  extractLineNumber(errorMessage) {
-    const match = errorMessage.match(/line (\d+)/i);
-    return match ? parseInt(match[1]) : null;
-  }
-
-  extractColumnNumber(errorMessage) {
-    const match = errorMessage.match(/column (\d+)/i);
-    return match ? parseInt(match[1]) : null;
-  }
-
-  async fileExists(filePath) {
-    try {
-      await fs.access(filePath, fs.constants.F_OK);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-}
-
-// Enhanced formatting engine with diff preview
-class FormattingEngine {
-  constructor() {
-    this.formatters = {
-      '.js': { command: 'prettier', args: ['--parser', 'babel'] },
-      '.jsx': { command: 'prettier', args: ['--parser', 'babel'] },
-      '.ts': { command: 'prettier', args: ['--parser', 'typescript'] },
-      '.tsx': { command: 'prettier', args: ['--parser', 'typescript'] },
-      '.json': { command: 'prettier', args: ['--parser', 'json'] },
-      '.css': { command: 'prettier', args: ['--parser', 'css'] },
-      '.html': { command: 'prettier', args: ['--parser', 'html'] },
-      '.py': { command: 'black', args: ['-'] },
-      '.go': { command: 'gofmt', args: [] },
-      '.rs': { command: 'rustfmt', args: [] },
-      '.java': { command: 'google-java-format', args: ['-'] },
-      '.cpp': { command: 'clang-format', args: [] },
-      '.c': { command: 'clang-format', args: [] }
-    };
-  }
-
-  async analyzeFormatting(file, content) {
-    const ext = path.extname(file).toLowerCase();
-    const formatter = this.formatters[ext];
-
-    if (!formatter) {
-      return {
-        needed: false,
-        changes: 0,
-        formatter: null,
-        preview: null,
-        suggestion: `No formatter available for ${ext} files`
-      };
-    }
-
-    try {
-      // Simulate formatting analysis
-      const analysis = this.simulateFormatting(content, ext);
-
-      return {
-        needed: analysis.changes > 0,
-        changes: analysis.changes,
-        formatter: formatter.command,
-        preview: analysis.preview,
-        suggestion: analysis.changes > 0
-          ? `Run ${formatter.command} to fix ${analysis.changes} formatting issues`
-          : 'Code formatting looks good'
-      };
-    } catch (error) {
-      return {
-        needed: false,
-        changes: 0,
-        formatter: formatter.command,
-        preview: null,
-        suggestion: `Formatting analysis failed: ${error.message}`
-      };
-    }
-  }
-
-  simulateFormatting(content, ext) {
-    let changes = 0;
-    const issues = [];
-
-    // Simulate common formatting issues
-    const lines = content.split('\n');
-
-    lines.forEach((line, index) => {
-      // Check for trailing whitespace
-      if (line.match(/\s+$/)) {
-        changes++;
-        issues.push(`Line ${index + 1}: Remove trailing whitespace`);
-      }
-
-      // Check for inconsistent indentation (basic check)
-      if (line.match(/^\t+ +/) || line.match(/^ +\t/)) {
-        changes++;
-        issues.push(`Line ${index + 1}: Mixed tabs and spaces`);
-      }
-
-      // Language-specific checks
-      if (['.js', '.jsx', '.ts', '.tsx'].includes(ext)) {
-        if (line.includes('  ;') || line.includes(' ;')) {
-          changes++;
-          issues.push(`Line ${index + 1}: Extra space before semicolon`);
-        }
-
-        if (line.includes('(){') && !line.includes('() {')) {
-          changes++;
-          issues.push(`Line ${index + 1}: Missing space before opening brace`);
-        }
-      }
-    });
-
-    const preview = issues.slice(0, 5).join('\n');
-
-    return {
-      changes,
-      preview: preview || 'No formatting issues detected',
-      issues
-    };
-  }
-}
-
-// Enhanced recommendations engine
-class RecommendationsEngine {
-  constructor() {
-    this.rules = [
-      this.securityRecommendations.bind(this),
-      this.performanceRecommendations.bind(this),
-      this.maintainabilityRecommendations.bind(this),
-      this.testingRecommendations.bind(this),
-      this.documentationRecommendations.bind(this)
-    ];
-  }
-
-  async generateRecommendations(file, content, validation, formatting) {
-    const recommendations = [];
-
-    // Run all recommendation rules
-    for (const rule of this.rules) {
-      const ruleRecommendations = await rule(file, content, validation, formatting);
-      recommendations.push(...ruleRecommendations);
-    }
-
-    // Add context-specific recommendations
-    const contextRecommendations = this.getContextualRecommendations(file, validation, formatting);
-    recommendations.push(...contextRecommendations);
-
-    return recommendations.slice(0, 10); // Limit to top 10
-  }
-
-  async securityRecommendations(file, content, validation, formatting) {
-    const recommendations = [];
-
-    if (content.includes('eval(') || content.includes('new Function(')) {
-      recommendations.push({
-        type: 'security',
-        priority: 'high',
-        message: 'Address security vulnerabilities immediately',
-        action: 'Move hardcoded credentials to environment variables'
-      });
-    }
-
-    if (content.includes('innerHTML') && content.includes('+')) {
-      recommendations.push({
-        type: 'security',
-        priority: 'medium',
-        message: 'Potential XSS vulnerability with innerHTML',
-        action: 'Use textContent or proper sanitization'
-      });
-    }
-
-    return recommendations;
-  }
-
-  async performanceRecommendations(file, content, validation, formatting) {
-    const recommendations = [];
-
-    if (content.includes('document.querySelector') && content.split('document.querySelector').length > 3) {
-      recommendations.push({
-        type: 'performance',
-        priority: 'medium',
-        message: 'Optimize performance bottlenecks',
-        action: 'Replace synchronous operations with asynchronous alternatives'
-      });
-    }
-
-    return recommendations;
-  }
-
-  async maintainabilityRecommendations(file, content, validation, formatting) {
-    const recommendations = [];
-
-    const lines = content.split('\n').length;
-    if (lines > 200) {
-      recommendations.push({
-        type: 'maintainability',
-        priority: 'medium',
-        message: `File has ${lines} lines - consider breaking it down`,
-        action: 'Split into smaller, focused modules'
-      });
-    }
-
-    return recommendations;
-  }
-
-  async testingRecommendations(file, content, validation, formatting) {
-    const recommendations = [];
-
-    if (!file.includes('test') && !file.includes('spec')) {
-      if (content.includes('function ') || content.includes('class ')) {
-        recommendations.push({
-          type: 'testing',
-          priority: 'medium',
-          message: 'Consider writing tests for this module',
-          action: 'Create corresponding test file'
-        });
-      }
-    }
-
-    return recommendations;
-  }
-
-  async documentationRecommendations(file, content, validation, formatting) {
-    const recommendations = [];
-
-    if (content.includes('export ') && !content.includes('/**')) {
-      recommendations.push({
-        type: 'documentation',
-        priority: 'low',
-        message: 'Public exports could benefit from JSDoc comments',
-        action: 'Add JSDoc documentation for exported functions/classes'
-      });
-    }
-
-    return recommendations;
-  }
-
-  getContextualRecommendations(file, validation, formatting) {
-    const recommendations = [];
-
-    // Validation-based recommendations
-    if (!validation.passed) {
-      recommendations.push({
-        type: 'immediate',
-        priority: 'high',
-        message: 'Fix validation errors before proceeding',
-        action: 'Address syntax or structural issues'
-      });
-    }
-
-    // Formatting-based recommendations
-    if (formatting.needed && formatting.changes > 5) {
-      recommendations.push({
-        type: 'formatting',
-        priority: 'medium',
-        message: `Run ${formatting.formatter} to fix ${formatting.changes} formatting issues`,
-        action: `Execute: ${formatting.formatter} ${file}`
-      });
-    }
-
-    return recommendations;
-  }
-}
-
-// Enhanced memory store with structured data
-class EnhancedMemoryStore {
-  constructor() {
-    this.memoryDir = path.join(process.cwd(), '.swarm');
-    this.memoryFile = path.join(this.memoryDir, 'enhanced-memory.json');
-    this.data = new Map();
-  }
-
-  async initialize() {
-    try {
-      await fs.mkdir(this.memoryDir, { recursive: true });
-
-      try {
-        const content = await fs.readFile(this.memoryFile, 'utf8');
-        const parsed = JSON.parse(content);
-        this.data = new Map(Object.entries(parsed));
-        Logger.info(`Enhanced memory store loaded (${this.data.size} entries)`);
-      } catch {
-        Logger.info('Initializing new enhanced memory store...');
-      }
-    } catch (error) {
-      Logger.warning(`Enhanced memory store init warning: ${error.message}`);
-    }
-  }
-
-  async store(key, value, options = {}) {
-    const entry = {
-      value,
-      options,
-      timestamp: new Date().toISOString(),
-      namespace: options.namespace || 'default',
-      metadata: options.metadata || {},
-      version: '2.0.0-enhanced'
-    };
-
-    this.data.set(key, entry);
-    await this.persist();
-    return entry;
-  }
-
-  async retrieve(key, options = {}) {
-    const entry = this.data.get(key);
-    if (!entry) return null;
-
-    if (options.namespace && entry.namespace !== options.namespace) {
-      return null;
-    }
-
-    return entry.value;
-  }
-
-  async persist() {
-    try {
-      const dataObj = Object.fromEntries(this.data);
-      await fs.writeFile(this.memoryFile, JSON.stringify(dataObj, null, 2));
-    } catch (error) {
-      Logger.warning(`Enhanced memory persist warning: ${error.message}`);
-    }
-  }
-
-  close() {
-    this.persist().catch(() => {});
-  }
-}
-
-// Main enhanced post-edit hook with TDD integration
-export async function enhancedPostEditHook(file, memoryKey = null, options = {}) {
-  const {
-    format = true,
-    validate = true,
-    generateRecommendations = true,
-    blockOnCritical = false,
-    enableTDD = true,
-    minimumCoverage = 80,
-    returnStructured = true
-  } = options;
-
-  console.log(`🚀 Enhanced Post-Edit Hook Starting...`);
-  console.log(`📄 File: ${file}`);
-  if (memoryKey) console.log(`💾 Memory key: ${memoryKey}`);
-
-  const result = {
-    success: false,
-    editId: `edit-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
-    file,
-    memoryKey,
-    timestamp: new Date().toISOString(),
-    validation: null,
-    formatting: null,
-    testing: null,
-    coverage: null,
-    tddCompliance: null,
-    tddPhase: 'unknown',
-    recommendations: [],
-    memory: { stored: false },
-    logs: [],
-    blocking: false
-  };
-
-  try {
-    // Initialize components
-    const store = new EnhancedMemoryStore();
-    await store.initialize();
-
-    const validator = new ValidationEngine();
-    const formatter = new FormattingEngine();
-    const recommender = new RecommendationsEngine();
-    const testEngine = enableTDD ? new SingleFileTestEngine() : null;
-
-    // Check if file exists
-    let content = '';
-    try {
-      content = await fs.readFile(file, 'utf8');
-    } catch (error) {
-      result.logs.push(Logger.error(`Cannot read file: ${error.message}`));
-      result.validation = {
-        passed: false,
-        issues: [{ type: 'file_access', severity: 'error', message: `Cannot read file: ${error.message}` }],
-        suggestions: ['Ensure file exists and is readable'],
-        coverage: 'none'
-      };
-
-      if (returnStructured) {
-        return result;
-      } else {
-        console.log(JSON.stringify(result, null, 2));
-        return;
-      }
-    }
-
-    // 1. Validation
-    if (validate) {
-      result.logs.push(Logger.info('Running enhanced validation...'));
-      result.validation = await validator.validate(file, content);
-
-      const errorCount = result.validation.issues.filter(i => i.severity === 'error').length;
-      const warningCount = result.validation.issues.filter(i => i.severity === 'warning').length;
-
-      if (result.validation.passed) {
-        result.logs.push(Logger.success(`Validation passed (${warningCount} warnings)`));
-      } else {
-        result.logs.push(Logger.error(`Validation failed (${errorCount} errors, ${warningCount} warnings)`));
-
-        if (blockOnCritical && errorCount > 0) {
-          result.blocking = true;
-          result.logs.push(Logger.error('BLOCKING: Critical validation errors must be fixed'));
-        }
-      }
-    }
-
-    // 2. Formatting analysis
-    if (format) {
-      result.logs.push(Logger.info('Analyzing formatting...'));
-      result.formatting = await formatter.analyzeFormatting(file, content);
-
-      if (result.formatting.needed) {
-        result.logs.push(Logger.warning(`Formatting needed: ${result.formatting.changes} changes`));
-      } else {
-        result.logs.push(Logger.success('Formatting looks good'));
-      }
-    }
-
-    // 3. TDD Testing (if enabled)
-    if (enableTDD && testEngine) {
-      result.logs.push(Logger.test('Executing TDD tests...'));
-      result.testing = await testEngine.executeTests(file, content);
-
-      if (result.testing.executed) {
-        result.logs.push(Logger.success(`Tests executed with ${result.testing.framework}`));
-
-        if (result.testing.results) {
-          const { total, passed, failed } = result.testing.results.summary;
-          result.logs.push(Logger.test(`Test results: ${passed}/${total} passed, ${failed} failed`));
-
-          // Determine TDD phase
-          if (failed > 0) {
-            result.tddPhase = 'red';
-            result.logs.push(Logger.tdd('TDD Phase: RED (failing tests)'));
-          } else if (passed > 0) {
-            result.tddPhase = 'green';
-            result.logs.push(Logger.tdd('TDD Phase: GREEN (passing tests)'));
-          }
-        }
-
-        // Coverage analysis
-        if (result.testing.coverage) {
-          result.coverage = result.testing.coverage;
-
-          if (result.coverage.lines) {
-            const coveragePercent = result.coverage.lines.percentage;
-            result.logs.push(Logger.coverage(`Line coverage: ${coveragePercent}%`));
-
-            if (coveragePercent < minimumCoverage) {
-              result.logs.push(Logger.warning(`Coverage below minimum (${minimumCoverage}%)`));
-            }
-          }
-        }
-
-        // TDD compliance
-        result.tddCompliance = result.testing.tddCompliance;
-      } else {
-        result.logs.push(Logger.warning(`Tests not executed: ${result.testing.reason}`));
-      }
-    }
-
-    // 4. Generate recommendations
-    if (generateRecommendations) {
-      result.logs.push(Logger.info('Generating recommendations...'));
-      result.recommendations = await recommender.generateRecommendations(
-        file, content, result.validation, result.formatting
-      );
-
-      // Add TDD-specific recommendations
-      if (result.tddCompliance) {
-        result.recommendations.push(...result.tddCompliance.recommendations);
-
-        // Add coverage recommendations
-        if (result.coverage && result.coverage.lines) {
-          const coverage = result.coverage.lines.percentage;
-
-          if (coverage < minimumCoverage) {
-            result.recommendations.push({
-              type: 'coverage',
-              priority: 'medium',
-              message: `Increase test coverage from ${coverage}% to ${minimumCoverage}%`,
-              action: 'Add tests for uncovered lines and branches'
-            });
-          }
-        }
-
-        // Add phase-specific recommendations
-        if (result.tddPhase === 'red') {
-          result.recommendations.push({
-            type: 'tdd_red',
-            priority: 'high',
-            message: 'TDD RED phase - implement minimal code to pass tests',
-            action: 'Write just enough code to make failing tests pass'
-          });
-        } else if (result.tddPhase === 'green') {
-          result.recommendations.push({
-            type: 'tdd_green',
-            priority: 'low',
-            message: 'TDD GREEN phase - consider refactoring',
-            action: 'Improve code design while keeping tests green'
-          });
-        }
-      }
-
-      const highPriority = result.recommendations.filter(r => r.priority === 'high').length;
-      result.logs.push(Logger.info(`Generated ${result.recommendations.length} recommendations (${highPriority} high priority)`));
-    }
-
-    // 5. Store in memory
-    const memoryData = {
-      editId: result.editId,
-      file,
-      timestamp: result.timestamp,
-      validation: result.validation,
-      formatting: result.formatting,
-      testing: result.testing,
-      coverage: result.coverage,
-      tddCompliance: result.tddCompliance,
-      tddPhase: result.tddPhase,
-      recommendations: result.recommendations,
-      enhanced: true,
-      version: '2.0.0-enhanced-tdd'
-    };
-
-    await store.store(`edit:${result.editId}`, memoryData, {
-      namespace: 'enhanced-edits',
-      metadata: {
-        hookType: 'enhanced-post-edit',
-        file,
-        passed: result.validation?.passed || false,
-        changes: result.formatting?.changes || 0,
-        hasTests: result.tddCompliance?.hasTests || false,
-        coverage: result.coverage?.lines?.percentage || 0,
-        tddPhase: result.tddPhase
-      }
-    });
-
-    if (memoryKey) {
-      await store.store(memoryKey, memoryData, { namespace: 'coordination' });
-    }
-
-    result.memory.stored = true;
-    result.memory.enhancedStore = true;
-    result.logs.push(Logger.success('Data stored in enhanced memory'));
-
-    // 6. Final status
-    result.success = !result.blocking;
-
-    if (result.success) {
-      result.logs.push(Logger.success('Enhanced post-edit hook completed successfully'));
-    } else {
-      result.logs.push(Logger.error('Hook completed with blocking issues'));
-    }
-
-    store.close();
-
-    // Return structured data or print results
-    if (returnStructured) {
-      return result;
-    } else {
-      // Pretty print for console output
-      console.log('\n📊 ENHANCED POST-EDIT RESULTS:');
-      console.log(`   Status: ${result.success ? '✅ SUCCESS' : '❌ BLOCKED'}`);
-      console.log(`   Edit ID: ${result.editId}`);
-
-      if (enableTDD) {
-        console.log(`   TDD Phase: ${result.tddPhase.toUpperCase()}`);
-
-        if (result.testing && result.testing.executed) {
-          const { total, passed, failed } = result.testing.results.summary;
-          console.log(`   Tests: ${passed}/${total} passed, ${failed} failed`);
-        }
-
-        if (result.coverage && result.coverage.lines) {
-          console.log(`   Coverage: ${result.coverage.lines.percentage}%`);
-        }
-      }
-
-      if (result.validation) {
-        console.log(`   Validation: ${result.validation.passed ? '✅ PASSED' : '❌ FAILED'}`);
-      }
-
-      if (result.formatting) {
-        console.log(`   Formatting: ${result.formatting.needed ? `⚠️ ${result.formatting.changes} changes needed` : '✅ Good'}`);
-      }
-
-      console.log(`   Recommendations: ${result.recommendations.length}`);
-
-      if (result.recommendations.length > 0) {
-        console.log('\n💡 TOP RECOMMENDATIONS:');
-        result.recommendations.slice(0, 3).forEach((rec, i) => {
-          console.log(`   ${i + 1}. [${rec.priority.toUpperCase()}] ${rec.message}`);
-          console.log(`      Action: ${rec.action}`);
-        });
-      }
-    }
-
-  } catch (error) {
-    result.success = false;
-    result.logs.push(Logger.error(`Hook failed: ${error.message}`));
-
-    if (returnStructured) {
-      return result;
-    } else {
-      console.log(`❌ Enhanced post-edit hook failed: ${error.message}`);
-    }
-  }
-}
-
-// CLI interface for the enhanced post-edit pipeline
-export async function cliMain() {
-  const args = process.argv.slice(2);
-  const command = args[0];
-
-  if (!command || command === '--help' || command === '-h') {
-    console.log(`
-🚀 Enhanced Post-Edit Pipeline for Claude Flow Novice - v2.0.0
-
-Available commands:
-  post-edit <file> [options]         Enhanced post-edit with TDD testing
-  tdd-post-edit <file> [options]     TDD-focused post-edit hook
-
-Options:
-  --memory-key <key>                 Store results with specific memory key
-  --format                           Analyze formatting (default: true)
-  --validate                         Run validation (default: true)
-  --enable-tdd                       Enable TDD testing (default: true)
-  --minimum-coverage <percent>       Minimum coverage threshold (default: 80)
-  --block-on-critical               Block execution on critical errors
-  --structured                       Return structured JSON data
-
-Examples:
-  node enhanced-post-edit-pipeline.js post-edit src/app.js --memory-key "swarm/coder/step-1"
-  node enhanced-post-edit-pipeline.js tdd-post-edit test.js --minimum-coverage 90 --structured
-
-Enhanced Features:
-  ✅ TDD testing with single-file execution
-  ✅ Real-time coverage analysis and diff reporting
-  ✅ Advanced multi-language validation with error locations
-  ✅ Formatting diff preview and change detection
-  ✅ Actionable recommendations by category
-  ✅ Blocking mechanisms for critical failures
-  ✅ Enhanced memory store with versioning
-    `);
-    return;
-  }
-
-  if (command === 'post-edit' || command === 'tdd-post-edit') {
-    const file = args[1];
-    if (!file) {
-      console.log('❌ File path required for post-edit hook');
-      return;
-    }
-
-    const options = {
-      format: !args.includes('--no-format'),
-      validate: !args.includes('--no-validate'),
-      generateRecommendations: !args.includes('--no-recommendations'),
-      blockOnCritical: args.includes('--block-on-critical'),
-      enableTDD: command === 'tdd-post-edit' || !args.includes('--no-tdd'),
-      returnStructured: args.includes('--structured')
-    };
-
-    const coverageIndex = args.indexOf('--minimum-coverage');
-    if (coverageIndex >= 0) {
-      options.minimumCoverage = parseInt(args[coverageIndex + 1]) || 80;
-    }
-
-    const memoryKeyIndex = args.indexOf('--memory-key');
-    const memoryKey = memoryKeyIndex >= 0 ? args[memoryKeyIndex + 1] : null;
-
-    const result = await enhancedPostEditHook(file, memoryKey, options);
-
-    if (options.returnStructured && result) {
-      console.log(JSON.stringify(result, null, 2));
-    }
-  } else {
-    console.log(`❌ Unknown command: ${command}`);
-  }
-}
-
-// Run CLI if called directly
-if (import.meta.url === `file://${process.argv[1]}`) {
-  cliMain().catch(error => {
-    console.error(`💥 Fatal error: ${error.message}`);
-    process.exit(1);
-  });
-}