claude-baton 2.0.1

package/dist/llm.js

@@ -0,0 +1,119 @@
+import { spawn } from "child_process";
+import os from "os";
+/**
+ * Strip markdown code fences from LLM output.
+ * LLMs frequently wrap JSON in ```json ... ``` blocks.
+ */
+export function stripCodeFences(text) {
+    const trimmed = text.trim();
+    // Match ```<optional language>\n...\n```
+    const match = trimmed.match(/^```(?:\w*)\s*\n?([\s\S]*?)\n?\s*```$/);
+    if (match) {
+        return match[1].trim();
+    }
+    return trimmed;
+}
+/**
+ * Internal: spawns claude -p and returns the raw stdout string.
+ * Used by both callClaude and callClaudeJson to avoid double-parse issues.
+ */
+function callClaudeRaw(prompt, model = "haiku", timeout = 30000) {
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        // Strip Claude Code env vars so nested claude -p works from hooks
+        const env = { ...process.env };
+        delete env.CLAUDECODE;
+        delete env.CLAUDE_CODE_ENTRYPOINT;
+        const proc = spawn("claude", ["-p", "--model", model, "--output-format", "json"], {
+            stdio: ["pipe", "pipe", "pipe"],
+            env,
+            cwd: os.tmpdir(),
+        });
+        let stdout = "";
+        let stderr = "";
+        proc.stdout.on("data", (data) => {
+            stdout += data.toString();
+        });
+        proc.stderr.on("data", (data) => {
+            stderr += data.toString();
+        });
+        const timer = setTimeout(() => {
+            if (settled)
+                return;
+            settled = true;
+            proc.kill();
+            reject(new Error(`claude -p timed out after ${timeout}ms`));
+        }, timeout);
+        proc.on("close", (code) => {
+            clearTimeout(timer);
+            if (settled)
+                return;
+            settled = true;
+            if (process.env.MEMORIA_DEBUG) {
+                console.error(`[DEBUG] claude -p exit=${code} stdout=${stdout.slice(0, 500)} stderr=${stderr.slice(0, 200)}`);
+            }
+            if (code !== 0) {
+                reject(new Error(`claude -p exited with code ${code}: ${stderr}`));
+                return;
+            }
+            resolve(stdout);
+        });
+        proc.on("error", (err) => {
+            clearTimeout(timer);
+            if (settled)
+                return;
+            settled = true;
+            reject(new Error(`Failed to spawn claude: ${err.message}`));
+        });
+        if (process.env.MEMORIA_DEBUG) {
+            console.error(`[DEBUG] Prompt length: ${prompt.length}, first 300 chars: ${prompt.slice(0, 300)}`);
+        }
+        proc.stdin.write(prompt);
+        proc.stdin.end();
+    });
+}
+/**
+ * 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 async function callClaude(prompt, model = "haiku", timeout = 30000) {
+    const raw = await callClaudeRaw(prompt, model, timeout);
+    const stripped = stripCodeFences(raw);
+    try {
+        const parsed = JSON.parse(stripped);
+        const result = parsed.result ?? stripped;
+        if (typeof result === "string") {
+            return result;
+        }
+        return JSON.stringify(result);
+    }
+    catch {
+        return stripped;
+    }
+}
+/**
+ * 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 async function callClaudeJson(prompt, model = "haiku", timeout = 30000) {
+    const raw = await callClaudeRaw(prompt, model, timeout);
+    const stripped = stripCodeFences(raw);
+    try {
+        const parsed = JSON.parse(stripped);
+        // If the output has a `result` field, use that as the JSON value
+        const value = parsed.result !== undefined ? parsed.result : parsed;
+        // If value is already an object/array, return it directly
+        if (typeof value === "object" && value !== null) {
+            return value;
+        }
+        // If value is a string, try to parse it as JSON
+        if (typeof value === "string") {
+            return JSON.parse(stripCodeFences(value));
+        }
+        return value;
+    }
+    catch {
+        throw new Error(`Failed to parse JSON from claude response: ${stripped.slice(0, 200)}`);
+    }
+}

package/dist/store.d.ts

@@ -0,0 +1,28 @@
+import { type Database } from "sql.js";
+import type { Checkpoint, DailySummary } from "./types.js";
+export declare function initDatabase(dbPath?: string): Promise<Database>;
+export declare function saveDatabase(db: Database, dbPath: string): void;
+export declare function getDefaultDbPath(): string;
+export declare function initSchema(db: Database): void;
+export declare function insertCheckpoint(db: Database, projectPath: string, sessionId: string, currentState: string, whatWasBuilt: string, nextSteps: string, opts?: {
+    branch?: string;
+    decisionsMade?: string;
+    blockers?: string;
+    uncommittedFiles?: string[];
+    gitSnapshot?: string;
+    planReference?: string;
+}, dbPath?: string): string;
+export declare function getCheckpoint(db: Database, id: string): Checkpoint | null;
+export declare function getLatestCheckpoint(db: Database, projectPath: string): Checkpoint | null;
+export declare function getCheckpointsByDate(db: Database, projectPath: string, date: string): Checkpoint[];
+export declare function getAllCheckpoints(db: Database, projectPath?: string): Checkpoint[];
+export declare function insertDailySummary(db: Database, projectPath: string, date: string, summary: Record<string, unknown>, dbPath?: string): string;
+export declare function getDailySummary(db: Database, projectPath: string, date: string): DailySummary | null;
+export declare function getAllDailySummaries(db: Database, projectPath?: string): DailySummary[];
+export declare function countAll(db: Database, projectPath?: string): Record<string, number>;
+export declare function listProjects(db: Database): Array<{
+    project_path: string;
+    checkpoint_count: number;
+}>;
+export declare function deleteProjectData(db: Database, projectPath: string, dbPath?: string): void;
+export declare function deleteAllData(db: Database, dbPath?: string): void;

package/dist/store.js

@@ -0,0 +1,249 @@
+import initSqlJs from "sql.js";
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import path from "path";
+import os from "os";
+import crypto from "crypto";
+// --- Database lifecycle ---
+export async function initDatabase(dbPath) {
+    const SQL = await initSqlJs();
+    let db;
+    if (dbPath && existsSync(dbPath)) {
+        const buffer = readFileSync(dbPath);
+        db = new SQL.Database(buffer);
+    }
+    else {
+        if (dbPath) {
+            mkdirSync(path.dirname(dbPath), { recursive: true });
+        }
+        db = new SQL.Database();
+    }
+    initSchema(db);
+    if (dbPath)
+        saveDatabase(db, dbPath);
+    return db;
+}
+export function saveDatabase(db, dbPath) {
+    const data = db.export();
+    const buffer = Buffer.from(data);
+    writeFileSync(dbPath, buffer);
+}
+export function getDefaultDbPath() {
+    return path.join(os.homedir(), ".claude-baton", "store.db");
+}
+export function initSchema(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS checkpoints (
+      id TEXT PRIMARY KEY,
+      project_path TEXT NOT NULL,
+      session_id TEXT NOT NULL,
+      branch TEXT,
+      current_state TEXT NOT NULL,
+      what_was_built TEXT NOT NULL,
+      next_steps TEXT NOT NULL,
+      decisions_made TEXT,
+      blockers TEXT,
+      uncommitted_files TEXT DEFAULT '[]',
+      git_snapshot TEXT,
+      plan_reference TEXT,
+      created_at TEXT DEFAULT (datetime('now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_checkpoints_project ON checkpoints(project_path);
+
+    CREATE TABLE IF NOT EXISTS daily_summaries (
+      id TEXT PRIMARY KEY,
+      project_path TEXT NOT NULL,
+      date TEXT NOT NULL,
+      summary TEXT NOT NULL,
+      created_at TEXT DEFAULT (datetime('now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_daily_summaries_project ON daily_summaries(project_path);
+    CREATE INDEX IF NOT EXISTS idx_daily_summaries_date ON daily_summaries(date);
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_daily_summaries_project_date ON daily_summaries(project_path, date);
+  `);
+    // Migration: add git_snapshot column for existing databases
+    try {
+        db.exec("ALTER TABLE checkpoints ADD COLUMN git_snapshot TEXT");
+    }
+    catch {
+        // Column already exists — expected for new databases or already-migrated ones
+    }
+    // Migration: add plan_reference column for existing databases
+    try {
+        db.exec("ALTER TABLE checkpoints ADD COLUMN plan_reference TEXT");
+    }
+    catch {
+        // Column already exists
+    }
+}
+// --- Checkpoints CRUD ---
+export function insertCheckpoint(db, projectPath, sessionId, currentState, whatWasBuilt, nextSteps, opts, dbPath) {
+    const id = crypto.randomUUID();
+    db.run(`INSERT INTO checkpoints (id, project_path, session_id, branch, current_state, what_was_built, next_steps, decisions_made, blockers, uncommitted_files, git_snapshot, plan_reference, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+        id,
+        projectPath,
+        sessionId,
+        opts?.branch ?? null,
+        currentState,
+        whatWasBuilt,
+        nextSteps,
+        opts?.decisionsMade ?? null,
+        opts?.blockers ?? null,
+        JSON.stringify(opts?.uncommittedFiles ?? []),
+        opts?.gitSnapshot ?? null,
+        opts?.planReference ?? null,
+        new Date().toISOString(),
+    ]);
+    if (dbPath)
+        saveDatabase(db, dbPath);
+    return id;
+}
+export function getCheckpoint(db, id) {
+    const stmt = db.prepare("SELECT * FROM checkpoints WHERE id = ?");
+    stmt.bind([id]);
+    const row = stmt.step() ? stmt.getAsObject() : null;
+    stmt.free();
+    if (!row)
+        return null;
+    return parseCheckpointRow(row);
+}
+export function getLatestCheckpoint(db, projectPath) {
+    const stmt = db.prepare("SELECT * FROM checkpoints WHERE project_path = ? ORDER BY created_at DESC, rowid DESC LIMIT 1");
+    stmt.bind([projectPath]);
+    const row = stmt.step() ? stmt.getAsObject() : null;
+    stmt.free();
+    if (!row)
+        return null;
+    return parseCheckpointRow(row);
+}
+function parseCheckpointRow(row) {
+    return {
+        ...row,
+        uncommitted_files: JSON.parse(row.uncommitted_files),
+        git_snapshot: row.git_snapshot ?? null,
+        plan_reference: row.plan_reference ?? null,
+    };
+}
+export function getCheckpointsByDate(db, projectPath, date) {
+    const stmt = db.prepare("SELECT * FROM checkpoints WHERE project_path = ? AND created_at LIKE ? || '%' ORDER BY created_at ASC");
+    stmt.bind([projectPath, date]);
+    const results = [];
+    while (stmt.step()) {
+        results.push(parseCheckpointRow(stmt.getAsObject()));
+    }
+    stmt.free();
+    return results;
+}
+export function getAllCheckpoints(db, projectPath) {
+    let sql = "SELECT * FROM checkpoints";
+    const params = [];
+    if (projectPath) {
+        sql += " WHERE project_path = ?";
+        params.push(projectPath);
+    }
+    sql += " ORDER BY created_at DESC";
+    const stmt = db.prepare(sql);
+    stmt.bind(params);
+    const results = [];
+    while (stmt.step()) {
+        results.push(parseCheckpointRow(stmt.getAsObject()));
+    }
+    stmt.free();
+    return results;
+}
+// --- Daily Summaries CRUD ---
+export function insertDailySummary(db, projectPath, date, summary, dbPath) {
+    const existing = getDailySummary(db, projectPath, date);
+    if (existing) {
+        db.run("UPDATE daily_summaries SET summary = ? WHERE id = ?", [
+            JSON.stringify(summary),
+            existing.id,
+        ]);
+        if (dbPath)
+            saveDatabase(db, dbPath);
+        return existing.id;
+    }
+    const id = crypto.randomUUID();
+    db.run(`INSERT INTO daily_summaries (id, project_path, date, summary, created_at)
+     VALUES (?, ?, ?, ?, ?)`, [id, projectPath, date, JSON.stringify(summary), new Date().toISOString()]);
+    if (dbPath)
+        saveDatabase(db, dbPath);
+    return id;
+}
+export function getDailySummary(db, projectPath, date) {
+    const stmt = db.prepare("SELECT * FROM daily_summaries WHERE project_path = ? AND date = ?");
+    stmt.bind([projectPath, date]);
+    const row = stmt.step() ? stmt.getAsObject() : null;
+    stmt.free();
+    if (!row)
+        return null;
+    return parseDailySummaryRow(row);
+}
+function parseDailySummaryRow(row) {
+    return { ...row, summary: JSON.parse(row.summary) };
+}
+export function getAllDailySummaries(db, projectPath) {
+    let sql = "SELECT * FROM daily_summaries";
+    const params = [];
+    if (projectPath) {
+        sql += " WHERE project_path = ?";
+        params.push(projectPath);
+    }
+    sql += " ORDER BY date DESC";
+    const stmt = db.prepare(sql);
+    stmt.bind(params);
+    const results = [];
+    while (stmt.step()) {
+        results.push(parseDailySummaryRow(stmt.getAsObject()));
+    }
+    stmt.free();
+    return results;
+}
+// --- Aggregate queries ---
+function countTable(db, sql, params) {
+    const stmt = db.prepare(sql);
+    stmt.bind(params);
+    stmt.step();
+    const count = stmt.getAsObject().count ?? 0;
+    stmt.free();
+    return count;
+}
+export function countAll(db, projectPath) {
+    if (projectPath) {
+        const p = [projectPath];
+        return {
+            checkpoints: countTable(db, "SELECT COUNT(*) as count FROM checkpoints WHERE project_path = ?", p),
+            daily_summaries: countTable(db, "SELECT COUNT(*) as count FROM daily_summaries WHERE project_path = ?", p),
+        };
+    }
+    return {
+        checkpoints: countTable(db, "SELECT COUNT(*) as count FROM checkpoints", []),
+        daily_summaries: countTable(db, "SELECT COUNT(*) as count FROM daily_summaries", []),
+    };
+}
+export function listProjects(db) {
+    const stmt = db.prepare("SELECT project_path, COUNT(*) as count FROM checkpoints GROUP BY project_path ORDER BY count DESC");
+    const results = [];
+    while (stmt.step()) {
+        const row = stmt.getAsObject();
+        results.push({
+            project_path: row.project_path,
+            checkpoint_count: row.count,
+        });
+    }
+    stmt.free();
+    return results;
+}
+// --- Delete operations ---
+export function deleteProjectData(db, projectPath, dbPath) {
+    db.run("DELETE FROM checkpoints WHERE project_path = ?", [projectPath]);
+    db.run("DELETE FROM daily_summaries WHERE project_path = ?", [projectPath]);
+    if (dbPath)
+        saveDatabase(db, dbPath);
+}
+export function deleteAllData(db, dbPath) {
+    db.run("DELETE FROM checkpoints");
+    db.run("DELETE FROM daily_summaries");
+    if (dbPath)
+        saveDatabase(db, dbPath);
+}

package/dist/types.d.ts

@@ -0,0 +1,24 @@
+/** A snapshot of session state saved before /compact or /clear. */
+export interface Checkpoint {
+    id: string;
+    project_path: string;
+    session_id: string;
+    branch: string | null;
+    current_state: string;
+    what_was_built: string;
+    next_steps: string;
+    decisions_made: string | null;
+    blockers: string | null;
+    uncommitted_files: string[];
+    git_snapshot: string | null;
+    plan_reference: string | null;
+    created_at: string;
+}
+/** An aggregated end-of-day summary of project activity. */
+export interface DailySummary {
+    id: string;
+    project_path: string;
+    date: string;
+    summary: Record<string, unknown>;
+    created_at: string;
+}

