@prih/mcp-graph-memory 1.0.3

package/dist/api/index.js

@@ -0,0 +1,473 @@
+"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.createMcpServer = createMcpServer;
+exports.startStdioServer = startStdioServer;
+exports.startHttpServer = startHttpServer;
+exports.startMultiProjectHttpServer = startMultiProjectHttpServer;
+const http_1 = __importDefault(require("http"));
+const crypto_1 = require("crypto");
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
+const embedder_1 = require("../lib/embedder");
+const index_1 = require("../api/rest/index");
+const websocket_1 = require("../api/rest/websocket");
+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 manager_types_1 = require("../graphs/manager-types");
+const listTopics = __importStar(require("../api/tools/docs/list-topics"));
+const getToc = __importStar(require("../api/tools/docs/get-toc"));
+const search = __importStar(require("../api/tools/docs/search"));
+const getNode = __importStar(require("../api/tools/docs/get-node"));
+const searchDocFiles = __importStar(require("../api/tools/docs/search-files"));
+const findExamples = __importStar(require("../api/tools/docs/find-examples"));
+const searchSnippets = __importStar(require("../api/tools/docs/search-snippets"));
+const listSnippets = __importStar(require("../api/tools/docs/list-snippets"));
+const explainSymbol = __importStar(require("../api/tools/docs/explain-symbol"));
+const crossReferences = __importStar(require("../api/tools/docs/cross-references"));
+const listFiles = __importStar(require("../api/tools/code/list-files"));
+const getFileSymbols = __importStar(require("../api/tools/code/get-file-symbols"));
+const searchCode = __importStar(require("../api/tools/code/search-code"));
+const getSymbol = __importStar(require("../api/tools/code/get-symbol"));
+const searchCodeFiles = __importStar(require("../api/tools/code/search-files"));
+const createNote = __importStar(require("../api/tools/knowledge/create-note"));
+const updateNote = __importStar(require("../api/tools/knowledge/update-note"));
+const deleteNote = __importStar(require("../api/tools/knowledge/delete-note"));
+const getNote = __importStar(require("../api/tools/knowledge/get-note"));
+const listNotes = __importStar(require("../api/tools/knowledge/list-notes"));
+const searchNotes = __importStar(require("../api/tools/knowledge/search-notes"));
+const createRelation = __importStar(require("../api/tools/knowledge/create-relation"));
+const deleteRelation = __importStar(require("../api/tools/knowledge/delete-relation"));
+const listRelations = __importStar(require("../api/tools/knowledge/list-relations"));
+const findLinkedNotes = __importStar(require("../api/tools/knowledge/find-linked-notes"));
+const addNoteAttachment = __importStar(require("../api/tools/knowledge/add-attachment"));
+const removeNoteAttachment = __importStar(require("../api/tools/knowledge/remove-attachment"));
+const listAllFiles = __importStar(require("../api/tools/file-index/list-all-files"));
+const searchAllFiles = __importStar(require("../api/tools/file-index/search-all-files"));
+const getFileInfo = __importStar(require("../api/tools/file-index/get-file-info"));
+const createTask = __importStar(require("../api/tools/tasks/create-task"));
+const updateTask = __importStar(require("../api/tools/tasks/update-task"));
+const deleteTask = __importStar(require("../api/tools/tasks/delete-task"));
+const getTask = __importStar(require("../api/tools/tasks/get-task"));
+const listTasksTool = __importStar(require("../api/tools/tasks/list-tasks"));
+const searchTasksTool = __importStar(require("../api/tools/tasks/search-tasks"));
+const moveTask = __importStar(require("../api/tools/tasks/move-task"));
+const linkTask = __importStar(require("../api/tools/tasks/link-task"));
+const createTaskLink = __importStar(require("../api/tools/tasks/create-task-link"));
+const deleteTaskLink = __importStar(require("../api/tools/tasks/delete-task-link"));
+const findLinkedTasks = __importStar(require("../api/tools/tasks/find-linked-tasks"));
+const addTaskAttachment = __importStar(require("../api/tools/tasks/add-attachment"));
+const removeTaskAttachment = __importStar(require("../api/tools/tasks/remove-attachment"));
+const createSkillTool = __importStar(require("../api/tools/skills/create-skill"));
+const updateSkillTool = __importStar(require("../api/tools/skills/update-skill"));
+const deleteSkillTool = __importStar(require("../api/tools/skills/delete-skill"));
+const getSkillTool = __importStar(require("../api/tools/skills/get-skill"));
+const listSkillsTool = __importStar(require("../api/tools/skills/list-skills"));
+const searchSkillsTool = __importStar(require("../api/tools/skills/search-skills"));
+const linkSkill = __importStar(require("../api/tools/skills/link-skill"));
+const createSkillLink = __importStar(require("../api/tools/skills/create-skill-link"));
+const deleteSkillLink = __importStar(require("../api/tools/skills/delete-skill-link"));
+const findLinkedSkills = __importStar(require("../api/tools/skills/find-linked-skills"));
+const addSkillAttachment = __importStar(require("../api/tools/skills/add-attachment"));
+const removeSkillAttachment = __importStar(require("../api/tools/skills/remove-attachment"));
+const recallSkills = __importStar(require("../api/tools/skills/recall-skills"));
+const bumpSkillUsage = __importStar(require("../api/tools/skills/bump-usage"));
+const getContext = __importStar(require("../api/tools/context/get-context"));
+/**
+ * Create an McpServer proxy that wraps registerTool handlers in a PromiseQueue.
+ * Used for mutation tools to prevent concurrent graph modifications.
+ */
+function createMutationServer(server, queue) {
+    const proxy = Object.create(server);
+    const origRegister = server.registerTool.bind(server);
+    proxy.registerTool = function (name, config, handler) {
+        if (typeof handler === 'function') {
+            const wrapped = (...handlerArgs) => queue.enqueue(() => handler(...handlerArgs));
+            return origRegister(name, config, wrapped);
+        }
+        return origRegister(name, config, handler);
+    };
+    return proxy;
+}
+function buildInstructions(ctx) {
+    const lines = [];
+    if (ctx.workspaceId) {
+        lines.push(`Connected to project "${ctx.projectId}" in workspace "${ctx.workspaceId}".`);
+        if (ctx.workspaceProjects?.length) {
+            lines.push(`Workspace projects: ${ctx.workspaceProjects.join(', ')}.`);
+        }
+        lines.push('Knowledge, tasks, and skills are shared across all workspace projects.');
+        lines.push('Docs, code, and files are specific to the current project.');
+        lines.push('Use projectId parameter in cross-graph links to reference nodes from other projects.');
+    }
+    else {
+        lines.push(`Connected to project "${ctx.projectId}".`);
+    }
+    lines.push('Use get_context tool for structured project/workspace information.');
+    return lines.join(' ');
+}
+/**
+ * Creates the McpServer with all tools wired to the given graphs.
+ * Pass docGraph to enable the 10 doc tools (5 base + 5 code-block tools);
+ * pass codeGraph to enable the 5 code tools;
+ * pass fileIndexGraph to enable the 3 file index tools.
+ * cross_references requires both docGraph and codeGraph.
+ * Knowledge tools (12) are always registered.
+ * Task tools (13) are always registered when taskGraph is provided.
+ * @param embedFn  Single EmbedFn (all graphs share it) or per-graph EmbedFnMap.
+ *                 Tests typically pass a single function; CLI passes a map for per-graph models.
+ * @param mutationQueue  Optional PromiseQueue to serialize mutation tool handlers.
+ */
+function createMcpServer(docGraph, codeGraph, knowledgeGraph, fileIndexGraph, taskGraph, embedFn, mutationQueue, projectDir, skillGraph, sessionContext) {
+    // Backward-compat: single EmbedFn → use for both document and query
+    const defaultPair = { document: (q) => (0, embedder_1.embed)(q, ''), query: (q) => (0, embedder_1.embed)(q, '') };
+    const fns = typeof embedFn === 'function'
+        ? {
+            docs: { document: embedFn, query: embedFn },
+            code: { document: embedFn, query: embedFn },
+            knowledge: { document: embedFn, query: embedFn },
+            tasks: { document: embedFn, query: embedFn },
+            files: { document: embedFn, query: embedFn },
+            skills: { document: embedFn, query: embedFn },
+        }
+        : {
+            docs: embedFn?.docs ?? defaultPair,
+            code: embedFn?.code ?? defaultPair,
+            knowledge: embedFn?.knowledge ?? defaultPair,
+            tasks: embedFn?.tasks ?? defaultPair,
+            files: embedFn?.files ?? defaultPair,
+            skills: embedFn?.skills ?? defaultPair,
+        };
+    // Build instructions for MCP clients (workspace/project context)
+    const instructions = sessionContext ? buildInstructions(sessionContext) : undefined;
+    const server = new mcp_js_1.McpServer({ name: 'mcp-graph-memory', version: '1.0.0' }, instructions ? { instructions } : undefined);
+    // Mutation tools are registered through mutServer to serialize concurrent writes
+    const mutServer = mutationQueue ? createMutationServer(server, mutationQueue) : server;
+    // Context tool (always registered)
+    getContext.register(server, sessionContext);
+    const ext = { docGraph, codeGraph, knowledgeGraph, fileIndexGraph, taskGraph, skillGraph };
+    // Docs tools (only when docGraph is provided)
+    if (docGraph) {
+        const docMgr = new docs_1.DocGraphManager(docGraph, fns.docs, ext);
+        listTopics.register(server, docMgr);
+        getToc.register(server, docMgr);
+        search.register(server, docMgr);
+        getNode.register(server, docMgr);
+        searchDocFiles.register(server, docMgr);
+        findExamples.register(server, docMgr);
+        searchSnippets.register(server, docMgr);
+        listSnippets.register(server, docMgr);
+        explainSymbol.register(server, docMgr);
+        // Cross-graph tools (require both docGraph and codeGraph)
+        if (codeGraph) {
+            const codeMgrForCross = new code_1.CodeGraphManager(codeGraph, fns.code, ext);
+            crossReferences.register(server, docMgr, codeMgrForCross);
+        }
+    }
+    // Code tools (only when codeGraph is provided)
+    if (codeGraph) {
+        const codeMgr = new code_1.CodeGraphManager(codeGraph, fns.code, ext);
+        listFiles.register(server, codeMgr);
+        getFileSymbols.register(server, codeMgr);
+        searchCode.register(server, codeMgr);
+        getSymbol.register(server, codeMgr);
+        searchCodeFiles.register(server, codeMgr);
+    }
+    // File index tools (always registered when fileIndexGraph is provided)
+    if (fileIndexGraph) {
+        const fileIndexMgr = new file_index_1.FileIndexGraphManager(fileIndexGraph, fns.files, ext);
+        listAllFiles.register(server, fileIndexMgr);
+        searchAllFiles.register(server, fileIndexMgr);
+        getFileInfo.register(server, fileIndexMgr);
+    }
+    // Knowledge tools (always registered)
+    // Mutations (create/update/delete) go through mutServer for queue serialization
+    if (knowledgeGraph) {
+        const ctx = projectDir ? { ...(0, manager_types_1.noopContext)(), projectDir } : (0, manager_types_1.noopContext)();
+        const knowledgeMgr = new knowledge_1.KnowledgeGraphManager(knowledgeGraph, fns.knowledge, ctx, {
+            docGraph, codeGraph, fileIndexGraph, taskGraph,
+        });
+        createNote.register(mutServer, knowledgeMgr);
+        updateNote.register(mutServer, knowledgeMgr);
+        deleteNote.register(mutServer, knowledgeMgr);
+        getNote.register(server, knowledgeMgr);
+        listNotes.register(server, knowledgeMgr);
+        searchNotes.register(server, knowledgeMgr);
+        createRelation.register(mutServer, knowledgeMgr);
+        deleteRelation.register(mutServer, knowledgeMgr);
+        listRelations.register(server, knowledgeMgr);
+        findLinkedNotes.register(server, knowledgeMgr);
+        addNoteAttachment.register(mutServer, knowledgeMgr);
+        removeNoteAttachment.register(mutServer, knowledgeMgr);
+    }
+    // Task tools (always registered when taskGraph is provided)
+    // Mutations go through mutServer for queue serialization
+    if (taskGraph) {
+        const taskCtx = projectDir ? { ...(0, manager_types_1.noopContext)(), projectDir } : (0, manager_types_1.noopContext)();
+        const taskMgr = new task_1.TaskGraphManager(taskGraph, fns.tasks, taskCtx, {
+            docGraph, codeGraph, knowledgeGraph, fileIndexGraph,
+        });
+        createTask.register(mutServer, taskMgr);
+        updateTask.register(mutServer, taskMgr);
+        deleteTask.register(mutServer, taskMgr);
+        getTask.register(server, taskMgr);
+        listTasksTool.register(server, taskMgr);
+        searchTasksTool.register(server, taskMgr);
+        moveTask.register(mutServer, taskMgr);
+        linkTask.register(mutServer, taskMgr);
+        createTaskLink.register(mutServer, taskMgr);
+        deleteTaskLink.register(mutServer, taskMgr);
+        findLinkedTasks.register(server, taskMgr);
+        addTaskAttachment.register(mutServer, taskMgr);
+        removeTaskAttachment.register(mutServer, taskMgr);
+    }
+    // Skill tools (always registered when skillGraph is provided)
+    if (skillGraph) {
+        const skillCtx = projectDir ? { ...(0, manager_types_1.noopContext)(), projectDir } : (0, manager_types_1.noopContext)();
+        const skillMgr = new skill_1.SkillGraphManager(skillGraph, fns.skills, skillCtx, {
+            docGraph, codeGraph, knowledgeGraph, fileIndexGraph, taskGraph,
+        });
+        createSkillTool.register(mutServer, skillMgr);
+        updateSkillTool.register(mutServer, skillMgr);
+        deleteSkillTool.register(mutServer, skillMgr);
+        getSkillTool.register(server, skillMgr);
+        listSkillsTool.register(server, skillMgr);
+        searchSkillsTool.register(server, skillMgr);
+        linkSkill.register(mutServer, skillMgr);
+        createSkillLink.register(mutServer, skillMgr);
+        deleteSkillLink.register(mutServer, skillMgr);
+        findLinkedSkills.register(server, skillMgr);
+        addSkillAttachment.register(mutServer, skillMgr);
+        removeSkillAttachment.register(mutServer, skillMgr);
+        recallSkills.register(server, skillMgr);
+        bumpSkillUsage.register(mutServer, skillMgr);
+    }
+    return server;
+}
+async function startStdioServer(docGraph, codeGraph, knowledgeGraph, fileIndexGraph, taskGraph, embedFn, projectDir, skillGraph, sessionContext) {
+    const server = createMcpServer(docGraph, codeGraph, knowledgeGraph, fileIndexGraph, taskGraph, embedFn, undefined, projectDir, skillGraph, sessionContext);
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+    process.stderr.write('[server] MCP server running on stdio\n');
+}
+// ---------------------------------------------------------------------------
+// HTTP transport (Streamable HTTP)
+// ---------------------------------------------------------------------------
+async function collectBody(req) {
+    const chunks = [];
+    for await (const chunk of req)
+        chunks.push(chunk);
+    return JSON.parse(Buffer.concat(chunks).toString());
+}
+async function startHttpServer(host, port, sessionTimeoutMs, docGraph, codeGraph, knowledgeGraph, fileIndexGraph, taskGraph, embedFn, projectDir, skillGraph, sessionContext) {
+    const sessions = new Map();
+    // Sweep stale sessions every 60s
+    const sweepInterval = setInterval(() => {
+        const now = Date.now();
+        for (const [sid, s] of sessions) {
+            if (now - s.lastActivity > sessionTimeoutMs) {
+                s.server.close().catch(() => { });
+                sessions.delete(sid);
+                process.stderr.write(`[http] Session ${sid} timed out\n`);
+            }
+        }
+    }, 60_000);
+    sweepInterval.unref();
+    const httpServer = http_1.default.createServer(async (req, res) => {
+        if (req.url !== '/mcp') {
+            res.writeHead(404).end();
+            return;
+        }
+        const sessionId = req.headers['mcp-session-id'];
+        // Existing session — route to its transport
+        if (sessionId && sessions.has(sessionId)) {
+            const session = sessions.get(sessionId);
+            session.lastActivity = Date.now();
+            const body = req.method === 'POST' ? await collectBody(req) : undefined;
+            await session.transport.handleRequest(req, res, body);
+            return;
+        }
+        // New session — only POST (initialize) can create one
+        if (req.method !== 'POST') {
+            res.writeHead(400).end('No session');
+            return;
+        }
+        const body = await collectBody(req);
+        const transport = new streamableHttp_js_1.StreamableHTTPServerTransport({
+            sessionIdGenerator: () => (0, crypto_1.randomUUID)(),
+            onsessioninitialized: (sid) => {
+                sessions.set(sid, { server: mcpServer, transport, lastActivity: Date.now() });
+                process.stderr.write(`[http] Session ${sid} started\n`);
+            },
+        });
+        transport.onclose = () => {
+            const sid = transport.sessionId;
+            if (sid)
+                sessions.delete(sid);
+        };
+        const mcpServer = createMcpServer(docGraph, codeGraph, knowledgeGraph, fileIndexGraph, taskGraph, embedFn, undefined, projectDir, skillGraph, sessionContext);
+        await mcpServer.connect(transport);
+        await transport.handleRequest(req, res, body);
+    });
+    return new Promise((resolve) => {
+        httpServer.listen(port, host, () => {
+            process.stderr.write(`[server] MCP HTTP server listening on http://${host}:${port}/mcp\n`);
+            resolve(httpServer);
+        });
+    });
+}
+async function startMultiProjectHttpServer(host, port, sessionTimeoutMs, projectManager) {
+    const sessions = new Map();
+    // Sweep stale sessions every 60s
+    const sweepInterval = setInterval(() => {
+        const now = Date.now();
+        for (const [sid, s] of sessions) {
+            if (now - s.lastActivity > sessionTimeoutMs) {
+                s.server.close().catch(() => { });
+                sessions.delete(sid);
+                process.stderr.write(`[http] Session ${sid} (project: ${s.projectId}) timed out\n`);
+            }
+        }
+    }, 60_000);
+    sweepInterval.unref();
+    // Express app handles /api/* routes
+    const restApp = (0, index_1.createRestApp)(projectManager);
+    const httpServer = http_1.default.createServer(async (req, res) => {
+        // Route /api/* to Express
+        if (req.url?.startsWith('/api/')) {
+            restApp(req, res);
+            return;
+        }
+        // Route: /mcp/{workspaceId}/{projectId} or /mcp/{projectId}
+        const wsMatch = req.url?.match(/^\/mcp\/([^/?]+)\/([^/?]+)/);
+        const projMatch = !wsMatch ? req.url?.match(/^\/mcp\/([^/?]+)/) : null;
+        if (!wsMatch && !projMatch) {
+            // Everything else (UI static files, SPA fallback) goes through Express
+            restApp(req, res);
+            return;
+        }
+        // Resolve project and optional workspace from URL
+        let projectId;
+        let workspaceId;
+        if (wsMatch) {
+            const maybeWs = decodeURIComponent(wsMatch[1]);
+            const maybeProjId = decodeURIComponent(wsMatch[2]);
+            const ws = projectManager.getWorkspace(maybeWs);
+            if (ws) {
+                // Valid workspace route
+                if (!ws.config.projects.includes(maybeProjId)) {
+                    res.writeHead(404).end(JSON.stringify({ error: `Project "${maybeProjId}" is not part of workspace "${maybeWs}"` }));
+                    return;
+                }
+                workspaceId = maybeWs;
+                projectId = maybeProjId;
+            }
+            else {
+                // Not a workspace — treat first segment as projectId (fallback)
+                projectId = maybeWs;
+            }
+        }
+        else {
+            projectId = decodeURIComponent(projMatch[1]);
+        }
+        const sessionId = req.headers['mcp-session-id'];
+        // Existing session — route to its transport
+        if (sessionId && sessions.has(sessionId)) {
+            const session = sessions.get(sessionId);
+            if (session.projectId !== projectId) {
+                res.writeHead(400).end('Session belongs to a different project');
+                return;
+            }
+            session.lastActivity = Date.now();
+            const body = req.method === 'POST' ? await collectBody(req) : undefined;
+            await session.transport.handleRequest(req, res, body);
+            return;
+        }
+        // New session — only POST (initialize) can create one
+        if (req.method !== 'POST') {
+            res.writeHead(400).end('No session');
+            return;
+        }
+        // Validate project exists
+        const project = projectManager.getProject(projectId);
+        if (!project) {
+            res.writeHead(404).end(JSON.stringify({ error: `Project "${projectId}" not found` }));
+            return;
+        }
+        // Build session context (auto-detect workspace if not in URL)
+        const ws = workspaceId
+            ? projectManager.getWorkspace(workspaceId)
+            : projectManager.getProjectWorkspace(projectId);
+        const sessionCtx = {
+            projectId,
+            workspaceId: ws?.id,
+            workspaceProjects: ws?.config.projects,
+        };
+        const body = await collectBody(req);
+        const transport = new streamableHttp_js_1.StreamableHTTPServerTransport({
+            sessionIdGenerator: () => (0, crypto_1.randomUUID)(),
+            onsessioninitialized: (sid) => {
+                sessions.set(sid, { projectId, workspaceId: ws?.id, server: mcpServer, transport, lastActivity: Date.now() });
+                process.stderr.write(`[http] Session ${sid} started (project: ${projectId}${ws ? `, workspace: ${ws.id}` : ''})\n`);
+            },
+        });
+        transport.onclose = () => {
+            const sid = transport.sessionId;
+            if (sid)
+                sessions.delete(sid);
+        };
+        const mcpServer = createMcpServer(project.docGraph, project.codeGraph, project.knowledgeGraph, project.fileIndexGraph, project.taskGraph, project.embedFns, project.mutationQueue, project.config.projectDir, project.skillGraph, sessionCtx);
+        await mcpServer.connect(transport);
+        await transport.handleRequest(req, res, body);
+    });
+    // Attach WebSocket server for real-time events
+    (0, websocket_1.attachWebSocket)(httpServer, projectManager);
+    return new Promise((resolve) => {
+        httpServer.listen(port, host, () => {
+            process.stderr.write(`[server] MCP endpoints: http://${host}:${port}/mcp/{projectId} and /mcp/{workspaceId}/{projectId}\n`);
+            process.stderr.write(`[server] REST API at http://${host}:${port}/api/\n`);
+            process.stderr.write(`[server] WebSocket at ws://${host}:${port}/api/ws\n`);
+            resolve(httpServer);
+        });
+    });
+}

