token-pilot 0.2.1 → 0.2.2

package/dist/core/persistent-cache.d.ts

@@ -1,153 +0,0 @@
-import type { CacheEntry } from '../types';
-/**
- * Persistent File Cache with Two-Level Architecture
- *
- * Problem: Cold start takes 200s because each file needs AST parsing
- * Solution: L1 (in-memory) + L2 (SQLite persistent) cache with LRU eviction
- *
- * L1 Cache (Memory):
- * - Fast: <5ms lookups
- * - Warm during session
- * - Survives memory pressure via eviction
- *
- * L2 Cache (SQLite):
- * - Persistent: survives restarts
- * - Slower: ~100ms lookups
- * - Enables 20x faster cold starts (200s → 10s)
- *
- * Strategy:
- * - Always read from L1 first (fastest)
- * - Miss in L1 → read from L2 (persistent)
- * - Miss in L2 → parse file (slowest, but cached for next time)
- * - Evict LRU when memory/disk limit exceeded
- */
-export declare class PersistentFileCache {
-    private l1;
-    private db;
-    private maxSizeBytes;
-    private l1MaxSize;
-    private onSetCallback;
-    private smallFileThreshold;
-    private l1Only;
-    private l1Hits;
-    private l2Hits;
-    private misses;
-    constructor(projectRoot: string, maxSizeMB?: number, smallFileThreshold?: number);
-    /**
-     * Initialize database schema with file_cache table and indexes
-     */
-    private initializeSchema;
-    /**
-     * Get cached entry from L1 or L2
-     * Returns from L1 first (fastest), then L2 (persistent)
-     */
-    get(filePath: string): CacheEntry | null;
-    /**
-     * Set cache entry in L1 and L2
-     */
-    set(filePath: string, entry: CacheEntry): void;
-    /**
-     * Get cached entry by content hash (semantic caching)
-     * Useful when same file content loaded from different paths
-     */
-    getByHash(contentHash: string): CacheEntry | null;
-    /**
-     * Remove entry from both L1 and L2
-     */
-    delete(filePath: string): void;
-    /**
-     * Clear all cache (useful for testing)
-     */
-    clear(): void;
-    /**
-     * Get cache statistics
-     */
-    getStats(): {
-        totalBytes: number;
-        entryCount: number;
-        l1Size: number;
-        l2Size: number;
-        maxBytes: number;
-    };
-    /**
-     * Get all cached entries (for iteration/analysis)
-     */
-    private getAllEntries;
-    /**
-     * Evict LRU entries if cache exceeds size limit
-     */
-    private evictIfNeeded;
-    /**
-     * Update lastAccess timestamp for file
-     */
-    private updateLastAccess;
-    /**
-     * Update cache statistics
-     */
-    private updateStats;
-    /**
-     * Estimate entry size in bytes
-     */
-    private estimateSize;
-    /**
-     * Register callback for file writes (compatibility with FileCache)
-     */
-    onSet(callback: (filePath: string) => void): void;
-    /**
-     * Invalidate cache entry (compatibility with FileCache)
-     */
-    invalidate(filePath?: string): void;
-    /**
-     * Invalidate files by git diff (compatibility with FileCache)
-     */
-    invalidateByGitDiff(changedFiles: string[]): Promise<void>;
-    /**
-     * Check if file is small (under threshold lines)
-     */
-    isSmallFile(filePath: string): Promise<boolean>;
-    /**
-     * Check if cached entry is stale (mtime changed)
-     */
-    isStale(filePath: string): Promise<boolean>;
-    /**
-     * Get small file threshold
-     */
-    getSmallFileThreshold(): number;
-    /**
-     * Get all cached file paths
-     */
-    cachedPaths(): string[];
-    /**
-     * Get cache statistics (compatibility with FileCache)
-     */
-    stats(): {
-        entries: number;
-        sizeBytes: number;
-        hitRate: number;
-    };
-    /**
-     * Get detailed cache performance metrics
-     */
-    getPerformanceMetrics(): {
-        l1Hits: number;
-        l2Hits: number;
-        misses: number;
-        totalRequests: number;
-        hitRate: number;
-        l1HitRate: number;
-        l2HitRate: number;
-        l1Only: boolean;
-    };
-    /**
-     * Trigger onSet callback after setting entry
-     */
-    private triggerOnSet;
-    /**
-     * Close database connection
-     */
-    close(): void;
-}
-export declare function initializePersistentCache(projectRoot: string, maxSizeMB?: number): PersistentFileCache;
-export declare function getPersistentCache(): PersistentFileCache;
-export declare function closePersistentCache(): void;
-//# sourceMappingURL=persistent-cache.d.ts.map

