@keepgoingdev/mcp-server 0.5.4 → 0.5.6

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 KeepGoing.dev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -8,13 +8,23 @@ KeepGoing auto-captures checkpoints (what you were doing, what's next, which fil
 
 ### Claude Code
 
+**Global (recommended)** — works across all your projects:
+
+```bash
+claude mcp add keepgoing --scope user -- npx -y @keepgoingdev/mcp-server
+```
+
+**Per-project** — scoped to a single project:
+
 ```bash
-claude mcp add keepgoing -- npx -y @keepgoingdev/mcp-server
+claude mcp add keepgoing --scope project -- npx -y @keepgoingdev/mcp-server
 ```
 
+Then ask Claude Code to run `setup_project` (with `scope: "user"` for global, or default for per-project) to add session hooks and CLAUDE.md instructions.
+
 ### Manual config
 
-Add to your MCP config (e.g., `~/.claude/claude_code_config.json`):
+Add to your MCP config (e.g., `~/.claude.json` for global, or `.mcp.json` for per-project):
 
 ```json
 {

package/dist/index.js

@@ -1960,10 +1960,48 @@ function registerGetCurrentTask(server, reader) {
 }
 
 // src/tools/setupProject.ts
+import fs6 from "fs";
+import os3 from "os";
+import path8 from "path";
+import { z as z4 } from "zod";
+
+// src/cli/migrate.ts
 import fs5 from "fs";
 import os2 from "os";
 import path7 from "path";
-import { z as z4 } from "zod";
+var STATUSLINE_CMD = "npx -y @keepgoingdev/mcp-server --statusline";
+function isLegacyStatusline(command) {
+  return !command.includes("--statusline") && command.includes("keepgoing-statusline");
+}
+function migrateStatusline(wsPath) {
+  const settingsPath = path7.join(wsPath, ".claude", "settings.json");
+  if (!fs5.existsSync(settingsPath)) return void 0;
+  try {
+    const settings = JSON.parse(fs5.readFileSync(settingsPath, "utf-8"));
+    const cmd = settings.statusLine?.command;
+    if (!cmd || !isLegacyStatusline(cmd)) return void 0;
+    settings.statusLine = {
+      type: "command",
+      command: STATUSLINE_CMD
+    };
+    fs5.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+    cleanupLegacyScript();
+    return "[KeepGoing] Migrated statusline to auto-updating command (restart Claude Code to apply)";
+  } catch {
+    return void 0;
+  }
+}
+function cleanupLegacyScript() {
+  const legacyScript = path7.join(os2.homedir(), ".claude", "keepgoing-statusline.sh");
+  if (fs5.existsSync(legacyScript)) {
+    try {
+      fs5.unlinkSync(legacyScript);
+    } catch {
+    }
+  }
+}
+
+// src/tools/setupProject.ts
 var KEEPGOING_MARKER = "@keepgoingdev/mcp-server";
 var SESSION_START_HOOK = {
   matcher: "",
@@ -2005,101 +2043,140 @@ function hasKeepGoingHook(hookEntries) {
     (entry) => entry?.hooks?.some((h) => typeof h?.command === "string" && h.command.includes(KEEPGOING_MARKER))
   );
 }
+function resolveScopePaths(scope, workspacePath) {
+  if (scope === "user") {
+    const claudeDir2 = path8.join(os3.homedir(), ".claude");
+    return {
+      claudeDir: claudeDir2,
+      settingsPath: path8.join(claudeDir2, "settings.json"),
+      claudeMdPath: path8.join(claudeDir2, "CLAUDE.md")
+    };
+  }
+  const claudeDir = path8.join(workspacePath, ".claude");
+  const dotClaudeMdPath = path8.join(workspacePath, ".claude", "CLAUDE.md");
+  const rootClaudeMdPath = path8.join(workspacePath, "CLAUDE.md");
+  return {
+    claudeDir,
+    settingsPath: path8.join(claudeDir, "settings.json"),
+    claudeMdPath: fs6.existsSync(dotClaudeMdPath) ? dotClaudeMdPath : rootClaudeMdPath
+  };
+}
+function writeHooksToSettings(settings) {
+  let changed = false;
+  if (!settings.hooks) {
+    settings.hooks = {};
+  }
+  if (!Array.isArray(settings.hooks.SessionStart)) {
+    settings.hooks.SessionStart = [];
+  }
+  if (!hasKeepGoingHook(settings.hooks.SessionStart)) {
+    settings.hooks.SessionStart.push(SESSION_START_HOOK);
+    changed = true;
+  }
+  if (!Array.isArray(settings.hooks.Stop)) {
+    settings.hooks.Stop = [];
+  }
+  if (!hasKeepGoingHook(settings.hooks.Stop)) {
+    settings.hooks.Stop.push(STOP_HOOK);
+    changed = true;
+  }
+  if (!Array.isArray(settings.hooks.PostToolUse)) {
+    settings.hooks.PostToolUse = [];
+  }
+  if (!hasKeepGoingHook(settings.hooks.PostToolUse)) {
+    settings.hooks.PostToolUse.push(POST_TOOL_USE_HOOK);
+    changed = true;
+  }
+  return changed;
+}
+function checkHookConflict(scope, workspacePath) {
+  const otherPaths = resolveScopePaths(scope === "user" ? "project" : "user", workspacePath);
+  if (!fs6.existsSync(otherPaths.settingsPath)) {
+    return null;
+  }
+  try {
+    const otherSettings = JSON.parse(fs6.readFileSync(otherPaths.settingsPath, "utf-8"));
+    const hooks = otherSettings?.hooks;
+    if (!hooks) return null;
+    const hasConflict = Array.isArray(hooks.SessionStart) && hasKeepGoingHook(hooks.SessionStart) || Array.isArray(hooks.Stop) && hasKeepGoingHook(hooks.Stop);
+    if (hasConflict) {
+      const otherScope = scope === "user" ? "project" : "user";
+      const otherFile = otherPaths.settingsPath;
+      return `**Warning:** KeepGoing hooks are also configured at ${otherScope} scope (\`${otherFile}\`). Having hooks at both scopes may cause them to fire twice. Consider removing the ${otherScope}-level hooks if you want to use ${scope}-level only.`;
+    }
+  } catch {
+  }
+  return null;
+}
 function registerSetupProject(server, workspacePath) {
   server.tool(
     "setup_project",
-    "Set up KeepGoing in the current project. Adds session hooks to .claude/settings.json and CLAUDE.md instructions so checkpoints are saved automatically.",
+    'Set up KeepGoing hooks and instructions. Use scope "user" for global setup (all projects) or "project" for per-project setup.',
     {
-      sessionHooks: z4.boolean().optional().default(true).describe("Add session hooks to .claude/settings.json"),
-      claudeMd: z4.boolean().optional().default(true).describe("Add KeepGoing instructions to CLAUDE.md")
+      sessionHooks: z4.boolean().optional().default(true).describe("Add session hooks to settings.json"),
+      claudeMd: z4.boolean().optional().default(true).describe("Add KeepGoing instructions to CLAUDE.md"),
+      scope: z4.enum(["project", "user"]).optional().default("project").describe('Where to write config: "user" for global (~/.claude/), "project" for per-project (.claude/)')
     },
-    async ({ sessionHooks, claudeMd }) => {
+    async ({ sessionHooks, claudeMd, scope }) => {
       const results = [];
-      const claudeDir = path7.join(workspacePath, ".claude");
-      const settingsPath = path7.join(claudeDir, "settings.json");
+      const { claudeDir, settingsPath, claudeMdPath } = resolveScopePaths(scope, workspacePath);
+      const scopeLabel = scope === "user" ? "`~/.claude/settings.json`" : "`.claude/settings.json`";
       let settings = {};
-      if (fs5.existsSync(settingsPath)) {
-        settings = JSON.parse(fs5.readFileSync(settingsPath, "utf-8"));
+      if (fs6.existsSync(settingsPath)) {
+        settings = JSON.parse(fs6.readFileSync(settingsPath, "utf-8"));
       }
       let settingsChanged = false;
       if (sessionHooks) {
-        if (!settings.hooks) {
-          settings.hooks = {};
-        }
-        if (!Array.isArray(settings.hooks.SessionStart)) {
-          settings.hooks.SessionStart = [];
-        }
-        if (!hasKeepGoingHook(settings.hooks.SessionStart)) {
-          settings.hooks.SessionStart.push(SESSION_START_HOOK);
-          settingsChanged = true;
-        }
-        if (!Array.isArray(settings.hooks.Stop)) {
-          settings.hooks.Stop = [];
-        }
-        if (!hasKeepGoingHook(settings.hooks.Stop)) {
-          settings.hooks.Stop.push(STOP_HOOK);
-          settingsChanged = true;
-        }
-        if (!Array.isArray(settings.hooks.PostToolUse)) {
-          settings.hooks.PostToolUse = [];
-        }
-        if (!hasKeepGoingHook(settings.hooks.PostToolUse)) {
-          settings.hooks.PostToolUse.push(POST_TOOL_USE_HOOK);
-          settingsChanged = true;
-        }
-        if (settingsChanged) {
-          results.push("**Session hooks:** Added to `.claude/settings.json`");
+        const hooksChanged = writeHooksToSettings(settings);
+        settingsChanged = hooksChanged;
+        if (hooksChanged) {
+          results.push(`**Session hooks:** Added to ${scopeLabel}`);
         } else {
           results.push("**Session hooks:** Already present, skipped");
         }
+        const conflict = checkHookConflict(scope, workspacePath);
+        if (conflict) {
+          results.push(conflict);
+        }
       }
-      if (process.env.KEEPGOING_PRO_BYPASS === "1" || getLicenseForFeature("session-awareness")) {
-        const statuslineSrc = path7.resolve(
-          new URL(".", import.meta.url).pathname,
-          "statusline.sh"
-        );
-        const claudeHome = path7.join(os2.homedir(), ".claude");
-        const statuslineDest = path7.join(claudeHome, "keepgoing-statusline.sh");
-        if (fs5.existsSync(statuslineSrc)) {
-          if (!fs5.existsSync(claudeHome)) {
-            fs5.mkdirSync(claudeHome, { recursive: true });
-          }
-          fs5.copyFileSync(statuslineSrc, statuslineDest);
-          fs5.chmodSync(statuslineDest, 493);
-          if (!settings.statusLine) {
+      if (scope === "project") {
+        if (process.env.KEEPGOING_PRO_BYPASS === "1" || getLicenseForFeature("session-awareness")) {
+          const needsUpdate = settings.statusLine?.command && isLegacyStatusline(settings.statusLine.command);
+          if (!settings.statusLine || needsUpdate) {
             settings.statusLine = {
               type: "command",
-              command: statuslineDest
+              command: STATUSLINE_CMD
             };
             settingsChanged = true;
-            results.push("**Statusline:** Installed `keepgoing-statusline.sh` and added to `.claude/settings.json`");
+            results.push(needsUpdate ? "**Statusline:** Migrated to auto-updating `npx` command" : "**Statusline:** Added to `.claude/settings.json`");
           } else {
             results.push("**Statusline:** `statusLine` already configured in settings, skipped");
           }
-        } else {
-          results.push("**Statusline:** Script not found in package, skipped");
+          cleanupLegacyScript();
         }
       }
       if (settingsChanged) {
-        if (!fs5.existsSync(claudeDir)) {
-          fs5.mkdirSync(claudeDir, { recursive: true });
+        if (!fs6.existsSync(claudeDir)) {
+          fs6.mkdirSync(claudeDir, { recursive: true });
         }
-        fs5.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+        fs6.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
       }
       if (claudeMd) {
-        const dotClaudeMdPath = path7.join(workspacePath, ".claude", "CLAUDE.md");
-        const rootClaudeMdPath = path7.join(workspacePath, "CLAUDE.md");
-        const claudeMdPath = fs5.existsSync(dotClaudeMdPath) ? dotClaudeMdPath : rootClaudeMdPath;
         let existing = "";
-        if (fs5.existsSync(claudeMdPath)) {
-          existing = fs5.readFileSync(claudeMdPath, "utf-8");
+        if (fs6.existsSync(claudeMdPath)) {
+          existing = fs6.readFileSync(claudeMdPath, "utf-8");
         }
+        const mdLabel = scope === "user" ? "`~/.claude/CLAUDE.md`" : "`CLAUDE.md`";
         if (existing.includes("## KeepGoing")) {
-          results.push("**CLAUDE.md:** KeepGoing section already present, skipped");
+          results.push(`**CLAUDE.md:** KeepGoing section already present in ${mdLabel}, skipped`);
         } else {
           const updated = existing + CLAUDE_MD_SECTION;
-          fs5.writeFileSync(claudeMdPath, updated);
-          results.push("**CLAUDE.md:** Added KeepGoing section");
+          const mdDir = path8.dirname(claudeMdPath);
+          if (!fs6.existsSync(mdDir)) {
+            fs6.mkdirSync(mdDir, { recursive: true });
+          }
+          fs6.writeFileSync(claudeMdPath, updated);
+          results.push(`**CLAUDE.md:** Added KeepGoing section to ${mdLabel}`);
         }
       }
       return {
@@ -2381,6 +2458,10 @@ async function handlePrintMomentum() {
     lines.push(`  Worked on ${touchedCount} files on ${lastSession.gitBranch ?? "unknown branch"}`);
   }
   lines.push("  Tip: Use the get_reentry_briefing tool for a full briefing");
+  const migrationMsg = migrateStatusline(wsPath);
+  if (migrationMsg) {
+    lines.push(migrationMsg);
+  }
   console.log(lines.join("\n"));
   process.exit(0);
 }
@@ -2422,7 +2503,7 @@ async function handlePrintCurrent() {
 }
 
 // src/cli/saveCheckpoint.ts
-import path8 from "path";
+import path9 from "path";
 async function handleSaveCheckpoint() {
   const wsPath = resolveWsPath();
   const reader = new KeepGoingReader(wsPath);
@@ -2450,9 +2531,9 @@ async function handleSaveCheckpoint() {
     sessionStartTime: lastSession?.timestamp ?? now,
     lastActivityTime: now
   });
-  const summary = buildSmartSummary(events) ?? `Worked on ${touchedFiles.slice(0, 5).map((f) => path8.basename(f)).join(", ")}`;
+  const summary = buildSmartSummary(events) ?? `Worked on ${touchedFiles.slice(0, 5).map((f) => path9.basename(f)).join(", ")}`;
   const nextStep = buildSmartNextStep(events);
-  const projectName = path8.basename(resolveStorageRoot(wsPath));
+  const projectName = path9.basename(resolveStorageRoot(wsPath));
   const sessionId = generateSessionId({ workspaceRoot: wsPath, branch: gitBranch ?? void 0, worktreePath: wsPath });
   const checkpoint = createCheckpoint({
     summary,
@@ -2543,7 +2624,8 @@ async function handleUpdateTaskFromHook() {
       const fileName = filePath ? filePath.split("/").pop() ?? filePath : "";
       const writer = new KeepGoingWriter(wsPath);
       const existing = writer.readCurrentTasks();
-      const cachedBranch = existing.find((t) => t.sessionActive && t.worktreePath === wsPath)?.branch;
+      const sessionIdFromHook = hookData.session_id;
+      const cachedBranch = sessionIdFromHook ? existing.find((t) => t.sessionId === sessionIdFromHook)?.branch : void 0;
       const branch = cachedBranch ?? getCurrentBranch(wsPath) ?? void 0;
       const task = {
         taskSummary: fileName ? `${toolName} ${fileName}` : `Used ${toolName}`,
@@ -2563,13 +2645,69 @@ async function handleUpdateTaskFromHook() {
   process.stdin.resume();
 }
 
+// src/cli/statusline.ts
+import fs7 from "fs";
+import path10 from "path";
+var STDIN_TIMEOUT_MS2 = 3e3;
+async function handleStatusline() {
+  const chunks = [];
+  const timeout = setTimeout(() => process.exit(0), STDIN_TIMEOUT_MS2);
+  process.stdin.on("error", () => {
+    clearTimeout(timeout);
+    process.exit(0);
+  });
+  process.stdin.on("data", (chunk) => chunks.push(chunk));
+  process.stdin.on("end", () => {
+    clearTimeout(timeout);
+    try {
+      const raw = Buffer.concat(chunks).toString("utf-8").trim();
+      if (!raw) {
+        process.exit(0);
+      }
+      const input = JSON.parse(raw);
+      const dir = input.workspace?.current_dir ?? input.cwd;
+      if (!dir) {
+        process.exit(0);
+      }
+      const gitRoot = findGitRoot(dir);
+      const tasksFile = path10.join(gitRoot, ".keepgoing", "current-tasks.json");
+      if (!fs7.existsSync(tasksFile)) {
+        process.exit(0);
+      }
+      const data = JSON.parse(fs7.readFileSync(tasksFile, "utf-8"));
+      const branch = getCurrentBranch(gitRoot) ?? "";
+      const active = pruneStaleTasks(data.tasks ?? []).filter((t) => t.sessionActive && t.branch === branch);
+      if (active.length === 0) {
+        process.exit(0);
+      }
+      active.sort((a, b) => a.updatedAt.localeCompare(b.updatedAt));
+      const task = active[active.length - 1];
+      const summary = task.taskSummary;
+      if (!summary) {
+        process.exit(0);
+      }
+      if (branch) {
+        process.stdout.write(`[KG] ${branch}: ${summary}
+`);
+      } else {
+        process.stdout.write(`[KG] ${summary}
+`);
+      }
+    } catch {
+    }
+    process.exit(0);
+  });
+  process.stdin.resume();
+}
+
 // src/index.ts
 var CLI_HANDLERS = {
   "--print-momentum": handlePrintMomentum,
   "--save-checkpoint": handleSaveCheckpoint,
   "--update-task": handleUpdateTask,
   "--update-task-from-hook": handleUpdateTaskFromHook,
-  "--print-current": handlePrintCurrent
+  "--print-current": handlePrintCurrent,
+  "--statusline": handleStatusline
 };
 var flag = process.argv.slice(2).find((a) => a in CLI_HANDLERS);
 if (flag) {