graph-indexer 1.0.2 → 1.1.0

package/init.mjs

@@ -18,18 +18,42 @@
 import fs from 'fs';
 import path from 'path';
 import os from 'os';
+import readline from 'readline';
 import { fileURLToPath } from 'url';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const isDryRun = process.argv.includes('--dry-run');
+const isAllLanguages = process.argv.includes('--all-languages');
 const PROJECT_ROOT = process.cwd();
 
-// ─── MCP Server config block ──────────────────────────────────────────────────
+// ─── Language Registry ────────────────────────────────────────────────────────
+
+const LANGUAGES = [
+    { key: 'typescript', label: 'TypeScript / TSX', exts: '.ts, .tsx' },
+    { key: 'javascript', label: 'JavaScript', exts: '.js, .jsx, .mjs, .cjs' },
+    { key: 'python', label: 'Python', exts: '.py' },
+    { key: 'go', label: 'Go', exts: '.go' },
+    { key: 'rust', label: 'Rust', exts: '.rs' },
+    { key: 'php', label: 'PHP', exts: '.php' },
+    { key: 'java', label: 'Java', exts: '.java' },
+    { key: 'kotlin', label: 'Kotlin', exts: '.kt, .kts' },
+    { key: 'csharp', label: 'C#', exts: '.cs' },
+    { key: 'ruby', label: 'Ruby', exts: '.rb' },
+    { key: 'css', label: 'CSS / SCSS', exts: '.css, .scss' },
+];
+
+// ─── MCP Server config blocks ─────────────────────────────────────────────────
 
 const SERVER_CONFIG = {
-    command: 'node',
-    args: [path.join(PROJECT_ROOT, 'node_modules', 'graph-indexer', 'mcp-server.mjs')],
-    env: { MCP_PROJECT_ROOT: PROJECT_ROOT }
+    command: 'npm',
+    args: ['run', 'mcp:start'],
+    env: { MCP_PROJECT_ROOT: PROJECT_ROOT },
+};
+
+const SERVER_CONFIG_GLOBAL = {
+    command: 'npm',
+    args: ['run', '--prefix', PROJECT_ROOT, 'mcp:start'],
+    env: { MCP_PROJECT_ROOT: PROJECT_ROOT },
 };
 
 // ─── Utilities ────────────────────────────────────────────────────────────────
