@compass-ai/nova 1.0.74 → 1.0.76

package/dist/services/codebase-indexer.js

@@ -1,863 +0,0 @@
-/**
- * Codebase indexing service for file discovery, AST parsing, and dependency graph building.
- * This service provides efficient indexing of large codebases (up to 100,000 files) while
- * maintaining memory constraints (<500MB). It supports streaming file processing, lazy loading,
- * and LRU caching for file metadata.
- */
-import path from 'path';
-import { glob } from 'glob';
-import * as parser from '@babel/parser';
-import { safeReadFile, safeWriteJson, safeReadJson, pathExists, stat, ensureDir, } from '../utils/file-system.js';
-import { getProjectCompassDir, toForwardSlashes, sanitizePath, } from '../utils/path.js';
-import { formatTimestamp } from '../utils/format.js';
-import { logger } from '../utils/logger.js';
-import { getConfigManager } from './config-manager.js';
-import { INDEX_DIR, DEFAULT_CONFIG } from '../constants/defaults.js';
-import { getSystemEventLogger } from './system-event-logger.js';
-import { DEFAULT_IGNORE_PATTERNS, loadIgnorePatterns, mergeSessionExclusions } from '../utils/ignore-patterns.js';
-import { getSessionManager } from './session-manager.js';
-// DEFAULT_IGNORE_PATTERNS is now imported from '../utils/ignore-patterns.js'
-// and re-exported for backward compatibility
-/**
- * Language detection mapping based on file extensions
- */
-const EXTENSION_TO_LANGUAGE = {
-    '.ts': 'typescript',
-    '.tsx': 'typescript',
-    '.js': 'javascript',
-    '.jsx': 'javascript',
-    '.mjs': 'javascript',
-    '.cjs': 'javascript',
-    '.py': 'python',
-    '.rb': 'ruby',
-    '.go': 'go',
-    '.rs': 'rust',
-    '.java': 'java',
-    '.kt': 'kotlin',
-    '.swift': 'swift',
-    '.c': 'c',
-    '.cpp': 'cpp',
-    '.h': 'c',
-    '.hpp': 'cpp',
-    '.cs': 'csharp',
-    '.php': 'php',
-    '.vue': 'vue',
-    '.svelte': 'svelte',
-    '.html': 'html',
-    '.css': 'css',
-    '.scss': 'scss',
-    '.sass': 'sass',
-    '.less': 'less',
-    '.json': 'json',
-    '.yaml': 'yaml',
-    '.yml': 'yaml',
-    '.xml': 'xml',
-    '.md': 'markdown',
-    '.mdx': 'markdown',
-    '.sql': 'sql',
-    '.sh': 'shell',
-    '.bash': 'shell',
-    '.zsh': 'shell',
-    '.fish': 'shell',
-    '.ps1': 'powershell',
-    '.dockerfile': 'dockerfile',
-    '.toml': 'toml',
-    '.ini': 'ini',
-    '.env': 'env',
-    '.graphql': 'graphql',
-    '.gql': 'graphql',
-    '.proto': 'protobuf',
-};
-/**
- * Binary file extensions to exclude
- */
-const BINARY_EXTENSIONS = new Set([
-    '.png', '.jpg', '.jpeg', '.gif', '.bmp', '.ico', '.webp', '.svg',
-    '.mp3', '.mp4', '.wav', '.avi', '.mov', '.mkv', '.webm',
-    '.zip', '.tar', '.gz', '.rar', '.7z', '.bz2',
-    '.pdf', '.doc', '.docx', '.xls', '.xlsx', '.ppt', '.pptx',
-    '.exe', '.dll', '.so', '.dylib', '.bin',
-    '.woff', '.woff2', '.ttf', '.otf', '.eot',
-    '.sqlite', '.db',
-]);
-/**
- * LRU Cache implementation for file metadata
- */
-class LRUCache {
-    cache = new Map();
-    maxSize;
-    constructor(maxSize = 1000) {
-        this.maxSize = maxSize;
-    }
-    get(key) {
-        const value = this.cache.get(key);
-        if (value !== undefined) {
-            // Move to end (most recently used)
-            this.cache.delete(key);
-            this.cache.set(key, value);
-        }
-        return value;
-    }
-    set(key, value) {
-        if (this.cache.has(key)) {
-            this.cache.delete(key);
-        }
-        else if (this.cache.size >= this.maxSize) {
-            // Remove oldest entry
-            const firstKey = this.cache.keys().next().value;
-            if (firstKey !== undefined) {
-                this.cache.delete(firstKey);
-            }
-        }
-        this.cache.set(key, value);
-    }
-    has(key) {
-        return this.cache.has(key);
-    }
-    delete(key) {
-        return this.cache.delete(key);
-    }
-    clear() {
-        this.cache.clear();
-    }
-    get size() {
-        return this.cache.size;
-    }
-}
-/**
- * CodebaseIndexer class for efficient codebase indexing and semantic search.
- * Handles file discovery, AST parsing, dependency graph building, and caching.
- */
-class CodebaseIndexer {
-    projectRoot;
-    index = null;
-    fileCache;
-    contentCache;
-    indexPath = null;
-    isInitialized = false;
-    constructor(projectRoot) {
-        this.projectRoot = projectRoot || process.cwd();
-        this.fileCache = new LRUCache(5000);
-        this.contentCache = new LRUCache(100);
-    }
-    /**
-     * Initializes the indexer and loads existing index if available
-     */
-    async initialize(projectRoot) {
-        if (projectRoot) {
-            this.projectRoot = projectRoot;
-        }
-        this.indexPath = path.join(getProjectCompassDir(this.projectRoot), INDEX_DIR, 'file-index.json');
-        // Ensure index directory exists
-        await ensureDir(path.dirname(this.indexPath));
-        // Try to load existing index
-        if (await pathExists(this.indexPath)) {
-            const existingIndex = await safeReadJson(this.indexPath);
-            if (existingIndex && existingIndex.projectRoot === this.projectRoot) {
-                this.index = existingIndex;
-                logger.debug(`Loaded existing index with ${existingIndex.totalFiles} files`);
-            }
-        }
-        // Create new index if none exists
-        if (!this.index) {
-            this.index = this.createEmptyIndex();
-        }
-        this.isInitialized = true;
-    }
-    /**
-     * Creates an empty index structure
-     */
-    createEmptyIndex() {
-        return {
-            version: '1.0',
-            projectRoot: this.projectRoot,
-            updatedAt: formatTimestamp(),
-            totalFiles: 0,
-            totalSize: 0,
-            files: {},
-            dependencyGraph: {},
-        };
-    }
-    /**
-     * Discovers files in the project directory.
-     * By default, loads ignore patterns from .gitignore if it exists,
-     * otherwise falls back to DEFAULT_IGNORE_PATTERNS.
-     * Also respects excludedFolders from the session.
-     */
-    async discoverFiles(projectRoot, options = {}) {
-        const root = projectRoot || this.projectRoot;
-        const configManager = getConfigManager();
-        const config = configManager.getConfig();
-        // Load base ignore patterns - use .gitignore if available and useGitignore is not false
-        const useGitignore = options.useGitignore !== false;
-        const basePatterns = useGitignore
-            ? await loadIgnorePatterns(root)
-            : DEFAULT_IGNORE_PATTERNS;
-        // Get session excluded folders
-        const sessionManager = getSessionManager();
-        const sessionExcludedFolders = sessionManager.getExcludedFolders();
-        // Merge base patterns with session exclusions
-        const patternsWithSessionExclusions = mergeSessionExclusions(sessionExcludedFolders, basePatterns);
-        // Merge with custom patterns from options or config
-        const ignorePatterns = [
-            ...patternsWithSessionExclusions,
-            ...(options.ignorePatterns || config.project?.ignorePatterns || []),
-        ];
-        const includePatterns = options.includePatterns ||
-            config.project?.includePatterns || ['**/*'];
-        const pattern = options.pattern || includePatterns;
-        const maxFileSize = options.maxFileSize ||
-            config.project?.maxFileSize ||
-            DEFAULT_CONFIG.project.maxFileSize;
-        try {
-            const files = await glob(pattern, {
-                cwd: root,
-                nodir: true,
-                ignore: ignorePatterns,
-                absolute: false,
-                dot: false,
-                maxDepth: options.maxDepth,
-            });
-            const discoveredFiles = [];
-            for (const filePath of files) {
-                const absolutePath = path.join(root, filePath);
-                const ext = path.extname(filePath).toLowerCase();
-                // Skip binary files
-                if (BINARY_EXTENSIONS.has(ext)) {
-                    continue;
-                }
-                try {
-                    const stats = await stat(absolutePath);
-                    if (stats && stats.size <= maxFileSize) {
-                        discoveredFiles.push({
-                            path: toForwardSlashes(filePath),
-                            absolutePath,
-                            size: stats.size,
-                            modifiedAt: stats.mtime,
-                        });
-                    }
-                }
-                catch {
-                    // Skip files we can't stat
-                }
-            }
-            logger.debug(`Discovered ${discoveredFiles.length} files in ${root}`);
-            return discoveredFiles;
-        }
-        catch (error) {
-            logger.error('Failed to discover files', error);
-            return [];
-        }
-    }
-    /**
-     * Indexes the entire project
-     */
-    async indexProject(projectRoot, options = {}) {
-        const startTime = Date.now();
-        const root = projectRoot || this.projectRoot;
-        const systemEventLogger = getSystemEventLogger();
-        // Log index start
-        await systemEventLogger.logIndexStarted({
-            projectPath: root,
-        });
-        if (!this.isInitialized) {
-            await this.initialize(root);
-        }
-        const errors = [];
-        let newFiles = 0;
-        let updatedFiles = 0;
-        let removedFiles = 0;
-        try {
-            // Discover all files
-            const discoveredFiles = await this.discoverFiles(root, options);
-            const totalFiles = discoveredFiles.length;
-            // Track which files we've seen
-            const seenPaths = new Set();
-            // Process each file
-            for (let i = 0; i < discoveredFiles.length; i++) {
-                const file = discoveredFiles[i];
-                seenPaths.add(file.path);
-                // Report progress
-                if (options.onProgress) {
-                    options.onProgress(i + 1, totalFiles, file.path);
-                }
-                try {
-                    const existingFile = this.index.files[file.path];
-                    const modifiedAt = file.modifiedAt?.toISOString() || formatTimestamp();
-                    // Check if file needs reindexing
-                    const needsReindex = options.force ||
-                        !existingFile ||
-                        existingFile.modifiedAt !== modifiedAt ||
-                        existingFile.size !== file.size;
-                    if (needsReindex) {
-                        const indexedFile = await this.indexFile(file.path, file.absolutePath);
-                        if (indexedFile) {
-                            this.index.files[file.path] = indexedFile;
-                            this.fileCache.set(file.path, indexedFile);
-                            const status = existingFile ? 'updated' : 'new';
-                            if (status === 'new') {
-                                newFiles++;
-                            }
-                            else {
-                                updatedFiles++;
-                            }
-                            if (options.onFileIndexed) {
-                                options.onFileIndexed(indexedFile, status);
-                            }
-                        }
-                    }
-                    else {
-                        if (options.onFileIndexed) {
-                            options.onFileIndexed(existingFile, 'skipped');
-                        }
-                    }
-                }
-                catch (error) {
-                    const errorMsg = error instanceof Error ? error.message : 'Unknown error';
-                    errors.push(`${file.path}: ${errorMsg}`);
-                    if (options.onError) {
-                        options.onError(file.path, errorMsg);
-                    }
-                }
-            }
-            // Remove files that no longer exist
-            for (const filePath of Object.keys(this.index.files)) {
-                if (!seenPaths.has(filePath)) {
-                    delete this.index.files[filePath];
-                    delete this.index.dependencyGraph[filePath];
-                    this.fileCache.delete(filePath);
-                    removedFiles++;
-                }
-            }
-            // Update index metadata
-            this.index.updatedAt = formatTimestamp();
-            this.index.totalFiles = Object.keys(this.index.files).length;
-            this.index.totalSize = Object.values(this.index.files).reduce((sum, f) => sum + f.size, 0);
-            // Build dependency graph
-            await this.buildDependencyGraph();
-            // Save index to disk
-            await this.saveIndex();
-            const duration = Date.now() - startTime;
-            logger.info(`Indexed ${this.index.totalFiles} files in ${duration}ms ` +
-                `(${newFiles} new, ${updatedFiles} updated, ${removedFiles} removed)`);
-            // Log successful completion
-            await systemEventLogger.logIndexCompleted({
-                projectPath: root,
-                fileCount: this.index.totalFiles,
-                indexedCount: newFiles + updatedFiles,
-                skippedCount: this.index.totalFiles - newFiles - updatedFiles,
-                duration_ms: duration,
-            });
-            return {
-                totalFiles: this.index.totalFiles,
-                newFiles,
-                updatedFiles,
-                removedFiles,
-                duration,
-                errors,
-            };
-        }
-        catch (error) {
-            const errorMsg = error instanceof Error ? error.message : 'Indexing failed';
-            errors.push(errorMsg);
-            logger.error('Project indexing failed', error);
-            // Log indexing failure
-            await systemEventLogger.logIndexCompleted({
-                projectPath: root,
-                fileCount: 0,
-                duration_ms: Date.now() - startTime,
-                error: errorMsg,
-            });
-            return {
-                totalFiles: 0,
-                newFiles: 0,
-                updatedFiles: 0,
-                removedFiles: 0,
-                duration: Date.now() - startTime,
-                errors,
-            };
-        }
-    }
-    /**
-     * Indexes a single file
-     */
-    async indexFile(relativePath, absolutePath) {
-        const absPath = absolutePath || path.join(this.projectRoot, relativePath);
-        const sanitized = sanitizePath(relativePath, this.projectRoot);
-        if (!sanitized) {
-            logger.warn(`Path traversal attempt blocked: ${relativePath}`);
-            return null;
-        }
-        if (!await pathExists(absPath)) {
-            return null;
-        }
-        try {
-            const content = await safeReadFile(absPath);
-            if (content === null) {
-                return null;
-            }
-            const stats = await stat(absPath);
-            const name = path.basename(relativePath);
-            const extension = path.extname(name).slice(1);
-            const language = this.detectLanguage(relativePath);
-            // Parse file for exports and imports
-            const { exports, imports } = await this.parseFile(content, language, relativePath);
-            const indexedFile = {
-                path: toForwardSlashes(relativePath),
-                absolutePath: absPath,
-                name,
-                extension,
-                size: stats?.size || 0,
-                modifiedAt: stats?.mtime.toISOString() || formatTimestamp(),
-                language,
-                exports,
-                imports,
-                parsed: true,
-            };
-            return indexedFile;
-        }
-        catch (error) {
-            logger.debug(`Failed to index file: ${relativePath}`, error);
-            return null;
-        }
-    }
-    /**
-     * Parses a file to extract exports and imports
-     */
-    async parseFile(content, language, filePath) {
-        const exports = [];
-        const imports = [];
-        try {
-            if (language === 'typescript' || language === 'javascript') {
-                return this.parseJavaScriptTypeScript(content, filePath);
-            }
-            else if (language === 'python') {
-                return this.parsePython(content);
-            }
-        }
-        catch (error) {
-            logger.debug(`Failed to parse ${filePath}`, error);
-        }
-        return { exports, imports };
-    }
-    /**
-     * Parses JavaScript/TypeScript files using Babel parser
-     */
-    parseJavaScriptTypeScript(content, filePath) {
-        const exports = [];
-        const imports = [];
-        try {
-            const isTypeScript = filePath.endsWith('.ts') || filePath.endsWith('.tsx');
-            const isJSX = filePath.endsWith('.jsx') || filePath.endsWith('.tsx');
-            const plugins = [
-                'decorators-legacy',
-                'classProperties',
-                'classPrivateProperties',
-                'classPrivateMethods',
-                'exportDefaultFrom',
-                'exportNamespaceFrom',
-                'dynamicImport',
-                'nullishCoalescingOperator',
-                'optionalChaining',
-                'topLevelAwait',
-            ];
-            if (isTypeScript) {
-                plugins.push('typescript');
-            }
-            if (isJSX) {
-                plugins.push('jsx');
-            }
-            const ast = parser.parse(content, {
-                sourceType: 'module',
-                plugins,
-                errorRecovery: true,
-            });
-            // Extract imports and exports from AST
-            for (const node of ast.program.body) {
-                // Import declarations
-                if (node.type === 'ImportDeclaration') {
-                    const source = node.source.value;
-                    if (typeof source === 'string') {
-                        imports.push(source);
-                    }
-                }
-                // Export declarations
-                if (node.type === 'ExportNamedDeclaration') {
-                    if (node.declaration) {
-                        if (node.declaration.type === 'FunctionDeclaration' ||
-                            node.declaration.type === 'ClassDeclaration') {
-                            if (node.declaration.id?.name) {
-                                exports.push(node.declaration.id.name);
-                            }
-                        }
-                        else if (node.declaration.type === 'VariableDeclaration') {
-                            for (const decl of node.declaration.declarations) {
-                                if (decl.id.type === 'Identifier') {
-                                    exports.push(decl.id.name);
-                                }
-                            }
-                        }
-                    }
-                    if (node.specifiers) {
-                        for (const spec of node.specifiers) {
-                            if (spec.exported.type === 'Identifier') {
-                                exports.push(spec.exported.name);
-                            }
-                        }
-                    }
-                }
-                if (node.type === 'ExportDefaultDeclaration') {
-                    exports.push('default');
-                }
-                if (node.type === 'ExportAllDeclaration') {
-                    if (node.source?.value) {
-                        imports.push(node.source.value);
-                    }
-                }
-            }
-        }
-        catch (error) {
-            // Fallback to regex-based parsing
-            return this.parseWithRegex(content);
-        }
-        return { exports, imports };
-    }
-    /**
-     * Parses Python files using regex
-     */
-    parsePython(content) {
-        const exports = [];
-        const imports = [];
-        // Match import statements
-        const importRegex = /^(?:from\s+(\S+)\s+)?import\s+(.+)$/gm;
-        let match;
-        while ((match = importRegex.exec(content)) !== null) {
-            if (match[1]) {
-                imports.push(match[1]);
-            }
-            else if (match[2]) {
-                const importedModules = match[2].split(',').map((s) => s.trim().split(' ')[0]);
-                imports.push(...importedModules);
-            }
-        }
-        // Match function and class definitions (potential exports)
-        const defRegex = /^(?:def|class)\s+(\w+)/gm;
-        while ((match = defRegex.exec(content)) !== null) {
-            exports.push(match[1]);
-        }
-        // Match __all__ definition
-        const allRegex = /__all__\s*=\s*\[([^\]]+)\]/;
-        const allMatch = content.match(allRegex);
-        if (allMatch) {
-            const allExports = allMatch[1]
-                .split(',')
-                .map((s) => s.trim().replace(/['"]/g, ''));
-            exports.length = 0;
-            exports.push(...allExports);
-        }
-        return { exports, imports };
-    }
-    /**
-     * Fallback regex-based parsing for JavaScript/TypeScript
-     */
-    parseWithRegex(content) {
-        const exports = [];
-        const imports = [];
-        // Match import statements
-        const importRegex = /import\s+(?:(?:\{[^}]*\}|\*\s+as\s+\w+|\w+)\s+from\s+)?['"]([^'"]+)['"]/g;
-        let match;
-        while ((match = importRegex.exec(content)) !== null) {
-            imports.push(match[1]);
-        }
-        // Match require statements
-        const requireRegex = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
-        while ((match = requireRegex.exec(content)) !== null) {
-            imports.push(match[1]);
-        }
-        // Match export statements
-        const exportRegex = /export\s+(?:default\s+)?(?:const|let|var|function|class|async\s+function)\s+(\w+)/g;
-        while ((match = exportRegex.exec(content)) !== null) {
-            exports.push(match[1]);
-        }
-        // Match named exports
-        const namedExportRegex = /export\s*\{\s*([^}]+)\s*\}/g;
-        while ((match = namedExportRegex.exec(content)) !== null) {
-            const names = match[1].split(',').map((s) => s.trim().split(/\s+as\s+/)[0].trim());
-            exports.push(...names.filter((n) => n.length > 0));
-        }
-        return { exports, imports };
-    }
-    /**
-     * Builds the dependency graph from indexed files
-     */
-    async buildDependencyGraph() {
-        if (!this.index)
-            return;
-        // Reset dependency graph
-        this.index.dependencyGraph = {};
-        // Initialize nodes for all files
-        for (const filePath of Object.keys(this.index.files)) {
-            this.index.dependencyGraph[filePath] = {
-                path: filePath,
-                dependencies: [],
-                dependents: [],
-            };
-        }
-        // Build dependencies
-        for (const [filePath, file] of Object.entries(this.index.files)) {
-            const node = this.index.dependencyGraph[filePath];
-            for (const importPath of file.imports) {
-                // Resolve relative imports
-                const resolvedPath = this.resolveImportPath(filePath, importPath);
-                if (resolvedPath && this.index.files[resolvedPath]) {
-                    node.dependencies.push(resolvedPath);
-                    // Add as dependent to the imported file
-                    const importedNode = this.index.dependencyGraph[resolvedPath];
-                    if (importedNode && !importedNode.dependents.includes(filePath)) {
-                        importedNode.dependents.push(filePath);
-                    }
-                }
-            }
-        }
-    }
-    /**
-     * Resolves an import path to a file in the index
-     */
-    resolveImportPath(fromFile, importPath) {
-        // Skip external packages
-        if (!importPath.startsWith('.') && !importPath.startsWith('/')) {
-            return null;
-        }
-        const fromDir = path.dirname(fromFile);
-        let resolvedPath = path.join(fromDir, importPath);
-        resolvedPath = toForwardSlashes(resolvedPath);
-        // Try exact match
-        if (this.index?.files[resolvedPath]) {
-            return resolvedPath;
-        }
-        // Try with extensions
-        const extensions = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'];
-        for (const ext of extensions) {
-            const withExt = resolvedPath + ext;
-            if (this.index?.files[withExt]) {
-                return withExt;
-            }
-        }
-        // Try index files
-        for (const ext of extensions) {
-            const indexPath = `${resolvedPath}/index${ext}`;
-            if (this.index?.files[indexPath]) {
-                return indexPath;
-            }
-        }
-        return null;
-    }
-    /**
-     * Detects the programming language based on file extension
-     */
-    detectLanguage(filePath) {
-        const ext = path.extname(filePath).toLowerCase();
-        const basename = path.basename(filePath).toLowerCase();
-        // Check for special filenames
-        if (basename === 'dockerfile' || basename.startsWith('dockerfile.')) {
-            return 'dockerfile';
-        }
-        if (basename === 'makefile' || basename === 'gnumakefile') {
-            return 'makefile';
-        }
-        if (basename === '.gitignore' || basename === '.dockerignore') {
-            return 'gitignore';
-        }
-        return EXTENSION_TO_LANGUAGE[ext] || 'text';
-    }
-    /**
-     * Saves the index to disk
-     */
-    async saveIndex() {
-        if (!this.index || !this.indexPath)
-            return;
-        try {
-            await safeWriteJson(this.indexPath, this.index);
-            logger.debug('Index saved to disk');
-        }
-        catch (error) {
-            logger.error('Failed to save index', error);
-        }
-    }
-    /**
-     * Gets the current index
-     */
-    getIndex() {
-        return this.index;
-    }
-    /**
-     * Gets an indexed file by path
-     */
-    getFile(filePath) {
-        // Check cache first
-        const cached = this.fileCache.get(filePath);
-        if (cached) {
-            return cached;
-        }
-        // Check index
-        if (this.index?.files[filePath]) {
-            const file = this.index.files[filePath];
-            this.fileCache.set(filePath, file);
-            return file;
-        }
-        return null;
-    }
-    /**
-     * Searches for files matching a pattern or query
-     */
-    async searchFiles(query) {
-        if (!this.index) {
-            await this.initialize();
-        }
-        const results = [];
-        const lowerQuery = query.toLowerCase();
-        for (const filePath of Object.keys(this.index.files)) {
-            // Match file path
-            if (filePath.toLowerCase().includes(lowerQuery)) {
-                results.push(filePath);
-                continue;
-            }
-            // Match file name
-            const fileName = path.basename(filePath).toLowerCase();
-            if (fileName.includes(lowerQuery)) {
-                results.push(filePath);
-                continue;
-            }
-            // Match exports
-            const file = this.index.files[filePath];
-            if (file.exports.some((e) => e.toLowerCase().includes(lowerQuery))) {
-                results.push(filePath);
-            }
-        }
-        return results;
-    }
-    /**
-     * Finds files related to a given file (imports/dependents)
-     */
-    async findRelatedFiles(filePath) {
-        if (!this.index) {
-            await this.initialize();
-        }
-        const related = new Set();
-        const node = this.index.dependencyGraph[filePath];
-        if (node) {
-            // Add direct dependencies
-            for (const dep of node.dependencies) {
-                related.add(dep);
-            }
-            // Add direct dependents
-            for (const dep of node.dependents) {
-                related.add(dep);
-            }
-        }
-        return Array.from(related);
-    }
-    /**
-     * Gets files by language
-     */
-    getFilesByLanguage(language) {
-        if (!this.index)
-            return [];
-        return Object.values(this.index.files).filter((f) => f.language === language);
-    }
-    /**
-     * Gets files by extension
-     */
-    getFilesByExtension(extension) {
-        if (!this.index)
-            return [];
-        const ext = extension.startsWith('.') ? extension.slice(1) : extension;
-        return Object.values(this.index.files).filter((f) => f.extension === ext);
-    }
-    /**
-     * Gets all indexed files
-     */
-    getAllFiles() {
-        if (!this.index)
-            return [];
-        return Object.values(this.index.files);
-    }
-    /**
-     * Gets index statistics
-     */
-    getStats() {
-        if (!this.index) {
-            return {
-                totalFiles: 0,
-                totalSize: 0,
-                languageBreakdown: {},
-                lastUpdated: '',
-            };
-        }
-        const languageBreakdown = {};
-        for (const file of Object.values(this.index.files)) {
-            languageBreakdown[file.language] = (languageBreakdown[file.language] || 0) + 1;
-        }
-        return {
-            totalFiles: this.index.totalFiles,
-            totalSize: this.index.totalSize,
-            languageBreakdown,
-            lastUpdated: this.index.updatedAt,
-        };
-    }
-    /**
-     * Clears the index and cache
-     */
-    async clearIndex() {
-        this.index = this.createEmptyIndex();
-        this.fileCache.clear();
-        this.contentCache.clear();
-        if (this.indexPath && await pathExists(this.indexPath)) {
-            const { remove } = await import('../utils/file-system.js');
-            await remove(this.indexPath);
-        }
-        logger.info('Index cleared');
-    }
-    /**
-     * Sets the project root and reinitializes
-     */
-    async setProjectRoot(projectRoot) {
-        this.projectRoot = projectRoot;
-        this.isInitialized = false;
-        this.index = null;
-        this.fileCache.clear();
-        this.contentCache.clear();
-        await this.initialize(projectRoot);
-    }
-}
-// Singleton instance
-let codebaseIndexerInstance = null;
-/**
- * Gets the singleton CodebaseIndexer instance.
- * Creates and initializes the instance on first call.
- *
- * @param projectRoot - Optional project root directory
- * @returns Promise resolving to the CodebaseIndexer instance
- */
-export async function getCodebaseIndexer(projectRoot) {
-    if (!codebaseIndexerInstance) {
-        codebaseIndexerInstance = new CodebaseIndexer(projectRoot);
-        await codebaseIndexerInstance.initialize(projectRoot);
-    }
-    else if (projectRoot && projectRoot !== codebaseIndexerInstance['projectRoot']) {
-        await codebaseIndexerInstance.setProjectRoot(projectRoot);
-    }
-    return codebaseIndexerInstance;
-}
-/**
- * Creates a new CodebaseIndexer instance with the specified project root.
- * Use this when you need a separate instance from the singleton.
- *
- * @param projectRoot - Project root directory
- * @returns A new CodebaseIndexer instance
- */
-export function createCodebaseIndexer(projectRoot) {
-    return new CodebaseIndexer(projectRoot);
-}
-export { CodebaseIndexer, DEFAULT_IGNORE_PATTERNS, EXTENSION_TO_LANGUAGE, BINARY_EXTENSIONS, LRUCache, };
-//# sourceMappingURL=codebase-indexer.js.map