code-auditor-mcp 1.3.1 → 1.6.0

package/dist/codeIndexDb.js

@@ -92,6 +92,13 @@ export class CodeIndexDB {
                         optimize: true,
                         resolution: 7,
                         weight: 2 // Return type matches
+                    },
+                    {
+                        field: 'body',
+                        tokenize: 'full',
+                        optimize: true,
+                        resolution: 9,
+                        weight: 1 // Body content matches (lower weight to prioritize metadata matches)
                     }
                 ]
             },
@@ -173,7 +180,9 @@ export class CodeIndexDB {
             },
             returnType: 'unknown',
             // Add tokenized name for better searching
-            tokenizedName: this.tokenizeFunctionName(func.name)
+            tokenizedName: this.tokenizeFunctionName(func.name),
+            // Extract body from metadata if present
+            body: func.metadata?.body
         };
         return enhanced;
     }
@@ -294,6 +303,8 @@ export class CodeIndexDB {
                     stats.removed++;
                 }
             }
+            // Update dependency graph for the affected functions
+            await this.updateDependencyGraph(filePath);
             // Force save
             this.db.saveDatabase();
         }
@@ -302,6 +313,192 @@ export class CodeIndexDB {
         }
         return stats;
     }
+    /**
+     * Update dependency graph - build reverse mappings for calledBy relationships
+     * @param filePath Optional file path to limit the update scope
+     */
+    async updateDependencyGraph(filePath) {
+        this.ensureInitialized();
+        try {
+            // Get all functions (or just those in the specified file)
+            const functions = filePath
+                ? this.functionsCollection.find({ filePath })
+                : this.functionsCollection.find();
+            // Clear existing calledBy relationships for affected functions
+            for (const func of functions) {
+                if (func.metadata) {
+                    func.metadata.calledBy = [];
+                }
+            }
+            // Build calledBy relationships by iterating through all functions
+            const allFunctions = this.functionsCollection.find();
+            for (const caller of allFunctions) {
+                if (caller.metadata?.functionCalls) {
+                    for (const callee of caller.metadata.functionCalls) {
+                        // Find the called function
+                        const calledFunc = this.findFunctionByQualifiedName(callee);
+                        if (calledFunc && calledFunc.metadata) {
+                            if (!calledFunc.metadata.calledBy) {
+                                calledFunc.metadata.calledBy = [];
+                            }
+                            // Add caller to calledBy list if not already present
+                            const callerName = this.getQualifiedFunctionName(caller);
+                            if (!calledFunc.metadata.calledBy.includes(callerName)) {
+                                calledFunc.metadata.calledBy.push(callerName);
+                                this.functionsCollection.update(calledFunc);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to update dependency graph: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Find a function by its qualified name (e.g., "filePath#functionName")
+     */
+    findFunctionByQualifiedName(qualifiedName) {
+        // Handle different name formats
+        if (qualifiedName.includes('#')) {
+            const [filePath, functionName] = qualifiedName.split('#');
+            return this.functionsCollection.findOne({
+                filePath: { $regex: filePath },
+                name: functionName
+            });
+        }
+        else {
+            // Simple function name - search across all files
+            return this.functionsCollection.findOne({ name: qualifiedName });
+        }
+    }
+    /**
+     * Get qualified name for a function
+     */
+    getQualifiedFunctionName(func) {
+        return `${func.filePath}#${func.name}`;
+    }
+    /**
+     * Get transitive dependencies for a function (functions it calls, directly and indirectly)
+     * @param functionName The function to analyze
+     * @param maxDepth Maximum depth to traverse (default 10)
+     * @returns Array of function names with their depth
+     */
+    async getTransitiveDependencies(functionName, maxDepth = 10) {
+        this.ensureInitialized();
+        const dependencies = [];
+        const visited = new Set();
+        const traverse = (funcName, depth) => {
+            if (depth > maxDepth || visited.has(funcName))
+                return;
+            visited.add(funcName);
+            const func = this.findFunctionByQualifiedName(funcName);
+            if (!func?.metadata?.functionCalls)
+                return;
+            for (const callee of func.metadata.functionCalls) {
+                if (!visited.has(callee)) {
+                    dependencies.push({ name: callee, depth });
+                    traverse(callee, depth + 1);
+                }
+            }
+        };
+        traverse(functionName, 1);
+        return dependencies;
+    }
+    /**
+     * Get transitive callers for a function (functions that call it, directly and indirectly)
+     * @param functionName The function to analyze
+     * @param maxDepth Maximum depth to traverse (default 10)
+     * @returns Array of function names with their depth
+     */
+    async getTransitiveCallers(functionName, maxDepth = 10) {
+        this.ensureInitialized();
+        const callers = [];
+        const visited = new Set();
+        const traverse = (funcName, depth) => {
+            if (depth > maxDepth || visited.has(funcName))
+                return;
+            visited.add(funcName);
+            const func = this.findFunctionByQualifiedName(funcName);
+            if (!func?.metadata?.calledBy)
+                return;
+            for (const caller of func.metadata.calledBy) {
+                if (!visited.has(caller)) {
+                    callers.push({ name: caller, depth });
+                    traverse(caller, depth + 1);
+                }
+            }
+        };
+        traverse(functionName, 1);
+        return callers;
+    }
+    /**
+     * Detect circular dependencies in the codebase
+     * @returns Array of circular dependency chains
+     */
+    async detectCircularDependencies() {
+        this.ensureInitialized();
+        const cycles = [];
+        const allFunctions = this.functionsCollection.find();
+        for (const func of allFunctions) {
+            if (!func.metadata?.functionCalls)
+                continue;
+            const funcName = this.getQualifiedFunctionName(func);
+            const visited = new Set();
+            const path = [];
+            const hasCycle = (current) => {
+                if (path.includes(current)) {
+                    // Found a cycle - extract it
+                    const cycleStart = path.indexOf(current);
+                    const cycle = [...path.slice(cycleStart), current];
+                    // Check if we already have this cycle (in any rotation)
+                    const isNewCycle = !cycles.some(existing => existing.length === cycle.length &&
+                        existing.every(f => cycle.includes(f)));
+                    if (isNewCycle) {
+                        cycles.push(cycle);
+                    }
+                    return true;
+                }
+                if (visited.has(current))
+                    return false;
+                visited.add(current);
+                path.push(current);
+                const currentFunc = this.findFunctionByQualifiedName(current);
+                if (currentFunc?.metadata?.functionCalls) {
+                    for (const callee of currentFunc.metadata.functionCalls) {
+                        if (hasCycle(callee))
+                            return true;
+                    }
+                }
+                path.pop();
+                return false;
+            };
+            hasCycle(funcName);
+        }
+        return cycles;
+    }
+    /**
+     * Calculate the maximum dependency depth for each function
+     * Updates the dependencyDepth field in metadata
+     */
+    async calculateDependencyDepths() {
+        this.ensureInitialized();
+        const allFunctions = this.functionsCollection.find();
+        for (const func of allFunctions) {
+            const funcName = this.getQualifiedFunctionName(func);
+            const dependencies = await this.getTransitiveDependencies(funcName);
+            const maxDepth = dependencies.length > 0
+                ? Math.max(...dependencies.map(d => d.depth))
+                : 0;
+            if (!func.metadata) {
+                func.metadata = {};
+            }
+            func.metadata.dependencyDepth = maxDepth;
+            this.functionsCollection.update(func);
+        }
+        this.db.saveDatabase();
+    }
     async searchFunctions(options) {
         this.ensureInitialized();
         const startTime = Date.now();
@@ -310,12 +507,41 @@ export class CodeIndexDB {
         // Parse the query if provided
         const queryParser = new QueryParser();
         let parsedQuery;
+        // Determine search mode
+        const searchMode = options.searchMode || 'metadata';
         if (options.query) {
             parsedQuery = options.parsedQuery || queryParser.parse(options.query);
             // Check if there are search terms or just filters
             if (parsedQuery.terms.length > 0 || parsedQuery.phrases.length > 0) {
-                // Execute multi-strategy search
-                results = await this.executeMultiStrategySearch(parsedQuery, searchScores);
+                if (searchMode === 'content') {
+                    // Content search only
+                    results = await this.executeContentSearch(parsedQuery, searchScores);
+                }
+                else if (searchMode === 'both') {
+                    // Both metadata and content search
+                    const metadataResults = await this.executeMultiStrategySearch(parsedQuery, searchScores);
+                    const contentResults = await this.executeContentSearch(parsedQuery, searchScores);
+                    // Merge results, combining scores for duplicates
+                    const resultMap = new Map();
+                    metadataResults.forEach(doc => {
+                        if (doc.$loki !== undefined) {
+                            resultMap.set(doc.$loki, doc);
+                        }
+                    });
+                    contentResults.forEach(doc => {
+                        if (doc.$loki !== undefined) {
+                            resultMap.set(doc.$loki, doc);
+                            // Combine scores
+                            const existingScore = searchScores.get(doc.$loki) || 0;
+                            searchScores.set(doc.$loki, existingScore);
+                        }
+                    });
+                    results = Array.from(resultMap.values());
+                }
+                else {
+                    // Metadata search only (default)
+                    results = await this.executeMultiStrategySearch(parsedQuery, searchScores);
+                }
             }
             else {
                 // No search terms, just filters - get all
@@ -331,7 +557,32 @@ export class CodeIndexDB {
             parsedQuery = options.parsedQuery;
             // Check if there are search terms or just filters
             if (parsedQuery.terms.length > 0 || parsedQuery.phrases.length > 0) {
-                results = await this.executeMultiStrategySearch(parsedQuery, searchScores);
+                if (searchMode === 'content') {
+                    results = await this.executeContentSearch(parsedQuery, searchScores);
+                }
+                else if (searchMode === 'both') {
+                    const metadataResults = await this.executeMultiStrategySearch(parsedQuery, searchScores);
+                    const contentResults = await this.executeContentSearch(parsedQuery, searchScores);
+                    // Merge results
+                    const resultMap = new Map();
+                    metadataResults.forEach(doc => {
+                        if (doc.$loki !== undefined) {
+                            resultMap.set(doc.$loki, doc);
+                        }
+                    });
+                    contentResults.forEach(doc => {
+                        if (doc.$loki !== undefined) {
+                            resultMap.set(doc.$loki, doc);
+                            // Combine scores
+                            const existingScore = searchScores.get(doc.$loki) || 0;
+                            searchScores.set(doc.$loki, existingScore);
+                        }
+                    });
+                    results = Array.from(resultMap.values());
+                }
+                else {
+                    results = await this.executeMultiStrategySearch(parsedQuery, searchScores);
+                }
             }
             else {
                 // No search terms, just filters - get all
@@ -620,7 +871,25 @@ export class CodeIndexDB {
             filtered = filtered.filter(doc => doc.language === filters.language);
         }
         if (filters.filePath) {
-            filtered = filtered.filter(doc => doc.filePath.includes(filters.filePath));
+            // Support both exact match and includes based on the filter format
+            if (filters.filePath.includes('*') || filters.filePath.includes('?')) {
+                // Glob pattern - convert to regex
+                const pattern = filters.filePath
+                    .replace(/\*/g, '.*')
+                    .replace(/\?/g, '.')
+                    .replace(/\//g, '\\/');
+                const regex = new RegExp(pattern);
+                filtered = filtered.filter(doc => regex.test(doc.filePath));
+            }
+            else if (filters.filePath.endsWith('.ts') || filters.filePath.endsWith('.tsx') ||
+                filters.filePath.endsWith('.js') || filters.filePath.endsWith('.jsx')) {
+                // If it looks like a full filename, match the end of the path
+                filtered = filtered.filter(doc => doc.filePath.endsWith(filters.filePath));
+            }
+            else {
+                // Otherwise, do substring match (for directory paths)
+                filtered = filtered.filter(doc => doc.filePath.includes(filters.filePath));
+            }
         }
         if (filters.fileType) {
             filtered = filtered.filter(doc => doc.filePath.endsWith(filters.fileType));
@@ -677,6 +946,52 @@ export class CodeIndexDB {
                 else if (filters.metadata.hasProp) {
                     return false; // No props but filter requires one
                 }
+                // Check usesDependency
+                if (filters.metadata.usesDependency) {
+                    const dep = filters.metadata.usesDependency.toLowerCase();
+                    // Check in both file-level dependencies and function-specific usedImports
+                    const usesDepInFile = doc.dependencies.some(d => d.toLowerCase().includes(dep));
+                    const usesDepInFunction = doc.metadata.usedImports?.some(imp => imp.toLowerCase().includes(dep)) || false;
+                    if (!usesDepInFile && !usesDepInFunction)
+                        return false;
+                }
+                // Check callsFunction
+                if (filters.metadata.callsFunction && doc.metadata.functionCalls) {
+                    const targetFunc = filters.metadata.callsFunction.toLowerCase();
+                    const callsFunc = doc.metadata.functionCalls.some(call => call.toLowerCase().includes(targetFunc));
+                    if (!callsFunc)
+                        return false;
+                }
+                else if (filters.metadata.callsFunction) {
+                    return false; // No function calls but filter requires one
+                }
+                // Check calledByFunction
+                if (filters.metadata.calledByFunction && doc.metadata.calledBy) {
+                    const callerFunc = filters.metadata.calledByFunction.toLowerCase();
+                    const isCalledBy = doc.metadata.calledBy.some(caller => caller.toLowerCase().includes(callerFunc));
+                    if (!isCalledBy)
+                        return false;
+                }
+                else if (filters.metadata.calledByFunction) {
+                    return false; // Not called by any function but filter requires one
+                }
+                // Check dependsOnModule
+                if (filters.metadata.dependsOnModule) {
+                    const module = filters.metadata.dependsOnModule.toLowerCase();
+                    // Check if any import or function call references this module
+                    const dependsOnFile = doc.filePath.toLowerCase().includes(module);
+                    const dependsOnImport = doc.dependencies.some(dep => dep.toLowerCase().includes(module));
+                    const dependsOnCall = doc.metadata.functionCalls?.some(call => call.toLowerCase().includes(module)) || false;
+                    if (!dependsOnFile && !dependsOnImport && !dependsOnCall)
+                        return false;
+                }
+                // Check hasUnusedImports
+                if (filters.metadata.hasUnusedImports) {
+                    const hasUnused = doc.metadata.unusedImports &&
+                        doc.metadata.unusedImports.length > 0;
+                    if (!hasUnused)
+                        return false;
+                }
                 return true;
             });
         }
@@ -905,5 +1220,117 @@ export class CodeIndexDB {
             errors
         };
     }
+    /**
+     * Execute content search - search within function bodies
+     */
+    async executeContentSearch(parsedQuery, searchScores) {
+        const resultsMap = new Map();
+        // Get all functions (we'll filter them)
+        const allFunctions = this.functionsCollection.find();
+        // Search in function bodies
+        for (const doc of allFunctions) {
+            // Check for body in multiple possible locations
+            const body = doc.body || doc.metadata?.body;
+            if (!body)
+                continue;
+            let score = 0;
+            const bodyLower = body.toLowerCase();
+            const matches = [];
+            // Split body into lines for line-level matching
+            const lines = body.split('\n');
+            // Check for exact phrases
+            for (const phrase of parsedQuery.phrases) {
+                const phraseLower = phrase.toLowerCase();
+                lines.forEach((line, lineIndex) => {
+                    const lineLower = line.toLowerCase();
+                    let columnIndex = lineLower.indexOf(phraseLower);
+                    while (columnIndex !== -1) {
+                        matches.push({
+                            term: phrase,
+                            line: (doc.lineNumber || 0) + lineIndex,
+                            column: columnIndex + 1
+                        });
+                        score += 100; // High score for exact phrase match
+                        columnIndex = lineLower.indexOf(phraseLower, columnIndex + 1);
+                    }
+                });
+            }
+            // Check for individual terms
+            for (const term of parsedQuery.terms) {
+                const termLower = term.toLowerCase();
+                lines.forEach((line, lineIndex) => {
+                    const lineLower = line.toLowerCase();
+                    let columnIndex = lineLower.indexOf(termLower);
+                    while (columnIndex !== -1) {
+                        matches.push({
+                            term: term,
+                            line: (doc.lineNumber || 0) + lineIndex,
+                            column: columnIndex + 1
+                        });
+                        score += 20; // Score for term match
+                        columnIndex = lineLower.indexOf(termLower, columnIndex + 1);
+                    }
+                });
+            }
+            // Check for excluded terms
+            let excluded = false;
+            for (const excludedTerm of parsedQuery.excludedTerms) {
+                if (bodyLower.includes(excludedTerm.toLowerCase())) {
+                    excluded = true;
+                    break;
+                }
+            }
+            // Add to results if score > 0 and not excluded
+            if (score > 0 && !excluded && doc.$loki !== undefined) {
+                // Store match information in metadata
+                const resultDoc = { ...doc };
+                if (!resultDoc.metadata)
+                    resultDoc.metadata = {};
+                resultDoc.metadata.contentMatches = matches;
+                // Add match context (surrounding lines)
+                const contextLines = 2; // Number of lines before and after to include
+                const matchContexts = [];
+                // Group matches by line to avoid duplicate context
+                const matchesByLine = new Map();
+                for (const match of matches) {
+                    const relativeLineNum = match.line - (doc.lineNumber || 0);
+                    if (!matchesByLine.has(relativeLineNum)) {
+                        matchesByLine.set(relativeLineNum, []);
+                    }
+                    matchesByLine.get(relativeLineNum).push(match);
+                }
+                // Build context for each unique line
+                for (const [relativeLineNum, lineMatches] of matchesByLine) {
+                    if (relativeLineNum >= 0 && relativeLineNum < lines.length) {
+                        const before = [];
+                        const after = [];
+                        // Get lines before
+                        for (let i = Math.max(0, relativeLineNum - contextLines); i < relativeLineNum; i++) {
+                            before.push(lines[i]);
+                        }
+                        // Get lines after
+                        for (let i = relativeLineNum + 1; i < Math.min(lines.length, relativeLineNum + contextLines + 1); i++) {
+                            after.push(lines[i]);
+                        }
+                        // Add context for each match on this line
+                        for (const match of lineMatches) {
+                            matchContexts.push({
+                                match,
+                                context: {
+                                    before,
+                                    line: lines[relativeLineNum],
+                                    after
+                                }
+                            });
+                        }
+                    }
+                }
+                resultDoc.metadata.matchContexts = matchContexts;
+                resultsMap.set(doc.$loki, resultDoc);
+                searchScores.set(doc.$loki, score);
+            }
+        }
+        return Array.from(resultsMap.values());
+    }
 }
 //# sourceMappingURL=codeIndexDB.js.map