ai-foreman 1.0.0

package/dist/adapters/codex.js

@@ -0,0 +1,155 @@
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+import { AsyncQueue } from "../util/asyncQueue.js";
+/**
+ * Pure function: parse one JSONL event from `codex exec --json` output into
+ * structured actions. Exported for unit testing; production code calls this
+ * via handleEvent().
+ */
+export function parseCodexLine(raw) {
+    const type = raw.type;
+    if (type === "thread.started") {
+        const sessionId = raw.thread_id;
+        return { events: [], sessionId };
+    }
+    if (type === "item.completed") {
+        const item = raw.item;
+        if (!item)
+            return { events: [] };
+        if (item.type === "agent_message") {
+            const text = item.text;
+            if (!text)
+                return { events: [] };
+            return { events: [{ kind: "text", text }], text };
+        }
+        if (item.type === "command_execution") {
+            return {
+                events: [{ kind: "tool", name: "command_execution", input: { command: item.command } }],
+            };
+        }
+        return { events: [] };
+    }
+    if (type === "error") {
+        const msg = raw.error?.message
+            ?? JSON.stringify(raw);
+        return { events: [{ kind: "error", message: msg }] };
+    }
+    return { events: [] };
+}
+/**
+ * Drives Codex CLI as a subprocess. Each sendTurn() spawns `codex exec --json`
+ * and reads JSONL from stdout. Session continuity is maintained via the
+ * thread_id captured from the first run and passed as `resume <id>` on
+ * subsequent turns.
+ *
+ * NOTE: opts.permission is accepted for interface conformance but is not
+ * invoked. Codex manages its own tool sandboxing via --sandbox workspace-write.
+ */
+export class CodexAdapter {
+    opts;
+    agent = "codex";
+    eventQueue = new AsyncQueue();
+    _sessionId;
+    _closed = false;
+    _activeProc;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    /**
+     * Prepend role system text to a turn instruction when `systemPromptAppend` is
+     * set. Codex reads everything from the prompt (no persistent system prompt), so
+     * role guidance must ride along with each turn.
+     */
+    buildInstruction(instruction) {
+        return this.opts.systemPromptAppend
+            ? `${this.opts.systemPromptAppend}\n\n${instruction}`
+            : instruction;
+    }
+    /** Build the `codex exec` argument list for the given instruction. */
+    buildArgs(instruction) {
+        const args = ["exec", "--json", "--sandbox", "workspace-write", "-C", this.opts.cwd];
+        if (this.opts.model)
+            args.push("-m", this.opts.model);
+        if (this.opts.effort) {
+            args.push("-c", `model_reasoning_effort=${this.opts.effort}`);
+        }
+        else if (this.opts.fast) {
+            args.push("-c", "model_reasoning_effort=low");
+        }
+        if (this._sessionId) {
+            args.push("resume", this._sessionId);
+        }
+        args.push(instruction);
+        return args;
+    }
+    sendTurn(instruction) {
+        if (this._closed)
+            return Promise.reject(new Error("builder is closed"));
+        const args = this.buildArgs(this.buildInstruction(instruction));
+        const textParts = [];
+        const stderrChunks = [];
+        return new Promise((resolve, reject) => {
+            const proc = spawn("codex", args, {
+                cwd: this.opts.cwd,
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+            this._activeProc = proc;
+            const rl = createInterface({ input: proc.stdout, crlfDelay: Infinity });
+            rl.on("line", (line) => {
+                if (!line.trim())
+                    return;
+                let raw;
+                try {
+                    raw = JSON.parse(line);
+                }
+                catch {
+                    return;
+                }
+                const result = parseCodexLine(raw);
+                if (result.sessionId)
+                    this._sessionId = result.sessionId;
+                if (result.text)
+                    textParts.push(result.text);
+                for (const ev of result.events)
+                    this.eventQueue.push(ev);
+            });
+            proc.stderr.on("data", (chunk) => {
+                stderrChunks.push(chunk);
+            });
+            proc.on("close", (code) => {
+                this._activeProc = undefined;
+                let text = textParts.join("\n");
+                if (!text && code !== 0) {
+                    text = Buffer.concat(stderrChunks).toString().trim();
+                }
+                const result = {
+                    text,
+                    isError: code !== 0,
+                    numTurns: 1,
+                    costUsd: 0,
+                };
+                this.eventQueue.push({ kind: "turn-complete", result });
+                resolve(result);
+            });
+            proc.on("error", (err) => {
+                this._activeProc = undefined;
+                this.eventQueue.push({ kind: "error", message: err.message });
+                reject(err);
+            });
+        });
+    }
+    sessionId() {
+        return this._sessionId;
+    }
+    events() {
+        return this.eventQueue;
+    }
+    close() {
+        if (this._closed)
+            return Promise.resolve();
+        this._closed = true;
+        this._activeProc?.kill("SIGTERM");
+        this.eventQueue.close();
+        return Promise.resolve();
+    }
+}

package/dist/adapters/types.js

@@ -0,0 +1,4 @@
+/**
+ * Agent-agnostic interface over a coding agent ("builder").
+ */
+export {};

package/dist/cli/events.js

@@ -0,0 +1,45 @@
+/** Print a compact live feed of builder activity. */
+export async function printEvents(events) {
+    let atLineStart = true;
+    for await (const ev of events) {
+        if (ev.kind === "text") {
+            if (ev.text) {
+                process.stdout.write(ev.text);
+                atLineStart = ev.text.endsWith("\n");
+            }
+        }
+        else if (ev.kind === "tool") {
+            if (!atLineStart) {
+                process.stdout.write("\n");
+                atLineStart = true;
+            }
+            console.log(`  -> ${ev.name} ${briefInput(ev.input)}`);
+        }
+        else if (ev.kind === "turn-complete") {
+            if (!atLineStart) {
+                process.stdout.write("\n");
+                atLineStart = true;
+            }
+            const tag = ev.result.isError ? "turn errored" : "turn complete";
+            const cost = ev.result.costUsd > 0 ? ` ($${ev.result.costUsd.toFixed(4)})` : "";
+            console.log(`  - ${tag}${cost}`);
+        }
+        else if (ev.kind === "error") {
+            if (!atLineStart) {
+                process.stdout.write("\n");
+                atLineStart = true;
+            }
+            console.log(`  ! error: ${ev.message}`);
+        }
+    }
+    if (!atLineStart)
+        process.stdout.write("\n");
+}
+function briefInput(input) {
+    if (input && typeof input === "object") {
+        const o = input;
+        const key = o.command ?? o.file_path ?? o.path ?? o.pattern ?? "";
+        return String(key).slice(0, 80);
+    }
+    return "";
+}