@postnesia/mcp 0.1.14 → 0.1.16

package/dist/index.js

@@ -3,28 +3,28 @@
  * MCP Server for Postnesia Memory System
  * Exposes memory operations as Model Context Protocol tools
  */
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z } from "zod";
-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";
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+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';
 const db = getDb();
 const server = new McpServer({
-    name: "postnesia",
-    version: "1.0.0",
+    name: 'postnesia',
+    version: '1.0.0',
 });
 // ---------------------------------------------------------------------------
 // memory tools
 // ---------------------------------------------------------------------------
-server.registerTool("memory_search", {
-    description: "Search memories by semantic similarity. Optionally filter by type.",
+server.registerTool('memory_search', {
+    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"),
+        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);
@@ -36,86 +36,86 @@ server.registerTool("memory_search", {
         ? queries.vectorSearchByType(db).all(embeddingBuffer, limit, type)
         : queries.vectorSearch(db).all(embeddingBuffer, limit);
     for (const result of results) {
-        logAccess(result.id, "search");
+        logAccess(result.id, 'search');
     }
     return {
-        content: [{ type: "text", text: JSON.stringify(results, null, 2) }],
+        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).",
+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)"),
+        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");
+        logAccess(result.id, 'search');
     }
     return {
-        content: [{ type: "text", text: JSON.stringify(results, null, 2) }],
+        content: [{ type: 'text', text: JSON.stringify(results, null, 2) }],
     };
 });
-server.registerTool("memory_by_context", {
-    description: "Find memories by context string (LIKE match).",
+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)"),
+        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");
+        logAccess(r.id, 'search');
     return {
-        content: [{ type: "text", text: JSON.stringify(results, null, 2) }],
+        content: [{ type: 'text', text: JSON.stringify(results, null, 2) }],
     };
 });
-server.registerTool("memory_by_tag", {
-    description: "Find memories by tag (exact match).",
+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)"),
+        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");
+        logAccess(r.id, 'search');
     return {
-        content: [{ type: "text", text: JSON.stringify(results, null, 2) }],
+        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).",
+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"),
+        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) }],
+        content: [{ type: 'text', text: JSON.stringify(chain, null, 2) }],
     };
 });
-server.registerTool("memory_core", {
-    description: "Get all core memories (foundational memories that are always loaded).",
+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) }],
+        content: [{ type: 'text', text: JSON.stringify(results, null, 2) }],
     };
 });
