@postnesia/mcp 0.1.7 → 0.1.12

package/dist/index.js

@@ -6,7 +6,8 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
-import { getDb, queries, createMemory } from "@postnesia/db";
+import { getDb, closeDb, createMemory } from "@postnesia/db";
+import queries from "@postnesia/db/queries";
 import { embed } from "@postnesia/db/embeddings";
 import { logAccess } from "@postnesia/db/access";
 import { runConsolidation } from "@postnesia/db/importance";
@@ -19,14 +20,37 @@ const server = new McpServer({
 // memory tools
 // ---------------------------------------------------------------------------
 server.registerTool("memory_search", {
-    description: "Search memories by content. Returns all matching memories.",
+    description: "Search memories by semantic similarity. Optionally filter by type.",
     inputSchema: {
         query: z.string().describe("Search query"),
         limit: z.number().optional().describe("Maximum results to return (default: 10)"),
+        type: z.enum(["event", "decision", "lesson", "preference", "person", "technical"]).optional().describe("Filter by memory type"),
+    },
+}, async ({ query, limit = 10, type }) => {
+    const [embedding] = await embed(query);
+    if (!embedding) {
+        throw new ReferenceError('Unable to create query embedding');
+    }
+    const embeddingBuffer = Buffer.from(embedding.buffer);
+    const results = type
+        ? queries.vectorSearchByType(db).all(embeddingBuffer, limit, type)
+        : queries.vectorSearch(db).all(embeddingBuffer, limit);
+    for (const result of results) {
+        logAccess(result.id, "search");
+    }
+    return {
+        content: [{ type: "text", text: JSON.stringify(results, null, 2) }],
+    };
+});
+server.registerTool("memory_search_keyword", {
+    description: "Keyword search memories by content (use when semantic search is not appropriate).",
+    inputSchema: {
+        query: z.string().describe("Keyword or phrase to search for"),
+        limit: z.number().optional().describe("Maximum results to return (default: 10)"),
     },
 }, async ({ query, limit = 10 }) => {
-    const embedding = await embed(query);
-    const results = queries.vectorSearch(db).all(Buffer.from(embedding.buffer), limit);
+    const pattern = `%${query}%`;
+    const results = queries.searchMemories(db).all(pattern, pattern, limit);
     for (const result of results) {
         logAccess(result.id, "search");
     }
@@ -34,6 +58,54 @@ server.registerTool("memory_search", {
         content: [{ type: "text", text: JSON.stringify(results, null, 2) }],
     };
 });
+server.registerTool("memory_by_context", {
+    description: "Find memories by context string (LIKE match).",
+    inputSchema: {
+        context: z.string().describe("Context string to search for"),
+        limit: z.number().optional().describe("Maximum results (default: 10)"),
+    },
+}, async ({ context, limit = 10 }) => {
+    const results = queries.getMemoriesByContext(db).all(`%${context}%`, limit);
+    for (const r of results)
+        logAccess(r.id, "search");
+    return {
+        content: [{ type: "text", text: JSON.stringify(results, null, 2) }],
+    };
+});
+server.registerTool("memory_by_tag", {
+    description: "Find memories by tag (exact match).",
+    inputSchema: {
+        tag: z.string().describe("Tag to filter by"),
+        limit: z.number().optional().describe("Maximum results (default: 10)"),
+    },
+}, async ({ tag, limit = 10 }) => {
+    const results = queries.getMemoriesByTag(db).all(tag, limit);
+    for (const r of results)
+        logAccess(r.id, "search");
+    return {
+        content: [{ type: "text", text: JSON.stringify(results, null, 2) }],
+    };
+});
+server.registerTool("memory_supersede_chain", {
+    description: "Trace the supersede chain for a memory (shows the full replacement history).",
+    inputSchema: {
+        memoryId: z.number().describe("Memory ID to trace"),
+    },
+}, async ({ memoryId }) => {
+    const chain = queries.getSupersedeChain(db).all(memoryId);
+    return {
+        content: [{ type: "text", text: JSON.stringify(chain, null, 2) }],
+    };
+});
+server.registerTool("memory_core", {
+    description: "Get all core memories (foundational memories that are always loaded).",
+    inputSchema: {},
+}, async () => {
+    const results = queries.coreMemories(db).all();
+    return {
+        content: [{ type: "text", text: JSON.stringify(results, null, 2) }],
+    };
+});
 server.registerTool("memory_add", {
     description: "Add a new memory to the database",
     inputSchema: {
@@ -47,7 +119,10 @@ server.registerTool("memory_add", {
     },
 }, async ({ content, contentL1, type, importance, tags, context, core }) => {
     const content_l1 = contentL1 || content.slice(0, 200);
-    const embedding = await embed(content);
+    const [embedding] = await embed(content);
+    if (!embedding) {
+        throw new ReferenceError('Unable to create query embedding');
+    }
     const id = createMemory(db, {
         timestamp: new Date().toISOString(),
         content,
@@ -81,12 +156,11 @@ server.registerTool("memory_update_core", {
         throw new Error(`Memory #${memoryId} not found`);
     if (!existing.core)
         throw new Error(`Memory #${memoryId} is not a core memory. Use memory_add with supersedes_id for regular memories.`);
-    const embedding = await embed(content);
-    db.prepare(`
-      UPDATE memory
-      SET content = ?, content_l1 = ?, updated_at = datetime('now')
-      WHERE id = ?
-    `).run(content, contentL1, memoryId);
+    const [embedding] = await embed(content);
+    if (!embedding) {
+        throw new ReferenceError('Unable to create query embedding');
+    }
+    queries.updateCoreMemory(db).run(content, contentL1, memoryId);
     db.prepare("DELETE FROM vec_memories WHERE memory_id = ?").run(BigInt(memoryId));
     db.prepare("INSERT INTO vec_memories(memory_id, embedding) VALUES (?, ?)").run(BigInt(memoryId), Buffer.from(embedding.buffer));
     return {
@@ -202,7 +276,7 @@ server.registerTool("journal_add", {
         date: z.string().describe("Date YYYY-MM-DD"),
         content: z.string().describe("Full journal narrative"),
         learned: z.string().optional().describe("What I learned (optional)"),
-        learnedAboutRye: z.string().optional().describe("What I learned about Rye (optional)"),
+        learnedAboutRye: z.string().optional().describe("What I learned about the user (optional)"),
         keyMoments: z.string().optional().describe("Key moments (optional)"),
         mood: z.string().optional().describe("Mood/feeling (optional)"),
     },
@@ -232,7 +306,7 @@ server.registerTool("task_create", {
     inputSchema: {
         title: z.string().describe("Short task title"),
         description: z.string().optional().describe("Detailed description of what needs to be done"),
-        session_id: z.string().optional().describe("Project or feature label to group related tasks (e.g. 'openmind-mcp', 'auth-refactor')"),
+        session_id: z.string().optional().describe("Project or feature label to group related tasks (e.g. 'postnesia-mcp', 'auth-refactor')"),
         memory_id: z.number().optional().describe("Optional ID of a related memory"),
     },
 }, async ({ title, description, session_id, memory_id }) => {
@@ -310,5 +384,8 @@ async function main() {
 }
 main().catch((error) => {
     console.error("Fatal error:", error);
+    closeDb();
     process.exit(1);
 });
+process.on('SIGINT', () => { closeDb(); process.exit(0); });
+process.on('SIGTERM', () => { closeDb(); process.exit(0); });

package/dist/install.d.ts

@@ -0,0 +1 @@
+import 'dotenv/config';

package/dist/install.js

@@ -0,0 +1,98 @@
+import 'dotenv/config';
+var TypeEnum;
+(function (TypeEnum) {
+    TypeEnum["claude"] = "claude";
+    TypeEnum["opencode"] = "opencode";
+})(TypeEnum || (TypeEnum = {}));
+;
+var ScopeEnum;
+(function (ScopeEnum) {
+    ScopeEnum["user"] = "user";
+    ScopeEnum["project"] = "project";
+    ScopeEnum["local"] = "local";
+})(ScopeEnum || (ScopeEnum = {}));
+;
+if (!process.env['DATABASE_URL']) {
+    console.error('DATABASE_URL (absolute path) environment variable is not configured');
+    process.exit(1);
+}
+if (!process.env['GEMINI_API_KEY']) {
+    console.error('GEMINI_API_KEY environment variable is not configured');
+    process.exit(1);
+}
+const config = {
+    claude: {
+        mcpServers: {
+            postnesia: {
+                type: "stdio",
+                enabled: true,
+                command: "npx",
+                args: [
+                    "pn-mcp"
+                ],
+                env: {
+                    DATABASE_URL: process.env['DATABASE_URL'],
+                    GEMINI_API_KEY: process.env['GEMINI_API_KEY']
+                }
+            }
+        }
+    },
+    opencode: {
+        mcp: {
+            postnesia: {
+                type: "local",
+                enabled: false,
+                command: [
+                    "npx",
+                    "pn-mcp"
+                ],
+                environment: {
+                    DATABASE_URL: process.env['DATABASE_URL'],
+                    GEMINI_API_KEY: process.env['GEMINI_API_KEY']
+                }
+            }
+        }
+    }
+};
+const [_, __, type, scope] = process.argv;
+if (type === 'claude') {
+    const msg = 'Add the following to your $file configuration:';
+    if (scope === 'project') {
+        console.log(msg.replace('$file', `${process.cwd()}/.mcp.json`));
+        console.log(JSON.stringify(config.claude, null, 2));
+        process.exit(0);
+    }
+    if (scope === 'local') {
+        console.log(msg.replace('$file', `${process.env.HOME}/.claude.json for the current project`));
+        console.log(JSON.stringify({ projects: { [process.cwd()]: config.claude } }, null, 2));
+        process.exit(0);
+    }
+    if (scope === 'user' || !scope) {
+        console.log(msg.replace('$file', `${process.env.HOME}/.claude.json`));
+        console.log(JSON.stringify(config.claude, null, 2));
+        process.exit(0);
+    }
+    console.error('Invalid scope argument provided: "project", "user" or "local"');
+    process.exit(1);
+}
+if (type === 'opencode') {
+    const msg = 'Add the following to your $file configuration:';
+    if (scope === 'project') {
+        console.log(msg.replace('$file', `${process.cwd()}/.opencode.json`));
+        console.log(JSON.stringify(config.opencode, null, 2));
+        process.exit(0);
+    }
+    if (!scope || scope === 'user') {
+        console.log(msg.replace('$file', `${process.env.HOME}/.config/opencode/opencode.json`));
+        console.log(JSON.stringify(config.opencode, null, 2));
+        process.exit(0);
+    }
+    if (scope === 'local') {
+        console.log('Local scope does not exist for opencode');
+        process.exit(1);
+    }
+    console.error('Invalid scope argument provided: "project", "user"');
+    process.exit(1);
+}
+console.error('Argument type opencode or claude is required');
+process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@postnesia/mcp",
-  "version": "0.1.7",
+  "version": "0.1.12",
   "description": "An MCP server to interact with the Postnesia database",
   "type": "module",
   "private": false,
@@ -8,15 +8,17 @@
     "dist"
   ],
   "bin": {
-    "postnesia-mcp": "./dist/index.js"
+    "pn-mcp": "./dist/index.js",
+    "pn-mcp-install": "./dist/install.js"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.26.0",
     "zod": "^4.3.6",
-    "@postnesia/db": "0.1.7"
+    "@postnesia/db": "0.1.12"
   },
   "devDependencies": {
     "@types/node": "^22.10.5",
+    "dotenv": "^17.3.1",
     "tsx": "^4.19.2",
     "typescript": "^5.7.3"
   },