package/dist/types.js

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

package/dist/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function getProjectPath(): string;
+export declare function ensureDir(dirPath: string): void;

package/dist/utils.js

@@ -0,0 +1,10 @@
+import { mkdirSync, existsSync } from "fs";
+// --- Path helpers ---
+export function getProjectPath() {
+    return process.cwd();
+}
+export function ensureDir(dirPath) {
+    if (!existsSync(dirPath)) {
+        mkdirSync(dirPath, { recursive: true });
+    }
+}

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "claude-baton",
+  "version": "2.0.1",
+  "description": "Session lifecycle management for Claude Code",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "claude-baton": "bin/claude-baton.js"
+  },
+  "files": [
+    "dist",
+    "bin",
+    "prompts",
+    "commands",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "mcp",
+    "claude",
+    "claude-code",
+    "session",
+    "checkpoint",
+    "resume",
+    "lifecycle"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "prepare": "tsc",
+    "build": "tsc",
+    "test": "vitest run",
+    "dev": "node dist/index.js",
+    "lint": "tsc --noEmit",
+    "format:check": "npx prettier --check 'src/**/*.ts' 'tests/**/*.ts'",
+    "format": "npx prettier --write 'src/**/*.ts' 'tests/**/*.ts'"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.1",
+    "commander": "^13.1.0",
+    "sql.js": "^1.12.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.3",
+    "typescript": "^5.8.3",
+    "vitest": "^3.1.2"
+  },
+  "license": "MIT",
+  "author": "bakabaka91",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bakabaka91/claude-baton.git"
+  },
+  "homepage": "https://github.com/bakabaka91/claude-baton#readme",
+  "bugs": {
+    "url": "https://github.com/bakabaka91/claude-baton/issues"
+  }
+}

