minovative-mind-cli 2.14.1 → 2.14.3

package/dist/utils/dependencyTracer.d.ts

@@ -1,9 +1,28 @@
+export declare function invalidateDependencyGraph(workspaceRoot?: string): void;
+export declare function clearDependencyGraphCache(): void;
+export declare function getDependencyGraphCacheStats(): Readonly<{
+    hits: number;
+    misses: number;
+    invalidations: number;
+    cachedWorkspaces: number;
+}>;
+export declare function resetDependencyGraphCacheStats(): void;
 export interface DependencyNode {
     /** Files this file directly imports (forward/downstream) */
     imports: Set<string>;
     /** Files that directly import this file (reverse/upstream) */
     importedBy: Set<string>;
 }
+export interface CentralityMetrics {
+    /** Number of files that directly import this file (hub dependency) */
+    inDegree: number;
+    /** Number of files this file directly imports */
+    outDegree: number;
+    /** Total direct connections (inDegree + outDegree) */
+    totalDegree: number;
+    /** Centrality score (weighted: inDegree * 1.5 + outDegree * 0.5) */
+    score: number;
+}
 export interface DependencyGraph {
     /** What files does `filePath` directly import? */
     getImports(filePath: string): string[];
@@ -13,6 +32,10 @@ export interface DependencyGraph {
     getReverseDependencyTree(filePath: string, maxDepth?: number): string[];
     /** Transitive: all files reachable via import chains, up to maxDepth */
     getForwardDependencyTree(filePath: string, maxDepth?: number): string[];
+    /** Centrality metrics for a specific file */
+    getCentrality(filePath: string): CentralityMetrics;
+    /** Centrality metrics across all indexed files in the graph */
+    getAllCentrality(): Map<string, CentralityMetrics>;
     /** The full raw graph for inspection */
     readonly nodes: ReadonlyMap<string, DependencyNode>;
 }
@@ -21,9 +44,13 @@ export interface DependencyGraph {
  *
  * Performance: This is pure regex + filesystem walking — no AST parsing.
  * For a typical project (<5,000 source files), this completes in <1s.
- * The graph is ephemeral: built once per `gatherContext` call and discarded.
+ * The graph is cached in-memory per workspaceRoot and automatically reused across
+ * subsequent queries until invalidated by file modifications.
+ *
+ * @param workspaceRoot - Root directory of the target project workspace
+ * @param forceRebuild - If true, bypasses the in-memory cache and forces a full rescan
  */
-export declare function buildDependencyGraph(workspaceRoot: string): Promise<DependencyGraph>;
+export declare function buildDependencyGraph(workspaceRoot: string, forceRebuild?: boolean): Promise<DependencyGraph>;
 export interface FindDependenciesResult {
     filePath: string;
     forwardDeps: string[];
@@ -42,6 +69,17 @@ export declare function findDependencies(workspaceRoot: string, filePath: string
  * suitable for feeding back to the LLM.
  */
 export declare function formatDependencyResult(result: FindDependenciesResult): string;
+/**
+ * Calculates graph centrality metrics for all nodes in a dependency graph.
+ */
+export declare function computeGraphCentrality(nodes: ReadonlyMap<string, DependencyNode> | Map<string, DependencyNode>): Map<string, CentralityMetrics>;
+/**
+ * Returns top dependency hub files sorted descending by centrality score.
+ */
+export declare function getHubFiles(graph: DependencyGraph, limit?: number): Array<{
+    filePath: string;
+    metrics: CentralityMetrics;
+}>;
 /**
  * Resets the tsconfig alias cache (useful between workspace changes).
  */

package/dist/utils/dependencyTracer.js

@@ -1,6 +1,47 @@
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
 import { EXCLUDED_EXTENSIONS } from './excludedExtensions.js';
+import { debugLog } from './logger.js';
+// ─── Dependency Graph Cache ──────────────────────────────────────────
+const dependencyGraphCache = new Map();
+const dependencyGraphCacheStats = {
+    hits: 0,
+    misses: 0,
+    invalidations: 0,
+};
+function normalizeWorkspaceKey(workspaceRoot) {
+    const resolved = path.resolve(workspaceRoot).replace(/\\/g, '/');
+    return process.platform === 'win32' ? resolved.toLowerCase() : resolved;
+}
+export function invalidateDependencyGraph(workspaceRoot) {
+    if (workspaceRoot) {
+        const key = normalizeWorkspaceKey(workspaceRoot);
+        if (dependencyGraphCache.delete(key)) {
+            dependencyGraphCacheStats.invalidations++;
+            debugLog(`[DependencyTracer] Invalidated graph cache for workspace: ${workspaceRoot}`);
+        }
+    }
+    else {
+        const count = dependencyGraphCache.size;
+        dependencyGraphCache.clear();
+        dependencyGraphCacheStats.invalidations += count;
+        debugLog(`[DependencyTracer] Cleared graph cache for all workspaces (${count})`);
+    }
+}
+export function clearDependencyGraphCache() {
+    invalidateDependencyGraph();
+}
+export function getDependencyGraphCacheStats() {
+    return {
+        ...dependencyGraphCacheStats,
+        cachedWorkspaces: dependencyGraphCache.size,
+    };
+}
+export function resetDependencyGraphCacheStats() {
+    dependencyGraphCacheStats.hits = 0;
+    dependencyGraphCacheStats.misses = 0;
+    dependencyGraphCacheStats.invalidations = 0;
+}
 // ─── Language Profile Registry ───────────────────────────────────────
 //
 // Each profile defines regex patterns that extract import specifiers for
@@ -503,9 +544,24 @@ async function walkWorkspace(workspaceRoot) {
  *
  * Performance: This is pure regex + filesystem walking — no AST parsing.
  * For a typical project (<5,000 source files), this completes in <1s.
- * The graph is ephemeral: built once per `gatherContext` call and discarded.
+ * The graph is cached in-memory per workspaceRoot and automatically reused across
+ * subsequent queries until invalidated by file modifications.
+ *
+ * @param workspaceRoot - Root directory of the target project workspace
+ * @param forceRebuild - If true, bypasses the in-memory cache and forces a full rescan
  */
-export async function buildDependencyGraph(workspaceRoot) {
+export async function buildDependencyGraph(workspaceRoot, forceRebuild = false) {
+    const key = normalizeWorkspaceKey(workspaceRoot);
+    if (!forceRebuild) {
+        const cached = dependencyGraphCache.get(key);
+        if (cached) {
+            dependencyGraphCacheStats.hits++;
+            debugLog(`[DependencyTracer] Graph cache HIT for ${workspaceRoot} (${cached.graph.nodes.size} nodes)`);
+            return cached.graph;
+        }
+    }
+    dependencyGraphCacheStats.misses++;
+    debugLog(`[DependencyTracer] Graph cache MISS, building graph for ${workspaceRoot}`);
     const nodes = new Map();
     function getOrCreate(filePath) {
         let node = nodes.get(filePath);
@@ -540,7 +596,7 @@ export async function buildDependencyGraph(workspaceRoot) {
         }
     }));
     // 3. Return the graph with query methods
-    return {
+    const graph = {
         nodes,
         getImports(filePath) {
             return Array.from(nodes.get(filePath)?.imports || []);
@@ -554,7 +610,20 @@ export async function buildDependencyGraph(workspaceRoot) {
         getForwardDependencyTree(filePath, maxDepth = 3) {
             return bfsTraverse(nodes, filePath, 'imports', maxDepth);
         },
+        getCentrality(filePath) {
+            const node = nodes.get(filePath);
+            const inDegree = node?.importedBy.size ?? 0;
+            const outDegree = node?.imports.size ?? 0;
+            const totalDegree = inDegree + outDegree;
+            const score = inDegree * 1.5 + outDegree * 0.5;
+            return { inDegree, outDegree, totalDegree, score };
+        },
+        getAllCentrality() {
+            return computeGraphCentrality(nodes);
+        },
     };
+    dependencyGraphCache.set(key, { graph, timestamp: Date.now() });
+    return graph;
 }
 /**
  * BFS traversal of the dependency graph in a given direction.
@@ -652,6 +721,29 @@ export function formatDependencyResult(result) {
     lines.push(`Total impact radius: ${totalImpact} file(s)`);
     return lines.join('\n');
 }
+/**
+ * Calculates graph centrality metrics for all nodes in a dependency graph.
+ */
+export function computeGraphCentrality(nodes) {
+    const result = new Map();
+    for (const [file, node] of nodes.entries()) {
+        const inDegree = node.importedBy.size;
+        const outDegree = node.imports.size;
+        const totalDegree = inDegree + outDegree;
+        const score = inDegree * 1.5 + outDegree * 0.5;
+        result.set(file, { inDegree, outDegree, totalDegree, score });
+    }
+    return result;
+}
+/**
+ * Returns top dependency hub files sorted descending by centrality score.
+ */
+export function getHubFiles(graph, limit) {
+    const allCentrality = graph.getAllCentrality();
+    const entries = Array.from(allCentrality.entries()).map(([filePath, metrics]) => ({ filePath, metrics }));
+    entries.sort((a, b) => b.metrics.score - a.metrics.score || b.metrics.inDegree - a.metrics.inDegree);
+    return typeof limit === 'number' && limit > 0 ? entries.slice(0, limit) : entries;
+}
 /**
  * Resets the tsconfig alias cache (useful between workspace changes).
  */

package/dist/utils/fileReadCache.d.ts

@@ -0,0 +1,58 @@
+export interface CachedFileEntry {
+    content: string;
+    mtimeMs: number;
+    size: number;
+    lastAccessed: number;
+    byteLength: number;
+}
+export interface FileReadCacheStats {
+    hits: number;
+    misses: number;
+    invalidations: number;
+    currentEntries: number;
+    currentBytes: number;
+}
+/**
+ * Normalizes a file path to create a deterministic, cross-platform cache key.
+ * Resolves relative segments, standardizes to forward slashes, and on Windows
+ * lowercases the path to guarantee case-insensitive parity.
+ *
+ * @param filePath - The absolute or relative file path to normalize.
+ * @returns Standardized cache key string.
+ */
+export declare function normalizeCacheKey(filePath: string): string;
+/**
+ * Retrieves file content with in-turn caching and strict mtime validation.
+ *
+ * Behavior:
+ * 1. Checks `fs.stat(absPath)`.
+ * 2. If file exceeds 1MB, reads from disk directly without polluting memory cache.
+ * 3. If cached with identical `mtimeMs` and `size`, returns the cached string ($O(1)$ disk avoidance).
+ * 4. If modified or uncached, reads from disk, stores in cache with LRU eviction, and returns.
+ *
+ * @param absPath - Absolute path to the file on disk.
+ * @returns The string content of the file.
+ */
+export declare function getCachedFileContent(absPath: string): Promise<string>;
+/**
+ * Invalidates the cached entry for a specific file path.
+ * Must be invoked whenever `modify_file`, `write_file`, `delete_file`, or `rename_file`
+ * modifies the target on disk.
+ *
+ * @param filePath - The file path that was modified.
+ */
+export declare function invalidateFileReadCache(filePath: string): void;
+/**
+ * Completely clears the in-memory file read cache.
+ * Must be invoked when arbitrary shell commands run (e.g. `npm run build`, `git checkout`),
+ * or when `/revert` restores previous file trees.
+ */
+export declare function clearFileReadCache(): void;
+/**
+ * Returns diagnostic statistics for the file read cache.
+ */
+export declare function getFileReadCacheStats(): Readonly<FileReadCacheStats>;
+/**
+ * Resets the telemetry counters (useful for unit tests).
+ */
+export declare function resetFileReadCacheStats(): void;

package/dist/utils/fileReadCache.js

@@ -0,0 +1,162 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { debugLog } from './logger.js';
+/**
+ * Maximum number of distinct files to keep in the in-memory read cache.
+ */
+const MAX_CACHED_FILES = 200;
+/**
+ * Maximum aggregate memory size (in bytes) allowed for cached file contents (15MB).
+ */
+const MAX_TOTAL_BYTES = 15 * 1024 * 1024;
+/**
+ * Single file size ceiling (1MB). Files larger than this bypass the in-memory
+ * cache to prevent memory bloat from huge generated assets.
+ */
+const MAX_SINGLE_FILE_BYTES = 1 * 1024 * 1024;
+const cache = new Map();
+let currentTotalBytes = 0;
+const stats = {
+    hits: 0,
+    misses: 0,
+    invalidations: 0,
+    currentEntries: 0,
+    currentBytes: 0,
+};
+/**
+ * Normalizes a file path to create a deterministic, cross-platform cache key.
+ * Resolves relative segments, standardizes to forward slashes, and on Windows
+ * lowercases the path to guarantee case-insensitive parity.
+ *
+ * @param filePath - The absolute or relative file path to normalize.
+ * @returns Standardized cache key string.
+ */
+export function normalizeCacheKey(filePath) {
+    const resolved = path.resolve(filePath).replace(/\\/g, '/');
+    return process.platform === 'win32' ? resolved.toLowerCase() : resolved;
+}
+/**
+ * Evicts the least recently accessed cache entries until the cache satisfies
+ * both the max file count and max byte size constraints.
+ */
+function evictOldestEntries(extraBytesNeeded = 0) {
+    while ((cache.size >= MAX_CACHED_FILES || currentTotalBytes + extraBytesNeeded > MAX_TOTAL_BYTES) && cache.size > 0) {
+        let oldestKey = null;
+        let oldestTime = Infinity;
+        for (const [key, entry] of cache.entries()) {
+            if (entry.lastAccessed < oldestTime) {
+                oldestTime = entry.lastAccessed;
+                oldestKey = key;
+            }
+        }
+        if (!oldestKey)
+            break;
+        const evicted = cache.get(oldestKey);
+        if (evicted) {
+            currentTotalBytes -= evicted.byteLength;
+        }
+        cache.delete(oldestKey);
+        debugLog(`[FileReadCache] Evicted LRU entry: ${oldestKey}`);
+    }
+    stats.currentEntries = cache.size;
+    stats.currentBytes = currentTotalBytes;
+}
+/**
+ * Retrieves file content with in-turn caching and strict mtime validation.
+ *
+ * Behavior:
+ * 1. Checks `fs.stat(absPath)`.
+ * 2. If file exceeds 1MB, reads from disk directly without polluting memory cache.
+ * 3. If cached with identical `mtimeMs` and `size`, returns the cached string ($O(1)$ disk avoidance).
+ * 4. If modified or uncached, reads from disk, stores in cache with LRU eviction, and returns.
+ *
+ * @param absPath - Absolute path to the file on disk.
+ * @returns The string content of the file.
+ */
+export async function getCachedFileContent(absPath) {
+    const stat = await fs.stat(absPath);
+    if (stat.size > MAX_SINGLE_FILE_BYTES) {
+        debugLog(`[FileReadCache] Bypassing cache for large file (${stat.size} bytes > 1MB): ${absPath}`);
+        stats.misses++;
+        return fs.readFile(absPath, 'utf-8');
+    }
+    const key = normalizeCacheKey(absPath);
+    const existing = cache.get(key);
+    if (existing && existing.mtimeMs === stat.mtimeMs && existing.size === stat.size) {
+        existing.lastAccessed = Date.now();
+        stats.hits++;
+        debugLog(`[FileReadCache] HIT (${stat.size} bytes): ${absPath}`);
+        return existing.content;
+    }
+    stats.misses++;
+    debugLog(`[FileReadCache] MISS (reading disk): ${absPath}`);
+    const content = await fs.readFile(absPath, 'utf-8');
+    const byteLength = Buffer.byteLength(content, 'utf8');
+    if (existing) {
+        currentTotalBytes -= existing.byteLength;
+    }
+    evictOldestEntries(byteLength);
+    cache.set(key, {
+        content,
+        mtimeMs: stat.mtimeMs,
+        size: stat.size,
+        lastAccessed: Date.now(),
+        byteLength,
+    });
+    currentTotalBytes += byteLength;
+    stats.currentEntries = cache.size;
+    stats.currentBytes = currentTotalBytes;
+    return content;
+}
+/**
+ * Invalidates the cached entry for a specific file path.
+ * Must be invoked whenever `modify_file`, `write_file`, `delete_file`, or `rename_file`
+ * modifies the target on disk.
+ *
+ * @param filePath - The file path that was modified.
+ */
+export function invalidateFileReadCache(filePath) {
+    const key = normalizeCacheKey(filePath);
+    const existing = cache.get(key);
+    if (existing) {
+        currentTotalBytes -= existing.byteLength;
+        cache.delete(key);
+        stats.invalidations++;
+        stats.currentEntries = cache.size;
+        stats.currentBytes = currentTotalBytes;
+        debugLog(`[FileReadCache] INVALIDATED entry: ${filePath}`);
+    }
+}
+/**
+ * Completely clears the in-memory file read cache.
+ * Must be invoked when arbitrary shell commands run (e.g. `npm run build`, `git checkout`),
+ * or when `/revert` restores previous file trees.
+ */
+export function clearFileReadCache() {
+    const count = cache.size;
+    cache.clear();
+    currentTotalBytes = 0;
+    stats.currentEntries = 0;
+    stats.currentBytes = 0;
+    debugLog(`[FileReadCache] CLEARED ${count} entries from cache`);
+}
+/**
+ * Returns diagnostic statistics for the file read cache.
+ */
+export function getFileReadCacheStats() {
+    return {
+        ...stats,
+        currentEntries: cache.size,
+        currentBytes: currentTotalBytes,
+    };
+}
+/**
+ * Resets the telemetry counters (useful for unit tests).
+ */
+export function resetFileReadCacheStats() {
+    stats.hits = 0;
+    stats.misses = 0;
+    stats.invalidations = 0;
+    stats.currentEntries = cache.size;
+    stats.currentBytes = currentTotalBytes;
+}

package/dist/utils/projectStorage.js

@@ -1,7 +1,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import * as pc from 'picocolors';
-import { buildDependencyGraph } from './dependencyTracer.js';
+import { buildDependencyGraph, invalidateDependencyGraph } from './dependencyTracer.js';
 /**
  * Gets the path to the project's .minovativemind storage directory.
  */
@@ -236,6 +236,7 @@ export async function invalidateCacheForDependents(workspaceRoot, changedFiles)
         if (updated) {
             writeCache(workspaceRoot, 'context_cache.json', cachedContext);
         }
+        invalidateDependencyGraph(workspaceRoot);
         try {
             const { invalidateFilesFromInvestigationCache } = await import('../services/orchestration/investigationCache.js');
             await invalidateFilesFromInvestigationCache(workspaceRoot, changedFiles);

package/dist/utils/symbolExtractor.d.ts

@@ -1,3 +1,15 @@
+export interface SymbolExtractorCacheStats {
+    outlineHits: number;
+    outlineMisses: number;
+    symbolsHits: number;
+    symbolsMisses: number;
+    indexHits: number;
+    indexMisses: number;
+    size: number;
+}
+export declare function clearSymbolExtractorCache(): void;
+export declare function getSymbolExtractorCacheStats(): Readonly<SymbolExtractorCacheStats>;
+export declare function resetSymbolExtractorCacheStats(): void;
 /**
  * Supported classification kinds for extracted AST symbols and definition chunks.
  */

package/dist/utils/symbolExtractor.js

@@ -1,4 +1,57 @@
 import * as path from 'node:path';
+import crypto from 'node:crypto';
+// ─── AST Symbol Cache ────────────────────────────────────────────────
+const MAX_SYMBOL_CACHE_ENTRIES = 1000;
+const symbolCache = new Map();
+const symbolCacheStats = {
+    outlineHits: 0,
+    outlineMisses: 0,
+    symbolsHits: 0,
+    symbolsMisses: 0,
+    indexHits: 0,
+    indexMisses: 0,
+};
+function hashContent(content) {
+    return crypto.createHash('sha256').update(content).digest('hex').substring(0, 16);
+}
+function getFromSymbolCache(key) {
+    if (!symbolCache.has(key))
+        return undefined;
+    const value = symbolCache.get(key);
+    // Refresh LRU order
+    symbolCache.delete(key);
+    symbolCache.set(key, value);
+    return value;
+}
+function setToSymbolCache(key, value) {
+    if (symbolCache.has(key)) {
+        symbolCache.delete(key);
+    }
+    else if (symbolCache.size >= MAX_SYMBOL_CACHE_ENTRIES) {
+        const oldestKey = symbolCache.keys().next().value;
+        if (oldestKey !== undefined) {
+            symbolCache.delete(oldestKey);
+        }
+    }
+    symbolCache.set(key, value);
+}
+export function clearSymbolExtractorCache() {
+    symbolCache.clear();
+}
+export function getSymbolExtractorCacheStats() {
+    return {
+        ...symbolCacheStats,
+        size: symbolCache.size,
+    };
+}
+export function resetSymbolExtractorCacheStats() {
+    symbolCacheStats.outlineHits = 0;
+    symbolCacheStats.outlineMisses = 0;
+    symbolCacheStats.symbolsHits = 0;
+    symbolCacheStats.symbolsMisses = 0;
+    symbolCacheStats.indexHits = 0;
+    symbolCacheStats.indexMisses = 0;
+}
 /**
  * Estimates token consumption for a given string using a standard ~3.8 characters per token heuristic.
  *
@@ -204,8 +257,14 @@ function findPrecedingContext(lines, declarationIndex, ext) {
         const isDecorator = prevLine.startsWith('@');
         const isPythonComment = (ext === '.py' || ext === '.pyi') && prevLine.startsWith('#');
         const isLineComment = prevLine.startsWith('//');
-        const isRustDocOrAttr = (ext === '.rs') && (prevLine.startsWith('///') || prevLine.startsWith('//!') || prevLine.startsWith('#['));
-        if (isDecorator || isPythonComment || isLineComment || isJsDocEnd || isJsDocLine || isJsDocStart || isRustDocOrAttr) {
+        const isRustDocOrAttr = ext === '.rs' && (prevLine.startsWith('///') || prevLine.startsWith('//!') || prevLine.startsWith('#['));
+        if (isDecorator ||
+            isPythonComment ||
+            isLineComment ||
+            isJsDocEnd ||
+            isJsDocLine ||
+            isJsDocStart ||
+            isRustDocOrAttr) {
             start--;
             if (isJsDocStart) {
                 insideJsDoc = false;
@@ -227,7 +286,8 @@ function findPrecedingContext(lines, declarationIndex, ext) {
  * @returns True if the line contains valid code characters outside comments/strings
  */
 function scanLineValidity(line, state) {
-    let j = 0, lineHasValidCode = false;
+    let j = 0;
+    let lineHasValidCode = false;
     while (j < line.length) {
         if (!state.inMultiLineComment && state.inMultiLineString) {
             if (line[j] === '\\') {
@@ -357,7 +417,11 @@ function findBlockEnd(lines, i, ext) {
             processLineChars(lines[j], parseState);
             if (parseState.foundOpen && parseState.braces === 0 && parseState.brackets === 0 && parseState.parens === 0)
                 break;
-            if (!parseState.foundOpen && j > i && parseState.braces === 0 && parseState.brackets === 0 && parseState.parens === 0) {
+            if (!parseState.foundOpen &&
+                j > i &&
+                parseState.braces === 0 &&
+                parseState.brackets === 0 &&
+                parseState.parens === 0) {
                 const prevLine = lines[j - 1].trim();
                 if (!prevLine.endsWith(',') && !prevLine.endsWith('.')) {
                     endIndex = j - 1;
@@ -421,7 +485,8 @@ export function extractSymbolMetadata(content, filePath, targetElements) {
     for (let i = 0; i < lines.length; i++) {
         const startsInMulti = scanState.inMultiLineComment || scanState.inMultiLineString !== null;
         const lineHasValidCode = scanLineValidity(lines[i], scanState);
-        if (startsInMulti || (!lineHasValidCode && (scanState.inMultiLineComment || scanState.inMultiLineString !== null))) {
+        if (startsInMulti ||
+            (!lineHasValidCode && (scanState.inMultiLineComment || scanState.inMultiLineString !== null))) {
             validLines[i] = false;
         }
     }
@@ -447,7 +512,6 @@ export function extractSymbolMetadata(content, filePath, targetElements) {
             // 1. If target specified a parent (e.g. Class.method)
             if (symTarget.parentName) {
                 if (symTarget.regex.test(line)) {
-                    const parentStartIndex = findPrecedingContext(lines, i, ext);
                     const parentEndIndex = findBlockEnd(lines, i, ext);
                     // Scan inside the parent body for the member
                     for (let m = i + 1; m <= parentEndIndex; m++) {
@@ -513,6 +577,13 @@ export function extractSymbolMetadata(content, filePath, targetElements) {
 export function extractSymbolIndex(content, filePath) {
     if (!content || !content.trim())
         return [];
+    const key = `index:${filePath}:${hashContent(content)}`;
+    const cached = getFromSymbolCache(key);
+    if (cached !== undefined) {
+        symbolCacheStats.indexHits++;
+        return cached;
+    }
+    symbolCacheStats.indexMisses++;
     const ext = path.extname(filePath).toLowerCase();
     const lines = content.split('\n');
     const symbols = [];
@@ -826,6 +897,7 @@ export function extractSymbolIndex(content, filePath) {
         }
         i++;
     }
+    setToSymbolCache(key, symbols);
     return symbols;
 }
 /**
@@ -895,12 +967,19 @@ export function chunkDefinitions(content, filePath, options) {
 export function extractSymbols(content, filePath, targetElements, options) {
     if (!targetElements || targetElements.length === 0)
         return content;
-    const ext = path.extname(filePath).toLowerCase();
+    const sortedTargets = targetElements.slice().sort().join(',');
+    const key = `symbols:${filePath}:${hashContent(content)}:${sortedTargets}:${options?.maxLinesPerSymbol ?? ''}`;
+    const cached = getFromSymbolCache(key);
+    if (cached !== undefined) {
+        symbolCacheStats.symbolsHits++;
+        return cached;
+    }
+    symbolCacheStats.symbolsMisses++;
     const lines = content.split('\n');
     const linesToKeep = new Set();
     const metadata = extractSymbolMetadata(content, filePath, targetElements);
     for (const meta of metadata) {
-        let start = meta.startLine;
+        const start = meta.startLine;
         let end = meta.endLine;
         if (options?.maxLinesPerSymbol && end - start + 1 > options.maxLinesPerSymbol) {
             end = start + options.maxLinesPerSymbol - 1;
@@ -919,7 +998,9 @@ export function extractSymbols(content, filePath, targetElements, options) {
         output.push(lines[lineNum]);
         previousLineNum = lineNum;
     }
-    return output.join('\n');
+    const result = output.join('\n');
+    setToSymbolCache(key, result);
+    return result;
 }
 /**
  * Extracts a compact declarations outline for TypeScript/JavaScript source files.
@@ -1312,7 +1393,7 @@ function extractPythonOutline(lines) {
                 if (cTrim.startsWith('"""') || cTrim.startsWith("'''")) {
                     const delim = cTrim.startsWith('"""') ? '"""' : "'''";
                     output.push(cLine);
-                    if (cTrim.length > 3 && cTrim.endsWith(delim) && cTrim.indexOf(delim, 3) !== -1) {
+                    if (cTrim.length > 3 && cTrim.endsWith(delim) && cTrim.includes(delim, 3)) {
                         // single line docstring
                     }
                     else {
@@ -1844,8 +1925,16 @@ function extractRustOutline(lines) {
 export function extractDeclarationsOutline(content, filePath) {
     if (!content || !content.trim())
         return '';
+    const key = `outline:${filePath}:${hashContent(content)}`;
+    const cached = getFromSymbolCache(key);
+    if (cached !== undefined) {
+        symbolCacheStats.outlineHits++;
+        return cached;
+    }
+    symbolCacheStats.outlineMisses++;
     const ext = path.extname(filePath).toLowerCase();
     const lines = content.split('\n');
+    let result = '';
     switch (ext) {
         case '.ts':
         case '.tsx':
@@ -1855,15 +1944,22 @@ export function extractDeclarationsOutline(content, filePath) {
         case '.cjs':
         case '.mts':
         case '.cts':
-            return extractTsJsOutline(lines);
+            result = extractTsJsOutline(lines);
+            break;
         case '.py':
         case '.pyi':
-            return extractPythonOutline(lines);
+            result = extractPythonOutline(lines);
+            break;
         case '.go':
-            return extractGoOutline(lines);
+            result = extractGoOutline(lines);
+            break;
         case '.rs':
-            return extractRustOutline(lines);
+            result = extractRustOutline(lines);
+            break;
         default:
-            return content.trim();
+            result = content.trim();
+            break;
     }
+    setToSymbolCache(key, result);
+    return result;
 }