claude-code-automation/lib/perfect-recovery-system.js

🚀 Generic project automation system with anti-compaction protection and recovery capabilities. Automatically detects project type (React, Node.js, Python, Rust, Go, Java) and provides intelligent analysis. Claude Code optimized - run 'welcome' after inst

#!/usr/bin/env node

/**
 * Perfect Recovery System - 100% Context Reconstruction
 * NO COMPROMISE - MUST ACHIEVE 100% RECOVERY
 */

const fs = require('fs').promises;
const path = require('path');

class PerfectRecoverySystem {
    constructor() {
        this.recoveryScore = 0;
        this.contextData = new Map();
        this.criticalFiles = new Set();
        this.projectState = {};
        this.conversationHistory = [];
        this.decisionLog = [];
    }

    async executeFullRecovery() {
        console.log('🎯 EXECUTING 100% PERFECT RECOVERY...');
        
        try {
            // Phase 1: Complete data recovery
            await this.recoverAllProjectData();
            
            // Phase 2: Full context reconstruction
            await this.reconstructCompleteContext();
            
            // Phase 3: Conversation history rebuild
            await this.rebuildConversationHistory();
            
            // Phase 4: Decision tree reconstruction
            await this.reconstructDecisionTree();
            
            // Phase 5: Validate 100% recovery
            const validationResult = await this.validate100PercentRecovery();
            
            if (validationResult.score !== 1.0) {
                throw new Error(`Recovery failed: ${validationResult.score * 100}% - MUST BE 100%`);
            }

            console.log('✅ 100% PERFECT RECOVERY ACHIEVED');
            return { success: true, score: 1.0, status: 'PERFECT' };
            
        } catch (error) {
            console.error('❌ RECOVERY FAILED:', error.message);
            throw error;
        }
    }

    async recoverAllProjectData() {
        console.log('📁 Recovering ALL project data...');
        
        // Scan entire project structure
        const allFiles = await this.scanCompleteProject('.');
        
        // Read every single file
        for (const file of allFiles) {
            try {
                const content = await fs.readFile(file, 'utf8');
                const metadata = await fs.stat(file);
                
                this.contextData.set(file, {
                    content,
                    size: metadata.size,
                    modified: metadata.mtime,
                    created: metadata.birthtime,
                    hash: this.calculateHash(content)
                });
                
                // Mark as critical if contains important data
                if (this.isCriticalFile(file)) {
                    this.criticalFiles.add(file);
                }
                
            } catch (error) {
                console.warn(`⚠️ Could not read ${file}: ${error.message}`);
            }
        }
        
        console.log(`📊 Recovered ${this.contextData.size} files, ${this.criticalFiles.size} critical`);
    }

    async scanCompleteProject(dir, files = []) {
        const entries = await fs.readdir(dir, { withFileTypes: true });
        
        for (const entry of entries) {
            const fullPath = path.join(dir, entry.name);
            
            if (entry.isDirectory()) {
                // Skip node_modules and hidden dirs except important ones
                if (!entry.name.startsWith('.') || entry.name === '.backup' || entry.name === '.claude') {
                    await this.scanCompleteProject(fullPath, files);
                }
            } else {
                files.push(fullPath);
            }
        }
        
        return files;
    }

    isCriticalFile(file) {
        const criticalPatterns = [
            /package\.json$/,
            /\.js$/,
            /\.ts$/,
            /\.md$/,
            /CLAUDE\.md$/,
            /emergency-.*\.json$/,
            /recovery-.*\.md$/,
            /state-.*\.json$/,
            /battle-test-.*\.(js|test\.js)$/
        ];
        
        return criticalPatterns.some(pattern => pattern.test(file));
    }

