@prih/mcp-graph-memory 1.0.3

package/dist/api/rest/files.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFilesRouter = createFilesRouter;
+const path_1 = __importDefault(require("path"));
+const express_1 = require("express");
+const validation_1 = require("../../api/rest/validation");
+function createFilesRouter() {
+    const router = (0, express_1.Router)({ mergeParams: true });
+    function getProject(req) {
+        return req.project;
+    }
+    // List all files
+    router.get('/', (0, validation_1.validateQuery)(validation_1.fileListSchema), (req, res, next) => {
+        try {
+            const p = getProject(req);
+            const q = req.validatedQuery;
+            const files = p.fileIndexManager.listAllFiles(q);
+            res.json({ results: files });
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    // Search files
+    router.get('/search', (0, validation_1.validateQuery)(validation_1.searchQuerySchema), async (req, res, next) => {
+        try {
+            const p = getProject(req);
+            const q = req.validatedQuery;
+            const results = await p.fileIndexManager.search(q.q, {
+                topK: q.topK,
+                minScore: q.minScore,
+            });
+            res.json({ results });
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    // Get file info
+    router.get('/info', (req, res, next) => {
+        try {
+            const p = getProject(req);
+            const filePath = req.query.path;
+            if (!filePath)
+                return res.status(400).json({ error: 'path query parameter required' });
+            // Prevent path traversal
+            const normalized = path_1.default.normalize(filePath);
+            if (normalized.startsWith('..') || path_1.default.isAbsolute(normalized)) {
+                return res.status(400).json({ error: 'Invalid path' });
+            }
+            const info = p.fileIndexManager.getFileInfo(normalized);
+            if (!info)
+                return res.status(404).json({ error: 'File not found' });
+            res.json(info);
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    return router;
+}

package/dist/api/rest/graph.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGraphRouter = createGraphRouter;
+const express_1 = require("express");
+const validation_1 = require("../../api/rest/validation");
+function exportGraph(graph, graphName) {
+    const nodes = [];
+    const edges = [];
+    graph.forEachNode((id, attrs) => {
+        // Skip proxy nodes and embeddings for transfer size
+        const { embedding, fileEmbedding, ...rest } = attrs;
+        nodes.push({ id, graph: graphName, ...rest });
+    });
+    graph.forEachEdge((_edge, attrs, source, target) => {
+        edges.push({ source, target, graph: graphName, ...attrs });
+    });
+    return { nodes, edges };
+}
+function createGraphRouter() {
+    const router = (0, express_1.Router)({ mergeParams: true });
+    function getProject(req) {
+        return req.project;
+    }
+    router.get('/', (0, validation_1.validateQuery)(validation_1.graphExportSchema), (req, res, next) => {
+        try {
+            const p = getProject(req);
+            const scope = req.validatedQuery.scope;
+            const allNodes = [];
+            const allEdges = [];
+            const add = (g, name) => {
+                if (!g)
+                    return;
+                const exp = exportGraph(g, name);
+                allNodes.push(...exp.nodes);
+                allEdges.push(...exp.edges);
+            };
+            if (scope === 'all' || scope === 'docs')
+                add(p.docGraph, 'docs');
+            if (scope === 'all' || scope === 'code')
+                add(p.codeGraph, 'code');
+            if (scope === 'all' || scope === 'knowledge')
+                add(p.knowledgeGraph, 'knowledge');
+            if (scope === 'all' || scope === 'tasks')
+                add(p.taskGraph, 'tasks');
+            if (scope === 'all' || scope === 'files')
+                add(p.fileIndexGraph, 'files');
+            if (scope === 'all' || scope === 'skills')
+                add(p.skillGraph, 'skills');
+            res.json({ nodes: allNodes, edges: allEdges });
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    return router;
+}

package/dist/api/rest/index.js

@@ -0,0 +1,117 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRestApp = createRestApp;
+const path_1 = __importDefault(require("path"));
+const express_1 = __importDefault(require("express"));
+const cors_1 = __importDefault(require("cors"));
+const knowledge_1 = require("../../api/rest/knowledge");
+const tasks_1 = require("../../api/rest/tasks");
+const skills_1 = require("../../api/rest/skills");
+const docs_1 = require("../../api/rest/docs");
+const code_1 = require("../../api/rest/code");
+const files_1 = require("../../api/rest/files");
+const graph_1 = require("../../api/rest/graph");
+const tools_1 = require("../../api/rest/tools");
+/**
+ * Create an Express app with all REST routes mounted.
+ * Each route uses the ProjectManager to look up project-specific graphs.
+ */
+function createRestApp(projectManager) {
+    const app = (0, express_1.default)();
+    app.use((0, cors_1.default)());
+    app.use(express_1.default.json({ limit: '10mb' }));
+    // Security headers
+    app.use((_req, res, next) => {
+        res.setHeader('X-Content-Type-Options', 'nosniff');
+        res.setHeader('X-Frame-Options', 'DENY');
+        next();
+    });
+    // Project resolution middleware — injects project instance into req
+    app.param('projectId', (req, _res, next, projectId) => {
+        const project = projectManager.getProject(projectId);
+        if (!project) {
+            return _res.status(404).json({ error: `Project "${projectId}" not found` });
+        }
+        req.project = project;
+        next();
+    });
+    // List projects
+    app.get('/api/projects', (_req, res) => {
+        const projects = projectManager.listProjects().map(id => {
+            const p = projectManager.getProject(id);
+            return {
+                id,
+                projectDir: p.config.projectDir,
+                workspaceId: p.workspaceId ?? null,
+                stats: {
+                    docs: p.docGraph ? p.docGraph.order : 0,
+                    code: p.codeGraph ? p.codeGraph.order : 0,
+                    knowledge: p.knowledgeGraph.order,
+                    files: p.fileIndexGraph.order,
+                    tasks: p.taskGraph.order,
+                    skills: p.skillGraph.order,
+                },
+            };
+        });
+        res.json({ results: projects });
+    });
+    // List workspaces
+    app.get('/api/workspaces', (_req, res) => {
+        const workspaces = projectManager.listWorkspaces().map(id => {
+            const ws = projectManager.getWorkspace(id);
+            return {
+                id,
+                projects: ws.config.projects,
+            };
+        });
+        res.json({ results: workspaces });
+    });
+    // Project stats
+    app.get('/api/projects/:projectId/stats', (req, res) => {
+        const p = req.project;
+        res.json({
+            docs: p.docGraph ? { nodes: p.docGraph.order, edges: p.docGraph.size } : null,
+            code: p.codeGraph ? { nodes: p.codeGraph.order, edges: p.codeGraph.size } : null,
+            knowledge: { nodes: p.knowledgeGraph.order, edges: p.knowledgeGraph.size },
+            fileIndex: { nodes: p.fileIndexGraph.order, edges: p.fileIndexGraph.size },
+            tasks: { nodes: p.taskGraph.order, edges: p.taskGraph.size },
+            skills: { nodes: p.skillGraph.order, edges: p.skillGraph.size },
+        });
+    });
+    // Mount domain routers
+    app.use('/api/projects/:projectId/knowledge', (0, knowledge_1.createKnowledgeRouter)());
+    app.use('/api/projects/:projectId/tasks', (0, tasks_1.createTasksRouter)());
+    app.use('/api/projects/:projectId/skills', (0, skills_1.createSkillsRouter)());
+    app.use('/api/projects/:projectId/docs', (0, docs_1.createDocsRouter)());
+    app.use('/api/projects/:projectId/code', (0, code_1.createCodeRouter)());
+    app.use('/api/projects/:projectId/files', (0, files_1.createFilesRouter)());
+    app.use('/api/projects/:projectId/graph', (0, graph_1.createGraphRouter)());
+    app.use('/api/projects/:projectId/tools', (0, tools_1.createToolsRouter)(projectManager));
+    // Serve UI static files (ui/dist)
+    const uiDist = path_1.default.resolve(__dirname, '../../../ui/dist');
+    app.use(express_1.default.static(uiDist));
+    // SPA fallback: serve index.html for non-API routes
+    app.get('/{*splat}', (_req, res, next) => {
+        if (_req.path.startsWith('/api/'))
+            return next();
+        res.sendFile(path_1.default.join(uiDist, 'index.html'), (err) => {
+            if (err)
+                next();
+        });
+    });
+    // Error handler
+    app.use((err, _req, res, _next) => {
+        if (err.name === 'ZodError') {
+            return res.status(400).json({ error: 'Validation error', details: err.issues });
+        }
+        if (err.type === 'entity.parse.failed' || (err instanceof SyntaxError && 'body' in err)) {
+            return res.status(400).json({ error: 'Invalid JSON' });
+        }
+        process.stderr.write(`[rest] Error: ${err.stack || err}\n`);
+        res.status(500).json({ error: 'Internal server error' });
+    });
+    return app;
+}

package/dist/api/rest/knowledge.js

@@ -0,0 +1,238 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createKnowledgeRouter = createKnowledgeRouter;
+const fs_1 = __importDefault(require("fs"));
+const mime_1 = __importDefault(require("mime"));
+const express_1 = require("express");
+const multer_1 = __importDefault(require("multer"));
+const validation_1 = require("../../api/rest/validation");
+const manager_types_1 = require("../../graphs/manager-types");
+const upload = (0, multer_1.default)({ storage: multer_1.default.memoryStorage(), limits: { fileSize: 50 * 1024 * 1024 } });
+function createKnowledgeRouter() {
+    const router = (0, express_1.Router)({ mergeParams: true });
+    function getProject(req) {
+        return req.project;
+    }
+    // List notes
+    router.get('/notes', (0, validation_1.validateQuery)(validation_1.noteListSchema), (req, res, next) => {
+        try {
+            const p = getProject(req);
+            const q = req.validatedQuery;
+            const notes = p.knowledgeManager.listNotes(q.filter, q.tag, q.limit);
+            res.json({ results: notes });
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    // Search notes
+    router.get('/search', (0, validation_1.validateQuery)(validation_1.noteSearchSchema), async (req, res, next) => {
+        try {
+            const p = getProject(req);
+            const q = req.validatedQuery;
+            const results = await p.knowledgeManager.searchNotes(q.q, {
+                topK: q.topK,
+                minScore: q.minScore,
+                searchMode: q.searchMode,
+            });
+            res.json({ results });
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    // Get note
+    router.get('/notes/:noteId', (req, res, next) => {
+        try {
+            const p = getProject(req);
+            const note = p.knowledgeManager.getNote(req.params.noteId);
+            if (!note)
+                return res.status(404).json({ error: 'Note not found' });
+            res.json(note);
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    // Create note
+    router.post('/notes', (0, validation_1.validateBody)(validation_1.createNoteSchema), async (req, res, next) => {
+        try {
+            const p = getProject(req);
+            const { title, content, tags } = req.body;
+            const created = await p.mutationQueue.enqueue(async () => {
+                const noteId = await p.knowledgeManager.createNote(title, content, tags);
+                return p.knowledgeManager.getNote(noteId);
+            });
+            res.status(201).json(created);
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    // Update note
+    router.put('/notes/:noteId', (0, validation_1.validateBody)(validation_1.updateNoteSchema), async (req, res, next) => {
+        try {
+            const p = getProject(req);
+            const noteId = req.params.noteId;
+            const { version, ...patch } = req.body;
+            const result = await p.mutationQueue.enqueue(async () => {
+                const ok = await p.knowledgeManager.updateNote(noteId, patch, version);
+                if (!ok)
+                    return null;
+                return p.knowledgeManager.getNote(noteId);
+            });
+            if (!result)
+                return res.status(404).json({ error: 'Note not found' });
+            res.json(result);
+        }
+        catch (err) {
+            if (err instanceof manager_types_1.VersionConflictError) {
+                return res.status(409).json({ error: 'version_conflict', current: err.current, expected: err.expected });
+            }
+            next(err);
+        }
+    });
+    // Delete note
+    router.delete('/notes/:noteId', async (req, res, next) => {
+        try {
+            const p = getProject(req);
+            const noteId = req.params.noteId;
+            const ok = await p.mutationQueue.enqueue(async () => {
+                return p.knowledgeManager.deleteNote(noteId);
+            });
+            if (!ok)
+                return res.status(404).json({ error: 'Note not found' });
+            res.status(204).end();
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    // Create relation
+    router.post('/relations', (0, validation_1.validateBody)(validation_1.createRelationSchema), async (req, res, next) => {
+        try {
+            const p = getProject(req);
+            const { fromId, toId, kind, targetGraph, projectId } = req.body;
+            const ok = await p.mutationQueue.enqueue(async () => {
+                return p.knowledgeManager.createRelation(fromId, toId, kind, targetGraph, projectId);
+            });
+            if (!ok)
+                return res.status(400).json({ error: 'Failed to create relation' });
+            res.status(201).json({ fromId, toId, kind, targetGraph: targetGraph || undefined });
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    // Delete relation
+    router.delete('/relations', (0, validation_1.validateBody)(validation_1.createRelationSchema.pick({ fromId: true, toId: true, targetGraph: true, projectId: true })), async (req, res, next) => {
+        try {
+            const p = getProject(req);
+            const { fromId, toId, targetGraph, projectId } = req.body;
+            const ok = await p.mutationQueue.enqueue(async () => {
+                return p.knowledgeManager.deleteRelation(fromId, toId, targetGraph, projectId);
+            });
+            if (!ok)
+                return res.status(404).json({ error: 'Relation not found' });
+            res.status(204).end();
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    // List relations for a note
+    router.get('/notes/:noteId/relations', (req, res, next) => {
+        try {
+            const p = getProject(req);
+            const relations = p.knowledgeManager.listRelations(req.params.noteId);
+            res.json({ results: relations });
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    // Find notes linked to an external entity
+    router.get('/linked', (0, validation_1.validateQuery)(validation_1.linkedQuerySchema), (req, res, next) => {
+        try {
+            const p = getProject(req);
+            const { targetGraph, targetNodeId, kind, projectId } = req.validatedQuery;
+            const notes = p.knowledgeManager.findLinkedNotes(targetGraph, targetNodeId, kind, projectId ?? req.params.projectId);
+            res.json({ results: notes });
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    // -- Attachments --
+    // Upload attachment
+    router.post('/notes/:noteId/attachments', upload.single('file'), async (req, res, next) => {
+        try {
+            const p = getProject(req);
+            const noteId = req.params.noteId;
+            const file = req.file;
+            if (!file)
+                return res.status(400).json({ error: 'No file uploaded' });
+            const meta = await p.mutationQueue.enqueue(async () => {
+                return p.knowledgeManager.addAttachment(noteId, file.originalname, file.buffer);
+            });
+            if (!meta)
+                return res.status(404).json({ error: 'Note not found' });
+            res.status(201).json(meta);
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    // List attachments
+    router.get('/notes/:noteId/attachments', (req, res, next) => {
+        try {
+            const p = getProject(req);
+            const attachments = p.knowledgeManager.listAttachments(req.params.noteId);
+            res.json({ results: attachments });
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    // Download attachment
+    router.get('/notes/:noteId/attachments/:filename', (req, res, next) => {
+        try {
+            const p = getProject(req);
+            const filename = validation_1.attachmentFilenameSchema.parse(req.params.filename);
+            const filePath = p.knowledgeManager.getAttachmentPath(req.params.noteId, filename);
+            if (!filePath)
+                return res.status(404).json({ error: 'Attachment not found' });
+            const mimeType = mime_1.default.getType(filePath) ?? 'application/octet-stream';
+            res.setHeader('Content-Type', mimeType);
+            res.setHeader('Content-Disposition', `attachment; filename="${filename}"`);
+            res.setHeader('X-Content-Type-Options', 'nosniff');
+            const stream = fs_1.default.createReadStream(filePath);
+            stream.on('error', (err) => next(err));
+            stream.pipe(res);
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    // Delete attachment
+    router.delete('/notes/:noteId/attachments/:filename', async (req, res, next) => {
+        try {
+            const p = getProject(req);
+            const noteId = req.params.noteId;
+            const filename = validation_1.attachmentFilenameSchema.parse(req.params.filename);
+            const ok = await p.mutationQueue.enqueue(async () => {
+                return p.knowledgeManager.removeAttachment(noteId, filename);
+            });
+            if (!ok)
+                return res.status(404).json({ error: 'Attachment not found' });
+            res.status(204).end();
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    return router;
+}