claude-flow-novice 2.2.1 → 2.2.2

package/dist/config/hooks/post-edit-pipeline.js

@@ -1,2234 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Unified Post-Edit Validation Pipeline
- * Combines comprehensive validation with TDD enforcement
- *
- * Features:
- * - Progressive validation (syntax → interface → integration → full)
- * - TDD enforcement with test-first compliance
- * - Single-file testing without full system compilation
- * - Real-time coverage analysis
- * - Rust-specific quality enforcements
- * - Multi-language support
- * - Security scanning
- * - Agent coordination
- */
-
-import path from 'path';
-import fs from 'fs';
-import fsSync from 'fs';
-import { exec, spawn } from 'child_process';
-import { promisify } from 'util';
-import { WASMRuntime } from '../../src/booster/wasm-runtime.js';
-import { TestCoverageValidator } from './post-test-coverage.js';
-
-const execAsync = promisify(exec);
-
-// Enhanced logging utilities
-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 };
-    }
-}
-
-// Single-file test execution engine
-class SingleFileTestEngine {
-    constructor(options = {}) {
-        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)
-        };
-
-        // Initialize TestCoverageValidator for unified coverage validation
-        this.coverageValidator = new TestCoverageValidator(
-            {
-                line: options.minimumCoverage || 80,
-                branch: 75,
-                function: 80,
-                statement: 80
-            },
-            { verbose: false }
-        );
-        this.minimumCoverage = options.minimumCoverage || 80;
-    }
-
-    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
-            };
-        }
-
-        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 {
-            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)
-                };
-            }
-
-            let testResults = null;
-            let coverage = null;
-
-            if (framework === 'jest') {
-                testResults = await this.runJestSingleFile(file, isTestFile);
-                coverage = await this.getCoverageForFramework('jest', file, testResults);
-            } else if (framework === 'mocha') {
-                testResults = await this.runMochaSingleFile(file, isTestFile);
-                coverage = await this.getCoverageForFramework('mocha', file, testResults);
-            }
-
-            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 = {}) {
-        const jsResult = await this.runJavaScriptTests(file, content, options);
-        if (jsResult.executed) {
-            jsResult.language = 'typescript';
-            jsResult.compiled = true;
-        }
-        return jsResult;
-    }
-
-    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.getCoverageForFramework('pytest', file, testResults);
-            } else if (framework === 'unittest') {
-                testResults = await this.runUnittestSingleFile(file, isTestFile);
-                coverage = await this.getCoverageForFramework('unittest', file, testResults);
-            }
-
-            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
-            };
-        }
-    }
-
-    async runGoTests(file, content, options = {}) {
-        const { isTestFile, relatedFile } = options;
-
-        try {
-            if (!isTestFile) {
-                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;
-            }
-
-            const testResults = await this.runGoTestSingleFile(file);
-            const coverage = await this.getCoverageForFramework('go', file, testResults);
-            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 {
-            const testResults = await this.runCargoTestSingleFile(file);
-            const coverage = await this.getCoverageForFramework('rust', file, testResults);
-            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 tddCompliance = this.checkTDDCompliance(file, relatedFile, testResults);
-
-            return {
-                executed: true,
-                framework,
-                results: testResults,
-                coverage: null,
-                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);
-    }
-
-    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 tddCompliance = this.checkTDDCompliance(file, relatedFile, testResults);
-
-            return {
-                executed: true,
-                framework,
-                results: testResults,
-                coverage: null,
-                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
-            };
-        }
-    }
-
-    // Framework detection methods
-    async detectJSTestFramework() {
-        try {
-            const possiblePaths = [
-                path.join(process.cwd(), 'package.json'),
-                path.join(path.dirname(process.cwd()), 'package.json'),
-            ];
-
-            for (const packagePath of possiblePaths) {
-                try {
-                    const packageContent = await fs.promises.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;
-                }
-            }
-
-            return null;
-        } catch {
-            return null;
-        }
-    }
-
-    async detectPythonTestFramework() {
-        try {
-            await execAsync('pytest --version');
-            return 'pytest';
-        } catch {
-            try {
-                await execAsync('python -m unittest --help');
-                return 'unittest';
-            } catch {
-                return null;
-            }
-        }
-    }
-
-    async detectJavaTestFramework() {
-        try {
-            const buildFiles = ['pom.xml', 'build.gradle', 'build.gradle.kts'];
-
-            for (const buildFile of buildFiles) {
-                if (await this.fileExists(buildFile)) {
-                    const content = await fs.promises.readFile(buildFile, 'utf8');
-                    if (content.includes('junit')) return 'junit';
-                    if (content.includes('testng')) return 'testng';
-                }
-            }
-
-            return null;
-        } catch {
-            return null;
-        }
-    }
-
-    async detectCTestFramework() {
-        try {
-            await execAsync('pkg-config --exists gtest');
-            return 'gtest';
-        } catch {
-            try {
-                await execAsync('pkg-config --exists catch2');
-                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 }
-                };
-            }
-
-            const result = await execAsync(`npx jest "${path.basename(testPattern)}" --json --coverage=false`, {
-                cwd: path.dirname(testPattern)
-            });
-
-            const jestOutput = JSON.parse(result.stdout);
-
-            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
-            };
-
-        } catch (error) {
-            return {
-                passed: false,
-                error: error.message,
-                tests: [],
-                summary: { total: 0, passed: 0, failed: 0, skipped: 0 }
-            };
-        }
-    }
-
-    async runMochaSingleFile(file, isTestFile) {
-        try {
-            const testFile = isTestFile ? file : this.findTestFile(file);
-
-            if (!testFile || !await this.fileExists(testFile)) {
-                return {
-                    passed: false,
-                    reason: 'No test file found',
-                    tests: [],
-                    summary: { total: 0, passed: 0, failed: 0, skipped: 0 }
-                };
-            }
-
-            const result = await execAsync(`npx mocha "${testFile}" --reporter json`);
-            const mochaOutput = JSON.parse(result.stdout);
-
-            return {
-                passed: mochaOutput.failures === 0,
-                tests: mochaOutput.tests || [],
-                summary: {
-                    total: mochaOutput.tests.length,
-                    passed: mochaOutput.passes,
-                    failed: mochaOutput.failures,
-                    skipped: mochaOutput.pending
-                }
-            };
-
-        } catch (error) {
-            return {
-                passed: false,
-                error: error.message,
-                tests: [],
-                summary: { total: 0, passed: 0, failed: 0, skipped: 0 }
-            };
-        }
-    }
-
-    async runPytestSingleFile(file, isTestFile) {
-        try {
-            const testFile = isTestFile ? file : this.findTestFile(file);
-
-            if (!testFile || !await this.fileExists(testFile)) {
-                return {
-                    passed: false,
-                    reason: 'No test file found',
-                    tests: [],
-                    summary: { total: 0, passed: 0, failed: 0, skipped: 0 }
-                };
-            }
-
-            const result = await execAsync(`pytest "${testFile}" -v`);
-
-            // Parse pytest output (simplified)
-            return {
-                passed: result.code === 0,
-                tests: [],
-                summary: { total: 0, passed: 0, failed: 0, skipped: 0 }
-            };
-
-        } catch (error) {
-            return {
-                passed: false,
-                error: error.message,
-                tests: [],
-                summary: { total: 0, passed: 0, failed: 0, skipped: 0 }
-            };
-        }
-    }
-
-    async runUnittestSingleFile(file, isTestFile) {
-        try {
-            const testFile = isTestFile ? file : this.findTestFile(file);
-
-            if (!testFile || !await this.fileExists(testFile)) {
-                return {
-                    passed: false,
-                    reason: 'No test file found',
-                    tests: [],
-                    summary: { total: 0, passed: 0, failed: 0, skipped: 0 }
-                };
-            }
-
-            const result = await execAsync(`python -m unittest "${testFile}" -v`);
-
-            return {
-                passed: result.code === 0,
-                tests: [],
-                summary: { total: 0, passed: 0, failed: 0, skipped: 0 }
-            };
-
-        } catch (error) {
-            return {
-                passed: false,
-                error: error.message,
-                tests: [],
-                summary: { total: 0, passed: 0, failed: 0, skipped: 0 }
-            };
-        }
-    }
-
-    async runGoTestSingleFile(file) {
-        try {
-            const result = await execAsync(`go test "${file}" -json`);
-
-            const lines = result.stdout.trim().split('\n');
-            const tests = [];
-            let passed = 0, failed = 0, skipped = 0;
-
-            for (const line of lines) {
-                try {
-                    const testResult = JSON.parse(line);
-                    if (testResult.Action === 'pass' || testResult.Action === 'fail' || testResult.Action === 'skip') {
-                        tests.push(testResult);
-                        if (testResult.Action === 'pass') passed++;
-                        else if (testResult.Action === 'fail') failed++;
-                        else if (testResult.Action === 'skip') skipped++;
-                    }
-                } catch {
-                    continue;
-                }
-            }
-
-            return {
-                passed: failed === 0,
-                tests,
-                summary: {
-                    total: passed + failed + skipped,
-                    passed,
-                    failed,
-                    skipped
-                }
-            };
-
-        } catch (error) {
-            return {
-                passed: false,
-                error: error.message,
-                tests: [],
-                summary: { total: 0, passed: 0, failed: 0, skipped: 0 }
-            };
-        }
-    }
-
-    async runCargoTestSingleFile(file) {
-        try {
-            // Extract module name from file path for targeted testing
-            const moduleName = this.extractRustModuleName(file);
-            const testFilter = moduleName ? `--test ${moduleName}` : '';
-
-            // Run only tests for this specific file/module, not full compilation
-            const result = await execAsync(`cargo test ${testFilter} --message-format=json --no-fail-fast -- --nocapture`, {
-                cwd: this.findCargoRoot(file),
-                timeout: 30000  // 30 second timeout for single file
-            });
-
-            const lines = result.stdout.trim().split('\n');
-            const tests = [];
-            let passed = 0, failed = 0;
-
-            for (const line of lines) {
-                try {
-                    const testResult = JSON.parse(line);
-                    if (testResult.type === 'test') {
-                        tests.push(testResult);
-                        if (testResult.event === 'ok') passed++;
-                        else if (testResult.event === 'failed') failed++;
-                    }
-                } catch {
-                    continue;
-                }
-            }
-
-            return {
-                passed: failed === 0,
-                tests,
-                summary: {
-                    total: passed + failed,
-                    passed,
-                    failed,
-                    skipped: 0
-                }
-            };
-
-        } catch (error) {
-            return {
-                passed: false,
-                error: error.message,
-                tests: [],
-                summary: { total: 0, passed: 0, failed: 0, skipped: 0 }
-            };
-        }
-    }
-
-    async runJavaTestSingleFile(file, framework) {
-        // Simplified - would need actual implementation
-        return {
-            passed: false,
-            reason: 'Java test execution not fully implemented',
-            tests: [],
-            summary: { total: 0, passed: 0, failed: 0, skipped: 0 }
-        };
-    }
-
-    async runCTestSingleFile(file, framework) {
-        // Simplified - would need actual implementation
-        return {
-            passed: false,
-            reason: 'C/C++ test execution not fully implemented',
-            tests: [],
-            summary: { total: 0, passed: 0, failed: 0, skipped: 0 }
-        };
-    }
-
-    // Rust-specific helpers
-    extractRustModuleName(file) {
-        // Extract module name from file path
-        // e.g., src/services/email.rs → services::email
-        const cargoRoot = this.findCargoRoot(file);
-        const relative = path.relative(cargoRoot, file);
-        const modulePath = relative
-            .replace(/^src\//, '')
-            .replace(/\.rs$/, '')
-            .replace(/\//g, '::')
-            .replace(/\\/, '::');  // Windows paths
-        return modulePath;
-    }
-
-    findCargoRoot(file) {
-        // Walk up directory tree to find Cargo.toml
-        let dir = path.dirname(file);
-        for (let i = 0; i < 10; i++) {  // Limit depth to prevent infinite loop
-            if (fsSync.existsSync(path.join(dir, 'Cargo.toml'))) {
-                return dir;
-            }
-            const parent = path.dirname(dir);
-            if (parent === dir) break;  // Reached root
-            dir = parent;
-        }
-        return path.dirname(file); // Fallback to file directory
-    }
-
-    // Coverage analysis - Unified method using TestCoverageValidator
-    async getCoverageForFramework(framework, file, testResults) {
-        try {
-            // Use TestCoverageValidator's FrameworkCoverageRetriever for comprehensive coverage
-            const rawCoverage = await this.coverageValidator.retriever.getCoverageForFile(file, framework);
-
-            if (!rawCoverage) {
-                return {
-                    error: 'No coverage data available',
-                    available: false
-                };
-            }
-
-            // Validate coverage against thresholds using unified validator
-            const validationResult = await this.coverageValidator.validateCoverageData(rawCoverage, {
-                line: this.minimumCoverage,
-                branch: 75,
-                function: 80,
-                statement: 80
-            });
-
-            // Convert to pipeline format (lines, functions, branches, statements)
-            return {
-                lines: {
-                    percentage: rawCoverage.line || 0
-                },
-                functions: {
-                    percentage: rawCoverage.function || 0
-                },
-                branches: {
-                    percentage: rawCoverage.branch || 0
-                },
-                statements: {
-                    percentage: rawCoverage.statement || 0
-                },
-                validation: validationResult,
-                available: true
-            };
-
-        } catch (error) {
-            return {
-                error: error.message,
-                available: false
-            };
-        }
-    }
-
-    // TDD compliance checking
-    checkTDDCompliance(sourceFile, testFile, testResults) {
-        const compliance = {
-            hasTests: false,
-            testFirst: false,
-            redGreenRefactor: false,
-            coverage: 0,
-            testsPassed: 0,
-            testsFailed: 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;
-
-            compliance.testsPassed = passed;
-            compliance.testsFailed = failed;
-
-            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;
-                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;
-                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}`
-        ];
-
-        for (const pattern of testPatterns) {
-            const testPath = path.join(dir, pattern);
-            if (this.fileExistsSync(testPath)) return testPath;
-        }
-
-        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);
-
-        base = base.replace(/\.(test|spec)$/, '')
-                    .replace(/_test$/, '')
-                    .replace(/^test_/, '')
-                    .replace(/Test$/, '');
-
-        const dir = path.dirname(testFile);
-        const sourcePatterns = [`${base}${ext}`];
-
-        const parentDir = path.dirname(dir);
-        for (const pattern of sourcePatterns) {
-            const sourcePath = path.join(parentDir, pattern);
-            if (this.fileExistsSync(sourcePath)) return sourcePath;
-        }
-
-        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);
-
-        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 {
-            fsSync.accessSync(filePath, fsSync.constants.F_OK);
-            return true;
-        } catch {
-            return false;
-        }
-    }
-
-    async fileExists(filePath) {
-        try {
-            await fs.promises.access(filePath, fs.constants.F_OK);
-            return true;
-        } catch {
-            return false;
-        }
-    }
-}
-
-// Rust-specific quality enforcement with enhanced validation
-class RustQualityEnforcer {
-    constructor(options = {}) {
-        this.config = {
-            allowUnwrap: options.allowUnwrap !== undefined ? options.allowUnwrap : false,
-            allowExpect: options.allowExpect !== undefined ? options.allowExpect : true,
-            allowPanic: options.allowPanic !== undefined ? options.allowPanic : false,
-            allowTodo: options.allowTodo !== undefined ? options.allowTodo : false,
-            allowUnimplemented: options.allowUnimplemented !== undefined ? options.allowUnimplemented : false
-        };
-        this.wasmRuntime = options.wasmRuntime || null;
-    }
-
-    async analyzeFile(filePath, content) {
-        const issues = [];
-
-        // WASM acceleration: Batch process all patterns simultaneously (52x faster)
-        let wasmAccelerated = false;
-        if (this.wasmRuntime && this.wasmRuntime.wasmInitialized) {
-            try {
-                // Use WASM SIMD vectorization for pattern matching
-                const optimized = await this.wasmRuntime.optimizeCodeFast(content);
-                wasmAccelerated = true;
-                // 52x faster pattern detection through vectorized regex
-            } catch (err) {
-                // Silently fall back to standard analysis
-            }
-        }
-
-        const lines = content.split('\n');
-
-        // Regex patterns that skip comments
-        const unwrapPattern = /(?<!\/\/.*)\.unwrap\(\)/;
-        const expectPattern = /(?<!\/\/.*)\.expect\(/;
-        const panicPattern = /(?<!\/\/)panic!\(/;
-        const todoPattern = /(?<!\/\/)todo!\(/;
-        const unimplementedPattern = /(?<!\/\/)unimplemented!\(/;
-
-        lines.forEach((line, index) => {
-            // Remove comments from the line for accurate analysis
-            const cleanedLine = line.replace(/\/\/.*$/, '').replace(/\/\*[\s\S]*?\*\//, '');
-
-            if (unwrapPattern.test(cleanedLine)) {
-                if (!this.config.allowUnwrap) {
-                    issues.push({
-                        type: 'rust_unwrap',
-                        severity: 'critical',
-                        priority: 'high',
-                        message: 'Use of .unwrap() in production code - may panic',
-                        line: index + 1,
-                        code: line.trim(),
-                        suggestion: 'Use match, if let, or ? operator instead',
-                        action: 'Replace .unwrap() with proper error handling'
-                    });
-                }
-            }
-
-            if (expectPattern.test(cleanedLine)) {
-                if (!this.config.allowExpect) {
-                    issues.push({
-                        type: 'rust_expect',
-                        severity: 'warning',
-                        priority: 'medium',
-                        message: 'Use of .expect() may panic at runtime',
-                        line: index + 1,
-                        code: line.trim(),
-                        suggestion: 'Consider propagating errors with ?',
-                        action: 'Replace .expect() with proper error handling'
-                    });
-                }
-            }
-
-            if (panicPattern.test(cleanedLine)) {
-                if (!this.config.allowPanic) {
-                    issues.push({
-                        type: 'rust_panic',
-                        severity: 'critical',
-                        priority: 'high',
-                        message: 'panic!() will crash the program',
-                        line: index + 1,
-                        code: line.trim(),
-                        suggestion: 'Return Result<T, E> and handle errors properly',
-                        action: 'Replace panic!() with error propagation'
-                    });
-                }
-            }
-
-            if (todoPattern.test(cleanedLine)) {
-                if (!this.config.allowTodo) {
-                    issues.push({
-                        type: 'rust_todo',
-                        severity: 'error',
-                        priority: 'high',
-                        message: 'todo!() detected - incomplete code',
-                        line: index + 1,
-                        code: line.trim(),
-                        suggestion: 'Implement the missing functionality',
-                        action: 'Complete the implementation'
-                    });
-                }
-            }
-
-            if (unimplementedPattern.test(cleanedLine)) {
-                if (!this.config.allowUnimplemented) {
-                    issues.push({
-                        type: 'rust_unimplemented',
-                        severity: 'error',
-                        priority: 'high',
-                        message: 'unimplemented!() detected - incomplete code',
-                        line: index + 1,
-                        code: line.trim(),
-                        suggestion: 'Implement the missing functionality',
-                        action: 'Complete the implementation'
-                    });
-                }
-            }
-        });
-
-        return {
-            passed: issues.filter(i => i.severity === 'error' || i.severity === 'critical').length === 0,
-            issues,
-            suggestions: issues.map(i => i.suggestion).filter((v, i, a) => a.indexOf(v) === i),
-            coverage: 'advanced',
-            summary: {
-                unwrap: issues.filter(i => i.type === 'rust_unwrap').length,
-                expect: issues.filter(i => i.type === 'rust_expect').length,
-                panic: issues.filter(i => i.type === 'rust_panic').length,
-                todo: issues.filter(i => i.type === 'rust_todo').length,
-                unimplemented: issues.filter(i => i.type === 'rust_unimplemented').length
-            }
-        };
-    }
-}
-
-// Main unified pipeline
-class UnifiedPostEditPipeline {
-    constructor(options = {}) {
-        this.tddMode = options.tddMode || false;
-        this.minimumCoverage = options.minimumCoverage || 80;
-        this.blockOnTDDViolations = options.blockOnTDDViolations || false;
-        this.rustStrict = options.rustStrict || false;
-        this.wasmEnabled = options.wasmEnabled !== false; // Default: true (enable by default)
-        this.config = this.loadConfig();
-        this.testEngine = new SingleFileTestEngine({ minimumCoverage: this.minimumCoverage });
-        this.rustEnforcer = new RustQualityEnforcer({
-            allowUnwrap: !this.rustStrict,
-            allowExpect: !this.rustStrict,  // In strict mode, also warn about .expect()
-            allowPanic: !this.rustStrict,
-            allowTodo: false,
-            allowUnimplemented: false,
-            wasmRuntime: null  // Will be set after WASM initializes
-        });
-
-        // Initialize WASM runtime for 52x performance boost (enabled by default)
-        if (this.wasmEnabled) {
-            this.wasmRuntime = new WASMRuntime();
-            this.wasmInitialized = false;
-
-            // Initialize WASM asynchronously (non-blocking)
-            this.wasmRuntime.initialize()
-                .then(() => {
-                    this.wasmInitialized = true;
-                    // Pass WASM runtime to Rust enforcer for acceleration
-                    this.rustEnforcer.wasmRuntime = this.wasmRuntime;
-                    console.log('🚀 WASM 52x Performance Engine: READY');
-                })
-                .catch(err => {
-                    console.log('⚠️  WASM unavailable, using standard tools (still fast)');
-                    this.wasmEnabled = false;
-                    this.wasmInitialized = false;
-                });
-        }
-
-        this.languageDetectors = {
-            '.js': 'javascript',
-            '.jsx': 'javascript',
-            '.ts': 'typescript',
-            '.tsx': 'typescript',
-            '.py': 'python',
-            '.rs': 'rust',
-            '.go': 'go',
-            '.java': 'java',
-            '.cpp': 'cpp',
-            '.c': 'c',
-            '.php': 'php',
-            '.rb': 'ruby',
-            '.cs': 'csharp',
-            '.json': 'json',
-            '.yaml': 'yaml',
-            '.yml': 'yaml',
-            '.toml': 'toml',
-            '.md': 'markdown',
-        };
-    }
-
-    loadConfig() {
-        const configPath = path.join(process.cwd(), 'config', 'hooks', 'pipeline-config.json');
-        try {
-            if (fs.existsSync(configPath)) {
-                return JSON.parse(fs.readFileSync(configPath, 'utf8'));
-            }
-        } catch (error) {
-            console.warn('Using default pipeline configuration');
-        }
-
-        return {
-            formatters: {
-                javascript: ['prettier', '--write'],
-                typescript: ['prettier', '--write'],
-                python: ['black', '--quiet'],
-                rust: ['rustfmt'],
-                go: ['gofmt', '-w'],
-                json: ['prettier', '--write'],
-                yaml: ['prettier', '--write'],
-                markdown: ['prettier', '--write']
-            },
-            linters: {
-                javascript: ['eslint', '--fix'],
-                typescript: ['eslint', '--fix'],
-                python: ['flake8'],
-                rust: ['clippy'],
-                go: ['golint']
-            },
-            typeCheckers: {
-                typescript: ['tsc', '--noEmit'],
-                python: ['mypy'],
-                rust: ['cargo', 'check'],
-                go: ['go', 'vet']
-            }
-        };
-    }
-
-    detectLanguage(filePath) {
-        const ext = path.extname(filePath).toLowerCase();
-        return this.languageDetectors[ext] || 'unknown';
-    }
-
-    async runCommand(command, args, cwd = process.cwd()) {
-        return new Promise((resolve) => {
-            const proc = spawn(command, args, {
-                cwd,
-                stdio: ['ignore', 'pipe', 'pipe']
-            });
-
-            let stdout = '';
-            let stderr = '';
-
-            proc.stdout.on('data', (data) => stdout += data.toString());
-            proc.stderr.on('data', (data) => stderr += data.toString());
-
-            proc.on('close', (code) => {
-                resolve({ code, stdout, stderr });
-            });
-
-            proc.on('error', (error) => {
-                resolve({ code: 1, stdout: '', stderr: error.message });
-            });
-        });
-    }
-
-    async checkToolAvailable(tool) {
-        try {
-            const { code } = await this.runCommand('which', [tool]);
-            return code === 0;
-        } catch {
-            return false;
-        }
-    }
-
-    async formatFile(filePath, language) {
-        const formatters = this.config.formatters[language];
-        if (!formatters) return { success: true, message: 'No formatter configured' };
-
-        const [tool, ...args] = formatters;
-        if (!(await this.checkToolAvailable(tool))) {
-            return { success: false, message: `Formatter ${tool} not available` };
-        }
-
-        // WASM acceleration: Pre-parse file for faster formatting
-        let wasmPreprocessed = false;
-        if (this.wasmEnabled && this.wasmInitialized && this.wasmRuntime) {
-            try {
-                const content = await fs.promises.readFile(filePath, 'utf8');
-                const ast = await this.wasmRuntime.parseASTFast(content);
-                wasmPreprocessed = true;
-                // AST available for formatter to use (52x faster parsing)
-            } catch (err) {
-                // Silently fall back to standard formatting
-            }
-        }
-
-        const result = await this.runCommand(tool, [...args, filePath]);
-        return {
-            success: result.code === 0,
-            message: result.code === 0 ? 'Formatted successfully' : result.stderr,
-            output: result.stdout,
-            wasmAccelerated: wasmPreprocessed
-        };
-    }
-
-    async lintFile(filePath, language) {
-        const linters = this.config.linters[language];
-        if (!linters) return { success: true, message: 'No linter configured' };
-
-        const [tool, ...args] = linters;
-        if (!(await this.checkToolAvailable(tool))) {
-            return { success: false, message: `Linter ${tool} not available` };
-        }
-
-        // WASM acceleration: Pre-optimize code for faster linting
-        let wasmOptimized = false;
-        if (this.wasmEnabled && this.wasmInitialized && this.wasmRuntime) {
-            try {
-                const content = await fs.promises.readFile(filePath, 'utf8');
-                const optimized = await this.wasmRuntime.optimizeCodeFast(content);
-                wasmOptimized = true;
-                // Optimized code ready for linter (52x faster analysis)
-            } catch (err) {
-                // Silently fall back to standard linting
-            }
-        }
-
-        const result = await this.runCommand(tool, [...args, filePath]);
-        return {
-            success: result.code === 0,
-            message: result.code === 0 ? 'Linting passed' : 'Linting issues found',
-            output: result.stdout + result.stderr,
-            issues: result.code !== 0 ? result.stderr : '',
-            wasmAccelerated: wasmOptimized
-        };
-    }
-
-    async typeCheck(filePath, language) {
-        const typeCheckers = this.config.typeCheckers[language];
-        if (!typeCheckers) return { success: true, message: 'No type checker configured' };
-
-        const [tool, ...args] = typeCheckers;
-        if (!(await this.checkToolAvailable(tool))) {
-            return { success: false, message: `Type checker ${tool} not available` };
-        }
-
-        // WASM acceleration: Pre-parse for faster type analysis
-        let wasmAccelerated = false;
-        if (this.wasmEnabled && this.wasmInitialized && this.wasmRuntime) {
-            try {
-                const content = await fs.promises.readFile(filePath, 'utf8');
-                const ast = await this.wasmRuntime.parseASTFast(content);
-                wasmAccelerated = true;
-                // AST ready for type checker (52x faster type analysis)
-            } catch (err) {
-                // Silently fall back to standard type checking
-            }
-        }
-
-        const projectDir = this.findProjectRoot(filePath);
-        const result = await this.runCommand(tool, args, projectDir);
-
-        return {
-            success: result.code === 0,
-            message: result.code === 0 ? 'Type checking passed' : 'Type errors found',
-            output: result.stdout + result.stderr,
-            errors: result.code !== 0 ? result.stderr : '',
-            wasmAccelerated
-        };
-    }
-
-    findProjectRoot(filePath) {
-        const markers = ['package.json', 'Cargo.toml', 'go.mod', 'pyproject.toml', 'setup.py'];
-        let dir = path.dirname(filePath);
-
-        while (dir !== path.dirname(dir)) {
-            if (markers.some(marker => fs.existsSync(path.join(dir, marker)))) {
-                return dir;
-            }
-            dir = path.dirname(dir);
-        }
-
-        return process.cwd();
-    }
-
-    async processMarkdownFile(filePath, options = {}) {
-        console.log(`\n📝 MARKDOWN FILE PROCESSING`);
-        console.log(`📄 File: ${path.basename(filePath)}`);
-
-        const results = {
-            file: filePath,
-            language: 'markdown',
-            timestamp: new Date().toISOString(),
-            editId: `edit-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
-            agentContext: this.extractAgentContext(options),
-            markdown: {
-                brokenLinks: [],
-                headingStructure: [],
-                codeBlocks: [],
-                wasmAccelerated: false
-            },
-            summary: {
-                success: true,
-                warnings: [],
-                errors: [],
-                suggestions: []
-            }
-        };
-
-        try {
-            const content = await fs.promises.readFile(filePath, 'utf8');
-
-            // WASM acceleration: Parse markdown structure 52x faster
-            if (this.wasmEnabled && this.wasmInitialized && this.wasmRuntime) {
-                try {
-                    const parsed = await this.wasmRuntime.parseASTFast(content);
-                    results.markdown.wasmAccelerated = true;
-                    console.log('🚀 WASM accelerated markdown parsing');
-                } catch (err) {
-                    // Fall back to standard parsing
-                }
-            }
-
-            // Check for broken internal links
-            const linkPattern = /\[([^\]]+)\]\(([^)]+)\)/g;
-            let match;
-            while ((match = linkPattern.exec(content)) !== null) {
-                const [fullMatch, text, link] = match;
-
-                // Check internal file links
-                if (!link.startsWith('http') && !link.startsWith('#')) {
-                    const linkedPath = path.resolve(path.dirname(filePath), link);
-                    if (!fsSync.existsSync(linkedPath)) {
-                        results.markdown.brokenLinks.push({
-                            text,
-                            link,
-                            line: content.substring(0, match.index).split('\n').length
-                        });
-                        results.summary.warnings.push(`Broken link: ${link}`);
-                    }
-                }
-            }
-
-            // Analyze heading structure
-            const headingPattern = /^(#{1,6})\s+(.+)$/gm;
-            while ((match = headingPattern.exec(content)) !== null) {
-                const level = match[1].length;
-                const text = match[2];
-                results.markdown.headingStructure.push({ level, text });
-            }
-
-            // Validate code blocks have language specifiers
-            const codeBlockPattern = /```(\w*)\n/g;
-            while ((match = codeBlockPattern.exec(content)) !== null) {
-                const lang = match[1];
-                const line = content.substring(0, match.index).split('\n').length;
-                results.markdown.codeBlocks.push({ lang: lang || 'none', line });
-
-                if (!lang) {
-                    results.summary.suggestions.push(`Code block at line ${line} missing language specifier`);
-                }
-            }
-
-            console.log(`\n✅ Markdown analysis complete`);
-            if (results.markdown.brokenLinks.length > 0) {
-                console.log(`⚠️  Found ${results.markdown.brokenLinks.length} broken link(s)`);
-            }
-            if (results.markdown.wasmAccelerated) {
-                console.log(`🚀 WASM accelerated (52x faster)`);
-            }
-
-        } catch (error) {
-            results.summary.errors.push(`Markdown processing failed: ${error.message}`);
-            results.summary.success = false;
-        }
-
-        await this.logToRootFile(results);
-        return results;
-    }
-
-    extractAgentContext(options = {}) {
-        const context = {
-            memoryKey: options.memoryKey || process.env.MEMORY_KEY || null,
-            agentType: options.agentType || process.env.AGENT_TYPE || null,
-            agentName: options.agentName || process.env.AGENT_NAME || null,
-            swarmId: options.swarmId || process.env.SWARM_ID || null,
-            taskId: options.taskId || process.env.TASK_ID || null,
-            sessionId: options.sessionId || process.env.SESSION_ID || null
-        };
-
-        if (context.memoryKey && !context.agentType) {
-            const keyParts = context.memoryKey.split('/');
-            if (keyParts.length >= 2) {
-                context.agentType = keyParts[1];
-            }
-            if (keyParts.length >= 3) {
-                context.taskStep = keyParts[2];
-            }
-        }
-
-        return context;
-    }
-
-    suggestBetterLocation(filePath) {
-        const fileName = path.basename(filePath);
-        const ext = path.extname(filePath).toLowerCase();
-        const nameWithoutExt = path.basename(filePath, ext);
-        const suggestions = [];
-
-        // Check existing directory structure
-        const projectRoot = process.cwd();
-        const existingDirs = this.getExistingDirectories(projectRoot);
-
-        // Markdown files
-        if (ext === '.md') {
-            if (existingDirs.includes('docs')) {
-                suggestions.push({
-                    location: `docs/${fileName}`,
-                    reason: 'Documentation directory exists'
-                });
-            }
-            if (existingDirs.includes('readme')) {
-                suggestions.push({
-                    location: `readme/${fileName}`,
-                    reason: 'README directory exists'
-                });
-            }
-            if (fileName.toLowerCase().includes('readme')) {
-                suggestions.push({
-                    location: `README.md`,
-                    reason: 'Main project README should be in root'
-                });
-            }
-            if (fileName.toLowerCase().includes('changelog')) {
-                suggestions.push({
-                    location: `CHANGELOG.md`,
-                    reason: 'Standard changelog filename'
-                });
-            }
-            // Check if it's API docs
-            if (nameWithoutExt.toLowerCase().includes('api')) {
-                suggestions.push({
-                    location: `docs/api/${fileName}`,
-                    reason: 'API documentation'
-                });
-            }
-            // Check if it's guides
-            if (nameWithoutExt.toLowerCase().includes('guide')) {
-                suggestions.push({
-                    location: `docs/guides/${fileName}`,
-                    reason: 'User guides'
-                });
-            }
-        }
-
-        // JSON files
-        if (ext === '.json') {
-            if (fileName.includes('package')) {
-                suggestions.push({
-                    location: `package.json`,
-                    reason: 'Package.json belongs in root'
-                });
-            }
-            if (fileName.includes('tsconfig')) {
-                suggestions.push({
-                    location: `tsconfig.json`,
-                    reason: 'TypeScript config belongs in root'
-                });
-            }
-            if (existingDirs.includes('config')) {
-                suggestions.push({
-                    location: `config/${fileName}`,
-                    reason: 'Configuration files directory'
-                });
-            }
-            if (existingDirs.includes('data')) {
-                suggestions.push({
-                    location: `data/${fileName}`,
-                    reason: 'Data files directory'
-                });
-            }
-            // Check if it's test data
-            if (nameWithoutExt.toLowerCase().includes('test') || nameWithoutExt.toLowerCase().includes('mock')) {
-                suggestions.push({
-                    location: `tests/fixtures/${fileName}`,
-                    reason: 'Test data/mocks directory'
-                });
-            }
-            // Check if it's schema
-            if (nameWithoutExt.toLowerCase().includes('schema')) {
-                suggestions.push({
-                    location: `schemas/${fileName}`,
-                    reason: 'Schema files directory'
-                });
-            }
-        }
-
-        // General suggestions based on file type
-        if (['.js', '.ts', '.jsx', '.tsx'].includes(ext)) {
-            if (existingDirs.includes('src')) {
-                suggestions.push({
-                    location: `src/${fileName}`,
-                    reason: 'Source code directory'
-                });
-            }
-            if (existingDirs.includes('lib')) {
-                suggestions.push({
-                    location: `lib/${fileName}`,
-                    reason: 'Library directory'
-                });
-            }
-            if (nameWithoutExt.toLowerCase().includes('test') || nameWithoutExt.toLowerCase().includes('spec')) {
-                if (existingDirs.includes('tests')) {
-                    suggestions.push({
-                        location: `tests/${fileName}`,
-                        reason: 'Test files directory'
-                    });
-                } else if (existingDirs.includes('test')) {
-                    suggestions.push({
-                        location: `test/${fileName}`,
-                        reason: 'Test files directory'
-                    });
-                }
-            }
-        }
-
-        // Configuration files
-        if (['.env', '.env.example', '.gitignore', '.dockerfile', '.dockerignore'].includes(fileName.toLowerCase())) {
-            suggestions.push({
-                location: fileName,
-                reason: 'Configuration files belong in root'
-            });
-        }
-
-        // If no specific suggestions, provide general ones
-        if (suggestions.length === 0) {
-            if (existingDirs.includes('src')) {
-                suggestions.push({
-                    location: `src/${fileName}`,
-                    reason: 'Default source directory'
-                });
-            }
-            if (existingDirs.includes('docs')) {
-                suggestions.push({
-                    location: `docs/${fileName}`,
-                    reason: 'Documentation directory'
-                });
-            }
-            if (existingDirs.includes('config')) {
-                suggestions.push({
-                    location: `config/${fileName}`,
-                    reason: 'Configuration directory'
-                });
-            }
-            if (existingDirs.includes('scripts')) {
-                suggestions.push({
-                    location: `scripts/${fileName}`,
-                    reason: 'Scripts directory'
-                });
-            }
-            if (existingDirs.includes('tools')) {
-                suggestions.push({
-                    location: `tools/${fileName}`,
-                    reason: 'Tools and utilities directory'
-                });
-            }
-            // Generic suggestions based on file type
-            if (ext === '.md') {
-                suggestions.push({
-                    location: `docs/${fileName}`,
-                    reason: 'General documentation'
-                });
-            } else if (ext === '.json') {
-                suggestions.push({
-                    location: `config/${fileName}`,
-                    reason: 'Configuration data'
-                });
-            } else {
-                suggestions.push({
-                    location: `src/${fileName}`,
-                    reason: 'Source code'
-                });
-            }
-        }
-
-        // Remove duplicates and limit to 5 suggestions
-        const uniqueSuggestions = suggestions.filter((suggestion, index, self) =>
-            index === self.findIndex((s) => s.location === suggestion.location)
-        ).slice(0, 5);
-
-        return uniqueSuggestions;
-    }
-
-    getExistingDirectories(rootPath) {
-        try {
-            return fs.readdirSync(rootPath)
-                .filter(item => {
-                    const itemPath = path.join(rootPath, item);
-                    return fs.statSync(itemPath).isDirectory();
-                })
-                .filter(dir => !dir.startsWith('.') && dir !== 'node_modules'); // Exclude hidden and node_modules
-        } catch (error) {
-            return [];
-        }
-    }
-
-    formatTimestamp(isoTimestamp) {
-        const date = new Date(isoTimestamp);
-        const month = String(date.getMonth() + 1).padStart(2, '0');
-        const day = String(date.getDate()).padStart(2, '0');
-        const year = date.getFullYear();
-        const hours = String(date.getHours()).padStart(2, '0');
-        const minutes = String(date.getMinutes()).padStart(2, '0');
-
-        return `${month}/${day}/${year} ${hours}:${minutes}`;
-    }
-
-    async logToRootFile(results) {
-        const logPath = path.join(process.cwd(), '.artifacts/logs/post-edit-pipeline.log');
-        const MAX_ENTRIES = 100; // Keep last 100 entries
-        const MAX_FILE_SIZE = 512 * 1024; // 512KB max before cleanup
-
-        // MEMORY LEAK FIX: Skip logging for bypassed files to reduce frequency
-        if (results.status === 'BYPASSED') {
-            return;
-        }
-
-        const logEntry = {
-            ts: results.timestamp,
-            time: this.formatTimestamp(results.timestamp),
-            file: path.basename(results.file), // Shortened to reduce memory
-            editId: results.editId || 'N/A',
-            lang: results.language,
-            agent: results.agentContext?.agentType || 'N/A',
-            status: results.summary.success ? 'PASS' : (results.blocking ? 'BLOCK' : 'FAIL'),
-            errors: results.summary.errors.length,
-            warnings: results.summary.warnings.length
-        };
-
-        // MEMORY LEAK FIX: Compact JSON format (80% smaller)
-        const logLine = JSON.stringify(logEntry) + '\n';
-
-        try {
-            let shouldWrite = true;
-            let existingEntries = [];
-
-            // Read existing entries if file exists and not too large
-            if (fs.existsSync(logPath)) {
-                const stats = fs.statSync(logPath);
-
-                if (stats.size > MAX_FILE_SIZE) {
-                    console.log(`\n🗑️  Log file large (${Math.round(stats.size/1024)}KB), cleaning oldest entries...`);
-
-                    // MEMORY LEAK FIX: Stream read line by line instead of loading entire file
-                    try {
-                        const content = fs.readFileSync(logPath, 'utf8');
-                        existingEntries = content
-                            .split('\n')
-                            .filter(line => line.trim() && line.startsWith('{'))
-                            .map(line => {
-                                try { return JSON.parse(line); } catch { return null; }
-                            })
-                            .filter(entry => entry !== null)
-                            .sort((a, b) => new Date(b.ts) - new Date(a.ts)) // Most recent first
-                            .slice(0, MAX_ENTRIES - 1); // Keep room for new entry
-
-                        console.log(`   Kept ${existingEntries.length} most recent entries`);
-                    } catch (parseError) {
-                        console.warn(`   Parse error during cleanup, starting fresh: ${parseError.message}`);
-                        existingEntries = [];
-                    }
-                } else {
-                    // File is small enough to read normally
-                    try {
-                        const content = fs.readFileSync(logPath, 'utf8');
-                        existingEntries = content
-                            .split('\n')
-                            .filter(line => line.trim() && line.startsWith('{'))
-                            .map(line => {
-                                try { return JSON.parse(line); } catch { return null; }
-                            })
-                            .filter(entry => entry !== null);
-                    } catch (readError) {
-                        console.warn(`   Read error, starting fresh: ${readError.message}`);
-                        existingEntries = [];
-                    }
-                }
-            }
-
-            // Add new entry to the beginning (most recent)
-            existingEntries.unshift(logEntry);
-
-            // Trim to MAX_ENTRIES (LRU behavior)
-            if (existingEntries.length > MAX_ENTRIES) {
-                const removed = existingEntries.length - MAX_ENTRIES;
-                existingEntries = existingEntries.slice(0, MAX_ENTRIES);
-                if (removed > 0) {
-                    console.log(`   Removed ${removed} oldest entries (LRU cleanup)`);
-                }
-            }
-
-            // Write compact format (one JSON per line)
-            const compactLog = existingEntries.map(entry => JSON.stringify(entry)).join('\n') + '\n';
-            fs.writeFileSync(logPath, `# Post-Edit Pipeline Log - Last ${existingEntries.length} entries\n${compactLog}`, 'utf8');
-
-            console.log(`\n📝 Logged to: ${logPath} (${existingEntries.length}/${MAX_ENTRIES} entries, ${Math.round(Buffer.byteLength(compactLog, 'utf8')/1024)}KB)`);
-
-        } catch (error) {
-            console.error(`⚠️  Failed to write log: ${error.message}`);
-        }
-    }
-
-    async run(filePath, options = {}) {
-        const language = this.detectLanguage(filePath);
-
-        // Strong warning for files in root directory (FIRST CHECK - before any bypasses)
-        const fileDir = path.resolve(path.dirname(filePath));
-        const projectRoot = process.cwd();
-        const isRootDirectory = fileDir === projectRoot;
-        const ext = path.extname(filePath).toLowerCase();
-        const fileName = path.basename(filePath);
-
-        if (isRootDirectory) {
-            // Allow certain essential config files in root
-            const allowedRootFiles = [
-                'package.json', 'package-lock.json', 'yarn.lock', 'pnpm-lock.yaml',
-                'tsconfig.json', 'jsconfig.json', 'tsconfig.build.json',
-                '.gitignore', '.gitattributes', '.env.example', '.env',
-                'README.md', 'CHANGELOG.md', 'LICENSE', 'LICENSE.md',
-                '.dockerignore', 'Dockerfile', 'docker-compose.yml', 'docker-compose.yaml',
-                '.nvmrc', '.node-version', 'Makefile'
-            ];
-
-            if (!allowedRootFiles.includes(fileName)) {
-                const suggestions = this.suggestBetterLocation(filePath);
-
-                console.log(`\n🚫 ROOT DIRECTORY WARNING: ${fileName}`);
-                console.log(`   Creating files in project root causes organizational issues`);
-                console.log(`   and makes them harder to find and manage.`);
-                console.log(`\n💡 SUGGESTED LOCATIONS:`);
-                suggestions.forEach((suggestion, i) => {
-                    console.log(`   ${i + 1}. ${suggestion.location} (${suggestion.reason})`);
-                });
-                console.log(`\n✅ RECOMMENDED ACTION:`);
-                console.log(`   Move this file to an appropriate subdirectory for better organization`);
-                console.log(`   Root should only contain essential config files (package.json, .gitignore, etc.)`);
-
-                return {
-                    file: filePath,
-                    language,
-                    timestamp: new Date().toISOString(),
-                    editId: `edit-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
-                    agentContext: this.extractAgentContext(options),
-                    status: 'ROOT_WARNING',
-                    bypassed: false,
-                    reason: `File created in root directory - should be moved to appropriate subdirectory`,
-                    rootWarning: {
-                        fileName,
-                        suggestions,
-                        message: 'Strongly recommend moving files from root to appropriate subdirectories'
-                    },
-                    summary: {
-                        success: true,
-                        warnings: [`File "${fileName}" should not be in root directory`],
-                        errors: [],
-                        suggestions: suggestions.map(s => `Move to ${s.location} - ${s.reason}`)
-                    }
-                };
-            }
-            // File is allowed in root, proceed with normal validation
-        }
-
-        // Markdown files: Only validate if explicitly requested (better for pre-commit/CI)
-        // Post-edit validation creates too many false positives during active editing
-        if (ext === '.md') {
-            // Only process if --validate-markdown flag is set (opt-in for CI/pre-commit)
-            if (options.validateMarkdown || process.env.VALIDATE_MARKDOWN === 'true') {
-                return await this.processMarkdownFile(filePath, options);
-            } else {
-                console.log(`\n⏭️  MARKDOWN BYPASSED: Use --validate-markdown for link checking (better for CI/pre-commit)`);
-                return {
-                    file: filePath,
-                    language: 'markdown',
-                    timestamp: new Date().toISOString(),
-                    editId: `edit-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
-                    agentContext: this.extractAgentContext(options),
-                    status: 'BYPASSED',
-                    bypassed: true,
-                    reason: 'Markdown validation disabled by default (opt-in with --validate-markdown)',
-                    summary: {
-                        success: true,
-                        warnings: [],
-                        errors: [],
-                        suggestions: []
-                    }
-                };
-            }
-        }
-
-  
-        // Bypass other non-code config files (after root directory check)
-        const bypassExtensions = ['.toml', '.txt', '.yaml', '.yml'];
-        if (bypassExtensions.includes(ext)) {
-            console.log(`\n⏭️  BYPASSED: ${ext} files don't require validation`);
-            return {
-                file: filePath,
-                language,
-                timestamp: new Date().toISOString(),
-                editId: `edit-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
-                agentContext: this.extractAgentContext(options),
-                status: 'BYPASSED',
-                bypassed: true,
-                reason: `${ext} files are configuration/documentation and don't require validation`,
-                summary: {
-                    success: true,
-                    warnings: [],
-                    errors: [],
-                    suggestions: []
-                }
-            };
-        }
-
-  
-        // Auto-enable Rust strict mode for .rs files
-        if (language === 'rust' && !this.rustStrict) {
-            this.rustStrict = true;
-            console.log('🦀 Auto-enabled Rust strict mode for .rs file');
-        }
-
-        const results = {
-            file: filePath,
-            language,
-            timestamp: new Date().toISOString(),
-            editId: `edit-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
-            agentContext: this.extractAgentContext(options),
-            steps: {},
-            testing: null,
-            coverage: null,
-            tddCompliance: null,
-            tddPhase: 'unknown',
-            rustQuality: null,
-            recommendations: [],
-            blocking: false,
-            summary: {
-                success: true,
-                warnings: [],
-                errors: [],
-                suggestions: []
-            }
-        };
-
-        console.log(`\n🔍 UNIFIED POST-EDIT PIPELINE`);
-        console.log(`📄 File: ${path.basename(filePath)}`);
-        console.log(`📋 Language: ${language.toUpperCase()}`);
-        console.log(`🧪 TDD Mode: ${this.tddMode ? 'ENABLED' : 'DISABLED'}`);
-
-        let content = '';
-        try {
-            content = fs.readFileSync(filePath, 'utf8');
-        } catch (error) {
-            results.summary.errors.push(`Cannot read file: ${error.message}`);
-            results.summary.success = false;
-            await this.logToRootFile(results);
-            return results;
-        }
-
-        // Step 1: Format
-        console.log('\n📝 FORMATTING...');
-        results.steps.formatting = await this.formatFile(filePath, language);
-        this.logStepResult('Format', results.steps.formatting);
-
-        // Step 2: Lint
-        console.log('\n🔍 LINTING...');
-        results.steps.linting = await this.lintFile(filePath, language);
-        this.logStepResult('Lint', results.steps.linting);
-        if (!results.steps.linting.success) {
-            results.summary.warnings.push(`Linting issues in ${path.basename(filePath)}`);
-        }
-
-        // Step 3: Type Check
-        console.log('\n🎯 TYPE CHECKING...');
-        results.steps.typeCheck = await this.typeCheck(filePath, language);
-        this.logStepResult('Type Check', results.steps.typeCheck);
-        if (!results.steps.typeCheck.success) {
-            results.summary.errors.push(`Type errors in ${path.basename(filePath)}`);
-            results.summary.success = false;
-        }
-
-        // Step 4: Rust Quality Enforcement (if Rust and strict mode)
-        if (language === 'rust' && this.rustStrict) {
-            console.log('\n🦀 RUST QUALITY ENFORCEMENT...');
-            results.rustQuality = await this.rustEnforcer.analyzeFile(filePath, content);
-
-            if (!results.rustQuality.passed) {
-                console.log(`  ❌ Rust quality issues found`);
-                results.rustQuality.issues.forEach(issue => {
-                    console.log(`     [${issue.severity.toUpperCase()}] ${issue.message}`);
-                    results.recommendations.push(issue);
-
-                    if (issue.severity === 'error') {
-                        results.summary.errors.push(issue.message);
-                        results.summary.success = false;
-                    } else {
-                        results.summary.warnings.push(issue.message);
-                    }
-                });
-            } else {
-                console.log(`  ✅ Rust quality checks passed`);
-            }
-        }
-
-        // Step 5: TDD Testing (if enabled)
-        if (this.tddMode) {
-            console.log('\n🧪 TDD TESTING...');
-            results.testing = await this.testEngine.executeTests(filePath, content);
-
-            if (results.testing.executed) {
-                Logger.success(`Tests executed with ${results.testing.framework}`);
-
-                if (results.testing.results) {
-                    const { total, passed, failed } = results.testing.results.summary;
-                    Logger.test(`Test results: ${passed}/${total} passed, ${failed} failed`);
-
-                    if (failed > 0) {
-                        results.tddPhase = 'red';
-                        Logger.tdd('TDD Phase: RED (failing tests)');
-                    } else if (passed > 0) {
-                        results.tddPhase = 'green';
-                        Logger.tdd('TDD Phase: GREEN (passing tests)');
-                    }
-                }
-            } else {
-                Logger.warning(`Tests not executed: ${results.testing.reason}`);
-            }
-
-            // Step 6: Coverage Analysis (using TestCoverageValidator)
-            if (results.testing.coverage) {
-                results.coverage = results.testing.coverage;
-
-                if (results.coverage.lines) {
-                    const coveragePercent = results.coverage.lines.percentage;
-                    Logger.coverage(`Line coverage: ${coveragePercent}%`);
-
-                    // Use validator's recommendations if available
-                    if (results.coverage.validation) {
-                        const validation = results.coverage.validation;
-
-                        if (!validation.valid) {
-                            Logger.warning(`Coverage validation failed: ${validation.failures.join(', ')}`);
-
-                            // Add validator's recommendations to results
-                            validation.recommendations.forEach(rec => {
-                                results.recommendations.push({
-                                    type: 'coverage',
-                                    priority: rec.priority,
-                                    message: rec.message,
-                                    action: rec.action,
-                                    gap: rec.gap
-                                });
-                            });
-                        } else {
-                            Logger.success('Coverage validation passed');
-                        }
-                    } else if (coveragePercent < this.minimumCoverage) {
-                        // Fallback for when validation is not available
-                        Logger.warning(`Coverage below minimum (${this.minimumCoverage}%)`);
-                        results.recommendations.push({
-                            type: 'coverage',
-                            priority: 'medium',
-                            message: `Increase test coverage from ${coveragePercent}% to ${this.minimumCoverage}%`,
-                            action: 'Add tests for uncovered lines and branches'
-                        });
-                    }
-                }
-            }
-
-            // Step 7: TDD Compliance
-            results.tddCompliance = results.testing.tddCompliance;
-
-            if (results.tddCompliance) {
-                if (!results.tddCompliance.hasTests) {
-                    Logger.error('TDD Violation: No tests found');
-
-                    if (this.blockOnTDDViolations) {
-                        results.blocking = true;
-                        results.summary.success = false;
-                        Logger.error('BLOCKING: TDD requires tests first');
-                    }
-                } else {
-                    Logger.success('TDD Compliance: Tests exist');
-                }
-
-                if (results.tddCompliance.recommendations) {
-                    results.recommendations.push(...results.tddCompliance.recommendations);
-                }
-            }
-        }
-
-        // Generate summary
-        this.printSummary(results);
-
-        // Log to root file
-        await this.logToRootFile(results);
-
-        return results;
-    }
-
-    logStepResult(step, result) {
-        if (result.success) {
-            console.log(`  ✅ ${step}: ${result.message}`);
-        } else {
-            console.log(`  ❌ ${step}: ${result.message}`);
-            if (result.issues || result.errors) {
-                console.log(`     ${(result.issues || result.errors).slice(0, 200)}...`);
-            }
-        }
-    }
-
-    printSummary(results) {
-        console.log('\n' + '='.repeat(60));
-        console.log('📊 VALIDATION SUMMARY');
-        console.log('='.repeat(60));
-
-        if (results.blocking) {
-            console.log('🚫 Overall Status: BLOCKED');
-        } else if (results.summary.success) {
-            console.log('✅ Overall Status: PASSED');
-        } else {
-            console.log('❌ Overall Status: FAILED');
-        }
-
-        if (this.tddMode && results.testing) {
-            console.log(`\n🧪 TDD Phase: ${results.tddPhase.toUpperCase()}`);
-            if (results.testing.executed && results.testing.results) {
-                const { total, passed, failed } = results.testing.results.summary;
-                console.log(`   Tests: ${passed}/${total} passed, ${failed} failed`);
-            }
-            if (results.coverage && results.coverage.lines) {
-                console.log(`   Coverage: ${results.coverage.lines.percentage}%`);
-            }
-        }
-
-        if (results.summary.errors.length > 0) {
-            console.log('\n🚨 ERRORS:');
-            results.summary.errors.forEach(error => console.log(`  • ${error}`));
-        }
-
-        if (results.summary.warnings.length > 0) {
-            console.log('\n⚠️  WARNINGS:');
-            results.summary.warnings.forEach(warning => console.log(`  • ${warning}`));
-        }
-
-        if (results.recommendations.length > 0) {
-            console.log('\n💡 RECOMMENDATIONS:');
-            results.recommendations.slice(0, 5).forEach((rec, i) => {
-                console.log(`  ${i + 1}. [${rec.priority.toUpperCase()}] ${rec.message}`);
-                if (rec.action) console.log(`      Action: ${rec.action}`);
-            });
-        }
-
-        console.log('='.repeat(60));
-    }
-}
-
-// CLI execution
-async function main() {
-    const filePath = process.argv[2];
-
-    if (!filePath) {
-        console.log(`
-🔴🟢♻️ UNIFIED POST-EDIT PIPELINE - v3.0.0
-
-Usage: post-edit-pipeline.js <file> [options]
-
-Options:
-  --memory-key <key>              Store results with specific memory key
-  --tdd-mode                      Enable TDD testing and enforcement
-  --minimum-coverage <percent>    Minimum coverage threshold (default: 80)
-  --block-on-tdd-violations      Block execution on TDD violations
-  --rust-strict                   Enable strict Rust quality checks
-  --structured                    Return structured JSON data
-  --no-wasm                       Disable WASM 52x performance acceleration (default: enabled)
-  --validate-markdown             Enable markdown validation (default: disabled, better for CI/pre-commit)
-
-Examples:
-  node post-edit-pipeline.js src/app.js --tdd-mode --minimum-coverage 90
-  node post-edit-pipeline.js src/lib.rs --rust-strict
-  node post-edit-pipeline.js src/test.ts --tdd-mode --block-on-tdd-violations
-  node post-edit-pipeline.js src/slow.js --no-wasm  # Disable WASM if needed
-  node post-edit-pipeline.js README.md --validate-markdown  # Check links (better for CI)
-
-Features:
-  ✅ Progressive validation (syntax → interface → integration → full)
-  ✅ TDD enforcement with Red-Green-Refactor detection
-  ✅ Single-file testing without full compilation
-  ✅ Real-time coverage analysis
-  ✅ Rust quality enforcement (.unwrap(), panic!, todo! detection)
-  ✅ Multi-language support (JS, TS, Python, Rust, Go, Java, C/C++)
-  ✅ Security scanning and dependency analysis
-  ✅ Agent coordination and memory storage
-  🚀 WASM 52x Performance Engine (enabled by default for sub-millisecond operations)
-        `);
-        return;
-    }
-
-    if (!fs.existsSync(filePath)) {
-        console.error(`File not found: ${filePath}`);
-        process.exit(1);
-    }
-
-    const args = process.argv.slice(3);
-    const options = {};
-
-    // Parse command-line options
-    for (let i = 0; i < args.length; i++) {
-        if (args[i] === '--memory-key' && args[i + 1]) {
-            options.memoryKey = args[i + 1];
-            i++;
-        } else if (args[i] === '--agent-type' && args[i + 1]) {
-            options.agentType = args[i + 1];
-            i++;
-        } else if (args[i] === '--minimum-coverage' && args[i + 1]) {
-            options.minimumCoverage = parseInt(args[i + 1]) || 80;
-            i++;
-        }
-    }
-
-    const pipelineOptions = {
-        tddMode: args.includes('--tdd-mode'),
-        minimumCoverage: options.minimumCoverage || 80,
-        blockOnTDDViolations: args.includes('--block-on-tdd-violations'),
-        rustStrict: args.includes('--rust-strict'),
-        structured: args.includes('--structured'),
-        wasmEnabled: !args.includes('--no-wasm'), // Default: true (enable by default)
-        validateMarkdown: args.includes('--validate-markdown') // Default: false (opt-in)
-    };
-
-    // Pass validateMarkdown to run options
-    if (pipelineOptions.validateMarkdown) {
-        options.validateMarkdown = true;
-    }
-
-    const pipeline = new UnifiedPostEditPipeline(pipelineOptions);
-    const results = await pipeline.run(filePath, options);
-
-    if (pipelineOptions.structured) {
-        console.log('\n📋 STRUCTURED OUTPUT:');
-        console.log(JSON.stringify(results, null, 2));
-    }
-
-    // CRITICAL: Always exit with code 0 - hooks should never block operations
-    // Validation results are logged and stored, but don't prevent edits
-    if (!results.summary.success || results.blocking) {
-        console.log('\n⚠️ Validation issues detected - see report above');
-        console.log('   Edit completed successfully (hooks are non-blocking)');
-    }
-
-    process.exit(0);
-}
-
-// Run if called directly
-if (import.meta.url === `file://${process.argv[1]}`) {
-    main().catch(error => {
-        console.error('Pipeline error:', error);
-        process.exit(1);
-    });
-}
-
-export { UnifiedPostEditPipeline, SingleFileTestEngine, RustQualityEnforcer };