@vigent/cli 0.0.0-stage → 0.2.1

package/dist/cli-engines.js

@@ -0,0 +1,537 @@
+/**
+ * Agents run by a coding-agent CLI you already have: Claude Code, Codex or
+ * OpenCode.
+ *
+ * vigent starts the CLI once per prompt in the agent's worktree, in its
+ * non-interactive JSON mode, and turns the events it prints into the
+ * transcript. Each CLI keeps its own conversation; vigent only remembers the
+ * id it prints and passes it back to resume. The CLI uses its own login:
+ * vigent never reads its credentials.
+ */
+import { spawn } from "node:child_process";
+import * as fs from "node:fs";
+import { ENGINE_BINS, ENGINE_NAMES } from "./engines.js";
+import { Session } from "./session.js";
+// ---------------------------------------------------------------------------
+// Claude Code: claude -p --output-format stream-json
+// ---------------------------------------------------------------------------
+export const claudeAdapter = {
+    id: "claude",
+    bin: ENGINE_BINS.claude,
+    // -p can't ask before a tool runs; edits are allowed, other tools follow your Claude Code settings
+    defaultArgs: ["--permission-mode", "acceptEdits"],
+    args(prompt, o) {
+        return [
+            "-p",
+            "--output-format",
+            "stream-json",
+            "--verbose",
+            "--include-partial-messages",
+            ...(o.extraArgs ?? this.defaultArgs),
+            ...(o.model ? ["--model", o.model] : []),
+            ...(o.effort ? ["--effort", o.effort] : []),
+            ...(o.resumeId ? ["--resume", o.resumeId] : []),
+            "--",
+            prompt,
+        ];
+    },
+    parser() {
+        return (e) => {
+            if (!e || typeof e !== "object")
+                return [];
+            // a subagent's own messages: only its result reaches the transcript
+            if (e.parent_tool_use_id)
+                return [];
+            const out = [];
+            switch (e.type) {
+                case "system":
+                    if (e.subtype === "init") {
+                        if (e.session_id)
+                            out.push({ type: "session", id: e.session_id });
+                        if (e.model)
+                            out.push({ type: "model", model: e.model });
+                    }
+                    break;
+                case "stream_event": {
+                    const ev = e.event ?? {};
+                    if (ev.type === "content_block_delta" && ev.delta?.type === "text_delta" && ev.delta.text) {
+                        out.push({ type: "text_delta", text: ev.delta.text });
+                    }
+                    break;
+                }
+                case "assistant":
+                    for (const b of contentOf(e.message)) {
+                        if (b?.type === "text" && b.text)
+                            out.push({ type: "text", text: b.text });
+                        else if (b?.type === "tool_use")
+                            out.push({ type: "tool", id: b.id, name: b.name, summary: summarize(b.input) });
+                    }
+                    break;
+                case "user":
+                    for (const b of contentOf(e.message)) {
+                        if (b?.type === "tool_result")
+                            out.push({ type: "tool_result", id: b.tool_use_id, output: textOf(b.content) });
+                    }
+                    break;
+                case "result": {
+                    const u = e.usage ?? {};
+                    const tokens = (u.input_tokens ?? 0) + (u.cache_creation_input_tokens ?? 0) + (u.cache_read_input_tokens ?? 0) + (u.output_tokens ?? 0);
+                    if (tokens)
+                        out.push({ type: "usage", tokens });
+                    if (e.session_id)
+                        out.push({ type: "session", id: e.session_id });
+                    const ok = !e.is_error && e.subtype === "success";
+                    out.push({ type: "done", ok, ...(ok ? {} : { error: String(e.result ?? e.errors?.join?.("; ") ?? e.subtype ?? "failed") }) });
+                    break;
+                }
+            }
+            return out;
+        };
+    },
+};
+// ---------------------------------------------------------------------------
+// Codex: codex exec --json
+// ---------------------------------------------------------------------------
+export const codexAdapter = {
+    id: "codex",
+    bin: ENGINE_BINS.codex,
+    // edits and commands inside the worktree, nothing outside it
+    defaultArgs: ["-c", 'sandbox_mode="workspace-write"'],
+    args(prompt, o) {
+        return [
+            "exec",
+            ...(o.resumeId ? ["resume"] : []),
+            "--json",
+            "--skip-git-repo-check",
+            ...(o.extraArgs ?? this.defaultArgs),
+            ...(o.model ? ["-m", o.model] : []),
+            ...(o.effort ? ["-c", `model_reasoning_effort="${o.effort}"`] : []),
+            ...(o.resumeId ? [o.resumeId] : []),
+            "--",
+            prompt,
+        ];
+    },
+    parser() {
+        let lastError;
+        const started = new Set();
+        const tool = (item) => {
+            switch (item.type) {
+                case "command_execution":
+                    return { type: "tool", id: item.id, name: "bash", summary: shellCommand(item.command) };
+                case "file_change":
+                    return {
+                        type: "tool",
+                        id: item.id,
+                        name: "edit",
+                        summary: (item.changes ?? []).map((c) => `${c.kind === "add" ? "+" : c.kind === "delete" ? "-" : ""}${c.path}`).join(", "),
+                    };
+                case "mcp_tool_call":
+                    return { type: "tool", id: item.id, name: [item.server, item.tool].filter(Boolean).join("."), summary: summarize(item.arguments) };
+                case "web_search":
+                    return { type: "tool", id: item.id, name: "web_search", summary: String(item.query ?? "") };
+            }
+            return undefined;
+        };
+        return (e) => {
+            if (!e || typeof e !== "object")
+                return [];
+            const out = [];
+            switch (e.type) {
+                case "thread.started":
+                    if (e.thread_id)
+                        out.push({ type: "session", id: e.thread_id });
+                    break;
+                case "item.started": {
+                    const t = e.item && tool(e.item);
+                    if (t) {
+                        started.add(e.item.id);
+                        out.push(t);
+                    }
+                    break;
+                }
+                case "item.completed": {
+                    const item = e.item ?? {};
+                    if (item.type === "agent_message" && item.text) {
+                        out.push({ type: "text", text: item.text });
+                        break;
+                    }
+                    const t = tool(item);
+                    if (!t)
+                        break;
+                    if (!started.has(item.id))
+                        out.push(t);
+                    const output = item.type === "command_execution"
+                        ? `${String(item.aggregated_output ?? "").trimEnd()}${item.exit_code ? `\n(exit ${item.exit_code})` : ""}`.trim()
+                        : item.type === "mcp_tool_call"
+                            ? textOf(item.result?.content ?? item.error?.message ?? "")
+                            : item.status === "failed"
+                                ? "failed"
+                                : "";
+                    out.push({ type: "tool_result", id: item.id, output });
+                    break;
+                }
+                case "turn.completed": {
+                    const u = e.usage ?? {};
+                    const tokens = (u.input_tokens ?? 0) + (u.output_tokens ?? 0);
+                    if (tokens)
+                        out.push({ type: "usage", tokens });
+                    out.push({ type: "done", ok: true });
+                    break;
+                }
+                case "turn.failed":
+                    out.push({ type: "done", ok: false, error: e.error?.message ?? lastError ?? "turn failed" });
+                    break;
+                case "error":
+                    // "Reconnecting... 2/5" is codex retrying; only the final error matters
+                    if (typeof e.message === "string" && !/^Reconnecting\.\.\./.test(e.message))
+                        lastError = e.message;
+                    break;
+            }
+            return out;
+        };
+    },
+};
+// ---------------------------------------------------------------------------
+// OpenCode: opencode run --format json
+// ---------------------------------------------------------------------------
+export const opencodeAdapter = {
+    id: "opencode",
+    bin: ENGINE_BINS.opencode,
+    defaultArgs: [],
+    args(prompt, o) {
+        return [
+            "run",
+            "--format",
+            "json",
+            "--dir",
+            o.cwd,
+            ...(o.extraArgs ?? this.defaultArgs),
+            ...(o.model ? ["-m", o.model] : []),
+            ...(o.effort ? ["--variant", o.effort] : []),
+            ...(o.resumeId ? ["--session", o.resumeId] : []),
+            "--",
+            prompt,
+        ];
+    },
+    parser() {
+        let sessionId;
+        return (e) => {
+            if (!e || typeof e !== "object")
+                return [];
+            const out = [];
+            if (e.sessionID && e.sessionID !== sessionId) {
+                sessionId = e.sessionID;
+                out.push({ type: "session", id: e.sessionID });
+            }
+            const part = e.part ?? {};
+            switch (e.type) {
+                case "text":
+                    if (part.text?.trim())
+                        out.push({ type: "text", text: part.text.trim() });
+                    break;
+                case "tool_use": {
+                    const st = part.state ?? {};
+                    out.push({ type: "tool", id: part.callID ?? part.id, name: part.tool ?? "tool", summary: st.title || summarize(st.input) });
+                    out.push({ type: "tool_result", id: part.callID ?? part.id, output: String(st.output ?? st.error ?? "") });
+                    break;
+                }
+                case "step_finish": {
+                    const t = part.tokens ?? {};
+                    const tokens = (t.input ?? 0) + (t.output ?? 0) + (t.reasoning ?? 0) + (t.cache?.read ?? 0) + (t.cache?.write ?? 0);
+                    if (tokens)
+                        out.push({ type: "usage", tokens });
+                    break;
+                }
+                case "error": {
+                    const err = e.error ?? {};
+                    out.push({ type: "error", message: String(err.data?.message ?? err.message ?? err.name ?? "error") });
+                    break;
+                }
+            }
+            return out;
+        };
+    },
+};
+export const CLI_ADAPTERS = {
+    claude: claudeAdapter,
+    codex: codexAdapter,
+    opencode: opencodeAdapter,
+};
+export class CliSession extends Session {
+    opts;
+    cwd;
+    resumeId;
+    adapter;
+    child;
+    aborted = false;
+    /** the model the user asked for; undefined = the CLI's own default */
+    requestedModel;
+    constructor(name, engine, model, opts) {
+        super(name, model ?? ENGINE_NAMES[engine], opts.worktree);
+        this.opts = opts;
+        this.engine = engine;
+        this.adapter = CLI_ADAPTERS[engine];
+        this.cwd = opts.cwd;
+        this.requestedModel = model;
+        this.effort = opts.effort;
+        this.resumeId = opts.resumeId;
+        if (opts.resumeId) {
+            this.pushInfo(`continuing the ${ENGINE_NAMES[engine]} conversation ${opts.resumeId.slice(0, 8)}… (earlier messages live in ${ENGINE_NAMES[engine]}'s history)`);
+            this.refreshStat(0);
+        }
+    }
+    get engineName() {
+        return ENGINE_NAMES[this.engine];
+    }
+    /** The model for the next prompt; undefined (or "default") = the CLI's own. */
+    setModel(model) {
+        this.requestedModel = model && model !== "default" ? model : undefined;
+        this.model = this.requestedModel ?? ENGINE_NAMES[this.engine];
+        this.emit();
+    }
+    /** Reasoning effort for the next prompt; undefined = the CLI's own. */
+    setEffort(effort) {
+        this.effort = effort && effort !== "default" ? effort : undefined;
+        this.emit();
+    }
+    /** what was asked for (vs. what the CLI reported it used) */
+    get chosenModel() {
+        return this.requestedModel;
+    }
+    send(text) {
+        this.pushUser(text);
+        this.setState("running");
+        this.aborted = false;
+        const args = this.adapter.args(text, {
+            cwd: this.cwd,
+            model: this.requestedModel,
+            effort: this.effort,
+            resumeId: this.resumeId,
+            extraArgs: this.opts.extraArgs,
+        });
+        let child;
+        try {
+            child = spawn(this.opts.bin ?? this.adapter.bin, args, {
+                cwd: this.cwd,
+                env: this.opts.env ?? process.env,
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+        }
+        catch (err) {
+            this.fail(`couldn't start ${this.adapter.bin}: ${err?.message ?? err}`);
+            return;
+        }
+        this.child = child;
+        const parse = this.adapter.parser();
+        let buf = "";
+        let stderr = "";
+        let result;
+        let lastError;
+        const tools = new Map();
+        const handle = (ev) => {
+            switch (ev.type) {
+                case "session":
+                    if (ev.id !== this.resumeId) {
+                        this.resumeId = ev.id;
+                        this.opts.onResumeId?.(ev.id);
+                    }
+                    break;
+                case "model":
+                    if (!this.requestedModel)
+                        this.model = ev.model;
+                    this.emit();
+                    break;
+                case "text_delta": {
+                    const last = this.items.at(-1);
+                    if (last?.kind === "agent" && last.streaming)
+                        last.text += ev.text;
+                    else
+                        this.items.push({ kind: "agent", text: ev.text, streaming: true });
+                    this.emit();
+                    break;
+                }
+                case "text": {
+                    const last = this.items.at(-1);
+                    if (last?.kind === "agent" && last.streaming) {
+                        last.text = ev.text;
+                        last.streaming = false;
+                    }
+                    else
+                        this.items.push({ kind: "agent", text: ev.text });
+                    this.emit();
+                    break;
+                }
+                case "tool": {
+                    this.endStreaming();
+                    const summary = this.relative(ev.summary).slice(0, 80);
+                    const item = { kind: "tool", text: "", tool: { name: ev.name, summary, output: "", folded: true } };
+                    this.items.push(item);
+                    if (ev.id)
+                        tools.set(ev.id, item);
+                    this.emit();
+                    break;
+                }
+                case "tool_result": {
+                    const item = (ev.id && tools.get(ev.id)) || [...this.items].reverse().find((i) => i.kind === "tool");
+                    if (item?.tool)
+                        item.tool.output = ev.output;
+                    this.emit();
+                    this.refreshStat();
+                    break;
+                }
+                case "usage":
+                    this.tokens += ev.tokens;
+                    this.emit();
+                    break;
+                case "error":
+                    lastError = ev.message;
+                    break;
+                case "done":
+                    result = ev;
+                    break;
+            }
+        };
+        child.stdout.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => {
+            buf += chunk;
+            let nl;
+            while ((nl = buf.indexOf("\n")) >= 0) {
+                const line = buf.slice(0, nl).trim();
+                buf = buf.slice(nl + 1);
+                if (!line.startsWith("{"))
+                    continue;
+                let json;
+                try {
+                    json = JSON.parse(line);
+                }
+                catch {
+                    continue; // not an event (a stray log line)
+                }
+                for (const ev of parse(json))
+                    handle(ev);
+            }
+        });
+        child.stderr.setEncoding("utf8");
+        child.stderr.on("data", (chunk) => {
+            stderr = (stderr + chunk).slice(-4000);
+        });
+        child.on("error", (err) => {
+            this.child = undefined;
+            this.fail(err.code === "ENOENT"
+                ? `${this.adapter.bin} isn't installed (or isn't on PATH) · :checkhealth`
+                : `${this.adapter.bin}: ${err.message}`);
+        });
+        child.on("close", (code, signal) => {
+            if (this.child !== child)
+                return; // already failed to start
+            this.child = undefined;
+            this.endStreaming();
+            this.refreshStat(0);
+            if (this.aborted) {
+                this.setState("idle");
+                return;
+            }
+            const ok = result ? result.ok : code === 0 && !lastError;
+            if (ok) {
+                this.setState("idle");
+                return;
+            }
+            const why = result?.error ??
+                lastError ??
+                lastLines(stderr) ??
+                (signal ? `stopped by ${signal}` : `exited with code ${code}`);
+            this.fail(`${this.engineName}: ${why}`);
+        });
+    }
+    /** paths inside the agent's folder, shown relative to it */
+    relative(text) {
+        let out = text;
+        for (const dir of new Set([this.cwd, safeRealpath(this.cwd)])) {
+            if (dir)
+                out = out.split(`${dir.replace(/\/+$/, "")}/`).join("");
+        }
+        return out;
+    }
+    endStreaming() {
+        const last = this.items.at(-1);
+        if (last?.kind === "agent" && last.streaming) {
+            last.streaming = false;
+            if (!last.text)
+                this.items.pop();
+        }
+    }
+    fail(message) {
+        this.endStreaming();
+        this.pushInfo(`error: ${message}`);
+        this.setState("error");
+    }
+    abort() {
+        const child = this.child;
+        if (child) {
+            this.aborted = true;
+            child.kill("SIGINT");
+            const t = setTimeout(() => {
+                if (child.exitCode === null && child.signalCode === null)
+                    child.kill("SIGTERM");
+            }, 2000);
+            t.unref();
+        }
+        this.setState("idle");
+    }
+    dispose() {
+        super.dispose();
+        if (this.child) {
+            this.aborted = true;
+            this.child.kill("SIGTERM");
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// helpers
+// ---------------------------------------------------------------------------
+function safeRealpath(p) {
+    try {
+        return fs.realpathSync(p);
+    }
+    catch {
+        return undefined;
+    }
+}
+function contentOf(message) {
+    return Array.isArray(message?.content) ? message.content : [];
+}
+function textOf(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return content == null ? "" : JSON.stringify(content);
+    return content
+        .filter((b) => b?.type === "text" && typeof b.text === "string")
+        .map((b) => b.text)
+        .join("\n");
+}
+function summarize(args) {
+    if (!args)
+        return "";
+    if (typeof args === "string")
+        return args.slice(0, 80);
+    const v = args.command ?? args.file_path ?? args.filePath ?? args.path ?? args.pattern ?? args.url ?? args.description ?? JSON.stringify(args);
+    return String(v).slice(0, 80);
+}
+/** codex reports commands as `/bin/bash -lc "npm test"` (or an argv array); show the command itself. */
+function shellCommand(cmd) {
+    const parts = Array.isArray(cmd) ? cmd.map(String) : undefined;
+    if (parts && parts.length >= 3 && /(^|\/)(ba|z)?sh$/.test(parts[0]) && /^-l?c$/.test(parts[1]))
+        return parts.slice(2).join(" ");
+    const s = parts ? parts.join(" ") : String(cmd ?? "");
+    const m = /^\S*\/(?:ba|z)?sh\s+-l?c\s+(['"])([\s\S]*)\1$/.exec(s);
+    return m ? m[2] : s;
+}
+function lastLines(stderr) {
+    const lines = stderr
+        .replace(/\x1b\[[0-9;]*m/g, "")
+        .split("\n")
+        .map((l) => l.trim())
+        .filter((l) => l && !/^Reading additional input from stdin/.test(l) && !/^Warning: no stdin data/.test(l));
+    return lines.length ? lines.slice(-2).join(" · ") : undefined;
+}