    async reconstructCompleteContext() {
        console.log('🧠 Reconstructing COMPLETE context...');
        
        // Analyze package.json for project understanding
        const packageData = this.contextData.get('./package.json');
        if (packageData) {
            this.projectState.package = JSON.parse(packageData.content);
        }
        
        // Analyze CLAUDE.md for project instructions
        const claudeData = this.contextData.get('./CLAUDE.md');
        if (claudeData) {
            this.projectState.instructions = this.parseClaudeInstructions(claudeData.content);
        }
        
        // Analyze all source files for functionality
        this.projectState.sourceFiles = {};
        for (const [file, data] of this.contextData) {
            if (file.endsWith('.js') && !file.includes('node_modules')) {
                this.projectState.sourceFiles[file] = {
                    functions: this.extractFunctions(data.content),
                    classes: this.extractClasses(data.content),
                    exports: this.extractExports(data.content),
                    imports: this.extractImports(data.content),
                    complexity: this.calculateComplexity(data.content)
                };
            }
        }
        
        // Analyze documentation
        this.projectState.documentation = {};
        for (const [file, data] of this.contextData) {
            if (file.endsWith('.md')) {
                this.projectState.documentation[file] = {
                    sections: this.extractMarkdownSections(data.content),
                    wordCount: data.content.split(/\s+/).length,
                    lastModified: data.modified
                };
            }
        }
        
        // Analyze test files
        this.projectState.tests = {};
        for (const [file, data] of this.contextData) {
            if (file.includes('.test.') || file.includes('test-')) {
                this.projectState.tests[file] = {
                    testCases: this.extractTestCases(data.content),
                    coverage: this.estimateTestCoverage(data.content)
                };
            }
        }
    }

    async rebuildConversationHistory() {
        console.log('💬 Rebuilding conversation history...');
        
        // Scan recovery reports for conversation history
        const recoveryFiles = Array.from(this.contextData.keys())
            .filter(file => file.includes('recovery-report-'));
        
        for (const file of recoveryFiles) {
            const data = this.contextData.get(file);
            const historyItems = this.extractConversationItems(data.content);
            this.conversationHistory.push(...historyItems);
        }
        
        // Sort by timestamp
        this.conversationHistory.sort((a, b) => new Date(a.timestamp) - new Date(b.timestamp));
        
        console.log(`📜 Rebuilt ${this.conversationHistory.length} conversation items`);
    }

    async reconstructDecisionTree() {
        console.log('🌳 Reconstructing decision tree...');
        
        // Extract decisions from various sources
        const sources = [
            { pattern: /emergency-.*\.json$/, parser: this.parseEmergencyDecisions.bind(this) },
            { pattern: /state-.*\.json$/, parser: this.parseStateDecisions.bind(this) },
            { pattern: /CLAUDE\.md$/, parser: this.parseInstructionDecisions.bind(this) },
            { pattern: /battle-test-.*\.js$/, parser: this.parseCodeDecisions.bind(this) }
        ];
        
        for (const source of sources) {
            for (const [file, data] of this.contextData) {
                if (source.pattern.test(file)) {
                    const decisions = source.parser(data.content, file);
                    this.decisionLog.push(...decisions);
                }
            }
        }
        
        // Sort decisions chronologically
        this.decisionLog.sort((a, b) => new Date(a.timestamp) - new Date(b.timestamp));
        
        console.log(`🎯 Reconstructed ${this.decisionLog.length} decisions`);
    }

    async validate100PercentRecovery() {
        console.log('🔍 VALIDATING 100% RECOVERY...');
        
        const validations = {
            projectStructure: this.validateCompleteProjectStructure(),
            sourceCodeRecovery: this.validateAllSourceCode(),
            documentationRecovery: this.validateAllDocumentation(),
            testRecovery: this.validateAllTests(),
            configurationRecovery: this.validateAllConfiguration(),
            historyRecovery: this.validateConversationHistory(),
            decisionRecovery: this.validateDecisionTree(),
            dataIntegrity: this.validateDataIntegrity()
        };
        
        console.log('📊 Validation Results:');
        let totalScore = 0;
        let failedValidations = [];
        
        for (const [category, result] of Object.entries(validations)) {
            console.log(`  ${category}: ${(result.score * 100).toFixed(1)}%`);
            totalScore += result.score;
            
            if (result.score < 1.0) {
                failedValidations.push({
                    category,
                    score: result.score,
                    issues: result.issues
                });
            }
        }
        
        const overallScore = totalScore / Object.keys(validations).length;
        
        if (overallScore < 1.0) {
            console.error('❌ VALIDATION FAILED - NOT 100%');
            console.error('Failed validations:', failedValidations);
            throw new Error(`Recovery incomplete: ${(overallScore * 100).toFixed(1)}% - MUST BE 100%`);
        }
        
        return {
            score: overallScore,
            status: overallScore === 1.0 ? 'PERFECT' : 'FAILED',
            details: validations,
            failedValidations
        };
    }

