@graphmemory/server 1.1.0

package/dist/cli/indexer.js

@@ -0,0 +1,275 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProjectIndexer = createProjectIndexer;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const micromatch_1 = __importDefault(require("micromatch"));
+const embedder_1 = require("../lib/embedder");
+const docs_1 = require("../lib/parsers/docs");
+const docs_2 = require("../graphs/docs");
+const code_1 = require("../lib/parsers/code");
+const code_2 = require("../graphs/code");
+const watcher_1 = require("../lib/watcher");
+const knowledge_1 = require("../graphs/knowledge");
+const task_1 = require("../graphs/task");
+const skill_1 = require("../graphs/skill");
+const file_index_1 = require("../graphs/file-index");
+function createProjectIndexer(docGraph, codeGraph, config, knowledgeGraph, fileIndexGraph, taskGraph, skillGraph) {
+    // Three independent serial queues — docs, code, and file index.
+    let docsQueue = Promise.resolve();
+    let codeQueue = Promise.resolve();
+    let fileQueue = Promise.resolve();
+    // Error tracking
+    let docErrors = 0;
+    let codeErrors = 0;
+    let fileErrors = 0;
+    function enqueueDoc(fn) {
+        docsQueue = docsQueue.then(fn).catch((err) => {
+            docErrors++;
+            process.stderr.write(`[indexer] Doc error: ${err}\n`);
+        });
+    }
+    function enqueueCode(fn) {
+        codeQueue = codeQueue.then(fn).catch((err) => {
+            codeErrors++;
+            process.stderr.write(`[indexer] Code error: ${err}\n`);
+        });
+    }
+    function enqueueFile(fn) {
+        fileQueue = fileQueue.then(fn).catch((err) => {
+            fileErrors++;
+            process.stderr.write(`[indexer] File index error: ${err}\n`);
+        });
+    }
+    // ---------------------------------------------------------------------------
+    // Per-file indexing
+    // ---------------------------------------------------------------------------
+    async function indexDocFile(absolutePath) {
+        if (!docGraph)
+            return;
+        let stat;
+        try {
+            stat = fs_1.default.statSync(absolutePath);
+        }
+        catch {
+            // File disappeared — remove stale node from graph if present
+            const fileId = path_1.default.relative(config.projectDir, absolutePath);
+            if (docGraph.hasNode(fileId)) {
+                (0, docs_2.removeFile)(docGraph, fileId);
+                if (knowledgeGraph)
+                    (0, knowledge_1.cleanupProxies)(knowledgeGraph, 'docs', docGraph, config.projectId);
+                if (taskGraph)
+                    (0, task_1.cleanupProxies)(taskGraph, 'docs', docGraph, config.projectId);
+                if (skillGraph)
+                    (0, skill_1.cleanupProxies)(skillGraph, 'docs', docGraph, config.projectId);
+            }
+            return;
+        }
+        const mtime = stat.mtimeMs;
+        const fileId = path_1.default.relative(config.projectDir, absolutePath);
+        if ((0, docs_2.getFileMtime)(docGraph, fileId) === mtime)
+            return;
+        if (config.maxFileSize && stat.size > config.maxFileSize) {
+            process.stderr.write(`[indexer] skip doc  ${fileId} (${(stat.size / 1024 / 1024).toFixed(1)} MB exceeds limit)\n`);
+            return;
+        }
+        const content = fs_1.default.readFileSync(absolutePath, 'utf-8');
+        const chunks = await (0, docs_1.parseFile)(content, absolutePath, config.projectDir, config.chunkDepth);
+        // Batch-embed all chunks + file-level in one forward pass
+        const batchInputs = chunks.map(c => ({ title: c.title, content: c.content }));
+        const rootChunk = chunks.find(c => c.level === 1);
+        const embedText = rootChunk?.title
+            ? `${fileId} ${rootChunk.title}`
+            : `${fileId} ${rootChunk?.content.slice(0, 200) ?? ''}`;
+        batchInputs.push({ title: embedText, content: '' });
+        const embeddings = await (0, embedder_1.embedBatch)(batchInputs, config.docsModelName);
+        for (let i = 0; i < chunks.length; i++) {
+            chunks[i].embedding = embeddings[i];
+        }
+        (0, docs_2.updateFile)(docGraph, chunks, mtime);
+        if (rootChunk && docGraph.hasNode(rootChunk.id)) {
+            docGraph.setNodeAttribute(rootChunk.id, 'fileEmbedding', embeddings[chunks.length]);
+        }
+        process.stderr.write(`[indexer] doc  ${fileId} (${chunks.length} chunks)\n`);
+    }
+    async function indexCodeFile(absolutePath) {
+        if (!codeGraph)
+            return;
+        let stat;
+        try {
+            stat = fs_1.default.statSync(absolutePath);
+        }
+        catch {
+            const fileId = path_1.default.relative(config.projectDir, absolutePath);
+            if (codeGraph.hasNode(fileId)) {
+                (0, code_2.removeCodeFile)(codeGraph, fileId);
+                if (knowledgeGraph)
+                    (0, knowledge_1.cleanupProxies)(knowledgeGraph, 'code', codeGraph, config.projectId);
+                if (taskGraph)
+                    (0, task_1.cleanupProxies)(taskGraph, 'code', codeGraph, config.projectId);
+                if (skillGraph)
+                    (0, skill_1.cleanupProxies)(skillGraph, 'code', codeGraph, config.projectId);
+            }
+            return;
+        }
+        const mtime = stat.mtimeMs;
+        const fileId = path_1.default.relative(config.projectDir, absolutePath);
+        if ((0, code_2.getCodeFileMtime)(codeGraph, fileId) === mtime)
+            return;
+        if (config.maxFileSize && stat.size > config.maxFileSize) {
+            process.stderr.write(`[indexer] skip code ${fileId} (${(stat.size / 1024 / 1024).toFixed(1)} MB exceeds limit)\n`);
+            return;
+        }
+        const parsed = await (0, code_1.parseCodeFile)(absolutePath, config.projectDir, mtime);
+        // Batch-embed all symbols + file-level in one forward pass
+        const batchInputs = parsed.nodes.map(({ attrs }) => ({ title: attrs.signature, content: attrs.docComment }));
+        batchInputs.push({ title: fileId, content: '' });
+        const embeddings = await (0, embedder_1.embedBatch)(batchInputs, config.codeModelName);
+        for (let i = 0; i < parsed.nodes.length; i++) {
+            parsed.nodes[i].attrs.embedding = embeddings[i];
+        }
+        (0, code_2.updateCodeFile)(codeGraph, parsed);
+        if (codeGraph.hasNode(fileId)) {
+            codeGraph.setNodeAttribute(fileId, 'fileEmbedding', embeddings[parsed.nodes.length]);
+        }
+        process.stderr.write(`[indexer] code ${fileId} (${parsed.nodes.length} symbols)\n`);
+    }
+    async function indexFileEntry(absolutePath) {
+        if (!fileIndexGraph)
+            return;
+        let stat;
+        try {
+            stat = fs_1.default.statSync(absolutePath);
+        }
+        catch {
+            const filePath = path_1.default.relative(config.projectDir, absolutePath);
+            if (fileIndexGraph.hasNode(filePath)) {
+                (0, file_index_1.removeFileEntry)(fileIndexGraph, filePath);
+                if (knowledgeGraph)
+                    (0, knowledge_1.cleanupProxies)(knowledgeGraph, 'files', fileIndexGraph, config.projectId);
+                if (taskGraph)
+                    (0, task_1.cleanupProxies)(taskGraph, 'files', fileIndexGraph, config.projectId);
+                if (skillGraph)
+                    (0, skill_1.cleanupProxies)(skillGraph, 'files', fileIndexGraph, config.projectId);
+            }
+            return;
+        }
+        const mtime = stat.mtimeMs;
+        const filePath = path_1.default.relative(config.projectDir, absolutePath);
+        if ((0, file_index_1.getFileEntryMtime)(fileIndexGraph, filePath) === mtime)
+            return;
+        const embedding = await (0, embedder_1.embed)(filePath, '', config.filesModelName);
+        (0, file_index_1.updateFileEntry)(fileIndexGraph, filePath, stat.size, mtime, embedding);
+    }
+    // ---------------------------------------------------------------------------
+    // Dispatch: match a file against both patterns, enqueue as needed
+    // ---------------------------------------------------------------------------
+    // Pre-accumulated exclude arrays (already includes server + workspace + project + graph)
+    const docsExclude = config.docsExclude;
+    const codeExclude = config.codeExclude;
+    const filesExclude = config.filesExclude;
+    // Union for directory pruning during scan
+    const allExcludePatterns = [...new Set([...docsExclude, ...codeExclude, ...filesExclude])];
+    function isExcluded(rel, patterns) {
+        return patterns.length > 0 && micromatch_1.default.isMatch(rel, patterns);
+    }
+    function dispatchAdd(absolutePath) {
+        const rel = path_1.default.relative(config.projectDir, absolutePath);
+        if (config.docsInclude && !isExcluded(rel, docsExclude) && micromatch_1.default.isMatch(rel, config.docsInclude)) {
+            enqueueDoc(() => indexDocFile(absolutePath));
+        }
+        if (codeGraph && config.codeInclude && !isExcluded(rel, codeExclude) && micromatch_1.default.isMatch(rel, config.codeInclude)) {
+            enqueueCode(() => indexCodeFile(absolutePath));
+        }
+        if (fileIndexGraph && !isExcluded(rel, filesExclude)) {
+            enqueueFile(() => indexFileEntry(absolutePath));
+        }
+    }
+    function dispatchRemove(absolutePath) {
+        const rel = path_1.default.relative(config.projectDir, absolutePath);
+        if (docGraph && config.docsInclude && !isExcluded(rel, docsExclude) && micromatch_1.default.isMatch(rel, config.docsInclude)) {
+            (0, docs_2.removeFile)(docGraph, rel);
+            if (knowledgeGraph)
+                (0, knowledge_1.cleanupProxies)(knowledgeGraph, 'docs', docGraph, config.projectId);
+            if (taskGraph)
+                (0, task_1.cleanupProxies)(taskGraph, 'docs', docGraph, config.projectId);
+            if (skillGraph)
+                (0, skill_1.cleanupProxies)(skillGraph, 'docs', docGraph, config.projectId);
+            process.stderr.write(`[indexer] removed doc  ${rel}\n`);
+        }
+        if (codeGraph && config.codeInclude && !isExcluded(rel, codeExclude) && micromatch_1.default.isMatch(rel, config.codeInclude)) {
+            (0, code_2.removeCodeFile)(codeGraph, rel);
+            if (knowledgeGraph)
+                (0, knowledge_1.cleanupProxies)(knowledgeGraph, 'code', codeGraph, config.projectId);
+            if (taskGraph)
+                (0, task_1.cleanupProxies)(taskGraph, 'code', codeGraph, config.projectId);
+            if (skillGraph)
+                (0, skill_1.cleanupProxies)(skillGraph, 'code', codeGraph, config.projectId);
+            process.stderr.write(`[indexer] removed code ${rel}\n`);
+        }
+        if (fileIndexGraph && !isExcluded(rel, filesExclude)) {
+            (0, file_index_1.removeFileEntry)(fileIndexGraph, rel);
+            if (knowledgeGraph)
+                (0, knowledge_1.cleanupProxies)(knowledgeGraph, 'files', fileIndexGraph, config.projectId);
+            if (taskGraph)
+                (0, task_1.cleanupProxies)(taskGraph, 'files', fileIndexGraph, config.projectId);
+            if (skillGraph)
+                (0, skill_1.cleanupProxies)(skillGraph, 'files', fileIndexGraph, config.projectId);
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Public API
+    // ---------------------------------------------------------------------------
+    function scan() {
+        function walk(dir) {
+            for (const entry of fs_1.default.readdirSync(dir, { withFileTypes: true })) {
+                if (entry.name.startsWith('.'))
+                    continue;
+                const full = path_1.default.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    const relDir = path_1.default.relative(config.projectDir, full);
+                    // prune directory if ALL graphs would exclude it
+                    if (allExcludePatterns.length > 0 && (micromatch_1.default.isMatch(relDir, allExcludePatterns) ||
+                        micromatch_1.default.isMatch(relDir + '/x', allExcludePatterns)))
+                        continue;
+                    walk(full);
+                }
+                else if (entry.isFile()) {
+                    dispatchAdd(full);
+                }
+            }
+        }
+        walk(config.projectDir);
+    }
+    function watch() {
+        return (0, watcher_1.startWatcher)(config.projectDir, {
+            onAdd: (f) => dispatchAdd(f),
+            onChange: (f) => dispatchAdd(f),
+            onUnlink: (f) => dispatchRemove(f),
+        }, '**/*', allExcludePatterns.length > 0 ? allExcludePatterns : undefined);
+    }
+    async function drain() {
+        await Promise.all([docsQueue, codeQueue, fileQueue]);
+        if (fileIndexGraph)
+            (0, file_index_1.rebuildDirectoryStats)(fileIndexGraph);
+        // Resolve cross-file edges that were deferred during indexing
+        if (docGraph) {
+            const docLinks = (0, docs_2.resolvePendingLinks)(docGraph);
+            if (docLinks > 0)
+                process.stderr.write(`[indexer] Resolved ${docLinks} deferred doc cross-file link(s)\n`);
+        }
+        if (codeGraph) {
+            const codeImports = (0, code_2.resolvePendingImports)(codeGraph);
+            if (codeImports > 0)
+                process.stderr.write(`[indexer] Resolved ${codeImports} deferred code import edge(s)\n`);
+        }
+        const totalErrors = docErrors + codeErrors + fileErrors;
+        if (totalErrors > 0) {
+            process.stderr.write(`[indexer] Completed with ${totalErrors} error(s): docs=${docErrors}, code=${codeErrors}, files=${fileErrors}\n`);
+        }
+    }
+    return { scan, watch, drain };
+}

package/dist/graphs/attachment-types.js

@@ -0,0 +1,74 @@
+"use strict";
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanAttachments = scanAttachments;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const mime_1 = __importDefault(require("mime"));
+/**
+ * Scan the attachments/ subdirectory of an entity directory.
+ * Returns metadata for each file found.
+ */
+function scanAttachments(entityDir) {
+    try {
+        const attachmentsDir = path.join(entityDir, 'attachments');
+        if (!fs.existsSync(attachmentsDir))
+            return [];
+        const entries = fs.readdirSync(attachmentsDir, { withFileTypes: true });
+        const attachments = [];
+        for (const entry of entries) {
+            if (!entry.isFile())
+                continue;
+            const filePath = path.join(attachmentsDir, entry.name);
+            try {
+                const stat = fs.statSync(filePath);
+                attachments.push({
+                    filename: entry.name,
+                    mimeType: mime_1.default.getType(entry.name) ?? 'application/octet-stream',
+                    size: stat.size,
+                    addedAt: stat.birthtimeMs || stat.mtimeMs,
+                });
+            }
+            catch { /* skip unreadable files */ }
+        }
+        return attachments;
+    }
+    catch {
+        return [];
+    }
+}

package/dist/graphs/code-types.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCodeGraph = createCodeGraph;
+const graphology_1 = require("graphology");
+function createCodeGraph() {
+    return new graphology_1.DirectedGraph({
+        multi: false,
+        allowSelfLoops: false,
+    });
+}

package/dist/graphs/code.js

@@ -0,0 +1,204 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeGraphManager = exports.createCodeGraph = void 0;
+exports.updateCodeFile = updateCodeFile;
+exports.resolvePendingImports = resolvePendingImports;
+exports.removeCodeFile = removeCodeFile;
+exports.getFileSymbols = getFileSymbols;
+exports.getCodeFileMtime = getCodeFileMtime;
+exports.listCodeFiles = listCodeFiles;
+exports.saveCodeGraph = saveCodeGraph;
+exports.loadCodeGraph = loadCodeGraph;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const code_types_1 = require("../graphs/code-types");
+Object.defineProperty(exports, "createCodeGraph", { enumerable: true, get: function () { return code_types_1.createCodeGraph; } });
+const manager_types_1 = require("../graphs/manager-types");
+const code_1 = require("../lib/search/code");
+const files_1 = require("../lib/search/files");
+const bm25_1 = require("../lib/search/bm25");
+// ---------------------------------------------------------------------------
+// CRUD
+// ---------------------------------------------------------------------------
+/** Replace all nodes/edges for a given file. */
+function updateCodeFile(graph, parsed) {
+    removeCodeFile(graph, parsed.fileId);
+    for (const { id, attrs } of parsed.nodes) {
+        graph.addNode(id, attrs);
+    }
+    const pendingImports = [];
+    for (const { from, to, attrs } of parsed.edges) {
+        if (!graph.hasNode(to)) {
+            if (attrs.kind === 'imports')
+                pendingImports.push(to);
+            continue;
+        }
+        if (graph.hasNode(from) && !graph.hasEdge(from, to)) {
+            graph.addEdgeWithKey(`${from}→${to}`, from, to, attrs);
+        }
+    }
+    // Store pending imports on the file node for post-drain resolution
+    if (pendingImports.length > 0 && graph.hasNode(parsed.fileId)) {
+        graph.setNodeAttribute(parsed.fileId, 'pendingImports', pendingImports);
+    }
+}
+/**
+ * Resolve pending import edges after all files have been indexed.
+ * Creates 'imports' edges from file nodes to targets that are now in the graph.
+ */
+function resolvePendingImports(graph) {
+    let created = 0;
+    graph.forEachNode((id, attrs) => {
+        if (!attrs.pendingImports || attrs.pendingImports.length === 0)
+            return;
+        const remaining = [];
+        for (const targetId of attrs.pendingImports) {
+            if (graph.hasNode(targetId) && id !== targetId) {
+                const edgeKey = `${id}→${targetId}`;
+                if (!graph.hasEdge(edgeKey)) {
+                    graph.addEdgeWithKey(edgeKey, id, targetId, { kind: 'imports' });
+                    created++;
+                }
+            }
+            else {
+                remaining.push(targetId);
+            }
+        }
+        graph.setNodeAttribute(id, 'pendingImports', remaining.length > 0 ? remaining : undefined);
+    });
+    return created;
+}
+/** Remove all nodes (and their incident edges) belonging to a file. */
+function removeCodeFile(graph, fileId) {
+    const toRemove = graph.filterNodes((_, attrs) => attrs.fileId === fileId);
+    toRemove.forEach(id => graph.dropNode(id));
+}
+/** Return all nodes for a file, sorted by startLine. */
+function getFileSymbols(graph, fileId) {
+    return graph
+        .filterNodes((_, attrs) => attrs.fileId === fileId)
+        .map(id => ({ id, ...graph.getNodeAttributes(id) }))
+        .sort((a, b) => a.startLine - b.startLine);
+}
+/** Return mtime for any node in the file (0 if not indexed). */
+function getCodeFileMtime(graph, fileId) {
+    const nodes = graph.filterNodes((_, attrs) => attrs.fileId === fileId);
+    if (nodes.length === 0)
+        return 0;
+    return graph.getNodeAttribute(nodes[0], 'mtime');
+}
+/** List all indexed files with symbol counts. */
+function listCodeFiles(graph, filter, limit = 20) {
+    const files = new Map();
+    const lowerFilter = filter?.toLowerCase();
+    graph.forEachNode((_, attrs) => {
+        files.set(attrs.fileId, (files.get(attrs.fileId) ?? 0) + 1);
+    });
+    let result = [...files.entries()]
+        .map(([fileId, symbolCount]) => ({ fileId, symbolCount }))
+        .sort((a, b) => a.fileId.localeCompare(b.fileId));
+    if (lowerFilter) {
+        result = result.filter(f => f.fileId.toLowerCase().includes(lowerFilter));
+    }
+    return result.slice(0, limit);
+}
+// ---------------------------------------------------------------------------
+// Persistence
+// ---------------------------------------------------------------------------
+function saveCodeGraph(graph, graphMemory, embeddingFingerprint) {
+    fs_1.default.mkdirSync(graphMemory, { recursive: true });
+    const file = path_1.default.join(graphMemory, 'code.json');
+    const tmp = file + '.tmp';
+    fs_1.default.writeFileSync(tmp, JSON.stringify({ embeddingModel: embeddingFingerprint, graph: graph.export() }));
+    fs_1.default.renameSync(tmp, file);
+}
+function loadCodeGraph(graphMemory, fresh = false, embeddingFingerprint) {
+    const graph = (0, code_types_1.createCodeGraph)();
+    if (fresh)
+        return graph;
+    const file = path_1.default.join(graphMemory, 'code.json');
+    if (!fs_1.default.existsSync(file))
+        return graph;
+    try {
+        const data = JSON.parse(fs_1.default.readFileSync(file, 'utf-8'));
+        const stored = data.embeddingModel;
+        if (embeddingFingerprint && stored !== embeddingFingerprint) {
+            process.stderr.write(`[code-graph] Embedding config changed, re-indexing code graph\n`);
+            return graph;
+        }
+        graph.import(data.graph);
+        process.stderr.write(`[code-graph] Loaded ${graph.order} nodes, ${graph.size} edges\n`);
+    }
+    catch (err) {
+        process.stderr.write(`[code-graph] Failed to load graph, starting fresh: ${err}\n`);
+    }
+    return graph;
+}
+// ---------------------------------------------------------------------------
+// CodeGraphManager — unified API for code graph operations
+// ---------------------------------------------------------------------------
+class CodeGraphManager {
+    _graph;
+    embedFns;
+    ext;
+    _bm25Index = new bm25_1.BM25Index((attrs) => `${attrs.name} ${attrs.signature} ${attrs.docComment}`);
+    constructor(_graph, embedFns, ext = {}) {
+        this._graph = _graph;
+        this.embedFns = embedFns;
+        this.ext = ext;
+        _graph.forEachNode((id, attrs) => {
+            this._bm25Index.addDocument(id, attrs);
+        });
+    }
+    get graph() { return this._graph; }
+    get bm25Index() { return this._bm25Index; }
+    // -- Write (used by indexer) --
+    updateFile(parsed) {
+        // Remove old nodes from BM25
+        this._graph.forEachNode((id, attrs) => {
+            if (attrs.fileId === parsed.fileId)
+                this._bm25Index.removeDocument(id);
+        });
+        updateCodeFile(this._graph, parsed);
+        // Add new nodes to BM25
+        this._graph.forEachNode((id, attrs) => {
+            if (attrs.fileId === parsed.fileId)
+                this._bm25Index.addDocument(id, attrs);
+        });
+    }
+    removeFile(fileId) {
+        this._graph.forEachNode((id, attrs) => {
+            if (attrs.fileId === fileId)
+                this._bm25Index.removeDocument(id);
+        });
+        removeCodeFile(this._graph, fileId);
+    }
+    // -- Read --
+    listFiles(filter, limit) {
+        return listCodeFiles(this._graph, filter, limit);
+    }
+    getFileSymbols(fileId) {
+        return getFileSymbols(this._graph, fileId);
+    }
+    getFileMtime(fileId) {
+        return getCodeFileMtime(this._graph, fileId);
+    }
+    getSymbol(nodeId) {
+        if (!this._graph.hasNode(nodeId))
+            return null;
+        const crossLinks = (0, manager_types_1.findIncomingCrossLinks)(this.ext, 'code', nodeId);
+        return { id: nodeId, ...this._graph.getNodeAttributes(nodeId), ...(crossLinks.length > 0 ? { crossLinks } : {}) };
+    }
+    async search(query, opts) {
+        const embedding = opts?.searchMode === 'keyword' ? [] : await this.embedFns.query(query);
+        return (0, code_1.searchCode)(this._graph, embedding, { ...opts, queryText: query, bm25Index: this._bm25Index });
+    }
+    async searchFiles(query, opts) {
+        const embedding = await this.embedFns.query(query);
+        return (0, files_1.searchCodeFiles)(this._graph, embedding, opts);
+    }
+}
+exports.CodeGraphManager = CodeGraphManager;