@prih/mcp-graph-memory 1.0.3

package/dist/api/tools/tasks/update-task.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.register = register;
+const zod_1 = require("zod");
+const manager_types_1 = require("../../../graphs/manager-types");
+function register(server, mgr) {
+    server.registerTool('update_task', {
+        description: 'Update an existing task. Only provided fields are changed. ' +
+            'Re-embeds automatically when title or description changes. ' +
+            'Status changes auto-manage completedAt (set on done/cancelled, cleared on reopen). ' +
+            'Use move_task for a simpler status-only change. ' +
+            'Pass expectedVersion to enable optimistic locking.',
+        inputSchema: {
+            taskId: zod_1.z.string().describe('Task ID to update'),
+            title: zod_1.z.string().optional().describe('New title'),
+            description: zod_1.z.string().optional().describe('New description'),
+            status: zod_1.z.enum(['backlog', 'todo', 'in_progress', 'review', 'done', 'cancelled']).optional()
+                .describe('New status'),
+            priority: zod_1.z.enum(['critical', 'high', 'medium', 'low']).optional().describe('New priority'),
+            tags: zod_1.z.array(zod_1.z.string()).optional().describe('Replace tags array'),
+            dueDate: zod_1.z.number().nullable().optional().describe('New due date (ms timestamp) or null to clear'),
+            estimate: zod_1.z.number().nullable().optional().describe('New estimate (hours) or null to clear'),
+            expectedVersion: zod_1.z.number().int().positive().optional().describe('Current version for optimistic locking — request fails with version_conflict if the task has been updated since'),
+        },
+    }, async ({ taskId, title, description, status, priority, tags, dueDate, estimate, expectedVersion }) => {
+        const patch = {};
+        if (title !== undefined)
+            patch.title = title;
+        if (description !== undefined)
+            patch.description = description;
+        if (status !== undefined)
+            patch.status = status;
+        if (priority !== undefined)
+            patch.priority = priority;
+        if (tags !== undefined)
+            patch.tags = tags;
+        if (dueDate !== undefined)
+            patch.dueDate = dueDate;
+        if (estimate !== undefined)
+            patch.estimate = estimate;
+        try {
+            const updated = await mgr.updateTask(taskId, patch, expectedVersion);
+            if (!updated) {
+                return { content: [{ type: 'text', text: `Task "${taskId}" not found.` }], isError: true };
+            }
+            return { content: [{ type: 'text', text: JSON.stringify({ taskId, updated: true }, null, 2) }] };
+        }
+        catch (err) {
+            if (err instanceof manager_types_1.VersionConflictError) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: 'version_conflict', current: err.current, expected: err.expected }) }], isError: true };
+            }
+            throw err;
+        }
+    });
+}

package/dist/cli/index.js