package/dist/api/rest/code.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCodeRouter = createCodeRouter;
+const express_1 = require("express");
+const validation_1 = require("../../api/rest/validation");
+/** Express 5 wildcard params are arrays — join them back into a path string. */
+function joinParam(value) {
+    return Array.isArray(value) ? value.join('/') : String(value);
+}
+function createCodeRouter() {
+    const router = (0, express_1.Router)({ mergeParams: true });
+    function getProject(req) {
+        return req.project;
+    }
+    // List code files
+    router.get('/files', (0, validation_1.validateQuery)(validation_1.listQuerySchema), (req, res, next) => {
+        try {
+            const p = getProject(req);
+            if (!p.codeManager)
+                return res.json({ results: [] });
+            const q = req.validatedQuery;
+            const files = p.codeManager.listFiles(q.filter, q.limit);
+            res.json({ results: files });
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    // Get symbols for a file
+    router.get('/files/*fileId/symbols', (req, res, next) => {
+        try {
+            const p = getProject(req);
+            if (!p.codeManager)
+                return res.status(404).json({ error: 'No code graph' });
+            const fileId = joinParam(req.params.fileId);
+            const symbols = p.codeManager.getFileSymbols(fileId);
+            res.json({ results: symbols });
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    // Get symbol by ID
+    router.get('/symbols/*symbolId', (req, res, next) => {
+        try {
+            const p = getProject(req);
+            if (!p.codeManager)
+                return res.status(404).json({ error: 'No code graph' });
+            const symbolId = joinParam(req.params.symbolId);
+            const symbol = p.codeManager.getSymbol(symbolId);
+            if (!symbol)
+                return res.status(404).json({ error: 'Symbol not found' });
+            res.json(symbol);
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    // Search code
+    router.get('/search', (0, validation_1.validateQuery)(validation_1.searchQuerySchema), async (req, res, next) => {
+        try {
+            const p = getProject(req);
+            if (!p.codeManager)
+                return res.json({ results: [] });
+            const q = req.validatedQuery;
+            const results = await p.codeManager.search(q.q, {
+                topK: q.topK,
+                minScore: q.minScore,
+                searchMode: q.searchMode,
+            });
+            res.json({ results });
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    return router;
+}

package/dist/api/rest/docs.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDocsRouter = createDocsRouter;
+const express_1 = require("express");
+const validation_1 = require("../../api/rest/validation");
+/** Express 5 wildcard params are arrays — join them back into a path string. */
+function joinParam(value) {
+    return Array.isArray(value) ? value.join('/') : String(value);
+}
+function createDocsRouter() {
+    const router = (0, express_1.Router)({ mergeParams: true });
+    function getProject(req) {
+        return req.project;
+    }
+    // List topics (files)
+    router.get('/topics', (0, validation_1.validateQuery)(validation_1.listQuerySchema), (req, res, next) => {
+        try {
+            const p = getProject(req);
+            if (!p.docManager)
+                return res.json({ results: [] });
+            const q = req.validatedQuery;
+            const topics = p.docManager.listFiles(q.filter, q.limit);
+            res.json({ results: topics });
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    // Get TOC for a file
+    router.get('/toc/*fileId', (req, res, next) => {
+        try {
+            const p = getProject(req);
+            if (!p.docManager)
+                return res.status(404).json({ error: 'No doc graph' });
+            const fileId = joinParam(req.params.fileId);
+            const chunks = p.docManager.getFileChunks(fileId);
+            if (!chunks.length)
+                return res.status(404).json({ error: 'File not found' });
+            res.json({ results: chunks });
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    // Get node by ID
+    router.get('/nodes/*nodeId', (req, res, next) => {
+        try {
+            const p = getProject(req);
+            if (!p.docManager)
+                return res.status(404).json({ error: 'No doc graph' });
+            const nodeId = joinParam(req.params.nodeId);
+            const node = p.docManager.getNode(nodeId);
+            if (!node)
+                return res.status(404).json({ error: 'Node not found' });
+            res.json(node);
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    // Search docs
+    router.get('/search', (0, validation_1.validateQuery)(validation_1.searchQuerySchema), async (req, res, next) => {
+        try {
+            const p = getProject(req);
+            if (!p.docManager)
+                return res.json({ results: [] });
+            const q = req.validatedQuery;
+            const results = await p.docManager.search(q.q, {
+                topK: q.topK,
+                minScore: q.minScore,
+                searchMode: q.searchMode,
+            });
+            res.json({ results });
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    return router;
+}