recker 1.0.12 → 1.0.13

package/dist/cache/memory-storage.js

@@ -1,30 +1,453 @@
+import zlib from 'node:zlib';
+import os from 'node:os';
+import { getEffectiveTotalMemoryBytes, resolveCacheMemoryLimit, formatBytes, getHeapStats, } from './memory-limits.js';
 export class MemoryStorage {
     storage = new Map();
-    ttls = new Map();
+    meta = new Map();
+    maxSize;
+    maxMemoryBytes;
+    maxMemoryPercent;
+    defaultTtl;
+    evictionPolicy;
+    compressionEnabled;
+    compressionThreshold;
+    enableStats;
+    heapUsageThreshold;
+    onEvict;
+    onPressure;
+    currentMemoryBytes = 0;
+    evictedDueToMemory = 0;
+    memoryPressureEvents = 0;
+    accessCounter = 0;
+    monitorHandle = null;
+    cleanupHandle = null;
+    stats = {
+        hits: 0,
+        misses: 0,
+        sets: 0,
+        deletes: 0,
+        evictions: 0,
+    };
+    compressionStats = {
+        totalCompressed: 0,
+        totalOriginalSize: 0,
+        totalCompressedSize: 0,
+    };
+    constructor(options = {}) {
+        if (options.maxMemoryBytes &&
+            options.maxMemoryBytes > 0 &&
+            options.maxMemoryPercent &&
+            options.maxMemoryPercent > 0) {
+            throw new Error('[MemoryStorage] Cannot use both maxMemoryBytes and maxMemoryPercent');
+        }
+        if (options.maxMemoryPercent !== undefined &&
+            (options.maxMemoryPercent < 0 || options.maxMemoryPercent > 1)) {
+            throw new Error('[MemoryStorage] maxMemoryPercent must be between 0 and 1');
+        }
+        this.maxSize = options.maxSize ?? 1000;
+        this.defaultTtl = options.ttl ?? 300000;
+        this.evictionPolicy = options.evictionPolicy ?? 'lru';
+        this.enableStats = options.enableStats ?? false;
+        this.heapUsageThreshold = options.heapUsageThreshold ?? 0.6;
+        if (options.maxMemoryBytes && options.maxMemoryBytes > 0) {
+            this.maxMemoryBytes = options.maxMemoryBytes;
+            this.maxMemoryPercent = 0;
+        }
+        else if (options.maxMemoryPercent && options.maxMemoryPercent > 0) {
+            const effectiveTotal = getEffectiveTotalMemoryBytes();
+            this.maxMemoryBytes = Math.floor(effectiveTotal * options.maxMemoryPercent);
+            this.maxMemoryPercent = options.maxMemoryPercent;
+        }
+        else {
+            const resolved = resolveCacheMemoryLimit({});
+            this.maxMemoryBytes = resolved.maxMemoryBytes;
+            this.maxMemoryPercent = resolved.inferredPercent ?? 0;
+        }
+        if (options.compression === true) {
+            this.compressionEnabled = true;
+            this.compressionThreshold = 1024;
+        }
+        else if (typeof options.compression === 'object' &&
+            options.compression.enabled) {
+            this.compressionEnabled = true;
+            this.compressionThreshold = options.compression.threshold ?? 1024;
+        }
+        else {
+            this.compressionEnabled = false;
+            this.compressionThreshold = 1024;
+        }
+        this.onEvict = options.onEvict;
+        this.onPressure = options.onPressure;
+        const monitorInterval = options.monitorInterval ?? 15000;
+        if (monitorInterval > 0) {
+            this.monitorHandle = setInterval(() => this.memoryHealthCheck(), monitorInterval);
+            this.monitorHandle.unref();
+        }
+        const cleanupInterval = options.cleanupInterval ?? 60000;
+        if (cleanupInterval > 0) {
+            this.cleanupHandle = setInterval(() => this.cleanupExpired(), cleanupInterval);
+            this.cleanupHandle.unref();
+        }
+    }
     async get(key) {
-        const entry = this.storage.get(key);
-        if (!entry) {
+        const data = this.storage.get(key);
+        const metadata = this.meta.get(key);
+        if (!data || !metadata) {
+            this.recordStat('misses');
             return undefined;
         }
-        const expiry = this.ttls.get(key);
-        if (expiry && Date.now() > expiry) {
-            this.delete(key);
+        const now = Date.now();
+        if (now > metadata.expiresAt) {
+            this.deleteInternal(key);
+            this.recordStat('misses');
             return undefined;
         }
-        return entry;
+        if (this.evictionPolicy === 'lru') {
+            metadata.lastAccess = now;
+            metadata.accessOrder = ++this.accessCounter;
+        }
+        this.recordStat('hits');
+        if (this.isCompressed(data)) {
+            try {
+                const decompressed = this.decompress(data);
+                return JSON.parse(decompressed);
+            }
+            catch {
+                this.deleteInternal(key);
+                return undefined;
+            }
+        }
+        return JSON.parse(data);
     }
     async set(key, entry, ttl) {
-        this.storage.set(key, entry);
-        if (ttl) {
-            this.ttls.set(key, Date.now() + ttl);
+        const effectiveTtl = ttl ?? this.defaultTtl;
+        const now = Date.now();
+        const serialized = JSON.stringify(entry);
+        const originalSize = Buffer.byteLength(serialized, 'utf8');
+        let finalData = serialized;
+        let compressedSize = originalSize;
+        let compressed = false;
+        if (this.compressionEnabled && originalSize >= this.compressionThreshold) {
+            try {
+                const result = this.compress(serialized);
+                finalData = result;
+                compressedSize = Buffer.byteLength(result.__data, 'utf8');
+                compressed = true;
+                this.compressionStats.totalCompressed++;
+                this.compressionStats.totalOriginalSize += originalSize;
+                this.compressionStats.totalCompressedSize += compressedSize;
+            }
+            catch {
+            }
         }
+        const existingMeta = this.meta.get(key);
+        if (existingMeta) {
+            this.currentMemoryBytes -= existingMeta.compressedSize;
+        }
+        if (!this.enforceMemoryLimit(compressedSize)) {
+            this.evictedDueToMemory++;
+            return;
+        }
+        if (!existingMeta && this.storage.size >= this.maxSize) {
+            this.evictOne('size');
+        }
+        this.storage.set(key, finalData);
+        this.meta.set(key, {
+            createdAt: now,
+            expiresAt: now + effectiveTtl,
+            lastAccess: now,
+            insertOrder: ++this.accessCounter,
+            accessOrder: this.accessCounter,
+            compressed,
+            originalSize,
+            compressedSize,
+        });
+        this.currentMemoryBytes += compressedSize;
+        this.recordStat('sets');
     }
     async delete(key) {
+        this.deleteInternal(key);
+        this.recordStat('deletes');
+    }
+    clear(prefix) {
+        if (!prefix) {
+            this.storage.clear();
+            this.meta.clear();
+            this.currentMemoryBytes = 0;
+            this.evictedDueToMemory = 0;
+            if (this.enableStats) {
+                this.stats = { hits: 0, misses: 0, sets: 0, deletes: 0, evictions: 0 };
+            }
+            return;
+        }
+        for (const key of this.storage.keys()) {
+            if (key.startsWith(prefix)) {
+                this.deleteInternal(key);
+            }
+        }
+    }
+    size() {
+        return this.storage.size;
+    }
+    keys() {
+        return Array.from(this.storage.keys());
+    }
+    has(key) {
+        const meta = this.meta.get(key);
+        if (!meta)
+            return false;
+        if (Date.now() > meta.expiresAt) {
+            this.deleteInternal(key);
+            return false;
+        }
+        return true;
+    }
+    getStats() {
+        const total = this.stats.hits + this.stats.misses;
+        const hitRate = total > 0 ? this.stats.hits / total : 0;
+        return {
+            enabled: this.enableStats,
+            ...this.stats,
+            hitRate,
+            totalItems: this.storage.size,
+            memoryUsageBytes: this.currentMemoryBytes,
+            maxMemoryBytes: this.maxMemoryBytes,
+            evictedDueToMemory: this.evictedDueToMemory,
+        };
+    }
+    getMemoryStats() {
+        const totalItems = this.storage.size;
+        const memoryUsagePercent = this.maxMemoryBytes > 0
+            ? (this.currentMemoryBytes / this.maxMemoryBytes) * 100
+            : 0;
+        const systemTotal = os.totalmem();
+        const systemFree = os.freemem();
+        const systemUsed = systemTotal - systemFree;
+        const cachePercentOfSystem = systemTotal > 0 ? (this.currentMemoryBytes / systemTotal) * 100 : 0;
+        return {
+            currentMemoryBytes: this.currentMemoryBytes,
+            maxMemoryBytes: this.maxMemoryBytes,
+            maxMemoryPercent: this.maxMemoryPercent,
+            memoryUsagePercent: parseFloat(memoryUsagePercent.toFixed(2)),
+            cachePercentOfSystemMemory: parseFloat(cachePercentOfSystem.toFixed(2)),
+            totalItems,
+            maxSize: this.maxSize,
+            evictedDueToMemory: this.evictedDueToMemory,
+            memoryPressureEvents: this.memoryPressureEvents,
+            averageItemSize: totalItems > 0 ? Math.round(this.currentMemoryBytes / totalItems) : 0,
+            memoryUsage: {
+                current: formatBytes(this.currentMemoryBytes),
+                max: formatBytes(this.maxMemoryBytes),
+                available: formatBytes(Math.max(0, this.maxMemoryBytes - this.currentMemoryBytes)),
+            },
+            systemMemory: {
+                total: formatBytes(systemTotal),
+                free: formatBytes(systemFree),
+                used: formatBytes(systemUsed),
+                cachePercent: `${cachePercentOfSystem.toFixed(2)}%`,
+            },
+        };
+    }
+    getCompressionStats() {
+        if (!this.compressionEnabled) {
+            return {
+                enabled: false,
+                totalItems: this.storage.size,
+                compressedItems: 0,
+                compressionThreshold: this.compressionThreshold,
+                totalOriginalSize: 0,
+                totalCompressedSize: 0,
+                averageCompressionRatio: '0',
+                spaceSavingsPercent: '0',
+                memoryUsage: {
+                    uncompressed: '0 B',
+                    compressed: '0 B',
+                    saved: '0 B',
+                },
+            };
+        }
+        const ratio = this.compressionStats.totalOriginalSize > 0
+            ? (this.compressionStats.totalCompressedSize /
+                this.compressionStats.totalOriginalSize).toFixed(2)
+            : '0';
+        const savings = this.compressionStats.totalOriginalSize > 0
+            ? (((this.compressionStats.totalOriginalSize -
+                this.compressionStats.totalCompressedSize) /
+                this.compressionStats.totalOriginalSize) *
+                100).toFixed(2)
+            : '0';
+        const saved = this.compressionStats.totalOriginalSize -
+            this.compressionStats.totalCompressedSize;
+        return {
+            enabled: true,
+            totalItems: this.storage.size,
+            compressedItems: this.compressionStats.totalCompressed,
+            compressionThreshold: this.compressionThreshold,
+            totalOriginalSize: this.compressionStats.totalOriginalSize,
+            totalCompressedSize: this.compressionStats.totalCompressedSize,
+            averageCompressionRatio: ratio,
+            spaceSavingsPercent: savings,
+            memoryUsage: {
+                uncompressed: formatBytes(this.compressionStats.totalOriginalSize),
+                compressed: formatBytes(this.compressionStats.totalCompressedSize),
+                saved: formatBytes(saved),
+            },
+        };
+    }
+    shutdown() {
+        if (this.monitorHandle) {
+            clearInterval(this.monitorHandle);
+            this.monitorHandle = null;
+        }
+        if (this.cleanupHandle) {
+            clearInterval(this.cleanupHandle);
+            this.cleanupHandle = null;
+        }
+    }
+    deleteInternal(key) {
+        const meta = this.meta.get(key);
+        if (meta) {
+            this.currentMemoryBytes -= meta.compressedSize;
+        }
         this.storage.delete(key);
-        this.ttls.delete(key);
+        this.meta.delete(key);
     }
-    clear() {
-        this.storage.clear();
-        this.ttls.clear();
+    recordStat(type) {
+        if (this.enableStats) {
+            this.stats[type]++;
+        }
+    }
+    isCompressed(data) {
+        return (typeof data === 'object' && data !== null && '__compressed' in data);
+    }
+    compress(data) {
+        const buffer = Buffer.from(data, 'utf8');
+        const compressed = zlib.gzipSync(buffer);
+        return {
+            __compressed: true,
+            __data: compressed.toString('base64'),
+            __originalSize: buffer.length,
+        };
+    }
+    decompress(data) {
+        const buffer = Buffer.from(data.__data, 'base64');
+        const decompressed = zlib.gunzipSync(buffer);
+        return decompressed.toString('utf8');
+    }
+    selectEvictionCandidate() {
+        if (this.meta.size === 0)
+            return null;
+        let candidate = null;
+        let candidateValue = this.evictionPolicy === 'lru' ? Infinity : Infinity;
+        for (const [key, meta] of this.meta) {
+            const value = this.evictionPolicy === 'lru' ? meta.accessOrder : meta.insertOrder;
+            if (value < candidateValue) {
+                candidateValue = value;
+                candidate = key;
+            }
+        }
+        return candidate;
+    }
+    evictOne(reason) {
+        const candidate = this.selectEvictionCandidate();
+        if (!candidate)
+            return null;
+        const meta = this.meta.get(candidate);
+        const freedBytes = meta?.compressedSize ?? 0;
+        this.deleteInternal(candidate);
+        this.stats.evictions++;
+        if (reason === 'memory' || reason === 'heap') {
+            this.evictedDueToMemory++;
+        }
+        this.onEvict?.({
+            reason,
+            key: candidate,
+            freedBytes,
+            currentBytes: this.currentMemoryBytes,
+            maxMemoryBytes: this.maxMemoryBytes,
+        });
+        return { key: candidate, freedBytes };
+    }
+    enforceMemoryLimit(incomingSize) {
+        if (incomingSize > this.maxMemoryBytes) {
+            return false;
+        }
+        while (this.currentMemoryBytes + incomingSize > this.maxMemoryBytes &&
+            this.storage.size > 0) {
+            const result = this.evictOne('memory');
+            if (!result)
+                break;
+        }
+        return this.currentMemoryBytes + incomingSize <= this.maxMemoryBytes;
+    }
+    reduceMemoryTo(targetBytes) {
+        targetBytes = Math.max(0, targetBytes);
+        let freedBytes = 0;
+        while (this.currentMemoryBytes > targetBytes && this.storage.size > 0) {
+            const result = this.evictOne('memory');
+            if (!result)
+                break;
+            freedBytes += result.freedBytes;
+        }
+        return freedBytes;
+    }
+    memoryHealthCheck() {
+        let totalFreed = 0;
+        if (this.currentMemoryBytes > this.maxMemoryBytes) {
+            const before = this.currentMemoryBytes;
+            this.enforceMemoryLimit(0);
+            const freed = before - this.currentMemoryBytes;
+            if (freed > 0) {
+                totalFreed += freed;
+                this.memoryPressureEvents++;
+                this.onPressure?.({
+                    reason: 'limit',
+                    heapLimit: getHeapStats().heapLimit,
+                    heapUsed: getHeapStats().heapUsed,
+                    currentBytes: this.currentMemoryBytes,
+                    maxMemoryBytes: this.maxMemoryBytes,
+                    freedBytes: freed,
+                });
+            }
+        }
+        const { heapUsed, heapLimit, heapRatio } = getHeapStats();
+        if (heapLimit > 0 && heapRatio >= this.heapUsageThreshold) {
+            const before = this.currentMemoryBytes;
+            const target = Math.floor(this.currentMemoryBytes * 0.5);
+            this.reduceMemoryTo(target);
+            const freed = before - this.currentMemoryBytes;
+            if (freed > 0) {
+                totalFreed += freed;
+                this.memoryPressureEvents++;
+                this.onPressure?.({
+                    reason: 'heap',
+                    heapLimit,
+                    heapUsed,
+                    heapRatio,
+                    currentBytes: this.currentMemoryBytes,
+                    maxMemoryBytes: this.maxMemoryBytes,
+                    freedBytes: freed,
+                });
+            }
+        }
+        return totalFreed;
+    }
+    cleanupExpired() {
+        const now = Date.now();
+        let cleaned = 0;
+        for (const [key, meta] of this.meta) {
+            if (now > meta.expiresAt) {
+                this.deleteInternal(key);
+                cleaned++;
+                this.onEvict?.({
+                    reason: 'expired',
+                    key,
+                    freedBytes: meta.compressedSize,
+                    currentBytes: this.currentMemoryBytes,
+                    maxMemoryBytes: this.maxMemoryBytes,
+                });
+            }
+        }
+        return cleaned;
     }
 }

package/dist/cli/tui/shell-search.d.ts

@@ -0,0 +1,46 @@
+import type { SearchResult } from '../../mcp/search/types.js';
+export declare class ShellSearch {
+    private hybridSearch;
+    private docsIndex;
+    private codeExamples;
+    private typeDefinitions;
+    private initialized;
+    private idleTimer;
+    private docsPath;
+    private examplesPath;
+    private srcPath;
+    constructor();
+    private ensureInitialized;
+    private resetIdleTimer;
+    private unload;
+    search(query: string, options?: {
+        limit?: number;
+        category?: string;
+    }): Promise<SearchResult[]>;
+    suggest(useCase: string): Promise<string>;
+    getExamples(feature: string, options?: {
+        limit?: number;
+        complexity?: string;
+    }): Promise<string>;
+    getStats(): {
+        documents: number;
+        examples: number;
+        types: number;
+        loaded: boolean;
+    };
+    private findDocsPath;
+    private findExamplesPath;
+    private findSrcPath;
+    private buildIndex;
+    private indexDocsFromEmbeddings;
+    private indexDocsFromFilesystem;
+    private indexExamples;
+    private indexTypes;
+    private extractKeywords;
+    private parseExampleMeta;
+    private inferFeature;
+    private extractMainCode;
+    private parseTypeDefinitions;
+}
+export declare function getShellSearch(): ShellSearch;
+//# sourceMappingURL=shell-search.d.ts.map

package/dist/cli/tui/shell-search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shell-search.d.ts","sourceRoot":"","sources":["../../../src/cli/tui/shell-search.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAc,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAmC1E,qBAAa,WAAW;IACtB,OAAO,CAAC,YAAY,CAA6B;IACjD,OAAO,CAAC,SAAS,CAAoB;IACrC,OAAO,CAAC,YAAY,CAAqB;IACzC,OAAO,CAAC,eAAe,CAAwB;IAC/C,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,SAAS,CAA8C;IAC/D,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,OAAO,CAAS;;YAWV,iBAAiB;IAgB/B,OAAO,CAAC,cAAc;IAUtB,OAAO,CAAC,MAAM;IAaR,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAO,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;IAenG,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAqGzC,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAAO,GAAG,OAAO,CAAC,MAAM,CAAC;IAwD1G,QAAQ,IAAI;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,OAAO,CAAA;KAAE;IAWnF,OAAO,CAAC,YAAY;IAYpB,OAAO,CAAC,gBAAgB;IAWxB,OAAO,CAAC,WAAW;IAanB,OAAO,CAAC,UAAU;IAUlB,OAAO,CAAC,uBAAuB;IAuC/B,OAAO,CAAC,uBAAuB;IAuC/B,OAAO,CAAC,aAAa;IAoCrB,OAAO,CAAC,UAAU;IAwBlB,OAAO,CAAC,eAAe;IA8BvB,OAAO,CAAC,gBAAgB;IA8BxB,OAAO,CAAC,YAAY;IAcpB,OAAO,CAAC,eAAe;IAkBvB,OAAO,CAAC,oBAAoB;CA4C7B;AAKD,wBAAgB,cAAc,IAAI,WAAW,CAK5C"}