-server.registerTool("memory_add", {
-    description: "Add a new memory to the database",
+server.registerTool('memory_add', {
+    description: 'Add a new memory to the database',
     inputSchema: {
-        content: z.string().describe("Memory content (full form)"),
-        contentL1: z.string().optional().describe("Compressed L1 form (optional, will auto-generate if omitted)"),
-        type: z.enum(["event", "decision", "lesson", "preference", "person", "technical"]).describe("Memory type"),
-        importance: z.number().describe("Base importance 1-5"),
-        tags: z.array(z.string()).describe("Tags for categorization"),
-        context: z.string().optional().describe("Optional context about when/why this memory was created"),
-        core: z.boolean().optional().describe("Mark as a core memory (always loaded, never decays, cannot be superseded)"),
+        content: z.string().describe('Memory content (full form)'),
+        contentL1: z.string().optional().describe('Compressed L1 form (optional, will auto-generate if omitted)'),
+        type: z.enum(['event', 'decision', 'lesson', 'preference', 'person', 'technical']).describe('Memory type'),
+        importance: z.number().describe('Base importance 1-5'),
+        tags: z.array(z.string()).describe('Tags for categorization'),
+        context: z.string().optional().describe('Optional context about when/why this memory was created'),
+        core: z.boolean().optional().describe('Mark as a core memory (always loaded, never decays, cannot be superseded)'),
     },
 }, async ({ content, contentL1, type, importance, tags, context, core }) => {
     const content_l1 = contentL1 || content.slice(0, 200);
@@ -137,21 +137,21 @@ server.registerTool("memory_add", {
     return {
         content: [
             {
-                type: "text",
-                text: `Created memory #${id}\n  Type: ${type}\n  Core: ${core ? "yes" : "no"}\n  Importance: ${importance}/5\n  Tags: ${tags.join(", ")}`,
+                type: 'text',
+                text: `Created memory #${id}\n  Type: ${type}\n  Core: ${core ? 'yes' : 'no'}\n  Importance: ${importance}/5\n  Tags: ${tags.join(', ')}`,
             },
         ],
     };
 });
-server.registerTool("memory_update_core", {
-    description: "Update the content of an existing core memory in place (core memories must be updated, never superseded)",
+server.registerTool('memory_update_core', {
+    description: 'Update the content of an existing core memory in place (core memories must be updated, never superseded)',
     inputSchema: {
-        memoryId: z.number().describe("ID of the memory to update"),
-        content: z.string().describe("New full content"),
-        contentL1: z.string().describe("New compressed L1 summary"),
+        memoryId: z.number().describe('ID of the memory to update'),
+        content: z.string().describe('New full content'),
+        contentL1: z.string().describe('New compressed L1 summary'),
     },
 }, async ({ memoryId, content, contentL1 }) => {
-    const existing = db.prepare("SELECT id, core FROM memory WHERE id = ?").get(memoryId);
+    const existing = db.prepare('SELECT id, core FROM memory WHERE id = ?').get(memoryId);
     if (!existing)
         throw new Error(`Memory #${memoryId} not found`);
     if (!existing.core)
@@ -161,152 +161,181 @@ server.registerTool("memory_update_core", {
         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));
+    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 {
-        content: [{ type: "text", text: `Updated core memory #${memoryId}` }],
+        content: [{ type: 'text', text: `Updated core memory #${memoryId}` }],
     };
 });
-server.registerTool("memory_recent", {
-    description: "Get recent memories within time window",
+server.registerTool('memory_recent', {
+    description: 'Get recent memories within time window',
     inputSchema: {
-        hours: z.number().optional().describe("Hours to look back (default: 24)"),
-        limit: z.number().optional().describe("Maximum results (default: 20)"),
+        hours: z.number().optional().describe('Hours to look back (default: 24)'),
+        limit: z.number().optional().describe('Maximum results (default: 20)'),
     },
 }, async ({ hours = 24, limit = 20 }) => {
     const results = queries.getRecentMemories(db).all(`-${hours} hours`, limit);
     for (const result of results) {
-        logAccess(result.id, "recent");
+        logAccess(result.id, 'recent');
     }
     return {
-        content: [{ type: "text", text: JSON.stringify(results, null, 2) }],
+        content: [{ type: 'text', text: JSON.stringify(results, null, 2) }],
     };
 });
-server.registerTool("memory_stats", {
-    description: "Get memory database statistics",
+server.registerTool('memory_stats', {
+    description: 'Get memory database statistics',
     inputSchema: {},
 }, async () => {
     const stats = queries.getStats(db).all();
-    const total = db.prepare("SELECT COUNT(*) as count FROM memory").get().count;
-    const tags = db.prepare("SELECT COUNT(*) as count FROM tag").get().count;
-    const relationships = db.prepare("SELECT COUNT(*) as count FROM relationship").get().count;
-    const accessLogs = db.prepare("SELECT COUNT(*) as count FROM access_log").get().count;
+    const total = db.prepare('SELECT COUNT(*) as count FROM memory').get().count;
+    const tags = db.prepare('SELECT COUNT(*) as count FROM tag').get().count;
+    const relationships = db.prepare('SELECT COUNT(*) as count FROM relationship').get().count;
+    const accessLogs = db.prepare('SELECT COUNT(*) as count FROM access_log').get().count;
     const rows = stats
         .map((s) => `  ${s.type.padEnd(15)} ${s.count.toString().padStart(3)} memories (avg importance: ${s.avg_importance?.toFixed(1)})`)
-        .join("\n");
+        .join('\n');
     return {
         content: [
             {
-                type: "text",
+                type: 'text',
                 text: `Memory Statistics:\n\n${rows}\n\n  Total:         ${total} memories\n  Tags:          ${tags}\n  Relationships: ${relationships}\n  Access Logs:   ${accessLogs}`,
             },
         ],
     };
 });
-server.registerTool("memory_consolidate", {
-    description: "Run memory consolidation cycle (decay old, boost accessed)",
+server.registerTool('memory_consolidate', {
+    description: 'Run memory consolidation cycle (decay old, boost accessed)',
     inputSchema: {},
 }, async () => {
     const results = runConsolidation();
     return {
         content: [
             {
-                type: "text",
+                type: 'text',
                 text: `Consolidation Complete\n\nReviewed: ${results.reviewed} memories\nBoosted: ${results.boosted} memories\nDecayed: ${results.decayed} memories\nUnchanged: ${results.unchanged} memories\n\nChanges saved to database`,
             },
         ],
     };
 });
-server.registerTool("memory_relationships", {
-    description: "View relationship graph for a memory",
+server.registerTool('memory_relationships', {
+    description: 'View relationship graph for a memory',
     inputSchema: {
-        memoryId: z.number().describe("Memory ID to explore"),
+        memoryId: z.number().describe('Memory ID to explore'),
     },
 }, async ({ memoryId }) => {
     const relationships = queries.getMemoryRelationships(db).all(memoryId, memoryId);
     return {
-        content: [{ type: "text", text: JSON.stringify(relationships, null, 2) }],
+        content: [{ type: 'text', text: JSON.stringify(relationships, null, 2) }],
     };
 });
-server.registerTool("memory_link", {
-    description: "Explicitly create a typed relationship between two memories",
+server.registerTool('memory_link', {
+    description: 'Explicitly create a typed relationship between two memories',
     inputSchema: {
-        fromId: z.number().describe("Source memory ID"),
-        toId: z.number().describe("Target memory ID"),
-        type: z.enum(["related", "supersedes", "supports", "contradicts", "derives_from"])
-            .describe("Relationship type"),
+        fromId: z.number().describe('Source memory ID'),
+        toId: z.number().describe('Target memory ID'),
+        type: z.enum(['related', 'supersedes', 'supports', 'contradicts', 'derives_from'])
+            .describe('Relationship type'),
     },
 }, async ({ fromId, toId, type }) => {
-    const from = db.prepare("SELECT id FROM memory WHERE id = ?").get(fromId);
+    const from = db.prepare('SELECT id FROM memory WHERE id = ?').get(fromId);
     if (!from)
         throw new Error(`Memory #${fromId} not found`);
-    const to = db.prepare("SELECT id FROM memory WHERE id = ?").get(toId);
+    const to = db.prepare('SELECT id FROM memory WHERE id = ?').get(toId);
     if (!to)
         throw new Error(`Memory #${toId} not found`);
     const existing = queries.findRelationshipBetween(db).get(fromId, toId, type);
     if (existing) {
-        return { content: [{ type: "text", text: `Relationship already exists (id: ${existing.id})` }] };
+        return { content: [{ type: 'text', text: `Relationship already exists (id: ${existing.id})` }] };
     }
     const result = queries.insertRelationship(db).run(fromId, toId, type);
     const id = Number(result.lastInsertRowid);
     return {
-        content: [{ type: "text", text: `Created relationship #${id}: #${fromId} -[${type}]-> #${toId}` }],
+        content: [{ type: 'text', text: `Created relationship #${id}: #${fromId} -[${type}]-> #${toId}` }],
     };
 });
-server.registerTool("memory_unlink", {
-    description: "Remove a relationship between two memories by relationship ID",
+server.registerTool('memory_unlink', {
+    description: 'Remove a relationship between two memories by relationship ID',
     inputSchema: {
-        relationshipId: z.number().describe("Relationship ID to delete"),
+        relationshipId: z.number().describe('Relationship ID to delete'),
     },
 }, async ({ relationshipId }) => {
-    const existing = db.prepare("SELECT id FROM relationship WHERE id = ?").get(relationshipId);
+    const existing = db.prepare('SELECT id FROM relationship WHERE id = ?').get(relationshipId);
     if (!existing)
         throw new Error(`Relationship #${relationshipId} not found`);
     queries.deleteRelationship(db).run(relationshipId);
     return {
-        content: [{ type: "text", text: `Deleted relationship #${relationshipId}` }],
+        content: [{ type: 'text', text: `Deleted relationship #${relationshipId}` }],
+    };
+});
+server.registerTool('memory_supersede', {
+    description: 'Mark an existing memory as superseded by another — use for deduplication. Demotes the duplicate\'s importance and links it to the canonical memory. Refuses core memories.',
+    inputSchema: {
+        duplicateId: z.number().describe('ID of the duplicate memory to demote'),
+        canonicalId: z.number().describe('ID of the canonical memory to keep'),
+    },
+}, async ({ duplicateId, canonicalId }) => {
+    if (duplicateId === canonicalId)
+        throw new Error('duplicate and canonical must be different memories');
+    const dup = db.prepare('SELECT id, core FROM memory WHERE id = ?').get(duplicateId);
+    if (!dup)
+        throw new Error(`Memory #${duplicateId} not found`);
+    if (dup.core)
+        throw new Error(`Memory #${duplicateId} is a core memory and cannot be superseded — use memory_update_core instead`);
+    const can = db.prepare('SELECT id FROM memory WHERE id = ?').get(canonicalId);
+    if (!can)
+        throw new Error(`Canonical memory #${canonicalId} not found`);
+    const alreadyLinked = db.prepare('SELECT supersedes_id FROM memory WHERE id = ? AND supersedes_id IS NOT NULL').get(duplicateId);
+    if (alreadyLinked)
+        throw new Error(`Memory #${duplicateId} already has a supersedes_id — check memory_supersede_chain first`);
+    db.prepare('UPDATE memory SET supersedes_id = ?, importance = MAX(1, importance - 2), updated_at = datetime(\'now\') WHERE id = ?').run(canonicalId, duplicateId);
+    const existing = queries.findRelationshipBetween(db).get(duplicateId, canonicalId, 'supersedes');
+    if (!existing) {
+        queries.insertRelationship(db).run(duplicateId, canonicalId, 'supersedes');
+    }
+    return {
+        content: [{ type: 'text', text: `Memory #${duplicateId} now superseded by #${canonicalId} (importance demoted by 2)` }],
     };
 });
 // ---------------------------------------------------------------------------
 // journal tools
 // ---------------------------------------------------------------------------
-server.registerTool("journal_add", {
-    description: "Add a daily journal entry",
+server.registerTool('journal_add', {
+    description: 'Add a daily journal entry',
     inputSchema: {
-        date: z.string().describe("Date YYYY-MM-DD"),
-        content: z.string().describe("Full journal narrative"),
-        learned: z.string().optional().describe("What I learned (optional)"),
-        keyMoments: z.string().optional().describe("Key moments (optional)"),
-        mood: z.string().optional().describe("Mood/feeling (optional)"),
+        date: z.string().describe('Date YYYY-MM-DD'),
+        content: z.string().describe('Full journal narrative'),
+        learned: z.string().optional().describe('What I learned (optional)'),
+        keyMoments: z.string().optional().describe('Key moments (optional)'),
+        mood: z.string().optional().describe('Mood/feeling (optional)'),
     },
 }, async ({ date, content, learned, keyMoments, mood }) => {
-    const combinedLearned = [learned].filter(Boolean).join("\n\n") || null;
+    const combinedLearned = [learned].filter(Boolean).join('\n\n') || null;
     queries.insertJournal(db).run(date, content, combinedLearned, keyMoments || null, mood || null);
     return {
-        content: [{ type: "text", text: `Journal entry created for ${date}` }],
+        content: [{ type: 'text', text: `Journal entry created for ${date}` }],
     };
 });
-server.registerTool("journal_recent", {
-    description: "Get recent journal entries",
+server.registerTool('journal_recent', {
+    description: 'Get recent journal entries',
     inputSchema: {
-        days: z.number().optional().describe("Days to look back (default: 7)"),
+        days: z.number().optional().describe('Days to look back (default: 7)'),
     },
 }, async ({ days = 7 }) => {
     const entries = queries.getRecentJournals(db).all(`-${days} days`);
     return {
-        content: [{ type: "text", text: JSON.stringify(entries, null, 2) }],
+        content: [{ type: 'text', text: JSON.stringify(entries, null, 2) }],
     };
 });
 // ---------------------------------------------------------------------------
 // task tools
 // ---------------------------------------------------------------------------
-server.registerTool("task_create", {
-    description: "Create a new task. Use session_id to group tasks by project or feature.",
+server.registerTool('task_create', {
+    description: 'Create a new task. Use session_id to group tasks by project or feature.',
     inputSchema: {
-        title: z.string().describe("Short task title"),
-        description: z.string().optional().describe("Detailed description of what needs to be done"),
+        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. 'postnesia-mcp', 'auth-refactor')"),
-        memory_id: z.number().optional().describe("Optional ID of a related memory"),
+        memory_id: z.number().optional().describe('Optional ID of a related memory'),
     },
 }, async ({ title, description, session_id, memory_id }) => {
     const result = queries.insertTask(db).run(title, description || null, session_id || null, memory_id || null);
@@ -314,19 +343,19 @@ server.registerTool("task_create", {
     return {
         content: [
             {
-                type: "text",
-                text: `Created task #${id}: ${title}${session_id ? `\n  Session: ${session_id}` : ""}`,
+                type: 'text',
+                text: `Created task #${id}: ${title}${session_id ? `\n  Session: ${session_id}` : ''}`,
             },
         ],
     };
 });
-server.registerTool("task_update", {
+server.registerTool('task_update', {
     description: "Update a task's status, title, or description",
     inputSchema: {
-        taskId: z.number().describe("ID of the task to update"),
-        status: z.enum(["pending", "in_progress", "completed", "cancelled"]).optional().describe("New status"),
-        title: z.string().optional().describe("Updated title"),
-        description: z.string().optional().describe("Updated description"),
+        taskId: z.number().describe('ID of the task to update'),
+        status: z.enum(['pending', 'in_progress', 'completed', 'cancelled']).optional().describe('New status'),
+        title: z.string().optional().describe('Updated title'),
+        description: z.string().optional().describe('Updated description'),
     },
 }, async ({ taskId, status, title, description }) => {
     const existing = queries.getTaskById(db).get(taskId);
@@ -337,31 +366,31 @@ server.registerTool("task_update", {
     return {
         content: [
             {
-                type: "text",
+                type: 'text',
                 text: `Task #${taskId} updated\n  Status: ${updated.status}\n  Title: ${updated.title}`,
             },
         ],
     };
 });
-server.registerTool("task_list", {
-    description: "List tasks, optionally filtered by status and/or session_id. Use at session start to resume open work.",
+server.registerTool('task_list', {
+    description: 'List tasks, optionally filtered by status and/or session_id. Use at session start to resume open work.',
     inputSchema: {
-        status: z.enum(["pending", "in_progress", "completed", "cancelled"]).optional().describe("Filter by status"),
-        session_id: z.string().optional().describe("Filter by project/feature label"),
-        limit: z.number().optional().describe("Maximum results (default: 50)"),
+        status: z.enum(['pending', 'in_progress', 'completed', 'cancelled']).optional().describe('Filter by status'),
+        session_id: z.string().optional().describe('Filter by project/feature label'),
+        limit: z.number().optional().describe('Maximum results (default: 50)'),
     },
 }, async ({ status, session_id, limit = 50 }) => {
     const conditions = [];
     const params = [];
     if (status) {
-        conditions.push("status = ?");
+        conditions.push('status = ?');
         params.push(status);
     }
     if (session_id) {
-        conditions.push("session_id = ?");
+        conditions.push('session_id = ?');
         params.push(session_id);
     }
-    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
     params.push(limit);
     const tasks = db.prepare(`
       SELECT * FROM task
@@ -370,7 +399,7 @@ server.registerTool("task_list", {
       LIMIT ?
     `).all(...params);
     return {
-        content: [{ type: "text", text: JSON.stringify(tasks, null, 2) }],
+        content: [{ type: 'text', text: JSON.stringify(tasks, null, 2) }],
     };
 });
 // ---------------------------------------------------------------------------
@@ -379,12 +408,16 @@ server.registerTool("task_list", {
 async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    console.error("Postnesia MCP Server running on stdio");
+    console.error('Postnesia MCP Server running on stdio');
 }
+const exit = () => {
+    closeDb();
+    process.exit(0);
+};
 main().catch((error) => {
-    console.error("Fatal error:", error);
+    console.error('Fatal error:', error);
     closeDb();
     process.exit(1);
 });
-process.on('SIGINT', () => { closeDb(); process.exit(0); });
-process.on('SIGTERM', () => { closeDb(); process.exit(0); });
+process.on('SIGINT', exit);
+process.on('SIGTERM', exit);

package/dist/install.js

@@ -24,11 +24,11 @@ const config = {
     claude: {
         mcpServers: {
             postnesia: {
-                type: "stdio",
+                type: 'stdio',
                 enabled: true,
-                command: "npx",
+                command: 'npx',
                 args: [
-                    "pn-mcp"
+                    'pn-mcp'
                 ],
                 env: {
                     DATABASE_URL: process.env['DATABASE_URL'],
@@ -40,11 +40,11 @@ const config = {
     opencode: {
         mcp: {
             postnesia: {
-                type: "local",
+                type: 'local',
                 enabled: false,
                 command: [
-                    "npx",
-                    "pn-mcp"
+                    'npx',
+                    'pn-mcp'
                 ],
                 environment: {
                     DATABASE_URL: process.env['DATABASE_URL'],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@postnesia/mcp",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "description": "An MCP server to interact with the Postnesia database",
   "type": "module",
   "private": false,
@@ -14,10 +14,10 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.26.0",
     "zod": "^4.3.6",
-    "@postnesia/db": "0.1.14"
+    "@postnesia/db": "0.1.16"
   },
   "devDependencies": {
-    "@types/node": "^22.10.5",
+    "@types/node": "^24.12.0",
     "dotenv": "^17.3.1",
     "tsx": "^4.19.2",
     "typescript": "^5.7.3"
@@ -25,6 +25,8 @@
   "scripts": {
     "build": "pnpm clean && tsc -p tsconfig.json",
     "clean": "rm -rf ./dist",
-    "start": "tsx src/index.ts"
+    "start": "tsx src/index.ts",
+    "lint": "pnpm eslint .",
+    "lint:fix": "pnpm eslint --fix ."
   }
 }