package/prompts/auto_checkpoint.txt

@@ -0,0 +1,30 @@
+You are extracting a session checkpoint from a Claude Code conversation transcript.
+
+Analyze the transcript and produce a JSON object with these fields:
+
+- what_was_built: What was accomplished in this session (1-3 sentences)
+- current_state: Current state of the project — what's passing, what's broken, what's uncommitted (1-2 sentences)
+- next_steps: What should be done next (1-2 sentences, actionable)
+- decisions_made: Key decisions made during this session, if any (1-2 sentences, or "None")
+- blockers: Anything blocking progress, if any (1 sentence, or "None")
+- plan_reference: If the session references an active plan document (e.g. PLAN.md, docs/plan.md, a spec file), include the file path and the specific section being worked on (e.g. "docs/v2-plan.md Phase 2 Step 3"). Null if no plan document is referenced.
+
+Rules:
+- Be concise — each field should be 1-3 sentences max
+- Focus on what changed, not what was discussed
+- next_steps should be specific enough to resume work
+- For plan_reference, look for file reads/references to plan docs, spec files, or roadmap documents in the transcript
+- Output ONLY valid JSON, no markdown, no explanation
+
+Example output:
+{
+  "what_was_built": "Added user authentication with JWT tokens and password hashing.",
+  "current_state": "Build passing, 45 tests passing. Auth routes implemented but not yet integrated with frontend.",
+  "next_steps": "Wire up login form to POST /auth/login endpoint. Add token refresh middleware.",
+  "decisions_made": "Using bcrypt over argon2 for password hashing due to simpler deployment. Storing refresh tokens in httpOnly cookies.",
+  "blockers": "None",
+  "plan_reference": "docs/auth-plan.md Phase 2 Step 1"
+}
+
+Transcript:
+{TRANSCRIPT}

