@geteigen/cli 0.0.0-stage → 3.0.0

package/dist/shared/backends/claudeCode.js

@@ -0,0 +1,540 @@
+import { diffFromToolArgs, extractThinkingText, formatToolResultDetail, isEditTool, isQuestionTool, isTodoTool, parseQuestionToolArgs, todoStatusSummary, todosFromToolArgs, TOOL_RESULT_DETAIL_LIMIT, stringifyUnknown, } from "./cursor.js";
+import { claudeToolIntegration } from "../toolIntegration.js";
+import { claudeResultUsage } from "./usage.js";
+function extractText(message) {
+    if (!message || typeof message !== "object")
+        return "";
+    const content = message.content;
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((part) => {
+        if (part &&
+            typeof part === "object" &&
+            part.type === "text" &&
+            "text" in part) {
+            return String(part.text ?? "");
+        }
+        return "";
+    })
+        .join("");
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function blockIndex(event) {
+    return typeof event.index === "number" && Number.isFinite(event.index)
+        ? event.index
+        : Number(event.index ?? 0) || 0;
+}
+function tryParseToolArgs(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return undefined;
+    try {
+        return asRecord(JSON.parse(trimmed));
+    }
+    catch {
+        return undefined;
+    }
+}
+/** `message.content` on assistant/user rows, or top-level `content` fallback. */
+function messageContent(ev) {
+    const message = asRecord(ev.message);
+    if (message && message.content !== undefined)
+        return message.content;
+    return ev.content;
+}
+function toolPathFromArgs(args) {
+    if (!args)
+        return undefined;
+    for (const k of [
+        "file_path",
+        "filePath",
+        "path",
+        "target_file",
+        "targetFile",
+    ]) {
+        if (typeof args[k] === "string" && String(args[k]).trim()) {
+            return String(args[k]).trim();
+        }
+    }
+    return undefined;
+}
+/** Normalize Claude tool_result `content` (string or content-block array). */
+function extractToolResultContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content)) {
+        if (content && typeof content === "object") {
+            try {
+                return JSON.stringify(content);
+            }
+            catch {
+                return "";
+            }
+        }
+        return "";
+    }
+    return content
+        .map((part) => {
+        if (typeof part === "string")
+            return part;
+        if (!part || typeof part !== "object")
+            return "";
+        const p = part;
+        if (typeof p.text === "string")
+            return p.text;
+        if (typeof p.content === "string")
+            return p.content;
+        return "";
+    })
+        .filter(Boolean)
+        .join("\n");
+}
+function toolDetail(name, args, path) {
+    if (!args)
+        return name;
+    const todos = todosFromToolArgs(args);
+    if (isTodoTool(name) || todos.length > 0) {
+        return todos.length
+            ? `${todos.length} todo${todos.length === 1 ? "" : "s"} · ${todoStatusSummary(todos)}`
+            : "Updating todos";
+    }
+    const command = typeof args.command === "string"
+        ? args.command
+        : typeof args.pattern === "string"
+            ? args.pattern
+            : typeof args.glob === "string"
+                ? args.glob
+                : typeof args.glob_pattern === "string"
+                    ? args.glob_pattern
+                    : undefined;
+    if (command)
+        return String(command);
+    if (path)
+        return path;
+    try {
+        return JSON.stringify(args).slice(0, 120);
+    }
+    catch {
+        return name;
+    }
+}
+/**
+ * Claude Code CLI headless backend.
+ * Spawns: `claude -p --output-format stream-json --verbose ...`
+ *
+ * Stateful: create a fresh instance per run so pending tool_use ids
+ * do not leak across concurrent agents.
+ */
+export class ClaudeCodeBackend {
+    kind = "claude-code";
+    available = true;
+    command = "claude";
+    /** tool_use id → metadata, filled on assistant/stream tool_use, consumed on tool_result */
+    pendingTools = new Map();
+    /** content_block index → accumulating tool_use input JSON */
+    streamingBlocks = new Map();
+    /**
+     * Each assistant message's slice of the run's cumulative text. Messages
+     * are joined with a blank line so turns never run together, and a full
+     * `assistant` snapshot can correct its own slice without touching others.
+     */
+    segments = new Map();
+    currentMessageId = null;
+    anonymousMessages = 0;
+    /** Append (or correct) one message's text in the cumulative buffer. */
+    setMessageText(ctx, messageId, text, mode) {
+        const buf = ctx.assistantBuf;
+        const seg = this.segments.get(messageId);
+        if (!seg) {
+            if (!text)
+                return false;
+            if (buf.value && !buf.value.endsWith("\n\n")) {
+                buf.value += buf.value.endsWith("\n") ? "\n" : "\n\n";
+            }
+            this.segments.set(messageId, { start: buf.value.length, text });
+            buf.value += text;
+            return true;
+        }
+        const next = mode === "append" ? seg.text + text : text;
+        if (next === seg.text)
+            return false;
+        const isLast = seg.start + seg.text.length === buf.value.length;
+        if (!isLast)
+            return false;
+        buf.value = buf.value.slice(0, seg.start) + next;
+        seg.text = next;
+        return true;
+    }
+    buildArgs(opts) {
+        const args = [
+            "-p",
+            "--output-format",
+            "stream-json",
+            "--verbose",
+            "--include-partial-messages",
+        ];
+        if (opts.mode === "plan") {
+            // Plan mode: explore + propose, no edits until the room exits plan.
+            args.push("--permission-mode", "plan");
+        }
+        else {
+            args.push("--dangerously-skip-permissions");
+        }
+        if (opts.modelId && opts.modelId !== "auto") {
+            args.push("--model", opts.modelId);
+        }
+        if (opts.sessionId) {
+            args.push("--resume", opts.sessionId);
+        }
+        if (opts.mcpServers && Object.keys(opts.mcpServers).length) {
+            args.push("--mcp-config", JSON.stringify({ mcpServers: opts.mcpServers }));
+        }
+        // `--mcp-config` is variadic: without `--` the CLI swallows the prompt as
+        // another config file path (ENAMETOOLONG). `--` also keeps prompts that
+        // start with "-" from being read as flags.
+        args.push("--", opts.prompt);
+        return args;
+    }
+    parseLine(json, ctx = {
+        assistantBuf: { value: "" },
+        gotTerminalEvent: { value: false },
+    }) {
+        if (!json || typeof json !== "object")
+            return [];
+        const ev = json;
+        const type = ev.type;
+        const out = [];
+        if (type === "system" && ev.subtype === "init" && ev.session_id) {
+            out.push({ kind: "session", sessionId: String(ev.session_id) });
+            const names = (value) => Array.isArray(value) ? value.filter((v) => typeof v === "string") : [];
+            const commands = names(ev.slash_commands);
+            if (commands.length && !ctx.toolsOnly) {
+                out.push({
+                    kind: "cli_commands",
+                    catalog: {
+                        commands,
+                        terminalOnly: names(ev.terminal_slash_commands),
+                        skills: names(ev.skills),
+                    },
+                });
+            }
+            return out;
+        }
+        // Heartbeat while a long tool runs — use it to ensure a card exists even
+        // when the original tool_use line was dropped by Blaxel streamLogs.
+        if (type === "tool_progress") {
+            const callId = (typeof ev.parent_tool_use_id === "string" && ev.parent_tool_use_id) ||
+                (typeof ev.tool_use_id === "string" &&
+                    !String(ev.tool_use_id).includes("-heartbeat-")
+                    ? String(ev.tool_use_id)
+                    : "") ||
+                "";
+            const name = typeof ev.tool_name === "string" && ev.tool_name
+                ? ev.tool_name
+                : "tool";
+            if (callId)
+                this.startTool(callId, name, undefined, out);
+            return out;
+        }
+        // Token-level streaming (requires --include-partial-messages).
+        // Tool calls start as content_block_start { type: tool_use, input: {} }
+        // with args arriving later as input_json_delta — must not return after
+        // text_delta only or the room UI never gets tool_start cards.
+        if (type === "stream_event") {
+            const event = asRecord(ev.event);
+            if (!event)
+                return out;
+            if (event.type === "message_start") {
+                const message = asRecord(event.message);
+                this.currentMessageId =
+                    (typeof message?.id === "string" && message.id) ||
+                        `anon-${(this.anonymousMessages += 1)}`;
+                return out;
+            }
+            this.parseContentBlockEvent(event, ctx, out);
+            return out;
+        }
+        if (type === "content_block_start" ||
+            type === "content_block_delta" ||
+            type === "content_block_stop") {
+            this.parseContentBlockEvent(ev, ctx, out);
+            return out;
+        }
+        if (type === "assistant") {
+            const message = ev.message;
+            if (!ctx.toolsOnly) {
+                const thinking = extractThinkingText(message);
+                if (thinking)
+                    this.emitThinking(ctx, thinking, "replace", true, out);
+                const text = extractText(message);
+                if (text) {
+                    const record = asRecord(message);
+                    const id = (typeof record?.id === "string" && record.id) ||
+                        this.currentMessageId ||
+                        `anon-${(this.anonymousMessages += 1)}`;
+                    // The snapshot is authoritative for its own message: it fills in
+                    // any deltas the stream missed, then closes the bubble.
+                    this.setMessageText(ctx, id, text, "replace");
+                    out.push({ kind: "assistant_final", text: ctx.assistantBuf.value });
+                }
+            }
+            const content = messageContent(ev);
+            if (Array.isArray(content)) {
+                for (const block of content) {
+                    const b = asRecord(block);
+                    if (!b || b.type !== "tool_use")
+                        continue;
+                    this.startTool(String(b.id ?? ""), String(b.name ?? "tool"), asRecord(b.input), out);
+                }
+            }
+            return out;
+        }
+        if (type === "user") {
+            const content = messageContent(ev);
+            if (!Array.isArray(content))
+                return out;
+            for (const block of content) {
+                if (!block || typeof block !== "object")
+                    continue;
+                const b = block;
+                if (b.type !== "tool_result")
+                    continue;
+                const callId = String(b.tool_use_id ?? "");
+                if (!callId)
+                    continue;
+                const pending = this.pendingTools.get(callId);
+                this.pendingTools.delete(callId);
+                const name = pending?.name || "tool";
+                const path = pending?.path;
+                const resultText = extractToolResultContent(b.content);
+                const startDetail = toolDetail(name, pending?.args, path);
+                const detail = formatToolResultDetail(name, pending?.args, resultText ? { success: { content: resultText } } : undefined, resultText || startDetail || path || "Done");
+                const diffPatch = isEditTool(name) && pending?.args
+                    ? diffFromToolArgs(name, pending.args)
+                    : undefined;
+                const todos = pending?.args ? todosFromToolArgs(pending.args) : [];
+                const questions = pending?.args
+                    ? parseQuestionToolArgs(pending.args)
+                    : [];
+                const integration = claudeToolIntegration(name, pending?.args);
+                out.push({
+                    kind: "tool_done",
+                    callId,
+                    name: todos.length && !isTodoTool(name)
+                        ? "todo"
+                        : isQuestionTool(name)
+                            ? "AskUserQuestion"
+                            : name,
+                    detail: todos.length
+                        ? `${todos.length} todo${todos.length === 1 ? "" : "s"} · ${todoStatusSummary(todos)}`
+                        : detail.slice(0, TOOL_RESULT_DETAIL_LIMIT),
+                    path,
+                    diffPatch: diffPatch || undefined,
+                    todos: todos.length ? todos : undefined,
+                    questions: questions.length ? questions : undefined,
+                    ...(integration ? { integration } : {}),
+                });
+            }
+            return out;
+        }
+        if (type === "error") {
+            if (ctx.toolsOnly)
+                return out;
+            ctx.gotTerminalEvent.value = true;
+            out.push({
+                kind: "error",
+                message: stringifyUnknown(ev.error) ||
+                    stringifyUnknown(ev.message) ||
+                    stringifyUnknown(ev.result) ||
+                    ctx.stderr ||
+                    "Claude Code error",
+            });
+            return out;
+        }
+        if (type === "result") {
+            if (ctx.toolsOnly) {
+                if (ev.session_id) {
+                    out.push({ kind: "session", sessionId: String(ev.session_id) });
+                }
+                return out;
+            }
+            ctx.gotTerminalEvent.value = true;
+            if (ev.session_id) {
+                out.push({ kind: "session", sessionId: String(ev.session_id) });
+            }
+            const subtype = String(ev.subtype ?? "");
+            const isError = Boolean(ev.is_error) ||
+                subtype.startsWith("error") ||
+                subtype === "error_during_execution" ||
+                subtype === "error_max_turns";
+            if (isError) {
+                const msg = stringifyUnknown(ev.result) ||
+                    stringifyUnknown(ev.errors) ||
+                    stringifyUnknown(ev.error) ||
+                    ctx.stderr ||
+                    `Claude Code error (${subtype || "unknown"})`;
+                out.push({ kind: "error", message: msg });
+            }
+            else {
+                out.push({
+                    kind: "done",
+                    result: stringifyUnknown(ev.result) ||
+                        ctx.assistantBuf.value ||
+                        "",
+                    usage: claudeResultUsage(ev),
+                });
+            }
+        }
+        return out;
+    }
+    parseContentBlockEvent(event, ctx, out) {
+        const eventType = String(event.type ?? "");
+        const index = blockIndex(event);
+        if (eventType === "content_block_start") {
+            const block = asRecord(event.content_block);
+            if (!block)
+                return;
+            if (block.type === "thinking" || block.type === "reasoning") {
+                ctx.thinkingBuf = { value: "" };
+                const seed = extractThinkingText(block);
+                if (seed && !ctx.toolsOnly)
+                    this.emitThinking(ctx, seed, "append", false, out);
+                return;
+            }
+            if (block.type !== "tool_use")
+                return;
+            const callId = String(block.id ?? "");
+            if (!callId)
+                return;
+            const name = String(block.name ?? "tool");
+            const args = asRecord(block.input);
+            this.streamingBlocks.set(index, {
+                callId,
+                name,
+                inputJson: args && Object.keys(args).length > 0 ? JSON.stringify(args) : "",
+            });
+            this.startTool(callId, name, args, out);
+            return;
+        }
+        if (eventType === "content_block_delta") {
+            const delta = asRecord(event.delta);
+            if (!delta)
+                return;
+            if (delta.type === "text_delta" && typeof delta.text === "string") {
+                if (ctx.toolsOnly)
+                    return;
+                this.currentMessageId ??= `anon-${(this.anonymousMessages += 1)}`;
+                if (this.setMessageText(ctx, this.currentMessageId, delta.text, "append")) {
+                    out.push({
+                        kind: "assistant_delta",
+                        text: ctx.assistantBuf.value,
+                    });
+                }
+                return;
+            }
+            if ((delta.type === "thinking_delta" || delta.type === "reasoning_delta") &&
+                !ctx.toolsOnly) {
+                const chunk = typeof delta.thinking === "string"
+                    ? delta.thinking
+                    : typeof delta.text === "string"
+                        ? delta.text
+                        : extractThinkingText(delta);
+                if (chunk)
+                    this.emitThinking(ctx, chunk, "append", false, out);
+                return;
+            }
+            if (delta.type === "input_json_delta" &&
+                typeof delta.partial_json === "string") {
+                const streaming = this.streamingBlocks.get(index);
+                if (!streaming)
+                    return;
+                streaming.inputJson += delta.partial_json;
+                const args = tryParseToolArgs(streaming.inputJson);
+                if (args) {
+                    this.startTool(streaming.callId, streaming.name, args, out);
+                }
+            }
+            return;
+        }
+        if (eventType === "content_block_stop") {
+            const streaming = this.streamingBlocks.get(index);
+            if (!streaming)
+                return;
+            this.streamingBlocks.delete(index);
+            const args = tryParseToolArgs(streaming.inputJson);
+            if (args) {
+                this.startTool(streaming.callId, streaming.name, args, out);
+            }
+        }
+    }
+    emitThinking(ctx, incoming, mode, final, out) {
+        if (!incoming)
+            return;
+        ctx.thinkingBuf ??= { value: "" };
+        const next = mode === "replace"
+            ? incoming
+            : ctx.thinkingBuf.value + incoming;
+        if (next === ctx.thinkingBuf.value)
+            return;
+        ctx.thinkingBuf.value = next;
+        out.push({
+            kind: final ? "thinking_final" : "thinking_delta",
+            text: next,
+        });
+    }
+    /**
+     * Record a tool_use and emit tool_start once. Re-emits when args go from
+     * empty `{}` (content_block_start placeholder) to a real path/command so
+     * the existing chat row can pick up a useful title.
+     *
+     * Nested Task/subagent tools (parent_tool_use_id set) still emit as
+     * `tool_start` / later `tool_done` so every Claude Code tool appears as a
+     * room tool card.
+     */
+    startTool(callId, name, args, out) {
+        if (!callId)
+            return;
+        const path = toolPathFromArgs(args);
+        const existing = this.pendingTools.get(callId);
+        const hasArgs = Boolean(args && Object.keys(args).length > 0);
+        const hadArgs = Boolean(existing?.args && Object.keys(existing.args).length > 0);
+        const mergedArgs = hasArgs ? args : existing?.args;
+        const mergedPath = path || existing?.path;
+        const mergedName = existing?.name || name;
+        this.pendingTools.set(callId, {
+            name: mergedName,
+            path: mergedPath,
+            args: mergedArgs,
+        });
+        const alreadyStarted = Boolean(existing);
+        const detailImproved = alreadyStarted && hasArgs && !hadArgs;
+        if (alreadyStarted && !detailImproved)
+            return;
+        const todos = mergedArgs ? todosFromToolArgs(mergedArgs) : [];
+        const questions = mergedArgs ? parseQuestionToolArgs(mergedArgs) : [];
+        const integration = claudeToolIntegration(mergedName, mergedArgs);
+        // Always surface as a first-class tool card (including nested Task tools).
+        out.push({
+            kind: "tool_start",
+            callId,
+            name: todos.length && !isTodoTool(mergedName)
+                ? "todo"
+                : isQuestionTool(mergedName)
+                    ? "AskUserQuestion"
+                    : mergedName,
+            detail: toolDetail(mergedName, mergedArgs, mergedPath),
+            path: mergedPath,
+            todos: todos.length ? todos : undefined,
+            questions: questions.length ? questions : undefined,
+            ...(integration ? { integration } : {}),
+        });
+    }
+}
+export const claudeCodeBackend = new ClaudeCodeBackend();

package/dist/shared/backends/codex.d.ts

@@ -0,0 +1,15 @@
+import type { BuildArgsOptions, NormalizedAgentEvent, ParseLineContext, WorkerBackend } from "./types.js";
+/**
+ * OpenAI Codex CLI headless backend.
+ * Spawns: `codex exec --json --dangerously-bypass-approvals-and-sandbox …`
+ *
+ * Event stream is JSONL (`thread.*`, `item.*`, `turn.*`).
+ */
+export declare class CodexBackend implements WorkerBackend {
+    readonly kind: "codex";
+    readonly available = true;
+    readonly command = "codex";
+    buildArgs(opts: BuildArgsOptions): string[];
+    parseLine(json: unknown, ctx?: ParseLineContext): NormalizedAgentEvent[];
+}
+export declare const codexBackend: CodexBackend;