huddle-cli 0.1.0 → 0.1.3

package/dist/ui/transcript.js

@@ -0,0 +1,434 @@
+// An agent's own session, as a readable transcript: what it said, what it
+// thought (when the CLI shows it), every tool call with its arguments in short,
+// and what came back — trimmed. `huddle export --level full` puts one of these
+// under each task of a run.
+//
+// The logs are whatever the agent CLI printed (.huddle/logs/<agent>-<task>.log,
+// src/orchestrator/launcher.ts):
+//   claude  --output-format stream-json   assistant/user messages, tool_use ↔ tool_result
+//   codex   exec --json                   item.started / item.completed (agent_message,
+//                                         command_execution, mcp_tool_call, file_change, …)
+//   cursor  --output-format stream-json   assistant text, thinking deltas, tool_call
+//                                         started/completed (shellToolCall, readToolCall, …)
+// amp and qwen speak Claude's shape. Anything else — another CLI, a log cut
+// short, a format that changed — is kept as plain text, never dropped.
+import fs from "node:fs";
+/** One tool result keeps this much; the rest is cut with a note saying how much. */
+export const OUTPUT_MAX = { chars: 2_000, lines: 40 };
+/** Arguments, summarized, keep this much. */
+const INPUT_MAX = 600;
+/** The launch prompt (long and the same for every task) keeps this much. */
+const PROMPT_MAX = 3_000;
+/** A raw (unparsed) log keeps this much. */
+export const RAW_MAX = 200_000;
+/** Logs bigger than this are read from the start only. */
+const READ_MAX = 32 * 1024 * 1024;
+/** Cut text to `chars` and `lines`, saying what was cut. */
+export function cap(text, max = OUTPUT_MAX) {
+    let t = text.replace(/\s+$/, "");
+    const lines = t.split("\n");
+    let cut = "";
+    if (lines.length > max.lines) {
+        t = lines.slice(0, max.lines).join("\n");
+        cut = `${lines.length - max.lines} more line${lines.length - max.lines === 1 ? "" : "s"}`;
+    }
+    if (t.length > max.chars) {
+        const more = text.length - max.chars;
+        t = t.slice(0, max.chars);
+        cut = `${more.toLocaleString("en-US")} more characters`;
+    }
+    return cut ? `${t}\n… [cut: ${cut} — the whole output is in the agent's log]` : t;
+}
+const one = (s, n = INPUT_MAX) => {
+    const l = s.replace(/\s+/g, " ").trim();
+    return l.length <= n ? l : l.slice(0, n - 1) + "…";
+};
+const str = (v) => (v === undefined || v === null ? "" : typeof v === "string" ? v : JSON.stringify(v));
+/**
+ * Absolute worktree paths → repo-relative ones. Every tool call names
+ * /…/repo/.huddle/worktrees/claude-aCN9HG/src/csv.js; a reader wants src/csv.js.
+ */
+export function relPaths(s) {
+    return s.replace(CD_WT, "").replace(WT_SLASH, "").replace(WT, ".");
+}
+const WT_SRC = String.raw `[^\s"'\`]*?\.huddle[\\/]worktrees[\\/][^\\/\s"'\`]+`;
+const CD_WT = new RegExp(String.raw `cd\s+(["']?)` + WT_SRC + String.raw `\1\s*(?:&&|;|\n)\s*`, "g");
+const WT_SLASH = new RegExp(WT_SRC + String.raw `[\\/]`, "g");
+const WT = new RegExp(WT_SRC, "g");
+const tidy = (s) => relPaths(s);
+/** "mcp__huddle__huddle_send" / "huddle-huddle_send" → "huddle_send". */
+const toolName = (n) => n.replace(/^mcp__[^_]+(?:_[^_]+)*?__/, "").replace(/^huddle-/, "");
+/** A tool's arguments in a line: the command, the path, the message — not the JSON. */
+export function summarizeInput(tool, input) {
+    const a = (input && typeof input === "object" ? input : {});
+    const t = toolName(tool).toLowerCase();
+    if (typeof input === "string")
+        return tidy(one(input));
+    // A command keeps its lines (a heredoc is a file being written), capped like an output.
+    if (a.command !== undefined)
+        return tidy(cap(Array.isArray(a.command) ? a.command.join(" ") : str(a.command), { chars: 1_500, lines: 30 }));
+    const file = a.file_path ?? a.path ?? a.notebook_path ?? a.targetFile;
+    if (/^(write|create)/.test(t) && file)
+        return `${tidy(str(file))} (${str(a.content ?? a.contents ?? a.streamContent).split("\n").length} lines)`;
+    if (/edit/.test(t) && file)
+        return tidy(str(file));
+    if (file && Object.keys(a).length <= 3)
+        return tidy(`${str(file)}${a.offset || a.limit ? ` (from line ${a.offset ?? 1}${a.limit ? `, ${a.limit} lines` : ""})` : ""}`);
+    if (a.pattern !== undefined || a.globPattern !== undefined)
+        return tidy(one(`${str(a.pattern ?? a.globPattern)}${a.path || a.targetDirectory ? " in " + str(a.path ?? a.targetDirectory) : ""}`));
+    // Huddle's own tools: who it's to and what it says — the conversation, in the agent's words.
+    if (a.to !== undefined && (a.message !== undefined || a.body !== undefined))
+        return one(`to ${str(a.to)}: ${str(a.message ?? a.body)}`, 2_000);
+    if (a.question !== undefined)
+        return one(`${a.to ? "to " + str(a.to) + ": " : ""}${str(a.question)}`, 2_000);
+    const keys = Object.keys(a);
+    if (!keys.length)
+        return "";
+    return tidy(one(keys.map((k) => `${k}: ${typeof a[k] === "string" ? a[k] : JSON.stringify(a[k])}`).join(" · ")));
+}
+/** Text out of an MCP / Claude tool result: strings, [{type:"text", text}], {content:[…]}. */
+function resultText(v) {
+    if (v === undefined || v === null)
+        return "";
+    if (typeof v === "string")
+        return v;
+    if (Array.isArray(v))
+        return v
+            .map((x) => (typeof x === "string" ? x : x?.type === "text" || typeof x?.text === "string" ? str(x.text) : typeof x?.text?.text === "string" ? x.text.text : x?.type === "tool_reference" ? `(loaded ${toolName(str(x.tool_name))})` : x?.type === "image" ? "(an image)" : JSON.stringify(x)))
+            .join("\n");
+    if (typeof v === "object") {
+        const o = v;
+        if (o.content !== undefined)
+            return resultText(o.content);
+        if (o.text !== undefined)
+            return resultText(o.text);
+        if (o.output !== undefined)
+            return resultText(o.output);
+        return JSON.stringify(o, null, 1);
+    }
+    return String(v);
+}
+function json(line) {
+    const l = line.trim();
+    if (!l.startsWith("{"))
+        return undefined;
+    try {
+        return JSON.parse(l);
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Which CLI wrote this log, from its lines (the agent's id is only a hint: custom ids exist). */
+export function sniffFormat(lines, hint = "") {
+    let claude = 0;
+    let codex = 0;
+    let cursor = 0;
+    for (const l of lines.slice(0, 400)) {
+        const e = json(l);
+        if (!e || typeof e !== "object")
+            continue;
+        if (/^(thread\.started|turn\.(started|completed|failed)|item\.(started|updated|completed))$/.test(str(e.type)))
+            codex++;
+        else if (e.type === "tool_call" || (e.type === "thinking" && e.subtype) || e.model_call_id || e.timestamp_ms)
+            cursor++;
+        else if ((e.type === "assistant" || e.type === "user") && e.message && Array.isArray(e.message.content) && (e.message.id || e.parent_tool_use_id !== undefined || e.uuid))
+            claude++;
+        else if (e.type === "system" && e.subtype === "init" && Array.isArray(e.tools))
+            claude++;
+        else if (e.type === "assistant" || e.type === "user" || e.type === "result")
+            claude += 0.5;
+    }
+    const best = Math.max(claude, codex, cursor);
+    if (!best)
+        return "raw";
+    const h = hint.split("#")[0];
+    if (h === "cursor" && cursor === best)
+        return "cursor";
+    if (h === "codex" && codex === best)
+        return "codex";
+    return codex === best ? "codex" : cursor === best ? "cursor" : "claude";
+}
+/** Consecutive non-JSON lines (stderr, a banner) as one note. */
+function notes(lines, into) {
+    const t = lines.join("\n").trim();
+    if (t)
+        into.push({ kind: "note", text: cap(tidy(t), { chars: 1_000, lines: 15 }) });
+    lines.length = 0;
+}
+function parseClaude(lines) {
+    const turns = [];
+    const calls = new Map();
+    const loose = [];
+    for (const line of lines) {
+        const e = json(line);
+        if (!e) {
+            if (line.trim())
+                loose.push(line);
+            continue;
+        }
+        notes(loose, turns);
+        if (e.type === "assistant" && Array.isArray(e.message?.content)) {
+            for (const c of e.message.content) {
+                if (c?.type === "text" && str(c.text).trim())
+                    turns.push({ kind: "text", text: str(c.text).trim() });
+                else if (c?.type === "thinking" && str(c.thinking).trim())
+                    turns.push({ kind: "thinking", text: str(c.thinking).trim() });
+                else if (c?.type === "tool_use") {
+                    const name = toolName(str(c.name));
+                    const t = { kind: "tool", tool: name, text: "", input: summarizeInput(str(c.name), c.input) };
+                    // What it wrote: a Write's content, an Edit's change — trimmed like an output.
+                    const i = c.input ?? {};
+                    if (/^(Write|create_file)$/i.test(name) && typeof i.content === "string")
+                        t.output = cap(i.content);
+                    else if (/Edit$/i.test(name) && (typeof i.old_string === "string" || typeof i.new_string === "string"))
+                        t.output = cap(`${str(i.old_string).split("\n").map((l) => "- " + l).join("\n")}\n${str(i.new_string).split("\n").map((l) => "+ " + l).join("\n")}`);
+                    else if (/MultiEdit$/i.test(name) && Array.isArray(i.edits))
+                        t.output = cap(`${i.edits.length} edit(s)`);
+                    t.text = `${name}${t.input ? " " + t.input : ""}`;
+                    if (typeof i.description === "string" && i.description.trim())
+                        t.about = one(i.description, 200);
+                    turns.push(t);
+                    if (c.id)
+                        calls.set(str(c.id), t);
+                }
+            }
+        }
+        else if (e.type === "user" && e.message) {
+            const content = Array.isArray(e.message.content) ? e.message.content : [{ type: "text", text: str(e.message.content) }];
+            for (const c of content) {
+                if (c?.type === "tool_result") {
+                    const t = calls.get(str(c.tool_use_id));
+                    const out = tidy(resultText(c.content));
+                    const wrote = t?.output;
+                    if (t) {
+                        t.error = c.is_error === true || undefined;
+                        // A Write's result ("File created successfully…") says less than what it wrote.
+                        if (!wrote || t.error)
+                            t.output = cap(out);
+                    }
+                    else
+                        turns.push({ kind: "tool", tool: "?", text: "(result of an earlier call)", output: cap(out), ...(c.is_error ? { error: true } : {}) });
+                }
+                else if (c?.type === "text" && str(c.text).trim())
+                    turns.push({ kind: turns.length ? "note" : "prompt", text: cap(tidy(str(c.text)), { chars: PROMPT_MAX, lines: 80 }) });
+            }
+        }
+        else if (e.type === "result") {
+            const bits = [e.subtype && e.subtype !== "success" ? str(e.subtype) : "finished", e.duration_ms ? `${Math.round(Number(e.duration_ms) / 1000)}s` : "", e.num_turns ? `${e.num_turns} turns` : "", e.is_error ? "with an error" : ""];
+            turns.push({ kind: "end", text: bits.filter(Boolean).join(" · ") });
+        }
+        else if (e.type === "system" && e.subtype === "init") {
+            turns.push({ kind: "note", text: `session started${e.model ? " · " + str(e.model) : ""}` });
+        }
+        // hook_*, thinking_tokens, rate_limit_event, tool_progress: plumbing.
+    }
+    notes(loose, turns);
+    return turns;
+}
+function parseCodex(lines) {
+    const turns = [];
+    const loose = [];
+    for (const line of lines) {
+        const e = json(line);
+        if (!e) {
+            // "Reading additional input from stdin..." is codex reading its prompt: noise.
+            if (line.trim() && !/^Reading (additional )?(input|prompt) from stdin/i.test(line.trim()))
+                loose.push(line);
+            continue;
+        }
+        notes(loose, turns);
+        if (e.type === "item.completed" && e.item) {
+            const it = e.item;
+            switch (it.type) {
+                case "agent_message":
+                case "assistant_message":
+                    if (str(it.text).trim())
+                        turns.push({ kind: "text", text: str(it.text).trim() });
+                    break;
+                case "reasoning":
+                    if (str(it.text ?? it.summary).trim())
+                        turns.push({ kind: "thinking", text: resultText(it.text ?? it.summary).trim() });
+                    break;
+                case "command_execution": {
+                    const input = tidy(cap(str(it.command).replace(/^\/bin\/(?:ba|z)?sh -lc /, "").replace(/^(["'])([\s\S]*)\1$/, "$2"), { chars: 1_500, lines: 30 }));
+                    const code = it.exit_code;
+                    turns.push({ kind: "tool", tool: "shell", text: `shell ${input}`, input, output: cap(tidy(str(it.aggregated_output))) + (typeof code === "number" && code !== 0 ? `\n(exit ${code})` : ""), ...(typeof code === "number" && code !== 0 ? { error: true } : {}) });
+                    break;
+                }
+                case "mcp_tool_call": {
+                    const name = toolName(str(it.tool));
+                    const input = summarizeInput(name, it.arguments);
+                    const err = it.error ? resultText(it.error.message ?? it.error) : "";
+                    turns.push({ kind: "tool", tool: name, text: `${name}${input ? " " + input : ""}`, input, output: cap(tidy(err || resultText(it.result))), ...(err || it.status === "failed" ? { error: true } : {}) });
+                    break;
+                }
+                case "file_change": {
+                    const ch = Array.isArray(it.changes) ? it.changes : [];
+                    const input = ch.map((c) => `${str(c.kind) || "edit"} ${tidy(str(c.path))}`).join(", ");
+                    turns.push({ kind: "tool", tool: "edit", text: `edit ${input}`, input, ...(it.status === "failed" ? { error: true } : {}) });
+                    break;
+                }
+                case "web_search":
+                    turns.push({ kind: "tool", tool: "web_search", text: `web_search ${one(str(it.query))}`, input: one(str(it.query)) });
+                    break;
+                case "todo_list":
+                    turns.push({ kind: "note", text: `plan: ${(Array.isArray(it.items) ? it.items : []).map((x) => `${x.completed ? "✓" : "○"} ${str(x.text)}`).join(" · ")}` });
+                    break;
+                case "error":
+                    turns.push({ kind: "note", text: `error: ${str(it.message)}` });
+                    break;
+                default:
+                    turns.push({ kind: "note", text: `[${str(it.type)}] ${one(JSON.stringify(it), 400)}` });
+            }
+        }
+        else if (e.type === "turn.completed") {
+            const u = e.usage ?? {};
+            const tok = (Number(u.input_tokens) || 0) + (Number(u.output_tokens) || 0);
+            turns.push({ kind: "end", text: `turn finished${tok ? ` · ${tok.toLocaleString("en-US")} tokens` : ""}` });
+        }
+        else if (e.type === "turn.failed" || e.type === "error") {
+            turns.push({ kind: "note", text: `error: ${str(e.error?.message ?? e.message ?? e.error)}` });
+        }
+    }
+    notes(loose, turns);
+    return turns;
+}
+/** cursor-agent's tool_call: { <name>ToolCall: { args, result: { success | failure } } }. */
+function cursorTool(tc) {
+    const key = Object.keys(tc).find((k) => /ToolCall$/.test(k)) ?? Object.keys(tc)[0] ?? "tool";
+    const body = tc[key] ?? {};
+    const args = body.args ?? {};
+    let name = key.replace(/ToolCall$/, "");
+    let input;
+    if (name === "mcp") {
+        name = toolName(str(args.toolName ?? args.name));
+        input = summarizeInput(name, args.args);
+    }
+    else if (name === "shell")
+        input = tidy(cap(str(args.command), { chars: 1_500, lines: 30 }));
+    else if (name === "edit" || name === "write")
+        input = tidy(str(args.path));
+    else
+        input = summarizeInput(name, args);
+    const r = body.result ?? {};
+    const ok = r.success;
+    const bad = r.failure ?? r.error ?? r.rejected;
+    const res = ok ?? bad;
+    let output = "";
+    if (res && typeof res === "object") {
+        if (name === "shell")
+            output = [str(res.stdout), str(res.stderr)].filter((x) => x.trim()).join("\n") + (res.exitCode ? `\n(exit ${res.exitCode})` : "");
+        else if (name === "edit" || name === "write")
+            output = str(res.diffString) || str(res.message);
+        else if (name === "glob")
+            output = (Array.isArray(res.files) ? res.files : []).join("\n");
+        else if (name === "read")
+            output = str(res.content);
+        else
+            output = resultText(res);
+    }
+    else if (res !== undefined)
+        output = str(res);
+    const error = !!bad || (name === "shell" && Number(res?.exitCode) > 0) || ok?.isError === true;
+    return { kind: "tool", tool: name, text: `${name}${input ? " " + input : ""}`, input, output: cap(tidy(output)), ...(error ? { error: true } : {}) };
+}
+function parseCursor(lines) {
+    const turns = [];
+    const loose = [];
+    let thinking = "";
+    const flush = () => {
+        if (thinking.trim())
+            turns.push({ kind: "thinking", text: thinking.trim() });
+        thinking = "";
+    };
+    for (const line of lines) {
+        const e = json(line);
+        if (!e) {
+            if (line.trim())
+                loose.push(line);
+            continue;
+        }
+        notes(loose, turns);
+        const ts = Number(e.timestamp_ms) || undefined;
+        if (e.type === "thinking") {
+            if (e.subtype === "delta")
+                thinking += str(e.text);
+            else
+                flush();
+            continue;
+        }
+        flush();
+        if (e.type === "assistant") {
+            const text = resultText(e.message?.content).trim();
+            if (text)
+                turns.push({ kind: "text", text, ...(ts ? { ts } : {}) });
+        }
+        else if (e.type === "user") {
+            const text = resultText(e.message?.content).trim();
+            if (text)
+                turns.push({ kind: turns.some((t) => t.kind === "prompt") ? "note" : "prompt", text: cap(tidy(text), { chars: PROMPT_MAX, lines: 80 }) });
+        }
+        else if (e.type === "tool_call" && e.subtype === "completed" && e.tool_call) {
+            turns.push({ ...cursorTool(e.tool_call), ...(ts ? { ts } : {}) });
+        }
+        else if (e.type === "result") {
+            turns.push({ kind: "end", text: [e.is_error ? "finished with an error" : "finished", e.duration_ms ? `${Math.round(Number(e.duration_ms) / 1000)}s` : ""].filter(Boolean).join(" · ") });
+        }
+        else if (e.type === "system" && e.subtype === "init") {
+            turns.push({ kind: "note", text: `session started${e.model ? " · " + str(e.model) : ""}` });
+        }
+    }
+    flush();
+    notes(loose, turns);
+    return turns;
+}
+/** A log's text → turns. Unknown formats are kept as one raw block (capped). */
+export function parseLog(text, agentHint = "") {
+    const lines = text.split(/\r?\n/);
+    const format = sniffFormat(lines, agentHint);
+    try {
+        const turns = format === "claude" ? parseClaude(lines) : format === "codex" ? parseCodex(lines) : format === "cursor" ? parseCursor(lines) : [];
+        if (format !== "raw" && turns.length)
+            return { format, turns };
+    }
+    catch {
+        /* a shape we didn't expect: fall back to the raw text below */
+    }
+    const raw = text.trim();
+    return { format: "raw", turns: raw ? [{ kind: "note", text: cap(tidy(raw), { chars: RAW_MAX, lines: 4_000 }) }] : [] };
+}
+/** Read and parse one log file; null when it isn't there. */
+export function readLog(file, agentHint = "") {
+    let st;
+    try {
+        st = fs.statSync(file);
+    }
+    catch {
+        return null;
+    }
+    if (!st.isFile())
+        return null;
+    let text;
+    let partial = false;
+    if (st.size > READ_MAX) {
+        const fd = fs.openSync(file, "r");
+        try {
+            const buf = Buffer.alloc(READ_MAX);
+            const n = fs.readSync(fd, buf, 0, READ_MAX, 0);
+            text = buf.subarray(0, n).toString("utf8");
+            text = text.slice(0, text.lastIndexOf("\n") + 1);
+            partial = true;
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+    }
+    else
+        text = fs.readFileSync(file, "utf8");
+    const parsed = parseLog(text, agentHint);
+    if (partial)
+        parsed.turns.push({ kind: "note", text: `… the log is ${Math.round(st.size / 1024 / 1024)} MB; only its first ${READ_MAX / 1024 / 1024} MB are shown` });
+    return { ...parsed, bytes: st.size, ...(partial ? { partial } : {}) };
+}
+//# sourceMappingURL=transcript.js.map