@keepgoingdev/mcp-server 0.1.0 → 0.1.2

package/dist/index.js

@@ -1,64 +1,646 @@
 #!/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 { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/storage.ts
+import fs from "fs";
+import path from "path";
+
+// ../../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 getCommitMessagesSince(workspacePath2, sinceTimestamp) {
+  return getGitLogSince(workspacePath2, "%s", sinceTimestamp);
+}
+
+// ../../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(", ");
+}
+
+// src/storage.ts
+var STORAGE_DIR = ".keepgoing";
+var META_FILE = "meta.json";
+var SESSIONS_FILE = "sessions.json";
+var STATE_FILE = "state.json";
+var KeepGoingReader = class {
+  storagePath;
+  metaFilePath;
+  sessionsFilePath;
+  stateFilePath;
+  constructor(workspacePath2) {
+    this.storagePath = path.join(workspacePath2, STORAGE_DIR);
+    this.metaFilePath = path.join(this.storagePath, META_FILE);
+    this.sessionsFilePath = path.join(this.storagePath, SESSIONS_FILE);
+    this.stateFilePath = path.join(this.storagePath, STATE_FILE);
+  }
+  /** Check if .keepgoing/ directory exists. */
+  exists() {
+    return fs.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 (!fs.existsSync(filePath)) {
+        return void 0;
+      }
+      const raw = fs.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/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);
 }
-// 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
 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