agentic-flow 2.0.1 → 2.0.2-alpha

package/dist/intelligence/agent-booster-enhanced.js

@@ -1,1143 +0,0 @@
-/**
- * RuVector-Enhanced Agent Booster v2
- *
- * Full upgrade with all RuVector capabilities:
- * - Semantic fuzzy matching (cosine similarity on embeddings)
- * - ONNX embeddings for semantic code understanding
- * - Parallel batch apply for multi-file edits
- * - Context-aware prefetch (predict likely edits)
- * - Error pattern learning (learn what NOT to do)
- * - TensorCompress for 10x more patterns in memory
- * - SONA continual learning with EWC++
- * - GNN differentiable search
- *
- * Performance targets:
- * - Exact match: 0ms
- * - Fuzzy match: 1-5ms
- * - Cache miss: 650ms (agent-booster)
- * - Pattern capacity: 100,000+ with compression
- */
-import { execSync, exec } from 'child_process';
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
-import { extname, join } from 'path';
-import { homedir } from 'os';
-import { promisify } from 'util';
-const execAsync = promisify(exec);
-// RuVector imports
-let IntelligenceEngine = null;
-let createIntelligenceEngine = null;
-let differentiableSearch = null;
-let isGnnAvailable = null;
-let TensorCompress = null;
-try {
-    const ruvector = await import('ruvector');
-    IntelligenceEngine = ruvector.IntelligenceEngine;
-    createIntelligenceEngine = ruvector.createIntelligenceEngine;
-    differentiableSearch = ruvector.differentiableSearch;
-    isGnnAvailable = ruvector.isGnnAvailable;
-    TensorCompress = ruvector.TensorCompress;
-}
-catch {
-    // RuVector not available
-}
-/**
- * RuVector-Enhanced Agent Booster v2
- */
-export class EnhancedAgentBooster {
-    intelligence;
-    patterns = new Map();
-    patternEmbeddings = [];
-    patternIds = [];
-    errorPatterns = new Map();
-    coEditGraph = new Map();
-    tensorCompress = null;
-    stats;
-    storagePath;
-    initialized = false;
-    onnxReady = false;
-    enableOnnx;
-    fuzzyThreshold = 0.85; // Cosine similarity threshold for fuzzy match
-    maxPatterns;
-    totalPatternAccesses = 0; // Total accesses across all patterns for frequency calc
-    lastRecompressionTime = 0; // Timestamp of last recompression cycle
-    recompressionInterval = 300000; // Recompress every 5 minutes
-    constructor(options = {}) {
-        this.storagePath = options.storagePath || join(homedir(), '.agentic-flow', 'booster-patterns-v2');
-        this.enableOnnx = options.enableOnnx ?? true; // Enable by default in v2
-        this.maxPatterns = options.maxPatterns || 100000;
-        this.fuzzyThreshold = options.fuzzyThreshold || 0.85;
-        // Initialize stats
-        this.stats = {
-            totalEdits: 0,
-            cacheHits: 0,
-            fuzzyHits: 0,
-            gnnHits: 0,
-            cacheMisses: 0,
-            avgLatency: 0,
-            avgConfidence: 0.8,
-            patternsLearned: 0,
-            errorPatternsLearned: 0,
-            sonaUpdates: 0,
-            gnnSearches: 0,
-            hitRate: '0%',
-            confidenceImprovement: '0%',
-            compressionRatio: '1:1',
-            onnxEnabled: false,
-            tierDistribution: { hot: 0, warm: 0, cool: 0, cold: 0, archive: 0 },
-            totalPatternAccesses: 0,
-            memorySavings: '0%'
-        };
-        // Initialize TensorCompress if available
-        if (TensorCompress) {
-            try {
-                this.tensorCompress = new TensorCompress();
-            }
-            catch {
-                // Not available
-            }
-        }
-        // Initialize RuVector intelligence if available
-        if (createIntelligenceEngine) {
-            this.intelligence = createIntelligenceEngine({
-                embeddingDim: 384, // Higher dim for ONNX
-                maxMemories: this.maxPatterns,
-                maxEpisodes: 50000,
-                enableSona: options.enableSona !== false,
-                enableAttention: true,
-                enableOnnx: this.enableOnnx,
-                storagePath: this.storagePath,
-                learningRate: 0.1
-            });
-        }
-    }
-    /**
-     * Initialize the enhanced booster (load patterns, init ONNX)
-     */
-    async init() {
-        if (this.initialized)
-            return;
-        // Ensure storage directory exists
-        if (!existsSync(this.storagePath)) {
-            mkdirSync(this.storagePath, { recursive: true });
-        }
-        // Load persisted patterns
-        const patternsFile = join(this.storagePath, 'patterns-v2.json');
-        if (existsSync(patternsFile)) {
-            try {
-                const data = JSON.parse(readFileSync(patternsFile, 'utf8'));
-                for (const pattern of data.patterns || []) {
-                    // Ensure new fields have defaults for older patterns
-                    pattern.accessCount = pattern.accessCount || pattern.successCount || 1;
-                    pattern.createdAt = pattern.createdAt || pattern.lastUsed || Date.now();
-                    pattern.compressionTier = pattern.compressionTier || (pattern.compressed ? 'half' : 'none');
-                    this.patterns.set(pattern.id, pattern);
-                    if (pattern.embedding) {
-                        this.patternEmbeddings.push(new Float32Array(pattern.embedding));
-                        this.patternIds.push(pattern.id);
-                    }
-                }
-                // Load error patterns
-                for (const ep of data.errorPatterns || []) {
-                    this.errorPatterns.set(ep.pattern, ep);
-                }
-                // Load co-edit graph
-                if (data.coEditGraph) {
-                    for (const [file, edges] of Object.entries(data.coEditGraph)) {
-                        this.coEditGraph.set(file, new Map(Object.entries(edges)));
-                    }
-                }
-                // Restore access tracking state
-                this.totalPatternAccesses = data.totalPatternAccesses || 0;
-                this.lastRecompressionTime = data.lastRecompressionTime || 0;
-                this.stats = { ...this.stats, ...data.stats };
-            }
-            catch {
-                // Start fresh
-            }
-        }
-        // Load intelligence state
-        const intelligenceFile = join(this.storagePath, 'intelligence-v2.json');
-        if (existsSync(intelligenceFile) && this.intelligence) {
-            try {
-                const data = JSON.parse(readFileSync(intelligenceFile, 'utf8'));
-                this.intelligence.import(data, true);
-            }
-            catch {
-                // Start fresh
-            }
-        }
-        // Initialize ONNX embeddings asynchronously
-        if (this.enableOnnx && this.intelligence) {
-            this.initOnnxAsync();
-        }
-        this.initialized = true;
-    }
-    /**
-     * Initialize ONNX in background (non-blocking)
-     */
-    async initOnnxAsync() {
-        try {
-            // Test ONNX embedding
-            await this.intelligence.embedAsync('test');
-            this.onnxReady = true;
-            this.stats.onnxEnabled = true;
-        }
-        catch {
-            this.onnxReady = false;
-        }
-    }
-    /**
-     * Calculate access frequency for a pattern
-     * Based on pattern access count relative to total accesses
-     *
-     * Compression Tiers:
-     * | Data Type             | Access Freq | Compression | Memory Savings |
-     * |-----------------------|-------------|-------------|----------------|
-     * | Hot patterns (recent) | >0.8        | none        | 0%             |
-     * | Warm patterns         | >0.4        | half        | 50%            |
-     * | Cool patterns         | >0.1        | pq8         | 87.5%          |
-     * | Cold patterns         | >0.01       | pq4         | 93.75%         |
-     * | Archive               | ≤0.01       | binary      | 96.9%          |
-     */
-    calculateAccessFrequency(pattern) {
-        if (this.totalPatternAccesses === 0)
-            return 1.0; // New pattern starts hot
-        // Calculate base frequency from access count
-        const accessRatio = pattern.accessCount / this.totalPatternAccesses;
-        // Factor in recency (patterns used recently get a boost)
-        const ageMs = Date.now() - pattern.lastUsed;
-        const recencyBoost = Math.exp(-ageMs / (24 * 60 * 60 * 1000)); // Decay over 24 hours
-        // Factor in success rate (successful patterns are more "hot")
-        const totalUses = pattern.successCount + pattern.failureCount;
-        const successBoost = totalUses > 0 ? pattern.successCount / totalUses : 0.5;
-        // Combine factors: 50% access ratio, 30% recency, 20% success
-        const frequency = accessRatio * 0.5 + recencyBoost * 0.3 + successBoost * 0.2;
-        return Math.min(1.0, Math.max(0, frequency));
-    }
-    /**
-     * Get compression tier based on access frequency
-     */
-    getCompressionTier(accessFreq) {
-        if (accessFreq > 0.8)
-            return 'none'; // Hot: no compression (0% savings)
-        if (accessFreq > 0.4)
-            return 'half'; // Warm: 50% savings
-        if (accessFreq > 0.1)
-            return 'pq8'; // Cool: 87.5% savings
-        if (accessFreq > 0.01)
-            return 'pq4'; // Cold: 93.75% savings
-        return 'binary'; // Archive: 96.9% savings
-    }
-    /**
-     * Apply tiered compression to an embedding
-     */
-    applyTieredCompression(embedding, tier) {
-        if (!this.tensorCompress || tier === 'none') {
-            return Array.from(embedding);
-        }
-        try {
-            // Configure TensorCompress for the tier
-            const config = {
-                'half': { levelType: 'half' },
-                'pq8': { levelType: 'pq8' },
-                'pq4': { levelType: 'pq4' },
-                'binary': { levelType: 'binary' }
-            };
-            // Create tier-specific compressor
-            const tierCompress = new TensorCompress(config[tier]);
-            const compressedJson = tierCompress.compress(Array.from(embedding));
-            // For storage, we keep compressed form; for search we decompress
-            return tierCompress.decompress(compressedJson);
-        }
-        catch {
-            return Array.from(embedding);
-        }
-    }
-    /**
-     * Periodically recompress patterns based on updated access frequencies
-     */
-    async recompressPatterns() {
-        const now = Date.now();
-        if (now - this.lastRecompressionTime < this.recompressionInterval) {
-            return { recompressed: 0, tierChanges: {} };
-        }
-        this.lastRecompressionTime = now;
-        let recompressed = 0;
-        const tierChanges = {
-            'none→half': 0, 'none→pq8': 0, 'none→pq4': 0, 'none→binary': 0,
-            'half→none': 0, 'half→pq8': 0, 'half→pq4': 0, 'half→binary': 0,
-            'pq8→none': 0, 'pq8→half': 0, 'pq8→pq4': 0, 'pq8→binary': 0,
-            'pq4→none': 0, 'pq4→half': 0, 'pq4→pq8': 0, 'pq4→binary': 0,
-            'binary→none': 0, 'binary→half': 0, 'binary→pq8': 0, 'binary→pq4': 0
-        };
-        for (const [id, pattern] of this.patterns) {
-            const accessFreq = this.calculateAccessFrequency(pattern);
-            const newTier = this.getCompressionTier(accessFreq);
-            const oldTier = pattern.compressionTier || 'none';
-            if (newTier !== oldTier) {
-                // Re-compress with new tier
-                const changeKey = `${oldTier}→${newTier}`;
-                if (changeKey in tierChanges) {
-                    tierChanges[changeKey]++;
-                }
-                // Re-embed and compress
-                const embedding = await this.embed((pattern.codeNormalized || pattern.codeHash) + '\n' + pattern.editHash);
-                pattern.embedding = this.applyTieredCompression(embedding, newTier);
-                pattern.compressionTier = newTier;
-                pattern.compressed = newTier !== 'none';
-                // Update embedding cache
-                const idx = this.patternIds.indexOf(id);
-                if (idx >= 0) {
-                    this.patternEmbeddings[idx] = new Float32Array(pattern.embedding);
-                }
-                recompressed++;
-            }
-        }
-        return { recompressed, tierChanges };
-    }
-    /**
-     * Apply code edit with full RuVector enhancement
-     */
-    async apply(request) {
-        await this.init();
-        const startTime = Date.now();
-        this.stats.totalEdits++;
-        // Trigger periodic recompression based on access patterns
-        // This runs asynchronously in the background, not blocking the edit
-        this.recompressPatterns().catch(() => { });
-        // 0. Check error patterns first (avoid known bad edits)
-        const errorCheck = this.checkErrorPatterns(request);
-        if (errorCheck) {
-            return {
-                output: errorCheck.suggestedFix,
-                success: true,
-                latency: Date.now() - startTime,
-                confidence: 0.9,
-                strategy: 'error_avoided',
-                cacheHit: true,
-                learned: false,
-                patternId: `error:${errorCheck.pattern}`
-            };
-        }
-        // 1. Check exact pattern cache
-        const exactResult = this.checkExactCache(request);
-        if (exactResult) {
-            const latency = Date.now() - startTime;
-            this.stats.cacheHits++;
-            this.updateStats(latency, exactResult.confidence);
-            return {
-                output: exactResult.output,
-                success: true,
-                latency,
-                confidence: exactResult.confidence,
-                strategy: 'exact_cache',
-                cacheHit: true,
-                learned: false,
-                patternId: exactResult.id
-            };
-        }
-        // 2. Try semantic fuzzy matching (cosine similarity)
-        const fuzzyResult = await this.fuzzyMatch(request);
-        if (fuzzyResult) {
-            const latency = Date.now() - startTime;
-            this.stats.fuzzyHits++;
-            this.updateStats(latency, fuzzyResult.confidence);
-            return {
-                output: fuzzyResult.output,
-                success: true,
-                latency,
-                confidence: fuzzyResult.confidence,
-                strategy: 'fuzzy_match',
-                cacheHit: true,
-                learned: false,
-                patternId: fuzzyResult.id,
-                fuzzyScore: fuzzyResult.score,
-                similarPatterns: fuzzyResult.similarCount
-            };
-        }
-        // 3. Try GNN differentiable search
-        const gnnResult = await this.gnnMatch(request);
-        if (gnnResult && gnnResult.confidence > 0.8) {
-            const latency = Date.now() - startTime;
-            this.stats.gnnHits++;
-            this.stats.gnnSearches++;
-            this.updateStats(latency, gnnResult.confidence);
-            return {
-                output: gnnResult.output,
-                success: true,
-                latency,
-                confidence: gnnResult.confidence,
-                strategy: 'gnn_match',
-                cacheHit: false,
-                learned: false,
-                patternId: gnnResult.id,
-                similarPatterns: gnnResult.similarCount
-            };
-        }
-        this.stats.cacheMisses++;
-        // 4. Fall back to agent-booster
-        const boosterResult = await this.callAgentBooster(request);
-        const latency = Date.now() - startTime;
-        // 5. Learn from the result
-        if (boosterResult.success) {
-            await this.learnPattern(request, boosterResult);
-        }
-        else {
-            // Learn from failure
-            this.learnError(request, boosterResult);
-        }
-        // 6. Record co-edit if file path provided
-        if (request.filePath) {
-            this.recordCoEdit(request.filePath);
-        }
-        this.updateStats(latency, boosterResult.confidence);
-        return {
-            ...boosterResult,
-            latency,
-            strategy: boosterResult.success ? 'agent_booster' : 'fallback',
-            cacheHit: false,
-            learned: boosterResult.success
-        };
-    }
-    /**
-     * Apply multiple edits in parallel
-     */
-    async applyBatch(requests, maxConcurrency = 4) {
-        await this.init();
-        const results = [];
-        const chunks = [];
-        // Split into chunks
-        for (let i = 0; i < requests.length; i += maxConcurrency) {
-            chunks.push(requests.slice(i, i + maxConcurrency));
-        }
-        // Process chunks in parallel
-        for (const chunk of chunks) {
-            const chunkResults = await Promise.all(chunk.map(req => this.apply(req)));
-            results.push(...chunkResults);
-        }
-        return results;
-    }
-    /**
-     * Prefetch likely edits based on context
-     */
-    async prefetch(filePath) {
-        await this.init();
-        const ext = extname(filePath).slice(1);
-        const language = this.extToLanguage(ext);
-        const likelyEdits = [];
-        // Get co-edited files
-        const coEdits = this.coEditGraph.get(filePath);
-        if (coEdits) {
-            const sorted = Array.from(coEdits.entries())
-                .sort((a, b) => b[1] - a[1])
-                .slice(0, 5);
-            for (const [file] of sorted) {
-                likelyEdits.push(`Edit ${file}`);
-            }
-        }
-        // Get common edit types for this language
-        const langPatterns = Array.from(this.patterns.values())
-            .filter(p => p.language === language)
-            .sort((a, b) => b.successCount - a.successCount)
-            .slice(0, 5);
-        for (const pattern of langPatterns) {
-            if (pattern.editType) {
-                likelyEdits.push(pattern.editType);
-            }
-        }
-        // Pre-warm embeddings for likely patterns
-        if (this.onnxReady && langPatterns.length > 0) {
-            // Generate embeddings in background
-            Promise.all(langPatterns.map(p => this.embed(p.codeNormalized || ''))).catch(() => { });
-        }
-        return {
-            file: filePath,
-            likelyEdits,
-            confidence: likelyEdits.length > 0 ? 0.7 : 0.3
-        };
-    }
-    /**
-     * Check for exact pattern match
-     */
-    checkExactCache(request) {
-        if (this.patterns.size === 0)
-            return null;
-        const codeHash = this.hash(request.code);
-        const editHash = this.hash(request.edit);
-        const exactKey = `${codeHash}:${editHash}:${request.language}`;
-        const exactMatch = this.patterns.get(exactKey);
-        if (exactMatch && exactMatch.output) {
-            exactMatch.lastUsed = Date.now();
-            exactMatch.successCount++;
-            exactMatch.accessCount = (exactMatch.accessCount || 0) + 1;
-            this.totalPatternAccesses++;
-            return exactMatch;
-        }
-        return null;
-    }
-    /**
-     * Semantic fuzzy matching using cosine similarity
-     */
-    async fuzzyMatch(request) {
-        if (this.patternEmbeddings.length < 3)
-            return null;
-        try {
-            // Generate embedding for request
-            const queryEmbed = await this.embed(this.normalizeCode(request.code) + '\n' + request.edit);
-            // Find best match using cosine similarity
-            let bestScore = 0;
-            let bestIdx = -1;
-            const scores = [];
-            for (let i = 0; i < this.patternEmbeddings.length; i++) {
-                const score = this.cosineSimilarity(queryEmbed, this.patternEmbeddings[i]);
-                scores.push(score);
-                if (score > bestScore) {
-                    bestScore = score;
-                    bestIdx = i;
-                }
-            }
-            if (bestScore < this.fuzzyThreshold || bestIdx < 0)
-                return null;
-            const patternId = this.patternIds[bestIdx];
-            const pattern = this.patterns.get(patternId);
-            if (!pattern || !pattern.output)
-                return null;
-            // Track access for compression tiering
-            pattern.accessCount = (pattern.accessCount || 0) + 1;
-            pattern.lastUsed = Date.now();
-            this.totalPatternAccesses++;
-            // Count similar patterns above threshold
-            const similarCount = scores.filter(s => s >= this.fuzzyThreshold).length;
-            // Adjust confidence based on success rate
-            const successRate = pattern.successCount / (pattern.successCount + pattern.failureCount + 1);
-            const adjustedConfidence = bestScore * 0.6 + successRate * 0.4;
-            // Transform output if needed (e.g., var x → var y)
-            const transformedOutput = this.transformOutput(request.code, request.edit, pattern.codeNormalized || '', pattern.output);
-            return {
-                output: transformedOutput,
-                confidence: adjustedConfidence,
-                id: patternId,
-                score: bestScore,
-                similarCount
-            };
-        }
-        catch {
-            return null;
-        }
-    }
-    /**
-     * Transform cached output for similar but not identical code
-     */
-    transformOutput(newCode, newEdit, cachedCode, cachedOutput) {
-        // Extract variable names from new code
-        const newVars = newCode.match(/\b(var|let|const)\s+(\w+)/g) || [];
-        const cachedVars = cachedCode.match(/\b(var|let|const)\s+(\w+)/g) || [];
-        if (newVars.length === 1 && cachedVars.length === 1) {
-            const newVar = newVars[0].split(/\s+/)[1];
-            const cachedVar = cachedVars[0].split(/\s+/)[1];
-            if (newVar !== cachedVar) {
-                // Replace variable name in output
-                return cachedOutput.replace(new RegExp(`\\b${cachedVar}\\b`, 'g'), newVar);
-            }
-        }
-        return cachedOutput;
-    }
-    /**
-     * GNN-based pattern matching using differentiable search
-     */
-    async gnnMatch(request) {
-        if (!differentiableSearch || !isGnnAvailable?.() || this.patternEmbeddings.length < 5) {
-            return null;
-        }
-        try {
-            const queryEmbed = await this.embed(request.code + '\n' + request.edit);
-            const result = differentiableSearch(queryEmbed, this.patternEmbeddings, Math.min(5, this.patternEmbeddings.length), 0.5);
-            if (result.indices.length === 0)
-                return null;
-            const bestIdx = result.indices[0];
-            const bestWeight = result.weights[0];
-            const patternId = this.patternIds[bestIdx];
-            const pattern = this.patterns.get(patternId);
-            if (!pattern || !pattern.output || bestWeight < 0.7)
-                return null;
-            const successRate = pattern.successCount / (pattern.successCount + pattern.failureCount + 1);
-            const adjustedConfidence = bestWeight * 0.7 + successRate * 0.3;
-            return {
-                output: pattern.output,
-                confidence: adjustedConfidence,
-                id: patternId,
-                similarCount: result.indices.length
-            };
-        }
-        catch {
-            return null;
-        }
-    }
-    /**
-     * Check error patterns to avoid known bad edits
-     */
-    checkErrorPatterns(request) {
-        const normalized = this.normalizeCode(request.code + request.edit);
-        for (const [pattern, errorInfo] of this.errorPatterns) {
-            if (normalized.includes(pattern) && errorInfo.occurrences >= 2) {
-                return errorInfo;
-            }
-        }
-        return null;
-    }
-    /**
-     * Learn from a failed edit
-     */
-    learnError(request, result) {
-        const pattern = this.normalizeCode(request.code.substring(0, 100));
-        const existing = this.errorPatterns.get(pattern);
-        if (existing) {
-            existing.occurrences++;
-            existing.lastSeen = Date.now();
-        }
-        else {
-            this.errorPatterns.set(pattern, {
-                pattern,
-                errorType: 'edit_failed',
-                suggestedFix: request.code, // Keep original
-                occurrences: 1,
-                lastSeen: Date.now()
-            });
-            this.stats.errorPatternsLearned++;
-        }
-    }
-    // Security: Allowlist of valid languages for agent-booster
-    static VALID_LANGUAGES = new Set([
-        'javascript', 'typescript', 'python', 'rust', 'go', 'java', 'c', 'cpp',
-        'ruby', 'php', 'swift', 'kotlin', 'scala', 'haskell', 'lua', 'perl',
-        'r', 'julia', 'dart', 'elixir', 'clojure', 'shell', 'bash', 'powershell',
-        'sql', 'html', 'css', 'json', 'yaml', 'xml', 'markdown', 'plaintext'
-    ]);
-    /**
-     * Call underlying agent-booster CLI
-     */
-    async callAgentBooster(request) {
-        try {
-            // Security: Validate language against allowlist to prevent command injection
-            const normalizedLanguage = request.language.toLowerCase().trim();
-            if (!EnhancedAgentBooster.VALID_LANGUAGES.has(normalizedLanguage)) {
-                // Fall back to plaintext for unknown languages instead of throwing
-                console.warn(`[AgentBooster] Unknown language '${request.language}', using 'plaintext'`);
-            }
-            const safeLanguage = EnhancedAgentBooster.VALID_LANGUAGES.has(normalizedLanguage)
-                ? normalizedLanguage
-                : 'plaintext';
-            // Security: Use execSync with argument array pattern via shell: false
-            // Note: We still use execSync here because we need stdin input, but we validate the language
-            const { spawnSync } = await import('child_process');
-            const result = spawnSync('npx', ['--yes', 'agent-booster@0.2.2', 'apply', '--language', safeLanguage], {
-                encoding: 'utf-8',
-                input: JSON.stringify({ code: request.code, edit: request.edit }),
-                maxBuffer: 10 * 1024 * 1024,
-                timeout: 30000
-            });
-            if (result.error || result.status !== 0) {
-                throw new Error(result.stderr || 'Agent booster failed');
-            }
-            const parsed = JSON.parse(result.stdout || '{}');
-            return {
-                output: parsed.output || '',
-                success: parsed.success || false,
-                latency: parsed.latency || 0,
-                confidence: parsed.confidence || 0,
-                strategy: 'agent_booster',
-                cacheHit: false,
-                learned: false
-            };
-        }
-        catch {
-            return {
-                output: '',
-                success: false,
-                latency: 0,
-                confidence: 0,
-                strategy: 'fallback',
-                cacheHit: false,
-                learned: false
-            };
-        }
-    }
-    /**
-     * Learn a successful pattern
-     */
-    async learnPattern(request, result) {
-        if (!result.success || result.confidence < 0.5)
-            return;
-        const codeHash = this.hash(request.code);
-        const editHash = this.hash(request.edit);
-        const patternId = `${codeHash}:${editHash}:${request.language}`;
-        // Generate embedding
-        const normalized = this.normalizeCode(request.code);
-        const embedding = await this.embed(normalized + '\n' + request.edit);
-        // New patterns start as "hot" (no compression) since they're likely to be used again soon
-        // Access frequency is calculated dynamically when the pattern is accessed
-        const now = Date.now();
-        // Calculate initial access frequency (new patterns are "hot")
-        const initialAccessFreq = 1.0; // New patterns start at 100% (hot tier)
-        const compressionTier = this.getCompressionTier(initialAccessFreq);
-        // Apply tiered compression based on access frequency
-        const compressedEmbedding = this.applyTieredCompression(embedding, compressionTier);
-        const compressed = compressionTier !== 'none';
-        const editType = this.detectEditType(request.code, request.edit);
-        const pattern = {
-            id: patternId,
-            codeHash,
-            editHash,
-            language: request.language,
-            embedding: compressedEmbedding,
-            confidence: result.confidence,
-            successCount: 1,
-            failureCount: 0,
-            avgLatency: result.latency,
-            lastUsed: now,
-            output: result.output,
-            codeNormalized: normalized,
-            editType,
-            compressed,
-            accessCount: 1,
-            createdAt: now,
-            compressionTier
-        };
-        this.patterns.set(patternId, pattern);
-        this.patternEmbeddings.push(new Float32Array(compressedEmbedding));
-        this.patternIds.push(patternId);
-        this.stats.patternsLearned++;
-        this.totalPatternAccesses++; // New pattern counts as one access
-        // Record in intelligence engine
-        if (this.intelligence) {
-            await this.intelligence.recordEpisode(request.code.substring(0, 500), request.edit.substring(0, 500), result.confidence, result.output.substring(0, 500), true, { language: request.language, latency: result.latency, editType });
-            this.stats.sonaUpdates++;
-        }
-        // Persist periodically
-        if (this.stats.patternsLearned % 10 === 0) {
-            await this.persist();
-        }
-    }
-    /**
-     * Record co-edit relationship
-     */
-    lastEditedFile = null;
-    recordCoEdit(filePath) {
-        if (this.lastEditedFile && this.lastEditedFile !== filePath) {
-            // Record bidirectional edge
-            if (!this.coEditGraph.has(this.lastEditedFile)) {
-                this.coEditGraph.set(this.lastEditedFile, new Map());
-            }
-            if (!this.coEditGraph.has(filePath)) {
-                this.coEditGraph.set(filePath, new Map());
-            }
-            const edges1 = this.coEditGraph.get(this.lastEditedFile);
-            const edges2 = this.coEditGraph.get(filePath);
-            edges1.set(filePath, (edges1.get(filePath) || 0) + 1);
-            edges2.set(this.lastEditedFile, (edges2.get(this.lastEditedFile) || 0) + 1);
-        }
-        this.lastEditedFile = filePath;
-    }
-    /**
-     * Detect edit type from code transformation
-     */
-    detectEditType(code, edit) {
-        if (/\bvar\b/.test(code) && /\bconst\b/.test(edit))
-            return 'var_to_const';
-        if (/\bvar\b/.test(code) && /\blet\b/.test(edit))
-            return 'var_to_let';
-        if (!/:/.test(code) && /:/.test(edit))
-            return 'add_types';
-        if (/\.then\(/.test(code) && /await/.test(edit))
-            return 'to_async';
-        if (/console\./.test(code) && !edit.trim())
-            return 'remove_console';
-        if (/function/.test(code) && /async function/.test(edit))
-            return 'add_async';
-        if (/require\(/.test(code) && /import/.test(edit))
-            return 'to_esm';
-        return 'general';
-    }
-    /**
-     * Normalize code for fuzzy matching
-     */
-    normalizeCode(code) {
-        return code
-            .replace(/\s+/g, ' ') // Normalize whitespace
-            .replace(/['"`]/g, '"') // Normalize quotes
-            .replace(/\b\w+\b/g, w => // Normalize variable names
-         /^(var|let|const|function|class|if|else|for|while|return|import|export|from|async|await)$/.test(w)
-            ? w
-            : 'VAR')
-            .trim();
-    }
-    /**
-     * Generate embedding
-     */
-    async embed(text) {
-        if (this.onnxReady && this.intelligence) {
-            try {
-                const emb = await this.intelligence.embedAsync(text);
-                return new Float32Array(emb);
-            }
-            catch {
-                // Fall back
-            }
-        }
-        return this.hashEmbed(text);
-    }
-    /**
-     * Cosine similarity between two vectors
-     */
-    cosineSimilarity(a, b) {
-        let dot = 0, normA = 0, normB = 0;
-        const len = Math.min(a.length, b.length);
-        for (let i = 0; i < len; i++) {
-            dot += a[i] * b[i];
-            normA += a[i] * a[i];
-            normB += b[i] * b[i];
-        }
-        const denom = Math.sqrt(normA) * Math.sqrt(normB);
-        return denom > 0 ? dot / denom : 0;
-    }
-    /**
-     * Hash-based embedding fallback
-     */
-    hashEmbed(text) {
-        const dim = 384;
-        const embedding = new Float32Array(dim);
-        const tokens = text.toLowerCase().split(/\s+/);
-        for (let i = 0; i < tokens.length; i++) {
-            const token = tokens[i];
-            for (let j = 0; j < token.length; j++) {
-                const idx = (token.charCodeAt(j) * 31 + i * 7 + j) % dim;
-                embedding[idx] += 1.0 / (i + 1);
-            }
-        }
-        // Normalize
-        let norm = 0;
-        for (let i = 0; i < dim; i++)
-            norm += embedding[i] * embedding[i];
-        norm = Math.sqrt(norm) || 1;
-        for (let i = 0; i < dim; i++)
-            embedding[i] /= norm;
-        return embedding;
-    }
-    /**
-     * Simple string hash
-     */
-    hash(str) {
-        let hash = 0;
-        for (let i = 0; i < str.length; i++) {
-            const char = str.charCodeAt(i);
-            hash = ((hash << 5) - hash) + char;
-            hash = hash & hash;
-        }
-        return hash.toString(36);
-    }
-    /**
-     * Extension to language mapping
-     */
-    extToLanguage(ext) {
-        const map = {
-            ts: 'typescript', tsx: 'typescript', js: 'javascript', jsx: 'javascript',
-            py: 'python', rs: 'rust', go: 'go', java: 'java', c: 'c', cpp: 'cpp',
-            rb: 'ruby', php: 'php', swift: 'swift', kt: 'kotlin'
-        };
-        return map[ext] || ext;
-    }
-    /**
-     * Update running statistics
-     */
-    updateStats(latency, confidence) {
-        const n = this.stats.totalEdits;
-        this.stats.avgLatency = (this.stats.avgLatency * (n - 1) + latency) / n;
-        this.stats.avgConfidence = (this.stats.avgConfidence * (n - 1) + confidence) / n;
-        const totalHits = this.stats.cacheHits + this.stats.fuzzyHits + this.stats.gnnHits;
-        this.stats.hitRate = ((totalHits / n) * 100).toFixed(1) + '%';
-        this.stats.confidenceImprovement = ((this.stats.avgConfidence / 0.8 - 1) * 100).toFixed(1) + '%';
-        // Calculate compression ratio
-        const compressedCount = Array.from(this.patterns.values()).filter(p => p.compressed).length;
-        if (compressedCount > 0) {
-            this.stats.compressionRatio = `${compressedCount}/${this.patterns.size} (10x)`;
-        }
-    }
-    /**
-     * Record edit outcome for learning
-     */
-    async recordOutcome(patternId, success) {
-        const pattern = this.patterns.get(patternId);
-        if (!pattern)
-            return;
-        if (success) {
-            pattern.successCount++;
-            pattern.confidence = Math.min(0.99, pattern.confidence + 0.02);
-        }
-        else {
-            pattern.failureCount++;
-            pattern.confidence = Math.max(0.1, pattern.confidence - 0.05);
-        }
-        if (this.intelligence) {
-            this.intelligence.recordEpisode(pattern.codeHash, pattern.editHash, success ? 1.0 : 0.0, success ? 'success' : 'failure', true);
-        }
-    }
-    /**
-     * Get current statistics with tier distribution
-     */
-    getStats() {
-        // Calculate tier distribution
-        const tierDistribution = { hot: 0, warm: 0, cool: 0, cold: 0, archive: 0 };
-        let totalCompressedSize = 0;
-        let totalUncompressedSize = 0;
-        for (const pattern of this.patterns.values()) {
-            const tier = pattern.compressionTier || 'none';
-            const embeddingSize = pattern.embedding?.length || 384;
-            // Calculate uncompressed size (float32 = 4 bytes per element)
-            totalUncompressedSize += embeddingSize * 4;
-            // Count by tier
-            switch (tier) {
-                case 'none':
-                    tierDistribution.hot++;
-                    totalCompressedSize += embeddingSize * 4; // No savings
-                    break;
-                case 'half':
-                    tierDistribution.warm++;
-                    totalCompressedSize += embeddingSize * 2; // 50% savings
-                    break;
-                case 'pq8':
-                    tierDistribution.cool++;
-                    totalCompressedSize += embeddingSize * 0.5; // 87.5% savings
-                    break;
-                case 'pq4':
-                    tierDistribution.cold++;
-                    totalCompressedSize += embeddingSize * 0.25; // 93.75% savings
-                    break;
-                case 'binary':
-                    tierDistribution.archive++;
-                    totalCompressedSize += embeddingSize / 8; // 96.9% savings
-                    break;
-            }
-        }
-        // Calculate memory savings
-        const memorySavings = totalUncompressedSize > 0
-            ? ((1 - totalCompressedSize / totalUncompressedSize) * 100).toFixed(1) + '%'
-            : '0%';
-        // Calculate compression ratio
-        const ratio = totalCompressedSize > 0
-            ? `${(totalUncompressedSize / totalCompressedSize).toFixed(1)}:1`
-            : '1:1';
-        return {
-            ...this.stats,
-            tierDistribution,
-            totalPatternAccesses: this.totalPatternAccesses,
-            memorySavings,
-            compressionRatio: ratio
-        };
-    }
-    /**
-     * Persist patterns and state
-     */
-    async persist() {
-        const patternsFile = join(this.storagePath, 'patterns-v2.json');
-        // Convert co-edit graph to serializable format
-        const coEditGraphObj = {};
-        for (const [file, edges] of this.coEditGraph) {
-            coEditGraphObj[file] = Object.fromEntries(edges);
-        }
-        const data = {
-            patterns: Array.from(this.patterns.values()),
-            errorPatterns: Array.from(this.errorPatterns.values()),
-            coEditGraph: coEditGraphObj,
-            stats: this.stats,
-            totalPatternAccesses: this.totalPatternAccesses,
-            lastRecompressionTime: this.lastRecompressionTime
-        };
-        writeFileSync(patternsFile, JSON.stringify(data, null, 2));
-        if (this.intelligence) {
-            const intelligenceFile = join(this.storagePath, 'intelligence-v2.json');
-            writeFileSync(intelligenceFile, JSON.stringify(this.intelligence.export()));
-        }
-    }
-    /**
-     * Pretrain with expanded pattern set
-     */
-    async pretrain() {
-        const start = Date.now();
-        const commonPatterns = [
-            // Variable conversions (JavaScript)
-            { code: 'var x = 1;', edit: 'const x = 1;', lang: 'javascript' },
-            { code: 'var arr = [];', edit: 'const arr = [];', lang: 'javascript' },
-            { code: 'var obj = {};', edit: 'const obj = {};', lang: 'javascript' },
-            { code: 'let x = 1;', edit: 'const x = 1;', lang: 'javascript' },
-            // Type annotations (TypeScript)
-            { code: 'function foo(x) {}', edit: 'function foo(x: any) {}', lang: 'typescript' },
-            { code: 'const x = 1', edit: 'const x: number = 1', lang: 'typescript' },
-            { code: 'let arr = []', edit: 'let arr: any[] = []', lang: 'typescript' },
-            // Async patterns
-            { code: '.then(x => {})', edit: 'await x', lang: 'javascript' },
-            { code: 'function foo() {}', edit: 'async function foo() {}', lang: 'javascript' },
-            { code: 'const foo = () => {}', edit: 'const foo = async () => {}', lang: 'javascript' },
-            // Error handling
-            { code: 'JSON.parse(str)', edit: 'try { JSON.parse(str) } catch (e) {}', lang: 'javascript' },
-            { code: 'await fetch(url)', edit: 'try { await fetch(url) } catch (e) {}', lang: 'javascript' },
-            // Console patterns
-            { code: 'console.log(x);', edit: '', lang: 'javascript' },
-            { code: 'console.debug(x);', edit: '', lang: 'javascript' },
-            { code: 'console.error(x);', edit: '', lang: 'javascript' },
-            // Python patterns
-            { code: 'print x', edit: 'print(x)', lang: 'python' },
-            { code: 'def foo():', edit: 'def foo() -> None:', lang: 'python' },
-            { code: 'def foo(x):', edit: 'def foo(x: Any) -> Any:', lang: 'python' },
-            // Import patterns
-            { code: "require('x')", edit: "import x from 'x'", lang: 'javascript' },
-            { code: 'module.exports = x', edit: 'export default x', lang: 'javascript' },
-            { code: "const x = require('x')", edit: "import x from 'x'", lang: 'javascript' },
-            // Arrow functions
-            { code: 'function foo(x) { return x; }', edit: 'const foo = (x) => x;', lang: 'javascript' },
-            { code: 'function foo() { return 1; }', edit: 'const foo = () => 1;', lang: 'javascript' },
-            // Template literals
-            { code: '"Hello " + name', edit: '`Hello ${name}`', lang: 'javascript' },
-            // Object shorthand
-            { code: '{ x: x, y: y }', edit: '{ x, y }', lang: 'javascript' },
-            // Spread operator
-            { code: 'Object.assign({}, obj)', edit: '{ ...obj }', lang: 'javascript' },
-            { code: 'arr.concat(arr2)', edit: '[...arr, ...arr2]', lang: 'javascript' },
-        ];
-        for (const p of commonPatterns) {
-            const result = await this.apply({
-                code: p.code,
-                edit: p.edit,
-                language: p.lang
-            });
-            if (result.success) {
-                this.stats.patternsLearned++;
-            }
-        }
-        await this.persist();
-        return {
-            patterns: commonPatterns.length,
-            timeMs: Date.now() - start
-        };
-    }
-    /**
-     * Force SONA learning cycle
-     */
-    tick() {
-        if (this.intelligence) {
-            return this.intelligence.tick();
-        }
-        return null;
-    }
-    /**
-     * Get intelligence stats
-     */
-    getIntelligenceStats() {
-        if (this.intelligence) {
-            return this.intelligence.getStats();
-        }
-        return null;
-    }
-    /**
-     * Get likely next files to edit
-     */
-    getLikelyNextFiles(filePath, topK = 5) {
-        const edges = this.coEditGraph.get(filePath);
-        if (!edges)
-            return [];
-        return Array.from(edges.entries())
-            .sort((a, b) => b[1] - a[1])
-            .slice(0, topK)
-            .map(([file, score]) => ({ file, score }));
-    }
-}
-/**
- * Create a singleton enhanced booster v2
- */
-let enhancedBooster = null;
-export function getEnhancedBooster() {
-    if (!enhancedBooster) {
-        enhancedBooster = new EnhancedAgentBooster({
-            enableOnnx: true,
-            enableSona: true,
-            maxPatterns: 100000,
-            fuzzyThreshold: 0.85
-        });
-    }
-    return enhancedBooster;
-}
-/**
- * Quick apply function
- */
-export async function enhancedApply(code, edit, language) {
-    const booster = getEnhancedBooster();
-    return booster.apply({ code, edit, language });
-}
-/**
- * Benchmark enhanced vs baseline
- */
-export async function benchmark(iterations = 50) {
-    const booster = getEnhancedBooster();
-    await booster.init();
-    await booster.pretrain();
-    const testCases = [
-        { code: 'var x = 1;', edit: 'const x = 1;', lang: 'javascript' },
-        { code: 'var y = 2;', edit: 'const y = 2;', lang: 'javascript' }, // Fuzzy match test
-        { code: 'var z = 3;', edit: 'const z = 3;', lang: 'javascript' }, // Fuzzy match test
-        { code: 'function foo(x) {}', edit: 'function foo(x: any) {}', lang: 'typescript' },
-        { code: 'let arr = []', edit: 'let arr: any[] = []', lang: 'typescript' },
-    ];
-    let baselineTotal = 0;
-    let enhancedTotal = 0;
-    let baselineConf = 0;
-    let enhancedConf = 0;
-    for (let i = 0; i < iterations; i++) {
-        const testCase = testCases[i % testCases.length];
-        // Baseline
-        const baseStart = Date.now();
-        try {
-            const cmd = `npx --yes agent-booster@0.2.2 apply --language ${testCase.lang}`;
-            const result = execSync(cmd, {
-                encoding: 'utf-8',
-                input: JSON.stringify({ code: testCase.code, edit: testCase.edit }),
-                maxBuffer: 10 * 1024 * 1024,
-                timeout: 30000
-            });
-            const parsed = JSON.parse(result);
-            baselineTotal += Date.now() - baseStart;
-            baselineConf += parsed.confidence || 0;
-        }
-        catch {
-            baselineTotal += Date.now() - baseStart;
-        }
-        // Enhanced
-        const enhResult = await booster.apply({
-            code: testCase.code,
-            edit: testCase.edit,
-            language: testCase.lang
-        });
-        enhancedTotal += enhResult.latency;
-        enhancedConf += enhResult.confidence;
-    }
-    const stats = booster.getStats();
-    const baseAvgLatency = baselineTotal / iterations;
-    const enhAvgLatency = enhancedTotal / iterations;
-    const totalHits = stats.cacheHits + stats.fuzzyHits + stats.gnnHits;
-    return {
-        baseline: {
-            avgLatency: baseAvgLatency,
-            avgConfidence: baselineConf / iterations
-        },
-        enhanced: {
-            avgLatency: enhAvgLatency,
-            avgConfidence: enhancedConf / iterations,
-            cacheHitRate: stats.cacheHits / stats.totalEdits,
-            fuzzyHitRate: stats.fuzzyHits / stats.totalEdits
-        },
-        improvement: {
-            latency: `${((baseAvgLatency - enhAvgLatency) / baseAvgLatency * 100).toFixed(1)}% faster`,
-            confidence: `${((enhancedConf / iterations) / (baselineConf / iterations) * 100 - 100).toFixed(1)}% higher`
-        }
-    };
-}
-export default EnhancedAgentBooster;
-//# sourceMappingURL=agent-booster-enhanced.js.map