    validateCompleteProjectStructure() {
        const requiredStructure = [
            'package.json',
            'CLAUDE.md',
            'src/',
            'docs/',
            'scripts/',
            'scripts/automation/'
        ];
        
        const existingItems = requiredStructure.filter(item => {
            return Array.from(this.contextData.keys()).some(file => 
                file.includes(item) || file === `./${item}`
            );
        });
        
        const score = existingItems.length / requiredStructure.length;
        
        return {
            score,
            issues: score < 1.0 ? [`Missing: ${requiredStructure.filter(item => !existingItems.includes(item)).join(', ')}`] : []
        };
    }

    validateAllSourceCode() {
        const jsFiles = Array.from(this.contextData.keys()).filter(file => 
            file.endsWith('.js') && !file.includes('node_modules')
        );
        
        let validFiles = 0;
        const issues = [];
        
        for (const file of jsFiles) {
            const data = this.contextData.get(file);
            if (data && data.content && data.content.trim().length > 0) {
                // Basic syntax validation
                try {
                    // Simple validation - check for basic JS structure
                    if (this.isValidJavaScript(data.content)) {
                        validFiles++;
                    } else {
                        issues.push(`Invalid JavaScript: ${file}`);
                    }
                } catch (error) {
                    issues.push(`Parse error in ${file}: ${error.message}`);
                }
            } else {
                issues.push(`Empty or missing content: ${file}`);
            }
        }
        
        const score = jsFiles.length > 0 ? validFiles / jsFiles.length : 1.0;
        return { score, issues };
    }

    validateAllDocumentation() {
        const mdFiles = Array.from(this.contextData.keys()).filter(file => file.endsWith('.md'));
        
        let validDocs = 0;
        const issues = [];
        
        for (const file of mdFiles) {
            const data = this.contextData.get(file);
            if (data && data.content && data.content.trim().length > 50) { // Minimum content
                validDocs++;
            } else {
                issues.push(`Insufficient documentation: ${file}`);
            }
        }
        
        const score = mdFiles.length > 0 ? validDocs / mdFiles.length : 1.0;
        return { score, issues };
    }

    validateAllTests() {
        const testFiles = Array.from(this.contextData.keys()).filter(file => 
            file.includes('.test.') || file.includes('test-')
        );
        
        if (testFiles.length === 0) {
            return { score: 0.5, issues: ['No test files found'] }; // 50% if no tests
        }
        
        let validTests = 0;
        const issues = [];
        
        for (const file of testFiles) {
            const data = this.contextData.get(file);
            if (data && this.hasValidTestStructure(data.content)) {
                validTests++;
            } else {
                issues.push(`Invalid test structure: ${file}`);
            }
        }
        
        const score = validTests / testFiles.length;
        return { score, issues };
    }

    validateAllConfiguration() {
        const configFiles = ['package.json', 'CLAUDE.md', 'vitest.config.js'];
        let validConfigs = 0;
        const issues = [];
        
        for (const configFile of configFiles) {
            const found = Array.from(this.contextData.keys()).find(file => 
                file.endsWith(configFile) || file === `./${configFile}`
            );
            
            if (found) {
                const data = this.contextData.get(found);
                if (data && data.content.trim().length > 0) {
                    validConfigs++;
                } else {
                    issues.push(`Empty configuration: ${configFile}`);
                }
            } else {
                issues.push(`Missing configuration: ${configFile}`);
            }
        }
        
        const score = validConfigs / configFiles.length;
        return { score, issues };
    }

