@roarpeng/graphflow 1.1.0 → 1.2.0

package/dist/graph/file-indexer.js

@@ -1,108 +1,120 @@
 "use strict";
+/**
+ * file-indexer.ts — Main entry point for file indexing
+ *
+ * Re-exports public API and implements the two main indexing functions:
+ * - indexWorkspaceFiles: full workspace batch indexing
+ * - indexSingleFile: incremental single-file indexing
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.clearGraphIndexArtifacts = clearGraphIndexArtifacts;
-exports.hasPendingGraphIndexWork = hasPendingGraphIndexWork;
+exports.resolveCallerAtLine = exports.hasIndexCache = exports.hasPendingGraphIndexWork = exports.clearGraphIndexArtifacts = exports.DEFAULT_MAX_FILE_SIZE = exports.DEFAULT_EXTENSIONS = void 0;
 exports.indexWorkspaceFiles = indexWorkspaceFiles;
-exports.resolveCallerAtLine = resolveCallerAtLine;
 exports.indexSingleFile = indexSingleFile;
-exports.hasIndexCache = hasIndexCache;
-const logger_1 = require("../utils/logger");
-const hash_1 = require("../utils/hash");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const node_crypto_1 = require("node:crypto");
-const index_1 = require("./language-indexers/index");
-const BASE_EXTENSIONS = [".md", ".json"];
-const DEFAULT_EXTENSIONS = Array.from(new Set([...index_1.ALL_LANGUAGE_EXTENSIONS, ...BASE_EXTENSIONS]));
-const DEFAULT_MAX_FILE_SIZE = 200_000;
-const IGNORED_DIRS = new Set([
-    ".git", "node_modules", "dist", "coverage", "tmp", "venv", ".venv", "env", ".env",
-    "__pycache__", ".vscode", ".idea", ".next", "build", "install", "log",
-    ".graphflow-cache", "graphflow-out", "graphify-out",
-]);
-const REFERENCE_SKIPLIST = new Set([
-    "if", "for", "let", "const", "var", "this", "new", "return", "true", "false",
-    "null", "undefined", "console", "process", "require", "module", "exports",
-    "import", "export", "default", "async", "await", "function", "class",
-    "interface", "type", "enum", "from", "as", "of", "in", "do", "while",
-    "switch", "case", "break", "continue", "throw", "try", "catch", "finally",
-    "void", "yield", "number", "string", "boolean", "object", "any", "unknown",
-    "never", "Array", "Promise", "Map", "Set", "Date", "Error", "JSON", "Math",
-    "Object", "String", "Number", "Boolean", "Symbol", "Function", "RegExp",
-    "def", "fn", "pub", "struct", "trait", "impl", "use", "mod", "func",
-    "package", "include", "namespace", "typedef", "define", "static", "inline",
-    "extern", "virtual", "nil", "None", "True", "False", "int", "char", "long",
-    "short", "float", "double", "bool", "auto", "sizeof", "self", "cls",
-    "and", "or", "not", "is", "lambda", "global", "nonlocal", "pass", "raise",
-    "with", "yield", "make", "len", "cap", "append", "range", "chan", "select",
-    "defer", "goto", "fallthrough", "size_t", "uint", "int8", "int16", "int32",
-    "int64", "uint8", "uint16", "uint32", "uint64", "byte", "rune", "string",
-]);
-const CACHE_DIR = ".graphflow-cache";
-const CACHE_FILE = "index-state.json";
-/** Remove graph store, index cache, and vector DB for a full rebuild. */
-function clearGraphIndexArtifacts(rootDir, graphStorePath) {
-    const cachePath = (0, node_path_1.join)(rootDir, CACHE_DIR, CACHE_FILE);
-    const vectorsPath = (0, node_path_1.join)(rootDir, CACHE_DIR, "vectors.db");
-    (0, node_fs_1.rmSync)(graphStorePath, { force: true });
-    (0, node_fs_1.rmSync)(cachePath, { force: true });
-    (0, node_fs_1.rmSync)(vectorsPath, { force: true });
-}
-function loadCacheState(cachePath, forceReindex) {
-    if (forceReindex) {
-        return {};
-    }
-    try {
-        const raw = (0, node_fs_1.readFileSync)(cachePath, "utf8");
-        const parsedCache = JSON.parse(raw);
-        if (parsedCache.version === 2 && parsedCache.state) {
-            return parsedCache.state;
+const hash_js_1 = require("../utils/hash.js");
+const logger_js_1 = require("../utils/logger.js");
+const index_js_1 = require("./language-indexers/index.js");
+var file_indexer_walker_js_1 = require("./file-indexer-walker.js");
+Object.defineProperty(exports, "DEFAULT_EXTENSIONS", { enumerable: true, get: function () { return file_indexer_walker_js_1.DEFAULT_EXTENSIONS; } });
+Object.defineProperty(exports, "DEFAULT_MAX_FILE_SIZE", { enumerable: true, get: function () { return file_indexer_walker_js_1.DEFAULT_MAX_FILE_SIZE; } });
+var file_indexer_cache_js_1 = require("./file-indexer-cache.js");
+Object.defineProperty(exports, "clearGraphIndexArtifacts", { enumerable: true, get: function () { return file_indexer_cache_js_1.clearGraphIndexArtifacts; } });
+Object.defineProperty(exports, "hasPendingGraphIndexWork", { enumerable: true, get: function () { return file_indexer_cache_js_1.hasPendingGraphIndexWork; } });
+Object.defineProperty(exports, "hasIndexCache", { enumerable: true, get: function () { return file_indexer_cache_js_1.hasIndexCache; } });
+var file_indexer_nodes_js_1 = require("./file-indexer-nodes.js");
+Object.defineProperty(exports, "resolveCallerAtLine", { enumerable: true, get: function () { return file_indexer_nodes_js_1.resolveCallerAtLine; } });
+// ── Internal imports ─────────────────────────────────────────────────
+const file_indexer_walker_js_2 = require("./file-indexer-walker.js");
+const file_indexer_cache_js_2 = require("./file-indexer-cache.js");
+const file_indexer_nodes_js_2 = require("./file-indexer-nodes.js");
+const file_indexer_edges_js_1 = require("./file-indexer-edges.js");
+/**
+ * 处理单个文件：读取内容、检查缓存、调用语言索引器提取符号/边。
+ * 返回 null 表示该文件未变更、被跳过。
+ *
+ * 该函数是并行安全：不修改共享的 nodes/edges/parsed 数组，
+ * 只返回本文件的局部结果，由调用方顺序合并。
+ */
+async function processFile(file, cacheState, forceReindex, client) {
+    const relPath = file.relPath;
+    const mtimeMs = file.mtimeMs;
+    const prev = cacheState[relPath];
+    let content = "";
+    let currentHash = "";
+    let isChanged = forceReindex;
+    if (!prev || prev.mtimeMs !== mtimeMs) {
+        content = (0, node_fs_1.readFileSync)(file.absPath, "utf8");
+        currentHash = (0, node_crypto_1.createHash)("md5").update(content).digest("hex");
+        if (!prev || prev.hash !== currentHash) {
+            isChanged = true;
         }
     }
-    catch (error) {
-        const err = error;
-        if (err.code !== "ENOENT") {
-            logger_1.logger.warn({ error: err.message }, "Failed to read index cache");
-        }
+    if (!isChanged) {
+        return null;
     }
-    return {};
-}
-/** Returns true when workspace files changed since last index (or cache is empty). */
-function hasPendingGraphIndexWork(rootDir, options) {
-    const includeExtensions = options?.includeExtensions ?? DEFAULT_EXTENSIONS;
-    const maxFileSizeBytes = options?.maxFileSizeBytes ?? DEFAULT_MAX_FILE_SIZE;
-    const forceReindex = options?.forceReindex ?? false;
-    if (forceReindex) {
-        return true;
+    // 清理该文件在图存储中的旧节点（不同 relPath 的节点互不重叠，并行安全）
+    if (client.deleteNode) {
+        await pruneFileFromGraph(client, relPath);
     }
-    const cachePath = (0, node_path_1.join)(rootDir, CACHE_DIR, CACHE_FILE);
-    const cacheState = loadCacheState(cachePath, false);
-    const scanned = walkScannableFiles(rootDir, includeExtensions, maxFileSizeBytes);
-    const currentRelPaths = new Set(scanned.map((file) => file.relPath));
-    for (const relPath of Object.keys(cacheState)) {
-        if (!currentRelPaths.has(relPath)) {
-            return true;
-        }
+    if (!content) {
+        content = (0, node_fs_1.readFileSync)(file.absPath, "utf8");
+        currentHash = (0, node_crypto_1.createHash)("md5").update(content).digest("hex");
     }
-    for (const file of scanned) {
-        const prev = cacheState[file.relPath];
-        if (!prev || prev.mtimeMs !== file.mtimeMs) {
-            return true;
-        }
+    const fileNodeId = `file:${relPath}`;
+    const moduleNodeId = `module:${(0, file_indexer_nodes_js_2.moduleKey)(relPath)}`;
+    const indexer = (0, index_js_1.getIndexerForFile)(relPath);
+    const language = indexer?.language ?? ((0, file_indexer_walker_js_2.extOf)(relPath).replace(/^\./, "") || "text");
+    let declared = [];
+    let imports = [];
+    let fileCalls = [];
+    let fileInherits = [];
+    if (indexer) {
+        const extracted = await indexer.extract(relPath, content);
+        declared = extracted.symbols.map((sym) => ({
+            ...sym,
+            nodeId: `symbol:${relPath}:${(0, hash_js_1.hashTextHex)(sym.name)}`,
+        }));
+        imports = extracted.imports.map((imp) => imp.module);
+        fileCalls = extracted.calls ?? [];
+        fileInherits = extracted.inherits ?? [];
     }
-    return false;
+    const { nodes: fileNodes, edges: fileEdges } = (0, file_indexer_nodes_js_2.buildFileNodesAndEdges)(relPath, file.size, language, declared, imports);
+    return {
+        relPath,
+        fileNodes,
+        fileEdges,
+        parsedEntry: {
+            relPath,
+            fileNodeId,
+            moduleNodeId,
+            declared,
+            content,
+            scannable: Boolean(indexer),
+            calls: fileCalls,
+            inherits: fileInherits,
+        },
+        cacheEntry: {
+            mtimeMs,
+            hash: currentHash,
+            numNodes: fileNodes.length,
+        },
+    };
 }
 async function indexWorkspaceFiles(client, rootDir, options) {
-    const includeExtensions = options?.includeExtensions ?? DEFAULT_EXTENSIONS;
-    const maxFileSizeBytes = options?.maxFileSizeBytes ?? DEFAULT_MAX_FILE_SIZE;
+    const includeExtensions = options?.includeExtensions ?? file_indexer_walker_js_2.DEFAULT_EXTENSIONS;
+    const maxFileSizeBytes = options?.maxFileSizeBytes ?? file_indexer_walker_js_2.DEFAULT_MAX_FILE_SIZE;
     const forceReindex = options?.forceReindex ?? false;
-    const cachePath = (0, node_path_1.join)(rootDir, CACHE_DIR, CACHE_FILE);
-    let cacheState = loadCacheState(cachePath, forceReindex);
+    // 并行索引并发数，默认每批 10 个文件
+    const concurrency = Math.max(1, options?.concurrency ?? 10);
+    const cachePath = (0, node_path_1.join)(rootDir, file_indexer_cache_js_2.CACHE_DIR, file_indexer_cache_js_2.CACHE_FILE);
+    let cacheState = (0, file_indexer_cache_js_2.loadCacheState)(cachePath, forceReindex);
     const snapshot = client.readSnapshot?.();
     if (snapshot && snapshot.nodes.length === 0 && snapshot.edges.length === 0 && Object.keys(cacheState).length > 0) {
         cacheState = {};
     }
-    const scanned = walkScannableFiles(rootDir, includeExtensions, maxFileSizeBytes);
+    const scanned = (0, file_indexer_walker_js_2.walkScannableFiles)(rootDir, includeExtensions, maxFileSizeBytes);
     const currentRelPaths = new Set(scanned.map((file) => file.relPath));
     if (client.deleteNode) {
         for (const relPath of Object.keys(cacheState)) {
@@ -115,119 +127,25 @@ async function indexWorkspaceFiles(client, rootDir, options) {
     const nodes = [];
     const edges = [];
     const parsed = [];
-    for (const file of scanned) {
-        const relPath = file.relPath;
-        const mtimeMs = file.mtimeMs;
-        const prev = cacheState[relPath];
-        let content = "";
-        let currentHash = "";
-        let isChanged = forceReindex;
-        if (!prev || prev.mtimeMs !== mtimeMs) {
-            content = (0, node_fs_1.readFileSync)(file.absPath, "utf8");
-            currentHash = (0, node_crypto_1.createHash)("md5").update(content).digest("hex");
-            if (!prev || prev.hash !== currentHash) {
-                isChanged = true;
+    // ── 并行分批索引：每批 concurrency 个文件并行处理 ──
+    let processedCount = 0;
+    for (let i = 0; i < scanned.length; i += concurrency) {
+        const batch = scanned.slice(i, i + concurrency);
+        const batchResults = await Promise.all(batch.map((file) => processFile(file, cacheState, forceReindex, client)));
+        // 顺序合并本批结果到共享数组（避免并行写冲突）
+        for (const result of batchResults) {
+            if (result) {
+                nodes.push(...result.fileNodes);
+                edges.push(...result.fileEdges);
+                parsed.push(result.parsedEntry);
+                cacheState[result.relPath] = result.cacheEntry;
             }
-        }
-        if (!isChanged) {
-            continue;
-        }
-        if (client.deleteNode) {
-            await pruneFileFromGraph(client, relPath);
-        }
-        if (!content) {
-            content = (0, node_fs_1.readFileSync)(file.absPath, "utf8");
-            currentHash = (0, node_crypto_1.createHash)("md5").update(content).digest("hex");
-        }
-        const nodesStartLen = nodes.length;
-        const fileNodeId = `file:${relPath}`;
-        const moduleNodeId = `module:${moduleKey(relPath)}`;
-        const indexer = (0, index_1.getIndexerForFile)(relPath);
-        const language = indexer?.language ?? (extOf(relPath).replace(/^\./, "") || "text");
-        let declared = [];
-        let imports = [];
-        let fileCalls = [];
-        let fileInherits = [];
-        if (indexer) {
-            const extracted = await indexer.extract(relPath, content);
-            declared = extracted.symbols.map((sym) => ({
-                ...sym,
-                nodeId: `symbol:${relPath}:${(0, hash_1.hashTextHex)(sym.name)}`,
-            }));
-            imports = extracted.imports.map((imp) => imp.module);
-            fileCalls = extracted.calls ?? [];
-            fileInherits = extracted.inherits ?? [];
-        }
-        const exportNames = declared
-            .filter((s) => s.exported && /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(s.name))
-            .map((s) => s.name);
-        const uniqueExports = Array.from(new Set(exportNames));
-        const exportsSuffix = uniqueExports.length > 0
-            ? ` # exports: ${uniqueExports.slice(0, 8).join(", ")}`
-            : "";
-        nodes.push({
-            id: fileNodeId,
-            type: "File",
-            content: `${relPath}${exportsSuffix}`,
-            metadata: {
-                path: relPath,
-                language,
-                exports: uniqueExports,
-                symbolCount: declared.length,
-                sizeBytes: file.size,
-            },
-        });
-        nodes.push({ id: moduleNodeId, type: "Module", content: moduleKey(relPath) });
-        edges.push({ from: fileNodeId, to: moduleNodeId, relation: "depends_on" });
-        for (const symbol of declared) {
-            const compactSig = `${symbol.kind} ${symbol.name}${symbol.exported ? " (exported)" : ""} @${relPath}:${symbol.line}`;
-            const signature = symbol.signature ?? compactSig;
-            const signatureHash = (0, hash_1.hashTextHex)(`${signature}\n${symbol.jsdoc ?? ""}\n${symbol.returnType ?? ""}`);
-            nodes.push({
-                id: symbol.nodeId,
-                type: "Symbol",
-                content: compactSig,
-                metadata: {
-                    name: symbol.name,
-                    kind: symbol.kind,
-                    exported: symbol.exported,
-                    line: symbol.line,
-                    file: relPath,
-                    signature,
-                    signatureHash,
-                    ...(symbol.jsdoc ? { jsdoc: symbol.jsdoc } : {}),
-                    ...(symbol.visibility ? { visibility: symbol.visibility } : {}),
-                    ...(symbol.paramsCount !== undefined ? { paramsCount: symbol.paramsCount } : {}),
-                    ...(symbol.returnType ? { returnType: symbol.returnType } : {}),
-                    ...(symbol.complexity !== undefined ? { complexity: symbol.complexity } : {}),
-                },
-            });
-            edges.push({ from: fileNodeId, to: symbol.nodeId, relation: "defines" });
-        }
-        for (const target of imports) {
-            const targetModule = normalizeImportTarget(target, relPath);
-            if (!targetModule) {
-                continue;
+            processedCount += 1;
+            // 每 100 个文件输出一次进度日志
+            if (processedCount > 0 && processedCount % 100 === 0) {
+                logger_js_1.logger.info({ processed: processedCount, total: scanned.length, percent: `${((processedCount / scanned.length) * 100).toFixed(1)}%` }, "工作区索引进度");
             }
-            const importNodeId = `module:${targetModule}`;
-            nodes.push({ id: importNodeId, type: "Module", content: targetModule });
-            edges.push({ from: moduleNodeId, to: importNodeId, relation: "imports" });
         }
-        parsed.push({
-            relPath,
-            fileNodeId,
-            moduleNodeId,
-            declared,
-            content,
-            scannable: Boolean(indexer),
-            calls: fileCalls,
-            inherits: fileInherits,
-        });
-        cacheState[relPath] = {
-            mtimeMs,
-            hash: currentHash,
-            numNodes: nodes.length - nodesStartLen,
-        };
     }
     const symbolIndex = new Map();
     for (const file of parsed) {
@@ -237,242 +155,25 @@ async function indexWorkspaceFiles(client, rootDir, options) {
             symbolIndex.set(symbol.name, list);
         }
     }
-    const identifierRe = /\b\w{3,}\b/g;
-    let referenceCount = 0;
-    for (const file of parsed) {
-        if (!file.scannable) {
-            continue;
-        }
-        const ownNames = new Set(file.declared.map((s) => s.name));
-        const seenThisFile = new Set();
-        const matches = file.content.match(identifierRe);
-        if (!matches)
-            continue;
-        const seenIdent = new Set();
-        for (const name of matches) {
-            if (seenIdent.has(name))
-                continue;
-            seenIdent.add(name);
-            if (name.length < 3 || REFERENCE_SKIPLIST.has(name)) {
-                continue;
-            }
-            const defs = symbolIndex.get(name);
-            if (!defs || defs.length === 0) {
-                continue;
-            }
-            for (const def of defs) {
-                if (ownNames.has(name) && def.nodeId.startsWith(`symbol:${file.relPath}:`)) {
-                    continue;
-                }
-                const key = `${file.fileNodeId}|${def.nodeId}`;
-                if (seenThisFile.has(key)) {
-                    continue;
-                }
-                seenThisFile.add(key);
-                edges.push({ from: file.fileNodeId, to: def.nodeId, relation: "references" });
-                referenceCount += 1;
-            }
-        }
-    }
-    // ── Build call graph edges (caller → callee) ──────────────────────
-    let callEdgeCount = 0;
-    for (const file of parsed) {
-        if (file.calls.length === 0)
-            continue;
-        // Map symbol names to node ids within this file for caller resolution
-        const localByName = new Map();
-        for (const sym of file.declared) {
-            localByName.set(sym.name, sym.nodeId);
-        }
-        const seenCalls = new Set();
-        for (const call of file.calls) {
-            // Resolve callee via global symbol index (may be in another file)
-            const calleeDefs = symbolIndex.get(call.callee);
-            if (!calleeDefs || calleeDefs.length === 0)
-                continue;
-            // Prefer same-file callee, then first match
-            const calleeDef = calleeDefs.find((d) => d.nodeId.startsWith(`symbol:${file.relPath}:`)) ?? calleeDefs[0];
-            if (!calleeDef)
-                continue;
-            // Resolve caller: prefer the caller name from extraction, then fall back
-            // to the innermost local symbol at or before the call line.
-            let callerNodeId;
-            if (call.caller) {
-                callerNodeId = localByName.get(call.caller);
-            }
-            if (!callerNodeId) {
-                callerNodeId = resolveCallerAtLine(file.declared, call.line);
-            }
-            if (!callerNodeId) {
-                continue;
-            }
-            const edgeKey = `${callerNodeId}|${calleeDef.nodeId}|calls`;
-            if (seenCalls.has(edgeKey))
-                continue;
-            seenCalls.add(edgeKey);
-            edges.push({ from: callerNodeId, to: calleeDef.nodeId, relation: "calls" });
-            callEdgeCount += 1;
-        }
-    }
-    // ── Build inheritance edges (child → parent) ──────────────────────
-    let inheritEdgeCount = 0;
-    for (const file of parsed) {
-        if (file.inherits.length === 0)
-            continue;
-        const localByName = new Map();
-        for (const sym of file.declared) {
-            localByName.set(sym.name, sym.nodeId);
-        }
-        const seenInherits = new Set();
-        for (const rel of file.inherits) {
-            const childNodeId = localByName.get(rel.child);
-            if (!childNodeId)
-                continue;
-            // Resolve parent via global symbol index
-            const parentDefs = symbolIndex.get(rel.parent);
-            if (!parentDefs || parentDefs.length === 0)
-                continue;
-            const parentDef = parentDefs.find((d) => d.nodeId.startsWith(`symbol:${file.relPath}:`)) ?? parentDefs[0];
-            if (!parentDef)
-                continue;
-            const edgeKey = `${childNodeId}|${parentDef.nodeId}|inherits`;
-            if (seenInherits.has(edgeKey))
-                continue;
-            seenInherits.add(edgeKey);
-            edges.push({ from: childNodeId, to: parentDef.nodeId, relation: "inherits" });
-            inheritEdgeCount += 1;
-        }
-    }
+    const { edges: refEdges, referenceCount } = (0, file_indexer_edges_js_1.buildBatchReferenceEdges)(parsed, symbolIndex);
+    edges.push(...refEdges);
+    const { edges: callEdges, callEdgeCount } = (0, file_indexer_edges_js_1.buildBatchCallEdges)(parsed, symbolIndex);
+    edges.push(...callEdges);
+    const { edges: inheritEdges, inheritEdgeCount } = (0, file_indexer_edges_js_1.buildBatchInheritEdges)(parsed, symbolIndex);
+    edges.push(...inheritEdges);
     await client.upsertNodes(nodes);
-    await client.upsertEdges(dedupEdges(edges));
-    try {
-        const dir = (0, node_path_1.dirname)(cachePath);
-        (0, node_fs_1.mkdirSync)(dir, { recursive: true });
-        (0, node_fs_1.writeFileSync)(cachePath, JSON.stringify({ version: 2, state: cacheState }, null, 2), "utf8");
-    }
-    catch (error) {
-        logger_1.logger.warn({ error }, "Failed to write index cache");
-    }
+    await client.upsertEdges((0, file_indexer_edges_js_1.dedupEdges)(edges));
+    (0, file_indexer_cache_js_2.saveCacheState)(cachePath, cacheState);
     return {
         indexedFiles: nodes.filter((node) => node.type === "File").length,
         indexedSymbols: nodes.filter((node) => node.type === "Symbol").length,
         indexedReferences: referenceCount + callEdgeCount + inheritEdgeCount,
     };
 }
-async function pruneFileFromGraph(client, relPath) {
-    if (!client.readSnapshot || !client.deleteNode) {
-        return;
-    }
-    const snapshot = client.readSnapshot();
-    const fileNodeId = `file:${relPath}`;
-    const moduleNodeId = `module:${moduleKey(relPath)}`;
-    const symbolPrefix = `symbol:${relPath}:`;
-    const toDelete = snapshot.nodes.filter((node) => node.id === fileNodeId || node.id === moduleNodeId || node.id.startsWith(symbolPrefix));
-    for (const node of toDelete) {
-        await client.deleteNode(node.id);
-    }
-}
-function walkScannableFiles(rootDir, includeExtensions, maxFileSizeBytes) {
-    const files = walkFiles(rootDir, includeExtensions);
-    const scanned = [];
-    for (const absPath of files) {
-        const stat = (0, node_fs_1.statSync)(absPath);
-        if (stat.size > maxFileSizeBytes) {
-            continue;
-        }
-        scanned.push({
-            absPath,
-            relPath: normalizePath((0, node_path_1.relative)(rootDir, absPath)),
-            size: stat.size,
-            mtimeMs: stat.mtimeMs,
-        });
-    }
-    return scanned;
-}
-function walkFiles(rootDir, includeExtensions) {
-    const entries = (0, node_fs_1.readdirSync)(rootDir, { withFileTypes: true });
-    const files = [];
-    for (const entry of entries) {
-        const full = (0, node_path_1.join)(rootDir, entry.name);
-        if (entry.isSymbolicLink()) {
-            continue;
-        }
-        if (entry.isDirectory()) {
-            if (IGNORED_DIRS.has(entry.name)) {
-                continue;
-            }
-            files.push(...walkFiles(full, includeExtensions));
-            continue;
-        }
-        if (includeExtensions.some((ext) => entry.name.endsWith(ext))) {
-            files.push(full);
-        }
-    }
-    return files;
-}
-function normalizeImportTarget(target, importerRelPath) {
-    let cleaned = target
-        .replace(/\\/g, "/")
-        .replace(/\.(ts|tsx|js|jsx|py|rs|go|hpp|hxx|cpp|cxx|cc|h|c|java|rb|rake|gemspec)$/i, "");
-    if (!cleaned) {
-        return undefined;
-    }
-    if (cleaned.startsWith(".")) {
-        const dir = node_path_1.posix.dirname(importerRelPath.replace(/\\/g, "/"));
-        cleaned = node_path_1.posix.join(dir, cleaned);
-        if (cleaned.startsWith("./")) {
-            cleaned = cleaned.slice(2);
-        }
-    }
-    return cleaned;
-}
-function moduleKey(relPath) {
-    return relPath.replace(/\.(ts|tsx|js|jsx|md|json|py|rs|go|hpp|hxx|cpp|cxx|cc|h|c|java|rb|rake|gemspec)$/i, "");
-}
-/** Innermost declared symbol at or before `line` (for call attribution when caller name is missing). */
-function resolveCallerAtLine(declared, line) {
-    const sorted = [...declared].sort((a, b) => b.line - a.line);
-    for (const sym of sorted) {
-        if (sym.line <= line) {
-            return sym.nodeId;
-        }
-    }
-    return undefined;
-}
-function dedupEdges(edges) {
-    const seen = new Set();
-    const result = [];
-    for (const edge of edges) {
-        const key = `${edge.from}|${edge.relation}|${edge.to}`;
-        if (!seen.has(key)) {
-            seen.add(key);
-            result.push(edge);
-        }
-    }
-    return result;
-}
-function normalizePath(pathText) {
-    return pathText.replace(/\\/g, "/");
-}
-/**
- * Incremental single-file indexing — borrowed from codebase-memory-mcp's
- * file-watcher pattern. Allows VS Code onSave hooks (or any file watcher)
- * to update the graph for one changed file without walking the entire workspace.
- *
- * Steps:
- *   1. Prune existing nodes/edges for the file (if any)
- *   2. Extract symbols + imports via the language indexer
- *   3. Upsert new nodes/edges
- *   4. Update the index cache entry for this file
- *
- * @param client Graph client
- * @param rootDir Workspace root (for relative path + cache location)
- * @param absPath Absolute path to the file to index
- * @param options Optional config
- */
+// ── Single-file incremental indexing ─────────────────────────────────
 async function indexSingleFile(client, rootDir, absPath, options) {
-    const includeExtensions = options?.includeExtensions ?? DEFAULT_EXTENSIONS;
-    const maxFileSizeBytes = options?.maxFileSizeBytes ?? DEFAULT_MAX_FILE_SIZE;
+    const includeExtensions = options?.includeExtensions ?? file_indexer_walker_js_2.DEFAULT_EXTENSIONS;
+    const maxFileSizeBytes = options?.maxFileSizeBytes ?? file_indexer_walker_js_2.DEFAULT_MAX_FILE_SIZE;
     // Validate extension
     if (!includeExtensions.some((ext) => absPath.toLowerCase().endsWith(ext))) {
         return { indexedFiles: 0, indexedSymbols: 0, indexedReferences: 0, skipped: true, reason: "extension not in includeExtensions" };
@@ -488,12 +189,12 @@ async function indexSingleFile(client, rootDir, absPath, options) {
     if (stat.size > maxFileSizeBytes) {
         return { indexedFiles: 0, indexedSymbols: 0, indexedReferences: 0, skipped: true, reason: "file exceeds maxFileSizeBytes" };
     }
-    const relPath = normalizePath((0, node_path_1.relative)(rootDir, absPath));
+    const relPath = (0, file_indexer_walker_js_2.normalizePath)((0, node_path_1.relative)(rootDir, absPath));
     const mtimeMs = stat.mtimeMs;
     const content = (0, node_fs_1.readFileSync)(absPath, "utf8");
     const currentHash = (0, node_crypto_1.createHash)("md5").update(content).digest("hex");
-    const cachePath = (0, node_path_1.join)(rootDir, CACHE_DIR, CACHE_FILE);
-    const cacheState = loadCacheState(cachePath, false);
+    const cachePath = (0, node_path_1.join)(rootDir, file_indexer_cache_js_2.CACHE_DIR, file_indexer_cache_js_2.CACHE_FILE);
+    const cacheState = (0, file_indexer_cache_js_2.loadCacheState)(cachePath, false);
     const prev = cacheState[relPath];
     // Skip if unchanged
     if (prev && prev.mtimeMs === mtimeMs && prev.hash === currentHash) {
@@ -505,9 +206,7 @@ async function indexSingleFile(client, rootDir, absPath, options) {
     }
     const nodes = [];
     const edges = [];
-    const fileNodeId = `file:${relPath}`;
-    const moduleNodeId = `module:${moduleKey(relPath)}`;
-    const indexer = (0, index_1.getIndexerForFile)(relPath);
+    const indexer = (0, index_js_1.getIndexerForFile)(relPath);
     const language = indexer?.language ?? (relPath.split(".").pop() ?? "text");
     let declared = [];
     let imports = [];
@@ -517,177 +216,40 @@ async function indexSingleFile(client, rootDir, absPath, options) {
         const extracted = await indexer.extract(relPath, content);
         declared = extracted.symbols.map((sym) => ({
             ...sym,
-            nodeId: `symbol:${relPath}:${(0, hash_1.hashTextHex)(sym.name)}`,
+            nodeId: `symbol:${relPath}:${(0, hash_js_1.hashTextHex)(sym.name)}`,
         }));
         imports = extracted.imports.map((imp) => imp.module);
         fileCalls = extracted.calls ?? [];
         fileInherits = extracted.inherits ?? [];
     }
-    const exportNames = declared
-        .filter((s) => s.exported && /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(s.name))
-        .map((s) => s.name);
-    const uniqueExports = Array.from(new Set(exportNames));
-    const exportsSuffix = uniqueExports.length > 0
-        ? ` # exports: ${uniqueExports.slice(0, 8).join(", ")}`
-        : "";
-    nodes.push({
-        id: fileNodeId,
-        type: "File",
-        content: `${relPath}${exportsSuffix}`,
-        metadata: {
-            path: relPath,
-            language,
-            exports: uniqueExports,
-            symbolCount: declared.length,
-            sizeBytes: stat.size,
-        },
-    });
-    nodes.push({ id: moduleNodeId, type: "Module", content: moduleKey(relPath) });
-    edges.push({ from: fileNodeId, to: moduleNodeId, relation: "depends_on" });
-    for (const symbol of declared) {
-        const compactSig = `${symbol.kind} ${symbol.name}${symbol.exported ? " (exported)" : ""} @${relPath}:${symbol.line}`;
-        const signature = symbol.signature ?? compactSig;
-        const signatureHash = (0, hash_1.hashTextHex)(`${signature}\n${symbol.jsdoc ?? ""}\n${symbol.returnType ?? ""}`);
-        nodes.push({
-            id: symbol.nodeId,
-            type: "Symbol",
-            content: compactSig,
-            metadata: {
-                name: symbol.name,
-                kind: symbol.kind,
-                exported: symbol.exported,
-                line: symbol.line,
-                file: relPath,
-                signature,
-                signatureHash,
-                ...(symbol.jsdoc ? { jsdoc: symbol.jsdoc } : {}),
-                ...(symbol.visibility ? { visibility: symbol.visibility } : {}),
-                ...(symbol.paramsCount !== undefined ? { paramsCount: symbol.paramsCount } : {}),
-                ...(symbol.returnType ? { returnType: symbol.returnType } : {}),
-                ...(symbol.complexity !== undefined ? { complexity: symbol.complexity } : {}),
-            },
-        });
-        edges.push({ from: fileNodeId, to: symbol.nodeId, relation: "defines" });
-    }
-    for (const target of imports) {
-        const targetModule = normalizeImportTarget(target, relPath);
-        if (!targetModule) {
-            continue;
-        }
-        const importNodeId = `module:${targetModule}`;
-        nodes.push({ id: importNodeId, type: "Module", content: targetModule });
-        edges.push({ from: moduleNodeId, to: importNodeId, relation: "imports" });
-    }
+    const { nodes: fileNodes, edges: fileEdges } = (0, file_indexer_nodes_js_2.buildFileNodesAndEdges)(relPath, stat.size, language, declared, imports);
+    nodes.push(...fileNodes);
+    edges.push(...fileEdges);
+    const fileNodeId = `file:${relPath}`;
     // Cross-file references: scan content against existing graph symbols
     let referenceCount = 0;
     const snapshot = client.readSnapshot?.();
     if (snapshot && indexer) {
-        const ownNames = new Set(declared.map((s) => s.name));
-        const identifierRe = /\b\w{3,}\b/g;
-        const matches = content.match(identifierRe);
-        if (matches) {
-            const seenIdent = new Set();
-            // Build symbol index from existing snapshot (excluding this file's own symbols)
-            const symbolIndex = new Map();
-            for (const node of snapshot.nodes) {
-                if (node.type !== "Symbol" || !node.metadata?.name)
-                    continue;
-                if (typeof node.metadata.file === "string" && node.metadata.file === relPath)
-                    continue;
-                const list = symbolIndex.get(node.metadata.name) ?? [];
-                list.push({ nodeId: node.id, file: node.metadata.file });
-                symbolIndex.set(node.metadata.name, list);
-            }
-            for (const name of matches) {
-                if (seenIdent.has(name))
-                    continue;
-                seenIdent.add(name);
-                if (name.length < 3 || REFERENCE_SKIPLIST.has(name))
-                    continue;
-                if (ownNames.has(name))
-                    continue;
-                const defs = symbolIndex.get(name);
-                if (!defs || defs.length === 0)
-                    continue;
-                for (const def of defs) {
-                    edges.push({ from: fileNodeId, to: def.nodeId, relation: "references" });
-                    referenceCount += 1;
-                }
-            }
-        }
-    }
-    // ── Call graph + inheritance edges (single-file incremental) ───────
-    // Build a combined symbol index: local symbols + snapshot symbols
-    const combinedSymbolIndex = new Map();
-    for (const sym of declared) {
-        const list = combinedSymbolIndex.get(sym.name) ?? [];
-        list.push({ nodeId: sym.nodeId, file: relPath });
-        combinedSymbolIndex.set(sym.name, list);
+        const { edges: refEdges, referenceCount: refCount } = (0, file_indexer_edges_js_1.buildSingleFileReferenceEdges)(fileNodeId, relPath, content, declared, snapshot.nodes);
+        edges.push(...refEdges);
+        referenceCount = refCount;
     }
+    // Call graph + inheritance edges
     if (snapshot) {
-        for (const node of snapshot.nodes) {
-            if (node.type !== "Symbol" || !node.metadata?.name)
-                continue;
-            const name = node.metadata.name;
-            const file = typeof node.metadata.file === "string" ? node.metadata.file : "";
-            const list = combinedSymbolIndex.get(name) ?? [];
-            list.push({ nodeId: node.id, file });
-            combinedSymbolIndex.set(name, list);
-        }
-    }
-    const localByName = new Map();
-    for (const sym of declared) {
-        localByName.set(sym.name, sym.nodeId);
-    }
-    // Call edges
-    for (const call of fileCalls) {
-        const calleeDefs = combinedSymbolIndex.get(call.callee);
-        if (!calleeDefs || calleeDefs.length === 0)
-            continue;
-        const calleeDef = calleeDefs.find((d) => d.file === relPath) ?? calleeDefs[0];
-        if (!calleeDef)
-            continue;
-        let callerNodeId;
-        if (call.caller) {
-            callerNodeId = localByName.get(call.caller);
-        }
-        if (!callerNodeId) {
-            callerNodeId = resolveCallerAtLine(declared, call.line);
-        }
-        if (!callerNodeId)
-            continue;
-        edges.push({ from: callerNodeId, to: calleeDef.nodeId, relation: "calls" });
-    }
-    // Inheritance edges
-    for (const rel of fileInherits) {
-        const childNodeId = localByName.get(rel.child);
-        if (!childNodeId)
-            continue;
-        const parentDefs = combinedSymbolIndex.get(rel.parent);
-        if (!parentDefs || parentDefs.length === 0)
-            continue;
-        const parentDef = parentDefs.find((d) => d.file === relPath) ?? parentDefs[0];
-        if (!parentDef)
-            continue;
-        edges.push({ from: childNodeId, to: parentDef.nodeId, relation: "inherits" });
+        const { edges: ciEdges, callCount, inheritCount } = (0, file_indexer_edges_js_1.buildSingleFileCallAndInheritEdges)(relPath, declared, fileCalls, fileInherits, snapshot.nodes);
+        edges.push(...ciEdges);
+        referenceCount += callCount + inheritCount;
     }
     await client.upsertNodes(nodes);
-    await client.upsertEdges(dedupEdges(edges));
+    await client.upsertEdges((0, file_indexer_edges_js_1.dedupEdges)(edges));
     // Update cache entry for this file
     cacheState[relPath] = {
         mtimeMs,
         hash: currentHash,
         numNodes: nodes.length,
     };
-    try {
-        const dir = (0, node_path_1.dirname)(cachePath);
-        (0, node_fs_1.mkdirSync)(dir, { recursive: true });
-        (0, node_fs_1.writeFileSync)(cachePath, JSON.stringify({ version: 2, state: cacheState }, null, 2), "utf8");
-    }
-    catch (error) {
-        logger_1.logger.warn({ error }, "Failed to write index cache after single-file index");
-    }
-    logger_1.logger.info({ relPath, symbols: declared.length, references: referenceCount }, "Single file indexed");
+    (0, file_indexer_cache_js_2.saveCacheState)(cachePath, cacheState);
+    logger_js_1.logger.info({ relPath, symbols: declared.length, references: referenceCount }, "Single file indexed");
     return {
         indexedFiles: 1,
         indexedSymbols: declared.length,
@@ -695,27 +257,32 @@ async function indexSingleFile(client, rootDir, absPath, options) {
         skipped: false,
     };
 }
-/**
- * Quick check whether the index cache exists and is non-empty.
- * Cheaper than hasPendingGraphIndexWork (no full workspace walk).
- */
-function hasIndexCache(rootDir) {
-    const cachePath = (0, node_path_1.join)(rootDir, CACHE_DIR, CACHE_FILE);
-    if (!(0, node_fs_1.existsSync)(cachePath))
-        return false;
-    try {
-        const cacheState = loadCacheState(cachePath, false);
-        return Object.keys(cacheState).length > 0;
+// ── Internal helpers ─────────────────────────────────────────────────
+async function pruneFileFromGraph(client, relPath) {
+    if (!client.readSnapshot || !client.deleteNode) {
+        return;
     }
-    catch {
-        return false;
+    const snapshot = client.readSnapshot();
+    const fileNodeId = `file:${relPath}`;
+    const moduleNodeId = `module:${(0, file_indexer_nodes_js_2.moduleKey)(relPath)}`;
+    const symbolPrefix = `symbol:${relPath}:`;
+    // 先收集要删除的节点 ID 集合，便于后续 O(1) 查找悬空边
+    const deletedIds = new Set();
+    const toDelete = snapshot.nodes.filter((node) => node.id === fileNodeId || node.id === moduleNodeId || node.id.startsWith(symbolPrefix));
+    for (const node of toDelete) {
+        deletedIds.add(node.id);
+        await client.deleteNode(node.id);
     }
-}
-function extOf(relPath) {
-    const idx = relPath.lastIndexOf(".");
-    if (idx < 0) {
-        return "";
+    // 清理跨文件的悬空引用边：删除任何 from 或 to 指向已删除节点 ID 的边。
+    // 某些传输后端（如 MCP HTTP）的 deleteNode 不保证级联清理边，因此显式清理以确保一致。
+    if (client.deleteEdge && deletedIds.size > 0) {
+        // 重新读取快照以获取当前边状态（部分后端的 deleteNode 可能已级联删除相关边）
+        const currentEdges = client.readSnapshot().edges;
+        for (const edge of currentEdges) {
+            if (deletedIds.has(edge.from) || deletedIds.has(edge.to)) {
+                await client.deleteEdge(edge.from, edge.to, edge.relation);
+            }
+        }
     }
-    return relPath.slice(idx).toLowerCase();
 }
 //# sourceMappingURL=file-indexer.js.map