codeseeker 1.4.0

package/dist/mcp/indexing-service.js

@@ -0,0 +1,961 @@
+"use strict";
+/**
+ * Indexing Service for MCP Server
+ *
+ * Provides reusable indexing logic for:
+ * - File indexing with chunking and embeddings
+ * - Knowledge graph building
+ * - Incremental updates
+ *
+ * This service reuses the same indexing logic as the CLI init command.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexingService = void 0;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const crypto = __importStar(require("crypto"));
+const fast_glob_1 = require("fast-glob");
+const storage_1 = require("../storage");
+const embedding_service_1 = require("../cli/services/data/embedding/embedding-service");
+const logger_1 = require("../utils/logger");
+const csharp_parser_1 = require("../cli/services/data/semantic-graph/parsers/csharp-parser");
+const go_parser_1 = require("../cli/services/data/semantic-graph/parsers/go-parser");
+const python_parser_1 = require("../cli/services/data/semantic-graph/parsers/python-parser");
+const java_parser_1 = require("../cli/services/data/semantic-graph/parsers/java-parser");
+class IndexingService {
+    logger = logger_1.Logger.getInstance();
+    embeddingService;
+    // Language-specific parsers for proper AST extraction
+    parsers = {
+        csharp: new csharp_parser_1.CSharpParser(),
+        go: new go_parser_1.GoParser(),
+        python: new python_parser_1.PythonParser(),
+        java: new java_parser_1.JavaParser()
+    };
+    // Map file extensions to parser types
+    extensionToParser = {
+        '.cs': 'csharp',
+        '.go': 'go',
+        '.py': 'python',
+        '.java': 'java'
+    };
+    // Supported file extensions for indexing
+    SUPPORTED_EXTENSIONS = [
+        '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs',
+        '.py', '.java', '.go', '.rs', '.rb', '.php',
+        '.c', '.cpp', '.h', '.hpp', '.cs',
+        '.json', '.yaml', '.yml', '.toml',
+        '.md', '.txt', '.rst',
+    ];
+    // Directories to ignore (must match file-scanner-config.json)
+    IGNORE_DIRS = [
+        // Package managers / dependencies
+        'node_modules', 'vendor', 'packages', 'venv', 'virtualenv', '.venv',
+        // Version control
+        '.git', '.svn', '.hg',
+        // Build outputs
+        'dist', 'build', 'out', 'target', 'bin', 'obj',
+        // Caches
+        '.cache', 'tmp', 'temp', '__pycache__', '.pytest_cache', '.tox',
+        // Test outputs
+        'coverage', '.nyc_output', 'TestReports',
+        // IDE / Editor
+        '.idea', '.vscode', '.vs',
+        // Framework-specific
+        '.next', '.nuxt',
+        // Unity (critical - Library alone can have 35K+ files)
+        'Library', 'Temp', 'Logs', 'UserSettings', 'MemoryCaptures', 'Recordings', 'PackageCache',
+        // Other game engines / platforms
+        'Exec', 'DerivedData', 'Intermediate', 'Saved', 'Binaries'
+    ];
+    constructor() {
+        this.embeddingService = new embedding_service_1.EmbeddingService({
+            provider: 'xenova',
+            model: 'Xenova/all-MiniLM-L6-v2'
+        });
+    }
+    /**
+     * Index a project directory
+     * Creates vector embeddings and knowledge graph nodes/edges
+     */
+    async indexProject(projectPath, projectId, onProgress) {
+        const startTime = Date.now();
+        const errors = [];
+        const progress = {
+            phase: 'scanning',
+            filesTotal: 0,
+            filesProcessed: 0,
+            chunksCreated: 0,
+            nodesCreated: 0,
+            edgesCreated: 0
+        };
+        try {
+            // Get storage manager
+            const storageManager = await (0, storage_1.getStorageManager)();
+            const vectorStore = storageManager.getVectorStore();
+            const graphStore = storageManager.getGraphStore();
+            // Phase 1: Scan for files with progress reporting
+            progress.phase = 'scanning';
+            progress.scanningStatus = { foldersScanned: 0, filesFound: 0, percentage: 0 };
+            onProgress?.(progress);
+            const files = await this.scanForFiles(projectPath, (scanStatus) => {
+                progress.scanningStatus = scanStatus;
+                onProgress?.(progress);
+            });
+            // Check file limits and generate warnings
+            const totalFiles = files.length;
+            progress.filesTotal = Math.min(totalFiles, this.FILE_LIMITS.maxFiles);
+            if (totalFiles > this.FILE_LIMITS.dbServerThreshold) {
+                progress.limitWarning = `⚠️ Large project detected: ${totalFiles.toLocaleString()} files found. ` +
+                    `For projects with 100K+ files, we recommend using DB server mode (PostgreSQL + Neo4j) for optimal performance. ` +
+                    `Run 'codeseeker config --storage=server' to switch. Currently indexing first ${this.FILE_LIMITS.maxFiles.toLocaleString()} files.`;
+            }
+            else if (totalFiles > this.FILE_LIMITS.maxFiles) {
+                progress.limitWarning = `ℹ️ Project has ${totalFiles.toLocaleString()} files. ` +
+                    `Indexing first ${this.FILE_LIMITS.maxFiles.toLocaleString()} files. ` +
+                    `To increase limits, edit .codeseeker/config.json or use DB server mode for very large projects.`;
+            }
+            onProgress?.(progress);
+            if (files.length === 0) {
+                return {
+                    success: true,
+                    filesIndexed: 0,
+                    chunksCreated: 0,
+                    nodesCreated: 0,
+                    edgesCreated: 0,
+                    durationMs: Date.now() - startTime,
+                    errors: ['No indexable files found'],
+                    warnings: []
+                };
+            }
+            // Phase 2: Index files with embeddings
+            progress.phase = 'indexing';
+            onProgress?.(progress);
+            // Apply file limit
+            const filesToIndex = files.slice(0, this.FILE_LIMITS.maxFiles);
+            for (const file of filesToIndex) {
+                try {
+                    const chunksCreated = await this.indexFile(path.join(projectPath, file), file, projectId, vectorStore);
+                    progress.filesProcessed++;
+                    progress.chunksCreated += chunksCreated;
+                    onProgress?.(progress);
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    errors.push(`Failed to index ${file}: ${message}`);
+                    this.logger.debug(`Failed to index ${file}: ${message}`);
+                }
+            }
+            // Phase 3: Build knowledge graph
+            progress.phase = 'graph';
+            onProgress?.(progress);
+            const graphResult = await this.buildKnowledgeGraph(projectPath, projectId, files, graphStore);
+            progress.nodesCreated = graphResult.nodesCreated;
+            progress.edgesCreated = graphResult.edgesCreated;
+            onProgress?.(progress);
+            // Flush to persist
+            await vectorStore.flush();
+            await graphStore.flush();
+            // Phase 4: Complete
+            progress.phase = 'complete';
+            onProgress?.(progress);
+            // Collect any warnings
+            const warnings = [];
+            if (progress.limitWarning) {
+                warnings.push(progress.limitWarning);
+            }
+            return {
+                success: true,
+                filesIndexed: progress.filesProcessed,
+                chunksCreated: progress.chunksCreated,
+                nodesCreated: progress.nodesCreated,
+                edgesCreated: progress.edgesCreated,
+                durationMs: Date.now() - startTime,
+                errors,
+                warnings
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            errors.push(`Indexing failed: ${message}`);
+            return {
+                success: false,
+                filesIndexed: progress.filesProcessed,
+                chunksCreated: progress.chunksCreated,
+                nodesCreated: progress.nodesCreated,
+                edgesCreated: progress.edgesCreated,
+                durationMs: Date.now() - startTime,
+                errors,
+                warnings: progress.limitWarning ? [progress.limitWarning] : []
+            };
+        }
+    }
+    /**
+     * Index a single file (for incremental updates)
+     * Uses two-stage change detection for maximum speed:
+     * 1. mtime check (~0.1ms) - if file not modified since indexing, skip
+     * 2. hash check (~1-5ms) - if mtime changed but content same, skip
+     * 3. reindex (~100-500ms) - only if content actually changed
+     */
+    async indexSingleFile(projectPath, relativePath, projectId, options) {
+        try {
+            const storageManager = await (0, storage_1.getStorageManager)();
+            const vectorStore = storageManager.getVectorStore();
+            const graphStore = storageManager.getGraphStore();
+            const absolutePath = path.join(projectPath, relativePath);
+            // Two-stage change detection (unless forced)
+            if (!options?.forceReindex) {
+                // Stage 1: Fast mtime check (~0.1ms)
+                const stats = fs.statSync(absolutePath);
+                const fileMtime = stats.mtime;
+                const storedMetadata = await vectorStore.getFileMetadata(projectId, relativePath);
+                if (storedMetadata) {
+                    const indexedAt = new Date(storedMetadata.indexedAt);
+                    // If file hasn't been modified since indexing, skip entirely
+                    if (fileMtime <= indexedAt) {
+                        this.logger.debug(`Skipping ${relativePath} - mtime unchanged`);
+                        return { success: true, chunksCreated: 0, skipped: true, skipReason: 'mtime' };
+                    }
+                    // Stage 2: mtime changed, check hash (~1-5ms)
+                    const content = fs.readFileSync(absolutePath, 'utf-8');
+                    const currentHash = crypto.createHash('md5').update(content).digest('hex');
+                    if (storedMetadata.fileHash === currentHash) {
+                        this.logger.debug(`Skipping ${relativePath} - content unchanged (hash match)`);
+                        return { success: true, chunksCreated: 0, skipped: true, skipReason: 'hash' };
+                    }
+                }
+            }
+            // File changed or new - delete existing embeddings and reindex
+            await this.deleteFileEmbeddings(projectId, relativePath, vectorStore);
+            // Re-index the file for vector search
+            const chunksCreated = await this.indexFile(absolutePath, relativePath, projectId, vectorStore);
+            // Also update the knowledge graph for this file
+            const nodesCreated = await this.indexFileToGraph(projectPath, relativePath, projectId, graphStore);
+            await vectorStore.flush();
+            await graphStore.flush();
+            return { success: true, chunksCreated, nodesCreated, skipped: false };
+        }
+        catch (error) {
+            this.logger.debug(`Failed to index ${relativePath}: ${error}`);
+            return { success: false, chunksCreated: 0 };
+        }
+    }
+    /**
+     * Index a single file to the knowledge graph
+     */
+    async indexFileToGraph(projectPath, relativePath, projectId, graphStore) {
+        const nodes = [];
+        const edges = [];
+        try {
+            const absolutePath = path.join(projectPath, relativePath);
+            const content = fs.readFileSync(absolutePath, 'utf-8');
+            // Create file node
+            const fileNodeId = `file-${projectId}-${relativePath.replace(/[\/\\]/g, '-')}`;
+            nodes.push({
+                id: fileNodeId,
+                type: 'file',
+                name: path.basename(relativePath),
+                filePath: absolutePath,
+                projectId,
+                properties: { relativePath }
+            });
+            // Link file to project root
+            const projectNodeId = `project-${projectId}`;
+            edges.push({
+                id: `contains-${projectNodeId}-${fileNodeId}`,
+                source: projectNodeId,
+                target: fileNodeId,
+                type: 'contains'
+            });
+            // Extract code elements using language-specific parser
+            const codeElements = await this.extractCodeElementsAsync(content, relativePath, projectId);
+            for (const element of codeElements) {
+                nodes.push({
+                    id: element.id,
+                    type: element.type,
+                    name: element.name,
+                    filePath: absolutePath,
+                    projectId,
+                    properties: { relativePath, lineNumber: element.line }
+                });
+                // Link element to file
+                edges.push({
+                    id: `contains-${fileNodeId}-${element.id}`,
+                    source: fileNodeId,
+                    target: element.id,
+                    type: 'contains'
+                });
+            }
+            // Extract import relationships (scan all project files for context)
+            const allFiles = await this.scanForFiles(projectPath);
+            const imports = this.extractImports(content, relativePath, projectId, allFiles);
+            edges.push(...imports);
+            // Upsert nodes and edges
+            if (nodes.length > 0) {
+                await graphStore.upsertNodes(nodes);
+            }
+            if (edges.length > 0) {
+                await graphStore.upsertEdges(edges);
+            }
+            return nodes.length;
+        }
+        catch (error) {
+            this.logger.debug(`Failed to index ${relativePath} to graph: ${error}`);
+            return 0;
+        }
+    }
+    /**
+     * Delete a file from the index
+     */
+    async deleteFile(projectId, relativePath) {
+        try {
+            const storageManager = await (0, storage_1.getStorageManager)();
+            const vectorStore = storageManager.getVectorStore();
+            const graphStore = storageManager.getGraphStore();
+            // Delete vector embeddings
+            const vectorsDeleted = await this.deleteFileEmbeddings(projectId, relativePath, vectorStore);
+            // Delete graph nodes for this file
+            const nodesDeleted = await this.deleteFileGraphNodes(projectId, relativePath, graphStore);
+            await vectorStore.flush();
+            await graphStore.flush();
+            return { success: true, deleted: vectorsDeleted + nodesDeleted };
+        }
+        catch (error) {
+            this.logger.debug(`Failed to delete ${relativePath}: ${error}`);
+            return { success: false, deleted: 0 };
+        }
+    }
+    // File limits configuration
+    FILE_LIMITS = {
+        /** Maximum files to index (embedded mode). Increase for DB server mode. */
+        maxFiles: 50000,
+        /** Threshold to suggest DB server mode */
+        dbServerThreshold: 100000,
+        /** Files for knowledge graph: source folders */
+        graphSourceFiles: 30000,
+        /** Files for knowledge graph: other code */
+        graphOtherCode: 15000,
+        /** Files for knowledge graph: config/docs */
+        graphConfigFiles: 5000
+    };
+    /**
+     * Load user-defined exclusions from .codeseeker/exclusions.json
+     */
+    loadUserExclusions(projectPath) {
+        const exclusionsPath = path.join(projectPath, '.codeseeker', 'exclusions.json');
+        if (!fs.existsSync(exclusionsPath)) {
+            return [];
+        }
+        try {
+            const content = fs.readFileSync(exclusionsPath, 'utf-8');
+            const exclusions = JSON.parse(content);
+            if (exclusions.patterns && Array.isArray(exclusions.patterns)) {
+                return exclusions.patterns.map((p) => p.pattern);
+            }
+        }
+        catch (error) {
+            this.logger.debug(`Failed to load user exclusions: ${error}`);
+        }
+        return [];
+    }
+    /**
+     * Check if a file matches any user exclusion pattern
+     */
+    matchesUserExclusion(filePath, exclusionPatterns) {
+        if (exclusionPatterns.length === 0) {
+            return false;
+        }
+        const normalizedPath = filePath.replace(/\\/g, '/').toLowerCase();
+        for (const pattern of exclusionPatterns) {
+            const normalizedPattern = pattern.replace(/\\/g, '/').toLowerCase();
+            // Direct match
+            if (normalizedPath === normalizedPattern) {
+                return true;
+            }
+            // Convert glob pattern to regex
+            let regexPattern = normalizedPattern
+                .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+                .replace(/\*\*/g, '<<GLOBSTAR>>')
+                .replace(/\*/g, '[^/]*')
+                .replace(/<<GLOBSTAR>>/g, '.*')
+                .replace(/\?/g, '.');
+            // Pattern matching at start or after /
+            if (!regexPattern.startsWith('.*')) {
+                regexPattern = `(^|/)${regexPattern}`;
+            }
+            regexPattern = `${regexPattern}(/.*)?$`;
+            try {
+                const regex = new RegExp(regexPattern);
+                if (regex.test(normalizedPath)) {
+                    return true;
+                }
+            }
+            catch {
+                // Fallback to simple includes check
+                if (normalizedPath.includes(normalizedPattern.replace(/\*/g, ''))) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    /**
+     * Scan for indexable files in a directory
+     * Reports progress during scanning via callback
+     * Respects user-defined exclusions from .codeseeker/exclusions.json
+     */
+    async scanForFiles(projectPath, onProgress) {
+        const patterns = this.SUPPORTED_EXTENSIONS.map(ext => `**/*${ext}`);
+        // Build comprehensive ignore patterns:
+        // - `dir/**` matches top-level directory
+        // - `**/dir/**` matches nested directories
+        const ignorePatterns = this.IGNORE_DIRS.flatMap(dir => [
+            `${dir}/**`, // Top-level: Library/**, Temp/**, etc.
+            `**/${dir}/**` // Nested: foo/Library/**, src/Temp/**, etc.
+        ]);
+        // Load user-defined exclusions
+        const userExclusions = this.loadUserExclusions(projectPath);
+        // Track unique folders for progress reporting
+        const foldersScanned = new Set();
+        let filesFound = 0;
+        const files = await (0, fast_glob_1.glob)(patterns, {
+            cwd: projectPath,
+            ignore: ignorePatterns,
+            onlyFiles: true,
+            followSymbolicLinks: false
+        });
+        // Double-check: filter out any files that slipped through
+        // (glob patterns can sometimes miss edge cases)
+        const excludedDirSet = new Set(this.IGNORE_DIRS.map(d => d.toLowerCase()));
+        let filteredFiles = files.filter(file => {
+            const pathParts = file.replace(/\\/g, '/').toLowerCase().split('/');
+            return !pathParts.some(part => excludedDirSet.has(part));
+        });
+        // Apply user-defined exclusions
+        if (userExclusions.length > 0) {
+            const beforeCount = filteredFiles.length;
+            filteredFiles = filteredFiles.filter(file => !this.matchesUserExclusion(file, userExclusions));
+            const excludedCount = beforeCount - filteredFiles.length;
+            if (excludedCount > 0) {
+                this.logger.debug(`User exclusions filtered out ${excludedCount} files`);
+            }
+        }
+        // Report progress by analyzing discovered files
+        if (onProgress) {
+            for (const file of filteredFiles) {
+                const folder = path.dirname(file);
+                if (!foldersScanned.has(folder)) {
+                    foldersScanned.add(folder);
+                    // Report progress every 10 new folders
+                    if (foldersScanned.size % 10 === 0) {
+                        onProgress({
+                            foldersScanned: foldersScanned.size,
+                            filesFound: filesFound,
+                            currentFolder: folder,
+                            percentage: 100 // Scanning complete, just counting
+                        });
+                    }
+                }
+                filesFound++;
+            }
+            // Final progress report
+            onProgress({
+                foldersScanned: foldersScanned.size,
+                filesFound: filteredFiles.length,
+                percentage: 100
+            });
+        }
+        return filteredFiles;
+    }
+    /**
+     * Index a single file with chunking and embeddings
+     */
+    async indexFile(absolutePath, relativePath, projectId, vectorStore) {
+        const content = fs.readFileSync(absolutePath, 'utf-8');
+        // Skip very small files
+        if (content.length < 50) {
+            return 0;
+        }
+        // Chunk the file content
+        const chunks = this.chunkContent(content);
+        // Generate embeddings for each chunk
+        const fileHash = crypto.createHash('md5').update(content).digest('hex');
+        let chunksCreated = 0;
+        for (let chunkIndex = 0; chunkIndex < chunks.length; chunkIndex++) {
+            const chunk = chunks[chunkIndex];
+            try {
+                // Generate embedding vector
+                const embeddingVector = await this.embeddingService.generateEmbedding(chunk.content, relativePath);
+                // Create document ID: projectId:filePath:chunkIndex
+                const docId = `${projectId}:${relativePath}:${chunkIndex}`;
+                await vectorStore.upsert({
+                    id: docId,
+                    projectId,
+                    filePath: relativePath,
+                    content: chunk.content,
+                    embedding: embeddingVector,
+                    metadata: {
+                        fileName: path.basename(relativePath),
+                        extension: path.extname(relativePath),
+                        chunkIndex,
+                        lineStart: chunk.lineStart,
+                        lineEnd: chunk.lineEnd,
+                        fileHash,
+                        indexedAt: new Date().toISOString()
+                    }
+                });
+                chunksCreated++;
+            }
+            catch (error) {
+                this.logger.debug(`Failed to create embedding for chunk ${chunkIndex} of ${relativePath}: ${error}`);
+            }
+        }
+        return chunksCreated;
+    }
+    /**
+     * Chunk file content into smaller pieces for better search granularity
+     */
+    chunkContent(content) {
+        const lines = content.split('\n');
+        const chunks = [];
+        const CHUNK_SIZE = 25; // lines per chunk
+        const OVERLAP = 5; // overlapping lines for context
+        for (let i = 0; i < lines.length; i += (CHUNK_SIZE - OVERLAP)) {
+            const chunkLines = lines.slice(i, i + CHUNK_SIZE);
+            const chunkContent = chunkLines.join('\n');
+            // Only include chunks with meaningful content
+            if (chunkContent.trim().length > 30) {
+                chunks.push({
+                    content: chunkContent,
+                    lineStart: i + 1,
+                    lineEnd: Math.min(i + CHUNK_SIZE, lines.length)
+                });
+            }
+        }
+        return chunks;
+    }
+    /**
+     * Build knowledge graph for the project
+     */
+    async buildKnowledgeGraph(projectPath, projectId, files, graphStore) {
+        const nodes = [];
+        const edges = [];
+        // Create project root node
+        const projectNodeId = `project-${projectId}`;
+        nodes.push({
+            id: projectNodeId,
+            type: 'file',
+            name: path.basename(projectPath),
+            filePath: projectPath,
+            projectId,
+            properties: { isProjectRoot: true }
+        });
+        // Limit files for performance (prioritize source code folders)
+        // Support multiple common source folder patterns: src/, Assets/Scripts/ (Unity), app/, lib/
+        const sourcePatterns = ['src/', 'src\\', 'Assets/Scripts/', 'Assets\\Scripts\\', 'app/', 'app\\', 'lib/', 'lib\\'];
+        const sourceFiles = files.filter(f => sourcePatterns.some(p => f.startsWith(p)));
+        const otherCodeFiles = files.filter(f => !sourcePatterns.some(p => f.startsWith(p)) &&
+            ['.ts', '.tsx', '.js', '.jsx', '.py', '.java', '.go', '.cs', '.rs', '.rb', '.php', '.c', '.cpp'].some(ext => f.endsWith(ext)));
+        const configFiles = files.filter(f => !sourcePatterns.some(p => f.startsWith(p)) &&
+            ['.json', '.yaml', '.yml', '.toml', '.md'].some(ext => f.endsWith(ext)));
+        // Prioritize: source folders > other code > config
+        // Use configurable limits for large project support
+        const totalGraphLimit = this.FILE_LIMITS.graphSourceFiles + this.FILE_LIMITS.graphOtherCode + this.FILE_LIMITS.graphConfigFiles;
+        const filesToProcess = [
+            ...sourceFiles.slice(0, this.FILE_LIMITS.graphSourceFiles),
+            ...otherCodeFiles.slice(0, this.FILE_LIMITS.graphOtherCode),
+            ...configFiles.slice(0, this.FILE_LIMITS.graphConfigFiles)
+        ].slice(0, totalGraphLimit);
+        for (const file of filesToProcess) {
+            try {
+                const absolutePath = path.join(projectPath, file);
+                const content = fs.readFileSync(absolutePath, 'utf-8');
+                // Create file node
+                const fileNodeId = `file-${projectId}-${file.replace(/[\/\\]/g, '-')}`;
+                nodes.push({
+                    id: fileNodeId,
+                    type: 'file',
+                    name: path.basename(file),
+                    filePath: absolutePath,
+                    projectId,
+                    properties: { relativePath: file }
+                });
+                // Link file to project
+                edges.push({
+                    id: `contains-${projectNodeId}-${fileNodeId}`,
+                    source: projectNodeId,
+                    target: fileNodeId,
+                    type: 'contains'
+                });
+                // Extract code elements using language-specific parser
+                const codeElements = await this.extractCodeElementsAsync(content, file, projectId);
+                for (const element of codeElements) {
+                    nodes.push({
+                        id: element.id,
+                        type: element.type,
+                        name: element.name,
+                        filePath: absolutePath,
+                        projectId,
+                        properties: { relativePath: file, lineNumber: element.line }
+                    });
+                    // Link element to file
+                    edges.push({
+                        id: `contains-${fileNodeId}-${element.id}`,
+                        source: fileNodeId,
+                        target: element.id,
+                        type: 'contains'
+                    });
+                }
+                // Extract import relationships
+                const imports = this.extractImports(content, file, projectId, filesToProcess);
+                edges.push(...imports);
+            }
+            catch (error) {
+                this.logger.debug(`Failed to process graph for ${file}: ${error}`);
+            }
+        }
+        // Batch insert nodes and edges
+        if (nodes.length > 0) {
+            await graphStore.upsertNodes(nodes);
+        }
+        if (edges.length > 0) {
+            await graphStore.upsertEdges(edges);
+        }
+        return {
+            nodesCreated: nodes.length,
+            edgesCreated: edges.length
+        };
+    }
+    /**
+     * Extract code elements (classes, functions) from file content
+     * Uses language-specific parsers for C#, Go, Python, Java
+     * Falls back to generic regex for JS/TS
+     */
+    async extractCodeElementsAsync(content, file, projectId) {
+        const elements = [];
+        const ext = path.extname(file).toLowerCase();
+        const parserType = this.extensionToParser[ext];
+        // Use language-specific parser if available
+        if (parserType && this.parsers[parserType]) {
+            try {
+                const parser = this.parsers[parserType];
+                const absolutePath = file; // Will be resolved by caller
+                const parsed = await parser.parse(content, absolutePath);
+                // Extract classes
+                for (const cls of parsed.classes) {
+                    elements.push({
+                        id: `class-${projectId}-${file.replace(/[\/\\]/g, '-')}-${cls.name}`,
+                        type: 'class',
+                        name: cls.name,
+                        line: 1 // Line info not available from parser, could be enhanced
+                    });
+                    // Extract methods from classes (limit to 20 per class)
+                    for (const method of cls.methods.slice(0, 20)) {
+                        elements.push({
+                            id: `function-${projectId}-${file.replace(/[\/\\]/g, '-')}-${cls.name}-${method}`,
+                            type: 'function',
+                            name: `${cls.name}.${method}`,
+                            line: 1
+                        });
+                    }
+                }
+                // Extract standalone functions
+                for (const func of parsed.functions.slice(0, 30)) {
+                    elements.push({
+                        id: `function-${projectId}-${file.replace(/[\/\\]/g, '-')}-${func.name}`,
+                        type: 'function',
+                        name: func.name,
+                        line: 1
+                    });
+                }
+                // Extract interfaces (as class-like elements)
+                for (const iface of parsed.interfaces) {
+                    elements.push({
+                        id: `class-${projectId}-${file.replace(/[\/\\]/g, '-')}-${iface}`,
+                        type: 'class',
+                        name: iface,
+                        line: 1
+                    });
+                }
+                return elements;
+            }
+            catch (error) {
+                this.logger.debug(`Parser failed for ${file}, falling back to regex: ${error}`);
+            }
+        }
+        // Fallback: generic regex parsing for JS/TS and unsupported languages
+        return this.extractCodeElementsRegex(content, file, projectId);
+    }
+    /**
+     * Regex-based extraction for JS/TS and fallback
+     * Also handles C# with specialized regex patterns
+     */
+    extractCodeElementsRegex(content, file, projectId) {
+        const elements = [];
+        const lines = content.split('\n');
+        const ext = path.extname(file).toLowerCase();
+        // Use C#-aware regex for .cs files
+        if (ext === '.cs') {
+            const classRegex = /(?:public\s+|private\s+|protected\s+|internal\s+)?(?:abstract\s+|sealed\s+|static\s+|partial\s+)*(?:class|struct|interface)\s+(\w+)/g;
+            const methodRegex = /(?:public\s+|private\s+|protected\s+|internal\s+)?(?:virtual\s+|override\s+|abstract\s+|static\s+|async\s+)*(?:[\w<>\[\],\s]+)\s+(\w+)\s*\([^)]*\)\s*[{;]/g;
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                let match;
+                classRegex.lastIndex = 0;
+                while ((match = classRegex.exec(line)) !== null) {
+                    const className = match[1];
+                    if (className && className.length > 1) {
+                        elements.push({
+                            id: `class-${projectId}-${file.replace(/[\/\\]/g, '-')}-${className}`,
+                            type: 'class',
+                            name: className,
+                            line: i + 1
+                        });
+                    }
+                }
+                // Limit methods per file
+                if (elements.filter(e => e.type === 'function').length < 50) {
+                    methodRegex.lastIndex = 0;
+                    while ((match = methodRegex.exec(line)) !== null) {
+                        const methodName = match[1];
+                        if (methodName && methodName.length > 1 &&
+                            !['if', 'for', 'while', 'switch', 'foreach', 'catch', 'using', 'lock', 'get', 'set'].includes(methodName)) {
+                            elements.push({
+                                id: `function-${projectId}-${file.replace(/[\/\\]/g, '-')}-${methodName}`,
+                                type: 'function',
+                                name: methodName,
+                                line: i + 1
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        else {
+            // Generic JS/TS regex
+            const classRegex = /class\s+(\w+)/g;
+            const functionRegex = /(?:function\s+(\w+)|(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?(?:\([^)]*\)|[^=]*?)\s*=>|(\w+)\s*\([^)]*\)\s*{)/g;
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                let match;
+                classRegex.lastIndex = 0;
+                while ((match = classRegex.exec(line)) !== null) {
+                    const className = match[1];
+                    if (className && className.length > 1) {
+                        elements.push({
+                            id: `class-${projectId}-${file.replace(/[\/\\]/g, '-')}-${className}`,
+                            type: 'class',
+                            name: className,
+                            line: i + 1
+                        });
+                    }
+                }
+                // Limit functions per file
+                if (elements.filter(e => e.type === 'function').length < 30) {
+                    functionRegex.lastIndex = 0;
+                    while ((match = functionRegex.exec(line)) !== null) {
+                        const funcName = match[1] || match[2] || match[3];
+                        if (funcName && funcName.length > 2 && !['if', 'for', 'while', 'switch'].includes(funcName)) {
+                            elements.push({
+                                id: `function-${projectId}-${file.replace(/[\/\\]/g, '-')}-${funcName}`,
+                                type: 'function',
+                                name: funcName,
+                                line: i + 1
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        return elements;
+    }
+    /**
+     * Extract import relationships from file content
+     * Supports: JS/TS imports, require(), C# using statements
+     */
+    extractImports(content, sourceFile, projectId, allFiles) {
+        const edges = [];
+        const sourceFileNodeId = `file-${projectId}-${sourceFile.replace(/[\/\\]/g, '-')}`;
+        const ext = path.extname(sourceFile).toLowerCase();
+        let match;
+        // C# using statements - link to files in same namespace
+        if (ext === '.cs') {
+            const usingRegex = /using\s+([\w.]+);/g;
+            const namespaceMap = this.buildNamespaceMap(allFiles, projectId);
+            while ((match = usingRegex.exec(content)) !== null) {
+                const namespace = match[1];
+                // Skip System namespaces
+                if (namespace.startsWith('System') || namespace.startsWith('UnityEngine') || namespace.startsWith('UnityEditor')) {
+                    continue;
+                }
+                // Find files in this namespace
+                const filesInNamespace = namespaceMap.get(namespace) || [];
+                for (const targetFile of filesInNamespace) {
+                    if (targetFile !== sourceFile) {
+                        const targetFileNodeId = `file-${projectId}-${targetFile.replace(/[\/\\]/g, '-')}`;
+                        edges.push({
+                            id: `imports-${sourceFileNodeId}-${targetFileNodeId}`,
+                            source: sourceFileNodeId,
+                            target: targetFileNodeId,
+                            type: 'imports'
+                        });
+                    }
+                }
+            }
+        }
+        else {
+            // JS/TS imports and require()
+            const importRegex = /import\s+(?:{[^}]+}|\*\s+as\s+\w+|\w+)\s+from\s+['"]([^'"]+)['"]/g;
+            const requireRegex = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+            const processImport = (importPath) => {
+                // Skip node_modules imports
+                if (!importPath.startsWith('.') && !importPath.startsWith('/')) {
+                    return;
+                }
+                // Resolve relative path
+                const sourceDir = path.dirname(sourceFile);
+                let resolvedPath = path.join(sourceDir, importPath).replace(/\\/g, '/');
+                // Add extension if missing
+                if (!path.extname(resolvedPath)) {
+                    const extensions = ['.ts', '.tsx', '.js', '.jsx'];
+                    for (const ext of extensions) {
+                        const withExt = resolvedPath + ext;
+                        if (allFiles.includes(withExt)) {
+                            resolvedPath = withExt;
+                            break;
+                        }
+                    }
+                }
+                // Check if target file exists in project
+                if (allFiles.includes(resolvedPath)) {
+                    const targetFileNodeId = `file-${projectId}-${resolvedPath.replace(/[\/\\]/g, '-')}`;
+                    edges.push({
+                        id: `imports-${sourceFileNodeId}-${targetFileNodeId}`,
+                        source: sourceFileNodeId,
+                        target: targetFileNodeId,
+                        type: 'imports'
+                    });
+                }
+            };
+            while ((match = importRegex.exec(content)) !== null) {
+                processImport(match[1]);
+            }
+            while ((match = requireRegex.exec(content)) !== null) {
+                processImport(match[1]);
+            }
+        }
+        return edges;
+    }
+    /**
+     * Build a map of namespace -> files for C# projects
+     * This is cached per indexing run for performance
+     */
+    namespaceMapCache = null;
+    buildNamespaceMap(allFiles, _projectId) {
+        // Return cached map if available (reset between indexing runs)
+        if (this.namespaceMapCache) {
+            return this.namespaceMapCache;
+        }
+        const namespaceMap = new Map();
+        const csFiles = allFiles.filter(f => f.endsWith('.cs'));
+        // For performance, only scan first 200 C# files for namespace detection
+        for (const file of csFiles.slice(0, 200)) {
+            try {
+                // Infer namespace from file path (common Unity/C# convention)
+                // Assets/Scripts/UI/MenuScreen.cs -> Project.UI
+                const pathParts = file.replace(/\\/g, '/').split('/');
+                const scriptsIndex = pathParts.findIndex(p => p.toLowerCase() === 'scripts');
+                if (scriptsIndex >= 0 && pathParts.length > scriptsIndex + 1) {
+                    // Build namespace from path after Scripts/
+                    const namespaceParts = pathParts.slice(scriptsIndex + 1, -1); // Exclude filename
+                    if (namespaceParts.length > 0) {
+                        const namespace = namespaceParts.join('.');
+                        const existing = namespaceMap.get(namespace) || [];
+                        existing.push(file);
+                        namespaceMap.set(namespace, existing);
+                    }
+                }
+            }
+            catch {
+                // Skip files that can't be processed
+            }
+        }
+        this.namespaceMapCache = namespaceMap;
+        return namespaceMap;
+    }
+    /**
+     * Delete embeddings for a specific file
+     */
+    async deleteFileEmbeddings(projectId, relativePath, vectorStore) {
+        // Search for documents with this file path and delete them
+        // The document IDs are formatted as: projectId:filePath:chunkIndex
+        const results = await vectorStore.searchByText(relativePath, projectId, 100);
+        let deleted = 0;
+        for (const result of results) {
+            if (result.document.filePath === relativePath) {
+                await vectorStore.delete(result.document.id);
+                deleted++;
+            }
+        }
+        return deleted;
+    }
+    /**
+     * Delete graph nodes for a specific file
+     */
+    async deleteFileGraphNodes(projectId, relativePath, graphStore) {
+        // Note: IGraphStore doesn't support individual node/edge deletion
+        // Graph nodes for deleted files will be cleaned up on next full reindex
+        // This is a limitation of the current storage abstraction
+        const fileNodeId = `file-${projectId}-${relativePath.replace(/[\/\\]/g, '-')}`;
+        try {
+            // Check if the node exists (for logging purposes)
+            const node = await graphStore.getNode(fileNodeId);
+            if (node) {
+                this.logger.debug(`Graph node for ${relativePath} exists but individual deletion not supported. ` +
+                    `Will be cleaned up on next full reindex.`);
+                // Count edges for informational purposes
+                const edges = await graphStore.getEdges(fileNodeId, 'both');
+                return 1 + edges.length; // Return count of what would be deleted
+            }
+        }
+        catch (error) {
+            this.logger.debug(`Failed to check graph nodes for ${relativePath}: ${error}`);
+        }
+        return 0;
+    }
+}
+exports.IndexingService = IndexingService;
+//# sourceMappingURL=indexing-service.js.map