    validateConversationHistory() {
        // Validate conversation history reconstruction
        const score = this.conversationHistory.length > 0 ? 1.0 : 0.0;
        const issues = score < 1.0 ? ['No conversation history recovered'] : [];
        
        return { score, issues };
    }

    validateDecisionTree() {
        // Validate decision tree reconstruction
        const score = this.decisionLog.length > 0 ? 1.0 : 0.0;
        const issues = score < 1.0 ? ['No decision history recovered'] : [];
        
        return { score, issues };
    }

    validateDataIntegrity() {
        // Validate data integrity across all files
        let integrityScore = 0;
        let totalFiles = 0;
        const issues = [];
        
        for (const [file, data] of this.contextData) {
            totalFiles++;
            
            // Check hash consistency (basic integrity)
            const currentHash = this.calculateHash(data.content);
            if (currentHash === data.hash) {
                integrityScore++;
            } else {
                issues.push(`Hash mismatch: ${file}`);
            }
        }
        
        const score = totalFiles > 0 ? integrityScore / totalFiles : 1.0;
        return { score, issues };
    }

    // Helper methods for parsing and extraction
    calculateHash(content) {
        // Simple hash for integrity checking
        let hash = 0;
        for (let i = 0; i < content.length; i++) {
            const char = content.charCodeAt(i);
            hash = ((hash << 5) - hash) + char;
            hash = hash & hash; // Convert to 32-bit integer
        }
        return hash.toString();
    }

    parseClaudeInstructions(content) {
        const sections = this.extractMarkdownSections(content);
        return {
            projectDescription: sections['# Calculator Suite - Enterprise Grade'] || '',
            techStack: sections['## Tech Stack'] || '',
            rules: sections['## Project Structure Rules'] || '',
            standards: sections['## Code Quality Standards'] || ''
        };
    }

    extractMarkdownSections(content) {
        const sections = {};
        const lines = content.split('\n');
        let currentSection = '';
        let currentContent = [];
        
        for (const line of lines) {
            if (line.startsWith('#')) {
                if (currentSection) {
                    sections[currentSection] = currentContent.join('\n');
                }
                currentSection = line;
                currentContent = [];
            } else {
                currentContent.push(line);
            }
        }
        
        if (currentSection) {
            sections[currentSection] = currentContent.join('\n');
        }
        
        return sections;
    }

    extractFunctions(content) {
        const functionRegex = /function\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\([^)]*\)|([a-zA-Z_$][a-zA-Z0-9_$]*)\s*[:=]\s*function/g;
        const functions = [];
        let match;
        
        while ((match = functionRegex.exec(content)) !== null) {
            functions.push(match[1] || match[2]);
        }
        
