code-auditor-mcp 2.6.2 → 3.0.1

package/dist/codeIndexDb.js

@@ -1,2102 +0,0 @@
-/**
- * Code Index Database using LokiJS + FlexSearch
- * Pure JavaScript implementation with no native dependencies
- */
-import Loki from 'lokijs';
-import * as FlexSearch from 'flexsearch';
-import { promises as fs } from 'fs';
-import path from 'path';
-import { ProjectTaskRepository } from './services/ProjectTaskRepository.js';
-import { QueryParser } from './search/QueryParser.js';
-import { getPersistedStorageRoot, resolvePersistedIndexPath } from './dataPaths.js';
-import { ContextualError, getErrnoCode } from './mcpToolErrors.js';
-import { WhitelistType, WhitelistStatus } from './types/whitelist.js';
-// Using SearchOptions and SearchResult from types.ts
-export class CodeIndexDB {
-    static instance;
-    /** Subclasses (e.g. EnhancedCodeIndexDB) need access for extra collections without `as any`. */
-    db;
-    functionsCollection = null;
-    whitelistCollection = null;
-    auditResultsCollection = null;
-    analyzerConfigCollection = null;
-    codeMapCollection = null;
-    schemaCollection = null;
-    schemaUsageCollection = null;
-    /** User tasks: NOT cleared by clearIndex() — see clearIndex() */
-    tasksCollection = null;
-    taskRepository = null;
-    searchIndex; // FlexSearch Document instance
-    dbPath;
-    isInitialized = false;
-    initializePromise = null;
-    constructor(dbPath = ':memory:') {
-        this.dbPath = dbPath;
-        this.db = new Loki(dbPath, {
-            autosave: false,
-            autosaveInterval: 0,
-            autoload: false
-        });
-        // Initialize FlexSearch with full-text search configuration
-        const { Document } = FlexSearch;
-        this.searchIndex = new Document({
-            document: {
-                id: '$loki',
-                index: [
-                    {
-                        field: 'name',
-                        tokenize: 'full',
-                        optimize: true,
-                        resolution: 9,
-                        bidirectional: true,
-                        weight: 10 // Highest weight for function name matches
-                    },
-                    {
-                        field: 'tokenizedName',
-                        tokenize: 'full',
-                        optimize: true,
-                        resolution: 9,
-                        bidirectional: true,
-                        weight: 9 // High weight for tokenized name matches
-                    },
-                    {
-                        field: 'signature',
-                        tokenize: 'full',
-                        optimize: true,
-                        resolution: 9,
-                        weight: 8 // High weight for signature matches
-                    },
-                    {
-                        field: 'purpose',
-                        tokenize: 'full',
-                        optimize: true,
-                        resolution: 9,
-                        weight: 7 // Important for semantic search
-                    },
-                    {
-                        field: 'context',
-                        tokenize: 'full',
-                        optimize: true,
-                        resolution: 9,
-                        weight: 6 // Contextual information
-                    },
-                    {
-                        field: 'jsDoc.description',
-                        tokenize: 'full',
-                        optimize: true,
-                        resolution: 9,
-                        weight: 5 // Documentation matches
-                    },
-                    {
-                        field: 'parameters[].name',
-                        tokenize: 'full',
-                        optimize: true,
-                        resolution: 7,
-                        weight: 4 // Parameter name matches
-                    },
-                    {
-                        field: 'parameters[].description',
-                        tokenize: 'full',
-                        optimize: true,
-                        resolution: 7,
-                        weight: 3 // Parameter description matches
-                    },
-                    {
-                        field: 'returnType',
-                        tokenize: 'full',
-                        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)
-                    }
-                ]
-            },
-            tokenize: 'full', // Global full-text tokenization
-            optimize: true,
-            resolution: 9,
-            cache: 100,
-            context: {
-                depth: 3, // Enable contextual scoring
-                bidirectional: true, // Search in both directions
-                resolution: 9
-            },
-            threshold: 7, // Lower threshold for fuzzy matching
-            depth: 3 // Search depth for better fuzzy matching
-        });
-    }
-    static getInstance(dbPath) {
-        if (!CodeIndexDB.instance) {
-            const resolved = dbPath !== undefined && dbPath !== ''
-                ? path.resolve(dbPath)
-                : resolvePersistedIndexPath();
-            CodeIndexDB.instance = new CodeIndexDB(resolved);
-        }
-        return CodeIndexDB.instance;
-    }
-    async initialize() {
-        if (this.isInitialized)
-            return;
-        if (this.initializePromise) {
-            await this.initializePromise;
-            return;
-        }
-        this.initializePromise = this.initializeInternal();
-        try {
-            await this.initializePromise;
-        }
-        finally {
-            this.initializePromise = null;
-        }
-    }
-    async initializeInternal() {
-        if (this.isInitialized)
-            return;
-        const dir = path.dirname(this.dbPath);
-        const storageRoot = getPersistedStorageRoot();
-        try {
-            let st;
-            try {
-                st = await fs.stat(dir);
-            }
-            catch (e) {
-                const code = getErrnoCode(e);
-                if (code && code !== 'ENOENT') {
-                    throw new ContextualError(`Cannot access code index storage directory (${code}): ${dir}`, {
-                        errnoCode: code,
-                        storageRoot,
-                        dbPath: this.dbPath,
-                        hint: 'Fix permissions or set CODE_AUDITOR_DATA_DIR / --data-dir to a writable directory.',
-                    }, e instanceof Error ? e : undefined);
-                }
-            }
-            if (st && !st.isDirectory()) {
-                throw new ContextualError(`Code index storage path exists but is not a directory: ${dir}`, {
-                    storageRoot,
-                    dbPath: this.dbPath,
-                    hint: 'Remove the conflicting file/path or choose a different CODE_AUDITOR_DATA_DIR / --data-dir.',
-                });
-            }
-            await fs.mkdir(dir, { recursive: true });
-        }
-        catch (e) {
-            if (e instanceof ContextualError)
-                throw e;
-            const code = getErrnoCode(e);
-            throw new ContextualError(`Failed to prepare code index storage: ${e instanceof Error ? e.message : String(e)}`, {
-                ...(code && { errnoCode: code }),
-                storageRoot,
-                dbPath: this.dbPath,
-                hint: 'Ensure the storage directory is writable (default: <cwd>/.code-index when CODE_AUDITOR_DATA_DIR is unset).',
-            }, e instanceof Error ? e : undefined);
-        }
-        try {
-            await new Promise((resolve, reject) => {
-                this.db.loadDatabase({}, (err) => {
-                    if (err)
-                        reject(err);
-                    else
-                        resolve();
-                });
-            });
-        }
-        catch (e) {
-            const code = getErrnoCode(e);
-            throw new ContextualError(`Failed to load code index database: ${e instanceof Error ? e.message : String(e)}`, {
-                ...(code && { errnoCode: code }),
-                storageRoot,
-                dbPath: this.dbPath,
-                hint: 'The index file may be corrupted, locked by another process, or on a read-only volume. Try a different CODE_AUDITOR_DATA_DIR or delete index.db if safe.',
-            }, e instanceof Error ? e : undefined);
-        }
-        // Get or create functions collection
-        this.functionsCollection = this.db.getCollection('functions') ||
-            this.db.addCollection('functions', {
-                indices: ['name', 'filePath', 'language']
-            });
-        // Get or create whitelist collection
-        this.whitelistCollection = this.db.getCollection('whitelist') ||
-            this.db.addCollection('whitelist', {
-                indices: ['name', 'type', 'status']
-            });
-        // Get or create audit results collection
-        this.auditResultsCollection = this.db.getCollection('auditResults') ||
-            this.db.addCollection('auditResults', {
-                indices: ['auditId', 'timestamp', 'projectPath']
-            });
-        // Get or create analyzer config collection
-        this.analyzerConfigCollection = this.db.getCollection('analyzerConfigs') ||
-            this.db.addCollection('analyzerConfigs', {
-                indices: ['analyzerName', 'projectPath', 'isGlobal']
-            });
-        // Get or create code map collection
-        this.codeMapCollection = this.db.getCollection('codeMaps') ||
-            this.db.addCollection('codeMaps', {
-                indices: ['mapId', 'sectionType', 'timestamp']
-            });
-        // Get or create schema collection
-        this.schemaCollection = this.db.getCollection('schemas') ||
-            this.db.addCollection('schemas', {
-                indices: ['schemaId', 'schemaName', 'indexedAt']
-            });
-        // Get or create schema usage collection
-        this.schemaUsageCollection = this.db.getCollection('schemaUsage') ||
-            this.db.addCollection('schemaUsage', {
-                indices: ['tableName', 'filePath', 'functionName', 'usageType']
-            });
-        this.tasksCollection = this.db.getCollection('projectTasks') ||
-            this.db.addCollection('projectTasks', {
-                indices: ['taskId', 'projectPath', 'status', 'source', 'sortOrder']
-            });
-        // Initialize default whitelists if empty
-        if (this.whitelistCollection.count() === 0) {
-            await this.initializeDefaultWhitelists();
-        }
-        // Rebuild search index from existing data
-        const existingDocs = this.functionsCollection.find();
-        for (const doc of existingDocs) {
-            const normalizedData = this.normalizeFunctionData(doc);
-            this.searchIndex.add(normalizedData);
-        }
-        this.isInitialized = true;
-    }
-    ensureInitialized() {
-        if (!this.isInitialized || !this.functionsCollection || !this.tasksCollection) {
-            throw new Error('Database not initialized. Call initialize() first.');
-        }
-    }
-    /**
-     * Normalize function metadata for indexing
-     * Converts FunctionMetadata to have required fields for FlexSearch
-     */
-    normalizeFunctionData(func) {
-        // If it's already enhanced, return as-is with $loki if present
-        if ('signature' in func && 'parameters' in func) {
-            const normalized = { ...func };
-            // Ensure nested jsDoc structure exists
-            if (!normalized.jsDoc) {
-                normalized.jsDoc = { description: func.purpose || '' };
-            }
-            // Add tokenized name to improve searchability
-            normalized.tokenizedName = this.tokenizeFunctionName(func.name);
-            return normalized;
-        }
-        // Convert basic FunctionMetadata to have searchable fields
-        const enhanced = {
-            ...func,
-            signature: func.name, // Use name as signature for now
-            parameters: [], // Empty parameters array
-            jsDoc: {
-                description: func.purpose || ''
-            },
-            returnType: 'unknown',
-            // Add tokenized name for better searching
-            tokenizedName: this.tokenizeFunctionName(func.name),
-            // Extract body from metadata if present
-            body: func.metadata?.body
-        };
-        return enhanced;
-    }
-    /**
-     * Tokenize function name for better search
-     * Splits camelCase, PascalCase, and snake_case into individual words
-     */
-    tokenizeFunctionName(name) {
-        // Remove class prefix if present (e.g., "UserService.authenticate" -> "authenticate")
-        const functionName = name.includes('.') ? name.split('.').pop() : name;
-        // Split camelCase and PascalCase
-        const camelSplit = functionName
-            .replace(/([a-z])([A-Z])/g, '$1 $2')
-            .replace(/([A-Z])([A-Z][a-z])/g, '$1 $2');
-        // Split snake_case and kebab-case
-        const allSplit = camelSplit
-            .replace(/[_-]/g, ' ')
-            .toLowerCase()
-            .trim();
-        return allSplit;
-    }
-    async registerFunction(func) {
-        this.ensureInitialized();
-        try {
-            // Check if function already exists (use composite key: name + filePath + lineNumber)
-            const existing = this.functionsCollection.findOne({
-                name: func.name,
-                filePath: func.filePath,
-                lineNumber: func.lineNumber
-            });
-            if (existing) {
-                // Update existing
-                Object.assign(existing, func);
-                this.functionsCollection.update(existing);
-                const normalizedData = this.normalizeFunctionData(existing);
-                this.searchIndex.update(normalizedData);
-            }
-            else {
-                // Insert new
-                const doc = this.functionsCollection.insert(func);
-                const normalizedData = this.normalizeFunctionData(doc);
-                this.searchIndex.add(normalizedData);
-            }
-            // Force save
-            this.db.saveDatabase();
-        }
-        catch (error) {
-            throw new Error(`Failed to register function: ${error instanceof Error ? error.message : 'Unknown error'}`);
-        }
-    }
-    async registerFunctions(functions) {
-        this.ensureInitialized();
-        let registered = 0;
-        let failed = 0;
-        const errors = [];
-        for (const func of functions) {
-            try {
-                await this.registerFunction(func);
-                registered++;
-            }
-            catch (error) {
-                failed++;
-                errors.push({
-                    function: func.name || 'unknown',
-                    error: error instanceof Error ? error.message : 'Unknown error'
-                });
-            }
-        }
-        return {
-            success: failed === 0,
-            registered,
-            failed,
-            errors: errors.length > 0 ? errors : undefined
-        };
-    }
-    /**
-     * Synchronize file index - add new functions, update existing, remove deleted
-     * @param filePath The file path to synchronize
-     * @param currentFunctions The current functions found in the file
-     * @returns Sync statistics
-     */
-    async syncFileIndex(filePath, currentFunctions) {
-        this.ensureInitialized();
-        const stats = {
-            added: 0,
-            updated: 0,
-            removed: 0
-        };
-        try {
-            // Get all currently indexed functions for this file
-            const indexedFunctions = this.functionsCollection.find({ filePath });
-            // Create a map of current functions by composite key for quick lookup
-            const createKey = (f) => `${f.name}:${f.filePath}:${f.lineNumber}`;
-            const currentFunctionMap = new Map(currentFunctions.map(f => [createKey(f), f]));
-            // Update or add functions
-            for (const func of currentFunctions) {
-                const existing = indexedFunctions.find(f => f.name === func.name &&
-                    f.filePath === func.filePath &&
-                    f.lineNumber === func.lineNumber);
-                if (existing) {
-                    // Update existing function
-                    Object.assign(existing, func);
-                    this.functionsCollection.update(existing);
-                    const normalizedData = this.normalizeFunctionData(existing);
-                    this.searchIndex.update(normalizedData);
-                    stats.updated++;
-                }
-                else {
-                    // Add new function
-                    const doc = this.functionsCollection.insert(func);
-                    const normalizedData = this.normalizeFunctionData(doc);
-                    this.searchIndex.add(normalizedData);
-                    stats.added++;
-                }
-            }
-            // Remove functions that no longer exist in the file
-            for (const indexed of indexedFunctions) {
-                const indexedKey = createKey(indexed);
-                if (!currentFunctionMap.has(indexedKey)) {
-                    // Function no longer exists, remove it
-                    this.functionsCollection.remove(indexed);
-                    this.searchIndex.remove(indexed.$loki);
-                    stats.removed++;
-                }
-            }
-            // Update dependency graph for the affected functions
-            await this.updateDependencyGraph(filePath);
-            // Force save
-            this.db.saveDatabase();
-        }
-        catch (error) {
-            throw new Error(`Failed to sync file index: ${error instanceof Error ? error.message : 'Unknown error'}`);
-        }
-        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();
-    }
-    /**
-     * Get all functions from the index
-     */
-    async getAllFunctions() {
-        this.ensureInitialized();
-        const allFunctions = this.functionsCollection.find();
-        // Return the full enhanced metadata
-        return allFunctions.map(func => ({
-            // Base metadata
-            name: func.name,
-            filePath: func.filePath,
-            lineNumber: func.lineNumber,
-            startLine: func.startLine,
-            endLine: func.endLine,
-            language: func.language,
-            dependencies: func.dependencies,
-            purpose: func.purpose,
-            context: func.context,
-            metadata: func.metadata,
-            // Enhanced metadata
-            signature: func.signature || '',
-            parameters: func.parameters || [],
-            jsDoc: typeof func.jsDoc === 'string' ? { description: func.jsDoc } : (func.jsDoc || {}),
-            imports: func.imports || [],
-            body: func.body || '',
-            comments: func.comments || [],
-            isAsync: func.isAsync || false,
-            isGenerator: func.isGenerator || false,
-            returnType: func.returnType,
-            visibility: func.visibility || 'public',
-            // Additional fields from metadata if available
-            ...(func.metadata || {})
-        }));
-    }
-    async searchFunctions(options) {
-        this.ensureInitialized();
-        const startTime = Date.now();
-        let results = [];
-        let searchScores = new Map(); // Map of $loki id to relevance score
-        // 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) {
-                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
-                results = this.functionsCollection.find();
-                results.forEach((doc, index) => {
-                    if (doc.$loki !== undefined) {
-                        searchScores.set(doc.$loki, 50); // Base score for browse mode
-                    }
-                });
-            }
-        }
-        else if (options.parsedQuery) {
-            parsedQuery = options.parsedQuery;
-            // Check if there are search terms or just filters
-            if (parsedQuery.terms.length > 0 || parsedQuery.phrases.length > 0) {
-                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
-                results = this.functionsCollection.find();
-                results.forEach((doc, index) => {
-                    if (doc.$loki !== undefined) {
-                        searchScores.set(doc.$loki, 50); // Base score for browse mode
-                    }
-                });
-            }
-        }
-        else {
-            // No query, get all
-            results = this.functionsCollection.find();
-            // Give all results a base score
-            results.forEach((doc, index) => {
-                if (doc.$loki !== undefined) {
-                    searchScores.set(doc.$loki, 50); // Base score for browse mode
-                }
-            });
-        }
-        // Apply filters from both options and parsedQuery
-        const combinedFilters = this.mergeFilters(options.filters, parsedQuery?.filters);
-        results = this.applyFilters(results, combinedFilters);
-        // Sort by relevance score
-        results.sort((a, b) => {
-            const scoreA = searchScores.get(a.$loki) || 0;
-            const scoreB = searchScores.get(b.$loki) || 0;
-            return scoreB - scoreA; // Higher scores first
-        });
-        // Apply pagination
-        const totalCount = results.length;
-        const limit = options.limit || 50;
-        const offset = options.offset || 0;
-        results = results.slice(offset, offset + limit);
-        // Clean up results and add scores
-        const functions = results.map((doc) => {
-            const { $loki, meta, ...functionData } = doc;
-            const score = searchScores.get($loki) || 0;
-            return {
-                ...functionData,
-                score
-            };
-        });
-        return {
-            functions,
-            totalCount,
-            query: options.query,
-            parsedQuery,
-            executionTime: Date.now() - startTime
-        };
-    }
-    /**
-     * Execute multi-strategy search with different approaches
-     * @param parsedQuery The parsed query object
-     * @param searchScores Map to store relevance scores
-     * @returns Array of matching documents
-     */
-    async executeMultiStrategySearch(parsedQuery, searchScores) {
-        const resultsMap = new Map(); // Map of $loki id to document
-        // Strategy 1: Exact phrase matching (highest weight)
-        if (parsedQuery.phrases.length > 0) {
-            for (const phrase of parsedQuery.phrases) {
-                const phraseResults = await this.searchWithFlexSearch(phrase, 1000);
-                this.mergeSearchResults(phraseResults, resultsMap, searchScores, 100); // High weight for exact phrases
-            }
-        }
-        // Strategy 2: All terms must match (AND logic) - use original terms
-        const originalTerms = parsedQuery.originalTerms || parsedQuery.terms;
-        if (originalTerms.length > 0) {
-            // For each original term, search including its synonyms
-            const termResultSets = new Map();
-            for (const originalTerm of originalTerms) {
-                // Get synonyms for this term
-                const queryParser = new QueryParser();
-                const synonyms = queryParser.getSynonyms(originalTerm);
-                const searchTerms = [originalTerm, ...synonyms];
-                // Find documents containing ANY of the synonyms
-                const termIds = new Set();
-                for (const searchTerm of searchTerms) {
-                    const termResults = await this.searchWithFlexSearch(searchTerm, 1000);
-                    termResults.forEach(doc => {
-                        if (doc.$loki !== undefined)
-                            termIds.add(doc.$loki);
-                    });
-                }
-                termResultSets.set(originalTerm, termIds);
-            }
-            // Find documents that contain ALL original terms (or their synonyms)
-            if (termResultSets.size > 0) {
-                const allTermIds = this.intersectSets(Array.from(termResultSets.values()));
-                if (allTermIds.size > 0) {
-                    const allTermDocs = this.functionsCollection.find({
-                        $loki: { $in: Array.from(allTermIds) }
-                    });
-                    // Calculate score based on how many fields matched
-                    allTermDocs.forEach(doc => {
-                        const baseScore = 80; // Base score for AND matches
-                        const fieldMatchBonus = this.calculateFieldMatchScore(doc, originalTerms);
-                        this.mergeSearchResults([doc], resultsMap, searchScores, baseScore + fieldMatchBonus);
-                    });
-                }
-            }
-        }
-        // Strategy 3: Any term can match (OR logic) - lower weight
-        if (parsedQuery.terms.length > 0) {
-            const orQuery = parsedQuery.terms.join(' ');
-            const orResults = await this.searchWithFlexSearch(orQuery, 1000);
-            // Score based on how many terms matched
-            orResults.forEach(doc => {
-                const matchCount = this.countMatchingTerms(doc, parsedQuery.terms);
-                const score = 40 + (matchCount * 10); // Base score + bonus per matched term
-                this.mergeSearchResults([doc], resultsMap, searchScores, score);
-            });
-        }
-        // Strategy 4: Fuzzy search if enabled
-        if (parsedQuery.fuzzy && parsedQuery.terms.length > 0) {
-            // FlexSearch already provides fuzzy matching with threshold setting
-            const fuzzyQuery = parsedQuery.terms.join(' ');
-            const fuzzyResults = await this.searchWithFlexSearch(fuzzyQuery, 1000, true);
-            this.mergeSearchResults(fuzzyResults, resultsMap, searchScores, 30); // Lower weight for fuzzy
-        }
-        // Apply excluded terms filter
-        let finalResults = Array.from(resultsMap.values());
-        if (parsedQuery.excludedTerms.length > 0) {
-            finalResults = this.excludeTermsFromResults(finalResults, parsedQuery.excludedTerms);
-        }
-        return finalResults;
-    }
-    /**
-     * Search using FlexSearch and return document results
-     */
-    async searchWithFlexSearch(query, limit, fuzzy = false) {
-        const searchOptions = { limit };
-        const searchResults = await this.searchIndex.search(query, searchOptions);
-        // Extract loki IDs from FlexSearch results
-        const lokiIds = [];
-        for (const fieldResult of searchResults) {
-            if (fieldResult.result && Array.isArray(fieldResult.result)) {
-                lokiIds.push(...fieldResult.result);
-            }
-        }
-        // Remove duplicates and fetch documents
-        const uniqueLokiIds = [...new Set(lokiIds)];
-        if (uniqueLokiIds.length === 0) {
-            return [];
-        }
-        return this.functionsCollection.find({
-            $loki: { $in: uniqueLokiIds }
-        });
-    }
-    /**
-     * Merge search results with scoring
-     */
-    mergeSearchResults(newResults, resultsMap, searchScores, weight) {
-        newResults.forEach(doc => {
-            if (doc.$loki === undefined)
-                return;
-            // Add or update document in results map
-            resultsMap.set(doc.$loki, doc);
-            // Update score (accumulate if already exists)
-            const currentScore = searchScores.get(doc.$loki) || 0;
-            searchScores.set(doc.$loki, currentScore + weight);
-        });
-    }
-    /**
-     * Calculate bonus score based on which fields matched
-     */
-    calculateFieldMatchScore(doc, terms) {
-        let score = 0;
-        const lowerTerms = terms.map(t => t.toLowerCase());
-        // Check each field with different weights
-        if (doc.name && lowerTerms.some(t => doc.name.toLowerCase().includes(t))) {
-            score += 15; // High bonus for name match
-        }
-        if (doc.signature && lowerTerms.some(t => doc.signature.toLowerCase().includes(t))) {
-            score += 10;
-        }
-        if (doc.purpose && lowerTerms.some(t => doc.purpose.toLowerCase().includes(t))) {
-            score += 8;
-        }
-        if (doc.jsDoc?.description && lowerTerms.some(t => doc.jsDoc.description.toLowerCase().includes(t))) {
-            score += 5;
-        }
-        return score;
-    }
-    /**
-     * Count how many terms match in a document
-     */
-    countMatchingTerms(doc, terms) {
-        let count = 0;
-        const documentText = this.getDocumentSearchText(doc).toLowerCase();
-        terms.forEach(term => {
-            if (documentText.includes(term.toLowerCase())) {
-                count++;
-            }
-        });
-        return count;
-    }
-    /**
-     * Get searchable text from document
-     */
-    getDocumentSearchText(doc) {
-        const parts = [
-            doc.name,
-            doc.signature,
-            doc.purpose,
-            doc.context,
-            doc.jsDoc?.description,
-            doc.returnType,
-            ...(doc.parameters || []).map(p => `${p.name} ${p.description || ''}`),
-            ...doc.dependencies
-        ];
-        return parts.filter(Boolean).join(' ');
-    }
-    /**
-     * Get synonyms for a term using QueryParser
-     */
-    getSynonyms(term) {
-        const queryParser = new QueryParser();
-        return queryParser.getSynonyms(term);
-    }
-    /**
-     * Exclude documents containing any of the excluded terms
-     */
-    excludeTermsFromResults(results, excludedTerms) {
-        return results.filter(doc => {
-            const searchText = this.getDocumentSearchText(doc).toLowerCase();
-            return !excludedTerms.some(term => searchText.includes(term.toLowerCase()));
-        });
-    }
-    /**
-     * Intersect multiple sets to find common elements
-     */
-    intersectSets(sets) {
-        if (sets.length === 0)
-            return new Set();
-        if (sets.length === 1)
-            return sets[0];
-        const result = new Set(sets[0]);
-        for (let i = 1; i < sets.length; i++) {
-            for (const item of result) {
-                if (!sets[i].has(item)) {
-                    result.delete(item);
-                }
-            }
-        }
-        return result;
-    }
-    /**
-     * Merge filters from options and parsed query
-     */
-    mergeFilters(optionsFilters, queryFilters) {
-        const merged = {};
-        // Copy options filters
-        if (optionsFilters) {
-            Object.assign(merged, optionsFilters);
-        }
-        // Merge query filters (query filters take precedence)
-        if (queryFilters) {
-            if (queryFilters.language)
-                merged.language = queryFilters.language;
-            if (queryFilters.filePath)
-                merged.filePath = queryFilters.filePath;
-            if (queryFilters.fileType)
-                merged.fileType = queryFilters.fileType;
-            if (queryFilters.hasJsDoc !== undefined)
-                merged.hasJsDoc = queryFilters.hasJsDoc;
-            if (queryFilters.complexity)
-                merged.complexity = queryFilters.complexity;
-            if (queryFilters.dateRange)
-                merged.dateRange = queryFilters.dateRange;
-            if (queryFilters.metadata)
-                merged.metadata = queryFilters.metadata;
-        }
-        return merged;
-    }
-    /**
-     * Apply filters to search results
-     */
-    applyFilters(results, filters) {
-        if (!filters)
-            return results;
-        let filtered = results;
-        if (filters.language) {
-            filtered = filtered.filter(doc => doc.language === filters.language);
-        }
-        if (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));
-        }
-        if (filters.hasJsDoc !== undefined) {
-            filtered = filtered.filter(doc => {
-                const hasJsDoc = doc.jsDoc && doc.jsDoc.description && doc.jsDoc.description.length > 0;
-                return filters.hasJsDoc ? hasJsDoc : !hasJsDoc;
-            });
-        }
-        if (filters.complexity) {
-            filtered = filtered.filter(doc => {
-                if (!doc.complexity)
-                    return false;
-                const complexity = doc.complexity;
-                const min = filters.complexity.min || 0;
-                const max = filters.complexity.max || Infinity;
-                return complexity >= min && complexity <= max;
-            });
-        }
-        if (filters.hasAnyDependency && filters.hasAnyDependency.length > 0) {
-            filtered = filtered.filter(doc => filters.hasAnyDependency.some(dep => doc.dependencies.includes(dep)));
-        }
-        // Apply metadata filters
-        if (filters.metadata) {
-            filtered = filtered.filter(doc => {
-                if (!doc.metadata)
-                    return false;
-                // Check entityType
-                if (filters.metadata.entityType &&
-                    doc.metadata.entityType !== filters.metadata.entityType) {
-                    return false;
-                }
-                // Check componentType
-                if (filters.metadata.componentType &&
-                    doc.metadata.componentType !== filters.metadata.componentType) {
-                    return false;
-                }
-                // Check hasHook
-                if (filters.metadata.hasHook && doc.metadata.hooks) {
-                    const hasHook = doc.metadata.hooks.some(hook => hook.name.toLowerCase().includes(filters.metadata.hasHook.toLowerCase()));
-                    if (!hasHook)
-                        return false;
-                }
-                else if (filters.metadata.hasHook) {
-                    return false; // No hooks but filter requires one
-                }
-                // Check hasProp
-                if (filters.metadata.hasProp && doc.metadata.props) {
-                    const hasProp = doc.metadata.props.some(prop => prop.name.toLowerCase().includes(filters.metadata.hasProp.toLowerCase()));
-                    if (!hasProp)
-                        return false;
-                }
-                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;
-            });
-        }
-        return filtered;
-    }
-    async findDefinition(name, filePath) {
-        this.ensureInitialized();
-        const query = { name };
-        if (filePath) {
-            query.filePath = filePath;
-        }
-        const result = this.functionsCollection.findOne(query);
-        if (!result)
-            return null;
-        const { $loki, meta, ...functionData } = result;
-        return functionData;
-    }
-    async getStats() {
-        this.ensureInitialized();
-        const allFunctions = this.functionsCollection.find();
-        // Calculate stats
-        const languages = {};
-        const dependencies = {};
-        const files = new Set();
-        for (const func of allFunctions) {
-            // Language stats
-            if (func.language) {
-                languages[func.language] = (languages[func.language] || 0) + 1;
-            }
-            // Dependency stats
-            for (const dep of func.dependencies) {
-                dependencies[dep] = (dependencies[dep] || 0) + 1;
-            }
-            // File stats
-            files.add(func.filePath);
-        }
-        // Top dependencies
-        const topDependencies = Object.entries(dependencies)
-            .sort((a, b) => b[1] - a[1])
-            .slice(0, 10)
-            .map(([name, count]) => ({ name, count }));
-        return {
-            totalFunctions: allFunctions.length,
-            languages,
-            topDependencies,
-            filesIndexed: files.size,
-            lastUpdated: new Date()
-        };
-    }
-    /**
-     * Drops analysis-derived data so search, cached audits, code maps, and schema overlays
-     * cannot reference removed or stale code ("ghost" analysis).
-     *
-     * Clears: indexed functions, FlexSearch, auditResults, codeMaps, schemas, schemaUsage.
-     * Preserves: projectTasks, analyzerConfigs, whitelist (user rules, not mirrored code).
-     *
-     * When adding collections that store derived code intelligence, clear them here unless
-     * they are durable user preferences (same category as analyzerConfigs).
-     */
-    async clearIndex() {
-        this.ensureInitialized();
-        this.functionsCollection.clear();
-        this.searchIndex.clear();
-        this.auditResultsCollection.clear();
-        this.codeMapCollection.clear();
-        this.schemaCollection.clear();
-        this.schemaUsageCollection.clear();
-        this.db.saveDatabase();
-    }
-    async close() {
-        if (this.isInitialized) {
-            this.taskRepository = null;
-            this.db.close();
-            this.isInitialized = false;
-        }
-    }
-    getTaskRepository() {
-        this.ensureInitialized();
-        if (!this.taskRepository) {
-            this.taskRepository = new ProjectTaskRepository(() => this.tasksCollection, () => this.db.saveDatabase());
-        }
-        return this.taskRepository;
-    }
-    /**
-     * Synchronize a single file's functions with the index
-     * Adds new functions, updates existing ones, and removes deleted ones
-     */
-    async synchronizeFile(filePath) {
-        this.ensureInitialized();
-        // fs is already imported at the top of the file
-        try {
-            // Check if file exists
-            await fs.access(filePath);
-        }
-        catch {
-            // File doesn't exist, remove all its functions
-            const existingFuncs = this.functionsCollection.find({ filePath });
-            for (const func of existingFuncs) {
-                this.functionsCollection.remove(func);
-                if (func.$loki !== undefined) {
-                    await this.searchIndex.remove(func.$loki);
-                }
-            }
-            this.db.saveDatabase();
-            return { added: 0, updated: 0, removed: existingFuncs.length };
-        }
-        // Parse the file for functions
-        const { FunctionScanner } = await import('./functionScanner.js');
-        const scanner = new FunctionScanner();
-        const fileContent = await fs.readFile(filePath, 'utf-8');
-        const language = filePath.endsWith('.ts') || filePath.endsWith('.tsx') ? 'typescript' : 'javascript';
-        const parsedFunctions = await scanner.scanFunctions(fileContent, filePath, language);
-        // Get existing functions
-        const existingFuncs = this.functionsCollection.find({ filePath });
-        const existingMap = new Map(existingFuncs.map(f => [f.name, f]));
-        const parsedMap = new Map(parsedFunctions.map(f => [f.name, f]));
-        let added = 0, updated = 0, removed = 0;
-        // Remove functions that no longer exist
-        for (const existing of existingFuncs) {
-            if (!parsedMap.has(existing.name)) {
-                this.functionsCollection.remove(existing);
-                if (existing.$loki !== undefined) {
-                    await this.searchIndex.remove(existing.$loki);
-                }
-                removed++;
-            }
-        }
-        // Add or update functions
-        for (const parsed of parsedFunctions) {
-            const existing = existingMap.get(parsed.name);
-            if (existing) {
-                // Update existing
-                Object.assign(existing, parsed);
-                this.functionsCollection.update(existing);
-                const normalizedData = this.normalizeFunctionData(existing);
-                await this.searchIndex.update(normalizedData);
-                updated++;
-            }
-            else {
-                // Add new
-                await this.registerFunction(parsed);
-                added++;
-            }
-        }
-        if (added > 0 || updated > 0 || removed > 0) {
-            this.db.saveDatabase();
-        }
-        return { added, updated, removed };
-    }
-    /**
-     * Performs bulk cleanup of the index by verifying all indexed files still exist
-     * and removing entries for deleted files
-     */
-    async bulkCleanup() {
-        this.ensureInitialized();
-        // fs is already imported at the top of the file
-        const allFunctions = this.functionsCollection.find();
-        const fileMap = new Map();
-        // Group functions by file
-        for (const func of allFunctions) {
-            if (!fileMap.has(func.filePath)) {
-                fileMap.set(func.filePath, []);
-            }
-            fileMap.get(func.filePath).push(func);
-        }
-        const removedFiles = [];
-        const errors = [];
-        let removedCount = 0;
-        // Check each file
-        for (const [filePath, functions] of fileMap) {
-            try {
-                await fs.access(filePath);
-                // File exists, no action needed
-            }
-            catch (error) {
-                // File doesn't exist, remove all its functions
-                for (const func of functions) {
-                    this.functionsCollection.remove(func);
-                    // Remove from search index
-                    if (func.$loki !== undefined) {
-                        await this.searchIndex.remove(func.$loki);
-                    }
-                    removedCount++;
-                }
-                removedFiles.push(filePath);
-            }
-        }
-        // Save changes
-        if (removedCount > 0) {
-            this.db.saveDatabase();
-        }
-        return {
-            scannedCount: fileMap.size,
-            removedCount,
-            removedFiles,
-            errors
-        };
-    }
-    /**
-     * Performs deep synchronization by re-scanning all indexed files
-     * Updates function signatures and removes stale entries
-     */
-    async deepSync(progressCallback) {
-        this.ensureInitialized();
-        const allFunctions = this.functionsCollection.find();
-        const fileMap = new Map();
-        // Group functions by file
-        for (const func of allFunctions) {
-            if (!fileMap.has(func.filePath)) {
-                fileMap.set(func.filePath, []);
-            }
-            fileMap.get(func.filePath).push(func);
-        }
-        let syncedFiles = 0;
-        let totalAdded = 0;
-        let totalUpdated = 0;
-        let totalRemoved = 0;
-        const errors = [];
-        let current = 0;
-        const total = fileMap.size;
-        // Sync each file
-        for (const [filePath, _] of fileMap) {
-            current++;
-            if (progressCallback) {
-                progressCallback({ current, total, file: filePath });
-            }
-            try {
-                const result = await this.synchronizeFile(filePath);
-                if (result) {
-                    syncedFiles++;
-                    totalAdded += result.added;
-                    totalUpdated += result.updated;
-                    totalRemoved += result.removed;
-                }
-            }
-            catch (error) {
-                errors.push({
-                    file: filePath,
-                    error: error instanceof Error ? error.message : String(error)
-                });
-            }
-        }
-        return {
-            syncedFiles,
-            addedFunctions: totalAdded,
-            updatedFunctions: totalUpdated,
-            removedFunctions: totalRemoved,
-            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());
-    }
-    /**
-     * Initialize default whitelist entries
-     */
-    async initializeDefaultWhitelists() {
-        const defaultEntries = [
-            // JavaScript built-ins
-            { name: 'Date', type: WhitelistType.PlatformAPI, status: WhitelistStatus.Active, category: 'javascript', addedBy: 'system', addedAt: new Date() },
-            { name: 'Error', type: WhitelistType.PlatformAPI, status: WhitelistStatus.Active, category: 'javascript', addedBy: 'system', addedAt: new Date() },
-            { name: 'Array', type: WhitelistType.PlatformAPI, status: WhitelistStatus.Active, category: 'javascript', addedBy: 'system', addedAt: new Date() },
-            { name: 'Map', type: WhitelistType.PlatformAPI, status: WhitelistStatus.Active, category: 'javascript', addedBy: 'system', addedAt: new Date() },
-            { name: 'Set', type: WhitelistType.PlatformAPI, status: WhitelistStatus.Active, category: 'javascript', addedBy: 'system', addedAt: new Date() },
-            { name: 'Promise', type: WhitelistType.PlatformAPI, status: WhitelistStatus.Active, category: 'javascript', addedBy: 'system', addedAt: new Date() },
-            { name: 'RegExp', type: WhitelistType.PlatformAPI, status: WhitelistStatus.Active, category: 'javascript', addedBy: 'system', addedAt: new Date() },
-            // DOM/Browser APIs
-            { name: 'URL', type: WhitelistType.PlatformAPI, status: WhitelistStatus.Active, category: 'dom', addedBy: 'system', addedAt: new Date() },
-            { name: 'URLSearchParams', type: WhitelistType.PlatformAPI, status: WhitelistStatus.Active, category: 'dom', addedBy: 'system', addedAt: new Date() },
-            { name: 'FormData', type: WhitelistType.PlatformAPI, status: WhitelistStatus.Active, category: 'dom', addedBy: 'system', addedAt: new Date() },
-            { name: 'Headers', type: WhitelistType.PlatformAPI, status: WhitelistStatus.Active, category: 'dom', addedBy: 'system', addedAt: new Date() },
-            // Node.js built-ins
-            { name: 'fs', type: WhitelistType.NodeBuiltin, status: WhitelistStatus.Active, patterns: ['fs', 'node:fs', 'fs/promises'], addedBy: 'system', addedAt: new Date() },
-            { name: 'path', type: WhitelistType.NodeBuiltin, status: WhitelistStatus.Active, patterns: ['path', 'node:path'], addedBy: 'system', addedAt: new Date() },
-            { name: 'crypto', type: WhitelistType.NodeBuiltin, status: WhitelistStatus.Active, patterns: ['crypto', 'node:crypto'], addedBy: 'system', addedAt: new Date() },
-            // Next.js framework classes
-            { name: 'NextResponse', type: WhitelistType.FrameworkClass, status: WhitelistStatus.Active, category: 'nextjs', addedBy: 'system', addedAt: new Date() },
-            { name: 'NextRequest', type: WhitelistType.FrameworkClass, status: WhitelistStatus.Active, category: 'nextjs', addedBy: 'system', addedAt: new Date() },
-            { name: 'Response', type: WhitelistType.FrameworkClass, status: WhitelistStatus.Active, category: 'web-api', addedBy: 'system', addedAt: new Date() },
-            { name: 'Request', type: WhitelistType.FrameworkClass, status: WhitelistStatus.Active, category: 'web-api', addedBy: 'system', addedAt: new Date() },
-            // React core classes and functions
-            { name: 'Component', type: WhitelistType.FrameworkClass, status: WhitelistStatus.Active, category: 'react', addedBy: 'system', addedAt: new Date() },
-            { name: 'PureComponent', type: WhitelistType.FrameworkClass, status: WhitelistStatus.Active, category: 'react', addedBy: 'system', addedAt: new Date() },
-            { name: 'Fragment', type: WhitelistType.FrameworkClass, status: WhitelistStatus.Active, category: 'react', addedBy: 'system', addedAt: new Date() },
-            { name: 'StrictMode', type: WhitelistType.FrameworkClass, status: WhitelistStatus.Active, category: 'react', addedBy: 'system', addedAt: new Date() },
-            { name: 'Suspense', type: WhitelistType.FrameworkClass, status: WhitelistStatus.Active, category: 'react', addedBy: 'system', addedAt: new Date() },
-            // Database clients
-            { name: 'Pool', type: WhitelistType.FrameworkClass, status: WhitelistStatus.Active, category: 'database', patterns: ['pg'], addedBy: 'system', addedAt: new Date() },
-            { name: 'Client', type: WhitelistType.FrameworkClass, status: WhitelistStatus.Active, category: 'database', patterns: ['pg'], addedBy: 'system', addedAt: new Date() },
-            { name: 'MongoClient', type: WhitelistType.FrameworkClass, status: WhitelistStatus.Active, category: 'database', patterns: ['mongodb'], addedBy: 'system', addedAt: new Date() },
-            { name: 'PrismaClient', type: WhitelistType.FrameworkClass, status: WhitelistStatus.Active, category: 'database', patterns: ['@prisma/client'], addedBy: 'system', addedAt: new Date() },
-            // Auth libraries
-            { name: 'StackServerApp', type: WhitelistType.FrameworkClass, status: WhitelistStatus.Active, category: 'auth', patterns: ['@stackframe/stack'], addedBy: 'system', addedAt: new Date() },
-            { name: 'StackClient', type: WhitelistType.FrameworkClass, status: WhitelistStatus.Active, category: 'auth', patterns: ['@stackframe/stack'], addedBy: 'system', addedAt: new Date() },
-            { name: 'ClerkProvider', type: WhitelistType.FrameworkClass, status: WhitelistStatus.Active, category: 'auth', patterns: ['@clerk/nextjs'], addedBy: 'system', addedAt: new Date() },
-            { name: 'Auth0Provider', type: WhitelistType.FrameworkClass, status: WhitelistStatus.Active, category: 'auth', patterns: ['@auth0/nextjs-auth0'], addedBy: 'system', addedAt: new Date() },
-            // HTTP/API clients
-            { name: 'Axios', type: WhitelistType.FrameworkClass, status: WhitelistStatus.Active, category: 'http', patterns: ['axios'], addedBy: 'system', addedAt: new Date() },
-            { name: 'HttpClient', type: WhitelistType.FrameworkClass, status: WhitelistStatus.Active, category: 'http', addedBy: 'system', addedAt: new Date() },
-            // Express/Node.js frameworks
-            { name: 'Router', type: WhitelistType.FrameworkClass, status: WhitelistStatus.Active, category: 'express', patterns: ['express'], addedBy: 'system', addedAt: new Date() },
-            { name: 'Application', type: WhitelistType.FrameworkClass, status: WhitelistStatus.Active, category: 'express', patterns: ['express'], addedBy: 'system', addedAt: new Date() },
-            // Testing frameworks
-            { name: 'TestingModule', type: WhitelistType.FrameworkClass, status: WhitelistStatus.Active, category: 'testing', patterns: ['@nestjs/testing'], addedBy: 'system', addedAt: new Date() },
-            { name: 'MockedProvider', type: WhitelistType.FrameworkClass, status: WhitelistStatus.Active, category: 'testing', patterns: ['@apollo/client/testing'], addedBy: 'system', addedAt: new Date() },
-            // Node.js core modules
-            { name: 'EventEmitter', type: WhitelistType.FrameworkClass, status: WhitelistStatus.Active, category: 'nodejs', patterns: ['events', 'node:events'], addedBy: 'system', addedAt: new Date() },
-            { name: 'Readable', type: WhitelistType.FrameworkClass, status: WhitelistStatus.Active, category: 'nodejs', patterns: ['stream', 'node:stream'], addedBy: 'system', addedAt: new Date() },
-            { name: 'Writable', type: WhitelistType.FrameworkClass, status: WhitelistStatus.Active, category: 'nodejs', patterns: ['stream', 'node:stream'], addedBy: 'system', addedAt: new Date() },
-            { name: 'Transform', type: WhitelistType.FrameworkClass, status: WhitelistStatus.Active, category: 'nodejs', patterns: ['stream', 'node:stream'], addedBy: 'system', addedAt: new Date() },
-            { name: 'Buffer', type: WhitelistType.FrameworkClass, status: WhitelistStatus.Active, category: 'nodejs', addedBy: 'system', addedAt: new Date() },
-        ];
-        for (const entry of defaultEntries) {
-            this.whitelistCollection.insert(entry);
-        }
-    }
-    /**
-     * Get all whitelist entries
-     */
-    async getWhitelist(type, status) {
-        this.ensureInitialized();
-        const query = {};
-        if (type)
-            query.type = type;
-        if (status)
-            query.status = status;
-        return this.whitelistCollection.find(query);
-    }
-    /**
-     * Add a whitelist entry
-     */
-    async addWhitelistEntry(entry) {
-        this.ensureInitialized();
-        const newEntry = {
-            ...entry,
-            addedAt: new Date()
-        };
-        return this.whitelistCollection.insert(newEntry);
-    }
-    /**
-     * Update whitelist entry status
-     */
-    async updateWhitelistStatus(name, status) {
-        this.ensureInitialized();
-        const entry = this.whitelistCollection.findOne({ name });
-        if (entry) {
-            entry.status = status;
-            entry.updatedAt = new Date();
-            this.whitelistCollection.update(entry);
-        }
-    }
-    /**
-     * Check if a class/import is whitelisted
-     */
-    isWhitelisted(name, type) {
-        if (!this.isInitialized)
-            return false;
-        const entries = this.whitelistCollection.find({
-            type,
-            status: WhitelistStatus.Active
-        });
-        return entries.some(entry => {
-            // Direct name match
-            if (entry.name === name)
-                return true;
-            // Pattern match
-            if (entry.patterns) {
-                return entry.patterns.some(pattern => {
-                    if (pattern.includes('*')) {
-                        const regex = new RegExp(pattern.replace(/\*/g, '.*'));
-                        return regex.test(name);
-                    }
-                    return pattern === name;
-                });
-            }
-            return false;
-        });
-    }
-    /**
-     * Detect and suggest new whitelist entries based on usage patterns
-     */
-    async detectWhitelistCandidates() {
-        this.ensureInitialized();
-        // This would analyze the codebase for patterns
-        // For now, returning empty array - to be implemented
-        return [];
-    }
-    /**
-     * Store audit results in database
-     */
-    async storeAuditResults(auditResult, projectPath) {
-        this.ensureInitialized();
-        // Generate unique audit ID
-        const auditId = `audit_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-        // Store the entire result to preserve analyzer structure; auditId must come last so
-        // a stray auditResult.auditId cannot break pagination lookups.
-        const auditRecord = {
-            ...auditResult,
-            auditId,
-            timestamp: new Date(),
-            projectPath,
-            expiresAt: new Date(Date.now() + 24 * 60 * 60 * 1000) // Expire after 24 hours
-        };
-        this.auditResultsCollection.insert(auditRecord);
-        // Clean up expired results
-        this.cleanupExpiredAudits();
-        // Persist so resultId survives MCP restart (Loki autosave is off; many code paths never save otherwise).
-        this.db.saveDatabase();
-        return auditId;
-    }
-    /**
-     * Retrieve cached audit results
-     */
-    async getAuditResults(auditId) {
-        this.ensureInitialized();
-        const result = this.auditResultsCollection.findOne({ auditId });
-        if (result && new Date(result.expiresAt) > new Date()) {
-            return result;
-        }
-        // Remove expired result if found
-        if (result) {
-            this.auditResultsCollection.remove(result);
-        }
-        return null;
-    }
-    /**
-     * Clean up expired audit results
-     */
-    cleanupExpiredAudits() {
-        const now = new Date();
-        const expired = this.auditResultsCollection.find({
-            expiresAt: { $lt: now }
-        });
-        expired.forEach(doc => {
-            this.auditResultsCollection.remove(doc);
-        });
-    }
-    // Analyzer Configuration Methods
-    /**
-     * Store analyzer configuration
-     */
-    async storeAnalyzerConfig(analyzerName, config, options) {
-        this.ensureInitialized();
-        const configDoc = {
-            analyzerName,
-            config,
-            isGlobal: options?.isGlobal ?? true,
-            projectPath: options?.projectPath || null,
-            createdAt: new Date(),
-            updatedAt: new Date(),
-            createdBy: 'user',
-            metadata: options?.metadata
-        };
-        // Check if config already exists
-        const existing = this.analyzerConfigCollection.findOne({
-            analyzerName,
-            projectPath: options?.projectPath || null,
-            isGlobal: options?.isGlobal ?? true
-        });
-        if (existing) {
-            Object.assign(existing, {
-                config,
-                updatedAt: new Date(),
-                metadata: options?.metadata
-            });
-            this.analyzerConfigCollection.update(existing);
-        }
-        else {
-            this.analyzerConfigCollection.insert(configDoc);
-        }
-        this.db.saveDatabase();
-        return analyzerName;
-    }
-    /**
-     * Retrieve analyzer configuration
-     */
-    async getAnalyzerConfig(analyzerName, projectPath) {
-        this.ensureInitialized();
-        // First try project-specific config
-        if (projectPath) {
-            const projectConfig = this.analyzerConfigCollection.findOne({
-                analyzerName,
-                projectPath,
-                isGlobal: false
-            });
-            if (projectConfig)
-                return projectConfig.config;
-        }
-        // Fall back to global config
-        const globalConfig = this.analyzerConfigCollection.findOne({
-            analyzerName,
-            isGlobal: true
-        });
-        return globalConfig?.config || null;
-    }
-    /**
-     * Get all analyzer configurations
-     */
-    async getAllAnalyzerConfigs(projectPath) {
-        this.ensureInitialized();
-        const configs = {};
-        // Get global configs first
-        const globalConfigs = this.analyzerConfigCollection.find({ isGlobal: true });
-        for (const config of globalConfigs) {
-            configs[config.analyzerName] = config.config;
-        }
-        // Override with project-specific configs if available
-        if (projectPath) {
-            const projectConfigs = this.analyzerConfigCollection.find({
-                projectPath,
-                isGlobal: false
-            });
-            for (const config of projectConfigs) {
-                configs[config.analyzerName] = config.config;
-            }
-        }
-        return configs;
-    }
-    /**
-     * Delete analyzer configuration
-     */
-    async deleteAnalyzerConfig(analyzerName, options) {
-        this.ensureInitialized();
-        const config = this.analyzerConfigCollection.findOne({
-            analyzerName,
-            projectPath: options?.projectPath || null,
-            isGlobal: options?.isGlobal ?? !options?.projectPath
-        });
-        if (config) {
-            this.analyzerConfigCollection.remove(config);
-            this.db.saveDatabase();
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Reset all analyzer configurations to defaults
-     */
-    async resetAnalyzerConfigs(projectPath) {
-        this.ensureInitialized();
-        if (projectPath) {
-            // Remove only project-specific configs
-            const projectConfigs = this.analyzerConfigCollection.find({
-                projectPath,
-                isGlobal: false
-            });
-            projectConfigs.forEach(config => {
-                this.analyzerConfigCollection.remove(config);
-            });
-        }
-        else {
-            // Remove all configs
-            this.analyzerConfigCollection.clear();
-        }
-        this.db.saveDatabase();
-    }
-    /**
-     * Store a code map section in the database
-     */
-    async storeCodeMapSection(mapId, sectionType, content, metadata) {
-        this.ensureInitialized();
-        // Remove any existing section of this type for this mapId
-        this.codeMapCollection.findAndRemove({
-            mapId,
-            sectionType
-        });
-        this.codeMapCollection.insert({
-            mapId,
-            sectionType,
-            content,
-            metadata: metadata || {},
-            timestamp: new Date(),
-            size: content.length
-        });
-        this.db.saveDatabase();
-    }
-    /**
-     * Retrieve a code map section
-     */
-    async getCodeMapSection(mapId, sectionType) {
-        this.ensureInitialized();
-        const section = this.codeMapCollection.findOne({
-            mapId,
-            sectionType
-        });
-        return section ? {
-            content: section.content,
-            metadata: section.metadata || {}
-        } : null;
-    }
-    /**
-     * List available code map sections for a mapId
-     */
-    async listCodeMapSections(mapId) {
-        this.ensureInitialized();
-        const sections = this.codeMapCollection.find({ mapId });
-        return sections.map(section => ({
-            sectionType: section.sectionType,
-            size: section.size || 0,
-            timestamp: section.timestamp
-        }));
-    }
-    /**
-     * Clear code map sections older than specified time
-     */
-    async clearOldCodeMaps(olderThanHours = 24) {
-        this.ensureInitialized();
-        const cutoffTime = new Date();
-        cutoffTime.setHours(cutoffTime.getHours() - olderThanHours);
-        const oldSections = this.codeMapCollection.find({
-            timestamp: { '$lt': cutoffTime }
-        });
-        const count = oldSections.length;
-        this.codeMapCollection.findAndRemove({
-            timestamp: { '$lt': cutoffTime }
-        });
-        this.db.saveDatabase();
-        return count;
-    }
-    /**
-     * Delete all sections for a specific mapId
-     */
-    async deleteCodeMap(mapId) {
-        this.ensureInitialized();
-        const sections = this.codeMapCollection.find({ mapId });
-        const count = sections.length;
-        this.codeMapCollection.findAndRemove({ mapId });
-        this.db.saveDatabase();
-        return count;
-    }
-    // Schema Management Methods
-    /**
-     * Store a database schema definition
-     */
-    async storeSchema(schema) {
-        this.ensureInitialized();
-        const schemaId = `schema_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-        const schemaMetadata = {
-            schemaId,
-            schemaName: schema.name,
-            indexedAt: new Date(),
-            tableCount: schema.databases.reduce((acc, db) => acc + db.tables.length, 0),
-            relationshipCount: schema.databases.reduce((acc, db) => acc + (db.relationships?.length || 0), 0),
-            usagePatterns: [],
-            discoveredPatterns: [],
-            violations: []
-        };
-        // Store the schema definition
-        this.schemaCollection.insert({
-            schemaId,
-            schema,
-            metadata: schemaMetadata,
-            indexedAt: new Date()
-        });
-        this.db.saveDatabase();
-        return schemaId;
-    }
-    /**
-     * Retrieve a schema by ID
-     */
-    async getSchema(schemaId) {
-        this.ensureInitialized();
-        const result = this.schemaCollection.findOne({ schemaId });
-        return result?.schema || null;
-    }
-    /**
-     * Get all schemas
-     */
-    async getAllSchemas() {
-        this.ensureInitialized();
-        const schemas = this.schemaCollection.find();
-        return schemas.map(doc => ({
-            schemaId: doc.schemaId,
-            metadata: doc.metadata,
-            schema: doc.schema
-        }));
-    }
-    /**
-     * Delete a schema
-     */
-    async deleteSchema(schemaId) {
-        this.ensureInitialized();
-        const schema = this.schemaCollection.findOne({ schemaId });
-        if (schema) {
-            this.schemaCollection.remove(schema);
-            // Also remove associated usage patterns
-            this.schemaUsageCollection.findAndRemove({ schemaId });
-            this.db.saveDatabase();
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Record schema usage in code
-     */
-    async recordSchemaUsage(usage, schemaId) {
-        this.ensureInitialized();
-        const usageDoc = {
-            ...usage,
-            schemaId: schemaId || 'default',
-            recordedAt: new Date()
-        };
-        // Check if this usage already exists
-        const existing = this.schemaUsageCollection.findOne({
-            tableName: usage.tableName,
-            filePath: usage.filePath,
-            functionName: usage.functionName,
-            line: usage.line
-        });
-        if (existing) {
-            Object.assign(existing, usageDoc);
-            this.schemaUsageCollection.update(existing);
-        }
-        else {
-            this.schemaUsageCollection.insert(usageDoc);
-        }
-        this.db.saveDatabase();
-    }
-    /**
-     * Get schema usage patterns
-     */
-    async getSchemaUsage(options = {}) {
-        this.ensureInitialized();
-        const query = {};
-        if (options.schemaId)
-            query.schemaId = options.schemaId;
-        if (options.tableName)
-            query.tableName = options.tableName;
-        if (options.filePath)
-            query.filePath = options.filePath;
-        if (options.functionName)
-            query.functionName = options.functionName;
-        if (options.usageType)
-            query.usageType = options.usageType;
-        const results = this.schemaUsageCollection.find(query);
-        return results.map(doc => {
-            const { $loki, meta, schemaId, recordedAt, ...usage } = doc;
-            return usage;
-        });
-    }
-    /**
-     * Find functions that interact with specific tables
-     */
-    async findFunctionsUsingTable(tableName) {
-        this.ensureInitialized();
-        const usages = this.schemaUsageCollection.find({ tableName });
-        return usages.map(usage => ({
-            functionName: usage.functionName,
-            filePath: usage.filePath,
-            usageType: usage.usageType,
-            line: usage.line
-        }));
-    }
-    /**
-     * Get schema statistics
-     */
-    async getSchemaStats() {
-        this.ensureInitialized();
-        const schemas = this.schemaCollection.find();
-        const usages = this.schemaUsageCollection.find();
-        const totalTables = schemas.reduce((acc, schema) => acc + schema.schema.databases.reduce((dbAcc, db) => dbAcc + db.tables.length, 0), 0);
-        // Count usage by table
-        const tableUsage = {};
-        const usageByType = {};
-        usages.forEach(usage => {
-            tableUsage[usage.tableName] = (tableUsage[usage.tableName] || 0) + 1;
-            usageByType[usage.usageType] = (usageByType[usage.usageType] || 0) + 1;
-        });
-        const mostUsedTables = Object.entries(tableUsage)
-            .sort((a, b) => b[1] - a[1])
-            .slice(0, 10)
-            .map(([tableName, usageCount]) => ({ tableName, usageCount }));
-        return {
-            totalSchemas: schemas.length,
-            totalTables,
-            totalUsagePatterns: usages.length,
-            mostUsedTables,
-            usageByType
-        };
-    }
-    /**
-     * Update search to include schema context
-     */
-    async searchWithSchemaContext(query, options = {}) {
-        this.ensureInitialized();
-        // First perform regular function search
-        const searchResult = await this.searchFunctions(options);
-        if (!options.includeSchemaUsage) {
-            return searchResult;
-        }
-        // Add schema context to results
-        const enhancedFunctions = await Promise.all(searchResult.functions.map(async (func) => {
-            const schemaUsage = await this.getSchemaUsage({
-                filePath: func.filePath,
-                functionName: func.name
-            });
-            return {
-                ...func,
-                schemaUsage,
-                affectedTables: [...new Set(schemaUsage.map(u => u.tableName))],
-                schemaPatterns: [...new Set(schemaUsage.map(u => u.usageType))]
-            };
-        }));
-        // Extract schema context for summary
-        const allSchemaUsage = enhancedFunctions.flatMap(f => f.schemaUsage || []);
-        const schemaContext = [...new Set(allSchemaUsage.map(u => ({
-                tableName: u.tableName,
-                usageType: u.usageType
-            })))];
-        return {
-            ...searchResult,
-            functions: enhancedFunctions,
-            schemaContext
-        };
-    }
-    async createProjectTask(input) {
-        return this.getTaskRepository().create(input);
-    }
-    async getProjectTask(taskId) {
-        return this.getTaskRepository().getById(taskId);
-    }
-    async listProjectTasks(projectPath, options) {
-        return this.getTaskRepository().list(projectPath, options);
-    }
-    async listProjectTasksTree(projectPath, options) {
-        return this.getTaskRepository().listTree(projectPath, options);
-    }
-    async listActionableProjectTasks(projectPath, options) {
-        return this.getTaskRepository().listActionable(projectPath, options);
-    }
-    async completeProjectTask(taskId) {
-        return this.getTaskRepository().complete(taskId);
-    }
-    /**
-     * @param patch Raw JSON-shaped update; unknown keys are ignored (see sanitizeUpdatePatch).
-     */
-    async updateProjectTask(taskId, patch) {
-        return this.getTaskRepository().update(taskId, patch);
-    }
-    async deleteProjectTask(taskId, mode) {
-        return this.getTaskRepository().delete(taskId, mode);
-    }
-}
-//# sourceMappingURL=codeIndexDB.js.map