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

package/dist/cli/commands/hookLog.js

@@ -0,0 +1,286 @@
+"use strict";
+/**
+ * hook:log CLI command.
+ *
+ * Reads a hook payload from stdin, extracts the relevant fields for the
+ * given hook type, formats a structured log line, and appends it to the
+ * specified log file.  This consolidates the field-extraction logic that
+ * was previously duplicated across 13 logger.sh shell scripts.
+ */
+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.handleHookLog = handleHookLog;
+const node_fs_1 = require("node:fs");
+const path = __importStar(require("node:path"));
+// ---------------------------------------------------------------------------
+// Event label mapping (matches the label used in the original logger.sh)
+// ---------------------------------------------------------------------------
+const HOOK_EVENT_LABELS = {
+    "on-run-start": "RUN_START",
+    "on-run-complete": "RUN_COMPLETE",
+    "on-run-fail": "RUN_FAIL",
+    "on-task-start": "TASK_START",
+    "on-task-complete": "TASK_COMPLETE",
+    "on-step-dispatch": "STEP_DISPATCH",
+    "on-iteration-start": "ITERATION_START",
+    "on-iteration-end": "ITERATION_END",
+    "on-breakpoint": "BREAKPOINT",
+    "pre-commit": "PRE_COMMIT",
+    "pre-branch": "PRE_BRANCH",
+    "post-planning": "POST_PLANNING",
+    "on-score": "SCORE",
+};
+const KNOWN_HOOK_TYPES = new Set(Object.keys(HOOK_EVENT_LABELS));
+// ---------------------------------------------------------------------------
+// Payload helpers
+// ---------------------------------------------------------------------------
+/** Safely read a string field from a parsed JSON object. */
+function str(payload, key, fallback = "unknown") {
+    const value = payload[key];
+    if (typeof value === "string")
+        return value;
+    if (typeof value === "number" || typeof value === "boolean")
+        return String(value);
+    return fallback;
+}
+/** Safely read a nested string field (e.g. ".context.runId"). */
+function nestedStr(payload, outerKey, innerKey, fallback = "unknown") {
+    const outer = payload[outerKey];
+    if (outer && typeof outer === "object" && !Array.isArray(outer)) {
+        const inner = outer[innerKey];
+        if (typeof inner === "string")
+            return inner;
+    }
+    return fallback;
+}
+/** Safely read the length of an array field. */
+function arrayLength(payload, key) {
+    const value = payload[key];
+    if (Array.isArray(value))
+        return String(value.length);
+    return "unknown";
+}
+const FIELD_EXTRACTORS = {
+    "on-run-start": (p) => [
+        ["runId", str(p, "runId")],
+        ["processId", str(p, "processId")],
+        ["entry", str(p, "entry")],
+    ],
+    "on-run-complete": (p) => [
+        ["runId", str(p, "runId")],
+        ["status", str(p, "status")],
+        ["duration", str(p, "duration")],
+    ],
+    "on-run-fail": (p) => [
+        ["runId", str(p, "runId")],
+        ["error", str(p, "error")],
+        ["duration", str(p, "duration")],
+    ],
+    "on-task-start": (p) => [
+        ["runId", str(p, "runId")],
+        ["effectId", str(p, "effectId")],
+        ["taskId", str(p, "taskId")],
+        ["kind", str(p, "kind")],
+    ],
+    "on-task-complete": (p) => [
+        ["runId", str(p, "runId")],
+        ["effectId", str(p, "effectId")],
+        ["taskId", str(p, "taskId")],
+        ["status", str(p, "status")],
+        ["duration", str(p, "duration")],
+    ],
+    "on-step-dispatch": (p) => [
+        ["runId", str(p, "runId")],
+        ["stepId", str(p, "stepId")],
+        ["action", str(p, "action")],
+    ],
+    "on-iteration-start": (p) => [
+        ["runId", str(p, "runId")],
+        ["iteration", str(p, "iteration")],
+    ],
+    "on-iteration-end": (p) => [
+        ["runId", str(p, "runId")],
+        ["iteration", str(p, "iteration")],
+        ["status", str(p, "status")],
+    ],
+    "on-breakpoint": (p) => [
+        // The original logger.sh uses: .runId // .context.runId // "unknown"
+        ["runId", typeof p.runId === "string" ? p.runId : nestedStr(p, "context", "runId")],
+        ["question", str(p, "question", "N/A")],
+        ["reason", str(p, "reason", "N/A")],
+    ],
+    "pre-commit": (p) => [
+        ["runId", str(p, "runId")],
+        ["files", arrayLength(p, "files")],
+        ["message", str(p, "message")],
+    ],
+    "pre-branch": (p) => [
+        ["runId", str(p, "runId")],
+        ["branch", str(p, "branch")],
+        ["base", str(p, "base")],
+    ],
+    "post-planning": (p) => [
+        ["runId", str(p, "runId")],
+        ["planFile", str(p, "planFile")],
+    ],
+    "on-score": (p) => [
+        ["runId", str(p, "runId")],
+        ["target", str(p, "target")],
+        ["score", str(p, "score")],
+    ],
+};
+// ---------------------------------------------------------------------------
+// Log line formatting
+// ---------------------------------------------------------------------------
+function formatLogLine(hookType, eventLabel, fields) {
+    const timestamp = new Date().toISOString();
+    const kvPairs = fields.map(([k, v]) => `${k}=${v}`).join(" ");
+    return `[${timestamp}] [${eventLabel}] hook=${hookType} ${kvPairs}`;
+}
+// ---------------------------------------------------------------------------
+// Stdin reader (reusable)
+// ---------------------------------------------------------------------------
+function readStdinUtf8() {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        process.stdin.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
+        process.stdin.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+        process.stdin.on("error", reject);
+    });
+}
+// ---------------------------------------------------------------------------
+// Main handler
+// ---------------------------------------------------------------------------
+async function handleHookLog(args) {
+    const { hookType, logFile, json } = args;
+    // Validate --hook-type
+    if (!hookType) {
+        const error = { error: "MISSING_HOOK_TYPE", message: "--hook-type is required" };
+        if (json) {
+            console.error(JSON.stringify(error));
+        }
+        else {
+            console.error("Error: --hook-type is required for hook:log");
+        }
+        return 1;
+    }
+    // Validate --log-file
+    if (!logFile) {
+        const error = { error: "MISSING_LOG_FILE", message: "--log-file is required" };
+        if (json) {
+            console.error(JSON.stringify(error));
+        }
+        else {
+            console.error("Error: --log-file is required for hook:log");
+        }
+        return 1;
+    }
+    // Read payload from stdin
+    let rawPayload;
+    try {
+        rawPayload = await readStdinUtf8();
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        const error = { error: "STDIN_READ_ERROR", message: msg };
+        if (json) {
+            console.error(JSON.stringify(error));
+        }
+        else {
+            console.error(`Error: Failed to read stdin: ${msg}`);
+        }
+        return 1;
+    }
+    // Parse JSON payload
+    let payload;
+    try {
+        const parsed = JSON.parse(rawPayload.trim() || "{}");
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            throw new Error("Payload must be a JSON object");
+        }
+        payload = parsed;
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        const error = { error: "INVALID_PAYLOAD", message: msg };
+        if (json) {
+            console.error(JSON.stringify(error));
+        }
+        else {
+            console.error(`Error: Failed to parse JSON payload: ${msg}`);
+        }
+        return 1;
+    }
+    // Determine event label and field extractor
+    const isKnown = KNOWN_HOOK_TYPES.has(hookType);
+    const eventLabel = isKnown
+        ? HOOK_EVENT_LABELS[hookType]
+        : hookType.toUpperCase().replace(/-/g, "_");
+    const fields = isKnown
+        ? FIELD_EXTRACTORS[hookType](payload)
+        : [["runId", str(payload, "runId")]];
+    // Format log line
+    const logLine = formatLogLine(hookType, eventLabel, fields);
+    // Ensure log directory exists and append
+    try {
+        const logDir = path.dirname(path.resolve(logFile));
+        await node_fs_1.promises.mkdir(logDir, { recursive: true });
+        await node_fs_1.promises.appendFile(path.resolve(logFile), logLine + "\n", "utf8");
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        const error = { error: "LOG_WRITE_ERROR", message: msg };
+        if (json) {
+            console.error(JSON.stringify(error));
+        }
+        else {
+            console.error(`Error: Failed to write to log file: ${msg}`);
+        }
+        return 1;
+    }
+    // Output confirmation
+    if (json) {
+        console.log(JSON.stringify({
+            hookType,
+            eventLabel,
+            logFile: path.resolve(logFile),
+            logLine,
+        }));
+    }
+    else {
+        console.log(logLine);
+    }
+    return 0;
+}

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

@@ -0,0 +1,20 @@
+/**
+ * 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)
+ */
+export interface HookRunCommandArgs {
+    hookType: string;
+    /** Which host tool is invoking the hook. Defaults to "claude-code". */
+    harness: string;
+    pluginRoot?: string;
+    stateDir?: string;
+    runsDir?: string;
+    json: boolean;
+    verbose?: boolean;
+}
+export declare function handleHookRun(args: HookRunCommandArgs): Promise<number>;
+//# sourceMappingURL=hookRun.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hookRun.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/hookRun.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AA+EH,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,MAAM,CAAC;IACjB,uEAAuE;IACvE,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAggBD,wBAAsB,aAAa,CAAC,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAAC,MAAM,CAAC,CAiD7E"}