@@ -37,44 +61,120 @@ const SERVER_CONFIG = {
 function log(msg) { process.stdout.write(msg + '\n'); }
 
 function writeFile(filePath, content) {
-    if (isDryRun) {
-        log(`  [dry-run] Would write: ${filePath}`);
-        return;
-    }
+    if (isDryRun) { log(`  [dry-run] Would write: ${filePath}`); return; }
     fs.mkdirSync(path.dirname(filePath), { recursive: true });
     fs.writeFileSync(filePath, content, 'utf-8');
 }
 
 function readJsonSafe(filePath) {
     try {
-        if (fs.existsSync(filePath)) {
-            return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
-        }
+        if (fs.existsSync(filePath)) return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
     } catch { /* malformed JSON — start fresh */ }
     return null;
 }
 
-/** Deep-merge src into dst without duplicating top-level keys. */
-function mergeJson(dst, src) {
-    for (const [k, v] of Object.entries(src)) {
-        if (dst[k] && typeof dst[k] === 'object' && !Array.isArray(dst[k]) && typeof v === 'object' && !Array.isArray(v)) {
-            mergeJson(dst[k], v);
-        } else {
-            dst[k] = v;
-        }
+// ─── Interactive Language Selection ───────────────────────────────────────────
+
+function selectLanguages() {
+    return new Promise((resolve) => {
+        if (isAllLanguages || !process.stdin.isTTY) return resolve(null);
+
+        const { stdin, stdout } = process;
+        readline.emitKeypressEvents(stdin);
+        stdin.setRawMode(true);
+        stdout.write('\x1B[?25l');
+
+        let cursorIndex = 0;
+        const selected = new Set();
+        let hasRendered = false;
+
+        const render = () => {
+            if (hasRendered) {
+                readline.moveCursor(stdout, 0, -(LANGUAGES.length + 2));
+                readline.cursorTo(stdout, 0);
+                readline.clearScreenDown(stdout);
+            }
+            hasRendered = true;
+
+            stdout.write('⚙️  Select languages (Arrows/Tab: move, Space: toggle, Enter: confirm):\n\n');
+
+            LANGUAGES.forEach((lang, i) => {
+                const isHovered = i === cursorIndex;
+                const isSelected = selected.has(i);
+
+                const prefix = isHovered ? '❯' : ' ';
+                const checkbox = isSelected ? '◉' : '◯';
+
+                const line = `  ${prefix} ${checkbox} ${lang.label.padEnd(20)} ${lang.exts}\n`;
+                stdout.write(isHovered ? `\x1b[36m${line}\x1b[0m` : line);
+            });
+        };
+
+        const cleanup = () => {
+            stdin.setRawMode(false);
+            stdout.write('\x1B[?25h');
+            stdin.removeListener('keypress', onKeypress);
+        };
+
+        const onKeypress = (str, key) => {
+            if (key.ctrl && key.name === 'c') {
+                cleanup();
+                process.exit(0);
+            }
+
+            if (key.name === 'up' || (key.name === 'tab' && key.shift)) {
+                cursorIndex = (cursorIndex - 1 + LANGUAGES.length) % LANGUAGES.length;
+                render();
+            } else if (key.name === 'down' || (key.name === 'tab' && !key.shift)) {
+                cursorIndex = (cursorIndex + 1) % LANGUAGES.length;
+                render();
+            } else if (key.name === 'space') {
+                if (selected.has(cursorIndex)) selected.delete(cursorIndex);
+                else selected.add(cursorIndex);
+                render();
+            } else if (key.name === 'return') {
+                cleanup();
+                readline.moveCursor(stdout, 0, -(LANGUAGES.length + 2));
+                readline.cursorTo(stdout, 0);
+                readline.clearScreenDown(stdout);
+
+                if (selected.size === 0) {
+                    resolve(null); // Enable all languages by default
+                } else {
+                    resolve(Array.from(selected).map(i => LANGUAGES[i].key));
+                }
+            }
+        };
+
+        stdin.on('keypress', onKeypress);
+        render();
+    });
+}
+
+function saveLanguageConfig(languages) {
+    const configPath = path.join(PROJECT_ROOT, '.graph-indexer.json');
+    if (isDryRun) {
+        if (languages) log(`  [dry-run] Would write: ${configPath}`);
+        return;
+    }
+    const existing = readJsonSafe(configPath) || {};
+    if (!languages) {
+        delete existing.languages;
+    } else {
+        existing.languages = languages;
+    }
+    if (languages || Object.keys(existing).length > 0) {
+        fs.writeFileSync(configPath, JSON.stringify(existing, null, 2) + '\n', 'utf-8');
     }
-    return dst;
 }
 
 // ─── IDE Detectors & Configurators ───────────────────────────────────────────
 
 function configureVSCode() {
-    const vscodeDir = path.join(PROJECT_ROOT, '.vscode');
-    const configPath = path.join(vscodeDir, 'mcp.json');
-
+    const configPath = path.join(PROJECT_ROOT, '.vscode', 'mcp.json');
     const existing = readJsonSafe(configPath) || {};
     if (!existing.servers) existing.servers = {};
-    if (existing.servers['graph-indexer']) return false; // already configured
+    if (existing.servers['graph-indexer']) return false;
 
     existing.servers['graph-indexer'] = SERVER_CONFIG;
     writeFile(configPath, JSON.stringify(existing, null, 2) + '\n');
@@ -82,15 +182,7 @@ function configureVSCode() {
 }
 
 function configureCursor() {
-    // Check both project-level and global Cursor config
-    const candidates = [
-        path.join(PROJECT_ROOT, '.cursor', 'mcp.json'),
-        path.join(os.homedir(), '.cursor', 'mcp.json'),
-    ];
-    const detected = candidates.some(p => fs.existsSync(path.dirname(p)));
-
-    // Prefer project-level config
-    const configPath = candidates[0];
+    const configPath = path.join(PROJECT_ROOT, '.cursor', 'mcp.json');
     const existing = readJsonSafe(configPath) || {};
     if (!existing.mcpServers) existing.mcpServers = {};
     if (existing.mcpServers['graph-indexer']) return false;
@@ -108,34 +200,28 @@ function configureClaudeDesktop() {
         configPath = path.join(os.homedir(), 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
     }
 
-    if (!fs.existsSync(path.dirname(configPath))) return false; // Claude not installed
+    if (!fs.existsSync(path.dirname(configPath))) return false;
 
     const existing = readJsonSafe(configPath) || {};
     if (!existing.mcpServers) existing.mcpServers = {};
     if (existing.mcpServers['graph-indexer']) return false;
 
-    existing.mcpServers['graph-indexer'] = SERVER_CONFIG;
+    existing.mcpServers['graph-indexer'] = SERVER_CONFIG_GLOBAL;
     writeFile(configPath, JSON.stringify(existing, null, 2) + '\n');
     return true;
 }
 
 function configureClaudeCode() {
-    // Claude Code stores MCP config in .mcp.json or .claude/settings.json at project root
-    const candidates = [
-        path.join(PROJECT_ROOT, '.claude', 'settings.json'),
-        path.join(PROJECT_ROOT, '.mcp.json'),
-    ];
-
-    // Prefer .claude/settings.json if directory exists, else .mcp.json
     const hasClaudeDir = fs.existsSync(path.join(PROJECT_ROOT, '.claude'));
-    const configPath = hasClaudeDir ? candidates[0] : candidates[1];
+    const configPath = hasClaudeDir
+        ? path.join(PROJECT_ROOT, '.claude', 'settings.json')
+        : path.join(PROJECT_ROOT, '.mcp.json');
 
     const existing = readJsonSafe(configPath) || {};
-    const serverKey = hasClaudeDir ? 'mcpServers' : 'mcpServers';
-    if (!existing[serverKey]) existing[serverKey] = {};
-    if (existing[serverKey]['graph-indexer']) return false;
+    if (!existing.mcpServers) existing.mcpServers = {};
+    if (existing.mcpServers['graph-indexer']) return false;
 
-    existing[serverKey]['graph-indexer'] = SERVER_CONFIG;
+    existing.mcpServers['graph-indexer'] = SERVER_CONFIG;
     writeFile(configPath, JSON.stringify(existing, null, 2) + '\n');
     return true;
 }
@@ -174,7 +260,13 @@ function updateGitignore() {
     const gitignorePath = path.join(PROJECT_ROOT, '.gitignore');
     const existing = fs.existsSync(gitignorePath) ? fs.readFileSync(gitignorePath, 'utf-8') : '';
 
-    const entries = ['code-index.json', 'code-index.embeddings.bin'];
+    const entries = [
+        'code-index.json',
+        'code-index.embeddings.bin',
+        '.idx-daemon.pid',
+        '.idx-daemon.log'
+    ];
+
     const toAdd = entries.filter(e => !existing.includes(e));
     if (toAdd.length === 0) return false;
 
@@ -185,13 +277,23 @@ function updateGitignore() {
 
 // ─── Main ─────────────────────────────────────────────────────────────────────
 
-log('\n🔧 graph-indexer init' + (isDryRun ? ' [dry-run]' : '') + '\n');
-log(`📂 Project: ${PROJECT_ROOT}\n`);
+log('\n🚀 graph-indexer init' + (isDryRun ? ' [dry-run]' : '') + '\n');
+log(`Project: ${PROJECT_ROOT}`);
+
+// Language selection (interactive menu).
+const selectedLanguages = await selectLanguages();
+saveLanguageConfig(selectedLanguages);
+
+if (selectedLanguages) {
+    const names = selectedLanguages.map(k => LANGUAGES.find(l => l.key === k)?.label || k);
+    log(`\n✅ Enabled languages: ${names.join(', ')}\n`);
+} else {
+    log('\n✅ Enabled languages: all (default)\n');
+}
 
 const configured = [];
 const skipped = [];
 
-// IDE configuration
 const ides = [
     { name: 'VS Code', fn: configureVSCode },
     { name: 'Cursor', fn: configureCursor },
@@ -199,43 +301,52 @@ const ides = [
     { name: 'Claude Code', fn: configureClaudeCode },
 ];
 
-log('🔍 Detecting IDEs / agents...\n');
+log('Detecting IDEs / agents...\n');
 for (const { name, fn } of ides) {
     try {
         const result = fn();
-        if (result === false) {
-            skipped.push(name + ' (already configured or not installed)');
-        } else {
-            configured.push(name);
-        }
+        if (result === false) skipped.push(name + ' (already configured or not installed)');
+        else configured.push(name);
     } catch (e) {
         skipped.push(name + ' (error: ' + e.message + ')');
     }
 }
 
-// Package scripts
 const scriptsAdded = addPackageScripts();
 if (scriptsAdded) configured.push('package.json scripts (mcp:index, mcp:watch, mcp:start)');
 else skipped.push('package.json scripts (already present)');
 
-// .gitignore
 const gitignoreUpdated = updateGitignore();
-if (gitignoreUpdated) configured.push('.gitignore (code-index.json, code-index.embeddings.bin)');
-else skipped.push('.gitignore (already contains index entries)');
+if (gitignoreUpdated) configured.push('.gitignore (code-index, daemon artifacts)');
+else skipped.push('.gitignore (already contains index/daemon entries)');
 
 // ─── Summary ─────────────────────────────────────────────────────────────────
 
-log('\n✅ Configured:\n');
-if (configured.length) configured.forEach(c => log('  • ' + c));
+log('\nConfigured:\n');
+if (configured.length) configured.forEach(c => log('  * ' + c));
 else log('  (nothing new to configure)');
 
 if (skipped.length) {
-    log('\n⏭️  Skipped:\n');
-    skipped.forEach(s => log('  • ' + s));
+    log('\nSkipped:\n');
+    skipped.forEach(s => log('  - ' + s));
 }
 
-log('\n📋 Next steps:\n');
+log('\nNext steps:\n');
 log('  1. Run `npm run mcp:index` to index this project');
-log('  2. Restart your IDE to activate MCP servers');
+log('  2. Restart your IDE to activate the MCP server');
 log('  3. Run `npm run mcp:start` if your IDE needs the server started manually');
-log('\n');
+
+// Mensaje final de agradecimiento
+log('\n─────────────────────────────────────────────────────────────────');
+log('✨ Thank you for setting up graph-indexer!');
+log('   Enjoy your blazing-fast, AST-precise codebase search.');
+log('─────────────────────────────────────────────────────────────────\n');
+log('');
+log('🤖 Agent Instructions:');
+log('   To teach your AI agent how to use graph-indexer effectively,');
+log('   copy the system prompt from our repository:');
+log('   https://github.com/MaquinaTech/graph-indexer/blob/main/PROMPT.md?plain=1');
+log('─────────────────────────────────────────────────────────────────\n');
+
+// Cierre limpio de la ejecución para devolver el control a la terminal
+process.exit(0);

package/mcp-server.mjs

@@ -21,6 +21,15 @@ const PROJECT_ROOT = process.env.MCP_PROJECT_ROOT || process.cwd();
 const INDEX_PATH = resolve(PROJECT_ROOT, "code-index.json");
 const PID_FILE = resolve(PROJECT_ROOT, ".idx-daemon.pid");
 
+// Single source of truth for the version: graph-indexer's own package.json
+// (next to this file), never the consumer project's package.json.
+const PACKAGE_DIR = path.dirname(fileURLToPath(import.meta.url));
+function readPackageVersion() {
+    try {
+        return JSON.parse(fs.readFileSync(path.join(PACKAGE_DIR, "package.json"), "utf-8")).version || "0.0.0";
+    } catch { return "0.0.0"; }
+}
+
 // ─── Daemon Orchestration ─────────────────────────────────────────────────────
 
 function ensureDaemonRunning() {
@@ -100,7 +109,7 @@ function pruneBodyByQuery(codeSnippet, queryTokens, maxLines = 40) {
 // ─── Server Initialization ────────────────────────────────────────────────────
 
 ensureDaemonRunning();
-const version = "1.0.2";
+const version = readPackageVersion();
 const server = new McpServer({ name: "graph-indexer", version });
 
 // Use lazy (disk-backed) vector loading for large corpora — cacheEmbeddings:false

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "graph-indexer",
-    "version": "1.0.2",
+    "version": "1.1.0",
     "description": "Zero-DB, Air-gapped, In-Memory Graph Indexer MCP Server with Hybrid RRF Search and Cross-Language Topology",
     "type": "module",
     "main": "core-engine.mjs",
@@ -26,6 +26,7 @@
     "scripts": {
         "start": "node ./mcp-server.mjs",
         "test": "node test/run.mjs",
+        "test:unit": "node test/unit.mjs",
         "test:setup": "node test/setup.mjs",
         "test:run": "node test/run.mjs",
         "test:embeddings": "OLLAMA_HOST=http://localhost:11435 node test/run-embeddings.mjs",
@@ -42,17 +43,6 @@
         "chokidar": "5.0.0",
         "ignore": "5.3.2",
         "tree-sitter": "0.21.1",
-        "tree-sitter-c-sharp": "^0.21.3",
-        "tree-sitter-css": "0.21.1",
-        "tree-sitter-go": "0.21.0",
-        "tree-sitter-java": "^0.21.0",
-        "tree-sitter-javascript": "0.21.4",
-        "tree-sitter-kotlin": "^0.3.8",
-        "tree-sitter-php": "0.23.1",
-        "tree-sitter-python": "0.21.0",
-        "tree-sitter-ruby": "^0.23.1",
-        "tree-sitter-rust": "0.21.0",
-        "tree-sitter-typescript": "0.21.2",
         "zod": "3.23.8"
     },
     "keywords": [
@@ -88,6 +78,17 @@
         "access": "public"
     },
     "optionalDependencies": {
-        "hnswlib-node": "^3.0.0"
+        "hnswlib-node": "^3.0.0",
+        "tree-sitter-c-sharp": "^0.21.3",
+        "tree-sitter-css": "0.21.1",
+        "tree-sitter-go": "0.21.0",
+        "tree-sitter-java": "^0.21.0",
+        "tree-sitter-javascript": "0.21.4",
+        "tree-sitter-kotlin": "^0.3.8",
+        "tree-sitter-php": "0.23.1",
+        "tree-sitter-python": "0.21.0",
+        "tree-sitter-ruby": "^0.23.1",
+        "tree-sitter-rust": "0.21.0",
+        "tree-sitter-typescript": "0.21.2"
     }
 }

package/parser-utils.mjs

@@ -21,32 +21,63 @@ import ignore from 'ignore';
 import Parser from 'tree-sitter';
 const { Query } = Parser; // Native parser query helper
 
-import TypeScript from 'tree-sitter-typescript';
-import JavaScript from 'tree-sitter-javascript';
-import CSS from 'tree-sitter-css';
-import Python from 'tree-sitter-python';
-import Rust from 'tree-sitter-rust';
-import Go from 'tree-sitter-go';
-import PHP from 'tree-sitter-php';
-import Java from 'tree-sitter-java';
-import Kotlin from 'tree-sitter-kotlin';
-import CSharp from 'tree-sitter-c-sharp';
-import Ruby from 'tree-sitter-ruby';
 import { truncateForEmbedding } from './core-engine.mjs';
 
 export const MAX_FILE_SIZE_BYTES = 500000;
 export const OLLAMA_HOST = process.env.OLLAMA_HOST || "http://localhost:11434";
 
+// ─── Dynamic Language Loading ─────────────────────────────────────────────────
+
+function _loadProjectConfig() {
+    const configPath = path.join(process.env.MCP_PROJECT_ROOT || process.cwd(), '.graph-indexer.json');
+    try {
+        if (fs.existsSync(configPath)) return JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    } catch { /* ignore */ }
+    return null;
+}
+
+async function _tryLang(pkg, enabledLangs, key) {
+    if (enabledLangs && !enabledLangs.includes(key)) return null;
+    try {
+        return (await import(pkg)).default;
+    } catch {
+        process.stderr.write(`[graph-indexer] WARNING: ${pkg} not installed — ${key} files will be skipped\n`);
+        return null;
+    }
+}
+
+const _cfg = _loadProjectConfig();
+const _enabled = _cfg?.languages ?? null; // null = all languages
+
+const [
+    TypeScript, JavaScript, CSS, Python, Rust,
+    Go, PHP, Java, Kotlin, CSharp, Ruby
+] = await Promise.all([
+    _tryLang('tree-sitter-typescript', _enabled, 'typescript'),
+    _tryLang('tree-sitter-javascript', _enabled, 'javascript'),
+    _tryLang('tree-sitter-css',        _enabled, 'css'),
+    _tryLang('tree-sitter-python',     _enabled, 'python'),
+    _tryLang('tree-sitter-rust',       _enabled, 'rust'),
+    _tryLang('tree-sitter-go',         _enabled, 'go'),
+    _tryLang('tree-sitter-php',        _enabled, 'php'),
+    _tryLang('tree-sitter-java',       _enabled, 'java'),
+    _tryLang('tree-sitter-kotlin',     _enabled, 'kotlin'),
+    _tryLang('tree-sitter-c-sharp',    _enabled, 'csharp'),
+    _tryLang('tree-sitter-ruby',       _enabled, 'ruby'),
+]);
+
 const LANGUAGE_MAP = {
-    '.ts': TypeScript.typescript, '.tsx': TypeScript.tsx,
-    '.js': JavaScript, '.jsx': JavaScript, '.mjs': JavaScript, '.cjs': JavaScript,
-    '.css': CSS, '.scss': CSS,
-    '.py': Python, '.rs': Rust, '.go': Go,
-    '.php': PHP.php,
-    '.java': Java,
-    '.kt': Kotlin, '.kts': Kotlin,
-    '.cs': CSharp,
-    '.rb': Ruby,
+    ...(TypeScript ? { '.ts': TypeScript.typescript, '.tsx': TypeScript.tsx } : {}),
+    ...(JavaScript ? { '.js': JavaScript, '.jsx': JavaScript, '.mjs': JavaScript, '.cjs': JavaScript } : {}),
+    ...(CSS        ? { '.css': CSS, '.scss': CSS } : {}),
+    ...(Python     ? { '.py': Python }  : {}),
+    ...(Rust       ? { '.rs': Rust }    : {}),
+    ...(Go         ? { '.go': Go }      : {}),
+    ...(PHP        ? { '.php': PHP.php } : {}),
+    ...(Java       ? { '.java': Java }  : {}),
+    ...(Kotlin     ? { '.kt': Kotlin, '.kts': Kotlin } : {}),
+    ...(CSharp     ? { '.cs': CSharp }  : {}),
+    ...(Ruby       ? { '.rb': Ruby }    : {}),
 };
 
 // 🥇 ULTRA-GENERIC QUERIES: Immune to grammar changes between TS/JS/TSX
@@ -606,6 +637,38 @@ export function resolveLocalImports(rawImports, fromFileRelPath, projectRoot) {
     return resolved;
 }
 
+/**
+ * Build the text payload sent to the embedding model for a chunk.
+ *
+ * Shared by the bootstrap indexer (indexer.mjs) and the watch daemon
+ * (watch-daemon.mjs) so a chunk yields the SAME embedding regardless of which
+ * path embedded it first. This matters because the cache key (content_hash) is
+ * derived from code + docstring only — it does NOT include this payload — so two
+ * divergent payloads for the same hash would silently produce inconsistent
+ * embeddings across a full re-index vs. an incremental update.
+ *
+ * @param {object}   chunk        Semantic chunk: { file_path, node_type, name, docstring, type_refs, code_snippet }.
+ * @param {string[]} depRelPaths  Resolved local imports of the chunk's file (project-relative paths).
+ * @returns {string}
+ */
+export function buildEmbeddingPayload(chunk, depRelPaths = []) {
+    const neighbors = depRelPaths
+        .map(d => path.basename(d, path.extname(d)))
+        .filter(Boolean);
+    const topologicalContext = neighbors.length
+        ? `This code architectural neighborhood connects with: ${neighbors.join(', ')}.`
+        : '';
+    return [
+        `File Location: ${chunk.file_path}`,
+        `Symbol Name: ${chunk.node_type} -> ${chunk.name}`,
+        chunk.docstring ? `Developer Documentation: ${chunk.docstring}` : '',
+        chunk.type_refs?.length ? `Type References: ${chunk.type_refs.join(', ')}` : '',
+        topologicalContext,
+        `--- Source Code ---`,
+        chunk.code_snippet,
+    ].filter(Boolean).join('\n');
+}
+
 export async function getLocalEmbedding(text, graceful = true) {
     if (process.env.INDEXER_EMBEDDINGS === 'off') return null; // lexical-only mode
     const MAX_RETRIES = 3;

package/watch-daemon.mjs

@@ -22,7 +22,8 @@ import chokidar from 'chokidar';
 import { MemoryGraphIndex } from './core-engine.mjs';
 import {
     MAX_FILE_SIZE_BYTES, EXTENSIONS, getParserForFile, buildIgnoreFilter,
-    extractImportsFromAST, extractSemanticChunks, resolveLocalImports, getLocalEmbeddingsBatch
+    extractImportsFromAST, extractSemanticChunks, resolveLocalImports, getLocalEmbeddingsBatch,
+    buildEmbeddingPayload
 } from './parser-utils.mjs';
 
 const PROJECT_ROOT = process.env.MCP_PROJECT_ROOT || process.cwd();
@@ -79,23 +80,11 @@ async function processFileChange(absolutePath) {
         const chunksToEmbed = newChunks.filter(c => !db.embeddingCache.has(c.content_hash));
 
         if (chunksToEmbed.length > 0) {
-            const textsToEmbed = chunksToEmbed.map(c => {
-                const dependencies = db.graph.dependencies[c.file_path] || [];
-                const cleanDeps = dependencies.map(d => path.basename(d, path.extname(d)));
-                const topologicalContext = cleanDeps.length > 0
-                    ? `This code architectural neighborhood connects with: ${cleanDeps.join(', ')}.`
-                    : '';
-
-                // 🥇 STRICT PAYLOAD PARITY: Eliminate real-time bleed
-                return [
-                    `File Location: ${c.file_path}`,
-                    `Symbol Name: ${c.node_type} -> ${c.name}`,
-                    c.docstring ? `Developer Documentation: ${c.docstring}` : '',
-                    topologicalContext,
-                    `--- Source Code ---`,
-                    c.code_snippet
-                ].filter(Boolean).join('\n');
-            });
+            // 🥇 STRICT PAYLOAD PARITY: identical embedding payload to indexer.mjs
+            // (shared helper) so incremental updates match the bootstrap index.
+            const textsToEmbed = chunksToEmbed.map(c =>
+                buildEmbeddingPayload(c, db.graph.dependencies[c.file_path] || [])
+            );
 
             const embeddingsMatrix = await getLocalEmbeddingsBatch(textsToEmbed, true);
             if (embeddingsMatrix) {
@@ -137,8 +126,23 @@ async function processFileChange(absolutePath) {
 }
 
 process.stderr.write(`🚀 Chokidar Watcher Daemon started in: ${PROJECT_ROOT}\n`);
+
+// Only watch source files we can actually index. Critically, this prevents
+// chokidar from descending into node_modules / dist / .git / .gitignored dirs —
+// watching those would exhaust the OS file-watcher limit (ENOSPC on Linux) and
+// waste CPU/memory on large projects. The ignore decision happens at the watcher
+// level, not just in processFileChange, so ignored trees are never traversed.
+function shouldIgnore(absPath) {
+    const rel = path.relative(PROJECT_ROOT, absPath).replace(/\\/g, '/');
+    if (!rel) return false;                       // the project root itself
+    if (path.basename(absPath).startsWith('.')) return true; // dotfiles / dot-dirs
+    try { return ignoreFilter.ignores(rel); }     // node_modules, dist, .gitignore, …
+    catch { return false; }
+}
+
 const watcher = chokidar.watch(PROJECT_ROOT, {
-    ignored: /(^|[\/\\])\../, persistent: true,
+    ignored: shouldIgnore,
+    persistent: true,
     awaitWriteFinish: { stabilityThreshold: 300, pollInterval: 100 }
 });
 watcher.on('add', processFileChange).on('change', processFileChange).on('unlink', (p) => processFileChange(p));