gnosys 5.4.0 → 5.4.1

package/dist/index.js

@@ -62,6 +62,17 @@ const server = new McpServer({
     name: "gnosys",
     version: "2.0.0",
 });
+/**
+ * v5.4.1: Format MCP errors. Detects DB corruption and replaces the raw
+ * "database disk image is malformed" with actionable recovery instructions.
+ * Use this in catch blocks instead of inlining error.message.
+ */
+function formatMcpError(action, err) {
+    if (GnosysDB.isCorruptionError(err)) {
+        return `Error ${action}: ${err instanceof Error ? err.message : String(err)}\n\n${GnosysDB.corruptionRecoveryInstructions()}`;
+    }
+    return `Error ${action}: ${err instanceof Error ? err.message : String(err)}`;
+}
 // These are initialized in main() after resolver runs
 let search = null;
 let tagRegistry = null;
@@ -480,12 +491,7 @@ server.tool("gnosys_add", "Add a new memory. Accepts raw text — an LLM structu
     }
     catch (err) {
         return {
-            content: [
-                {
-                    type: "text",
-                    text: `Error adding memory: ${err instanceof Error ? err.message : String(err)}`,
-                },
-            ],
+            content: [{ type: "text", text: formatMcpError("adding memory", err) }],
             isError: true,
         };
     }
