@postnesia/mcp 0.1.8 → 0.1.12

package/dist/index.js

@@ -20,17 +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 }) => {
+}, async ({ query, limit = 10, type }) => {
     const [embedding] = await embed(query);
     if (!embedding) {
         throw new ReferenceError('Unable to create query embedding');
     }
-    const results = queries.vectorSearch(db).all(Buffer.from(embedding.buffer), limit);
+    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 pattern = `%${query}%`;
+    const results = queries.searchMemories(db).all(pattern, pattern, limit);
     for (const result of results) {
         logAccess(result.id, "search");
     }
@@ -38,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: {
@@ -92,11 +160,7 @@ server.registerTool("memory_update_core", {
     if (!embedding) {
         throw new ReferenceError('Unable to create query embedding');
     }
-    db.prepare(`
-      UPDATE memory
-      SET content = ?, content_l1 = ?, updated_at = datetime('now')
-      WHERE id = ?
-    `).run(content, contentL1, memoryId);
+    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 {
@@ -212,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)"),
     },

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.8",
+  "version": "0.1.12",
   "description": "An MCP server to interact with the Postnesia database",
   "type": "module",
   "private": false,
@@ -8,21 +8,23 @@
     "dist"
   ],
   "bin": {
-    "pn-mcp": "./dist/index.js"
-  },
-  "scripts": {
-    "build": "pnpm clean && tsc -p tsconfig.json",
-    "clean": "rm -rf ./dist",
-    "start": "tsx src/index.ts"
+    "pn-mcp": "./dist/index.js",
+    "pn-mcp-install": "./dist/install.js"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.26.0",
-    "@postnesia/db": "workspace:*",
-    "zod": "^4.3.6"
+    "zod": "^4.3.6",
+    "@postnesia/db": "0.1.12"
   },
   "devDependencies": {
     "@types/node": "^22.10.5",
+    "dotenv": "^17.3.1",
     "tsx": "^4.19.2",
     "typescript": "^5.7.3"
+  },
+  "scripts": {
+    "build": "pnpm clean && tsc -p tsconfig.json",
+    "clean": "rm -rf ./dist",
+    "start": "tsx src/index.ts"
   }
-}
+}