claude-baton 2.0.1

package/dist/cli.js

@@ -0,0 +1,392 @@
+import { Command } from "commander";
+import { readFileSync, writeFileSync, copyFileSync, existsSync, statSync, readdirSync, unlinkSync, rmSync, } from "fs";
+import { execSync } from "child_process";
+import { fileURLToPath } from "url";
+import path from "path";
+import os from "os";
+import { createInterface } from "readline";
+import { initDatabase, getDefaultDbPath, saveDatabase, countAll, listProjects, insertCheckpoint, getAllCheckpoints, getAllDailySummaries, deleteProjectData, deleteAllData, } from "./store.js";
+import { ensureDir } from "./utils.js";
+import { callClaudeJson } from "./llm.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+function readPromptTemplate(name) {
+    return readFileSync(path.join(__dirname, "..", "prompts", name), "utf-8");
+}
+function gitCmd(cmd) {
+    try {
+        return execSync(cmd, { encoding: "utf-8", timeout: 5000 }).trim();
+    }
+    catch {
+        return "";
+    }
+}
+export async function handleAutoCheckpoint() {
+    try {
+        // Read hook metadata from stdin
+        let stdinData = "";
+        try {
+            stdinData = readFileSync(0, "utf-8");
+        }
+        catch {
+            console.error("[claude-baton] No stdin data, skipping auto-checkpoint");
+            return;
+        }
+        let transcriptPath;
+        try {
+            const metadata = JSON.parse(stdinData);
+            transcriptPath = metadata?.input?.metadata?.transcript_path;
+        }
+        catch {
+            console.error("[claude-baton] Could not parse hook metadata, skipping auto-checkpoint");
+            return;
+        }
+        if (!transcriptPath || !existsSync(transcriptPath)) {
+            console.error("[claude-baton] Transcript not found, skipping auto-checkpoint");
+            return;
+        }
+        // Read and truncate transcript
+        const fullTranscript = readFileSync(transcriptPath, "utf-8");
+        const MAX_CHARS = 50000;
+        const transcript = fullTranscript.length > MAX_CHARS
+            ? fullTranscript.slice(-MAX_CHARS)
+            : fullTranscript;
+        // Gather git state
+        const branch = gitCmd("git branch --show-current");
+        const status = gitCmd("git status --short");
+        const log = gitCmd("git log --oneline -10");
+        // Build prompt
+        const template = readPromptTemplate("auto_checkpoint.txt");
+        const prompt = template.replace("{TRANSCRIPT}", transcript);
+        // Call LLM
+        const result = await callClaudeJson(prompt, "haiku", 30000);
+        // Save checkpoint
+        const dbPath = getDefaultDbPath();
+        const db = await initDatabase(dbPath);
+        const projectPath = process.cwd();
+        const sessionId = new Date().toISOString();
+        const uncommittedFiles = status
+            ? status.split("\n").map((l) => l.trim())
+            : [];
+        insertCheckpoint(db, projectPath, sessionId, result.current_state || "Unknown", result.what_was_built || "Unknown", result.next_steps || "Unknown", {
+            branch: branch || undefined,
+            decisionsMade: result.decisions_made || undefined,
+            blockers: result.blockers || undefined,
+            uncommittedFiles,
+            gitSnapshot: log || undefined,
+            planReference: result.plan_reference || undefined,
+        }, dbPath);
+        console.error("[claude-baton] Auto-checkpoint saved before compaction");
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        console.error(`[claude-baton] Auto-checkpoint failed: ${msg}`);
+        // Exit gracefully — don't block compaction
+    }
+}
+// --- Setup command ---
+export async function handleSetup() {
+    const settingsPath = path.join(os.homedir(), ".claude", "settings.json");
+    const settingsDir = path.dirname(settingsPath);
+    ensureDir(settingsDir);
+    let settings = {};
+    if (existsSync(settingsPath)) {
+        try {
+            settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+        }
+        catch {
+            settings = {};
+        }
+    }
+    // Register MCP server
+    const mcpServers = (settings.mcpServers ?? {});
+    mcpServers["claude-baton"] = {
+        command: "npx",
+        args: ["-y", "claude-baton", "serve"],
+    };
+    settings.mcpServers = mcpServers;
+    // Register PreCompact hook (idempotent — skip if already present)
+    const hooks = (settings.hooks ?? {});
+    const preCompactHooks = (hooks.PreCompact ?? []);
+    const hasMemoriaHook = preCompactHooks.some((h) => h.command && h.command.includes("claude-baton"));
+    if (!hasMemoriaHook) {
+        preCompactHooks.push({
+            type: "command",
+            command: "npx -y claude-baton auto-checkpoint",
+        });
+        hooks.PreCompact = preCompactHooks;
+        settings.hooks = hooks;
+        console.error("  Registered PreCompact hook");
+    }
+    writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+    const dbPath = getDefaultDbPath();
+    await initDatabase(dbPath);
+    const cmdResult = installCommands();
+    console.error(`Setup complete.`);
+    console.error(`  Database: ${dbPath}`);
+    console.error(`  MCP server: registered`);
+    console.error(`  Commands: ${cmdResult.installed} installed, ${cmdResult.skipped} skipped`);
+}
+// --- Install memo- commands ---
+export function installCommands() {
+    const sourceDir = path.join(__dirname, "..", "commands");
+    const targetDir = path.join(os.homedir(), ".claude", "commands");
+    ensureDir(targetDir);
+    let installed = 0;
+    let skipped = 0;
+    const files = readdirSync(sourceDir).filter((f) => f.endsWith(".md"));
+    for (const file of files) {
+        const targetPath = path.join(targetDir, file);
+        if (existsSync(targetPath)) {
+            const name = file.replace(".md", "");
+            console.error(`  Skipping ${name} -- already exists`);
+            skipped++;
+        }
+        else {
+            copyFileSync(path.join(sourceDir, file), targetPath);
+            const name = file.replace(".md", "");
+            console.error(`  Installed /${name}`);
+            installed++;
+        }
+    }
+    return { installed, skipped };
+}
+// --- Uninstall command ---
+export async function handleUninstall(opts) {
+    // 1. Remove MCP server from settings.json
+    const settingsPath = path.join(os.homedir(), ".claude", "settings.json");
+    if (existsSync(settingsPath)) {
+        try {
+            const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+            // Remove MCP server registration
+            if (settings.mcpServers &&
+                typeof settings.mcpServers === "object" &&
+                settings.mcpServers["claude-baton"]) {
+                delete settings.mcpServers["claude-baton"];
+                if (Object.keys(settings.mcpServers).length === 0) {
+                    delete settings.mcpServers;
+                }
+                console.error("  Removed MCP server from settings.json");
+            }
+            // Remove PreCompact hook
+            if (settings.hooks &&
+                typeof settings.hooks === "object" &&
+                settings.hooks.PreCompact) {
+                const hooksObj = settings.hooks;
+                const preCompact = hooksObj.PreCompact;
+                const filtered = preCompact.filter((h) => !h.command || !h.command.includes("claude-baton"));
+                if (filtered.length === 0) {
+                    delete hooksObj.PreCompact;
+                }
+                else {
+                    hooksObj.PreCompact = filtered;
+                }
+                if (Object.keys(hooksObj).length === 0) {
+                    delete settings.hooks;
+                }
+                console.error("  Removed PreCompact hook");
+            }
+            writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+        }
+        catch {
+            console.error("  Warning: could not parse settings.json");
+        }
+    }
+    // 2. Remove memo-* command files
+    const commandsDir = path.join(os.homedir(), ".claude", "commands");
+    let commandsRemoved = 0;
+    if (existsSync(commandsDir)) {
+        const files = readdirSync(commandsDir).filter((f) => f.startsWith("memo-") && f.endsWith(".md"));
+        for (const file of files) {
+            unlinkSync(path.join(commandsDir, file));
+            commandsRemoved++;
+        }
+    }
+    console.error(`  Removed ${commandsRemoved} slash commands`);
+    // 3. Optionally remove database
+    const dbDir = path.join(os.homedir(), ".claude-baton");
+    if (!opts.keepData && existsSync(dbDir)) {
+        if (!opts.force) {
+            const answer = await askConfirmation("  Delete database (~/.claude-baton)? This cannot be undone. [y/N] ");
+            if (answer.toLowerCase() !== "y") {
+                console.error("  Kept database.");
+                console.error("Uninstall complete (database preserved).");
+                return;
+            }
+        }
+        rmSync(dbDir, { recursive: true });
+        console.error("  Deleted database");
+    }
+    else if (opts.keepData) {
+        console.error("  Kept database (--keep-data)");
+    }
+    console.error("Uninstall complete. Run 'npm uninstall -g claude-baton' to remove the binary.");
+}
+// --- Status command ---
+export async function handleStatus(opts) {
+    const dbPath = getDefaultDbPath();
+    if (!existsSync(dbPath)) {
+        console.error("No database found. Run 'claude-baton setup' first.");
+        return;
+    }
+    const db = await initDatabase(dbPath);
+    const projectPath = opts.project ?? process.cwd();
+    const counts = countAll(db, projectPath);
+    const dbSize = statSync(dbPath).size;
+    console.log(`Project: ${projectPath}`);
+    console.log(`Database: ${dbPath} (${(dbSize / 1024).toFixed(1)} KB)`);
+    console.log();
+    console.log("Counts:");
+    for (const [key, value] of Object.entries(counts)) {
+        console.log(`  ${key}: ${value}`);
+    }
+}
+// --- Projects command ---
+export async function handleProjects() {
+    const dbPath = getDefaultDbPath();
+    if (!existsSync(dbPath)) {
+        console.error("No database found. Run 'claude-baton setup' first.");
+        return;
+    }
+    const db = await initDatabase(dbPath);
+    const projects = listProjects(db);
+    if (projects.length === 0) {
+        console.log("No projects with checkpoints yet.");
+        return;
+    }
+    for (const p of projects) {
+        console.log(`${p.project_path} (${p.checkpoint_count} checkpoints)`);
+    }
+}
+// --- Export command ---
+export async function handleExport(opts) {
+    const dbPath = getDefaultDbPath();
+    if (!existsSync(dbPath)) {
+        console.error("No database found. Run 'claude-baton setup' first.");
+        return;
+    }
+    const db = await initDatabase(dbPath);
+    const projectPath = opts.project;
+    const data = {
+        version: 2,
+        exported_at: new Date().toISOString(),
+        checkpoints: getAllCheckpoints(db, projectPath),
+        daily_summaries: getAllDailySummaries(db, projectPath),
+    };
+    console.log(JSON.stringify(data, null, 2));
+}
+// --- Import command ---
+export async function handleImport(file) {
+    const dbPath = getDefaultDbPath();
+    const db = await initDatabase(dbPath);
+    let data;
+    try {
+        const raw = readFileSync(file, "utf-8");
+        data = JSON.parse(raw);
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        console.error(`Failed to read import file: ${msg}`);
+        return;
+    }
+    let imported = 0;
+    if (Array.isArray(data.checkpoints)) {
+        for (const cp of data.checkpoints) {
+            insertCheckpoint(db, cp.project_path, cp.session_id, cp.current_state, cp.what_was_built, cp.next_steps, {
+                branch: cp.branch,
+                decisionsMade: cp.decisions_made,
+                blockers: cp.blockers,
+                uncommittedFiles: cp.uncommitted_files,
+                gitSnapshot: cp.git_snapshot,
+            });
+            imported++;
+        }
+    }
+    saveDatabase(db, dbPath);
+    console.error(`Imported ${imported} items.`);
+}
+// --- Reset command ---
+export async function handleReset(opts) {
+    const dbPath = getDefaultDbPath();
+    if (!existsSync(dbPath)) {
+        console.error("No database found. Nothing to reset.");
+        return;
+    }
+    if (!opts.force) {
+        const target = opts.project ?? "ALL projects";
+        const answer = await askConfirmation(`Reset data for ${target}? This cannot be undone. [y/N] `);
+        if (answer.toLowerCase() !== "y") {
+            console.error("Aborted.");
+            return;
+        }
+    }
+    const db = await initDatabase(dbPath);
+    if (opts.project) {
+        deleteProjectData(db, opts.project, dbPath);
+        console.error(`Reset data for project: ${opts.project}`);
+    }
+    else {
+        deleteAllData(db, dbPath);
+        console.error("Reset all data.");
+    }
+}
+function askConfirmation(prompt) {
+    const rl = createInterface({ input: process.stdin, output: process.stderr });
+    return new Promise((resolve) => {
+        rl.question(prompt, (answer) => {
+            rl.close();
+            resolve(answer);
+        });
+    });
+}
+// --- CLI program ---
+const pkg = JSON.parse(readFileSync(path.join(__dirname, "..", "package.json"), "utf-8"));
+const program = new Command();
+program
+    .name("claude-baton")
+    .description("Session lifecycle management for Claude Code")
+    .version(pkg.version);
+program
+    .command("serve")
+    .description("Start the MCP server (stdio transport)")
+    .action(async () => {
+    await import("./index.js");
+});
+program
+    .command("setup")
+    .description("Register MCP server and initialize database")
+    .action(() => handleSetup());
+program
+    .command("auto-checkpoint")
+    .description("Auto-save checkpoint (called by PreCompact hook)")
+    .action(() => handleAutoCheckpoint());
+program
+    .command("uninstall")
+    .description("Remove MCP server, slash commands, and optionally the database")
+    .option("--keep-data", "Keep the database (~/.claude-baton)")
+    .option("--force", "Skip confirmation for database deletion")
+    .action((opts) => handleUninstall(opts));
+program
+    .command("status")
+    .description("Show checkpoint counts and status")
+    .option("--project <path>", "Project path (default: cwd)")
+    .action((opts) => handleStatus(opts));
+program
+    .command("projects")
+    .description("List projects with checkpoints")
+    .action(() => handleProjects());
+program
+    .command("export")
+    .description("Export all data as JSON to stdout")
+    .option("--project <path>", "Filter by project path")
+    .action((opts) => handleExport(opts));
+program
+    .command("import <file>")
+    .description("Import data from JSON file")
+    .action((file) => handleImport(file));
+program
+    .command("reset")
+    .description("Delete all data (or data for a project)")
+    .option("--project <path>", "Only reset this project")
+    .option("--force", "Skip confirmation")
+    .action((opts) => handleReset(opts));
+program.parse();

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,251 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { initDatabase, getDefaultDbPath, insertCheckpoint, getLatestCheckpoint, getCheckpoint, getCheckpointsByDate, insertDailySummary, } from "./store.js";
+import { callClaudeJson } from "./llm.js";
+import { readFileSync, statSync } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+let db;
+let dbPath;
+let lastDbMtime = 0;
+/** Reload the database from disk if the file has been modified externally. */
+async function reloadDbIfChanged() {
+    try {
+        const mtimeMs = statSync(dbPath).mtimeMs;
+        if (mtimeMs > lastDbMtime) {
+            db = await initDatabase(dbPath);
+            lastDbMtime = mtimeMs;
+        }
+    }
+    catch {
+        // File doesn't exist or stat failed — keep current db as-is
+    }
+}
+/** Stable fallback session ID — generated once at module load, not per call. */
+const fallbackSessionId = `session-${Date.now()}`;
+/** Build an MCP error response with a descriptive message. */
+function toolError(message) {
+    return {
+        content: [{ type: "text", text: `Error: ${message}` }],
+        isError: true,
+    };
+}
+/**
+ * Validate that a required string argument is present and is a string.
+ * Returns the validated string, or throws with a descriptive message.
+ */
+function requireString(args, field, toolName) {
+    const value = args?.[field];
+    if (!value || typeof value !== "string") {
+        throw new ValidationError(`${toolName} requires a "${field}" string argument`);
+    }
+    return value;
+}
+/** Sentinel error class for argument validation — caught in the handler to return toolError. */
+class ValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ValidationError";
+    }
+}
+const server = new Server({ name: "claude-baton", version: "1.0.0" }, { capabilities: { tools: {} } });
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [
+        {
+            name: "save_checkpoint",
+            description: "Save session state before context loss",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    what_was_built: { type: "string" },
+                    current_state: { type: "string" },
+                    next_steps: { type: "string" },
+                    decisions: { type: "string" },
+                    blockers: { type: "string" },
+                    branch: {
+                        type: "string",
+                        description: "Current git branch name",
+                    },
+                    uncommitted_files: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "Output of git status --short",
+                    },
+                    git_snapshot: {
+                        type: "string",
+                        description: "Recent commits, e.g. output of git log --oneline -10",
+                    },
+                    plan_reference: {
+                        type: "string",
+                        description: "Reference to active plan document and section, e.g. 'docs/plan.md Phase 2 Step 3'",
+                    },
+                    project: {
+                        type: "string",
+                        description: "Project path (defaults to cwd)",
+                    },
+                },
+                required: ["what_was_built", "current_state", "next_steps"],
+            },
+        },
+        {
+            name: "get_checkpoint",
+            description: "Retrieve a checkpoint by ID, or the latest for the project",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    id: {
+                        type: "string",
+                        description: "Checkpoint ID to fetch; if omitted, returns the latest",
+                    },
+                    project: {
+                        type: "string",
+                        description: "Project path (defaults to cwd)",
+                    },
+                },
+            },
+        },
+        {
+            name: "list_checkpoints",
+            description: "List all checkpoints for a date",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    date: {
+                        type: "string",
+                        description: "YYYY-MM-DD (defaults to today)",
+                    },
+                    project: {
+                        type: "string",
+                        description: "Project path (defaults to cwd)",
+                    },
+                },
+            },
+        },
+        {
+            name: "daily_summary",
+            description: "Generate EOD summary from the day's activity",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    date: {
+                        type: "string",
+                        description: "Date (YYYY-MM-DD, defaults to today)",
+                    },
+                    project: {
+                        type: "string",
+                        description: "Project path (defaults to cwd)",
+                    },
+                },
+            },
+        },
+    ],
+}));
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    const projectPath = args?.project ?? process.cwd();
+    await reloadDbIfChanged();
+    try {
+        switch (name) {
+            case "save_checkpoint": {
+                const a = args;
+                const whatWasBuilt = requireString(a, "what_was_built", "save_checkpoint");
+                const currentState = requireString(a, "current_state", "save_checkpoint");
+                const nextSteps = requireString(a, "next_steps", "save_checkpoint");
+                const sessionId = process.env.CLAUDE_SESSION_ID ?? fallbackSessionId;
+                const id = insertCheckpoint(db, projectPath, sessionId, currentState, whatWasBuilt, nextSteps, {
+                    branch: a?.branch,
+                    decisionsMade: a?.decisions,
+                    blockers: a?.blockers,
+                    uncommittedFiles: a?.uncommitted_files,
+                    gitSnapshot: a?.git_snapshot,
+                    planReference: a?.plan_reference,
+                }, dbPath);
+                return { content: [{ type: "text", text: `Checkpoint saved: ${id}` }] };
+            }
+            case "get_checkpoint": {
+                const cpId = args?.id;
+                const cp = cpId
+                    ? getCheckpoint(db, cpId)
+                    : getLatestCheckpoint(db, projectPath);
+                if (!cp)
+                    return { content: [{ type: "text", text: "No checkpoint found" }] };
+                return {
+                    content: [{ type: "text", text: JSON.stringify(cp, null, 2) }],
+                };
+            }
+            case "list_checkpoints": {
+                const cpDate = args?.date ?? new Date().toISOString().slice(0, 10);
+                const cps = getCheckpointsByDate(db, projectPath, cpDate);
+                const summary = cps.map((cp) => ({
+                    id: cp.id,
+                    created_at: cp.created_at,
+                    what_was_built: cp.what_was_built,
+                    branch: cp.branch,
+                    current_state: cp.current_state,
+                }));
+                return {
+                    content: [{ type: "text", text: JSON.stringify(summary, null, 2) }],
+                };
+            }
+            case "daily_summary": {
+                const date = args?.date ?? new Date().toISOString().slice(0, 10);
+                const checkpoints = getCheckpointsByDate(db, projectPath, date);
+                if (checkpoints.length === 0) {
+                    return {
+                        content: [{ type: "text", text: `No activity found for ${date}` }],
+                    };
+                }
+                const activityParts = [];
+                activityParts.push("CHECKPOINTS:\n" +
+                    checkpoints
+                        .map((cp) => `- [${cp.created_at}] Built: ${cp.what_was_built} | State: ${cp.current_state} | Next: ${cp.next_steps}`)
+                        .join("\n"));
+                const summaryTemplate = readFileSync(path.join(__dirname, "..", "prompts", "daily_summary.txt"), "utf-8");
+                const summaryPrompt = summaryTemplate
+                    .replace("{{DATE}}", date)
+                    .replace("{{ACTIVITY}}", activityParts.join("\n\n"));
+                const summaryResult = await callClaudeJson(summaryPrompt, "haiku", 30000);
+                insertDailySummary(db, projectPath, date, summaryResult, dbPath);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(summaryResult, null, 2),
+                        },
+                    ],
+                };
+            }
+            default:
+                return {
+                    content: [{ type: "text", text: `Unknown tool: ${name}` }],
+                    isError: true,
+                };
+        }
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        console.error(`Tool error (${name}):`, msg);
+        return {
+            content: [{ type: "text", text: `Error: ${msg}` }],
+            isError: true,
+        };
+    }
+});
+async function main() {
+    dbPath = getDefaultDbPath();
+    db = await initDatabase(dbPath);
+    try {
+        lastDbMtime = statSync(dbPath).mtimeMs;
+    }
+    catch {
+        // File may not exist yet if initDatabase created it in-memory only
+    }
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch((error) => {
+    console.error("Server error:", error);
+    process.exit(1);
+});

package/dist/llm.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Strip markdown code fences from LLM output.
+ * LLMs frequently wrap JSON in ```json ... ``` blocks.
+ */
+export declare function stripCodeFences(text: string): string;
+/**
+ * Call claude -p and return the result as a string.
+ * If the raw output is JSON with a `result` field, extracts it.
+ * Always returns a string — non-string result values are JSON.stringified.
+ */
+export declare function callClaude(prompt: string, model?: string, timeout?: number): Promise<string>;
+/**
+ * Call claude -p and parse the response as JSON of type T.
+ * Uses the raw stdout (not the string-extracted callClaude) to avoid double-parse.
+ */
+export declare function callClaudeJson<T>(prompt: string, model?: string, timeout?: number): Promise<T>;