gnosys 5.7.0 → 5.8.0

package/dist/index.js

@@ -11,6 +11,7 @@
 import dotenv from "dotenv";
 import path from "path";
 import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
 const home = process.env.HOME || process.env.USERPROFILE || "/tmp";
 try {
     const envFile = readFileSync(path.join(home, ".config", "gnosys", ".env"), "utf8");
@@ -23,6 +24,19 @@ try {
 catch {
     // .env file not found — that's fine, env vars may be set elsewhere
 }
+// v5.7.1 (#15): read our running version so the upgrade-marker watcher
+// can detect when a newer global install lands and exit for client respawn.
+const __filenameMcp = fileURLToPath(import.meta.url);
+const __dirnameMcp = path.dirname(__filenameMcp);
+const RUNNING_VERSION = (() => {
+    try {
+        const raw = readFileSync(path.resolve(__dirnameMcp, "..", "package.json"), "utf8");
+        return JSON.parse(raw).version || "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+})();
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
@@ -51,7 +65,7 @@ import { GnosysDreamEngine, DreamScheduler, formatDreamReport } from "./lib/drea
 import { GnosysExporter, formatExportReport } from "./lib/export.js";
 import { createProjectIdentity, readProjectIdentity } from "./lib/projectIdentity.js";
 import { setPreference, getPreference, getAllPreferences, deletePreference } from "./lib/preferences.js";
-import { syncRules } from "./lib/rulesGen.js";
+import { syncRules, generateRulesBlock } from "./lib/rulesGen.js";
 import { federatedSearch, detectAmbiguity, generateBriefing, generateAllBriefings, getWorkingSet, formatWorkingSet, detectCurrentProject } from "./lib/federated.js";
 import { generatePortfolio, formatPortfolioCompact, formatPortfolioMarkdown, generateStatusPrompt } from "./lib/portfolio.js";
 // Initialize resolver (discovers all layered stores)
@@ -73,6 +87,38 @@ function formatMcpError(action, err) {
     }
     return `Error ${action}: ${err instanceof Error ? err.message : String(err)}`;
 }
+/**
+ * v5.7.1 (#15): poll `~/.gnosys/last-upgrade-at` and exit when a newer
+ * version has been installed. The MCP client (Claude Code, Cursor, etc.)
+ * sees the clean exit and respawns the process, which then runs the new
+ * global binary.
+ *
+ * The 10s cadence is a deliberate trade-off: latency is small, the FS
+ * check is one stat (~µs), and an upgrade that landed mid-session gets
+ * picked up before the next agent turn in almost every case.
+ */
+function startUpgradeMarkerWatcher() {
+    const check = async () => {
+        try {
+            const { shouldRestartMcp, readUpgradeMarker } = await import("./lib/upgrade.js");
+            if (shouldRestartMcp(RUNNING_VERSION)) {
+                const marker = readUpgradeMarker();
+                const newVersion = marker?.version || "newer";
+                console.error(`gnosys MCP: upgrading from v${RUNNING_VERSION} → v${newVersion} — restarting`);
+                // Clean exit so the MCP host respawns us against the upgraded binary.
+                process.exit(0);
+            }
+        }
+        catch {
+            // Stat failed — non-critical. Try again on the next tick.
+        }
+    };
+    // Immediate boot-time check, then poll.
+    void check();
+    const timer = setInterval(() => void check(), 10_000);
+    // Don't block process exit on this timer.
+    timer.unref();
+}
 // These are initialized in main() after resolver runs
 let search = null;
 let tagRegistry = null;
@@ -150,6 +196,38 @@ async function resolveToolContext(projectRoot) {
         projectId,
     };
 }
+/**
+ * v5.7.1 (#13): Resolve scope + projectId for a memory write.
+ *
+ * Previously every write was hard-coded to scope="project" with whatever
+ * `ctx.projectId` happened to resolve to — including null. That produced
+ * "project-scope, no project" orphans visible cross-project.
+ *
+ * Now: derive scope from the explicit `store` argument and refuse to
+ * create a project-scoped memory when no project identity is reachable,
+ * telling the caller exactly how to fix it.
+ */
+function resolveWriteScope(ctx, targetStore) {
+    const scope = targetStore || "project";
+    if (scope === "global" || scope === "personal") {
+        return { ok: true, scope, projectId: null };
+    }
+    if (!ctx.projectId) {
+        return {
+            ok: false,
+            error: [
+                "Cannot write a project-scoped memory: no project identity is reachable.",
+                "",
+                "Pick one:",
+                "  • Pass projectRoot=<path-to-project> to anchor this memory to that project",
+                "  • Pass store='global' to write to shared org knowledge",
+                "  • Pass store='personal' for cross-project personal notes",
+                "  • Run gnosys_init in the target directory to register it as a project",
+            ].join("\n"),
+        };
+    }
+    return { ok: true, scope: "project", projectId: ctx.projectId };
+}
 // ─── Tool: gnosys_discover ──────────────────────────────────────────────
 server.tool("gnosys_discover", "Discover relevant memories by describing what you're working on. Searches relevance keyword clouds across all stores. Returns lightweight metadata (title, path, relevance keywords) — NO file contents. Use gnosys_read to load specific memories you need. Call this FIRST when starting a task to find what Gnosys knows.", {
     query: z
@@ -435,14 +513,21 @@ server.tool("gnosys_add", "Add a new memory. Accepts raw text — an LLM structu
         };
     }
     try {
-        const result = await ingestion.ingest(input);
+        // v5.8.0 (#8): pass per-call config so the LLM provider resolves against
+        // the merged project+global config, not the MCP's boot-time config.
+        const result = await ingestion.ingest(input, ctx.config);
         if (!ctx.centralDb?.isAvailable()) {
             return {
                 content: [{ type: "text", text: "Database not available. Cannot write memory." }],
                 isError: true,
             };
         }
-        const id = ctx.centralDb.getNextId(result.category, ctx.projectId ?? undefined);
+        // v5.7.1 (#13): determine scope/projectId before writing
+        const scopeResult = resolveWriteScope(ctx, targetStore);
+        if (!scopeResult.ok) {
+            return { content: [{ type: "text", text: scopeResult.error }], isError: true };
+        }
+        const id = ctx.centralDb.getNextId(result.category, scopeResult.projectId ?? undefined);
         const today = new Date().toISOString().split("T")[0];
         const frontmatter = {
             id,
@@ -461,7 +546,7 @@ server.tool("gnosys_add", "Add a new memory. Accepts raw text — an LLM structu
         };
         const content = `# ${result.title}\n\n${result.content}`;
         // Write to DB only (SQLite is sole source of truth)
-        syncMemoryToDb(ctx.centralDb, frontmatter, content, undefined, ctx.projectId, "project");
+        syncMemoryToDb(ctx.centralDb, frontmatter, content, undefined, scopeResult.projectId, scopeResult.scope);
         auditToDb(ctx.centralDb, "write", id, { tool: "gnosys_add", category: result.category });
         // Rebuild search index across all stores
         if (ctx.search) {
@@ -531,7 +616,12 @@ server.tool("gnosys_add_structured", "Add a memory with structured input (no LLM
                 isError: true,
             };
         }
-        const id = ctx.centralDb.getNextId(category, ctx.projectId ?? undefined);
+        // v5.7.1 (#13): determine scope/projectId before writing
+        const scopeResult = resolveWriteScope(ctx, targetStore);
+        if (!scopeResult.ok) {
+            return { content: [{ type: "text", text: scopeResult.error }], isError: true };
+        }
+        const id = ctx.centralDb.getNextId(category, scopeResult.projectId ?? undefined);
         const today = new Date().toISOString().split("T")[0];
         const frontmatter = {
             id,
@@ -550,7 +640,7 @@ server.tool("gnosys_add_structured", "Add a memory with structured input (no LLM
         };
         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");
+        syncMemoryToDb(ctx.centralDb, frontmatter, fullContent, undefined, scopeResult.projectId, scopeResult.scope);
         auditToDb(ctx.centralDb, "write", id, { tool: "gnosys_add_structured", category });
         if (ctx.search)
             await reindexAllStores();
@@ -961,15 +1051,15 @@ server.tool("gnosys_commit_context", "Pre-compaction memory sweep. Call this bef
     projectRoot: projectRootParam,
 }, async ({ context, dry_run, projectRoot }) => {
     const ctx = await resolveToolContext(projectRoot);
-    // Note: ingestion is module-level since it's heavy
-    if (!ingestion || !ingestion.isLLMAvailable) {
+    // v5.8.0 (#8): no early-gate on the module-level `ingestion` here.
+    // It's bound to the MCP's boot-time config — which may not have an LLM
+    // block on the directory we launched in. The real LLM resolution
+    // happens against `ctx.config` (merged project+global) below; if that
+    // can't find a provider, getLLMProvider() surfaces a provider-specific
+    // error message.
+    if (!ingestion) {
         return {
-            content: [
-                {
-                    type: "text",
-                    text: "Commit context requires an LLM. Configure a provider in gnosys.json or set ANTHROPIC_API_KEY.",
-                },
-            ],
+            content: [{ type: "text", text: "Ingestion module not initialized." }],
             isError: true,
         };
     }
@@ -1059,7 +1149,7 @@ Output ONLY the JSON array, no markdown fences.`,
                         results.push(`❌ FAILED: "${candidate.summary}": Database not available`);
                         continue;
                     }
-                    const result = await ingestion.ingest(candidate.summary);
+                    const result = await ingestion.ingest(candidate.summary, ctx.config);
                     const id = ctx.centralDb.getNextId(result.category, ctx.projectId ?? undefined);
                     const today = new Date().toISOString().split("T")[0];
                     const frontmatter = {
@@ -2050,7 +2140,11 @@ server.tool("gnosys_preference_set", "Set a user preference. Preferences are sto
         return {
             content: [{
                     type: "text",
-                    text: `Preference set: **${pref.title}**\n  Key: ${pref.key}\n  Value: ${pref.value}\n\nRun \`gnosys_sync\` to regenerate agent rules files with this preference.`,
+                    // v5.8.0 (#9): no longer suggest running gnosys_sync. The
+                    // SessionStart hook (gnosys recall) already injects preferences
+                    // into the next session's context — no need to rewrite tracked
+                    // files like CLAUDE.md.
+                    text: `Preference set: **${pref.title}**\n  Key: ${pref.key}\n  Value: ${pref.value}`,
                 }],
         };
     }
@@ -2123,14 +2217,31 @@ server.tool("gnosys_preference_delete", "Delete a user preference by key.", {
     return {
         content: [{
                 type: "text",
-                text: `Preference "${key}" deleted. Run \`gnosys_sync\` to update agent rules files.`,
+                // v5.8.0 (#9): drop the gnosys_sync suggestion — SessionStart
+                // hook picks up the change next time without rewriting tracked files.
+                text: `Preference "${key}" deleted.`,
             }],
     };
 });
 // ─── Tool: gnosys_sync ──────────────────────────────────────────────────
-server.tool("gnosys_sync", "Regenerate agent rules file from current user preferences and project conventions. Injects a GNOSYS:START/GNOSYS:END block into the detected agent rules file (CLAUDE.md, .cursor/rules/gnosys.mdc). User content outside the block is preserved.", {
+//
+// v5.8.0 (#9): inert-by-default. Previously this tool always wrote a
+// GNOSYS:START/GNOSYS:END block into the project's CLAUDE.md (a tracked
+// file in most repos), producing phantom git diffs every time an agent
+// helpfully called it after a preference change. Now the default is
+// "return the rules block as text" — the agent can use that as in-context
+// guidance without touching disk. To actually rewrite the rules file
+// (the v5.7.0 behaviour), pass `commit_to_disk: true` explicitly.
+//
+// Routine in-session context flows through the SessionStart hook
+// (`gnosys recall`), not through this tool.
+server.tool("gnosys_sync", "Get the current user preferences + project conventions formatted as a GNOSYS:START/GNOSYS:END block. By default returns the block as text only (no disk write). Pass commit_to_disk=true to write it into the detected agent rules file (CLAUDE.md, .cursor/rules/gnosys.mdc) — only do this if the user has explicitly asked to refresh the rules file. Routine session context is already injected via the SessionStart hook (`gnosys recall`); do NOT call this tool after every preference change.", {
     projectRoot: projectRootParam,
-}, async ({ projectRoot }) => {
+    commit_to_disk: z
+        .boolean()
+        .optional()
+        .describe("If true, write the block into the detected agent rules file on disk. Default: false (text only). Note: rules files like CLAUDE.md and .cursor/rules/*.mdc are typically tracked in git, so writing creates a diff."),
+}, async ({ projectRoot, commit_to_disk }) => {
     if (!centralDb?.isAvailable()) {
         return {
             content: [{ type: "text", text: "Central DB not available. Cannot sync rules." }],
@@ -2155,12 +2266,36 @@ server.tool("gnosys_sync", "Regenerate agent rules file from current user prefer
             isError: true,
         };
     }
+    const preferences = getAllPreferences(centralDb);
+    let projectConventions = [];
+    if (identity.projectId) {
+        const projectMems = centralDb.getMemoriesByProject(identity.projectId);
+        projectConventions = projectMems.filter((m) => (m.category === "decisions" || m.category === "conventions") && m.status === "active");
+    }
+    const block = generateRulesBlock(preferences, projectConventions);
+    // Default path: return the block as text, no disk write.
+    if (!commit_to_disk) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Rules block (preview, not written to disk):\n\n${block}\n\n` +
+                        `Summary: ${preferences.length} preference(s), ${projectConventions.length} project convention(s).\n` +
+                        `To write this into ${identity.agentRulesTarget || "the agent rules file"}, call gnosys_sync again with commit_to_disk=true.\n` +
+                        `(SessionStart hook 'gnosys recall' already provides routine session context — usually no disk write is needed.)`,
+                },
+            ],
+        };
+    }
+    // Opt-in disk write path.
     if (!identity.agentRulesTarget) {
         return {
-            content: [{
+            content: [
+                {
                     type: "text",
-                    text: "No agent rules target detected (no .cursor/ or CLAUDE.md found). Create one of these first, then re-run gnosys_init to detect it.",
-                }],
+                    text: "commit_to_disk=true requested, but no agent rules target detected (no .cursor/ or CLAUDE.md found). Create one first, then re-run gnosys_init to detect it.",
+                },
+            ],
         };
     }
     const result = await syncRules(centralDb, projectDir, identity.agentRulesTarget, identity.projectId);
@@ -2172,10 +2307,13 @@ server.tool("gnosys_sync", "Regenerate agent rules file from current user prefer
     }
     const action = result.created ? "Created" : "Updated";
     return {
-        content: [{
+        content: [
+            {
                 type: "text",
-                text: `${action} rules file: ${result.filePath}\n\n  Preferences injected: ${result.prefCount}\n  Project conventions: ${result.conventionCount}\n\nContent is inside <!-- GNOSYS:START --> / <!-- GNOSYS:END --> markers.\nUser content outside these markers is preserved.`,
-            }],
+                text: `${action} rules file: ${result.filePath}\n\n  Preferences injected: ${result.prefCount}\n  Project conventions: ${result.conventionCount}\n\n` +
+                    `⚠ This wrote to a file that may be tracked in git — expect a diff. Routine session context flows through the SessionStart hook; only call gnosys_sync with commit_to_disk=true when the user explicitly asks to refresh the rules file.`,
+            },
+        ],
     };
 });
 // ─── Tool: gnosys_federated_search ───────────────────────────────────────
@@ -2644,6 +2782,10 @@ This marks the conversation checkpoint so the next /gnosys-memorize only process
 });
 // ─── Start the server ────────────────────────────────────────────────────
 async function main() {
+    // v5.7.1 (#15): start the upgrade-marker watcher BEFORE anything else.
+    // If `gnosys upgrade` was run on this machine while the MCP was idle,
+    // pick that up immediately instead of serving stale tool handlers.
+    startUpgradeMarkerWatcher();
     // v3.0: Initialize central DB at ~/.gnosys/gnosys.db
     try {
         centralDb = GnosysDB.openCentral();