claude-flow-novice 2.3.4 → 2.3.6

package/dist/scripts/post-edit-pipeline.js

@@ -1,2091 +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';
-
-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() {
-        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)
-        };
-    }
-
-    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.getJestCoverage(file);
-            } else if (framework === 'mocha') {
-                testResults = await this.runMochaSingleFile(file, isTestFile);
-            }
-
-            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.getPytestCoverage(file);
-            } else if (framework === 'unittest') {
-                testResults = await this.runUnittestSingleFile(file, isTestFile);
-            }
-
-            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.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 {
-            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 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 {
-            const result = await execAsync(`cargo test --message-format=json`, {
-                cwd: path.dirname(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 }
-        };
-    }
-
-    // Coverage analysis
-    async getJestCoverage(file) {
-        try {
-            await execAsync(`npx jest "${file}" --coverage --coverageReporters=json --silent`);
-
-            const coveragePath = path.join(process.cwd(), 'coverage', 'coverage-final.json');
-            const coverageData = JSON.parse(await fs.promises.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
-            };
-        }
-    }
-
-    async getPytestCoverage(file) {
-        try {
-            const result = await execAsync(`pytest "${file}" --cov="${path.dirname(file)}" --cov-report=json:/tmp/coverage.json`);
-
-            const coverageData = JSON.parse(await fs.promises.readFile('/tmp/coverage.json', 'utf8'));
-            const fileCoverage = coverageData.files[path.resolve(file)] || {};
-
-            return {
-                lines: {
-                    total: fileCoverage.summary?.num_statements || 0,
-                    covered: fileCoverage.summary?.covered_lines || 0,
-                    percentage: fileCoverage.summary?.percent_covered || 0
-                },
-                missing: fileCoverage.missing_lines || [],
-                executed: fileCoverage.executed_lines || []
-            };
-
-        } catch (error) {
-            return {
-                error: error.message,
-                available: false
-            };
-        }
-    }
-
-    async getRustCoverage(file) {
-        try {
-            // Try to check if cargo-tarpaulin is available
-            try {
-                await execAsync('cargo tarpaulin --version');
-            } catch {
-                return {
-                    error: 'cargo-tarpaulin not installed',
-                    available: false,
-                    suggestion: 'Install with: cargo install cargo-tarpaulin'
-                };
-            }
-
-            const projectDir = path.dirname(file);
-            let rootDir = projectDir;
-
-            // Find Cargo.toml root
-            while (rootDir !== path.dirname(rootDir)) {
-                if (fsSync.existsSync(path.join(rootDir, 'Cargo.toml'))) {
-                    break;
-                }
-                rootDir = path.dirname(rootDir);
-            }
-
-            const result = await execAsync(`cargo tarpaulin --out Json --output-dir /tmp`, {
-                cwd: rootDir
-            });
-
-            const coverageData = JSON.parse(await fs.promises.readFile('/tmp/tarpaulin-report.json', 'utf8'));
-
-            return {
-                lines: {
-                    total: coverageData.files[file]?.total_lines || 0,
-                    covered: coverageData.files[file]?.covered_lines || 0,
-                    percentage: coverageData.files[file]?.coverage || 0
-                },
-                overall: {
-                    percentage: coverageData.coverage || 0
-                }
-            };
-
-        } catch (error) {
-            return {
-                error: error.message,
-                available: false
-            };
-        }
-    }
-
-    async getGoCoverage(file) {
-        try {
-            const result = await execAsync(`go test -coverprofile=/tmp/coverage.out "${file}"`);
-
-            const coverageOutput = await fs.promises.readFile('/tmp/coverage.out', 'utf8');
-            const lines = coverageOutput.split('\n').filter(line => line.includes(file));
-
-            let totalStatements = 0;
-            let coveredStatements = 0;
-
-            lines.forEach(line => {
-                const match = line.match(/(\d+)\s+(\d+)\s+(\d+)/);
-                if (match) {
-                    const count = parseInt(match[3]);
-                    totalStatements++;
-                    if (count > 0) coveredStatements++;
-                }
-            });
-
-            const percentage = totalStatements > 0 ? Math.round((coveredStatements / totalStatements) * 100) : 0;
-
-            return {
-                lines: {
-                    total: totalStatements,
-                    covered: coveredStatements,
-                    percentage
-                }
-            };
-
-        } 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
-        };
-    }
-
-    async analyzeFile(filePath, content) {
-        const issues = [];
-        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.config = this.loadConfig();
-        this.testEngine = new SingleFileTestEngine();
-        this.rustEnforcer = new RustQualityEnforcer({
-            allowUnwrap: !this.rustStrict,
-            allowExpect: !this.rustStrict,  // In strict mode, also warn about .expect()
-            allowPanic: !this.rustStrict,
-            allowTodo: false,
-            allowUnimplemented: 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(), options = {}) {
-        const {
-            timeout = 30000,           // 30 second default timeout
-            maxBufferSize = 1024 * 1024, // 1MB max buffer size
-            killOnTimeout = true,
-            killOnOversize = true
-        } = options;
-
-        return new Promise((resolve, reject) => {
-            let stdout = '';
-            let stderr = '';
-            let killed = false;
-            let timeoutId;
-
-            const proc = spawn(command, args, {
-                cwd,
-                stdio: ['ignore', 'pipe', 'pipe'],
-                detached: false
-            });
-
-            // Set up timeout
-            if (timeout > 0) {
-                timeoutId = setTimeout(() => {
-                    if (!killed) {
-                        killed = true;
-                        console.warn(`⚠️  Process timeout: ${command} ${args.join(' ')} (${timeout}ms)`);
-
-                        if (killOnTimeout) {
-                            try {
-                                proc.kill('SIGTERM');
-                                setTimeout(() => {
-                                    try {
-                                        proc.kill('SIGKILL');
-                                    } catch (e) {
-                                        // Process already dead
-                                    }
-                                }, 5000);
-                            } catch (e) {
-                                // Process already dead
-                            }
-                        }
-
-                        resolve({
-                            code: 124, // timeout exit code
-                            stdout,
-                            stderr,
-                            killed: true,
-                            reason: 'timeout'
-                        });
-                    }
-                }, timeout);
-            }
-
-            // Handle stdout with size limits
-            proc.stdout.on('data', (data) => {
-                if (!killed) {
-                    const chunk = data.toString();
-
-                    // Check buffer size limit
-                    if (stdout.length + chunk.length > maxBufferSize) {
-                        if (killOnOversize) {
-                            killed = true;
-                            console.warn(`⚠️  Process output too large: ${command} ${args.join(' ')} (${stdout.length + chunk.length} > ${maxBufferSize} bytes)`);
-
-                            try {
-                                proc.kill('SIGKILL');
-                            } catch (e) {
-                                // Process already dead
-                            }
-
-                            resolve({
-                                code: 125, // output too large exit code
-                                stdout,
-                                stderr,
-                                killed: true,
-                                reason: 'oversize'
-                            });
-                        } else {
-                            // Truncate output
-                            stdout = stdout.substring(0, maxBufferSize - chunk.length) + chunk;
-                        }
-                    } else {
-                        stdout += chunk;
-                    }
-                }
-            });
-
-            // Handle stderr with size limits
-            proc.stderr.on('data', (data) => {
-                if (!killed) {
-                    const chunk = data.toString();
-
-                    // Check buffer size limit
-                    if (stderr.length + chunk.length > maxBufferSize) {
-                        if (killOnOversize) {
-                            killed = true;
-                            console.warn(`⚠️  Process error output too large: ${command} ${args.join(' ')} (${stderr.length + chunk.length} > ${maxBufferSize} bytes)`);
-
-                            try {
-                                proc.kill('SIGKILL');
-                            } catch (e) {
-                                // Process already dead
-                            }
-
-                            resolve({
-                                code: 125, // output too large exit code
-                                stdout,
-                                stderr,
-                                killed: true,
-                                reason: 'oversize'
-                            });
-                        } else {
-                            // Truncate output
-                            stderr = stderr.substring(0, maxBufferSize - chunk.length) + chunk;
-                        }
-                    } else {
-                        stderr += chunk;
-                    }
-                }
-            });
-
-            // Handle process completion
-            proc.on('close', (code) => {
-                if (!killed) {
-                    if (timeoutId) {
-                        clearTimeout(timeoutId);
-                    }
-                    resolve({ code, stdout, stderr, killed: false });
-                }
-            });
-
-            // Handle process errors
-            proc.on('error', (error) => {
-                if (!killed) {
-                    if (timeoutId) {
-                        clearTimeout(timeoutId);
-                    }
-                    resolve({ code: 1, stdout: '', stderr: error.message, killed: false });
-                }
-            });
-
-            // Handle process exit (additional safety)
-            proc.on('exit', (code, signal) => {
-                if (!killed) {
-                    if (timeoutId) {
-                        clearTimeout(timeoutId);
-                    }
-                    // Process already handled by 'close' event
-                }
-            });
-        });
-    }
-
-    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` };
-        }
-
-        // Format files with shorter timeout and smaller buffer
-        const result = await this.runCommand(tool, [...args, filePath], undefined, {
-            timeout: 10000,        // 10 second timeout for formatters
-            maxBufferSize: 512 * 1024  // 512KB buffer for formatters
-        });
-
-        return {
-            success: result.code === 0 && !result.killed,
-            message: result.killed
-                ? `Formatting ${result.reason === 'timeout' ? 'timed out' : 'output too large'}`
-                : (result.code === 0 ? 'Formatted successfully' : result.stderr),
-            output: result.stdout,
-            killed: result.killed,
-            reason: result.reason
-        };
-    }
-
-    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` };
-        }
-
-        // Lint files with moderate timeout and buffer
-        const result = await this.runCommand(tool, [...args, filePath], undefined, {
-            timeout: 15000,        // 15 second timeout for linters
-            maxBufferSize: 256 * 1024  // 256KB buffer for linters
-        });
-
-        return {
-            success: result.code === 0 && !result.killed,
-            message: result.killed
-                ? `Linting ${result.reason === 'timeout' ? 'timed out' : 'output too large'}`
-                : (result.code === 0 ? 'Linting passed' : 'Linting issues found'),
-            output: result.stdout + result.stderr,
-            issues: result.code !== 0 ? result.stderr : '',
-            killed: result.killed,
-            reason: result.reason
-        };
-    }
-
-    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` };
-        }
-
-        const projectDir = this.findProjectRoot(filePath);
-
-        // Type checking with longer timeout but smaller buffer (type errors can be verbose)
-        const result = await this.runCommand(tool, args, { cwd: projectDir }, {
-            timeout: 60000,        // 60 second timeout for type checkers (they can be slow)
-            maxBufferSize: 512 * 1024  // 512KB buffer for type checkers
-        });
-
-        return {
-            success: result.code === 0 && !result.killed,
-            message: result.killed
-                ? `Type checking ${result.reason === 'timeout' ? 'timed out' : 'output too large'}`
-                : (result.code === 0 ? 'Type checking passed' : 'Type errors found'),
-            output: result.stdout + result.stderr,
-            errors: result.code !== 0 ? result.stderr : '',
-            killed: result.killed,
-            reason: result.reason
-        };
-    }
-
-    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();
-    }
-
-    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;
-    }
-
-    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(), 'post-edit-pipeline.log');
-        const MAX_ENTRIES = 500;
-
-        const logEntry = {
-            timestamp: results.timestamp,
-            displayTimestamp: this.formatTimestamp(results.timestamp),
-            file: results.file,
-            editId: results.editId || 'N/A',
-            language: results.language,
-            agent: results.agentContext,
-            status: results.summary.success ? 'PASSED' : (results.blocking ? 'BLOCKED' : 'FAILED'),
-            tddMode: this.tddMode,
-            tddPhase: results.tddPhase || 'N/A',
-            errors: results.summary.errors.length,
-            warnings: results.summary.warnings.length,
-            steps: results.steps || {},
-            testing: results.testing || {},
-            coverage: results.coverage || {},
-            tddCompliance: results.tddCompliance || {},
-            rustQuality: results.rustQuality || {},
-            recommendations: results.recommendations || [],
-            details: {
-                errors: results.summary.errors,
-                warnings: results.summary.warnings,
-                suggestions: results.summary.suggestions
-            }
-        };
-
-        const logText = [
-            '═'.repeat(80),
-            `TIMESTAMP: ${logEntry.displayTimestamp}`,
-            `FILE: ${logEntry.file}`,
-            `EDIT ID: ${logEntry.editId}`,
-            `LANGUAGE: ${logEntry.language}`,
-            `STATUS: ${logEntry.status}`,
-            `TDD MODE: ${logEntry.tddMode ? 'ENABLED' : 'DISABLED'}`,
-            `TDD PHASE: ${logEntry.tddPhase}`,
-            '',
-            'AGENT CONTEXT:',
-            `  Memory Key: ${logEntry.agent.memoryKey || 'N/A'}`,
-            `  Agent Type: ${logEntry.agent.agentType || 'N/A'}`,
-            '',
-            'JSON:',
-            JSON.stringify(logEntry, null, 2),
-            '═'.repeat(80),
-            '',
-            ''
-        ].join('\n');
-
-        try {
-            let existingEntries = [];
-            if (fs.existsSync(logPath)) {
-                const existingLog = fs.readFileSync(logPath, 'utf8');
-                const entrySections = existingLog.split('═'.repeat(80)).filter(s => s.trim());
-
-                for (const section of entrySections) {
-                    const jsonStart = section.indexOf('JSON:');
-                    if (jsonStart !== -1) {
-                        const jsonText = section.substring(jsonStart + 5).trim();
-                        let braceCount = 0;
-                        let jsonEnd = 0;
-                        let inString = false;
-                        let escapeNext = false;
-
-                        for (let i = 0; i < jsonText.length; i++) {
-                            const char = jsonText[i];
-
-                            if (escapeNext) {
-                                escapeNext = false;
-                                continue;
-                            }
-
-                            if (char === '\\') {
-                                escapeNext = true;
-                                continue;
-                            }
-
-                            if (char === '"') {
-                                inString = !inString;
-                                continue;
-                            }
-
-                            if (!inString) {
-                                if (char === '{') braceCount++;
-                                if (char === '}') {
-                                    braceCount--;
-                                    if (braceCount === 0) {
-                                        jsonEnd = i + 1;
-                                        break;
-                                    }
-                                }
-                            }
-                        }
-
-                        if (jsonEnd > 0) {
-                            try {
-                                const entry = JSON.parse(jsonText.substring(0, jsonEnd));
-                                existingEntries.push(entry);
-                            } catch (e) {
-                                console.error(`Failed to parse JSON entry: ${e.message}`);
-                            }
-                        }
-                    }
-                }
-            }
-
-            existingEntries.unshift(logEntry);
-
-            if (existingEntries.length > MAX_ENTRIES) {
-                existingEntries = existingEntries.slice(0, MAX_ENTRIES);
-                console.log(`\n🗑️  Trimmed log to ${MAX_ENTRIES} most recent entries`);
-            }
-
-            const rebuiltLog = existingEntries.map(entry => {
-                return [
-                    '═'.repeat(80),
-                    `TIMESTAMP: ${entry.displayTimestamp}`,
-                    `FILE: ${entry.file}`,
-                    `EDIT ID: ${entry.editId || 'N/A'}`,
-                    `LANGUAGE: ${entry.language}`,
-                    `STATUS: ${entry.status}`,
-                    `TDD MODE: ${entry.tddMode ? 'ENABLED' : 'DISABLED'}`,
-                    `TDD PHASE: ${entry.tddPhase || 'N/A'}`,
-                    '',
-                    'AGENT CONTEXT:',
-                    `  Memory Key: ${entry.agent?.memoryKey || 'N/A'}`,
-                    `  Agent Type: ${entry.agent?.agentType || 'N/A'}`,
-                    '',
-                    'JSON:',
-                    JSON.stringify(entry, null, 2),
-                    '═'.repeat(80),
-                    '',
-                    ''
-                ].join('\n');
-            }).join('');
-
-            fs.writeFileSync(logPath, rebuiltLog, 'utf8');
-
-            console.log(`\n📝 Logged to: ${logPath} (${existingEntries.length}/${MAX_ENTRIES} entries)`);
-        } catch (error) {
-            console.error(`⚠️  Failed to write log: ${error.message}`);
-        }
-    }
-
-    async run(filePath, options = {}) {
-        const language = this.detectLanguage(filePath);
-
-        // Bypass non-code files (config/documentation)
-        const bypassExtensions = ['.toml', '.md', '.txt', '.json', '.yaml', '.yml'];
-        const ext = path.extname(filePath).toLowerCase();
-        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
-            if (results.testing.coverage) {
-                results.coverage = results.testing.coverage;
-
-                if (results.coverage.lines) {
-                    const coveragePercent = results.coverage.lines.percentage;
-                    Logger.coverage(`Line coverage: ${coveragePercent}%`);
-
-                    if (coveragePercent < this.minimumCoverage) {
-                        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
-// Memory and process monitoring
-class ProcessMonitor {
-    constructor(maxMemoryMB = 500, maxDurationMs = 300000) {
-        this.maxMemoryMB = maxMemoryMB;
-        this.maxDurationMs = maxDurationMs;
-        this.startTime = Date.now();
-        this.monitoring = false;
-        this.monitorInterval = null;
-    }
-
-    start() {
-        if (this.monitoring) return;
-        this.monitoring = true;
-
-        this.monitorInterval = setInterval(() => {
-            this.checkMemory();
-            this.checkDuration();
-        }, 5000); // Check every 5 seconds
-    }
-
-    stop() {
-        if (this.monitorInterval) {
-            clearInterval(this.monitorInterval);
-            this.monitorInterval = null;
-        }
-        this.monitoring = false;
-    }
-
-    checkMemory() {
-        const memoryUsage = process.memoryUsage();
-        const memoryMB = memoryUsage.heapUsed / 1024 / 1024;
-
-        if (memoryMB > this.maxMemoryMB) {
-            console.error(`🚨 MEMORY LIMIT EXCEEDED: ${memoryMB.toFixed(1)}MB > ${this.maxMemoryMB}MB`);
-            console.error('🔥 EMERGENCY SHUTDOWN - Process killed to prevent system crash');
-
-            // Force cleanup before exit
-            this.cleanup();
-            process.exit(137); // SIGKILL exit code
-        }
-
-        // Warning at 80% of limit
-        if (memoryMB > this.maxMemoryMB * 0.8) {
-            console.warn(`⚠️  High memory usage: ${memoryMB.toFixed(1)}MB (limit: ${this.maxMemoryMB}MB)`);
-        }
-    }
-
-    checkDuration() {
-        const elapsed = Date.now() - this.startTime;
-
-        if (elapsed > this.maxDurationMs) {
-            console.error(`🚨 TIME LIMIT EXCEEDED: ${(elapsed / 1000).toFixed(1)}s > ${(this.maxDurationMs / 1000).toFixed(1)}s`);
-            console.error('🔥 EMERGENCY SHUTDOWN - Process killed to prevent hanging');
-
-            this.cleanup();
-            process.exit(124); // timeout exit code
-        }
-    }
-
-    cleanup() {
-        // Clean up any spawned processes
-        try {
-            // Kill any child processes
-            process.kill(0, 'SIGTERM');
-        } catch (e) {
-            // Ignore errors
-        }
-    }
-}
-
-async function main() {
-    const filePath = process.argv[2];
-
-    if (!filePath) {
-        console.log(`
-🔴🟢♻️ UNIFIED POST-EDIT PIPELINE - v3.0.0 (Memory-Safe)
-
-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
-  --max-memory <MB>               Maximum memory usage (default: 500MB)
-  --max-duration <seconds>        Maximum execution time (default: 300s)
-
-Examples:
-  node post-edit-pipeline.js src/app.js --tdd-mode --minimum-coverage 90
-  node post-edit-pipeline.js src/lib.rs --rust-strict --max-memory 1000
-  node post-edit-pipeline.js src/test.ts --tdd-mode --max-duration 600
-
-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
-  ✅ Memory leak protection and auto-kill safeguards
-        `);
-        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++;
-        }
-    }
-
-    // Initialize process monitor with limits
-    const maxMemoryMB = (() => {
-        const memArg = args.find(arg => arg.startsWith('--max-memory='));
-        return memArg ? parseInt(memArg.split('=')[1]) : 500;
-    })();
-
-    const maxDurationMs = (() => {
-        const durArg = args.find(arg => arg.startsWith('--max-duration='));
-        return durArg ? parseInt(durArg.split('=')[1]) * 1000 : 300000; // 5 minutes default
-    })();
-
-    const monitor = new ProcessMonitor(maxMemoryMB, maxDurationMs);
-    monitor.start();
-
-    console.log(`🛡️  Process limits: ${maxMemoryMB}MB memory, ${(maxDurationMs / 1000).toFixed(0)}s duration`);
-
-    try {
-        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')
-        };
-
-        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));
-        }
-
-        monitor.stop();
-        process.exit(results.summary.success && !results.blocking ? 0 : 1);
-
-    } catch (error) {
-        console.error('💥 Pipeline error:', error.message);
-        monitor.stop();
-        process.exit(1);
-    }
-}
-
-// 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 };