@a5c-ai/babysitter-sdk 0.0.169 → 0.0.170-staging.00aac85c

package/dist/cli/commands/hookRun.js

@@ -0,0 +1,544 @@
+"use strict";
+/**
+ * hook:run CLI command.
+ *
+ * Replaces heavy bash hook scripts with a single TypeScript command.
+ * Dispatches to the appropriate handler based on --hook-type:
+ *   - "stop"          → handleHookRunStop (replaces babysitter-stop-hook.sh)
+ *   - "session-start" → handleHookRunSessionStart (replaces babysitter-session-start-hook.sh)
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleHookRun = handleHookRun;
+const path = __importStar(require("node:path"));
+const node_fs_1 = require("node:fs");
+const journal_1 = require("../../storage/journal");
+const runFiles_1 = require("../../storage/runFiles");
+const effectIndex_1 = require("../../runtime/replay/effectIndex");
+const completionProof_1 = require("../completionProof");
+const skill_1 = require("./skill");
+const session_1 = require("../../session");
+const session_2 = require("./session");
+function createHookLogger(hookName) {
+    const logDir = process.env.BABYSITTER_LOG_DIR;
+    const logFile = logDir ? path.join(logDir, `${hookName}.log`) : null;
+    const context = {};
+    if (logFile) {
+        try {
+            (0, node_fs_1.mkdirSync)(logDir, { recursive: true });
+        }
+        catch {
+            // Best-effort
+        }
+    }
+    function write(level, message) {
+        if (!logFile)
+            return;
+        const ts = new Date().toISOString();
+        const ctxParts = Object.entries(context).map(([k, v]) => `${k}=${v}`);
+        const ctxStr = ctxParts.length > 0 ? ` [${ctxParts.join(" ")}]` : "";
+        const line = `[${level}] ${ts}${ctxStr} ${message}\n`;
+        try {
+            (0, node_fs_1.appendFileSync)(logFile, line);
+        }
+        catch {
+            // Best-effort
+        }
+    }
+    return {
+        info: (msg) => write("INFO", msg),
+        warn: (msg) => write("WARN", msg),
+        error: (msg) => write("ERROR", msg),
+        setContext: (key, value) => {
+            context[key] = value;
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// Stdin reader
+// ---------------------------------------------------------------------------
+async function readStdin() {
+    return new Promise((resolve, reject) => {
+        let data = "";
+        process.stdin.setEncoding("utf8");
+        process.stdin.on("data", (chunk) => {
+            data += chunk;
+        });
+        process.stdin.on("end", () => resolve(data));
+        process.stdin.on("error", reject);
+    });
+}
+function parseHookInput(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return {};
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        // Malformed JSON — treat as empty
+    }
+    return {};
+}
+function safeStr(obj, key) {
+    const val = obj[key];
+    return typeof val === "string" ? val : "";
+}
+// ---------------------------------------------------------------------------
+// Pending-by-kind helper (mirrors session.ts countPendingByKind)
+// ---------------------------------------------------------------------------
+function countPendingByKind(records) {
+    const counts = new Map();
+    for (const record of records) {
+        const key = record.kind ?? "unknown";
+        counts.set(key, (counts.get(key) ?? 0) + 1);
+    }
+    return Object.fromEntries(Array.from(counts.entries()).sort(([a], [b]) => a.localeCompare(b)));
+}
+// ---------------------------------------------------------------------------
+// handleHookRunStop — Claude Code "SessionEnd" hook handler
+//
+// Claude Code-specific: reads {session_id, transcript_path} from stdin,
+// outputs {decision: "approve"|"block", reason?, systemMessage?, instructions?}
+// ---------------------------------------------------------------------------
+async function handleHookRunStop(args) {
+    const { verbose } = args;
+    const log = createHookLogger("babysitter-stop-hook");
+    log.info("handleHookRunStop started");
+    // 1. Read hook input JSON from stdin
+    let rawInput;
+    try {
+        rawInput = await readStdin();
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        log.warn(`stdin read error: ${msg}`);
+        if (verbose) {
+            process.stderr.write(`[hook:run stop] stdin read error: ${msg}\n`);
+        }
+        // Allow exit on error
+        process.stdout.write('{"decision":"approve"}\n');
+        return 0;
+    }
+    const hookInput = parseHookInput(rawInput);
+    log.info("Hook input received");
+    const sessionId = safeStr(hookInput, "session_id");
+    if (!sessionId) {
+        // No session ID — allow exit
+        log.info("No session ID in hook input — allowing exit");
+        if (verbose) {
+            process.stderr.write("[hook:run stop] No session ID in hook input\n");
+        }
+        process.stdout.write('{"decision":"approve"}\n');
+        return 0;
+    }
+    log.setContext("session", sessionId);
+    log.info(`Session ID: ${sessionId}`);
+    // 2. Resolve pluginRoot and stateDir
+    const pluginRoot = args.pluginRoot || process.env.CLAUDE_PLUGIN_ROOT || "";
+    const stateDir = args.stateDir ||
+        (pluginRoot ? path.join(pluginRoot, "skills", "babysit", "state") : "");
+    if (!stateDir) {
+        log.warn("Cannot determine state directory — allowing exit");
+        if (verbose) {
+            process.stderr.write("[hook:run stop] Cannot determine state directory\n");
+        }
+        process.stdout.write('{"decision":"approve"}\n');
+        return 0;
+    }
+    const runsDir = args.runsDir || ".a5c/runs";
+    // 3. Check iteration (replaces session:check-iteration CLI call)
+    const filePath = (0, session_1.getSessionFilePath)(stateDir, sessionId);
+    log.info(`Checking session at: ${filePath}`);
+    let sessionFile;
+    try {
+        if (!(await (0, session_1.sessionFileExists)(filePath))) {
+            // No active loop
+            log.info("No active loop found — allowing exit");
+            if (verbose) {
+                process.stderr.write(`[hook:run stop] No active loop found for session ${sessionId}\n`);
+            }
+            process.stdout.write('{"decision":"approve"}\n');
+            return 0;
+        }
+        sessionFile = await (0, session_1.readSessionFile)(filePath);
+    }
+    catch {
+        // Cannot read session — allow exit
+        log.warn("Session file read error — allowing exit");
+        process.stdout.write('{"decision":"approve"}\n');
+        return 0;
+    }
+    const { state } = sessionFile;
+    const prompt = sessionFile.prompt ?? "";
+    // Check max iterations
+    if (state.maxIterations > 0 && state.iteration >= state.maxIterations) {
+        if (verbose) {
+            process.stderr.write(`[hook:run stop] Max iterations (${state.maxIterations}) reached\n`);
+        }
+        await cleanupSession(filePath);
+        process.stdout.write('{"decision":"approve"}\n');
+        return 0;
+    }
+    // Check iteration timing (runaway loop detection)
+    const now = (0, session_1.getCurrentTimestamp)();
+    const updatedTimes = state.iteration >= 5
+        ? (0, session_1.updateIterationTimes)(state.iterationTimes, state.lastIterationAt, now)
+        : state.iterationTimes;
+    if ((0, session_1.isIterationTooFast)(updatedTimes)) {
+        if (verbose) {
+            const avg = updatedTimes.reduce((a, b) => a + b, 0) / updatedTimes.length;
+            process.stderr.write(`[hook:run stop] Iteration too fast (avg ${avg}s)\n`);
+        }
+        await cleanupSession(filePath);
+        process.stdout.write('{"decision":"approve"}\n');
+        return 0;
+    }
+    // shouldContinue=true at this point
+    const iteration = state.iteration;
+    const maxIterations = state.maxIterations;
+    const runId = state.runId ?? "";
+    if (runId) {
+        log.setContext("run", runId);
+    }
+    // 4. Parse transcript for last assistant message
+    const transcriptPath = safeStr(hookInput, "transcript_path");
+    let lastText = null;
+    let hasPromise = false;
+    let promiseValue = null;
+    if (transcriptPath) {
+        const resolvedTranscript = path.resolve(transcriptPath);
+        if ((0, node_fs_1.existsSync)(resolvedTranscript)) {
+            try {
+                const content = (0, node_fs_1.readFileSync)(resolvedTranscript, "utf-8");
+                const parsed = (0, session_2.parseTranscriptLastAssistantMessage)(content);
+                lastText = parsed.text;
+                if (parsed.found && parsed.text) {
+                    promiseValue = (0, session_2.extractPromiseTag)(parsed.text);
+                    hasPromise = promiseValue !== null;
+                }
+            }
+            catch {
+                // Transcript parse error — cleanup and allow exit
+                if (verbose) {
+                    process.stderr.write(`[hook:run stop] Transcript parse error: ${resolvedTranscript}\n`);
+                }
+                await cleanupSession(filePath);
+                process.stdout.write('{"decision":"approve"}\n');
+                return 0;
+            }
+        }
+        else {
+            if (verbose) {
+                process.stderr.write(`[hook:run stop] Transcript not found: ${resolvedTranscript}\n`);
+            }
+            await cleanupSession(filePath);
+            process.stdout.write('{"decision":"approve"}\n');
+            return 0;
+        }
+    }
+    if (!lastText) {
+        if (verbose) {
+            process.stderr.write("[hook:run stop] No assistant text content found in transcript\n");
+        }
+        await cleanupSession(filePath);
+        process.stdout.write('{"decision":"approve"}\n');
+        return 0;
+    }
+    // 4b. If no run is associated, there's nothing to iterate on — allow exit
+    if (!runId) {
+        log.info("No run associated with session — allowing exit");
+        if (verbose) {
+            process.stderr.write(`[hook:run stop] No run associated with session ${sessionId} — allowing exit\n`);
+        }
+        await cleanupSession(filePath);
+        process.stdout.write('{"decision":"approve"}\n');
+        return 0;
+    }
+    // 5. If runId is present, get run status
+    let runState = "";
+    let completionProof = "";
+    let pendingKinds = "";
+    if (runId) {
+        try {
+            const runDir = path.isAbsolute(runId)
+                ? runId
+                : path.join(runsDir, runId);
+            const metadata = await (0, runFiles_1.readRunMetadata)(runDir);
+            const journal = await (0, journal_1.loadJournal)(runDir);
+            const index = await (0, effectIndex_1.buildEffectIndex)({ runDir, events: journal });
+            const hasCompleted = journal.some((e) => e.type === "RUN_COMPLETED");
+            const hasFailed = journal.some((e) => e.type === "RUN_FAILED");
+            const pendingRecords = index.listPendingEffects();
+            const pendingByKind = countPendingByKind(pendingRecords);
+            const kindKeys = Object.keys(pendingByKind);
+            if (kindKeys.length > 0) {
+                pendingKinds = kindKeys.join(", ");
+            }
+            if (hasCompleted) {
+                runState = "completed";
+                completionProof = (0, completionProof_1.resolveCompletionProof)(metadata);
+            }
+            else if (hasFailed) {
+                runState = "failed";
+            }
+            else if (pendingRecords.length > 0) {
+                runState = "waiting";
+            }
+            else {
+                runState = "created";
+            }
+        }
+        catch {
+            runState = "";
+        }
+        log.info(`Run state: ${runState || "unknown"}`);
+        if (completionProof) {
+            log.info("Completion proof available");
+        }
+        // If state is empty (couldn't determine) → cleanup and allow
+        if (!runState) {
+            if (verbose) {
+                process.stderr.write(`[hook:run stop] Run state is empty for ${runId}; run may be misconfigured\n`);
+            }
+            await cleanupSession(filePath);
+            process.stdout.write('{"decision":"approve"}\n');
+            return 0;
+        }
+    }
+    // 6. If completionProof matches promiseValue → complete
+    if (hasPromise) {
+        log.info("Detected valid promise tag");
+    }
+    if (completionProof && hasPromise && promiseValue === completionProof) {
+        log.info("Promise matches completion proof — allowing exit");
+        if (verbose) {
+            process.stderr.write(`[hook:run stop] Valid promise tag detected - run complete\n`);
+        }
+        await cleanupSession(filePath);
+        process.stdout.write('{"decision":"approve"}\n');
+        return 0;
+    }
+    // 7. Not complete → continue loop
+    if (!prompt) {
+        if (verbose) {
+            process.stderr.write(`[hook:run stop] State file corrupted - no prompt text\n`);
+        }
+        await cleanupSession(filePath);
+        process.stdout.write('{"decision":"approve"}\n');
+        return 0;
+    }
+    const nextIteration = iteration + 1;
+    const currentTime = (0, session_1.getCurrentTimestamp)();
+    // Update session state
+    const updatedState = {
+        ...state,
+        iteration: nextIteration,
+        lastIterationAt: currentTime,
+        iterationTimes: updatedTimes,
+    };
+    try {
+        await (0, session_1.writeSessionFile)(filePath, updatedState, prompt);
+    }
+    catch {
+        if (verbose) {
+            process.stderr.write(`[hook:run stop] Failed to update session state\n`);
+        }
+        // Continue anyway — state might be stale but loop should work
+    }
+    // 8. Build system message
+    let systemMessage;
+    if (completionProof) {
+        systemMessage = `\u{1F504} Babysitter iteration ${nextIteration} | Run completed! To finish: agent must call 'run:status --json' on your run, extract 'completionProof' from the output, then output it in <promise>SECRET</promise> tags. Do not mention or reveal the secret otherwise.`;
+    }
+    else if (runState === "waiting" && pendingKinds) {
+        systemMessage = `\u{1F504} Babysitter iteration ${nextIteration} | Waiting on: ${pendingKinds}. Check if pending effects are resolved, then call run:iterate.`;
+    }
+    else if (runState === "failed") {
+        systemMessage = `\u{1F504} Babysitter iteration ${nextIteration} | Failed. agent must fix the run, journal or process (inspect the sdk.md if needed) and proceed.`;
+    }
+    else {
+        systemMessage = `\u{1F504} Babysitter iteration ${nextIteration} | Agent should continue orchestration (run:iterate)`;
+    }
+    // 9. Try to resolve skill context
+    if (pluginRoot) {
+        try {
+            const discoverResult = await (0, skill_1.discoverSkillsInternal)({
+                pluginRoot,
+                runId: runId || undefined,
+                runsDir,
+            });
+            if (discoverResult.summary) {
+                systemMessage = `${systemMessage} | Available skills for this task: ${discoverResult.summary}. Use the Skill tool or skill-discovery to load any of these.`;
+            }
+        }
+        catch {
+            // Skill discovery failure is non-fatal
+        }
+    }
+    // Cap system message at 1200 chars
+    if (systemMessage.length > 1200) {
+        systemMessage = systemMessage.slice(0, 1197) + "...";
+    }
+    // 10. Output block decision
+    const output = {
+        decision: "block",
+        instructions: "use the babysitter skill to advance the orchestration to the next state (run:iterate) or perform the pending effects (task:list --pending --json), or fix the run if it failed.",
+        reason: prompt,
+        systemMessage,
+    };
+    process.stdout.write(JSON.stringify(output) + "\n");
+    log.info(`Decision: block (iteration=${nextIteration}, maxIterations=${maxIterations})`);
+    if (verbose) {
+        process.stderr.write(`[hook:run stop] Blocking stop, iteration=${nextIteration} maxIterations=${maxIterations}\n`);
+    }
+    return 0;
+}
+// ---------------------------------------------------------------------------
+// handleHookRunSessionStart — Claude Code "SessionStart" hook handler
+//
+// Claude Code-specific: reads {session_id} from stdin,
+// writes session ID to CLAUDE_ENV_FILE if set, outputs {}
+// ---------------------------------------------------------------------------
+async function handleHookRunSessionStart(args) {
+    const { verbose } = args;
+    // 1. Read hook input JSON from stdin
+    let rawInput;
+    try {
+        rawInput = await readStdin();
+    }
+    catch {
+        process.stdout.write("{}\n");
+        return 0;
+    }
+    finally {
+        // Unref stdin so it doesn't keep the event loop alive.
+        // The session-start handler is short-lived and doesn't need stdin after this.
+        // (The stop handler is unaffected — its shell script pipes from a temp file
+        // which reaches EOF naturally, so the event loop drains without unref.)
+        process.stdin.unref();
+    }
+    const hookInput = parseHookInput(rawInput);
+    const sessionId = safeStr(hookInput, "session_id");
+    if (!sessionId) {
+        process.stdout.write("{}\n");
+        return 0;
+    }
+    // 2. If CLAUDE_ENV_FILE is set, append session ID export
+    const envFile = process.env.CLAUDE_ENV_FILE;
+    if (envFile) {
+        try {
+            (0, node_fs_1.appendFileSync)(envFile, `export CLAUDE_SESSION_ID="${sessionId}"\n`);
+        }
+        catch {
+            // Non-fatal — env file write failure
+            if (verbose) {
+                process.stderr.write(`[hook:run session-start] Failed to write to CLAUDE_ENV_FILE: ${envFile}\n`);
+            }
+        }
+    }
+    if (verbose) {
+        process.stderr.write(`Babysitter session started: ${sessionId}\n`);
+    }
+    // 3. Output empty object
+    process.stdout.write("{}\n");
+    return 0;
+}
+// ---------------------------------------------------------------------------
+// Cleanup helper
+// ---------------------------------------------------------------------------
+async function cleanupSession(filePath) {
+    try {
+        await (0, session_1.deleteSessionFile)(filePath);
+    }
+    catch {
+        // Best-effort cleanup
+    }
+}
+// ---------------------------------------------------------------------------
+// Main dispatcher
+// ---------------------------------------------------------------------------
+const SUPPORTED_HARNESSES = ["claude-code"];
+async function handleHookRun(args) {
+    const { hookType, harness, json } = args;
+    if (!hookType) {
+        const error = {
+            error: "MISSING_HOOK_TYPE",
+            message: "--hook-type is required for hook:run",
+        };
+        if (json) {
+            process.stderr.write(JSON.stringify(error) + "\n");
+        }
+        else {
+            process.stderr.write("Error: --hook-type is required for hook:run\n");
+        }
+        return 1;
+    }
+    if (!SUPPORTED_HARNESSES.includes(harness)) {
+        const error = {
+            error: "UNSUPPORTED_HARNESS",
+            message: `Unsupported harness: "${harness}". Supported: ${SUPPORTED_HARNESSES.join(", ")}`,
+        };
+        if (json) {
+            process.stderr.write(JSON.stringify(error) + "\n");
+        }
+        else {
+            process.stderr.write(`Error: ${error.message}\n`);
+        }
+        return 1;
+    }
+    switch (hookType) {
+        case "stop":
+            return await handleHookRunStop(args);
+        case "session-start":
+            return await handleHookRunSessionStart(args);
+        default: {
+            const error = {
+                error: "UNKNOWN_HOOK_TYPE",
+                message: `Unknown hook type: ${hookType}. Supported: stop, session-start`,
+            };
+            if (json) {
+                process.stderr.write(JSON.stringify(error) + "\n");
+            }
+            else {
+                process.stderr.write(`Error: Unknown hook type: ${hookType}. Supported: stop, session-start\n`);
+            }
+            return 1;
+        }
+    }
+}

package/dist/cli/commands/runExecuteTasks.d.ts

@@ -0,0 +1,42 @@
+/**
+ * run:execute-tasks command - Execute pending node tasks in a run
+ *
+ * This command replaces the shell-based task execution logic in native-orchestrator.sh.
+ * It:
+ * 1. Loads the journal and builds the effect index
+ * 2. Filters pending effects by kind (default "node")
+ * 3. Slices to maxTasks (default 3)
+ * 4. For each task: reads task.json, spawns `node`, captures stdout/stderr, commits result
+ * 5. Returns a summary of executed tasks
+ */
+export interface RunExecuteTasksOptions {
+    runDir: string;
+    maxTasks?: number;
+    kind?: string;
+    timeout?: number;
+    verbose?: boolean;
+    json?: boolean;
+    dryRun?: boolean;
+}
+export interface TaskExecutionSummary {
+    effectId: string;
+    label: string | null;
+    status: "ok" | "error";
+    exitCode: number;
+    durationMs: number;
+    stdoutRef: string | null;
+    stderrRef: string | null;
+    resultRef: string | null;
+    error?: {
+        name: string;
+        message: string;
+    };
+}
+export interface RunExecuteTasksResult {
+    action: string;
+    count: number;
+    reason: string;
+    tasks: TaskExecutionSummary[];
+}
+export declare function runExecuteTasks(options: RunExecuteTasksOptions): Promise<RunExecuteTasksResult>;
+//# sourceMappingURL=runExecuteTasks.d.ts.map

package/dist/cli/commands/runExecuteTasks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runExecuteTasks.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/runExecuteTasks.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAWH,MAAM,WAAW,sBAAsB;IACrC,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,MAAM,EAAE,IAAI,GAAG,OAAO,CAAC;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,KAAK,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;CAC3C;AAED,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,oBAAoB,EAAE,CAAC;CAC/B;AA4TD,wBAAsB,eAAe,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,qBAAqB,CAAC,CA+ErG"}