@geteigen/cli 0.0.0-stage → 3.1.0

package/dist/shared/backends/cursor.js

@@ -0,0 +1,1216 @@
+const EMPTY_UNKNOWN = new Set(["", "[object Object]", "undefined", "null"]);
+function isEmptyUnknown(text) {
+    return EMPTY_UNKNOWN.has(text.trim());
+}
+/**
+ * Turn unknown thrown values / CLI payloads into a user-visible string.
+ * Never returns "[object Object]". Lives here so Next (extensionless) and
+ * Node ESM (`*.js`) both resolve it without a new shared module.
+ */
+export function stringifyUnknown(value, fallback = "", depth = 0) {
+    if (value == null)
+        return fallback;
+    if (depth > 4)
+        return fallback;
+    if (typeof value === "string") {
+        return isEmptyUnknown(value) ? fallback : value;
+    }
+    if (typeof value === "number" || typeof value === "boolean") {
+        return String(value);
+    }
+    if (typeof value === "bigint")
+        return value.toString();
+    if (value instanceof Error) {
+        const msg = value.message?.trim();
+        if (msg && !isEmptyUnknown(msg))
+            return msg;
+        const cause = value.cause;
+        if (cause !== undefined) {
+            const nested = stringifyUnknown(cause, "", depth + 1);
+            if (nested)
+                return nested;
+        }
+        return value.name || fallback;
+    }
+    if (Array.isArray(value)) {
+        const parts = value
+            .map((item) => stringifyUnknown(item, "", depth + 1))
+            .filter((part) => part && !isEmptyUnknown(part));
+        return parts.length ? parts.join("\n") : fallback;
+    }
+    if (typeof value === "object") {
+        const rec = value;
+        for (const key of [
+            "message",
+            "error",
+            "detail",
+            "description",
+            "reason",
+            "result",
+            "stderr",
+            "stdout",
+            "text",
+            "content",
+        ]) {
+            if (!(key in rec))
+                continue;
+            const inner = stringifyUnknown(rec[key], "", depth + 1);
+            if (inner && !isEmptyUnknown(inner))
+                return inner;
+        }
+        try {
+            const json = JSON.stringify(value);
+            if (json && json !== "{}" && json !== "[]" && !isEmptyUnknown(json)) {
+                return json.length > 800 ? `${json.slice(0, 800)}…` : json;
+            }
+        }
+        catch {
+            // circular / bigint
+        }
+    }
+    return fallback;
+}
+export function errorMessage(err, fallback = "Unknown error") {
+    const text = stringifyUnknown(err, "");
+    return text && !isEmptyUnknown(text) ? text : fallback;
+}
+const QUESTION_TOOL_RE = /^(askuserquestion|askfollowupquestion|askquestion|ask_user|ask_followup_question|ask_user_question|clarify|question|userinput|getinput)/i;
+/** Whether a tool name represents an agent asking the user clarifying questions. */
+export function isQuestionTool(name) {
+    return QUESTION_TOOL_RE.test(name.replace(/ToolCall$/i, ""));
+}
+function parseQuestionOption(opt) {
+    if (typeof opt === "string" && opt.trim())
+        return { label: opt.trim() };
+    if (!opt || typeof opt !== "object")
+        return null;
+    const o = opt;
+    const label = String(o.label ?? o.text ?? o.title ?? "").trim();
+    const description = typeof o.description === "string" ? o.description.trim() : undefined;
+    return label ? { label, description } : null;
+}
+/** Parse structured clarifying questions from a tool's args (Claude AskUserQuestion, etc). */
+export function parseQuestionToolArgs(args) {
+    if (!args || typeof args !== "object")
+        return [];
+    const raw = args;
+    if (Array.isArray(raw.questions)) {
+        const list = [];
+        for (let i = 0; i < raw.questions.length; i++) {
+            const q = raw.questions[i];
+            if (typeof q === "string" && q.trim()) {
+                list.push({ id: `q-${i + 1}`, question: q.trim() });
+            }
+            else if (q && typeof q === "object") {
+                const item = q;
+                const questionText = String(item.question ?? item.prompt ?? item.text ?? item.title ?? "").trim();
+                if (!questionText)
+                    continue;
+                const options = Array.isArray(item.options)
+                    ? item.options.map(parseQuestionOption).filter((o) => o !== null)
+                    : undefined;
+                list.push({
+                    id: String(item.id || `q-${i + 1}`),
+                    question: questionText,
+                    header: typeof item.header === "string" ? item.header.trim() : undefined,
+                    options: options && options.length ? options : undefined,
+                    multiSelect: Boolean(item.multiSelect),
+                });
+            }
+        }
+        if (list.length)
+            return list;
+    }
+    const singleText = String(raw.question ?? raw.prompt ?? raw.query ?? raw.message ?? "").trim();
+    if (singleText) {
+        const options = Array.isArray(raw.options)
+            ? raw.options.map(parseQuestionOption).filter((o) => o !== null)
+            : undefined;
+        return [
+            {
+                id: "q-1",
+                question: singleText,
+                header: typeof raw.header === "string" ? raw.header.trim() : undefined,
+                options: options && options.length ? options : undefined,
+                multiSelect: Boolean(raw.multiSelect),
+            },
+        ];
+    }
+    return [];
+}
+/**
+ * Merge a new assistant payload into the accumulated stream.
+ * Cursor `--stream-partial-output` may send either token deltas or a growing
+ * snapshot of the same message. Blind concatenation duplicates the paragraph;
+ * blindly replacing with a shorter payload truncates it.
+ */
+export function mergeAssistantText(prev, incoming) {
+    if (!incoming)
+        return prev;
+    if (!prev)
+        return incoming;
+    if (incoming === prev)
+        return prev;
+    if (incoming.startsWith(prev))
+        return incoming;
+    if (prev.startsWith(incoming))
+        return prev;
+    return prev + incoming;
+}
+const THINKING_PART_TYPES = new Set([
+    "thinking",
+    "reasoning",
+    "redacted_thinking",
+    "thinking_delta",
+    "reasoning_delta",
+]);
+function isThinkingPartType(type) {
+    return THINKING_PART_TYPES.has(type) || type.endsWith("thinking") || type.endsWith("reasoning");
+}
+/** Collapse hard wraps so thinking reads as prose, not one phrase per line. */
+export function normalizeThinkingText(text) {
+    return text
+        .replace(/\r\n/g, "\n")
+        .replace(/\s*\n+\s*/g, " ")
+        .replace(/[ \t]{2,}/g, " ");
+}
+/** Merge streamed thinking: snapshots replace, deltas append with a space. */
+export function mergeThinkingText(prev, incoming) {
+    if (!incoming)
+        return prev;
+    const chunk = normalizeThinkingText(incoming).trim();
+    if (!chunk)
+        return prev;
+    const base = normalizeThinkingText(prev).trim();
+    if (!base)
+        return chunk;
+    if (chunk === base)
+        return base;
+    if (chunk.startsWith(base))
+        return chunk;
+    if (base.startsWith(chunk))
+        return base;
+    return `${base} ${chunk}`;
+}
+/**
+ * Cursor CLI streams thinking as phrase-sized JSON lines that are not prefixes
+ * of each other. Always concatenate; a new thought starts only after tools
+ * (`afterTools` in RoomManager).
+ */
+export function advanceThinking(prev, incoming) {
+    return { current: mergeThinkingText(prev, incoming) };
+}
+function thinkingFromRecord(rec) {
+    for (const key of ["thinking", "reasoning", "text", "content"]) {
+        const value = rec[key];
+        if (typeof value === "string" && value.trim())
+            return value;
+    }
+    const summary = rec.summary;
+    if (Array.isArray(summary)) {
+        const parts = summary
+            .map((row) => {
+            if (typeof row === "string")
+                return row;
+            if (row && typeof row === "object") {
+                const item = row;
+                return typeof item.text === "string"
+                    ? item.text
+                    : typeof item.summary === "string"
+                        ? item.summary
+                        : "";
+            }
+            return "";
+        })
+            .filter((part) => part.trim());
+        if (parts.length)
+            return parts.join(" ");
+    }
+    return "";
+}
+/** Pull visible model thinking / reasoning out of a CLI or SDK payload. */
+export function extractThinkingText(source) {
+    if (!source || typeof source !== "object")
+        return "";
+    if (Array.isArray(source)) {
+        return source
+            .map((part) => extractThinkingText(part))
+            .filter(Boolean)
+            .join(" ");
+    }
+    const rec = source;
+    const type = String(rec.type ?? rec.kind ?? "").trim();
+    if (type === "text" || type === "output_text" || type === "tool_use" || type === "tool_result") {
+        return "";
+    }
+    if (rec.message !== undefined) {
+        const nested = extractThinkingText(rec.message);
+        if (nested)
+            return nested;
+    }
+    if (Array.isArray(rec.content)) {
+        const fromContent = extractThinkingText(rec.content);
+        if (fromContent)
+            return fromContent;
+    }
+    if (isThinkingPartType(type) || "thinking" in rec || "reasoning" in rec) {
+        return thinkingFromRecord(rec);
+    }
+    return "";
+}
+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")
+            return "";
+        const rec = part;
+        const type = String(rec.type ?? "");
+        if (isThinkingPartType(type) || "thinking" in rec)
+            return "";
+        if (type && type !== "text" && type !== "output_text")
+            return "";
+        if ("text" in rec)
+            return String(rec.text ?? "");
+        return "";
+    })
+        .join("");
+}
+function errorText(value) {
+    if (typeof value === "string")
+        return value.trim();
+    if (value && typeof value === "object") {
+        const rec = value;
+        for (const k of ["message", "reason", "error", "stderr"]) {
+            if (typeof rec[k] === "string" && String(rec[k]).trim())
+                return String(rec[k]).trim();
+        }
+    }
+    return "";
+}
+/**
+ * Failure message for a finished tool call, or null when it succeeded.
+ * Covers SDK `{status:"error", error}` results / call status, CLI
+ * `{failure}` / `{error}` / `{rejected}` results and MCP `isError` replies.
+ */
+export function toolResultError(result, callStatus) {
+    const r = result && typeof result === "object" ? result : null;
+    if (r) {
+        if (r.status === "error")
+            return errorText(r.error) || "Tool failed";
+        if (r.failure !== undefined)
+            return errorText(r.failure) || "Tool failed";
+        if (r.rejected !== undefined)
+            return errorText(r.rejected) || "Rejected";
+        if (r.error !== undefined && r.success === undefined)
+            return errorText(r.error) || "Tool failed";
+        const payload = unwrapToolResultPayload(r);
+        if (payload?.isError === true) {
+            return formatToolResultDetail("mcp", undefined, r, "Tool returned an error");
+        }
+    }
+    if (callStatus === "error")
+        return errorText(r?.error) || "Tool failed";
+    return null;
+}
+/** Readable start-of-call detail for tools whose args aren't a path/command. */
+export function structuredToolDetail(name, args) {
+    const tool = name.replace(/ToolCall$/i, "").toLowerCase();
+    if (tool === "mcp") {
+        // Card shows the call's own inputs (valid JSON → rendered as inputs).
+        const inner = coerceArgsObject(args.args) ?? {};
+        const payload = args.toolName === "call_tool" && inner.arguments && typeof inner.arguments === "object"
+            ? inner.arguments
+            : inner;
+        try {
+            const json = JSON.stringify(payload);
+            return json.length <= 4000 ? json : `${json.slice(0, 4000)}…`;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    if (tool === "readlints" && Array.isArray(args.paths)) {
+        const paths = args.paths.filter((p) => typeof p === "string");
+        return paths.length ? `Lints · ${paths.join(", ")}`.slice(0, 160) : "Lints · workspace";
+    }
+    return undefined;
+}
+/** Max chars of tool result text we persist into chat content. */
+export const TOOL_RESULT_DETAIL_LIMIT = 100_000;
+/** `$ command` plus its full stdout/stderr for the tool-call card. */
+export function formatToolTranscript(command, output) {
+    const cmd = (command || "").trim();
+    const out = (output || "").trim();
+    if (cmd && out && out !== cmd) {
+        if (out.startsWith(`$ ${cmd}`))
+            return out;
+        return `$ ${cmd}\n\n${out}`;
+    }
+    return out || cmd;
+}
+function commandFromArgs(args) {
+    if (!args)
+        return undefined;
+    if (typeof args.command === "string" && args.command.trim()) {
+        return args.command.trim();
+    }
+    return undefined;
+}
+function withCommandPrefix(args, body) {
+    return formatToolTranscript(commandFromArgs(args), body);
+}
+function finishResultDetail(args, body) {
+    return truncateDetail(withCommandPrefix(args, body));
+}
+/**
+ * Keep the start-time command/args when a tool_done only has the result,
+ * so the chat card can show input and output together.
+ */
+export function mergeToolStartAndResult(name, start, result) {
+    const startText = (start || "").trim();
+    const resultText = (result || "").trim();
+    if (!resultText)
+        return truncateDetail(startText);
+    if (!startText || resultText === startText)
+        return truncateDetail(resultText);
+    if (resultText.startsWith("$ "))
+        return truncateDetail(resultText);
+    try {
+        const parsed = JSON.parse(resultText);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            const rec = parsed;
+            if (rec.input != null ||
+                rec.command != null ||
+                rec.output != null ||
+                rec.stdout != null) {
+                return truncateDetail(resultText);
+            }
+        }
+    }
+    catch {
+        /* result is not JSON */
+    }
+    if (/bash|shell|exec|terminal/i.test(name)) {
+        return truncateDetail(formatToolTranscript(startText, resultText));
+    }
+    try {
+        const parsed = JSON.parse(startText);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return truncateDetail(JSON.stringify({ ...parsed, output: resultText }));
+        }
+    }
+    catch {
+        /* start is not JSON */
+    }
+    return truncateDetail(JSON.stringify({ input: startText, output: resultText }));
+}
+function toolInfo(toolCall) {
+    if (!toolCall)
+        return { name: "tool", detail: "" };
+    // Prefer explicit *ToolCall keys — Cursor sometimes also attaches metadata
+    // objects that would otherwise win Object.keys().find().
+    const toolCallKey = Object.keys(toolCall).find((k) => k.endsWith("ToolCall"));
+    const key = toolCallKey ||
+        Object.keys(toolCall).find((k) => ![
+            "hookAdditionalContexts",
+            "toolCallId",
+            "startedAtMs",
+            "completedAtMs",
+            "parentToolCallId",
+            "parent_tool_call_id",
+        ].includes(k) && typeof toolCall[k] === "object");
+    const name = key ? key.replace(/ToolCall$/, "") : "tool";
+    const body = key ? toolCall[key] : undefined;
+    const rawArgs = body?.args ?? body?.input ?? body?.parameters;
+    const args = coerceArgsObject(rawArgs);
+    const result = body?.result;
+    let detail = "";
+    let path;
+    if (args) {
+        for (const k of [
+            "path",
+            "filePath",
+            "file_path",
+            "target_file",
+            "targetFile",
+        ]) {
+            if (typeof args[k] === "string" && String(args[k]).trim()) {
+                path = String(args[k]).trim();
+                break;
+            }
+        }
+        // editToolCall.result.success.path is often the authoritative absolute path
+        const resultPath = pathFromToolResult(result);
+        if (!path && resultPath)
+            path = resultPath;
+        const todos = todosFromToolArgs(args);
+        if (isTodoTool(name) || todos.length > 0) {
+            detail = todos.length
+                ? `${todos.length} todo${todos.length === 1 ? "" : "s"} · ${todoStatusSummary(todos)}`
+                : "Updating todos";
+        }
+        else if (structuredToolDetail(name, args)) {
+            detail = structuredToolDetail(name, args);
+        }
+        else if (typeof args.description === "string" &&
+            String(args.description).trim()) {
+            detail = String(args.description).trim().slice(0, 160);
+        }
+        else {
+            detail =
+                String(args.command ??
+                    args.pattern ??
+                    args.globPattern ??
+                    args.glob_pattern ??
+                    args.query ??
+                    path ??
+                    args.targetDirectory ??
+                    args.prompt ??
+                    "") || JSON.stringify(args).slice(0, 120);
+        }
+    }
+    else {
+        const resultPath = pathFromToolResult(result);
+        if (resultPath)
+            path = resultPath;
+    }
+    const parentCallId = typeof toolCall.parentToolCallId === "string"
+        ? toolCall.parentToolCallId
+        : typeof toolCall.parent_tool_call_id === "string"
+            ? toolCall.parent_tool_call_id
+            : undefined;
+    return { name, detail, path, args, result, parentCallId };
+}
+/** Unwrap CLI `{success:{…}}` / SDK `{status,value}` / bare object result shapes. */
+export function unwrapToolResultPayload(result) {
+    if (!result || typeof result !== "object")
+        return null;
+    const r = result;
+    if (r.success && typeof r.success === "object") {
+        return r.success;
+    }
+    if (r.failure && typeof r.failure === "object") {
+        return r.failure;
+    }
+    if (r.error && typeof r.error === "object") {
+        return r.error;
+    }
+    if ((r.status === "success" || r.status === "error" || r.status === "failure") &&
+        r.value &&
+        typeof r.value === "object") {
+        return r.value;
+    }
+    return r;
+}
+function pathFromToolResult(result) {
+    const payload = unwrapToolResultPayload(result);
+    if (!payload)
+        return undefined;
+    for (const k of ["path", "filePath", "file_path", "target_file"]) {
+        if (typeof payload[k] === "string" && String(payload[k]).trim()) {
+            return String(payload[k]).trim();
+        }
+    }
+    return undefined;
+}
+function truncateDetail(text, limit = TOOL_RESULT_DETAIL_LIMIT) {
+    if (text.length <= limit)
+        return text;
+    return `${text.slice(0, limit)}\n…(truncated)`;
+}
+/**
+ * Human-readable tool output for chat. Prefers completed `result` payloads
+ * (stdout, file content, diff summary) over the start-time args summary.
+ */
+export function formatToolResultDetail(name, args, result, fallback = "") {
+    const payload = unwrapToolResultPayload(result);
+    if (payload) {
+        if (typeof payload.stdout === "string" || typeof payload.stderr === "string") {
+            const stdout = typeof payload.stdout === "string" ? payload.stdout : "";
+            const stderr = typeof payload.stderr === "string" ? payload.stderr : "";
+            const exit = typeof payload.exitCode === "number"
+                ? `exit ${payload.exitCode}`
+                : typeof payload.exit_code === "number"
+                    ? `exit ${payload.exit_code}`
+                    : "";
+            const parts = [stdout, stderr].filter((s) => s.trim().length > 0);
+            const body = parts.join(parts.length === 2 ? "\n--- stderr ---\n" : "");
+            if (body.trim()) {
+                return finishResultDetail(args, exit ? `${exit}\n${body}` : body);
+            }
+            if (exit)
+                return finishResultDetail(args, exit);
+        }
+        if (typeof payload.content === "string" && payload.content.length > 0) {
+            return finishResultDetail(args, payload.content);
+        }
+        if (typeof payload.resultForModel === "string" && payload.resultForModel.trim()) {
+            const linesAdded = typeof payload.linesAdded === "number" ? payload.linesAdded : undefined;
+            const linesRemoved = typeof payload.linesRemoved === "number" ? payload.linesRemoved : undefined;
+            const stats = linesAdded != null || linesRemoved != null
+                ? ` (+${linesAdded ?? 0}/-${linesRemoved ?? 0})`
+                : "";
+            return finishResultDetail(args, `${payload.resultForModel}${stats}`);
+        }
+        if (typeof payload.diffString === "string" && payload.diffString.trim()) {
+            const path = (typeof payload.path === "string" && payload.path) ||
+                (args && typeof args.path === "string" && args.path) ||
+                "file";
+            const linesAdded = typeof payload.linesAdded === "number" ? payload.linesAdded : undefined;
+            const linesRemoved = typeof payload.linesRemoved === "number" ? payload.linesRemoved : undefined;
+            if (linesAdded != null || linesRemoved != null) {
+                return `${path} (+${linesAdded ?? 0}/-${linesRemoved ?? 0})`;
+            }
+            return path;
+        }
+        if (typeof payload.errorMessage === "string" && payload.errorMessage.trim()) {
+            return finishResultDetail(args, payload.errorMessage);
+        }
+        if (Array.isArray(payload.content)) {
+            const text = payload.content
+                .map((item) => {
+                if (typeof item === "string")
+                    return item;
+                if (!item || typeof item !== "object")
+                    return "";
+                const o = item;
+                if (typeof o.text === "string")
+                    return o.text;
+                if (o.text && typeof o.text === "object") {
+                    const inner = o.text.text;
+                    if (typeof inner === "string")
+                        return inner;
+                }
+                if (typeof o.content === "string")
+                    return o.content;
+                return "";
+            })
+                .filter(Boolean)
+                .join("\n");
+            if (text.trim())
+                return finishResultDetail(args, text);
+        }
+        if (Array.isArray(payload.entries)) {
+            return finishResultDetail(args, payload.entries
+                .map((e) => (typeof e === "string" ? e : JSON.stringify(e)))
+                .join("\n"));
+        }
+        if (Array.isArray(payload.files)) {
+            return finishResultDetail(args, payload.files
+                .map((e) => (typeof e === "string" ? e : JSON.stringify(e)))
+                .join("\n"));
+        }
+        if (Array.isArray(payload.matches)) {
+            try {
+                return finishResultDetail(args, JSON.stringify(payload.matches, null, 2));
+            }
+            catch {
+                /* fall through */
+            }
+        }
+        if (typeof payload.linesCreated === "number") {
+            const path = (typeof payload.path === "string" && payload.path) ||
+                (args && typeof args.path === "string" && args.path) ||
+                "file";
+            return `${path} · ${payload.linesCreated} lines`;
+        }
+    }
+    if (typeof result === "string" && result.trim()) {
+        return finishResultDetail(args, result);
+    }
+    // Fall back to args summary (start-time detail) when result has no text.
+    if (args) {
+        const todos = todosFromToolArgs(args);
+        if (isTodoTool(name) || todos.length > 0) {
+            return todos.length
+                ? `${todos.length} todo${todos.length === 1 ? "" : "s"} · ${todoStatusSummary(todos)}`
+                : "Updating todos";
+        }
+    }
+    return fallback || "Done";
+}
+/**
+ * Pull a unified diff out of a completed tool `result` payload.
+ * Cursor editToolCall puts the real patch in `result.success.diffString`.
+ */
+export function diffFromToolResult(result, pathHint) {
+    const payload = unwrapToolResultPayload(result);
+    if (!payload)
+        return "";
+    const ready = (typeof payload.diffString === "string" && payload.diffString) ||
+        (typeof payload.diff === "string" && payload.diff) ||
+        (typeof payload.unifiedDiff === "string" && payload.unifiedDiff) ||
+        (typeof payload.unified_diff === "string" && payload.unified_diff) ||
+        (typeof payload.patch === "string" && payload.patch) ||
+        "";
+    if (ready && /diff --git|@@ /.test(ready)) {
+        return ready.trim();
+    }
+    // editToolCall often emits a short hunk without git headers — wrap it.
+    if (typeof payload.diffString === "string" && payload.diffString.trim()) {
+        const path = (typeof payload.path === "string" && payload.path) ||
+            pathHint ||
+            "file";
+        const body = payload.diffString.trim();
+        if (body.startsWith("diff --git") || body.includes("\n@@ ") || body.startsWith("@@ ")) {
+            if (body.startsWith("diff --git"))
+                return body;
+            return [
+                `diff --git a/${path} b/${path}`,
+                `--- a/${path}`,
+                `+++ b/${path}`,
+                body.startsWith("@@") ? body : `@@ -1,1 +1,1 @@\n${body}`,
+            ].join("\n");
+        }
+        // Line-oriented +/- dump without hunk header
+        if (/^[+-]/m.test(body) || body.includes("\n+") || body.includes("\n-")) {
+            const lines = body.split("\n");
+            return [
+                `diff --git a/${path} b/${path}`,
+                `--- a/${path}`,
+                `+++ b/${path}`,
+                `@@ -1,${lines.filter((l) => l.startsWith("-")).length || 0} +1,${lines.filter((l) => l.startsWith("+")).length || 0} @@`,
+                body,
+            ].join("\n");
+        }
+    }
+    const after = (typeof payload.afterFullFileContent === "string" &&
+        payload.afterFullFileContent) ||
+        (typeof payload.afterContent === "string" && payload.afterContent) ||
+        undefined;
+    if (typeof after === "string") {
+        const path = (typeof payload.path === "string" && payload.path) || pathHint || "file";
+        return buildUnifiedDiff(path, "", after);
+    }
+    return "";
+}
+function buildUnifiedDiff(filePath, before, after) {
+    const path = filePath.replace(/\\/g, "/").replace(/^\.\//, "") || "file";
+    if (before === after)
+        return "";
+    const oldLines = before.length
+        ? before.replace(/\n$/, "").split("\n")
+        : [];
+    const newLines = after.length ? after.replace(/\n$/, "").split("\n") : [];
+    const deleted = after.length === 0 && before.length > 0;
+    const created = before.length === 0 && after.length > 0;
+    const hunk = [
+        `@@ -${created ? 0 : 1},${oldLines.length} +${deleted ? 0 : 1},${newLines.length} @@`,
+    ];
+    for (const line of oldLines)
+        hunk.push(`-${line}`);
+    for (const line of newLines)
+        hunk.push(`+${line}`);
+    return [
+        `diff --git a/${path} b/${path}`,
+        deleted ? `deleted file mode 100644` : "",
+        created ? `new file mode 100644` : "",
+        created ? `--- /dev/null` : `--- a/${path}`,
+        deleted ? `+++ /dev/null` : `+++ b/${path}`,
+        ...hunk,
+    ]
+        .filter((l) => l !== "")
+        .join("\n");
+}
+export function diffFromToolArgs(toolName, args) {
+    if (!args)
+        return "";
+    const path = (typeof args.path === "string" && args.path) ||
+        (typeof args.file_path === "string" && args.file_path) ||
+        (typeof args.target_file === "string" && args.target_file) ||
+        (typeof args.filePath === "string" && args.filePath) ||
+        "file";
+    const name = toolName.replace(/ToolCall$/i, "").toLowerCase();
+    // Flat StrReplace / Edit args (Claude + older Cursor)
+    const oldStr = (typeof args.old_string === "string" && args.old_string) ||
+        (typeof args.oldString === "string" && args.oldString) ||
+        (typeof args.old_str === "string" && args.old_str) ||
+        (typeof args.OldString === "string" && args.OldString) ||
+        undefined;
+    const newStr = (typeof args.new_string === "string" && args.new_string) ||
+        (typeof args.newString === "string" && args.newString) ||
+        (typeof args.new_str === "string" && args.new_str) ||
+        (typeof args.NewString === "string" && args.NewString) ||
+        undefined;
+    if (typeof oldStr === "string" && typeof newStr === "string") {
+        return buildUnifiedDiff(path, oldStr, newStr);
+    }
+    // Cursor editToolCall nested strategies
+    const strReplace = args.strReplace && typeof args.strReplace === "object"
+        ? args.strReplace
+        : null;
+    if (strReplace) {
+        const oldText = (typeof strReplace.oldText === "string" && strReplace.oldText) ||
+            (typeof strReplace.old_string === "string" && strReplace.old_string) ||
+            undefined;
+        const newText = (typeof strReplace.newText === "string" && strReplace.newText) ||
+            (typeof strReplace.new_string === "string" && strReplace.new_string) ||
+            undefined;
+        if (typeof oldText === "string" && typeof newText === "string") {
+            return buildUnifiedDiff(path, oldText, newText);
+        }
+    }
+    const multi = args.multiStrReplace && typeof args.multiStrReplace === "object"
+        ? args.multiStrReplace
+        : null;
+    if (multi && Array.isArray(multi.edits)) {
+        const parts = [];
+        for (const edit of multi.edits) {
+            if (!edit || typeof edit !== "object")
+                continue;
+            const e = edit;
+            const o = (typeof e.oldText === "string" && e.oldText) ||
+                (typeof e.old_string === "string" && e.old_string) ||
+                undefined;
+            const n = (typeof e.newText === "string" && e.newText) ||
+                (typeof e.new_string === "string" && e.new_string) ||
+                undefined;
+            if (typeof o === "string" && typeof n === "string") {
+                const hunk = buildUnifiedDiff(path, o, n);
+                if (hunk)
+                    parts.push(hunk);
+            }
+        }
+        if (parts.length)
+            return parts.join("\n");
+    }
+    const applyPatch = args.applyPatch && typeof args.applyPatch === "object"
+        ? args.applyPatch
+        : null;
+    if (applyPatch) {
+        const patchContent = (typeof applyPatch.patchContent === "string" && applyPatch.patchContent) ||
+            (typeof applyPatch.patch === "string" && applyPatch.patch) ||
+            "";
+        if (patchContent && /diff --git|@@ /.test(patchContent)) {
+            return patchContent.trim();
+        }
+        if (patchContent.trim()) {
+            return [
+                `diff --git a/${path} b/${path}`,
+                `--- a/${path}`,
+                `+++ b/${path}`,
+                patchContent.trim().startsWith("@@")
+                    ? patchContent.trim()
+                    : `@@\n${patchContent.trim()}`,
+            ].join("\n");
+        }
+    }
+    // writeToolCall uses fileText (CLI) or contents/content
+    const contents = (typeof args.fileText === "string" && args.fileText) ||
+        (typeof args.file_text === "string" && args.file_text) ||
+        (typeof args.contents === "string" && args.contents) ||
+        (typeof args.content === "string" && args.content) ||
+        (typeof args.new_contents === "string" && args.new_contents) ||
+        (typeof args.newContents === "string" && args.newContents) ||
+        (typeof args.text === "string" && args.text) ||
+        undefined;
+    if (typeof contents === "string" &&
+        /^(write|create|updatefile|writefile|editnotebook)/i.test(name)) {
+        return buildUnifiedDiff(path, "", contents);
+    }
+    // Bare edit with only full contents (some agents)
+    if (typeof contents === "string" &&
+        name === "edit" &&
+        !strReplace &&
+        !multi &&
+        !applyPatch) {
+        return buildUnifiedDiff(path, "", contents);
+    }
+    if (typeof args.patch === "string" && /diff --git|@@ /.test(args.patch)) {
+        return args.patch.trim();
+    }
+    if (typeof args.unifiedDiff === "string" &&
+        /diff --git|@@ /.test(args.unifiedDiff)) {
+        return args.unifiedDiff.trim();
+    }
+    if (typeof args.unified_diff === "string" &&
+        /diff --git|@@ /.test(args.unified_diff)) {
+        return args.unified_diff.trim();
+    }
+    if (/^delete/i.test(name)) {
+        return buildUnifiedDiff(path, `/* deleted: ${path} */\n`, "");
+    }
+    return "";
+}
+/** Prefer result.diffString, then synthesize from args. */
+export function diffFromToolEvent(toolName, args, result) {
+    const fromResult = diffFromToolResult(result, args && typeof args.path === "string" ? args.path : undefined);
+    if (fromResult)
+        return fromResult;
+    return diffFromToolArgs(toolName, args);
+}
+const EDIT_TOOL_RE = /^(write|edit|strreplace|searchreplace|delete|applypatch|editnotebook|create|updatefile|deletefile|writefile)/i;
+const TODO_TOOL_RE = /^(todo|todowrite|todoread|updatetodos|write_todos|todo_write|todo_read)$/i;
+export function isEditTool(name) {
+    return EDIT_TOOL_RE.test(name.replace(/ToolCall$/i, ""));
+}
+export function isTodoTool(name) {
+    const n = name.replace(/ToolCall$/i, "");
+    return TODO_TOOL_RE.test(n) || /todo/i.test(n);
+}
+function normalizeTodoStatus(raw) {
+    let s = String(raw ?? "pending").toLowerCase().replace(/[\s-]/g, "_");
+    // Cursor CLI enums: TODO_STATUS_COMPLETED, TODO_STATUS_IN_PROGRESS, …
+    if (s.startsWith("todo_status_"))
+        s = s.slice("todo_status_".length);
+    if (s === "completed" || s === "complete" || s === "done")
+        return "completed";
+    if (s === "in_progress" || s === "inprogress" || s === "active")
+        return "in_progress";
+    if (s === "cancelled" || s === "canceled")
+        return "cancelled";
+    if (s === "pending" || s === "todo" || s === "not_started")
+        return "pending";
+    return "pending";
+}
+function coerceArgsObject(args) {
+    if (!args)
+        return undefined;
+    if (typeof args === "string") {
+        try {
+            const parsed = JSON.parse(args);
+            if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                return parsed;
+            }
+            if (Array.isArray(parsed))
+                return { todos: parsed };
+        }
+        catch {
+            return undefined;
+        }
+        return undefined;
+    }
+    if (typeof args === "object" && !Array.isArray(args)) {
+        return args;
+    }
+    if (Array.isArray(args))
+        return { todos: args };
+    return undefined;
+}
+export function todosFromToolArgs(args) {
+    const o = coerceArgsObject(args);
+    if (!o)
+        return [];
+    const raw = (Array.isArray(o.todos) && o.todos) ||
+        (Array.isArray(o.items) && o.items) ||
+        (Array.isArray(o.todo_list) && o.todo_list) ||
+        null;
+    if (!raw)
+        return [];
+    const out = [];
+    for (let i = 0; i < raw.length; i++) {
+        const item = raw[i];
+        if (!item || typeof item !== "object")
+            continue;
+        const t = item;
+        const content = String(t.content ?? t.text ?? t.title ?? t.description ?? "").trim();
+        if (!content)
+            continue;
+        out.push({
+            id: String(t.id ?? `todo-${i + 1}`),
+            content,
+            status: normalizeTodoStatus(t.status),
+        });
+    }
+    return out;
+}
+/**
+ * Recover structured todos from a chat message — prefers `message.todos`,
+ * then parses JSON tool args that older servers stored as `content`.
+ */
+export function resolveMessageTodos(message) {
+    if (message.todos && message.todos.length > 0)
+        return message.todos;
+    const content = message.content?.trim() ?? "";
+    if (!content)
+        return [];
+    if (content.startsWith("{") ||
+        content.startsWith("[") ||
+        content.includes('"todos"')) {
+        const parsed = todosFromToolArgs(content);
+        if (parsed.length)
+            return parsed;
+        // Truncated JSON from older servers (JSON.stringify(args).slice(0, N)).
+        return todosFromTruncatedContent(content);
+    }
+    return [];
+}
+/** Whether a chat tool message should render as the Todos card. */
+export function messageHasTodos(message) {
+    if (message.todos && message.todos.length > 0)
+        return true;
+    if (message.toolName && isTodoTool(message.toolName))
+        return true;
+    const content = message.content?.trim() ?? "";
+    if (!content)
+        return false;
+    return ((content.startsWith("{") || content.startsWith("[")) &&
+        /"todos"\s*:/.test(content));
+}
+/**
+ * Keep only the latest todos card per agent so successive TodoWrite updates
+ * (2 → 3 → 4 items) don't stack as separate groups in the timeline.
+ */
+export function coalesceTodoMessages(messages) {
+    const latestIdByAgent = new Map();
+    for (const msg of messages) {
+        if (msg.role !== "tool" || !messageHasTodos(msg))
+            continue;
+        latestIdByAgent.set(msg.agentId || "__default__", msg.id);
+    }
+    if (latestIdByAgent.size === 0)
+        return messages;
+    return messages.filter((msg) => {
+        if (msg.role !== "tool" || !messageHasTodos(msg))
+            return true;
+        return latestIdByAgent.get(msg.agentId || "__default__") === msg.id;
+    });
+}
+/** Best-effort extraction when content is a sliced JSON blob. */
+function todosFromTruncatedContent(content) {
+    if (!/"content"\s*:/.test(content))
+        return [];
+    const out = [];
+    const re = /\{\s*"id"\s*:\s*"((?:\\.|[^"\\])*)"\s*,\s*"content"\s*:\s*"((?:\\.|[^"\\])*)"\s*,\s*"status"\s*:\s*"((?:\\.|[^"\\])*)"/g;
+    let m;
+    let i = 0;
+    while ((m = re.exec(content)) !== null) {
+        i += 1;
+        const todoContent = m[2].replace(/\\"/g, '"').replace(/\\\\/g, "\\").trim();
+        if (!todoContent)
+            continue;
+        out.push({
+            id: m[1] || `todo-${i}`,
+            content: todoContent,
+            status: normalizeTodoStatus(m[3]),
+        });
+    }
+    if (out.length)
+        return out;
+    // Looser: pull content fields even if id/status order differs or was cut off.
+    const contentRe = /"content"\s*:\s*"((?:\\.|[^"\\])*)"/g;
+    while ((m = contentRe.exec(content)) !== null) {
+        i += 1;
+        const todoContent = m[1].replace(/\\"/g, '"').replace(/\\\\/g, "\\").trim();
+        if (!todoContent)
+            continue;
+        out.push({
+            id: `todo-${i}`,
+            content: todoContent,
+            status: "pending",
+        });
+    }
+    return out;
+}
+export function todoStatusSummary(todos) {
+    const completed = todos.filter((t) => t.status === "completed").length;
+    const active = todos.filter((t) => t.status === "in_progress").length;
+    const pending = todos.filter((t) => t.status === "pending").length;
+    const parts = [];
+    if (active)
+        parts.push(`${active} in progress`);
+    if (completed)
+        parts.push(`${completed} done`);
+    if (pending)
+        parts.push(`${pending} pending`);
+    return parts.join(" · ") || "updated";
+}
+/**
+ * Cursor CLI headless agent backend.
+ * Spawns: `cursor agent --print --output-format stream-json ...`
+ */
+export class CursorAgentBackend {
+    kind = "cursor";
+    available = true;
+    command = "cursor";
+    buildArgs(opts) {
+        const args = [
+            "agent",
+            "--print",
+            "--output-format",
+            "stream-json",
+            "--stream-partial-output",
+            "--force",
+            "--trust",
+        ];
+        if (opts.mode === "plan") {
+            args.push("--mode", "plan");
+        }
+        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) {
+            // Cursor CLI reads MCP servers from `.cursor/mcp.json`, not a flag.
+            // `--approve-mcps` skips the headless approval prompt for those servers.
+            args.push("--approve-mcps");
+        }
+        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) });
+            return out;
+        }
+        if (type === "thinking" ||
+            type === "reasoning" ||
+            type === "thinkingMessage" ||
+            type === "reasoningMessage") {
+            if (ctx.toolsOnly)
+                return out;
+            const text = extractThinkingText(ev) ||
+                (typeof ev.text === "string" ? ev.text : "") ||
+                (typeof ev.thinking === "string" ? ev.thinking : "");
+            if (!text)
+                return out;
+            ctx.thinkingBuf ??= { value: "" };
+            const step = advanceThinking(ctx.thinkingBuf.value, text);
+            if (step.finalize) {
+                out.push({ kind: "thinking_final", text: step.finalize });
+            }
+            if (step.current === ctx.thinkingBuf.value && !step.finalize)
+                return out;
+            ctx.thinkingBuf.value = step.current;
+            const done = ev.subtype === "completed";
+            out.push({
+                kind: done ? "thinking_final" : "thinking_delta",
+                text: step.current,
+            });
+            if (done)
+                ctx.thinkingBuf.value = "";
+            return out;
+        }
+        if (type === "assistant") {
+            if (!ctx.toolsOnly) {
+                const thinking = extractThinkingText(ev.message ?? ev);
+                if (thinking) {
+                    ctx.thinkingBuf ??= { value: "" };
+                    const step = advanceThinking(ctx.thinkingBuf.value, thinking);
+                    if (step.finalize) {
+                        out.push({ kind: "thinking_final", text: step.finalize });
+                    }
+                    if (step.current !== ctx.thinkingBuf.value || step.finalize) {
+                        ctx.thinkingBuf.value = step.current;
+                        const done = !("timestamp_ms" in ev);
+                        out.push({
+                            kind: done ? "thinking_final" : "thinking_delta",
+                            text: step.current,
+                        });
+                        if (done)
+                            ctx.thinkingBuf.value = "";
+                    }
+                }
+            }
+            const text = extractText(ev.message);
+            if (!text)
+                return out;
+            const merged = mergeAssistantText(ctx.assistantBuf.value, text);
+            ctx.assistantBuf.value = merged;
+            if ("timestamp_ms" in ev) {
+                out.push({
+                    kind: "assistant_delta",
+                    text: merged,
+                });
+            }
+            else {
+                out.push({ kind: "assistant_final", text: merged });
+            }
+            return out;
+        }
+        if (type === "tool_call") {
+            const callId = String(ev.call_id ?? "");
+            const info = toolInfo(ev.tool_call);
+            const todos = info.args ? todosFromToolArgs(info.args) : [];
+            const todoTool = isTodoTool(info.name) || todos.length > 0;
+            const questions = info.args ? parseQuestionToolArgs(info.args) : [];
+            const questionTool = isQuestionTool(info.name) || questions.length > 0;
+            const toolName = todoTool && !isTodoTool(info.name)
+                ? "todo"
+                : questionTool && !isQuestionTool(info.name)
+                    ? "AskUserQuestion"
+                    : /^task$/i.test(info.name)
+                        ? "Task"
+                        : info.name;
+            // Nested Task/subagent tools (parentToolCallId) still become first-class
+            // chat cards so cloud/local Cursor subagent work is visible.
+            if (ev.subtype === "started") {
+                ctx.thinkingBuf = { value: "" };
+                out.push({
+                    kind: "tool_start",
+                    callId,
+                    name: toolName,
+                    detail: info.detail || toolName,
+                    path: info.path,
+                    todos: todos.length ? todos : undefined,
+                    questions: questions.length ? questions : undefined,
+                });
+            }
+            else if (ev.subtype === "completed") {
+                const path = info.path || pathFromToolResult(info.result);
+                const failure = toolResultError(info.result);
+                const detail = failure ??
+                    formatToolResultDetail(info.name, info.args, info.result, info.detail || path || "Done");
+                const fromResult = !todoTool
+                    ? diffFromToolResult(info.result, path)
+                    : "";
+                const diffPatch = fromResult ||
+                    (!todoTool && isEditTool(info.name)
+                        ? diffFromToolArgs(info.name, info.args)
+                        : "") ||
+                    undefined;
+                out.push({
+                    kind: "tool_done",
+                    callId,
+                    name: toolName,
+                    detail,
+                    path,
+                    ...(failure ? { isError: true } : {}),
+                    diffPatch: failure ? undefined : diffPatch || undefined,
+                    todos: todos.length ? todos : undefined,
+                    questions: questions.length ? questions : undefined,
+                });
+            }
+            return out;
+        }
+        if (type === "result") {
+            ctx.gotTerminalEvent.value = true;
+            if (ev.session_id) {
+                out.push({ kind: "session", sessionId: String(ev.session_id) });
+            }
+            if (ev.is_error) {
+                const msg = stringifyUnknown(ev.result) ||
+                    stringifyUnknown(ev.errors) ||
+                    stringifyUnknown(ev.error) ||
+                    ctx.stderr ||
+                    "Agent error";
+                out.push({ kind: "error", message: msg });
+            }
+            else {
+                out.push({
+                    kind: "done",
+                    result: stringifyUnknown(ev.result) || ctx.assistantBuf.value || "",
+                });
+            }
+        }
+        return out;
+    }
+}
+export const cursorAgentBackend = new CursorAgentBackend();