        return functions;
    }

    extractClasses(content) {
        const classRegex = /class\s+([a-zA-Z_$][a-zA-Z0-9_$]*)/g;
        const classes = [];
        let match;
        
        while ((match = classRegex.exec(content)) !== null) {
            classes.push(match[1]);
        }
        
        return classes;
    }

    extractExports(content) {
        const exportRegex = /module\.exports\s*=|export\s+(?:default\s+)?([^;]+)/g;
        const exports = [];
        let match;
        
        while ((match = exportRegex.exec(content)) !== null) {
            exports.push(match[1] || 'default');
        }
        
        return exports;
    }

    extractImports(content) {
        const importRegex = /require\s*\(\s*['"]([^'"]+)['"]\s*\)|import\s+.*?from\s+['"]([^'"]+)['"]/g;
        const imports = [];
        let match;
        
        while ((match = importRegex.exec(content)) !== null) {
            imports.push(match[1] || match[2]);
        }
        
        return imports;
    }

    calculateComplexity(content) {
        // Simple complexity metric based on control structures
        const complexityPatterns = [
            /if\s*\(/g,
            /for\s*\(/g,
            /while\s*\(/g,
            /switch\s*\(/g,
            /catch\s*\(/g,
            /function\s/g
        ];
        
        let complexity = 1; // Base complexity
        for (const pattern of complexityPatterns) {
            const matches = content.match(pattern);
            complexity += matches ? matches.length : 0;
        }
        
        return complexity;
    }

    extractTestCases(content) {
        const testRegex = /(?:it|test)\s*\(\s*['"]([^'"]+)['"]/g;
        const testCases = [];
        let match;
        
        while ((match = testRegex.exec(content)) !== null) {
            testCases.push(match[1]);
        }
        
        return testCases;
    }

    estimateTestCoverage(content) {
        const assertions = content.match(/expect\s*\(/g);
        const testCases = this.extractTestCases(content);
        
        if (testCases.length === 0) return 0;
        
        const assertionsPerTest = assertions ? assertions.length / testCases.length : 0;
        return Math.min(assertionsPerTest / 3, 1.0); // Normalize to 0-1
    }

    extractConversationItems(content) {
        // Extract conversation items from recovery reports
        const items = [];
        const lines = content.split('\n');
        
        for (const line of lines) {
            if (line.includes('User:') || line.includes('Assistant:')) {
                items.push({
                    type: line.includes('User:') ? 'user' : 'assistant',
                    content: line,
                    timestamp: new Date().toISOString() // Approximate
                });
            }
        }
        
        return items;
    }

    parseEmergencyDecisions(content, file) {
        try {
            const data = JSON.parse(content);
            return [{
                type: 'emergency',
                trigger: data.trigger,
                timestamp: new Date(data.timestamp).toISOString(),
                actions: data.protectionActions || [],
                source: file
            }];
        } catch {
            return [];
        }
    }

    parseStateDecisions(content, file) {
        try {
            const data = JSON.parse(content);
            return [{
                type: 'state',
                phase: data.phase,
                timestamp: new Date().toISOString(),
                metrics: data.keyMetrics,
                source: file
            }];
        } catch {
            return [];
        }
    }

    parseInstructionDecisions(content, file) {
        const decisions = [];
        const sections = this.extractMarkdownSections(content);
        
        for (const [section, sectionContent] of Object.entries(sections)) {
            if (section.includes('Rules') || section.includes('Standards')) {
                decisions.push({
                    type: 'instruction',
                    category: section,
                    content: sectionContent,
                    timestamp: new Date().toISOString(),
                    source: file
                });
            }
        }
        
        return decisions;
    }

    parseCodeDecisions(content, file) {
        const decisions = [];
        const classes = this.extractClasses(content);
        const functions = this.extractFunctions(content);
        
        if (classes.length > 0 || functions.length > 0) {
            decisions.push({
                type: 'implementation',
                classes,
                functions,
                complexity: this.calculateComplexity(content),
                timestamp: new Date().toISOString(),
                source: file
            });
        }
        
        return decisions;
    }

    isValidJavaScript(content) {
        // Basic JavaScript validation
        const requiredPatterns = [
            /[{}]/,  // Has braces
            /[;]/,   // Has semicolons or
            /function|class|const|let|var|=>/  // Has JS keywords
        ];
        
        return requiredPatterns.some(pattern => pattern.test(content));
    }

    hasValidTestStructure(content) {
        // Check for test structure
        const testPatterns = [
            /describe\s*\(/,
            /it\s*\(/,
            /test\s*\(/,
            /expect\s*\(/
        ];
        
        return testPatterns.some(pattern => pattern.test(content));
    }
}

// Execute perfect recovery if run directly
if (require.main === module) {
    const recovery = new PerfectRecoverySystem();
    recovery.executeFullRecovery()
        .then(result => {
            console.log('🎯 PERFECT RECOVERY COMPLETED:', result);
            process.exit(0);
        })
        .catch(error => {
            console.error('❌ PERFECT RECOVERY FAILED:', error.message);
            process.exit(1);
        });
}

module.exports = PerfectRecoverySystem;