package/prompts/daily_summary.txt

@@ -0,0 +1,29 @@
+You are a daily summary agent. Given a day's activity data, produce a structured end-of-day summary.
+
+Date: {{DATE}}
+
+Activity data:
+{{ACTIVITY}}
+
+Instructions:
+- Summarize what was accomplished during the day based on the activity data
+- Identify key decisions that were made and their rationale
+- Note any blockers or unresolved issues that need attention
+- Suggest concrete next steps based on the day's progress
+- Write a single quotable highlight line that captures the day's essence
+- Be concise — each field should capture signal, not noise
+- Do not fabricate information not present in the activity data
+- If the activity data is sparse, reflect that honestly rather than padding
+
+Respond with ONLY a valid JSON object matching this shape:
+
+{"what_was_built": "...", "decisions_made": ["..."], "blockers": ["..."], "next_steps": ["..."], "highlights": "..."}
+
+Field rules:
+- what_was_built: 1-3 sentence summary of concrete accomplishments
+- decisions_made: array of short strings, each describing one decision and why
+- blockers: array of unresolved issues; use [] if none
+- next_steps: array of actionable items for the next session
+- highlights: one-line summary suitable for a changelog or standup
+
+Respond with ONLY valid JSON. Do not wrap in code fences. Do not include any text before or after the JSON object. Your entire response must be parseable by JSON.parse().