package/dist/core/persistent-cache.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"persistent-cache.d.ts","sourceRoot":"","sources":["../../src/core/persistent-cache.ts"],"names":[],"mappings":"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"}

package/dist/core/persistent-cache.js

@@ -1,555 +0,0 @@
-import Database from 'better-sqlite3';
-import { join } from 'node:path';
-import { mkdirSync, stat, readFile } from 'node:fs/promises';
-/**
- * Persistent File Cache with Two-Level Architecture
- *
- * Problem: Cold start takes 200s because each file needs AST parsing
- * Solution: L1 (in-memory) + L2 (SQLite persistent) cache with LRU eviction
- *
- * L1 Cache (Memory):
- * - Fast: <5ms lookups
- * - Warm during session
- * - Survives memory pressure via eviction
- *
- * L2 Cache (SQLite):
- * - Persistent: survives restarts
- * - Slower: ~100ms lookups
- * - Enables 20x faster cold starts (200s → 10s)
- *
- * Strategy:
- * - Always read from L1 first (fastest)
- * - Miss in L1 → read from L2 (persistent)
- * - Miss in L2 → parse file (slowest, but cached for next time)
- * - Evict LRU when memory/disk limit exceeded
- */
-export class PersistentFileCache {
-    l1 = new Map();
-    db = null;
-    maxSizeBytes;
-    l1MaxSize = 50; // max files in L1 memory
-    onSetCallback = null;
-    smallFileThreshold = 80;
-    l1Only = false; // graceful degradation mode
-    l1Hits = 0;
-    l2Hits = 0;
-    misses = 0;
-    constructor(projectRoot, maxSizeMB = 1000, smallFileThreshold = 80) {
-        this.maxSizeBytes = maxSizeMB * 1024 * 1024;
-        this.smallFileThreshold = smallFileThreshold;
-        try {
-            // Initialize SQLite database
-            const cacheDir = join(projectRoot, '.token-pilot');
-            mkdirSync(cacheDir, { recursive: true });
-            const dbPath = join(cacheDir, 'cache.db');
-            this.db = new Database(dbPath);
-            // Enable performance optimizations
-            this.db.pragma('journal_mode = WAL'); // Write-Ahead Logging for concurrency
-            this.db.pragma('synchronous = NORMAL'); // Balance safety & speed
-            this.db.pragma('cache_size = -64000'); // 64MB cache
-            // Create schema
-            this.initializeSchema();
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            console.error(`[token-pilot] PersistentFileCache init error: ${message}`);
-            console.error(`[token-pilot] Falling back to L1-only (memory) cache`);
-            this.db = null;
-            this.l1Only = true;
-        }
-    }
-    /**
-     * Initialize database schema with file_cache table and indexes
-     */
-    initializeSchema() {
-        if (!this.db)
-            return;
-        try {
-            this.db.exec(`
-        CREATE TABLE IF NOT EXISTS file_cache (
-          path TEXT PRIMARY KEY,
-          structure TEXT NOT NULL,
-          content TEXT NOT NULL,
-          lines TEXT NOT NULL,
-          hash TEXT NOT NULL UNIQUE,
-          mtime INTEGER NOT NULL,
-          lastAccess INTEGER NOT NULL,
-          sizeBytes INTEGER NOT NULL
-        );
-
-        CREATE INDEX IF NOT EXISTS idx_hash ON file_cache(hash);
-        CREATE INDEX IF NOT EXISTS idx_lastAccess ON file_cache(lastAccess);
-        CREATE INDEX IF NOT EXISTS idx_mtime ON file_cache(mtime);
-
-        CREATE TABLE IF NOT EXISTS cache_stats (
-          id INTEGER PRIMARY KEY,
-          totalBytes INTEGER DEFAULT 0,
-          entryCount INTEGER DEFAULT 0,
-          lastEviction INTEGER DEFAULT 0
-        );
-
-        INSERT OR IGNORE INTO cache_stats (id, totalBytes, entryCount, lastEviction)
-        VALUES (1, 0, 0, 0);
-      `);
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            console.error(`[token-pilot] Failed to initialize cache schema: ${message}`);
-            throw err;
-        }
-    }
-    /**
-     * Get cached entry from L1 or L2
-     * Returns from L1 first (fastest), then L2 (persistent)
-     */
-    get(filePath) {
-        // L1: In-memory cache (fastest)
-        const l1Entry = this.l1.get(filePath);
-        if (l1Entry) {
-            this.l1Hits++;
-            this.updateLastAccess(filePath);
-            return l1Entry;
-        }
-        // Skip L2 if in L1-only mode
-        if (this.l1Only || !this.db) {
-            this.misses++;
-            return null;
-        }
-        // L2: SQLite persistent cache
-        try {
-            const stmt = this.db.prepare(`
-        SELECT path, structure, content, lines, hash, mtime, lastAccess
-        FROM file_cache
-        WHERE path = ?
-        LIMIT 1
-      `);
-            const row = stmt.get(filePath);
-            if (row) {
-                this.l2Hits++;
-                const entry = {
-                    structure: JSON.parse(row.structure),
-                    content: row.content,
-                    lines: JSON.parse(row.lines),
-                    mtime: row.mtime,
-                    hash: row.hash,
-                    lastAccess: Date.now()
-                };
-                // Promote to L1 (capped at l1MaxSize)
-                if (this.l1.size >= this.l1MaxSize) {
-                    const firstKey = this.l1.keys().next().value;
-                    this.l1.delete(firstKey);
-                }
-                this.l1.set(filePath, entry);
-                // Update lastAccess in L2
-                this.updateLastAccess(filePath);
-                return entry;
-            }
-            this.misses++;
-            return null;
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            console.error(`[token-pilot] Cache get error for ${filePath}: ${message}`);
-            return null;
-        }
-    }
-    /**
-     * Set cache entry in L1 and L2
-     */
-    set(filePath, entry) {
-        // Add to L1 (capped at l1MaxSize)
-        if (this.l1.size >= this.l1MaxSize) {
-            const firstKey = this.l1.keys().next().value;
-            this.l1.delete(firstKey);
-        }
-        this.l1.set(filePath, entry);
-        // Skip L2 if in L1-only mode
-        if (this.l1Only || !this.db) {
-            this.triggerOnSet(filePath);
-            return;
-        }
-        // Add to L2 (SQLite)
-        try {
-            const sizeBytes = this.estimateSize(entry);
-            const stmt = this.db.prepare(`
-        INSERT OR REPLACE INTO file_cache
-        (path, structure, content, lines, hash, mtime, lastAccess, sizeBytes)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-      `);
-            const now = Date.now();
-            stmt.run(filePath, JSON.stringify(entry.structure), entry.content, JSON.stringify(entry.lines), entry.hash, entry.mtime, now, sizeBytes);
-            // Update stats
-            this.updateStats();
-            // Check if eviction needed
-            this.evictIfNeeded();
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            console.error(`[token-pilot] Cache set error for ${filePath}: ${message}`);
-            // Continue anyway - we have L1 cache
-        }
-        // Trigger onSet callback
-        this.triggerOnSet(filePath);
-    }
-    /**
-     * Get cached entry by content hash (semantic caching)
-     * Useful when same file content loaded from different paths
-     */
-    getByHash(contentHash) {
-        if (this.l1Only || !this.db) {
-            return null;
-        }
-        try {
-            const stmt = this.db.prepare(`
-        SELECT path, structure, content, lines, hash, mtime, lastAccess
-        FROM file_cache
-        WHERE hash = ?
-        LIMIT 1
-      `);
-            const row = stmt.get(contentHash);
-            if (row) {
-                const entry = {
-                    structure: JSON.parse(row.structure),
-                    content: row.content,
-                    lines: JSON.parse(row.lines),
-                    mtime: row.mtime,
-                    hash: row.hash,
-                    lastAccess: Date.now()
-                };
-                return entry;
-            }
-            return null;
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            console.error(`[token-pilot] Cache getByHash error: ${message}`);
-            return null;
-        }
-    }
-    /**
-     * Remove entry from both L1 and L2
-     */
-    delete(filePath) {
-        this.l1.delete(filePath);
-        if (this.l1Only || !this.db) {
-            return;
-        }
-        try {
-            const stmt = this.db.prepare('DELETE FROM file_cache WHERE path = ?');
-            stmt.run(filePath);
-            this.updateStats();
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            console.error(`[token-pilot] Cache delete error: ${message}`);
-        }
-    }
-    /**
-     * Clear all cache (useful for testing)
-     */
-    clear() {
-        this.l1.clear();
-        if (this.l1Only || !this.db) {
-            return;
-        }
-        try {
-            this.db.exec('DELETE FROM file_cache');
-            this.db.prepare('UPDATE cache_stats SET totalBytes = 0, entryCount = 0').run();
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            console.error(`[token-pilot] Cache clear error: ${message}`);
-        }
-    }
-    /**
-     * Get cache statistics
-     */
-    getStats() {
-        if (this.l1Only || !this.db) {
-            return {
-                totalBytes: 0,
-                entryCount: 0,
-                l1Size: this.l1.size,
-                l2Size: 0,
-                maxBytes: this.maxSizeBytes
-            };
-        }
-        try {
-            const stmt = this.db.prepare('SELECT totalBytes, entryCount FROM cache_stats WHERE id = 1');
-            const row = stmt.get();
-            return {
-                totalBytes: row?.totalBytes || 0,
-                entryCount: row?.entryCount || 0,
-                l1Size: this.l1.size,
-                l2Size: this.getAllEntries().length,
-                maxBytes: this.maxSizeBytes
-            };
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            console.error(`[token-pilot] Cache getStats error: ${message}`);
-            return {
-                totalBytes: 0,
-                entryCount: 0,
-                l1Size: this.l1.size,
-                l2Size: 0,
-                maxBytes: this.maxSizeBytes
-            };
-        }
-    }
-    /**
-     * Get all cached entries (for iteration/analysis)
-     */
-    getAllEntries() {
-        if (this.l1Only || !this.db) {
-            return [];
-        }
-        try {
-            const stmt = this.db.prepare('SELECT path, sizeBytes, lastAccess FROM file_cache');
-            return stmt.all();
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            console.error(`[token-pilot] Cache getAllEntries error: ${message}`);
-            return [];
-        }
-    }
-    /**
-     * Evict LRU entries if cache exceeds size limit
-     */
-    evictIfNeeded() {
-        if (this.l1Only || !this.db) {
-            return;
-        }
-        try {
-            const stats = this.getStats();
-            if (stats.totalBytes <= this.maxSizeBytes) {
-                return;
-            }
-            // Need to evict: remove oldest entries until below 90% limit
-            const targetSize = this.maxSizeBytes * 0.9;
-            let currentSize = stats.totalBytes;
-            const stmt = this.db.prepare(`
-        SELECT path, sizeBytes FROM file_cache
-        ORDER BY lastAccess ASC
-        LIMIT 100
-      `);
-            const oldestEntries = stmt.all();
-            for (const entry of oldestEntries) {
-                if (currentSize <= targetSize)
-                    break;
-                this.delete(entry.path);
-                currentSize -= entry.sizeBytes;
-            }
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            console.error(`[token-pilot] Cache evictIfNeeded error: ${message}`);
-        }
-    }
-    /**
-     * Update lastAccess timestamp for file
-     */
-    updateLastAccess(filePath) {
-        if (this.l1Only || !this.db) {
-            return;
-        }
-        try {
-            const stmt = this.db.prepare('UPDATE file_cache SET lastAccess = ? WHERE path = ?');
-            stmt.run(Date.now(), filePath);
-        }
-        catch (err) {
-            // Silently ignore - not critical for operation
-        }
-    }
-    /**
-     * Update cache statistics
-     */
-    updateStats() {
-        if (this.l1Only || !this.db) {
-            return;
-        }
-        try {
-            const stmt = this.db.prepare(`
-        SELECT COUNT(*) as count, COALESCE(SUM(sizeBytes), 0) as totalBytes
-        FROM file_cache
-      `);
-            const row = stmt.get();
-            const updateStmt = this.db.prepare(`
-        UPDATE cache_stats
-        SET entryCount = ?, totalBytes = ?, lastEviction = ?
-        WHERE id = 1
-      `);
-            updateStmt.run(row.count, row.totalBytes, Date.now());
-        }
-        catch (err) {
-            // Silently ignore - not critical for operation
-        }
-    }
-    /**
-     * Estimate entry size in bytes
-     */
-    estimateSize(entry) {
-        return (entry.content.length +
-            JSON.stringify(entry.structure).length +
-            JSON.stringify(entry.lines).length +
-            entry.hash.length);
-    }
-    /**
-     * Register callback for file writes (compatibility with FileCache)
-     */
-    onSet(callback) {
-        this.onSetCallback = callback;
-    }
-    /**
-     * Invalidate cache entry (compatibility with FileCache)
-     */
-    invalidate(filePath) {
-        if (filePath) {
-            this.delete(filePath);
-        }
-        else {
-            this.clear();
-        }
-    }
-    /**
-     * Invalidate files by git diff (compatibility with FileCache)
-     */
-    async invalidateByGitDiff(changedFiles) {
-        for (const file of changedFiles) {
-            this.invalidate(file);
-        }
-    }
-    /**
-     * Check if file is small (under threshold lines)
-     */
-    async isSmallFile(filePath) {
-        try {
-            const content = await readFile(filePath, 'utf-8');
-            return content.split('\n').length <= this.smallFileThreshold;
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * Check if cached entry is stale (mtime changed)
-     */
-    async isStale(filePath) {
-        const entry = this.get(filePath);
-        if (!entry)
-            return true;
-        try {
-            const fileStat = await stat(filePath);
-            return fileStat.mtimeMs !== entry.mtime;
-        }
-        catch {
-            return true;
-        }
-    }
-    /**
-     * Get small file threshold
-     */
-    getSmallFileThreshold() {
-        return this.smallFileThreshold;
-    }
-    /**
-     * Get all cached file paths
-     */
-    cachedPaths() {
-        // Return L1 paths + L2 paths
-        const l1Paths = Array.from(this.l1.keys());
-        if (this.l1Only || !this.db) {
-            return l1Paths;
-        }
-        try {
-            const stmt = this.db.prepare('SELECT path FROM file_cache');
-            const rows = stmt.all();
-            const l2Paths = rows.map(row => row.path);
-            // Combine and deduplicate
-            return Array.from(new Set([...l1Paths, ...l2Paths]));
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            console.error(`[token-pilot] Cache cachedPaths error: ${message}`);
-            return l1Paths;
-        }
-    }
-    /**
-     * Get cache statistics (compatibility with FileCache)
-     */
-    stats() {
-        const cacheStats = this.getStats();
-        const total = this.l1Hits + this.l2Hits + this.misses;
-        const hitRate = total > 0 ? (this.l1Hits + this.l2Hits) / total : 0;
-        return {
-            entries: cacheStats.entryCount,
-            sizeBytes: cacheStats.totalBytes,
-            hitRate,
-        };
-    }
-    /**
-     * Get detailed cache performance metrics
-     */
-    getPerformanceMetrics() {
-        const total = this.l1Hits + this.l2Hits + this.misses;
-        const hits = this.l1Hits + this.l2Hits;
-        const hitRate = total > 0 ? hits / total : 0;
-        const l1HitRate = this.l1Hits > 0 ? this.l1Hits / (this.l1Hits + this.l2Hits + this.misses) : 0;
-        const l2HitRate = this.l2Hits > 0 ? this.l2Hits / total : 0;
-        return {
-            l1Hits: this.l1Hits,
-            l2Hits: this.l2Hits,
-            misses: this.misses,
-            totalRequests: total,
-            hitRate,
-            l1HitRate,
-            l2HitRate,
-            l1Only: this.l1Only,
-        };
-    }
-    /**
-     * Trigger onSet callback after setting entry
-     */
-    triggerOnSet(filePath) {
-        this.onSetCallback?.(filePath);
-    }
-    /**
-     * Close database connection
-     */
-    close() {
-        if (!this.db) {
-            return;
-        }
-        try {
-            this.db.close();
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            console.error(`[token-pilot] Cache close error: ${message}`);
-        }
-    }
-}
-/**
- * Singleton instance for global use
- */
-let instance = null;
-export function initializePersistentCache(projectRoot, maxSizeMB) {
-    if (!instance) {
-        instance = new PersistentFileCache(projectRoot, maxSizeMB);
-    }
-    return instance;
-}
-export function getPersistentCache() {
-    if (!instance) {
-        throw new Error('PersistentFileCache not initialized. Call initializePersistentCache first.');
-    }
-    return instance;
-}
-export function closePersistentCache() {
-    if (instance) {
-        instance.close();
-        instance = null;
-    }
-}
-//# sourceMappingURL=persistent-cache.js.map