@compass-ai/nova 1.0.72 → 1.0.74

package/dist/services/codebase-indexer.js

@@ -0,0 +1,863 @@
+/**
+ * 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