@prih/mcp-graph-memory 1.0.3

package/dist/lib/parsers/docs.js

@@ -0,0 +1,196 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFile = parseFile;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const codeblock_1 = require("../../lib/parsers/codeblock");
+// Parse a markdown file into chunks split by headings
+function parseFile(content, absolutePath, projectDir, chunkDepth) {
+    const fileId = path_1.default.relative(projectDir, absolutePath);
+    const lines = content.split('\n');
+    const rawChunks = [];
+    let current = {
+        level: 1,
+        title: extractFileTitle(content, absolutePath),
+        lines: [],
+    };
+    for (const line of lines) {
+        const heading = matchHeading(line, chunkDepth);
+        if (heading) {
+            rawChunks.push(current);
+            current = { level: heading.level, title: heading.title, lines: [line] };
+        }
+        else {
+            current.lines.push(line);
+        }
+    }
+    rawChunks.push(current);
+    // Build Chunk objects
+    const seenIds = new Set();
+    const textChunks = rawChunks
+        .filter(c => c.lines.join('\n').trim() || c.level === 1)
+        .map(c => {
+        const chunkContent = c.lines.join('\n').trim();
+        const baseId = c.level === 1 ? fileId : `${fileId}::${c.title}`;
+        let id = baseId;
+        let counter = 2;
+        while (seenIds.has(id))
+            id = `${baseId}::${counter++}`;
+        seenIds.add(id);
+        return {
+            id,
+            fileId,
+            title: c.title,
+            content: chunkContent,
+            level: c.level,
+            links: extractLinks(chunkContent, absolutePath, projectDir),
+            embedding: [], // filled later by embedder
+            symbols: [],
+        };
+    });
+    return spliceCodeBlocks(textChunks, seenIds);
+}
+// --- code block extraction ---
+const FENCE_RE = /^(`{3,}|~{3,})(\S*)\s*\n([\s\S]*?)^\1\s*$/gm;
+function spliceCodeBlocks(chunks, seenIds) {
+    const result = [];
+    for (const chunk of chunks) {
+        // Skip chunks that are already code blocks (shouldn't happen, but guard)
+        if (chunk.language !== undefined) {
+            result.push(chunk);
+            continue;
+        }
+        const codeBlocks = [];
+        let match;
+        FENCE_RE.lastIndex = 0;
+        while ((match = FENCE_RE.exec(chunk.content)) !== null) {
+            const lang = match[2].toLowerCase();
+            const code = match[3].trimEnd();
+            if (code)
+                codeBlocks.push({ language: lang, code, index: match.index });
+        }
+        result.push(chunk);
+        // Create child chunks for each code block
+        let codeIdx = 0;
+        for (const cb of codeBlocks) {
+            codeIdx++;
+            const baseId = `${chunk.id}::code-${codeIdx}`;
+            let id = baseId;
+            let counter = 2;
+            while (seenIds.has(id))
+                id = `${baseId}::${counter++}`;
+            seenIds.add(id);
+            const lang = cb.language || undefined;
+            const symbols = lang ? (0, codeblock_1.extractSymbols)(cb.code, lang) : [];
+            result.push({
+                id,
+                fileId: chunk.fileId,
+                title: lang || 'code',
+                content: cb.code,
+                level: chunk.level + 1,
+                links: [],
+                embedding: [],
+                language: lang,
+                symbols,
+            });
+        }
+    }
+    return result;
+}
+// --- helpers ---
+function matchHeading(line, maxDepth) {
+    const match = line.match(/^(#{1,6})\s+(.+)$/);
+    if (!match)
+        return null;
+    const level = match[1].length;
+    if (level < 2 || level > maxDepth)
+        return null; // # is file title, not a chunk split
+    return { level, title: match[2].trim() };
+}
+function extractFileTitle(content, filePath) {
+    const match = content.match(/^#\s+(.+)$/m);
+    if (match)
+        return match[1].trim();
+    return path_1.default.basename(filePath, '.md');
+}
+function extractLinks(content, fromFile, projectDir) {
+    const results = new Set();
+    const fileDir = path_1.default.dirname(fromFile);
+    // [text](./path.md)
+    const mdLinks = content.matchAll(/\[[^\]]*\]\(([^)#\s]+)/g);
+    for (const [, href] of mdLinks) {
+        if (isExternal(href))
+            continue;
+        const resolved = path_1.default.resolve(fileDir, href);
+        const fileId = toFileId(resolved, projectDir);
+        if (fileId)
+            results.add(fileId);
+    }
+    // [[wiki link]] or [[wiki link|alias]]
+    const wikiLinks = content.matchAll(/\[\[([^\]|]+)(?:\|[^\]]+)?\]\]/g);
+    for (const [, name] of wikiLinks) {
+        const resolved = findWikiFile(name.trim(), projectDir);
+        if (!resolved)
+            continue;
+        const fileId = toFileId(resolved, projectDir); // same guard as md links
+        if (fileId)
+            results.add(fileId);
+    }
+    return [...results];
+}
+// Reject anything that looks like an external URL
+function isExternal(href) {
+    return /^[a-zA-Z][a-zA-Z\d+\-.]*:\/\//.test(href) // http://, ftp://, mailto://, etc.
+        || href.startsWith('//') // protocol-relative //cdn.example.com
+        || href.startsWith('data:') // data URIs
+        || href.startsWith('mailto:');
+}
+function toFileId(absolutePath, projectDir) {
+    if (!absolutePath.startsWith(projectDir))
+        return null;
+    const rel = path_1.default.relative(projectDir, absolutePath);
+    if (fs_1.default.existsSync(absolutePath))
+        return rel;
+    // try adding .md
+    const withMd = absolutePath + '.md';
+    if (fs_1.default.existsSync(withMd))
+        return path_1.default.relative(projectDir, withMd);
+    return null;
+}
+function findWikiFile(name, projectDir) {
+    const direct = path_1.default.join(projectDir, name);
+    if (fs_1.default.existsSync(direct))
+        return direct;
+    const withMd = direct + '.md';
+    if (fs_1.default.existsSync(withMd))
+        return withMd;
+    return searchRecursive(name, projectDir);
+}
+function searchRecursive(name, dir) {
+    let entries;
+    try {
+        entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return null;
+    }
+    for (const entry of entries) {
+        if (entry.name.startsWith('.'))
+            continue;
+        const full = path_1.default.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            const found = searchRecursive(name, full);
+            if (found)
+                return found;
+        }
+        else if (entry.isFile()) {
+            if (entry.name === name || entry.name === `${name}.md` || path_1.default.basename(entry.name, '.md') === name) {
+                return full;
+            }
+        }
+    }
+    return null;
+}

package/dist/lib/project-manager.js

@@ -0,0 +1,418 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectManager = void 0;
+const events_1 = require("events");
+const embedder_1 = require("../lib/embedder");
+const docs_1 = require("../graphs/docs");
+const code_1 = require("../graphs/code");
+const knowledge_1 = require("../graphs/knowledge");
+const file_index_1 = require("../graphs/file-index");
+const task_1 = require("../graphs/task");
+const skill_1 = require("../graphs/skill");
+const indexer_1 = require("../cli/indexer");
+const promise_queue_1 = require("../lib/promise-queue");
+const multi_config_1 = require("../lib/multi-config");
+const mirror_watcher_1 = require("../lib/mirror-watcher");
+// ---------------------------------------------------------------------------
+// ProjectManager
+// ---------------------------------------------------------------------------
+class ProjectManager extends events_1.EventEmitter {
+    serverConfig;
+    projects = new Map();
+    workspaces = new Map();
+    autoSaveInterval;
+    constructor(serverConfig) {
+        super();
+        this.serverConfig = serverConfig;
+    }
+    // ---------------------------------------------------------------------------
+    // Workspaces
+    // ---------------------------------------------------------------------------
+    /**
+     * Add a workspace: load shared knowledge/task/skill graphs.
+     * Must be called before addProject for projects that belong to this workspace.
+     */
+    async addWorkspace(id, config, reindex = false) {
+        if (this.workspaces.has(id)) {
+            throw new Error(`Workspace "${id}" already exists`);
+        }
+        const ge = config.graphEmbeddings;
+        const knowledgeGraph = (0, knowledge_1.loadKnowledgeGraph)(config.graphMemory, reindex, (0, multi_config_1.embeddingFingerprint)(ge.knowledge));
+        const taskGraph = (0, task_1.loadTaskGraph)(config.graphMemory, reindex, (0, multi_config_1.embeddingFingerprint)(ge.tasks));
+        const skillGraph = (0, skill_1.loadSkillGraph)(config.graphMemory, reindex, (0, multi_config_1.embeddingFingerprint)(ge.skills));
+        const mutationQueue = new promise_queue_1.PromiseQueue();
+        const mirrorTracker = new mirror_watcher_1.MirrorWriteTracker();
+        const wsInstance = {
+            id,
+            config,
+            knowledgeGraph,
+            taskGraph,
+            skillGraph,
+            mutationQueue,
+            mirrorTracker,
+            dirty: false,
+        };
+        const ctx = {
+            markDirty: () => { wsInstance.dirty = true; },
+            emit: (event, data) => { this.emit(event, data); },
+            projectId: id,
+            mirrorDir: config.mirrorDir,
+            author: (0, multi_config_1.formatAuthor)(config.author),
+        };
+        // ExternalGraphs for workspace — projectGraphs will be populated as projects are added
+        const ext = {
+            knowledgeGraph,
+            taskGraph,
+            skillGraph,
+            projectGraphs: new Map(),
+        };
+        const knowledgeEmbedFns = {
+            document: (q) => (0, embedder_1.embed)(q, '', `${id}:knowledge`),
+            query: (q) => (0, embedder_1.embedQuery)(q, `${id}:knowledge`),
+        };
+        const taskEmbedFns = {
+            document: (q) => (0, embedder_1.embed)(q, '', `${id}:tasks`),
+            query: (q) => (0, embedder_1.embedQuery)(q, `${id}:tasks`),
+        };
+        const skillEmbedFns = {
+            document: (q) => (0, embedder_1.embed)(q, '', `${id}:skills`),
+            query: (q) => (0, embedder_1.embedQuery)(q, `${id}:skills`),
+        };
+        wsInstance.knowledgeManager = new knowledge_1.KnowledgeGraphManager(knowledgeGraph, knowledgeEmbedFns, ctx, ext);
+        wsInstance.taskManager = new task_1.TaskGraphManager(taskGraph, taskEmbedFns, ctx, ext);
+        wsInstance.skillManager = new skill_1.SkillGraphManager(skillGraph, skillEmbedFns, ctx, ext);
+        wsInstance.knowledgeManager.setMirrorTracker(mirrorTracker);
+        wsInstance.taskManager.setMirrorTracker(mirrorTracker);
+        wsInstance.skillManager.setMirrorTracker(mirrorTracker);
+        this.workspaces.set(id, wsInstance);
+        process.stderr.write(`[project-manager] Added workspace "${id}"\n`);
+    }
+    /**
+     * Load embedding models for a workspace. Call after addWorkspace.
+     */
+    async loadWorkspaceModels(id) {
+        const ws = this.workspaces.get(id);
+        if (!ws)
+            throw new Error(`Workspace "${id}" not found`);
+        const ge = ws.config.graphEmbeddings;
+        await (0, embedder_1.loadModel)(ge.knowledge, this.serverConfig.modelsDir, 2000, `${id}:knowledge`);
+        await (0, embedder_1.loadModel)(ge.tasks, this.serverConfig.modelsDir, 2000, `${id}:tasks`);
+        await (0, embedder_1.loadModel)(ge.skills, this.serverConfig.modelsDir, 2000, `${id}:skills`);
+    }
+    /**
+     * Start mirror watcher for a workspace. Call after all workspace projects are indexed.
+     */
+    async startWorkspaceMirror(id) {
+        const ws = this.workspaces.get(id);
+        if (!ws)
+            throw new Error(`Workspace "${id}" not found`);
+        const mirrorConfig = {
+            projectDir: ws.config.mirrorDir,
+            knowledgeManager: ws.knowledgeManager,
+            taskManager: ws.taskManager,
+            skillManager: ws.skillManager,
+            mutationQueue: ws.mutationQueue,
+            tracker: ws.mirrorTracker,
+        };
+        await (0, mirror_watcher_1.scanMirrorDirs)(mirrorConfig);
+        ws.mirrorWatcher = (0, mirror_watcher_1.startMirrorWatcher)(mirrorConfig);
+    }
+    getWorkspace(id) {
+        return this.workspaces.get(id);
+    }
+    listWorkspaces() {
+        return Array.from(this.workspaces.keys());
+    }
+    /** Find which workspace a project belongs to. */
+    getProjectWorkspace(projectId) {
+        const project = this.projects.get(projectId);
+        if (!project?.workspaceId)
+            return undefined;
+        return this.workspaces.get(project.workspaceId);
+    }
+    /**
+     * Add a project: load graphs, load models, create indexer, start watcher.
+     */
+    async addProject(id, config, reindex = false, workspaceId) {
+        if (this.projects.has(id)) {
+            throw new Error(`Project "${id}" already exists`);
+        }
+        const ws = workspaceId ? this.workspaces.get(workspaceId) : undefined;
+        if (workspaceId && !ws)
+            throw new Error(`Workspace "${workspaceId}" not found`);
+        const ge = config.graphEmbeddings;
+        // Load per-project graphs (docs, code, file-index are always per-project)
+        const docGraph = config.docsPattern ? (0, docs_1.loadGraph)(config.graphMemory, reindex, (0, multi_config_1.embeddingFingerprint)(ge.docs)) : undefined;
+        const codeGraph = config.codePattern ? (0, code_1.loadCodeGraph)(config.graphMemory, reindex, (0, multi_config_1.embeddingFingerprint)(ge.code)) : undefined;
+        const fileIndexGraph = (0, file_index_1.loadFileIndexGraph)(config.graphMemory, reindex, (0, multi_config_1.embeddingFingerprint)(ge.files));
+        // Knowledge/tasks/skills: shared from workspace or per-project
+        const knowledgeGraph = ws ? ws.knowledgeGraph : (0, knowledge_1.loadKnowledgeGraph)(config.graphMemory, reindex, (0, multi_config_1.embeddingFingerprint)(ge.knowledge));
+        const taskGraph = ws ? ws.taskGraph : (0, task_1.loadTaskGraph)(config.graphMemory, reindex, (0, multi_config_1.embeddingFingerprint)(ge.tasks));
+        const skillGraph = ws ? ws.skillGraph : (0, skill_1.loadSkillGraph)(config.graphMemory, reindex, (0, multi_config_1.embeddingFingerprint)(ge.skills));
+        // Build embed functions (project-scoped model names)
+        const embedFns = this.buildEmbedFns(id);
+        const instance = {
+            id,
+            config,
+            docGraph,
+            codeGraph,
+            knowledgeGraph,
+            fileIndexGraph,
+            taskGraph,
+            skillGraph,
+            embedFns,
+            mutationQueue: ws ? ws.mutationQueue : new promise_queue_1.PromiseQueue(),
+            dirty: false,
+            workspaceId,
+        };
+        // Build graph manager context
+        const ctx = {
+            markDirty: () => { instance.dirty = true; },
+            emit: (event, data) => { this.emit(event, data); },
+            projectId: id,
+            projectDir: config.projectDir,
+            author: (0, multi_config_1.formatAuthor)(config.author),
+        };
+        const ext = { docGraph, codeGraph, knowledgeGraph, fileIndexGraph, taskGraph, skillGraph };
+        // In workspace mode, register this project's graphs for cross-graph resolution
+        if (ws) {
+            const wsExt = ws.knowledgeManager.externalGraphs;
+            if (wsExt?.projectGraphs) {
+                wsExt.projectGraphs.set(id, { docGraph, codeGraph, fileIndexGraph });
+            }
+        }
+        instance.docManager = docGraph ? new docs_1.DocGraphManager(docGraph, embedFns.docs, ext) : undefined;
+        instance.codeManager = codeGraph ? new code_1.CodeGraphManager(codeGraph, embedFns.code, ext) : undefined;
+        instance.fileIndexManager = new file_index_1.FileIndexGraphManager(fileIndexGraph, embedFns.files, ext);
+        if (ws) {
+            // Use workspace-level shared managers
+            instance.knowledgeManager = ws.knowledgeManager;
+            instance.taskManager = ws.taskManager;
+            instance.skillManager = ws.skillManager;
+            instance.mirrorTracker = ws.mirrorTracker;
+        }
+        else {
+            // Per-project managers
+            instance.knowledgeManager = new knowledge_1.KnowledgeGraphManager(knowledgeGraph, embedFns.knowledge, ctx, ext);
+            instance.taskManager = new task_1.TaskGraphManager(taskGraph, embedFns.tasks, ctx, ext);
+            instance.skillManager = new skill_1.SkillGraphManager(skillGraph, embedFns.skills, ctx, ext);
+            // Set up mirror write tracker for feedback loop prevention
+            const mirrorTracker = new mirror_watcher_1.MirrorWriteTracker();
+            instance.mirrorTracker = mirrorTracker;
+            instance.knowledgeManager.setMirrorTracker(mirrorTracker);
+            instance.taskManager.setMirrorTracker(mirrorTracker);
+            instance.skillManager.setMirrorTracker(mirrorTracker);
+        }
+        this.projects.set(id, instance);
+        process.stderr.write(`[project-manager] Added project "${id}" (${config.projectDir})${ws ? ` [workspace: ${workspaceId}]` : ''}\n`);
+    }
+    /**
+     * Load embedding models for a project. Call after addProject.
+     * Separated because model loading is slow and server can start before it's done.
+     */
+    async loadModels(id) {
+        const instance = this.projects.get(id);
+        if (!instance)
+            throw new Error(`Project "${id}" not found`);
+        const ge = instance.config.graphEmbeddings;
+        // Skip knowledge/tasks/skills models for workspace projects (loaded by workspace)
+        const skipGraphs = instance.workspaceId
+            ? new Set(['knowledge', 'tasks', 'skills'])
+            : new Set();
+        for (const gn of multi_config_1.GRAPH_NAMES) {
+            if (skipGraphs.has(gn))
+                continue;
+            await (0, embedder_1.loadModel)(ge[gn], this.serverConfig.modelsDir, instance.config.embedMaxChars, `${id}:${gn}`);
+        }
+    }
+    /**
+     * Start indexing + watching for a project. Call after loadModels.
+     */
+    async startIndexing(id) {
+        const instance = this.projects.get(id);
+        if (!instance)
+            throw new Error(`Project "${id}" not found`);
+        const indexer = (0, indexer_1.createProjectIndexer)(instance.docGraph, instance.codeGraph, {
+            projectDir: instance.config.projectDir,
+            docsPattern: instance.config.docsPattern || undefined,
+            codePattern: instance.config.codePattern || undefined,
+            excludePattern: instance.config.excludePattern || undefined,
+            chunkDepth: instance.config.chunkDepth,
+            tsconfig: instance.config.tsconfig,
+            docsModelName: `${id}:docs`,
+            codeModelName: `${id}:code`,
+            filesModelName: `${id}:files`,
+        }, instance.knowledgeGraph, instance.fileIndexGraph, instance.taskGraph, instance.skillGraph);
+        instance.indexer = indexer;
+        instance.watcher = indexer.watch();
+        await instance.watcher.whenReady;
+        await indexer.drain();
+        // Save after initial scan
+        this.saveProject(instance);
+        instance.dirty = false;
+        // Scan and watch .notes/ and .tasks/ for reverse import (skip for workspace projects — handled by workspace)
+        if (instance.mirrorTracker && !instance.workspaceId) {
+            const mirrorConfig = {
+                projectDir: instance.config.projectDir,
+                knowledgeManager: instance.knowledgeManager,
+                taskManager: instance.taskManager,
+                skillManager: instance.skillManager,
+                mutationQueue: instance.mutationQueue,
+                tracker: instance.mirrorTracker,
+            };
+            await (0, mirror_watcher_1.scanMirrorDirs)(mirrorConfig);
+            instance.mirrorWatcher = (0, mirror_watcher_1.startMirrorWatcher)(mirrorConfig);
+        }
+        this.emit('project:indexed', { projectId: id });
+        process.stderr.write(`[project-manager] Project "${id}" indexed\n`);
+    }
+    /**
+     * Remove a project: drain indexer, save graphs, close watcher.
+     */
+    async removeProject(id) {
+        const instance = this.projects.get(id);
+        if (!instance)
+            return;
+        if (instance.mirrorWatcher)
+            await instance.mirrorWatcher.close();
+        if (instance.watcher)
+            await instance.watcher.close();
+        if (instance.indexer)
+            await instance.indexer.drain();
+        if (instance.mcpClientCleanup)
+            await instance.mcpClientCleanup();
+        this.saveProject(instance);
+        // Clean up workspace shared graphs: remove projectGraphs reference and orphaned proxies
+        if (instance.workspaceId) {
+            const ws = this.workspaces.get(instance.workspaceId);
+            if (ws) {
+                ws.knowledgeManager.externalGraphs?.projectGraphs?.delete(id);
+                // Remove orphaned proxy nodes that reference this project
+                for (const graph of [ws.knowledgeManager.graph, ws.taskManager?.graph, ws.skillManager?.graph]) {
+                    if (!graph)
+                        continue;
+                    const toRemove = [];
+                    graph.forEachNode((nodeId, attrs) => {
+                        if (attrs.proxyFor?.projectId === id)
+                            toRemove.push(nodeId);
+                    });
+                    for (const nodeId of toRemove)
+                        graph.dropNode(nodeId);
+                }
+            }
+        }
+        this.projects.delete(id);
+        process.stderr.write(`[project-manager] Removed project "${id}"\n`);
+    }
+    getProject(id) {
+        return this.projects.get(id);
+    }
+    listProjects() {
+        return Array.from(this.projects.keys());
+    }
+    markDirty(id) {
+        const instance = this.projects.get(id);
+        if (instance)
+            instance.dirty = true;
+    }
+    /**
+     * Start auto-save interval (every intervalMs, save dirty projects).
+     */
+    startAutoSave(intervalMs = 30_000) {
+        this.autoSaveInterval = setInterval(() => {
+            for (const instance of this.projects.values()) {
+                if (instance.dirty) {
+                    try {
+                        this.saveProject(instance);
+                        instance.dirty = false;
+                    }
+                    catch (err) {
+                        process.stderr.write(`[project-manager] Auto-save error for "${instance.id}": ${err}\n`);
+                    }
+                }
+            }
+            for (const ws of this.workspaces.values()) {
+                if (ws.dirty) {
+                    try {
+                        this.saveWorkspace(ws);
+                        ws.dirty = false;
+                    }
+                    catch (err) {
+                        process.stderr.write(`[project-manager] Auto-save error for workspace "${ws.id}": ${err}\n`);
+                    }
+                }
+            }
+        }, intervalMs);
+        this.autoSaveInterval.unref();
+    }
+    /**
+     * Save all projects and shut down.
+     */
+    async shutdown() {
+        if (this.autoSaveInterval)
+            clearInterval(this.autoSaveInterval);
+        for (const instance of this.projects.values()) {
+            try {
+                if (instance.mirrorWatcher)
+                    await instance.mirrorWatcher.close();
+                if (instance.watcher)
+                    await instance.watcher.close();
+                if (instance.indexer)
+                    await instance.indexer.drain();
+                if (instance.mcpClientCleanup)
+                    await instance.mcpClientCleanup();
+                this.saveProject(instance);
+            }
+            catch (err) {
+                process.stderr.write(`[project-manager] Shutdown error for "${instance.id}": ${err}\n`);
+            }
+        }
+        for (const ws of this.workspaces.values()) {
+            try {
+                if (ws.mirrorWatcher)
+                    await ws.mirrorWatcher.close();
+                this.saveWorkspace(ws);
+            }
+            catch (err) {
+                process.stderr.write(`[project-manager] Shutdown error for workspace "${ws.id}": ${err}\n`);
+            }
+        }
+        this.projects.clear();
+        this.workspaces.clear();
+        process.stderr.write('[project-manager] Shutdown complete\n');
+    }
+    // ---------------------------------------------------------------------------
+    // Private helpers
+    // ---------------------------------------------------------------------------
+    saveProject(instance) {
+        const ge = instance.config.graphEmbeddings;
+        if (instance.docGraph)
+            (0, docs_1.saveGraph)(instance.docGraph, instance.config.graphMemory, (0, multi_config_1.embeddingFingerprint)(ge.docs));
+        if (instance.codeGraph)
+            (0, code_1.saveCodeGraph)(instance.codeGraph, instance.config.graphMemory, (0, multi_config_1.embeddingFingerprint)(ge.code));
+        (0, file_index_1.saveFileIndexGraph)(instance.fileIndexGraph, instance.config.graphMemory, (0, multi_config_1.embeddingFingerprint)(ge.files));
+        // Skip knowledge/tasks/skills for workspace projects (saved by workspace)
+        if (!instance.workspaceId) {
+            (0, knowledge_1.saveKnowledgeGraph)(instance.knowledgeGraph, instance.config.graphMemory, (0, multi_config_1.embeddingFingerprint)(ge.knowledge));
+            (0, task_1.saveTaskGraph)(instance.taskGraph, instance.config.graphMemory, (0, multi_config_1.embeddingFingerprint)(ge.tasks));
+            (0, skill_1.saveSkillGraph)(instance.skillGraph, instance.config.graphMemory, (0, multi_config_1.embeddingFingerprint)(ge.skills));
+        }
+    }
+    saveWorkspace(ws) {
+        const ge = ws.config.graphEmbeddings;
+        (0, knowledge_1.saveKnowledgeGraph)(ws.knowledgeGraph, ws.config.graphMemory, (0, multi_config_1.embeddingFingerprint)(ge.knowledge));
+        (0, task_1.saveTaskGraph)(ws.taskGraph, ws.config.graphMemory, (0, multi_config_1.embeddingFingerprint)(ge.tasks));
+        (0, skill_1.saveSkillGraph)(ws.skillGraph, ws.config.graphMemory, (0, multi_config_1.embeddingFingerprint)(ge.skills));
+    }
+    buildEmbedFns(projectId) {
+        const pair = (gn) => ({
+            document: (q) => (0, embedder_1.embed)(q, '', `${projectId}:${gn}`),
+            query: (q) => (0, embedder_1.embedQuery)(q, `${projectId}:${gn}`),
+        });
+        return {
+            docs: pair('docs'), code: pair('code'), knowledge: pair('knowledge'),
+            tasks: pair('tasks'), files: pair('files'), skills: pair('skills'),
+        };
+    }
+}
+exports.ProjectManager = ProjectManager;

package/dist/lib/promise-queue.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromiseQueue = void 0;
+/**
+ * A simple serial promise queue.
+ * Enqueued functions execute one at a time, in order.
+ * If a function rejects, the error propagates to the caller
+ * but the queue continues processing subsequent items.
+ */
+class PromiseQueue {
+    chain = Promise.resolve();
+    /**
+     * Enqueue an async function. Returns a promise that resolves/rejects
+     * with the function's result once it has been executed in turn.
+     */
+    enqueue(fn) {
+        return new Promise((resolve, reject) => {
+            this.chain = this.chain.then(fn).then(resolve, reject);
+        });
+    }
+}
+exports.PromiseQueue = PromiseQueue;