@keepgoingdev/mcp-server 0.1.1 → 0.2.0

package/dist/index.js

@@ -1,64 +1,945 @@
 #!/usr/bin/env node
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { KeepGoingReader } from './storage.js';
-import { formatRelativeTime } from '@keepgoingdev/shared';
-import { registerGetMomentum } from './tools/getMomentum.js';
-import { registerGetSessionHistory } from './tools/getSessionHistory.js';
-import { registerGetReentryBriefing } from './tools/getReentryBriefing.js';
-import { registerResumePrompt } from './prompts/resume.js';
-// Handle --print-momentum CLI flag: print momentum context and exit.
-// Used by the Claude Code SessionStart hook (scripts/keepgoing-hook.sh).
-if (process.argv.includes('--print-momentum')) {
-    // Workspace path is the first non-flag argument after the script path
-    const wsPath = process.argv.slice(2).find(a => a !== '--print-momentum') || process.cwd();
-    const reader = new KeepGoingReader(wsPath);
-    if (!reader.exists()) {
-        process.exit(0);
-    }
-    const lastSession = reader.getLastSession();
-    if (!lastSession) {
-        process.exit(0);
-    }
-    const touchedCount = lastSession.touchedFiles?.length ?? 0;
-    const lines = [];
-    lines.push(`[KeepGoing] Last checkpoint: ${formatRelativeTime(lastSession.timestamp)}`);
-    if (lastSession.summary) {
-        lines.push(`  Summary: ${lastSession.summary}`);
-    }
-    if (lastSession.nextStep) {
-        lines.push(`  Next step: ${lastSession.nextStep}`);
-    }
-    if (lastSession.blocker) {
-        lines.push(`  Blocker: ${lastSession.blocker}`);
-    }
-    if (lastSession.gitBranch) {
-        lines.push(`  Branch: ${lastSession.gitBranch}`);
-    }
-    if (touchedCount > 0) {
-        lines.push(`  Worked on ${touchedCount} files on ${lastSession.gitBranch ?? 'unknown branch'}`);
-    }
-    lines.push('  Tip: Use the get_reentry_briefing tool for a full briefing');
-    console.log(lines.join('\n'));
+
+// src/index.ts
+import path5 from "path";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/storage.ts
+import fs2 from "fs";
+import path2 from "path";
+
+// ../../packages/shared/src/session.ts
+import { randomUUID } from "crypto";
+function generateCheckpointId() {
+  return randomUUID();
+}
+function createCheckpoint(fields) {
+  return {
+    id: generateCheckpointId(),
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    ...fields
+  };
+}
+
+// ../../packages/shared/src/timeUtils.ts
+function formatRelativeTime(timestamp) {
+  const now = Date.now();
+  const then = new Date(timestamp).getTime();
+  const diffMs = now - then;
+  if (isNaN(diffMs)) {
+    return "unknown time";
+  }
+  if (diffMs < 0) {
+    return "in the future";
+  }
+  const seconds = Math.floor(diffMs / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  const weeks = Math.floor(days / 7);
+  const months = Math.floor(days / 30);
+  const years = Math.floor(days / 365);
+  if (seconds < 10) {
+    return "just now";
+  } else if (seconds < 60) {
+    return `${seconds} seconds ago`;
+  } else if (minutes < 60) {
+    return minutes === 1 ? "1 minute ago" : `${minutes} minutes ago`;
+  } else if (hours < 24) {
+    return hours === 1 ? "1 hour ago" : `${hours} hours ago`;
+  } else if (days < 7) {
+    return days === 1 ? "1 day ago" : `${days} days ago`;
+  } else if (weeks < 4) {
+    return weeks === 1 ? "1 week ago" : `${weeks} weeks ago`;
+  } else if (months < 12) {
+    return months === 1 ? "1 month ago" : `${months} months ago`;
+  } else {
+    return years === 1 ? "1 year ago" : `${years} years ago`;
+  }
+}
+
+// ../../packages/shared/src/gitUtils.ts
+import { execFileSync, execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+function getCurrentBranch(workspacePath2) {
+  try {
+    const result = execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+      cwd: workspacePath2,
+      encoding: "utf-8",
+      timeout: 5e3
+    });
+    return result.trim() || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function getGitLogSince(workspacePath2, format, sinceTimestamp) {
+  try {
+    const since = sinceTimestamp || new Date(Date.now() - 24 * 60 * 60 * 1e3).toISOString();
+    const result = execFileSync(
+      "git",
+      ["log", `--since=${since}`, `--format=${format}`],
+      {
+        cwd: workspacePath2,
+        encoding: "utf-8",
+        timeout: 5e3
+      }
+    );
+    if (!result.trim()) {
+      return [];
+    }
+    return result.trim().split("\n").filter((line) => line.length > 0);
+  } catch {
+    return [];
+  }
+}
+function getCommitsSince(workspacePath2, sinceTimestamp) {
+  return getGitLogSince(workspacePath2, "%H", sinceTimestamp);
+}
+function getCommitMessagesSince(workspacePath2, sinceTimestamp) {
+  return getGitLogSince(workspacePath2, "%s", sinceTimestamp);
+}
+function getTouchedFiles(workspacePath2) {
+  try {
+    const result = execFileSync("git", ["status", "--porcelain"], {
+      cwd: workspacePath2,
+      encoding: "utf-8",
+      timeout: 5e3
+    });
+    if (!result.trim()) {
+      return [];
+    }
+    return result.trim().split("\n").map((line) => line.substring(3).trim()).filter((file) => file.length > 0 && !file.endsWith("/"));
+  } catch {
+    return [];
+  }
+}
+
+// ../../packages/shared/src/reentry.ts
+var RECENT_SESSION_COUNT = 5;
+function generateBriefing(lastSession, recentSessions, projectState, gitBranch, recentCommitMessages) {
+  if (!lastSession) {
+    return void 0;
+  }
+  return {
+    lastWorked: formatRelativeTime(lastSession.timestamp),
+    currentFocus: buildCurrentFocus(lastSession, projectState, gitBranch),
+    recentActivity: buildRecentActivity(
+      lastSession,
+      recentSessions,
+      recentCommitMessages
+    ),
+    suggestedNext: buildSuggestedNext(lastSession, gitBranch),
+    smallNextStep: buildSmallNextStep(
+      lastSession,
+      gitBranch,
+      recentCommitMessages
+    )
+  };
+}
+function getRecentSessions(allSessions, count = RECENT_SESSION_COUNT) {
+  return allSessions.slice(-count).reverse();
+}
+function buildCurrentFocus(lastSession, projectState, gitBranch) {
+  if (projectState.derivedCurrentFocus) {
+    return projectState.derivedCurrentFocus;
+  }
+  const branchFocus = inferFocusFromBranch(gitBranch);
+  if (branchFocus) {
+    return branchFocus;
+  }
+  if (lastSession.summary) {
+    return lastSession.summary;
+  }
+  if (lastSession.touchedFiles.length > 0) {
+    return inferFocusFromFiles(lastSession.touchedFiles);
+  }
+  return "Unknown, save a checkpoint to set context";
+}
+function buildRecentActivity(lastSession, recentSessions, recentCommitMessages) {
+  const parts = [];
+  const sessionCount = recentSessions.length;
+  if (sessionCount > 1) {
+    parts.push(`${sessionCount} recent sessions`);
+  } else if (sessionCount === 1) {
+    parts.push("1 recent session");
+  }
+  if (lastSession.summary) {
+    parts.push(`Last: ${lastSession.summary}`);
+  }
+  if (lastSession.touchedFiles.length > 0) {
+    parts.push(`${lastSession.touchedFiles.length} files touched`);
+  }
+  if (recentCommitMessages && recentCommitMessages.length > 0) {
+    parts.push(`${recentCommitMessages.length} recent commits`);
+  }
+  return parts.length > 0 ? parts.join(". ") : "No recent activity recorded";
+}
+function buildSuggestedNext(lastSession, gitBranch) {
+  if (lastSession.nextStep) {
+    return lastSession.nextStep;
+  }
+  const branchFocus = inferFocusFromBranch(gitBranch);
+  if (branchFocus) {
+    return `Continue working on ${branchFocus}`;
+  }
+  if (lastSession.touchedFiles.length > 0) {
+    return `Continue working on ${inferFocusFromFiles(lastSession.touchedFiles)}`;
+  }
+  return "Save a checkpoint to track your next step";
+}
+function buildSmallNextStep(lastSession, gitBranch, recentCommitMessages) {
+  const fallback = "Review last changed files to resume flow";
+  if (lastSession.nextStep) {
+    const distilled = distillToSmallStep(
+      lastSession.nextStep,
+      lastSession.touchedFiles
+    );
+    if (distilled) {
+      return distilled;
+    }
+  }
+  if (recentCommitMessages && recentCommitMessages.length > 0) {
+    const commitStep = deriveStepFromCommits(recentCommitMessages);
+    if (commitStep) {
+      return commitStep;
+    }
+  }
+  if (lastSession.touchedFiles.length > 0) {
+    const fileStep = deriveStepFromFiles(lastSession.touchedFiles);
+    if (fileStep) {
+      return fileStep;
+    }
+  }
+  const branchFocus = inferFocusFromBranch(gitBranch);
+  if (branchFocus) {
+    return `Check git status for ${branchFocus}`;
+  }
+  return fallback;
+}
+function distillToSmallStep(nextStep, touchedFiles) {
+  if (!nextStep.trim()) {
+    return void 0;
+  }
+  const words = nextStep.trim().split(/\s+/);
+  if (words.length <= 12) {
+    if (touchedFiles.length > 0 && !mentionsFile(nextStep)) {
+      const primaryFile = getPrimaryFileName(touchedFiles);
+      const enhanced = `${nextStep.trim()} in ${primaryFile}`;
+      if (enhanced.split(/\s+/).length <= 12) {
+        return enhanced;
+      }
+    }
+    return nextStep.trim();
+  }
+  return words.slice(0, 12).join(" ");
+}
+function deriveStepFromCommits(commitMessages) {
+  const lastCommit = commitMessages[0];
+  if (!lastCommit || !lastCommit.trim()) {
+    return void 0;
+  }
+  const wipPattern = /^(?:wip|work in progress|started?|begin|draft)[:\s]/i;
+  if (wipPattern.test(lastCommit)) {
+    const topic = lastCommit.replace(wipPattern, "").trim();
+    if (topic) {
+      const words = topic.split(/\s+/).slice(0, 8).join(" ");
+      return `Continue ${words}`;
+    }
+  }
+  return void 0;
+}
+function deriveStepFromFiles(files) {
+  const primaryFile = getPrimaryFileName(files);
+  if (files.length > 1) {
+    return `Open ${primaryFile} and review ${files.length} changed files`;
+  }
+  return `Open ${primaryFile} and pick up where you left off`;
+}
+function getPrimaryFileName(files) {
+  const sourceFiles = files.filter((f) => {
+    const lower = f.toLowerCase();
+    return !lower.includes("test") && !lower.includes("spec") && !lower.includes(".config") && !lower.includes("package.json") && !lower.includes("tsconfig");
+  });
+  const target = sourceFiles.length > 0 ? sourceFiles[0] : files[0];
+  const parts = target.replace(/\\/g, "/").split("/");
+  return parts[parts.length - 1];
+}
+function mentionsFile(text) {
+  return /\w+\.(?:ts|tsx|js|jsx|py|go|rs|java|rb|css|scss|html|json|yaml|yml|md|sql|sh)\b/i.test(
+    text
+  );
+}
+function inferFocusFromBranch(branch) {
+  if (!branch || branch === "main" || branch === "master" || branch === "develop" || branch === "HEAD") {
+    return void 0;
+  }
+  const prefixPattern = /^(?:feature|feat|fix|bugfix|hotfix|chore|refactor|docs|test|ci)\//i;
+  const isFix = /^(?:fix|bugfix|hotfix)\//i.test(branch);
+  const stripped = branch.replace(prefixPattern, "");
+  const cleaned = stripped.replace(/[-_/]/g, " ").replace(/^\d+\s*/, "").trim();
+  if (!cleaned) {
+    return void 0;
+  }
+  return isFix ? `${cleaned} fix` : cleaned;
+}
+function inferFocusFromFiles(files) {
+  if (files.length === 0) {
+    return "unknown files";
+  }
+  const dirs = files.map((f) => {
+    const parts = f.replace(/\\/g, "/").split("/");
+    return parts.length > 1 ? parts.slice(0, -1).join("/") : "";
+  }).filter((d) => d.length > 0);
+  if (dirs.length > 0) {
+    const counts = /* @__PURE__ */ new Map();
+    for (const dir of dirs) {
+      counts.set(dir, (counts.get(dir) ?? 0) + 1);
+    }
+    let topDir = "";
+    let topCount = 0;
+    for (const [dir, count] of counts) {
+      if (count > topCount) {
+        topDir = dir;
+        topCount = count;
+      }
+    }
+    if (topDir) {
+      return `files in ${topDir}`;
+    }
+  }
+  const names = files.slice(0, 3).map((f) => {
+    const parts = f.replace(/\\/g, "/").split("/");
+    return parts[parts.length - 1];
+  });
+  return names.join(", ");
+}
+
+// ../../packages/shared/src/storage.ts
+import fs from "fs";
+import path from "path";
+import { randomUUID as randomUUID2 } from "crypto";
+var STORAGE_DIR = ".keepgoing";
+var META_FILE = "meta.json";
+var SESSIONS_FILE = "sessions.json";
+var STATE_FILE = "state.json";
+var KeepGoingWriter = class {
+  storagePath;
+  sessionsFilePath;
+  stateFilePath;
+  metaFilePath;
+  constructor(workspacePath2) {
+    this.storagePath = path.join(workspacePath2, STORAGE_DIR);
+    this.sessionsFilePath = path.join(this.storagePath, SESSIONS_FILE);
+    this.stateFilePath = path.join(this.storagePath, STATE_FILE);
+    this.metaFilePath = path.join(this.storagePath, META_FILE);
+  }
+  ensureDir() {
+    if (!fs.existsSync(this.storagePath)) {
+      fs.mkdirSync(this.storagePath, { recursive: true });
+    }
+  }
+  saveCheckpoint(checkpoint, projectName) {
+    this.ensureDir();
+    let sessionsData;
+    try {
+      if (fs.existsSync(this.sessionsFilePath)) {
+        const raw = JSON.parse(fs.readFileSync(this.sessionsFilePath, "utf-8"));
+        if (Array.isArray(raw)) {
+          sessionsData = { version: 1, project: projectName, sessions: raw };
+        } else {
+          sessionsData = raw;
+        }
+      } else {
+        sessionsData = { version: 1, project: projectName, sessions: [] };
+      }
+    } catch {
+      sessionsData = { version: 1, project: projectName, sessions: [] };
+    }
+    sessionsData.sessions.push(checkpoint);
+    sessionsData.lastSessionId = checkpoint.id;
+    const MAX_SESSIONS = 200;
+    if (sessionsData.sessions.length > MAX_SESSIONS) {
+      sessionsData.sessions = sessionsData.sessions.slice(-MAX_SESSIONS);
+    }
+    fs.writeFileSync(this.sessionsFilePath, JSON.stringify(sessionsData, null, 2), "utf-8");
+    const state = {
+      lastSessionId: checkpoint.id,
+      lastKnownBranch: checkpoint.gitBranch,
+      lastActivityAt: checkpoint.timestamp
+    };
+    fs.writeFileSync(this.stateFilePath, JSON.stringify(state, null, 2), "utf-8");
+    let meta;
+    try {
+      if (fs.existsSync(this.metaFilePath)) {
+        meta = JSON.parse(fs.readFileSync(this.metaFilePath, "utf-8"));
+        meta.lastUpdated = checkpoint.timestamp;
+      } else {
+        meta = {
+          projectId: randomUUID2(),
+          createdAt: checkpoint.timestamp,
+          lastUpdated: checkpoint.timestamp
+        };
+      }
+    } catch {
+      meta = {
+        projectId: randomUUID2(),
+        createdAt: checkpoint.timestamp,
+        lastUpdated: checkpoint.timestamp
+      };
+    }
+    fs.writeFileSync(this.metaFilePath, JSON.stringify(meta, null, 2), "utf-8");
+  }
+};
+
+// src/storage.ts
+var STORAGE_DIR2 = ".keepgoing";
+var META_FILE2 = "meta.json";
+var SESSIONS_FILE2 = "sessions.json";
+var STATE_FILE2 = "state.json";
+var KeepGoingReader = class {
+  storagePath;
+  metaFilePath;
+  sessionsFilePath;
+  stateFilePath;
+  constructor(workspacePath2) {
+    this.storagePath = path2.join(workspacePath2, STORAGE_DIR2);
+    this.metaFilePath = path2.join(this.storagePath, META_FILE2);
+    this.sessionsFilePath = path2.join(this.storagePath, SESSIONS_FILE2);
+    this.stateFilePath = path2.join(this.storagePath, STATE_FILE2);
+  }
+  /** Check if .keepgoing/ directory exists. */
+  exists() {
+    return fs2.existsSync(this.storagePath);
+  }
+  /** Read state.json, returns undefined if missing or corrupt. */
+  getState() {
+    return this.readJsonFile(this.stateFilePath);
+  }
+  /** Read meta.json, returns undefined if missing or corrupt. */
+  getMeta() {
+    return this.readJsonFile(this.metaFilePath);
+  }
+  /**
+   * Read sessions from sessions.json.
+   * Handles both formats:
+   * - Flat array: SessionCheckpoint[] (from ProjectStorage)
+   * - Wrapper object: ProjectSessions (from SessionStorage)
+   */
+  getSessions() {
+    return this.parseSessions().sessions;
+  }
+  /**
+   * Get the most recent session checkpoint.
+   * Uses state.lastSessionId if available, falls back to last in array.
+   */
+  getLastSession() {
+    const { sessions, wrapperLastSessionId } = this.parseSessions();
+    if (sessions.length === 0) {
+      return void 0;
+    }
+    const state = this.getState();
+    if (state?.lastSessionId) {
+      const found = sessions.find((s) => s.id === state.lastSessionId);
+      if (found) {
+        return found;
+      }
+    }
+    if (wrapperLastSessionId) {
+      const found = sessions.find((s) => s.id === wrapperLastSessionId);
+      if (found) {
+        return found;
+      }
+    }
+    return sessions[sessions.length - 1];
+  }
+  /**
+   * Returns the last N sessions, newest first.
+   */
+  getRecentSessions(count) {
+    return getRecentSessions(this.getSessions(), count);
+  }
+  /**
+   * Parses sessions.json once, returning both the session list
+   * and the optional lastSessionId from a ProjectSessions wrapper.
+   */
+  parseSessions() {
+    const raw = this.readJsonFile(
+      this.sessionsFilePath
+    );
+    if (!raw) {
+      return { sessions: [] };
+    }
+    if (Array.isArray(raw)) {
+      return { sessions: raw };
+    }
+    return { sessions: raw.sessions ?? [], wrapperLastSessionId: raw.lastSessionId };
+  }
+  readJsonFile(filePath) {
+    try {
+      if (!fs2.existsSync(filePath)) {
+        return void 0;
+      }
+      const raw = fs2.readFileSync(filePath, "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      return void 0;
+    }
+  }
+};
+
+// src/tools/getMomentum.ts
+function registerGetMomentum(server2, reader2, workspacePath2) {
+  server2.tool(
+    "get_momentum",
+    "Get current developer momentum: last checkpoint, next step, blockers, and branch context. Use this to understand where the developer left off.",
+    {},
+    async () => {
+      if (!reader2.exists()) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "No KeepGoing data found. The developer has not saved any checkpoints yet."
+            }
+          ]
+        };
+      }
+      const lastSession = reader2.getLastSession();
+      if (!lastSession) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "KeepGoing is set up but no session checkpoints exist yet."
+            }
+          ]
+        };
+      }
+      const state = reader2.getState();
+      const currentBranch = getCurrentBranch(workspacePath2);
+      const branchChanged = lastSession.gitBranch && currentBranch && lastSession.gitBranch !== currentBranch;
+      const lines = [
+        `## Developer Momentum`,
+        "",
+        `**Last checkpoint:** ${formatRelativeTime(lastSession.timestamp)}`,
+        `**Summary:** ${lastSession.summary || "No summary"}`,
+        `**Next step:** ${lastSession.nextStep || "Not specified"}`
+      ];
+      if (lastSession.blocker) {
+        lines.push(`**Blocker:** ${lastSession.blocker}`);
+      }
+      if (lastSession.projectIntent) {
+        lines.push(`**Project intent:** ${lastSession.projectIntent}`);
+      }
+      lines.push("");
+      if (currentBranch) {
+        lines.push(`**Current branch:** ${currentBranch}`);
+      }
+      if (branchChanged) {
+        lines.push(
+          `**Note:** Branch changed since last checkpoint (was \`${lastSession.gitBranch}\`, now \`${currentBranch}\`)`
+        );
+      }
+      if (lastSession.touchedFiles.length > 0) {
+        lines.push("");
+        lines.push(
+          `**Files touched (${lastSession.touchedFiles.length}):** ${lastSession.touchedFiles.slice(0, 10).join(", ")}`
+        );
+        if (lastSession.touchedFiles.length > 10) {
+          lines.push(
+            `  ...and ${lastSession.touchedFiles.length - 10} more`
+          );
+        }
+      }
+      if (state?.derivedCurrentFocus) {
+        lines.push("");
+        lines.push(`**Derived focus:** ${state.derivedCurrentFocus}`);
+      }
+      return {
+        content: [{ type: "text", text: lines.join("\n") }]
+      };
+    }
+  );
+}
+
+// src/tools/getSessionHistory.ts
+import { z } from "zod";
+function registerGetSessionHistory(server2, reader2) {
+  server2.tool(
+    "get_session_history",
+    "Get recent session checkpoints. Returns a chronological list of what the developer worked on.",
+    { limit: z.number().min(1).max(50).default(5).describe("Number of recent sessions to return (1-50, default 5)") },
+    async ({ limit }) => {
+      if (!reader2.exists()) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "No KeepGoing data found."
+            }
+          ]
+        };
+      }
+      const sessions = reader2.getRecentSessions(limit);
+      if (sessions.length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "No session checkpoints found."
+            }
+          ]
+        };
+      }
+      const lines = [
+        `## Session History (last ${sessions.length})`,
+        ""
+      ];
+      for (const session of sessions) {
+        lines.push(`### ${formatRelativeTime(session.timestamp)}`);
+        lines.push(`- **Summary:** ${session.summary || "No summary"}`);
+        lines.push(`- **Next step:** ${session.nextStep || "Not specified"}`);
+        if (session.blocker) {
+          lines.push(`- **Blocker:** ${session.blocker}`);
+        }
+        if (session.gitBranch) {
+          lines.push(`- **Branch:** ${session.gitBranch}`);
+        }
+        if (session.touchedFiles.length > 0) {
+          lines.push(
+            `- **Files:** ${session.touchedFiles.slice(0, 5).join(", ")}${session.touchedFiles.length > 5 ? ` (+${session.touchedFiles.length - 5} more)` : ""}`
+          );
+        }
+        lines.push("");
+      }
+      return {
+        content: [{ type: "text", text: lines.join("\n") }]
+      };
+    }
+  );
+}
+
+// src/tools/getReentryBriefing.ts
+function registerGetReentryBriefing(server2, reader2, workspacePath2) {
+  server2.tool(
+    "get_reentry_briefing",
+    "Get a synthesized re-entry briefing that helps a developer understand where they left off. Includes focus, recent activity, and suggested next steps.",
+    {},
+    async () => {
+      if (!reader2.exists()) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "No KeepGoing data found. The developer has not saved any checkpoints yet."
+            }
+          ]
+        };
+      }
+      const lastSession = reader2.getLastSession();
+      const recentSessions = reader2.getRecentSessions(5);
+      const state = reader2.getState() ?? {};
+      const gitBranch = getCurrentBranch(workspacePath2);
+      const sinceTimestamp = lastSession?.timestamp;
+      const recentCommits = sinceTimestamp ? getCommitMessagesSince(workspacePath2, sinceTimestamp) : [];
+      const briefing = generateBriefing(
+        lastSession,
+        recentSessions,
+        state,
+        gitBranch,
+        recentCommits
+      );
+      if (!briefing) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "No session data available to generate a briefing."
+            }
+          ]
+        };
+      }
+      const lines = [
+        `## Re-entry Briefing`,
+        "",
+        `**Last worked:** ${briefing.lastWorked}`,
+        `**Current focus:** ${briefing.currentFocus}`,
+        `**Recent activity:** ${briefing.recentActivity}`,
+        `**Suggested next:** ${briefing.suggestedNext}`,
+        `**Quick start:** ${briefing.smallNextStep}`
+      ];
+      return {
+        content: [{ type: "text", text: lines.join("\n") }]
+      };
+    }
+  );
+}
+
+// src/tools/saveCheckpoint.ts
+import path3 from "path";
+import { z as z2 } from "zod";
+function registerSaveCheckpoint(server2, reader2, workspacePath2) {
+  server2.tool(
+    "save_checkpoint",
+    "Save a development checkpoint. Call this after completing a task or meaningful piece of work, not just at end of session. Each checkpoint helps the next session (or developer) pick up exactly where you left off.",
+    {
+      summary: z2.string().describe("What was accomplished in this session"),
+      nextStep: z2.string().optional().describe("What to do next"),
+      blocker: z2.string().optional().describe("Any blocker preventing progress")
+    },
+    async ({ summary, nextStep, blocker }) => {
+      const lastSession = reader2.getLastSession();
+      const gitBranch = getCurrentBranch(workspacePath2);
+      const touchedFiles = getTouchedFiles(workspacePath2);
+      const commitHashes = getCommitsSince(workspacePath2, lastSession?.timestamp);
+      const projectName = path3.basename(workspacePath2);
+      const checkpoint = createCheckpoint({
+        summary,
+        nextStep: nextStep || "",
+        blocker,
+        gitBranch,
+        touchedFiles,
+        commitHashes,
+        workspaceRoot: workspacePath2,
+        source: "manual"
+      });
+      const writer = new KeepGoingWriter(workspacePath2);
+      writer.saveCheckpoint(checkpoint, projectName);
+      const lines = [
+        `Checkpoint saved.`,
+        `- **ID:** ${checkpoint.id}`,
+        `- **Branch:** ${gitBranch || "unknown"}`,
+        `- **Files tracked:** ${touchedFiles.length}`,
+        `- **Commits captured:** ${commitHashes.length}`
+      ];
+      return {
+        content: [{ type: "text", text: lines.join("\n") }]
+      };
+    }
+  );
+}
+
+// src/tools/setupProject.ts
+import fs3 from "fs";
+import path4 from "path";
+import { z as z3 } from "zod";
+var KEEPGOING_MARKER = "@keepgoingdev/mcp-server";
+var SESSION_START_HOOK = {
+  matcher: "",
+  hooks: [
+    {
+      type: "command",
+      command: "npx -y @keepgoingdev/mcp-server --print-momentum"
+    }
+  ]
+};
+var STOP_HOOK = {
+  matcher: "",
+  hooks: [
+    {
+      type: "command",
+      command: "npx -y @keepgoingdev/mcp-server --save-checkpoint"
+    }
+  ]
+};
+var CLAUDE_MD_SECTION = `
+## KeepGoing
+
+After completing a task or meaningful piece of work, call the \`save_checkpoint\` MCP tool with:
+- \`summary\`: What you accomplished
+- \`nextStep\`: What should be done next
+- \`blocker\`: Any blocker (if applicable)
+`;
+function hasKeepGoingHook(hookEntries) {
+  return hookEntries.some(
+    (entry) => entry?.hooks?.some((h) => typeof h?.command === "string" && h.command.includes(KEEPGOING_MARKER))
+  );
+}
+function registerSetupProject(server2, workspacePath2) {
+  server2.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.",
+    {
+      sessionHooks: z3.boolean().optional().default(true).describe("Add session hooks to .claude/settings.json"),
+      claudeMd: z3.boolean().optional().default(true).describe("Add KeepGoing instructions to CLAUDE.md")
+    },
+    async ({ sessionHooks, claudeMd }) => {
+      const results = [];
+      if (sessionHooks) {
+        const claudeDir = path4.join(workspacePath2, ".claude");
+        const settingsPath = path4.join(claudeDir, "settings.json");
+        let settings = {};
+        if (fs3.existsSync(settingsPath)) {
+          settings = JSON.parse(fs3.readFileSync(settingsPath, "utf-8"));
+        }
+        if (!settings.hooks) {
+          settings.hooks = {};
+        }
+        let hooksChanged = false;
+        if (!Array.isArray(settings.hooks.SessionStart)) {
+          settings.hooks.SessionStart = [];
+        }
+        if (!hasKeepGoingHook(settings.hooks.SessionStart)) {
+          settings.hooks.SessionStart.push(SESSION_START_HOOK);
+          hooksChanged = true;
+        }
+        if (!Array.isArray(settings.hooks.Stop)) {
+          settings.hooks.Stop = [];
+        }
+        if (!hasKeepGoingHook(settings.hooks.Stop)) {
+          settings.hooks.Stop.push(STOP_HOOK);
+          hooksChanged = true;
+        }
+        if (hooksChanged) {
+          if (!fs3.existsSync(claudeDir)) {
+            fs3.mkdirSync(claudeDir, { recursive: true });
+          }
+          fs3.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+          results.push("**Session hooks:** Added to `.claude/settings.json`");
+        } else {
+          results.push("**Session hooks:** Already present, skipped");
+        }
+      }
+      if (claudeMd) {
+        const claudeMdPath = path4.join(workspacePath2, "CLAUDE.md");
+        let existing = "";
+        if (fs3.existsSync(claudeMdPath)) {
+          existing = fs3.readFileSync(claudeMdPath, "utf-8");
+        }
+        if (existing.includes("## KeepGoing")) {
+          results.push("**CLAUDE.md:** KeepGoing section already present, skipped");
+        } else {
+          const updated = existing + CLAUDE_MD_SECTION;
+          fs3.writeFileSync(claudeMdPath, updated);
+          results.push("**CLAUDE.md:** Added KeepGoing section");
+        }
+      }
+      return {
+        content: [{ type: "text", text: results.join("\n") }]
+      };
+    }
+  );
+}
+
+// src/prompts/resume.ts
+function registerResumePrompt(server2) {
+  server2.prompt(
+    "resume",
+    "Check developer momentum and suggest what to work on next",
+    async () => ({
+      messages: [
+        {
+          role: "user",
+          content: {
+            type: "text",
+            text: [
+              "I just opened this project and want to pick up where I left off.",
+              "",
+              "Please use the KeepGoing tools to:",
+              "1. Check my current momentum (get_momentum)",
+              "2. Get a re-entry briefing (get_reentry_briefing)",
+              "3. Based on the results, give me a concise summary of where I left off and suggest what to work on next.",
+              "",
+              "Keep your response brief and actionable."
+            ].join("\n")
+          }
+        }
+      ]
+    })
+  );
+}
+
+// src/index.ts
+if (process.argv.includes("--print-momentum")) {
+  const wsPath = process.argv.slice(2).find((a) => a !== "--print-momentum") || process.cwd();
+  const reader2 = new KeepGoingReader(wsPath);
+  if (!reader2.exists()) {
     process.exit(0);
+  }
+  const lastSession = reader2.getLastSession();
+  if (!lastSession) {
+    process.exit(0);
+  }
+  const touchedCount = lastSession.touchedFiles?.length ?? 0;
+  const lines = [];
+  lines.push(`[KeepGoing] Last checkpoint: ${formatRelativeTime(lastSession.timestamp)}`);
+  if (lastSession.summary) {
+    lines.push(`  Summary: ${lastSession.summary}`);
+  }
+  if (lastSession.nextStep) {
+    lines.push(`  Next step: ${lastSession.nextStep}`);
+  }
+  if (lastSession.blocker) {
+    lines.push(`  Blocker: ${lastSession.blocker}`);
+  }
+  if (lastSession.gitBranch) {
+    lines.push(`  Branch: ${lastSession.gitBranch}`);
+  }
+  if (touchedCount > 0) {
+    lines.push(`  Worked on ${touchedCount} files on ${lastSession.gitBranch ?? "unknown branch"}`);
+  }
+  lines.push("  Tip: Use the get_reentry_briefing tool for a full briefing");
+  console.log(lines.join("\n"));
+  process.exit(0);
+}
+if (process.argv.includes("--save-checkpoint")) {
+  const wsPath = process.argv.slice(2).find((a) => !a.startsWith("--")) || process.cwd();
+  const reader2 = new KeepGoingReader(wsPath);
+  const lastSession = reader2.getLastSession();
+  if (lastSession?.timestamp) {
+    const ageMs = Date.now() - new Date(lastSession.timestamp).getTime();
+    if (ageMs < 2 * 60 * 1e3) {
+      process.exit(0);
+    }
+  }
+  const touchedFiles = getTouchedFiles(wsPath);
+  const commitHashes = getCommitsSince(wsPath, lastSession?.timestamp);
+  if (touchedFiles.length === 0 && commitHashes.length === 0) {
+    process.exit(0);
+  }
+  const gitBranch = getCurrentBranch(wsPath);
+  const commitMessages = getCommitMessagesSince(wsPath, lastSession?.timestamp);
+  let summary;
+  if (commitMessages.length > 0) {
+    summary = commitMessages.slice(0, 3).join("; ");
+  } else {
+    const fileNames = touchedFiles.slice(0, 5).map((f) => path5.basename(f));
+    summary = `Worked on ${fileNames.join(", ")}`;
+    if (touchedFiles.length > 5) {
+      summary += ` and ${touchedFiles.length - 5} more`;
+    }
+  }
+  const projectName = path5.basename(wsPath);
+  const checkpoint = createCheckpoint({
+    summary,
+    nextStep: "",
+    gitBranch,
+    touchedFiles,
+    commitHashes,
+    workspaceRoot: wsPath,
+    source: "auto"
+  });
+  const writer = new KeepGoingWriter(wsPath);
+  writer.saveCheckpoint(checkpoint, projectName);
+  console.log(`[KeepGoing] Auto-checkpoint saved: ${summary}`);
+  process.exit(0);
 }
-// Default: start MCP server
-// Workspace path can be passed as an argument, otherwise defaults to CWD.
-// MCP hosts (Claude Code, etc.) typically launch the server with the project root as CWD.
-const workspacePath = process.argv[2] || process.cwd();
-const reader = new KeepGoingReader(workspacePath);
-const server = new McpServer({
-    name: 'keepgoing',
-    version: '0.1.0',
+var workspacePath = process.argv[2] || process.cwd();
+var reader = new KeepGoingReader(workspacePath);
+var server = new McpServer({
+  name: "keepgoing",
+  version: "0.1.0"
 });
-// Register tools
 registerGetMomentum(server, reader, workspacePath);
 registerGetSessionHistory(server, reader);
 registerGetReentryBriefing(server, reader, workspacePath);
-// Register prompts
+registerSaveCheckpoint(server, reader, workspacePath);
+registerSetupProject(server, workspacePath);
 registerResumePrompt(server);
-// Connect via stdio
-const transport = new StdioServerTransport();
+var transport = new StdioServerTransport();
 await server.connect(transport);
-console.error('KeepGoing MCP server started');
+console.error("KeepGoing MCP server started");
 //# sourceMappingURL=index.js.map