@@ -0,0 +1,451 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const path_1 = __importDefault(require("path"));
+const multi_config_1 = require("../lib/multi-config");
+const project_manager_1 = require("../lib/project-manager");
+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 index_1 = require("../api/index");
+const indexer_1 = require("../cli/indexer");
+const watcher_1 = require("../lib/watcher");
+const program = new commander_1.Command();
+program
+    .name('mcp-graph-memory')
+    .description('MCP server for semantic graph memory from markdown docs and source code')
+    .version('1.0.0');
+const parseIntArg = (v) => parseInt(v, 10);
+// ---------------------------------------------------------------------------
+// Helper: resolve a single project from YAML config + --project flag
+// ---------------------------------------------------------------------------
+function resolveProject(configPath, projectId) {
+    const mc = (0, multi_config_1.loadMultiConfig)(configPath);
+    const ids = Array.from(mc.projects.keys());
+    if (ids.length === 0) {
+        process.stderr.write('[cli] No projects defined in config\n');
+        process.exit(1);
+    }
+    const id = projectId ?? ids[0];
+    const project = mc.projects.get(id);
+    if (!project) {
+        process.stderr.write(`[cli] Project "${id}" not found in config. Available: ${ids.join(', ')}\n`);
+        process.exit(1);
+    }
+    return { id, project, server: mc.server };
+}
+async function loadAllModels(projectId, config, modelsDir) {
+    for (const gn of multi_config_1.GRAPH_NAMES) {
+        await (0, embedder_1.loadModel)(config.graphEmbeddings[gn], modelsDir, config.embedMaxChars, `${projectId}:${gn}`);
+    }
+}
+function 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'),
+    };
+}
+// ---------------------------------------------------------------------------
+// Command: index — scan one project and exit
+// ---------------------------------------------------------------------------
+program
+    .command('index')
+    .description('Scan and embed all matching files, then exit (all projects or one with --project)')
+    .option('--config <path>', 'Path to graph-memory.yaml', 'graph-memory.yaml')
+    .option('--project <id>', 'Project ID to index (omit to index all)')
+    .option('--reindex', 'Discard persisted graphs and re-index from scratch')
+    .action((opts) => {
+    (async () => {
+        const mc = (0, multi_config_1.loadMultiConfig)(opts.config);
+        const reindex = !!opts.reindex;
+        if (reindex)
+            process.stderr.write('[index] Re-indexing from scratch\n');
+        const manager = new project_manager_1.ProjectManager(mc.server);
+        // Build workspace membership lookup
+        const projectWorkspace = new Map();
+        for (const [wsId, wsConfig] of mc.workspaces) {
+            for (const projId of wsConfig.projects) {
+                projectWorkspace.set(projId, wsId);
+            }
+        }
+        // Add workspaces first
+        for (const [wsId, wsConfig] of mc.workspaces) {
+            await manager.addWorkspace(wsId, wsConfig, reindex);
+        }
+        // Add projects (workspace projects share knowledge/task/skill graphs)
+        const ids = opts.project ? [opts.project] : Array.from(mc.projects.keys());
+        if (ids.length === 0) {
+            process.stderr.write('[index] No projects defined in config\n');
+            process.exit(1);
+        }
+        for (const id of ids) {
+            const project = mc.projects.get(id);
+            if (!project) {
+                process.stderr.write(`[index] Project "${id}" not found in config. Available: ${Array.from(mc.projects.keys()).join(', ')}\n`);
+                process.exit(1);
+            }
+            await manager.addProject(id, project, reindex, projectWorkspace.get(id));
+        }
+        // Load models (workspaces first, then projects)
+        for (const wsId of manager.listWorkspaces()) {
+            await manager.loadWorkspaceModels(wsId);
+        }
+        for (const id of ids) {
+            await manager.loadModels(id);
+        }
+        // Index all projects
+        for (const id of ids) {
+            process.stderr.write(`[index] Indexing project "${id}"...\n`);
+            await manager.startIndexing(id);
+            const instance = manager.getProject(id);
+            if (instance.docGraph) {
+                process.stderr.write(`[index] "${id}" docs: ${instance.docGraph.order} nodes, ${instance.docGraph.size} edges\n`);
+            }
+            if (instance.codeGraph) {
+                process.stderr.write(`[index] "${id}" code: ${instance.codeGraph.order} nodes, ${instance.codeGraph.size} edges\n`);
+            }
+            process.stderr.write(`[index] "${id}" files: ${instance.fileIndexGraph.order} nodes, ${instance.fileIndexGraph.size} edges\n`);
+        }
+        // Save workspaces
+        for (const wsId of manager.listWorkspaces()) {
+            const ws = manager.getWorkspace(wsId);
+            process.stderr.write(`[index] Workspace "${wsId}" knowledge: ${ws.knowledgeGraph.order} nodes, tasks: ${ws.taskGraph.order} nodes, skills: ${ws.skillGraph.order} nodes\n`);
+        }
+        await manager.shutdown();
+        process.stderr.write(`[index] Done. Indexed ${ids.length} project${ids.length > 1 ? 's' : ''}.\n`);
+    })().catch((err) => {
+        process.stderr.write(`[index] Fatal: ${err}\n`);
+        process.exit(1);
+    });
+});
+// ---------------------------------------------------------------------------
+// Command: mcp — single-project stdio mode
+// ---------------------------------------------------------------------------
+program
+    .command('mcp')
+    .description('Index one project (or workspace), keep watching for changes, and start MCP server on stdio')
+    .option('--config <path>', 'Path to graph-memory.yaml', 'graph-memory.yaml')
+    .option('--project <id>', 'Project ID (defaults to first project)')
+    .option('--workspace <id>', 'Workspace ID (loads all workspace projects with shared graphs)')
+    .option('--reindex', 'Discard persisted graphs and re-index from scratch')
+    .action(async (opts) => {
+    // Workspace mode: load all projects in the workspace with shared graphs
+    if (opts.workspace) {
+        const mc = (0, multi_config_1.loadMultiConfig)(opts.config);
+        const wsConfig = mc.workspaces.get(opts.workspace);
+        if (!wsConfig) {
+            process.stderr.write(`[mcp] Workspace "${opts.workspace}" not found in config. Available: ${Array.from(mc.workspaces.keys()).join(', ')}\n`);
+            process.exit(1);
+        }
+        const fresh = !!opts.reindex;
+        if (fresh)
+            process.stderr.write(`[mcp] Re-indexing workspace "${opts.workspace}" from scratch\n`);
+        const manager = new project_manager_1.ProjectManager(mc.server);
+        await manager.addWorkspace(opts.workspace, wsConfig, fresh);
+        for (const projId of wsConfig.projects) {
+            const projConfig = mc.projects.get(projId);
+            if (!projConfig) {
+                process.stderr.write(`[mcp] Project "${projId}" referenced by workspace not found\n`);
+                process.exit(1);
+            }
+            await manager.addProject(projId, projConfig, fresh, opts.workspace);
+        }
+        // Use specified project (or first) for stdio server
+        const targetId = opts.project ?? wsConfig.projects[0];
+        if (!wsConfig.projects.includes(targetId)) {
+            process.stderr.write(`[mcp] Project "${targetId}" is not part of workspace "${opts.workspace}"\n`);
+            process.exit(1);
+        }
+        const instance = manager.getProject(targetId);
+        const sessionCtx = {
+            projectId: targetId,
+            workspaceId: opts.workspace,
+            workspaceProjects: wsConfig.projects,
+        };
+        await (0, index_1.startStdioServer)(instance.docGraph, instance.codeGraph, instance.knowledgeGraph, instance.fileIndexGraph, instance.taskGraph, instance.embedFns, instance.config.projectDir, instance.skillGraph, sessionCtx);
+        // Load models and index in background
+        (async () => {
+            await manager.loadWorkspaceModels(opts.workspace);
+            for (const projId of wsConfig.projects) {
+                await manager.loadModels(projId);
+                await manager.startIndexing(projId);
+            }
+            await manager.startWorkspaceMirror(opts.workspace);
+            process.stderr.write(`[mcp] Workspace "${opts.workspace}" fully indexed\n`);
+        })().catch((err) => {
+            process.stderr.write(`[mcp] Workspace indexer error: ${err}\n`);
+        });
+        let shuttingDown = false;
+        async function shutdown() {
+            if (shuttingDown) {
+                process.stderr.write('[mcp] Force exit\n');
+                process.exit(1);
+            }
+            shuttingDown = true;
+            process.stderr.write('[mcp] Shutting down...\n');
+            const forceTimer = setTimeout(() => { process.stderr.write('[mcp] Shutdown timeout, force exit\n'); process.exit(1); }, 5000);
+            try {
+                await manager.shutdown();
+            }
+            catch { /* ignore */ }
+            clearTimeout(forceTimer);
+            // Let event loop drain naturally — avoids ONNX global thread pool destructor crash on macOS
+        }
+        process.on('SIGINT', () => { void shutdown(); });
+        process.on('SIGTERM', () => { void shutdown(); });
+        return;
+    }
+    const { id, project, server } = resolveProject(opts.config, opts.project);
+    const projectDir = path_1.default.resolve(project.projectDir);
+    const fresh = !!opts.reindex;
+    if (fresh)
+        process.stderr.write(`[mcp] Re-indexing project "${id}" from scratch\n`);
+    const ge = project.graphEmbeddings;
+    // Load persisted graphs (or create fresh ones if reindexing / model changed) and start MCP server immediately
+    const docGraph = project.docsPattern ? (0, docs_1.loadGraph)(project.graphMemory, fresh, (0, multi_config_1.embeddingFingerprint)(ge.docs)) : undefined;
+    const codeGraph = project.codePattern ? (0, code_1.loadCodeGraph)(project.graphMemory, fresh, (0, multi_config_1.embeddingFingerprint)(ge.code)) : undefined;
+    const knowledgeGraph = (0, knowledge_1.loadKnowledgeGraph)(project.graphMemory, fresh, (0, multi_config_1.embeddingFingerprint)(ge.knowledge));
+    const fileIndexGraph = (0, file_index_1.loadFileIndexGraph)(project.graphMemory, fresh, (0, multi_config_1.embeddingFingerprint)(ge.files));
+    const taskGraph = (0, task_1.loadTaskGraph)(project.graphMemory, fresh, (0, multi_config_1.embeddingFingerprint)(ge.tasks));
+    const skillGraph = (0, skill_1.loadSkillGraph)(project.graphMemory, fresh, (0, multi_config_1.embeddingFingerprint)(ge.skills));
+    const embedFns = buildEmbedFns(id);
+    const sessionCtx = { projectId: id };
+    await (0, index_1.startStdioServer)(docGraph, codeGraph, knowledgeGraph, fileIndexGraph, taskGraph, embedFns, project.projectDir, skillGraph, sessionCtx);
+    // Load models and start watcher in the background
+    let watcher;
+    let indexer;
+    async function startIndexing() {
+        await loadAllModels(id, project, server.modelsDir);
+        indexer = (0, indexer_1.createProjectIndexer)(docGraph, codeGraph, {
+            projectDir,
+            docsPattern: project.docsPattern || undefined,
+            codePattern: project.codePattern || undefined,
+            excludePattern: project.excludePattern || undefined,
+            chunkDepth: project.chunkDepth,
+            tsconfig: project.tsconfig,
+            docsModelName: `${id}:docs`,
+            codeModelName: `${id}:code`,
+            filesModelName: `${id}:files`,
+        }, knowledgeGraph, fileIndexGraph, taskGraph, skillGraph);
+        watcher = indexer.watch();
+        await watcher.whenReady;
+        await indexer.drain();
+        if (docGraph) {
+            (0, docs_1.saveGraph)(docGraph, project.graphMemory, (0, multi_config_1.embeddingFingerprint)(ge.docs));
+            process.stderr.write(`[mcp] Docs indexed. ${docGraph.order} nodes, ${docGraph.size} edges.\n`);
+        }
+        if (codeGraph) {
+            (0, code_1.saveCodeGraph)(codeGraph, project.graphMemory, (0, multi_config_1.embeddingFingerprint)(ge.code));
+            process.stderr.write(`[mcp] Code indexed. ${codeGraph.order} nodes, ${codeGraph.size} edges.\n`);
+        }
+        (0, file_index_1.saveFileIndexGraph)(fileIndexGraph, project.graphMemory, (0, multi_config_1.embeddingFingerprint)(ge.files));
+        process.stderr.write(`[mcp] File index done. ${fileIndexGraph.order} nodes, ${fileIndexGraph.size} edges.\n`);
+    }
+    startIndexing().catch((err) => {
+        process.stderr.write(`[mcp] Indexer error: ${err}\n`);
+    });
+    let shuttingDown = false;
+    async function shutdown() {
+        if (shuttingDown) {
+            process.stderr.write('[mcp] Force exit\n');
+            process.exit(1);
+        }
+        shuttingDown = true;
+        process.stderr.write('[mcp] Shutting down...\n');
+        const forceTimer = setTimeout(() => {
+            process.stderr.write('[mcp] Shutdown timeout, force exit\n');
+            process.exit(1);
+        }, 5000);
+        try {
+            if (watcher)
+                await watcher.close();
+            if (indexer)
+                await indexer.drain();
+            if (docGraph)
+                (0, docs_1.saveGraph)(docGraph, project.graphMemory, (0, multi_config_1.embeddingFingerprint)(ge.docs));
+            if (codeGraph)
+                (0, code_1.saveCodeGraph)(codeGraph, project.graphMemory, (0, multi_config_1.embeddingFingerprint)(ge.code));
+            (0, knowledge_1.saveKnowledgeGraph)(knowledgeGraph, project.graphMemory, (0, multi_config_1.embeddingFingerprint)(ge.knowledge));
+            (0, file_index_1.saveFileIndexGraph)(fileIndexGraph, project.graphMemory, (0, multi_config_1.embeddingFingerprint)(ge.files));
+            (0, task_1.saveTaskGraph)(taskGraph, project.graphMemory, (0, multi_config_1.embeddingFingerprint)(ge.tasks));
+        }
+        catch { /* ignore */ }
+        clearTimeout(forceTimer);
+        // Let event loop drain naturally — avoids ONNX global thread pool destructor crash on macOS
+    }
+    process.on('SIGINT', () => { void shutdown(); });
+    process.on('SIGTERM', () => { void shutdown(); });
+});
+// ---------------------------------------------------------------------------
+// Command: serve — multi-project HTTP mode
+// ---------------------------------------------------------------------------
+program
+    .command('serve')
+    .description('Start multi-project MCP server over HTTP')
+    .option('--config <path>', 'Path to graph-memory.yaml', 'graph-memory.yaml')
+    .option('--host <addr>', 'HTTP server bind address')
+    .option('--port <n>', 'HTTP server port', parseIntArg)
+    .option('--reindex', 'Discard persisted graphs and re-index from scratch')
+    .action(async (opts) => {
+    const mc = (0, multi_config_1.loadMultiConfig)(opts.config);
+    const host = opts.host ?? mc.server.host;
+    const port = opts.port ?? mc.server.port;
+    const sessionTimeoutMs = mc.server.sessionTimeout * 1000;
+    const reindex = !!opts.reindex;
+    if (reindex)
+        process.stderr.write('[serve] Re-indexing all projects from scratch\n');
+    const manager = new project_manager_1.ProjectManager(mc.server);
+    // Build workspace membership lookup
+    const projectWorkspace = new Map();
+    for (const [wsId, wsConfig] of mc.workspaces) {
+        for (const projId of wsConfig.projects) {
+            projectWorkspace.set(projId, wsId);
+        }
+    }
+    // Add workspaces first (loads shared knowledge/task/skill graphs)
+    for (const [wsId, wsConfig] of mc.workspaces) {
+        await manager.addWorkspace(wsId, wsConfig, reindex);
+    }
+    // Add all projects (workspace projects share knowledge/task/skill graphs)
+    for (const [id, config] of mc.projects) {
+        await manager.addProject(id, config, reindex, projectWorkspace.get(id));
+    }
+    // Start HTTP server immediately (before models are loaded)
+    const httpServer = await (0, index_1.startMultiProjectHttpServer)(host, port, sessionTimeoutMs, manager);
+    // Track open connections for graceful shutdown
+    const openSockets = new Set();
+    httpServer.on('connection', (socket) => {
+        openSockets.add(socket);
+        socket.on('close', () => openSockets.delete(socket));
+    });
+    // Start auto-save
+    manager.startAutoSave();
+    // Load models and start indexing in background (workspaces first, then projects)
+    async function initProjects() {
+        // Load workspace models
+        for (const wsId of manager.listWorkspaces()) {
+            try {
+                await manager.loadWorkspaceModels(wsId);
+            }
+            catch (err) {
+                process.stderr.write(`[serve] Failed to load workspace "${wsId}" models: ${err}\n`);
+            }
+        }
+        // Load project models and start indexing
+        for (const id of manager.listProjects()) {
+            try {
+                await manager.loadModels(id);
+                await manager.startIndexing(id);
+            }
+            catch (err) {
+                process.stderr.write(`[serve] Failed to initialize project "${id}": ${err}\n`);
+            }
+        }
+        // Start workspace mirror watchers (after all projects are indexed)
+        for (const wsId of manager.listWorkspaces()) {
+            try {
+                await manager.startWorkspaceMirror(wsId);
+            }
+            catch (err) {
+                process.stderr.write(`[serve] Failed to start workspace "${wsId}" mirror: ${err}\n`);
+            }
+        }
+    }
+    initProjects().catch((err) => {
+        process.stderr.write(`[serve] Init error: ${err}\n`);
+    });
+    // Watch YAML config for hot-reload
+    let reloading = false;
+    const configWatcher = (0, watcher_1.startWatcher)(path_1.default.dirname(path_1.default.resolve(opts.config)), {
+        onAdd: () => { },
+        onChange: async (f) => {
+            if (path_1.default.resolve(f) !== path_1.default.resolve(opts.config))
+                return;
+            if (reloading)
+                return;
+            reloading = true;
+            try {
+                process.stderr.write('[serve] Config changed, reloading...\n');
+                const newMc = (0, multi_config_1.loadMultiConfig)(opts.config);
+                const currentIds = new Set(manager.listProjects());
+                const newIds = new Set(newMc.projects.keys());
+                // Remove projects no longer in config
+                for (const id of currentIds) {
+                    if (!newIds.has(id)) {
+                        await manager.removeProject(id);
+                    }
+                }
+                // Add new projects
+                for (const [id, config] of newMc.projects) {
+                    if (!currentIds.has(id)) {
+                        await manager.addProject(id, config);
+                        await manager.loadModels(id);
+                        await manager.startIndexing(id);
+                    }
+                }
+                // Re-add changed projects
+                for (const [id, config] of newMc.projects) {
+                    if (currentIds.has(id)) {
+                        const existing = manager.getProject(id);
+                        if (existing && JSON.stringify(existing.config) !== JSON.stringify(config)) {
+                            await manager.removeProject(id);
+                            await manager.addProject(id, config);
+                            await manager.loadModels(id);
+                            await manager.startIndexing(id);
+                        }
+                    }
+                }
+                process.stderr.write('[serve] Config reload complete\n');
+            }
+            catch (err) {
+                process.stderr.write(`[serve] Config reload error: ${err}\n`);
+            }
+            finally {
+                reloading = false;
+            }
+        },
+        onUnlink: () => { },
+    }, path_1.default.basename(opts.config));
+    let shuttingDown = false;
+    async function shutdown() {
+        if (shuttingDown) {
+            process.stderr.write('[serve] Force exit\n');
+            process.exit(1);
+        }
+        shuttingDown = true;
+        process.stderr.write('[serve] Shutting down...\n');
+        // Force exit after 5s if graceful shutdown hangs
+        const forceTimer = setTimeout(() => {
+            process.stderr.write('[serve] Shutdown timeout, force exit\n');
+            process.exit(1);
+        }, 5000);
+        try {
+            httpServer.close();
+            // Destroy all open connections (including WebSocket) so the server can close
+            for (const socket of openSockets) {
+                socket.destroy();
+            }
+            openSockets.clear();
+            await configWatcher.close();
+            await manager.shutdown();
+        }
+        catch { /* ignore */ }
+        clearTimeout(forceTimer);
+        // Let event loop drain naturally — avoids ONNX global thread pool destructor crash on macOS
+    }
+    process.on('SIGINT', () => { void shutdown(); });
+    process.on('SIGTERM', () => { void shutdown(); });
+});
+program.parse();