@@ -510,51 +516,59 @@ server.tool("gnosys_add_structured", "Add a memory with structured input (no LLM
     confidence: z.number().min(0).max(1).optional(),
     projectRoot: projectRootParam,
 }, async ({ title, category, tags, relevance, content, store: targetStore, author, authority, confidence, projectRoot }) => {
-    const ctx = await resolveToolContext(projectRoot);
-    const writeTarget = ctx.resolver.getWriteTarget(targetStore || undefined);
-    if (!writeTarget) {
+    try {
+        const ctx = await resolveToolContext(projectRoot);
+        const writeTarget = ctx.resolver.getWriteTarget(targetStore || undefined);
+        if (!writeTarget) {
+            return {
+                content: [{ type: "text", text: "No writable store found." }],
+                isError: true,
+            };
+        }
+        if (!ctx.centralDb?.isAvailable()) {
+            return {
+                content: [{ type: "text", text: "Database not available. Cannot write memory." }],
+                isError: true,
+            };
+        }
+        const id = ctx.centralDb.getNextId(category, ctx.projectId ?? undefined);
+        const today = new Date().toISOString().split("T")[0];
+        const frontmatter = {
+            id,
+            title,
+            category,
+            tags: tags,
+            relevance: relevance || "",
+            author: author || "ai",
+            authority: authority || "observed",
+            confidence: confidence || 0.8,
+            created: today,
+            modified: today,
+            last_reviewed: today,
+            status: "active",
+            supersedes: null,
+        };
+        const fullContent = `# ${title}\n\n${content}`;
+        // Write to DB only (SQLite is sole source of truth)
+        syncMemoryToDb(ctx.centralDb, frontmatter, fullContent, undefined, ctx.projectId, "project");
+        auditToDb(ctx.centralDb, "write", id, { tool: "gnosys_add_structured", category });
+        if (ctx.search)
+            await reindexAllStores();
         return {
-            content: [{ type: "text", text: "No writable store found." }],
-            isError: true,
+            content: [
+                {
+                    type: "text",
+                    text: `Memory added to [${writeTarget.label}]: **${title}**\nID: ${id}`,
+                },
+            ],
         };
     }
-    if (!ctx.centralDb?.isAvailable()) {
+    catch (err) {
         return {
-            content: [{ type: "text", text: "Database not available. Cannot write memory." }],
+            content: [{ type: "text", text: formatMcpError("adding structured memory", err) }],
             isError: true,
         };
     }
-    const id = ctx.centralDb.getNextId(category, ctx.projectId ?? undefined);
-    const today = new Date().toISOString().split("T")[0];
-    const frontmatter = {
-        id,
-        title,
-        category,
-        tags: tags,
-        relevance: relevance || "",
-        author: author || "ai",
-        authority: authority || "observed",
-        confidence: confidence || 0.8,
-        created: today,
-        modified: today,
-        last_reviewed: today,
-        status: "active",
-        supersedes: null,
-    };
-    const fullContent = `# ${title}\n\n${content}`;
-    // Write to DB only (SQLite is sole source of truth)
-    syncMemoryToDb(ctx.centralDb, frontmatter, fullContent, undefined, ctx.projectId, "project");
-    auditToDb(ctx.centralDb, "write", id, { tool: "gnosys_add_structured", category });
-    if (ctx.search)
-        await reindexAllStores();
-    return {
-        content: [
-            {
-                type: "text",
-                text: `Memory added to [${writeTarget.label}]: **${title}**\nID: ${id}`,
-            },
-        ],
-    };
 });
 // ─── Tool: gnosys_tags ───────────────────────────────────────────────────
 server.tool("gnosys_tags", "List all tags in the registry, grouped by category.", { projectRoot: projectRootParam }, async ({ projectRoot }) => {
@@ -2282,81 +2296,106 @@ server.tool("gnosys_portfolio", "Portfolio dashboard — shows all registered pr
 });
 // ─── Remote sync tools (v5.3.0) ─────────────────────────────────────────
 server.tool("gnosys_remote_status", "Check the status of remote sync (multi-machine). Returns pending pushes, pulls, conflicts, and reachability. Agents should surface this to the user when there are pending changes or conflicts.", {}, async () => {
-    if (!centralDb?.isAvailable()) {
-        return { content: [{ type: "text", text: "Central DB not available." }], isError: true };
-    }
-    const remotePath = centralDb.getMeta("remote_path");
-    if (!remotePath) {
+    // Sync operations need explicit local DB access (not auto-routed remote).
+    const localDb = GnosysDB.openLocal();
+    try {
+        if (!localDb.isAvailable()) {
+            return { content: [{ type: "text", text: "Local DB not available." }], isError: true };
+        }
+        const remotePath = localDb.getMeta("remote_path");
+        if (!remotePath) {
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({ configured: false, message: "Remote sync not configured." }, null, 2),
+                    }],
+            };
+        }
+        const { RemoteSync } = await import("./lib/remote.js");
+        const sync = new RemoteSync(localDb, remotePath);
+        const status = await sync.getStatus();
+        sync.closeRemote();
         return {
-            content: [{
-                    type: "text",
-                    text: JSON.stringify({ configured: false, message: "Remote sync not configured." }, null, 2),
-                }],
+            content: [{ type: "text", text: JSON.stringify(status, null, 2) }],
         };
     }
-    const { RemoteSync } = await import("./lib/remote.js");
-    const sync = new RemoteSync(centralDb, remotePath);
-    const status = await sync.getStatus();
-    sync.closeRemote();
-    return {
-        content: [{ type: "text", text: JSON.stringify(status, null, 2) }],
-    };
+    finally {
+        localDb.close();
+    }
 });
 server.tool("gnosys_remote_push", "Push local memory changes to the remote (NAS) database. Uses skip-and-flag for conflicts by default. Call this when the user has approved pushing local changes.", {
     newerWins: z.boolean().optional().describe("Auto-resolve conflicts by taking the newer version"),
 }, async ({ newerWins }) => {
-    if (!centralDb?.isAvailable()) {
-        return { content: [{ type: "text", text: "Central DB not available." }], isError: true };
+    const localDb = GnosysDB.openLocal();
+    try {
+        if (!localDb.isAvailable()) {
+            return { content: [{ type: "text", text: "Local DB not available." }], isError: true };
+        }
+        const remotePath = localDb.getMeta("remote_path");
+        if (!remotePath) {
+            return { content: [{ type: "text", text: "Remote not configured. Run 'gnosys remote configure'." }], isError: true };
+        }
+        const { RemoteSync } = await import("./lib/remote.js");
+        const sync = new RemoteSync(localDb, remotePath);
+        const result = await sync.push({ strategy: newerWins ? "newer-wins" : "skip-and-flag" });
+        sync.closeRemote();
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
     }
-    const remotePath = centralDb.getMeta("remote_path");
-    if (!remotePath) {
-        return { content: [{ type: "text", text: "Remote not configured. Run 'gnosys remote configure'." }], isError: true };
+    finally {
+        localDb.close();
     }
-    const { RemoteSync } = await import("./lib/remote.js");
-    const sync = new RemoteSync(centralDb, remotePath);
-    const result = await sync.push({ strategy: newerWins ? "newer-wins" : "skip-and-flag" });
-    sync.closeRemote();
-    return {
-        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
-    };
 });
 server.tool("gnosys_remote_pull", "Pull remote memory changes to the local database. Uses skip-and-flag for conflicts by default. Call this when the user wants the latest from the remote.", {
     newerWins: z.boolean().optional().describe("Auto-resolve conflicts by taking the newer version"),
 }, async ({ newerWins }) => {
-    if (!centralDb?.isAvailable()) {
-        return { content: [{ type: "text", text: "Central DB not available." }], isError: true };
+    const localDb = GnosysDB.openLocal();
+    try {
+        if (!localDb.isAvailable()) {
+            return { content: [{ type: "text", text: "Local DB not available." }], isError: true };
+        }
+        const remotePath = localDb.getMeta("remote_path");
+        if (!remotePath) {
+            return { content: [{ type: "text", text: "Remote not configured." }], isError: true };
+        }
+        const { RemoteSync } = await import("./lib/remote.js");
+        const sync = new RemoteSync(localDb, remotePath);
+        const result = await sync.pull({ strategy: newerWins ? "newer-wins" : "skip-and-flag" });
+        sync.closeRemote();
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
     }
-    const remotePath = centralDb.getMeta("remote_path");
-    if (!remotePath) {
-        return { content: [{ type: "text", text: "Remote not configured." }], isError: true };
+    finally {
+        localDb.close();
     }
-    const { RemoteSync } = await import("./lib/remote.js");
-    const sync = new RemoteSync(centralDb, remotePath);
-    const result = await sync.pull({ strategy: newerWins ? "newer-wins" : "skip-and-flag" });
-    sync.closeRemote();
-    return {
-        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
-    };
 });
 server.tool("gnosys_remote_resolve", "Resolve a sync conflict by choosing which version to keep. Use after gnosys_remote_status reveals conflicts. The agent should present the local and remote versions to the user and call this with their choice.", {
     memoryId: z.string().describe("Memory ID with the conflict"),
     choice: z.enum(["local", "remote"]).describe("Which version to keep"),
 }, async ({ memoryId, choice }) => {
-    if (!centralDb?.isAvailable()) {
-        return { content: [{ type: "text", text: "Central DB not available." }], isError: true };
-    }
-    const remotePath = centralDb.getMeta("remote_path");
-    if (!remotePath) {
-        return { content: [{ type: "text", text: "Remote not configured." }], isError: true };
+    const localDb = GnosysDB.openLocal();
+    try {
+        if (!localDb.isAvailable()) {
+            return { content: [{ type: "text", text: "Local DB not available." }], isError: true };
+        }
+        const remotePath = localDb.getMeta("remote_path");
+        if (!remotePath) {
+            return { content: [{ type: "text", text: "Remote not configured." }], isError: true };
+        }
+        const { RemoteSync } = await import("./lib/remote.js");
+        const sync = new RemoteSync(localDb, remotePath);
+        const result = await sync.resolve(memoryId, choice);
+        sync.closeRemote();
+        if (result.ok) {
+            return { content: [{ type: "text", text: `Resolved ${memoryId}: kept ${choice} version.` }] };
+        }
+        return { content: [{ type: "text", text: `Failed to resolve: ${result.error}` }], isError: true };
     }
-    const { RemoteSync } = await import("./lib/remote.js");
-    const sync = new RemoteSync(centralDb, remotePath);
-    const result = await sync.resolve(memoryId, choice);
-    sync.closeRemote();
-    if (result.ok) {
-        return { content: [{ type: "text", text: `Resolved ${memoryId}: kept ${choice} version.` }] };
+    finally {
+        localDb.close();
     }
-    return { content: [{ type: "text", text: `Failed to resolve: ${result.error}` }], isError: true };
 });
 // ─── Tool: gnosys_update_status ─────────────────────────────────────────
 server.tool("gnosys_update_status", "Get the prompt/template for writing a dashboard-compatible status memory for this project. Returns instructions for creating a landscape memory with the correct heading format so the portfolio dashboard can parse it. Run this, then follow the instructions to analyze and write the status.", {