chore: recovery checkpoint - v3.0 API successfully recovered

CRITICAL CHECKPOINT - DO NOT PUSH TO GITHUB

Recovery Status:
- Successfully recovered brainy.ts from compiled JavaScript
- All core v3.0 API methods functional (add, get, update, delete, relate, find, etc.)
- Neural subsystem intact (562KB embedded patterns, NLP working)
- Augmentation pipeline operational (20+ augmentations)
- HNSW clustering system complete
- Triple Intelligence compiled (needs constructor fix)
- Test suite validates functionality

Changes preserved:
- 898 files with changes from last 3 days
- 144,475 insertions
- All augmentation improvements
- All test coverage enhancements
- Complete v3.0 feature set

This is a LOCAL checkpoint only - contains recovered work after corruption incident.
Created backup in .backups/brainy-full-20250910-151314.tar.gz

Branch: recovery-checkpoint-20250910-151433
Date: Wed Sep 10 03:18:04 PM PDT 2025

.recovery-workspace/dist-backup-20250910-141917/utils/metadataIndexCache.js

@@ -0,0 +1,119 @@
+/**
+ * MetadataIndexCache - Caches metadata index data for improved performance
+ * Reuses the same pattern as SearchCache for consistency
+ */
+export class MetadataIndexCache {
+    constructor(config = {}) {
+        this.cache = new Map();
+        // Cache statistics
+        this.hits = 0;
+        this.misses = 0;
+        this.evictions = 0;
+        this.maxAge = config.maxAge ?? 5 * 60 * 1000; // 5 minutes
+        this.maxSize = config.maxSize ?? 500; // More entries than SearchCache since indexes are smaller
+        this.enabled = config.enabled ?? true;
+        this.hitCountWeight = config.hitCountWeight ?? 0.3;
+    }
+    /**
+     * Get cached entry
+     */
+    get(key) {
+        if (!this.enabled)
+            return undefined;
+        const entry = this.cache.get(key);
+        if (!entry) {
+            this.misses++;
+            return undefined;
+        }
+        // Check if entry is expired
+        if (Date.now() - entry.timestamp > this.maxAge) {
+            this.cache.delete(key);
+            this.misses++;
+            return undefined;
+        }
+        // Update hit count
+        entry.hits++;
+        this.hits++;
+        return entry.data;
+    }
+    /**
+     * Set cache entry
+     */
+    set(key, data) {
+        if (!this.enabled)
+            return;
+        // Evict entries if at max size
+        if (this.cache.size >= this.maxSize) {
+            this.evictLeastValuable();
+        }
+        this.cache.set(key, {
+            data,
+            timestamp: Date.now(),
+            hits: 0
+        });
+    }
+    /**
+     * Evict least valuable entry based on age and hit count
+     */
+    evictLeastValuable() {
+        let leastValuableKey = null;
+        let lowestScore = Infinity;
+        for (const [key, entry] of this.cache.entries()) {
+            const age = Date.now() - entry.timestamp;
+            const ageScore = age / this.maxAge;
+            const hitScore = entry.hits * this.hitCountWeight;
+            const score = hitScore - ageScore;
+            if (score < lowestScore) {
+                lowestScore = score;
+                leastValuableKey = key;
+            }
+        }
+        if (leastValuableKey) {
+            this.cache.delete(leastValuableKey);
+            this.evictions++;
+        }
+    }
+    /**
+     * Invalidate cache entries matching a pattern
+     */
+    invalidatePattern(pattern) {
+        const keysToDelete = [];
+        for (const key of this.cache.keys()) {
+            if (key.includes(pattern)) {
+                keysToDelete.push(key);
+            }
+        }
+        keysToDelete.forEach(key => this.cache.delete(key));
+    }
+    /**
+     * Clear all cache entries
+     */
+    clear() {
+        this.cache.clear();
+    }
+    /**
+     * Get cache statistics
+     */
+    getStats() {
+        return {
+            size: this.cache.size,
+            hits: this.hits,
+            misses: this.misses,
+            hitRate: this.hits / (this.hits + this.misses) || 0,
+            evictions: this.evictions
+        };
+    }
+    /**
+     * Get estimated memory usage
+     */
+    getMemoryUsage() {
+        // Rough estimate: 100 bytes per entry + data size
+        let totalSize = 0;
+        for (const entry of this.cache.values()) {
+            totalSize += 100; // Base overhead
+            totalSize += JSON.stringify(entry.data).length * 2; // Unicode chars
+        }
+        return totalSize;
+    }
+}
+//# sourceMappingURL=metadataIndexCache.js.map