@sortedyuan/maybecode 0.3.2 → 0.5.0

package/dist/tui.js

@@ -1,1109 +0,0 @@
-import { userInfo } from "node:os";
-import { sanitizeTerminalText, TerminalImages, encodeImage, workspaceGitLabel } from "@sortedyuan/tui";
-import { createMaybeCodeSlashCommandSuggester, executeMaybeCodeSlashCommand, formatMaybeCodeMcpStatus, parseMaybeCodeSlashCommand, } from "./slash-commands.js";
-import { createNodeTerminal } from "@sortedyuan/tui/node-terminal";
-import { runModelPicker } from "./model-picker.js";
-import { runSessionPicker } from "./session-picker.js";
-import { runForkPicker, runChangesPicker } from "./fork-picker.js";
-import { presentMcpInteraction } from "./mcp-interaction-ui.js";
-import { MaybeCodeTerminalWeb } from "./terminal-web.js";
-import { formatGoal } from "./goal-commands.js";
-import { renderDelegationTask } from "./delegation-commands.js";
-export async function runTerminalUI(app, options = {}) {
-    const terminal = options.terminal ?? createNodeTerminal();
-    terminal.imageSupport?.query();
-    await terminal.imageSupport?.ready();
-    let terminalClosed = false;
-    const closeTerminal = () => {
-        if (terminalClosed)
-            return;
-        terminalClosed = true;
-        terminal.close();
-    };
-    const renderer = new TerminalRenderer(terminal);
-    const slashCommandSuggestions = createMaybeCodeSlashCommandSuggester(app);
-    let activeQuestion;
-    let inputQuestionController;
-    let inputContinuation = false;
-    let gitLabel = "";
-    let interactionDone = Promise.resolve();
-    const pendingRuns = new Set();
-    const observeRun = (result) => {
-        const pending = result.then(() => undefined, error => {
-            if (!terminalClosed && !isCancellation(error))
-                terminal.write(`\nError: ${sanitizeTerminalText(errorMessage(error))}\n`);
-        }).finally(() => pendingRuns.delete(pending));
-        pendingRuns.add(pending);
-    };
-    let exit = false;
-    const handleProcessSignal = () => {
-        exit = true;
-        if (app.isRunning)
-            app.cancel("Interrupted by process signal");
-        activeQuestion?.abort();
-        closeTerminal();
-    };
-    process.on("SIGINT", handleProcessSignal);
-    process.on("SIGTERM", handleProcessSignal);
-    const question = async (prompt, questionOptions = {}) => {
-        inputQuestionController?.abort();
-        const previousInteraction = interactionDone;
-        let release;
-        interactionDone = new Promise(resolve => { release = resolve; });
-        const controller = new AbortController();
-        activeQuestion = controller;
-        try {
-            await previousInteraction;
-            return await terminal.question(prompt, {
-                ...questionOptions,
-                signal: questionOptions.signal === undefined ? controller.signal : AbortSignal.any([controller.signal, questionOptions.signal]),
-            });
-        }
-        finally {
-            release();
-            if (activeQuestion === controller)
-                activeQuestion = undefined;
-        }
-    };
-    const inputQuestion = async (prompt, questionOptions = {}) => {
-        await interactionDone;
-        const controller = new AbortController();
-        inputQuestionController = controller;
-        inputContinuation = prompt.endsWith("... ");
-        activeQuestion = controller;
-        try {
-            return await terminal.question(prompt, { ...questionOptions, signal: controller.signal });
-        }
-        finally {
-            if (activeQuestion === controller)
-                activeQuestion = undefined;
-            if (inputQuestionController === controller)
-                inputQuestionController = undefined;
-        }
-    };
-    const removeInterrupt = terminal.onInterrupt?.(() => {
-        if (app.isRunning) {
-            terminal.write("\nCancelling current operation...\n");
-            app.cancel("Interrupted");
-            activeQuestion?.abort();
-        }
-        else {
-            exit = true;
-            activeQuestion?.abort();
-        }
-    });
-    const web = new MaybeCodeTerminalWeb(app, handleProcessSignal);
-    const eventTask = consumeEvents(app, renderer, question, web.events, () => {
-        if (inputQuestionController !== undefined)
-            terminal.updatePrompt?.(inputPrompt(app.permissionMode === "yolo", inputContinuation, gitLabel));
-    });
-    const refreshWorkspace = async () => {
-        if (!app.getWorkspaceGit || terminalClosed)
-            return;
-        try {
-            gitLabel = workspaceGitLabel(await app.getWorkspaceGit());
-        }
-        catch (error) {
-            gitLabel = `Git 错误：${sanitizeTerminalText(errorMessage(error))}`;
-        }
-        if (inputQuestionController)
-            terminal.updatePrompt?.(inputPrompt(app.permissionMode === "yolo", inputContinuation, gitLabel));
-    };
-    await refreshWorkspace();
-    let refreshingWorkspace = false;
-    const workspaceTimer = app.getWorkspaceGit ? setInterval(() => {
-        if (refreshingWorkspace || terminalClosed)
-            return;
-        refreshingWorkspace = true;
-        void refreshWorkspace().finally(() => { refreshingWorkspace = false; });
-    }, 2_000) : undefined;
-    terminal.write(sanitizeTerminalText(`MaybeCode\nWorkspace: ${app.workspace}\n` +
-        `Model: ${modelLabel(app)}\n` +
-        (app.permissionMode === "yolo" ? "YOLO · Auto-approve\n" : "") +
-        `${renderInstructionSources(app)}` +
-        "Type /help for commands. End a line with \\ for multiline input.\n"));
-    try {
-        while (!exit) {
-            let input;
-            try {
-                input = await readInput(inputQuestion, slashCommandSuggestions, () => app.permissionMode === "yolo", () => gitLabel);
-            }
-            catch (error) {
-                if (isAbortError(error)) {
-                    if (exit)
-                        break;
-                    continue;
-                }
-                throw error;
-            }
-            if (input === "")
-                continue;
-            terminal.addHistory?.(input);
-            if (input.startsWith("/")) {
-                try {
-                    exit = await handleCommand(input, app, terminal, question, web, observeRun);
-                }
-                catch (error) {
-                    if (!isCancellation(error) && !isAbortError(error)) {
-                        terminal.write(`\nError: ${sanitizeTerminalText(errorMessage(error))}\n`);
-                    }
-                }
-                continue;
-            }
-            try {
-                const run = await app.submit({ input });
-                observeRun(run.result);
-            }
-            catch (error) {
-                if (!isCancellation(error)) {
-                    terminal.write(`\nError: ${sanitizeTerminalText(errorMessage(error))}\n`);
-                }
-            }
-        }
-    }
-    finally {
-        process.removeListener("SIGINT", handleProcessSignal);
-        if (workspaceTimer)
-            clearInterval(workspaceTimer);
-        process.removeListener("SIGTERM", handleProcessSignal);
-        activeQuestion?.abort();
-        removeInterrupt?.();
-        // Restore readline/raw terminal state before potentially slow application
-        // cancellation and event-drain work.
-        closeTerminal();
-        await web.close();
-        await Promise.all(pendingRuns);
-        await eventTask;
-    }
-}
-async function consumeEvents(app, renderer, question, events, permissionModeChanged) {
-    const pending = new Map();
-    let lastGoalDisplay = "";
-    let prompts = Promise.resolve();
-    const enqueue = (id, work, expiresAt) => {
-        const controller = new AbortController();
-        pending.set(id, controller);
-        const signal = expiresAt === undefined ? controller.signal : AbortSignal.any([controller.signal, AbortSignal.timeout(Math.max(0, Math.ceil(expiresAt - Date.now())))]);
-        prompts = prompts.then(async () => { if (!signal.aborted)
-            await work(signal); }).catch(() => {
-            if (!signal.aborted) {
-                renderer.write("\nInteraction could not be completed.\n");
-                app.cancel("User interaction is unavailable");
-            }
-        }).finally(() => pending.delete(id));
-    };
-    for await (const event of events) {
-        if (event.type === "goal.changed") {
-            const display = `${event.goal.id}:${event.goal.status}:${event.goal.progress}`;
-            if (display !== lastGoalDisplay) {
-                lastGoalDisplay = display;
-                renderer.write(`\n${sanitizeTerminalText(formatGoal(event.goal))}\n`);
-            }
-        }
-        else if (event.type === "permission-mode.changed") {
-            permissionModeChanged();
-            renderer.write(event.mode === "yolo" ? "\nYOLO enabled\n" : "\nYOLO disabled\n");
-        }
-        else if (event.type === "run.event") {
-            await renderer.runEvent(event.event);
-        }
-        else if (event.type === "permission.event") {
-            if (event.event.type === "approval.requested") {
-                enqueue(`approval:${event.event.request.id}`, (signal) => handlePermissionEvent(event.event, app, renderer, (prompt, options) => question(prompt, { ...options, signal })));
-            }
-            else {
-                if (event.event.type === "approval.resolved" || event.event.type === "approval.cancelled")
-                    pending.get(`approval:${event.event.requestId}`)?.abort();
-                renderer.permissionEvent(event.event);
-            }
-        }
-        else if (event.type === "mcp.interaction.requested") {
-            enqueue(event.request.id, (signal) => presentMcpInteraction(event.request, app, (prompt, signal) => question(prompt, { history: false, signal }), signal), event.request.expiresAt);
-        }
-        else if (event.type === "mcp.interaction.settled") {
-            pending.get(event.requestId)?.abort();
-        }
-        else if (event.type === "change.preview") {
-            renderer.changePreview(event);
-        }
-        else if (event.type === "context.compacted") {
-            renderer.contextCompacted(event);
-        }
-        else if (event.type === "context.compaction.failed") {
-            renderer.contextCompactionFailed(event);
-        }
-        else if (event.type === "model.changed") {
-            renderer.modelChanged(event.model);
-        }
-        else if (event.type === "model.default.changed") {
-            renderer.defaultModelChanged(event.profile);
-        }
-        else if (event.type === "delegation.started" ||
-            event.type === "delegation.finished") {
-            renderer.delegationLifecycle(event, app.delegationNotifications === true);
-        }
-        else if (event.type === "delegation.event") {
-            const inner = event.event;
-            if (inner.type === "permission.event") {
-                if (inner.event.type === "approval.requested") {
-                    enqueue(`approval:${inner.event.request.id}`, (signal) => handlePermissionEvent(inner.event, app, renderer, (prompt, options) => question(prompt, { ...options, signal })));
-                }
-                else {
-                    if (inner.event.type === "approval.resolved" || inner.event.type === "approval.cancelled") {
-                        pending.get(`approval:${inner.event.requestId}`)?.abort();
-                    }
-                    renderer.permissionEvent(inner.event);
-                }
-            }
-            else {
-                await renderer.delegationEvent(event);
-            }
-        }
-        else if (event.type === "delegation.updated") {
-            renderer.delegationState(event.state, app.delegationNotifications === true);
-        }
-        else if (event.type === "mcp.resource.updated" ||
-            event.type === "mcp.resource.watch-closed" ||
-            event.type === "mcp.server.connected" ||
-            event.type === "mcp.server.catalog-updated" ||
-            event.type === "mcp.server.failed" ||
-            event.type === "mcp.server.disconnected") {
-            renderer.mcpEvent(event);
-        }
-        else if (event.type === "workspace.git.changed") {
-            if (event.checkpoint.error)
-                renderer.write(`\nGit checkpoint：${sanitizeTerminalText(event.checkpoint.error)}\n`);
-        }
-        else if (event.type === "session.changed") {
-            await renderer.sessionChanged(event, app);
-        }
-    }
-    for (const controller of pending.values())
-        controller.abort();
-    await prompts;
-}
-async function handlePermissionEvent(event, app, renderer, question) {
-    if (event.type !== "approval.requested") {
-        renderer.permissionEvent(event);
-        return;
-    }
-    renderer.approvalRequest(event.request);
-    while (true) {
-        const choices = event.request.grantKey === undefined
-            ? "[a]llow once / [d]eny"
-            : permissionChoices(event.request.tool.name) + (event.request.persistent ? ` / [p]ersistent (${event.request.persistent.description})` : "");
-        let answer;
-        try {
-            answer = (await question(`${choices}: `, { history: false }))
-                .trim()
-                .toLowerCase();
-        }
-        catch (error) {
-            if (isAbortError(error))
-                return;
-            throw error;
-        }
-        const decision = answer === "a" || answer === "allow" || answer === "y"
-            ? "allow"
-            : answer === "d" || answer === "deny" || answer === "n"
-                ? "deny"
-                : answer === "s" || answer === "session"
-                    ? "allow-session"
-                    : answer === "p" || answer === "persistent"
-                        ? "allow-persistent"
-                        : undefined;
-        if (decision === undefined) {
-            renderer.write(event.request.persistent ? "请输入 a、s、p 或 d。\n" : "请输入 a、s 或 d。\n");
-            continue;
-        }
-        if (decision === "allow-session" && event.request.grantKey === undefined) {
-            renderer.write("This request cannot be granted for the session.\n");
-            continue;
-        }
-        if (decision === "allow-persistent" && !event.request.persistent) {
-            renderer.write("此请求没有可保存的授权范围。\n");
-            continue;
-        }
-        await app.resolveApproval(event.request.id, decision, decision === "allow-persistent" ? { createdBy: `local:${userInfo().username}` } : undefined);
-        return;
-    }
-}
-async function handleCommand(input, app, terminal, question, web, observeRun) {
-    const parsed = parseMaybeCodeSlashCommand(input);
-    if (parsed.type === "command" &&
-        parsed.definition.name === "/retry" &&
-        parsed.arguments.length === 0) {
-        terminal.write("\nRetrying the latest failed run...\n");
-    }
-    if (parsed.type === "command" &&
-        parsed.definition.name === "/compact" &&
-        parsed.arguments.length === 0) {
-        terminal.write("\nPruning old tool results and summarizing context...\n");
-    }
-    const result = await executeMaybeCodeSlashCommand(input, app);
-    if (result.type === "web.requested") {
-        terminal.write(`\nWeb UI 已打开：${await web.open()}\n`);
-        return false;
-    }
-    return renderSlashCommandResult(result, app, terminal, question, observeRun);
-}
-async function renderSlashCommandResult(result, app, terminal, question, observeRun) {
-    switch (result.type) {
-        case "exit":
-            return true;
-        case "help":
-            terminal.write(`\n${renderSlashCommandHelp(result.commands)}`);
-            break;
-        case "instructions":
-            terminal.write(sanitizeTerminalText(`\n${renderInstructionSources(app)}` +
-                `Effective instructions:\n---\n${result.instructions.effective}\n---\n`));
-            break;
-        case "mcp.run-started":
-        case "skill.run-started":
-        case "retry.started":
-            observeRun(result.run.result);
-            break;
-        case "status":
-            terminal.write(`\n${renderStatus(app, result.inspection)}`);
-            break;
-        case "display":
-        case "mcp.display":
-            terminal.write(`\n${sanitizeTerminalText(result.text)}\n`);
-            break;
-        case "mcp.status":
-            terminal.write(`\n${sanitizeTerminalText(formatMaybeCodeMcpStatus(result.servers))}\n`);
-            break;
-        case "context":
-            terminal.write(result.inspection === undefined
-                ? "\nContext inspection is not supported by the active context.\n"
-                : `\n${renderContextInspection(result.inspection)}`);
-            break;
-        case "compacted":
-            terminal.write(`\n${renderCompactionResult(result.result)}`);
-            break;
-        case "session.created":
-            terminal.write(`\nCreated session ${result.sessionId}\n`);
-            break;
-        case "session.selection.requested": {
-            const selection = await runSessionPicker({
-                controller: app,
-                terminal,
-                sessions: result.sessions,
-                question: (prompt) => question(prompt, { history: false }),
-            });
-            if (selection.type === "empty") {
-                terminal.write("\nNo sessions found for this workspace.\n");
-            }
-            else if (selection.type === "resume") {
-                await app.resumeSession(selection.sessionId);
-                terminal.write(`\nResumed session ${selection.sessionId}\n`);
-            }
-            break;
-        }
-        case "fork.selection.requested": {
-            const selection = await runForkPicker({ points: result.points, currentSessionId: app.sessionId, terminal, question: prompt => question(prompt, { history: false }) });
-            if (selection) {
-                if (!app.forkSession)
-                    throw new Error("Session 分支能力不可用。");
-                const id = await app.forkSession(selection.pointId, selection.mode);
-                terminal.write(sanitizeTerminalText(`\nSession 分支已创建：${id}\n`));
-            }
-            break;
-        }
-        case "changes.selection.requested":
-            await runChangesPicker(terminal, result.diff, app);
-            break;
-        case "worktrees.display":
-            terminal.write(sanitizeTerminalText(`\n${result.worktrees.length ? result.worktrees.map(item => `${item.id}\n${item.path}\n${item.branch} · ${item.status} · ${item.commit.slice(0, 12)}`).join("\n\n") : "没有已登记的 worktree。"}\n`));
-            break;
-        case "session.resumed":
-            terminal.write(`\nResumed session ${result.sessionId}\n`);
-            break;
-        case "model.selection.requested": {
-            let models = result.models;
-            while (true) {
-                const selection = await runModelPicker({
-                    controller: app,
-                    terminal,
-                    models,
-                    question: (prompt) => question(prompt, { history: false }),
-                });
-                if (selection.type === "empty") {
-                    terminal.write("\nNo model profiles are configured.\n");
-                    break;
-                }
-                if (selection.type === "cancelled")
-                    break;
-                if (selection.type === "select") {
-                    await app.switchModel(selection.profile);
-                    break;
-                }
-                await app.setDefaultModel(selection.profile);
-                models = await app.listModels();
-            }
-            break;
-        }
-        case "model.switched":
-            break;
-        case "model.not-found":
-            terminal.write(`\nNo model profile starts with: ` +
-                `${sanitizeTerminalText(result.query)}\n`);
-            break;
-        case "effort.selection.requested": {
-            if (result.state.status !== "known") {
-                terminal.write(`\n${renderReasoningEffortState(result.state)}\n`);
-                break;
-            }
-            const choices = ["default", ...result.state.efforts];
-            terminal.write(`\n${renderReasoningEffortState(result.state)}`);
-            for (const [index, effort] of choices.entries()) {
-                terminal.write(`  ${index + 1}. ${sanitizeTerminalText(effort)}\n`);
-            }
-            const answer = (await question("Select an effort number or name (Enter to cancel): ", { history: false })).trim().toLowerCase();
-            if (answer !== "") {
-                const numeric = Number(answer);
-                const selected = Number.isSafeInteger(numeric) && numeric > 0
-                    ? choices[numeric - 1]
-                    : choices.find((choice) => choice.startsWith(answer));
-                if (selected === undefined) {
-                    terminal.write(`\nNo reasoning effort starts with: ` +
-                        `${sanitizeTerminalText(answer)}\n`);
-                }
-                else {
-                    const state = await app.setReasoningEffort(selected === "default" ? undefined : selected);
-                    terminal.write(`\n${renderReasoningEffortChanged(state)}\n`);
-                }
-            }
-            break;
-        }
-        case "effort.changed":
-            terminal.write(`\n${renderReasoningEffortChanged(result.state)}\n`);
-            break;
-        case "effort.not-found":
-            terminal.write(`\nNo reasoning effort starts with: ` +
-                `${sanitizeTerminalText(result.query)}\n`);
-            break;
-        case "usage":
-            terminal.write(`\nUsage: ${sanitizeTerminalText(result.usage)}\n`);
-            break;
-        case "unknown":
-            terminal.write(`\nUnknown command: ${sanitizeTerminalText(result.command)}. ` +
-                "Type /help.\n");
-            break;
-    }
-    return false;
-}
-function renderReasoningEffortState(state) {
-    if (state.status === "unknown") {
-        return "Reasoning effort capability is unknown for the active model.";
-    }
-    if (state.status === "unsupported") {
-        return "The active model does not support effort-based reasoning.";
-    }
-    const current = sanitizeTerminalText(state.effectiveEffort ?? "provider/model default");
-    return `Reasoning effort (source: ${sanitizeTerminalText(state.source)}, ` +
-        `current: ${current})\n`;
-}
-function renderReasoningEffortChanged(state) {
-    const effort = sanitizeTerminalText(state.effectiveEffort ?? "provider/model default");
-    return `Reasoning effort: ${effort}${state.overridden ? " (runtime override)" : ""}`;
-}
-function renderSlashCommandHelp(commands) {
-    const entries = commands.map((command) => {
-        const aliases = command.aliases === undefined
-            ? ""
-            : ` (alias ${command.aliases.join(", ")})`;
-        return `  ${command.usage}${aliases}\n      ${command.description}`;
-    }).join("\n");
-    return `Commands:\n${entries}\n` +
-        "  Ctrl+C\n      Cancel the active operation, or exit while idle\n" +
-        "  Multiline\n      End a line with \\ to continue on the next line\n";
-}
-function inputPrompt(yolo, continuation, gitLabel = "") {
-    return `${continuation ? "" : "\n"}${!continuation && gitLabel ? `[${gitLabel}] ` : ""}${yolo ? "YOLO · Auto-approve " : ""}${continuation ? "... " : "> "}`;
-}
-async function readInput(question, suggestions, yolo, gitLabel = () => "") {
-    const lines = [];
-    while (true) {
-        let line = await question(inputPrompt(yolo(), lines.length > 0, gitLabel()), {
-            history: false,
-            ...(lines.length === 0 && suggestions !== undefined
-                ? { suggestions }
-                : {}),
-        });
-        if (lines.length === 0 && suggestions !== undefined) {
-            const candidates = await suggestions(line);
-            line = candidates.length === 1 ? candidates[0].value : line;
-        }
-        const continuation = removeLineContinuation(line);
-        lines.push(continuation.text);
-        if (!continuation.continued)
-            return lines.join("\n").trim();
-    }
-}
-function removeLineContinuation(line) {
-    let backslashes = 0;
-    for (let index = line.length - 1; index >= 0 && line[index] === "\\"; index--) {
-        backslashes += 1;
-    }
-    if (backslashes % 2 === 0)
-        return { text: line, continued: false };
-    return { text: line.slice(0, -1), continued: true };
-}
-class TerminalRenderer {
-    terminal;
-    images;
-    textStarted = false;
-    reasoningStarted = false;
-    changePreviews = new Map();
-    delegationStatus = new Map();
-    lastDelegationKey = "";
-    label = "";
-    toolOutputState = new Map();
-    constructor(terminal) {
-        this.terminal = terminal;
-        this.images = new TerminalImages(undefined, terminal.imageSupport?.protocol, { cellSize: () => terminal.imageSupport?.cellSize });
-    }
-    write(text) {
-        this.terminal.write(text);
-    }
-    tagged(text) {
-        return this.label === "" ? text : `${this.label} ${text}`;
-    }
-    async runEvent(event) {
-        switch (event.type) {
-            case "input.received":
-                this.endReasoning();
-                for (const message of event.messages) {
-                    this.terminal.write(`\nYou: ${sanitizeTerminalText(textFromContent(message.content))}\n`);
-                }
-                break;
-            case "model.started":
-                this.textStarted = false;
-                this.reasoningStarted = false;
-                break;
-            case "model.reasoning.delta":
-                if (!this.reasoningStarted) {
-                    this.terminal.write(`\n${this.dim("[thinking] ")}`);
-                    this.reasoningStarted = true;
-                }
-                this.terminal.write(this.dim(sanitizeTerminalText(event.delta)));
-                break;
-            case "model.text.delta":
-                this.endReasoning();
-                if (!this.textStarted) {
-                    this.terminal.write(this.label === "" ? "\nMaybeCode: " : `\n${this.label} Sub-agent: `);
-                    this.textStarted = true;
-                }
-                this.terminal.write(sanitizeTerminalText(event.delta));
-                break;
-            case "model.retrying":
-                this.endReasoning();
-                if (this.textStarted)
-                    this.terminal.write("\n");
-                this.terminal.write(`\nModel request failed: ${sanitizeTerminalText(event.error.message)}. ` +
-                    `Retrying in ${formatDelay(event.delayMs)} ` +
-                    `(attempt ${event.attempt}/${event.maxAttempts})...\n`);
-                this.textStarted = false;
-                this.reasoningStarted = false;
-                break;
-            case "model.completed": {
-                this.endReasoning();
-                if (event.message.content.some(part => part.type === "image")) {
-                    this.terminal.write("\nMaybeCode · 完整图文回复：\n");
-                    await this.renderContent(event.message.content);
-                    break;
-                }
-                const text = textFromContent(event.message.content);
-                if (!this.textStarted && text !== "") {
-                    this.terminal.write(`\nMaybeCode: ${sanitizeTerminalText(text)}`);
-                    this.textStarted = true;
-                }
-                if (this.textStarted)
-                    this.terminal.write("\n");
-                break;
-            }
-            case "tool.started":
-                this.terminal.write(`\n${this.tagged(`→ ${sanitizeTerminalText(event.call.name)}${toolInputSummary(event.call.name, event.call.input)}`)}\n`);
-                break;
-            case "tool.output.delta": {
-                const key = toolCallKey(event.runId, event.call.id);
-                const previous = this.toolOutputState.get(key);
-                if (previous !== undefined &&
-                    !previous.endsWithNewline &&
-                    previous.channel !== event.channel) {
-                    this.terminal.write("\n");
-                }
-                if (previous === undefined || previous.endsWithNewline ||
-                    previous.channel !== event.channel) {
-                    this.terminal.write(event.channel === undefined
-                        ? ""
-                        : `[${sanitizeTerminalText(event.channel)}] `);
-                }
-                this.terminal.write(sanitizeTerminalText(event.delta));
-                this.toolOutputState.set(key, {
-                    endsWithNewline: event.delta.endsWith("\n"),
-                    ...(event.channel === undefined ? {} : { channel: event.channel }),
-                });
-                break;
-            }
-            case "tool.progress":
-                this.endToolOutput(event.runId, event.call.id);
-                this.terminal.write(`↳ ${sanitizeTerminalText(event.call.name)}: ` +
-                    `${sanitizeTerminalText(event.message)}\n`);
-                break;
-            case "tool.completed":
-                this.endToolOutput(event.runId, event.call.id);
-                this.renderToolCompleted(event);
-                if (event.content.some(part => part.type === "image"))
-                    await this.renderContent(event.content);
-                break;
-            case "tool.failed":
-                this.endToolOutput(event.runId, event.call.id);
-                this.changePreviews.delete(toolCallKey(event.runId, event.call.id));
-                this.terminal.write(`\n${this.tagged(`✗ ${sanitizeTerminalText(event.call.name)}: ` +
-                    `${sanitizeTerminalText(event.error.message)}`)}\n`);
-                break;
-            case "run.completed":
-            case "run.yielded":
-                this.clearRunPreviews(event.runId);
-                break;
-            case "run.failed":
-                this.clearRunPreviews(event.runId);
-                this.terminal.write(`\n${this.tagged(`Run failed: ${sanitizeTerminalText(event.error.message)}`)}\n`);
-                break;
-            case "run.cancelled":
-                this.clearRunPreviews(event.runId);
-                this.terminal.write(`\n${this.tagged(`Run cancelled${event.reason === undefined
-                    ? ""
-                    : `: ${sanitizeTerminalText(event.reason)}`}`)}\n`);
-                break;
-        }
-    }
-    async renderContent(content) {
-        await this.images.prepare(content);
-        for (const part of content) {
-            if (part.type === "text")
-                this.terminal.write(sanitizeTerminalText(part.text) + "\n");
-            if (part.type === "image") {
-                const result = this.images.render(part.source, { width: process.stdout.columns || 80, height: 30 });
-                const image = result.images?.[0];
-                this.terminal.write(result.lines.slice(0, image?.y ?? result.lines.length).join("\n") + "\n");
-                if (image) {
-                    this.terminal.write("\n".repeat(image.rows) + `\x1b[${image.rows}A\x1b7` + encodeImage(image) + `\x1b8\x1b[${image.rows}B\r`);
-                }
-            }
-        }
-    }
-    changePreview(event) {
-        this.changePreviews.set(toolCallKey(event.runId, event.toolCallId), event.preview);
-        if (event.preview.status === "unavailable") {
-            this.terminal.write(`\nDiff unavailable for ${event.preview.tool} ` +
-                `${sanitizeTerminalText(event.preview.path)}: ` +
-                `${sanitizeTerminalText(event.preview.reason)}\n`);
-            return;
-        }
-        this.terminal.write(`\nChange preview: ${sanitizeTerminalText(event.preview.path)} ` +
-            `(${changeKindLabel(event.preview.kind)})\n`);
-        this.terminal.write(event.preview.diff === ""
-            ? "(no content changes)\n"
-            : `${sanitizeTerminalText(event.preview.diff)}\n`);
-    }
-    contextCompacted(event) {
-        const saved = Math.max(0, event.before.estimatedTokens - event.after.estimatedTokens);
-        this.terminal.write(`\nContext automatically compacted with ${event.strategy}: ` +
-            `${event.before.messageCount} -> ${event.after.messageCount} messages, ` +
-            `~${formatNumber(saved)} tokens saved.\n`);
-    }
-    contextCompactionFailed(event) {
-        const next = event.continuing
-            ? " Trying the next strategy."
-            : " No fallback strategies remain.";
-        const message = sanitizeTerminalText(event.error.message)
-            .replace(/[.!?]+$/u, "");
-        this.terminal.write(`\nAutomatic context compaction failed with ${event.strategy} at ` +
-            `~${formatNumber(event.before.effectiveTokens)} tokens: ` +
-            `${message}.${next}\n`);
-    }
-    permissionEvent(event) {
-        if (event.type === "approval.resolved") {
-            this.terminal.write(`Permission: ${event.decision}\n`);
-        }
-        else if (event.type === "approval.cancelled") {
-            this.terminal.write("Permission request cancelled.\n");
-        }
-    }
-    approvalRequest(request) {
-        const preview = this.changePreviews.get(toolCallKey(request.context.runId, request.context.toolCallId));
-        if (preview !== undefined) {
-            this.terminal.write(`\nApproval required for ${sanitizeTerminalText(request.tool.name)}: ` +
-                `${sanitizeTerminalText(preview.path)}\n`);
-            return;
-        }
-        this.terminal.write(`\nApproval required for ${sanitizeTerminalText(request.tool.name)}:\n` +
-            `${sanitizeTerminalText(truncate(stringify(request.input), 1200))}\n`);
-    }
-    async sessionChanged(event, app) {
-        this.terminal.write(`\nSession ${event.resumed ? "resumed" : "started"}: ${event.sessionId}\n`);
-        if (!event.resumed)
-            return;
-        if (app.sessionId !== event.sessionId)
-            return;
-        const history = await app.history();
-        const steering = new Map(history.flatMap(event => event.type === "input.steering.queued" ? [[event.input.inputId, event.input.message]] : []));
-        for (const event of history) {
-            if (event.type === "assistant.completed" && event.message.content.some(part => part.type === "image"))
-                await this.renderContent(event.message.content);
-            else
-                renderHistory([event], this.terminal, steering);
-        }
-    }
-    modelChanged(model) {
-        const profile = model.profile === undefined
-            ? ""
-            : ` ${sanitizeTerminalText(model.profile)}`;
-        this.terminal.write(`\nModel switched to${profile}: ` +
-            `${sanitizeTerminalText(model.provider)}/` +
-            `${sanitizeTerminalText(model.model)}\n`);
-    }
-    defaultModelChanged(profile) {
-        this.terminal.write(`\nDefault model set to ${sanitizeTerminalText(profile)}\n`);
-    }
-    /** 子 Agent 请求的开始与结束，包含整棵任务树。 */
-    delegationLifecycle(event, enabled) {
-        if (event.type === "delegation.started") {
-            this.delegationStatus.clear();
-            this.lastDelegationKey = "";
-        }
-        if (!enabled)
-            return;
-        this.write(`\n${event.type === "delegation.started" ? "Sub-agent request" : "Sub-agent request finished"} ` +
-            `${sanitizeTerminalText(event.state.requestId)}\n`);
-        for (const task of delegationOrder(event.state.tasks)) {
-            this.write(`${sanitizeTerminalText(renderDelegationTask(task))}\n`);
-        }
-    }
-    /** 子任务运行期间的状态变化；状态未变化时不重复显示。 */
-    delegationState(state, enabled) {
-        const key = `${state.tasks.map((task) => `${task.id}:${task.status}`).join("|")}#${state.status}`;
-        if (key === this.lastDelegationKey)
-            return;
-        this.lastDelegationKey = key;
-        for (const task of delegationOrder(state.tasks)) {
-            if (this.delegationStatus.get(task.id) === task.status)
-                continue;
-            this.delegationStatus.set(task.id, task.status);
-            if (enabled)
-                this.write(`${sanitizeTerminalText(renderDelegationTask(task))}\n`);
-        }
-    }
-    /** 一个子 Agent Run 事件，带上任务身份前缀。 */
-    async delegationEvent(event) {
-        if (event.event.type !== "run.event") {
-            this.endReasoning();
-            this.write(`\n[${event.taskId}] ${sanitizeTerminalText(describeApplicationEvent(event.event))}\n`);
-            return;
-        }
-        this.label = `[${event.taskId}]`;
-        try {
-            await this.runEvent(event.event.event);
-        }
-        finally {
-            this.label = "";
-        }
-    }
-    mcpEvent(event) {
-        if (event.type === "mcp.resource.updated" || event.type === "mcp.resource.watch-closed") {
-            this.terminal.write(`\n${sanitizeTerminalText(`${event.type}: ${event.serverId} ${event.uri}${event.type === "mcp.resource.watch-closed" ? ` (${event.reason})` : ""}`)}\n`);
-            return;
-        }
-        if (event.type === "mcp.server.catalog-updated") {
-            this.terminal.write(`\nMCP catalog updated: ${sanitizeTerminalText(event.serverId)} (revision ${event.revision})\n`);
-            return;
-        }
-        if (event.type === "mcp.server.connected") {
-            this.terminal.write(`\nMCP server connected: ${sanitizeTerminalText(event.serverId)} ` +
-                `(${event.toolNames.length} tools)\n`);
-            return;
-        }
-        if (event.type === "mcp.server.failed") {
-            this.terminal.write(`\nMCP server failed: ${sanitizeTerminalText(event.serverId)}: ` +
-                `${sanitizeTerminalText(event.diagnostic.message)}\n`);
-            return;
-        }
-        this.terminal.write(`\nMCP server disconnected: ${sanitizeTerminalText(event.serverId)}\n`);
-    }
-    endReasoning() {
-        if (!this.reasoningStarted)
-            return;
-        this.terminal.write(this.terminal.colors ? "\x1b[0m\n" : "\n");
-        this.reasoningStarted = false;
-    }
-    dim(text) {
-        return this.terminal.colors ? `\x1b[2m${text}\x1b[0m` : text;
-    }
-    renderToolCompleted(event) {
-        const key = toolCallKey(event.runId, event.call.id);
-        const preview = this.changePreviews.get(key);
-        this.changePreviews.delete(key);
-        if (preview?.status === "ready") {
-            this.terminal.write(`${this.tagged(`✓ ${sanitizeTerminalText(event.call.name)}: ` +
-                `${sanitizeTerminalText(preview.path)} ` +
-                `(${changeKindLabel(preview.kind)}, ` +
-                `+${preview.additions} -${preview.deletions})`)}\n`);
-            return;
-        }
-        this.terminal.write(`${this.tagged(`${toolResultMarker(event.output)} ${sanitizeTerminalText(event.call.name)}${toolResultSummary(event.output)}`)}\n`);
-    }
-    clearRunPreviews(runId) {
-        const prefix = `${runId}:`;
-        for (const key of this.changePreviews.keys()) {
-            if (key.startsWith(prefix))
-                this.changePreviews.delete(key);
-        }
-        for (const key of this.toolOutputState.keys()) {
-            if (key.startsWith(prefix))
-                this.toolOutputState.delete(key);
-        }
-    }
-    endToolOutput(runId, toolCallId) {
-        const key = toolCallKey(runId, toolCallId);
-        const state = this.toolOutputState.get(key);
-        this.toolOutputState.delete(key);
-        if (state?.endsWithNewline === false)
-            this.terminal.write("\n");
-    }
-}
-function renderHistory(history, terminal, steering) {
-    for (const event of history) {
-        if (event.type === "input.submitted") {
-            const text = textFromContent(event.message.content);
-            if (text !== "")
-                terminal.write(`You: ${sanitizeTerminalText(text)}\n`);
-        }
-        else if (event.type === "input.steering.delivered") {
-            for (const inputId of event.inputIds) {
-                const message = steering.get(inputId);
-                if (!message)
-                    throw new Error(`Missing steering input: ${inputId}`);
-                const text = textFromContent(message.content);
-                if (text !== "")
-                    terminal.write(`You: ${sanitizeTerminalText(text)}\n`);
-            }
-        }
-        else if (event.type === "assistant.completed") {
-            const text = textFromContent(event.message.content);
-            if (text !== "") {
-                terminal.write(`MaybeCode: ${sanitizeTerminalText(text)}\n`);
-            }
-        }
-        else if (event.type === "tool.completed") {
-            terminal.write(`${toolResultMarker(event.output)} ${sanitizeTerminalText(event.call.name)}${toolResultSummary(event.output)}\n`);
-        }
-        else if (event.type === "tool.failed") {
-            terminal.write(`✗ ${sanitizeTerminalText(event.call.name)}: ` +
-                `${sanitizeTerminalText(event.error.message)}\n`);
-        }
-    }
-}
-function textFromContent(content) {
-    return content
-        .filter((part) => part.type === "text")
-        .map((part) => part.text)
-        .join("");
-}
-function toolResultSummary(output) {
-    if (typeof output !== "object" || output === null)
-        return "";
-    if ("path" in output && typeof output.path === "string") {
-        return `: ${sanitizeTerminalText(output.path)}`;
-    }
-    if ("exitCode" in output && typeof output.exitCode === "number") {
-        return `: exit ${output.exitCode}`;
-    }
-    return "";
-}
-function toolResultMarker(output) {
-    if (typeof output === "object" &&
-        output !== null &&
-        "exitCode" in output &&
-        typeof output.exitCode === "number" &&
-        output.exitCode !== 0) {
-        return "✗";
-    }
-    return "✓";
-}
-function permissionChoices(toolName) {
-    const scope = toolName === "shell" || toolName === "bash"
-        ? "same command"
-        : toolName === "edit" || toolName === "write"
-            ? "same path"
-            : "same operation";
-    return `[a]llow once / allow ${scope} for [s]ession / [d]eny`;
-}
-function toolInputSummary(toolName, input) {
-    if ((toolName === "edit" || toolName === "write") &&
-        typeof input === "object" &&
-        input !== null &&
-        "path" in input &&
-        typeof input.path === "string") {
-        return `: ${sanitizeTerminalText(input.path)}`;
-    }
-    return ` ${sanitizeTerminalText(truncate(stringify(input), 800))}`;
-}
-function toolCallKey(runId, toolCallId) {
-    return `${runId}:${toolCallId}`;
-}
-function delegationOrder(tasks) {
-    return [...tasks].sort((left, right) => left.depth - right.depth || left.id.localeCompare(right.id));
-}
-function describeApplicationEvent(event) {
-    if (event.type === "context.compacted") {
-        return `context compacted with ${event.strategy}: ${event.before.messageCount} -> ${event.after.messageCount} messages`;
-    }
-    if (event.type === "context.compaction.failed") {
-        return `context compaction failed with ${event.strategy}: ${event.error.message}`;
-    }
-    if (event.type === "tool.presentation")
-        return `tool presentation recorded`;
-    return "session event";
-}
-function renderInstructionSources(app) {
-    const system = app.instructions.system.source;
-    const runtime = app.instructions.runtime?.source;
-    const projects = app.instructions.projects;
-    return `Instructions:\n  system: ${instructionSourceLabel(system)}\n` +
-        `  runtime: ${runtime === undefined ? "none" : instructionSourceLabel(runtime)}\n` +
-        `  project: ${projects.length === 0 ? "none" : projects.map(project => instructionSourceLabel(project.source)).join("\n    ")}\n`;
-}
-function renderStatus(app, inspection) {
-    let output = `Status:\n` +
-        `  model: ${modelLabel(app)}\n` +
-        `  session: ${sanitizeTerminalText(app.sessionId)}\n` +
-        `  workspace: ${sanitizeTerminalText(app.workspace)}\n` +
-        `  permissions: ${app.permissionMode === "yolo" ? "YOLO · Auto-approve" : "Default"}\n`;
-    if (inspection === undefined)
-        return `${output}  context: unavailable\n`;
-    output += `  context: ~${formatNumber(inspection.effectiveTokens)}`;
-    if (inspection.contextWindowTokens !== undefined) {
-        output += ` / ${formatNumber(inspection.contextWindowTokens)} tokens ` +
-            `(${((inspection.usageRatio ?? 0) * 100).toFixed(1)}%)`;
-    }
-    else {
-        output += ` tokens (${inspection.measurementMethod})`;
-    }
-    return `${output}\n`;
-}
-function modelLabel(app) {
-    if (app.modelInfo === undefined)
-        return "custom";
-    const endpoint = `${sanitizeTerminalText(app.modelInfo.provider)}/` +
-        sanitizeTerminalText(app.modelInfo.model);
-    return app.modelInfo.profile === undefined
-        ? endpoint
-        : `${sanitizeTerminalText(app.modelInfo.profile)} (${endpoint})`;
-}
-function renderContextInspection(inspection) {
-    const roles = inspection.messagesByRole;
-    let output = `Context:\n` +
-        `  messages: ${inspection.messageCount} ` +
-        `(system ${roles.system}, user ${roles.user}, ` +
-        `assistant ${roles.assistant}, tool ${roles.tool})\n` +
-        `  instructions: ${formatBytes(inspection.instructionsBytes)}\n` +
-        `  message data: ${formatBytes(inspection.messageBytes)}\n` +
-        `  total: ${formatBytes(inspection.totalBytes)}\n` +
-        `  estimated tokens: ~${inspection.estimatedTokens} ` +
-        `(${inspection.tokenEstimateMethod})\n`;
-    if (inspection.contextWindowTokens === undefined) {
-        output += `  effective usage: ~${formatNumber(inspection.effectiveTokens)} ` +
-            `(${inspection.measurementMethod})\n`;
-    }
-    else {
-        output += `  effective usage: ~${formatNumber(inspection.effectiveTokens)} / ` +
-            `${formatNumber(inspection.contextWindowTokens)} ` +
-            `(${((inspection.usageRatio ?? 0) * 100).toFixed(1)}%)\n`;
-    }
-    if (inspection.measurementMethod === "measured+estimated") {
-        output += `  measurement: ${formatNumber(inspection.measuredInputTokens ?? 0)} measured + ~${formatNumber(inspection.estimatedTailTokens ?? 0)} estimated tail\n`;
-    }
-    else {
-        output += "  measurement: estimated only\n";
-    }
-    if (inspection.remainingTokens !== undefined) {
-        output += `  remaining: ${formatNumber(inspection.remainingTokens)} tokens\n`;
-    }
-    if (inspection.inputBudgetTokens !== undefined) {
-        output += `  input budget: ${formatNumber(inspection.inputBudgetTokens)} tokens`;
-        if ((inspection.reservedTokens ?? 0) > 0) {
-            output += ` (${formatNumber(inspection.reservedTokens ?? 0)} reserved)`;
-        }
-        output += "\n";
-    }
-    if (inspection.compactTriggerTokens !== undefined) {
-        output += `  compaction threshold: ${formatNumber(inspection.compactTriggerTokens)} tokens (${inspection.shouldCompact === true ? "reached" : "not reached"})\n`;
-    }
-    return output;
-}
-function renderCompactionResult(result) {
-    if (!result.changed) {
-        return `No context changes were eligible for ${result.strategy}.\n`;
-    }
-    const saved = Math.max(0, result.before.estimatedTokens - result.after.estimatedTokens);
-    const ratio = result.before.estimatedTokens === 0
-        ? 0
-        : saved / result.before.estimatedTokens * 100;
-    return `Context compacted with ${result.strategy}:\n` +
-        `  messages: ${result.before.messageCount} -> ${result.after.messageCount}\n` +
-        `  estimated tokens: ~${formatNumber(result.before.estimatedTokens)} -> ` +
-        `~${formatNumber(result.after.estimatedTokens)}\n` +
-        `  saved: ~${formatNumber(saved)} tokens (${ratio.toFixed(1)}%)\n`;
-}
-function formatNumber(value) {
-    return value.toLocaleString("en-US");
-}
-function formatDelay(milliseconds) {
-    return milliseconds < 1000
-        ? `${milliseconds}ms`
-        : `${(milliseconds / 1000).toFixed(milliseconds % 1000 === 0 ? 0 : 1)}s`;
-}
-function formatBytes(bytes) {
-    if (bytes < 1024)
-        return `${bytes} B`;
-    return `${(bytes / 1024).toFixed(1)} KiB`;
-}
-function instructionSourceLabel(source) {
-    return source.type === "file" ? source.path : source.type;
-}
-function changeKindLabel(kind) {
-    switch (kind) {
-        case "create":
-            return "created";
-        case "update":
-            return "updated";
-        case "no-change":
-            return "unchanged";
-    }
-}
-function stringify(value) {
-    try {
-        return JSON.stringify(value, undefined, 2);
-    }
-    catch {
-        return String(value);
-    }
-}
-function truncate(text, limit) {
-    return text.length <= limit ? text : `${text.slice(0, limit)}…`;
-}
-function isAbortError(error) {
-    return error instanceof Error && error.name === "AbortError";
-}
-function isCancellation(error) {
-    return error instanceof Error && error.name === "RunCancelledError";
-}
-function errorMessage(error) {
-    if (error instanceof Error)
-        return error.message;
-    return typeof error === "string" ? error : "Unknown error";
-}
-//# sourceMappingURL=tui.js.map