@markusylisiurunen/tau 0.1.2

package/dist/app.js

@@ -0,0 +1,1140 @@
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { streamSimple } from "@mariozechner/pi-ai";
+import { Spacer, Text, TUI } from "@mariozechner/pi-tui";
+import { loadBashCommands } from "./bash_commands.js";
+import { copyTextToClipboard } from "./clipboard.js";
+import { buildHelpText, getRiskLevelDescription, parseCommand } from "./commands.js";
+import { getApiKeyForProvider } from "./config.js";
+import { loadAllContent } from "./content_loader.js";
+import { SessionEngine } from "./session/session_engine.js";
+import { createAppTerminal } from "./terminal.js";
+import { createBashToolDefinition, executeBashTool, formatBashUserMessageText, prepareBashOutput, } from "./tools/bash.js";
+import { createEditToolDefinition } from "./tools/edit.js";
+import { ToolRegistry } from "./tools/registry.js";
+import { createTaskToolDefinition } from "./tools/task.js";
+import { createWriteToolDefinition } from "./tools/write.js";
+import { REASONING_LEVELS } from "./types.js";
+import { AssistantMessageComponent } from "./ui/assistant_message.js";
+import { renderBashBlocked, renderBashExecution, renderBashRunning } from "./ui/bash_execution.js";
+import { ChatContainerComponent } from "./ui/chat_container.js";
+import { CustomEditor } from "./ui/custom_editor.js";
+import { renderEditBlocked, renderEditSuccess, renderWriteBlocked, renderWriteSuccess, } from "./ui/file_execution.js";
+import { FooterComponent } from "./ui/footer.js";
+import { QueuedMessagesComponent } from "./ui/queued_messages.js";
+import { SessionDividerComponent } from "./ui/session_divider.js";
+import { SessionSummaryComponent } from "./ui/session_summary.js";
+import { SlashAutocompleteProvider } from "./ui/slash_autocomplete.js";
+import { SystemMessageComponent } from "./ui/system_message.js";
+import { renderTaskBlocked, renderTaskFinished, renderTaskRunning } from "./ui/task_execution.js";
+import { editorBorderForReasoning, theme } from "./ui/theme.js";
+import { UserMessageComponent } from "./ui/user_message.js";
+import { buildBaseSystemPrompt, buildEnvironmentTag, buildProjectContextBlock, findAgentsFilesFromCwdToHome, formatRiskLevelChangeNotice, } from "./utils/context.js";
+import { formatHistoryForCompression } from "./utils/fork.js";
+import { formatAdaptiveNumber, formatCwd, formatTokenWindow } from "./utils/format.js";
+import { getGitRoot } from "./utils/git.js";
+import { extractAllFencedCodeBlocks, extractAssistantText } from "./utils/messages.js";
+import { listProjectFiles } from "./utils/project_files.js";
+const { palette } = theme;
+export class ChatApp {
+    ui;
+    chatContainer;
+    footer;
+    queuedMessages;
+    editor;
+    personas;
+    currentPersona;
+    prompts;
+    bashCommands;
+    repoRoot;
+    initialUserMessage;
+    config;
+    assistantComponents = [];
+    engine;
+    runningBashComponents = new Map(); // toolCallId -> component index
+    runningTaskComponents = new Map(); // toolCallId -> component index
+    taskEvents = new Map(); // toolCallId -> accumulated events
+    subagentCostTotal = 0;
+    isStreaming = false;
+    queuedUserMessages = [];
+    isDrainingQueuedUserMessages = false;
+    isBashMode = false;
+    isMemoryMode = false;
+    showThinking = false;
+    compactToolUi = true;
+    currentTurnAbort;
+    riskLevel = "read-only";
+    initialRiskLevel;
+    environmentTag;
+    projectContextBlock;
+    projectFiles;
+    agentsFiles;
+    baseSystemPrompt;
+    pendingRiskLevelChange;
+    previousSessionSummary;
+    expandedFilesInCurrentPrompt = new Set();
+    constructor(options) {
+        this.personas = options.personas;
+        this.prompts = options.prompts ?? [];
+        this.bashCommands = options.bashCommands ?? [];
+        this.repoRoot = getGitRoot(process.cwd()) ?? process.cwd();
+        this.initialUserMessage = options.initialUserMessage;
+        this.config = options.config ?? {};
+        this.compactToolUi = this.config.toolDisplayMode !== "full";
+        if (options.initialRiskLevel) {
+            this.riskLevel = options.initialRiskLevel;
+        }
+        this.initialRiskLevel = this.riskLevel;
+        this.environmentTag = buildEnvironmentTag({
+            riskLevel: this.initialRiskLevel,
+            cwd: process.cwd(),
+            datetime: new Date().toISOString(),
+        });
+        this.agentsFiles = options.withContext
+            ? findAgentsFilesFromCwdToHome(process.cwd(), homedir())
+            : [];
+        this.projectContextBlock = options.withContext
+            ? buildProjectContextBlock({ cwd: process.cwd(), home: homedir() })
+            : undefined;
+        this.projectFiles = listProjectFiles(process.cwd());
+        this.currentPersona =
+            (options.initialPersonaId &&
+                this.personas.find((p) => p.id.toLowerCase() === options.initialPersonaId.toLowerCase())) ||
+                this.personas[0];
+        this.clampPersonaReasoning(this.currentPersona);
+        this.baseSystemPrompt = buildBaseSystemPrompt({
+            personaSystemPrompt: this.currentPersona.systemPrompt,
+            projectContextBlock: this.projectContextBlock,
+            environmentTag: this.environmentTag,
+            userPreferences: this.config.userPreferences,
+        });
+        const toolRegistry = new ToolRegistry([
+            createBashToolDefinition(),
+            createWriteToolDefinition(),
+            createEditToolDefinition(),
+            createTaskToolDefinition(),
+        ]);
+        this.engine = new SessionEngine({
+            persona: this.currentPersona,
+            baseSystemPrompt: this.baseSystemPrompt,
+            riskLevel: this.riskLevel,
+            toolRegistry,
+            config: this.config,
+        });
+        this.ui = new TUI(createAppTerminal(Boolean(this.initialUserMessage)));
+        this.chatContainer = new ChatContainerComponent();
+        this.chatContainer.setCompactToolUi(this.compactToolUi);
+        this.footer = new FooterComponent(this.ui);
+        this.queuedMessages = new QueuedMessagesComponent(() => this.queuedUserMessages);
+        this.editor = new CustomEditor(theme.editorTheme);
+        this.setupUI();
+        this.setupEditor();
+    }
+    setupUI() {
+        this.ui.addChild(this.chatContainer);
+        this.ui.addChild(new Spacer(1));
+        this.ui.addChild(this.queuedMessages);
+        this.ui.addChild(this.editor);
+        this.ui.addChild(this.footer);
+        const headerText = `\n${palette.accent("tau")} ${palette.muted("– terminal chat")}\n\n` +
+            palette.muted(buildHelpText(this.agentsFiles));
+        this.chatContainer.addMessage(new Text(headerText, 1, 0));
+        this.ui.setFocus(this.editor);
+        this.updateFooter();
+        this.updateEditorBorderColor();
+    }
+    setupEditor() {
+        this.editor.onCtrlC = () => {
+            this.stop();
+            process.exit(0);
+        };
+        this.editor.onCtrlT = () => this.toggleThinkingVisibility();
+        this.editor.onCtrlO = () => this.toggleCompactToolUi();
+        this.editor.onShiftTab = () => this.cycleReasoningLevel();
+        this.editor.onEscape = () => this.interruptAssistantTurn();
+        this.editor.onCtrlF = () => {
+            this.expandFileMentions().catch((err) => {
+                this.addSystemMessage(`file expansion failed: ${err.message}`, palette.noticeError);
+            });
+        };
+        this.editor.onAltUp = () => this.popQueuedUserMessageIntoEditor();
+        this.editor.beforeSubmit = (text) => {
+            if (!this.isStreaming)
+                return true;
+            const trimmed = text.trimStart();
+            return !trimmed.startsWith("/") && !trimmed.startsWith("!");
+        };
+        this.editor.onChange = (text) => {
+            const wasBash = this.isBashMode;
+            const wasMemory = this.isMemoryMode;
+            const trimmed = text.trimStart();
+            this.isBashMode = trimmed.startsWith("!");
+            this.isMemoryMode = trimmed.startsWith("#");
+            if (wasBash !== this.isBashMode || wasMemory !== this.isMemoryMode) {
+                this.updateEditorBorderColor();
+            }
+        };
+        this.editor.setAutocompleteProvider(new SlashAutocompleteProvider(() => this.personas.map((p) => ({ id: p.id, label: p.label })), () => this.prompts.map((t) => ({ id: t.id, label: t.label })), () => this.bashCommands.map((b) => ({
+            id: b.id,
+            description: b.description,
+        })), () => this.projectFiles));
+        this.editor.onSubmit = (text) => this.handleSubmit(text);
+    }
+    async start() {
+        this.ui.start();
+        if (this.initialUserMessage) {
+            await this.sendInitialUserMessage(this.initialUserMessage);
+        }
+    }
+    stop() {
+        this.ui.stop();
+    }
+    // UI Updates ------------------------------------------------------------------------------------
+    updateFooter() {
+        const reasoningLabel = this.currentPersona.settings.reasoning || "default";
+        const toolLabel = this.formatRiskLevelLabel();
+        const contextUsage = this.getContextUsageString();
+        const sessionCost = this.getSessionCostString();
+        const cwd = formatCwd(process.cwd());
+        const left = palette.dim(`${cwd} · ${contextUsage} · ${sessionCost}`);
+        const personaName = this.currentPersona.label || this.currentPersona.id;
+        const statusPart = palette.dim(`${personaName} · ${reasoningLabel} · `);
+        const right = `${statusPart}${toolLabel}`;
+        this.footer.setLeftRight(left, right);
+        this.ui.requestRender();
+    }
+    formatRiskLevelLabel() {
+        switch (this.riskLevel) {
+            case "none":
+                return palette.riskNone("none");
+            case "read-only":
+                return palette.riskReadOnly("read-only");
+            case "read-write":
+                return palette.riskReadWrite("read-write");
+        }
+    }
+    updateEditorBorderColor() {
+        if (this.isBashMode) {
+            this.editor.borderColor = (s) => palette.bashRan(s);
+        }
+        else if (this.isMemoryMode) {
+            this.editor.borderColor = (s) => palette.memoryMode(s);
+        }
+        else {
+            this.editor.borderColor = editorBorderForReasoning(this.currentPersona.settings.reasoning);
+        }
+        this.ui.requestRender();
+    }
+    addSystemMessage(text, styleFn) {
+        this.chatContainer.addMessage(new SystemMessageComponent(text, styleFn));
+        this.ui.requestRender();
+    }
+    addUserMessage(text, opts) {
+        this.chatContainer.addMessage(new UserMessageComponent(text, opts));
+        this.ui.requestRender();
+    }
+    addAssistantComponent(component) {
+        this.chatContainer.addMessage(component);
+        this.assistantComponents.push(component);
+        this.ui.requestRender();
+    }
+    // Context & Cost Tracking -----------------------------------------------------------------------
+    getContextUsageString() {
+        const last = this.getLastAssistantMessage();
+        const windowTokens = last
+            ? this.getContextWindowForLastTurn(last)
+            : this.currentPersona.model.contextWindow;
+        const { read, write } = this.getCacheTotals();
+        let stats = `R${formatTokenWindow(read)} W${formatTokenWindow(write)}`;
+        if (!last) {
+            return `${stats} 0%/${formatTokenWindow(windowTokens)}`;
+        }
+        // Sum output tokens from assistant messages in the current turn (after last user message)
+        let totalOutputTokens = 0;
+        for (let i = this.engine.history.length - 1; i >= 0; i--) {
+            const m = this.engine.history[i];
+            if (m.role === "user") {
+                break;
+            }
+            if (m.role === "assistant") {
+                totalOutputTokens += m.usage?.output ?? 0;
+            }
+        }
+        stats += ` O${formatTokenWindow(totalOutputTokens)}`;
+        const promptTokensSent = (last.usage?.input ?? 0) + (last.usage?.cacheRead ?? 0) + (last.usage?.cacheWrite ?? 0);
+        const percent = windowTokens > 0 ? (promptTokensSent / windowTokens) * 100 : 0;
+        const percentStr = `${formatAdaptiveNumber(percent, 1, 3)}%`;
+        return `${stats} ${percentStr}/${formatTokenWindow(windowTokens)}`;
+    }
+    getSessionCostString() {
+        let total = 0;
+        for (const m of this.engine.history) {
+            if (m.role === "assistant") {
+                total += m.usage?.cost?.total ?? 0;
+            }
+        }
+        return `$${formatAdaptiveNumber(total + this.subagentCostTotal, 2, 5)}`;
+    }
+    getCacheTotals() {
+        let read = 0;
+        let write = 0;
+        for (const m of this.engine.history) {
+            if (m.role === "assistant") {
+                const usage = m.usage;
+                read += usage?.cacheRead ?? 0;
+                write += usage?.cacheWrite ?? 0;
+            }
+        }
+        return { read, write };
+    }
+    getLastAssistantMessage() {
+        const history = this.engine.history;
+        for (let i = history.length - 1; i >= 0; i--) {
+            const m = history[i];
+            if (m?.role === "assistant")
+                return m;
+        }
+        return undefined;
+    }
+    getContextWindowForLastTurn(last) {
+        const exactPersona = this.personas.find((p) => p.model.provider === last.provider && p.model.id === last.model);
+        return exactPersona?.model.contextWindow ?? this.currentPersona.model.contextWindow;
+    }
+    // Reasoning Level Management --------------------------------------------------------------------
+    cycleReasoningLevel() {
+        const allowed = this.getAllowedReasoningLevels(this.currentPersona);
+        const current = (this.currentPersona.settings.reasoning ?? allowed[0]);
+        const index = allowed.indexOf(current);
+        const next = allowed[(index + 1) % allowed.length];
+        this.currentPersona.settings.reasoning = next;
+        this.updateFooter();
+        this.updateEditorBorderColor();
+    }
+    isReasoningEffort(value) {
+        return typeof value === "string" && REASONING_LEVELS.includes(value);
+    }
+    getAllowedReasoningLevels(persona) {
+        if (!persona.model.reasoning) {
+            return ["none"];
+        }
+        const raw = persona.allowedReasoningLevels;
+        if (!raw || raw.length === 0) {
+            return REASONING_LEVELS;
+        }
+        const normalized = raw.filter((level) => this.isReasoningEffort(level));
+        const unique = [...new Set(normalized)];
+        return unique.length ? unique : REASONING_LEVELS;
+    }
+    clampPersonaReasoning(persona) {
+        const allowed = this.getAllowedReasoningLevels(persona);
+        if (!allowed.includes(persona.settings.reasoning)) {
+            persona.settings.reasoning = allowed[0];
+        }
+    }
+    // User Actions ----------------------------------------------------------------------------------
+    toggleThinkingVisibility() {
+        this.showThinking = !this.showThinking;
+        this.assistantComponents.forEach((c) => {
+            c.setThinkingVisibility(this.showThinking);
+        });
+        this.chatContainer.setThinkingVisibility(this.showThinking);
+        const message = this.showThinking
+            ? "thoughts visible (ctrl+t to hide)"
+            : "thoughts hidden (ctrl+t to show)";
+        this.addSystemMessage(message, palette.noticeSuccess);
+        this.ui.requestRender();
+    }
+    toggleCompactToolUi() {
+        this.compactToolUi = !this.compactToolUi;
+        this.chatContainer.setCompactToolUi(this.compactToolUi);
+        const message = this.compactToolUi
+            ? "compact tool UI enabled (ctrl+o to disable)"
+            : "compact tool UI disabled (ctrl+o to enable)";
+        this.addSystemMessage(message, palette.noticeSuccess);
+        this.ui.requestRender();
+    }
+    interruptAssistantTurn() {
+        if (!this.isStreaming || this.currentTurnAbort?.signal.aborted)
+            return;
+        this.currentTurnAbort?.abort();
+        this.addSystemMessage("interrupted.", palette.noticeError);
+        this.ui.requestRender();
+    }
+    // Input Handling --------------------------------------------------------------------------------
+    queueUserMessage(text) {
+        this.queuedUserMessages.push(text);
+        this.ui.requestRender();
+    }
+    popQueuedUserMessageIntoEditor() {
+        if (this.editor.getText() !== "")
+            return;
+        const last = this.queuedUserMessages.pop();
+        if (!last)
+            return;
+        this.editor.setText(last);
+        this.ui.requestRender();
+    }
+    async drainQueuedUserMessages() {
+        if (this.isDrainingQueuedUserMessages)
+            return;
+        this.isDrainingQueuedUserMessages = true;
+        try {
+            while (!this.isStreaming && this.queuedUserMessages.length > 0) {
+                const next = this.queuedUserMessages.shift();
+                if (!next)
+                    return;
+                this.ui.requestRender();
+                await this.handleSubmit(next);
+            }
+        }
+        finally {
+            this.isDrainingQueuedUserMessages = false;
+        }
+    }
+    async handleSubmit(text) {
+        const trimmed = text.trim();
+        if (!trimmed)
+            return;
+        if (this.isStreaming) {
+            if (trimmed.startsWith("/") || trimmed.startsWith("!")) {
+                return;
+            }
+            this.queueUserMessage(trimmed);
+            return;
+        }
+        if (trimmed.startsWith("/")) {
+            await this.handleCommand(trimmed);
+            return;
+        }
+        if (trimmed.startsWith("!")) {
+            const command = trimmed.slice(1).trim();
+            if (command)
+                await this.runBashCommand(command);
+            return;
+        }
+        if (trimmed.startsWith("#")) {
+            const request = trimmed.slice(1).trim();
+            if (!request) {
+                this.addSystemMessage("memory mode request was empty.", palette.noticeWarn);
+                return;
+            }
+            const agentsFilePath = this.getMemoryModeFilePath();
+            const textForModel = this.formatMemoryModeUserMessage(agentsFilePath, request);
+            await this.sendUserMessage(request, { textForModel, isMemoryMode: true });
+            return;
+        }
+        await this.sendUserMessage(trimmed);
+    }
+    async sendUserMessage(text, opts) {
+        this.addUserMessage(text, { isMemoryMode: opts?.isMemoryMode });
+        this.expandedFilesInCurrentPrompt.clear();
+        const systemNotice = this.pendingRiskLevelChange
+            ? formatRiskLevelChangeNotice(this.pendingRiskLevelChange)
+            : undefined;
+        this.pendingRiskLevelChange = undefined;
+        const baseTextForModel = opts?.textForModel ?? text;
+        const textForModel = systemNotice ? `${systemNotice}\n\n${baseTextForModel}` : baseTextForModel;
+        this.engine.addUserText(textForModel);
+        await this.runAssistantTurn();
+    }
+    async sendInitialUserMessage(text) {
+        const trimmed = text.trim();
+        if (!trimmed || this.isStreaming)
+            return;
+        this.addUserMessage(trimmed);
+        this.engine.addUserText(trimmed);
+        await this.runAssistantTurn();
+    }
+    getMemoryModeFilePath() {
+        const cwd = process.cwd();
+        const gitRoot = getGitRoot(cwd);
+        if (gitRoot) {
+            return resolve(join(gitRoot, "AGENTS.md"));
+        }
+        return resolve(join(cwd, "AGENTS.md"));
+    }
+    formatMemoryModeUserMessage(agentsFilePath, request) {
+        const system = [
+            "Memory mode: update the project guidelines file at:",
+            agentsFilePath,
+            "",
+            "If the file exists, use the edit tool to update it. If it does not exist, use the write tool to create it.",
+            "Preserve all unrelated content and match the existing formatting style.",
+            "Integrate the user's request thoughtfully. Don't just append it verbatim.",
+            "Place new content in the most appropriate existing section, or create a new section if needed.",
+            "Always prefer an existing section over creating a new one. Sometimes changes are required in more than one place.",
+            "",
+            "Do not mention this surrounding instruction in your response.",
+        ].join("\n");
+        return ["<system>", system, "</system>", "", request].join("\n");
+    }
+    // Command Handling ------------------------------------------------------------------------------
+    async handleCommand(raw) {
+        const cmd = parseCommand(raw);
+        switch (cmd.type) {
+            case "help":
+                this.showHelp();
+                break;
+            case "copy":
+                await this.copyLastAssistantMessage();
+                break;
+            case "copyCode":
+                await this.copyLastAssistantCodeBlock();
+                break;
+            case "new":
+                this.clearSession();
+                break;
+            case "forkOnlySummary":
+                await this.forkSessionOnlySummary();
+                break;
+            case "forkSummaryAndLastTurn":
+                await this.forkSessionSummaryAndLastTurn();
+                break;
+            case "risk":
+                this.setRiskLevel(cmd.level);
+                break;
+            case "persona":
+                this.switchPersona(cmd.id);
+                break;
+            case "prompt":
+                this.insertPrompt(cmd.id);
+                break;
+            case "bash":
+                await this.runSavedBashCommand(cmd.id);
+                break;
+            case "reload":
+                await this.reloadContent();
+                break;
+            case "unknown":
+                this.addSystemMessage("unknown command. type /help.", palette.noticeError);
+                break;
+        }
+    }
+    showHelp() {
+        this.addSystemMessage(buildHelpText(this.agentsFiles), palette.muted);
+    }
+    async copyLastAssistantMessage() {
+        const lastAssistant = this.getLastAssistantMessage();
+        if (!lastAssistant) {
+            this.addSystemMessage("no assistant message to copy yet.", palette.noticeWarn);
+            return;
+        }
+        const text = extractAssistantText(lastAssistant);
+        if (!text.trim()) {
+            this.addSystemMessage("last assistant message was empty.", palette.noticeWarn);
+            return;
+        }
+        try {
+            await copyTextToClipboard(text);
+            this.addSystemMessage("copied last assistant message to clipboard.", palette.noticeSuccess);
+        }
+        catch (err) {
+            this.addSystemMessage(`clipboard copy failed: ${err.message}`, palette.noticeError);
+        }
+    }
+    async copyLastAssistantCodeBlock() {
+        const lastAssistant = this.getLastAssistantMessage();
+        if (!lastAssistant) {
+            this.addSystemMessage("no assistant message to copy yet.", palette.noticeWarn);
+            return;
+        }
+        const text = extractAssistantText(lastAssistant);
+        const code = extractAllFencedCodeBlocks(text);
+        if (!code) {
+            this.addSystemMessage("no code block to copy yet.", palette.noticeWarn);
+            return;
+        }
+        try {
+            await copyTextToClipboard(code);
+            this.addSystemMessage("copied all code blocks to clipboard.", palette.noticeSuccess);
+        }
+        catch (err) {
+            this.addSystemMessage(`clipboard copy failed: ${err.message}`, palette.noticeError);
+        }
+    }
+    clearSession() {
+        this.engine.reset();
+        this.assistantComponents = [];
+        this.runningBashComponents.clear();
+        this.runningTaskComponents.clear();
+        this.taskEvents.clear();
+        this.subagentCostTotal = 0;
+        this.expandedFilesInCurrentPrompt.clear();
+        this.chatContainer.addMessage(new SessionDividerComponent("new session"));
+        this.isBashMode = false;
+        this.isMemoryMode = false;
+        this.previousSessionSummary = undefined;
+        this.rebuildSystemPrompt();
+        this.updateEditorBorderColor();
+        this.updateFooter();
+        this.ui.requestRender();
+    }
+    escapeXml(text) {
+        return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+    }
+    extractLastTurn(history) {
+        if (history.length === 0) {
+            return {};
+        }
+        let lastUserIndex = -1;
+        let lastUserText;
+        // Find the last user message and extract its text
+        for (let i = history.length - 1; i >= 0; i--) {
+            if (history[i].role === "user") {
+                lastUserIndex = i;
+                const userMessage = history[i];
+                const textParts = [];
+                for (const block of userMessage.content) {
+                    if (typeof block === "string") {
+                        textParts.push(block);
+                    }
+                    else if (block.type === "text") {
+                        textParts.push(block.text);
+                    }
+                }
+                const combined = textParts.join("\n").trim();
+                if (combined) {
+                    lastUserText = combined;
+                }
+                break;
+            }
+        }
+        let lastAssistantText;
+        if (lastUserIndex >= 0) {
+            // Find the last assistant message after the last user message
+            for (let i = history.length - 1; i > lastUserIndex; i--) {
+                if (history[i].role === "assistant") {
+                    const text = extractAssistantText(history[i]).trim();
+                    if (text) {
+                        lastAssistantText = text;
+                    }
+                    break;
+                }
+            }
+        }
+        else {
+            // No user message found; look for the last assistant message overall
+            for (let i = history.length - 1; i >= 0; i--) {
+                if (history[i].role === "assistant") {
+                    const text = extractAssistantText(history[i]).trim();
+                    if (text) {
+                        lastAssistantText = text;
+                    }
+                    break;
+                }
+            }
+        }
+        return { lastUserText, lastAssistantText };
+    }
+    rebuildSystemPrompt(previousSessionSummary) {
+        this.environmentTag = buildEnvironmentTag({
+            riskLevel: this.riskLevel,
+            cwd: process.cwd(),
+            datetime: new Date().toISOString(),
+        });
+        this.baseSystemPrompt = buildBaseSystemPrompt({
+            personaSystemPrompt: this.currentPersona.systemPrompt,
+            projectContextBlock: this.projectContextBlock,
+            environmentTag: this.environmentTag,
+            previousSessionSummary,
+            userPreferences: this.config.userPreferences,
+        });
+        this.engine.setPersona(this.currentPersona, this.baseSystemPrompt);
+    }
+    async generateSummary(history) {
+        const formattedHistory = formatHistoryForCompression(history);
+        const summaryPrompt = `
+Summarize this conversation so another assistant can continue without losing context. Be specific and factual. Aim for extreme compression; at least 90% reduction from the original conversation length, preferably more. Every word should earn its place.
+
+<conversation>
+${formattedHistory.trim()}
+</conversation>
+
+The conversation format uses \`--- USER ---\` and \`--- ASSISTANT ---\` markers. Tool calls appear as \`[Tool call: name(arguments)]\` and outputs as \`[Tool output: name (truncated)]\`. Outputs are truncated, so when tools were used, describe what was attempted rather than assuming outcomes.
+
+Capture only what matters for continuity:
+
+- The goal or topic. What did the user want to accomplish or discuss? Note how this evolved if it changed during the conversation.
+- Key substance. For discussions: important facts, explanations, or ideas that were shared. For coding tasks: files created or modified, commands run, with concrete paths and names. Distinguish between "attempted" and "confirmed working" when tools were involved.
+- Decisions and preferences. Conclusions reached, options chosen, or constraints the user specified. These should carry forward.
+- Open threads. What's unresolved? For discussions: unanswered questions, topics to revisit. For tasks: what's incomplete, broken, or in progress when the conversation ended.
+- Skip the back-and-forth. Collapse tangents and false starts into what ultimately mattered. The reader has no context beyond what you provide, so name things concretely and include enough detail to resume without guessing.
+
+Ruthlessly compress: collapse tangents, skip back-and-forth, omit pleasantries. Name things concretely (paths, functions, errors) but use minimal words.
+
+Write plain prose, no formatting. Be thorough enough that the reader can resume without guessing, but don't narrate every exchange. When relevant, name things concretely: file paths, function names, error messages. The reader has no context beyond what you provide as the summary.
+    `.trim();
+        const apiKey = getApiKeyForProvider(this.config, this.currentPersona.model.provider);
+        const stream = streamSimple(this.currentPersona.model, {
+            systemPrompt: [
+                "You are a precise and thorough conversation summarizer.",
+                "Your task is to distill conversations into clear, actionable summaries that preserve all context needed for seamless continuation.",
+                "Focus on facts, decisions, and concrete details rather than narrative flow.",
+                "Be specific about file paths, function names, and technical details when present.",
+                "Distinguish between what was attempted versus what was confirmed to work.",
+            ].join(" "),
+            messages: [
+                {
+                    role: "user",
+                    content: [{ type: "text", text: summaryPrompt }],
+                    timestamp: Date.now(),
+                },
+            ],
+        }, { reasoning: "medium", ...(apiKey && { apiKey }) });
+        const final = await stream.result();
+        return extractAssistantText(final).trim();
+    }
+    applySessionContext(previousSessionContext) {
+        this.previousSessionSummary = previousSessionContext;
+        // Reset the session state but preserve history with divider and summary
+        this.engine.reset();
+        this.assistantComponents = [];
+        this.runningBashComponents.clear();
+        this.runningTaskComponents.clear();
+        this.taskEvents.clear();
+        this.subagentCostTotal = 0;
+        this.expandedFilesInCurrentPrompt.clear();
+        this.chatContainer.addMessage(new SessionDividerComponent("new session"));
+        this.chatContainer.addMessage(new SessionSummaryComponent(this.previousSessionSummary));
+        this.isBashMode = false;
+        this.isMemoryMode = false;
+        // Rebuild environment tag and system prompt with the new summary and current risk level
+        this.rebuildSystemPrompt(this.previousSessionSummary);
+        this.updateEditorBorderColor();
+        this.updateFooter();
+    }
+    async forkSessionOnlySummary() {
+        const history = this.engine.history;
+        if (history.length === 0) {
+            this.addSystemMessage("no conversation to fork.", palette.noticeWarn);
+            return;
+        }
+        this.addSystemMessage("summarizing session...", palette.noticeSuccess);
+        this.isStreaming = true;
+        this.footer.startWorkingIcon();
+        try {
+            const summary = await this.generateSummary(history);
+            this.applySessionContext(summary);
+            this.addSystemMessage("session forked. previous context has been summarized.", palette.noticeSuccess);
+        }
+        catch (err) {
+            this.addSystemMessage(`fork failed: ${err.message}`, palette.noticeError);
+        }
+        finally {
+            this.footer.stop();
+            this.isStreaming = false;
+            this.ui.requestRender();
+            void this.drainQueuedUserMessages();
+        }
+    }
+    async forkSessionSummaryAndLastTurn() {
+        const history = this.engine.history;
+        if (history.length === 0) {
+            this.addSystemMessage("no conversation to fork.", palette.noticeWarn);
+            return;
+        }
+        this.addSystemMessage("summarizing session...", palette.noticeSuccess);
+        this.isStreaming = true;
+        this.footer.startWorkingIcon();
+        try {
+            const summary = await this.generateSummary(history);
+            // Extract the last turn from history
+            const lastTurn = this.extractLastTurn(history);
+            // Build the combined context with summary and last turn
+            let sessionContext = summary;
+            if (lastTurn.lastUserText || lastTurn.lastAssistantText) {
+                sessionContext += "\n\nLast turn from previous session (verbatim):\n";
+                sessionContext += "<last_turn>";
+                if (lastTurn.lastUserText) {
+                    sessionContext += `\n<last_user_message>${this.escapeXml(lastTurn.lastUserText)}</last_user_message>`;
+                }
+                if (lastTurn.lastAssistantText) {
+                    sessionContext += `\n<last_assistant_message>${this.escapeXml(lastTurn.lastAssistantText)}</last_assistant_message>`;
+                }
+                sessionContext += "\n</last_turn>";
+            }
+            this.applySessionContext(sessionContext);
+            this.addSystemMessage("session forked. previous context and last turn have been included.", palette.noticeSuccess);
+        }
+        catch (err) {
+            this.addSystemMessage(`fork failed: ${err.message}`, palette.noticeError);
+        }
+        finally {
+            this.footer.stop();
+            this.isStreaming = false;
+            this.ui.requestRender();
+            void this.drainQueuedUserMessages();
+        }
+    }
+    setRiskLevel(level) {
+        const previous = this.riskLevel;
+        this.riskLevel = level;
+        this.engine.setRiskLevel(level);
+        this.updateFooter();
+        if (previous !== level) {
+            this.pendingRiskLevelChange = { from: previous, to: level };
+        }
+        const details = getRiskLevelDescription(level);
+        this.addSystemMessage(`risk level set to '${level}': ${details}`, palette.noticeSuccess);
+    }
+    switchPersona(id) {
+        const persona = this.personas.find((p) => p.id.toLowerCase() === id.toLowerCase());
+        if (!persona) {
+            this.addSystemMessage(`unknown persona '${id}'.`, palette.noticeError);
+            return;
+        }
+        this.currentPersona = persona;
+        this.clampPersonaReasoning(this.currentPersona);
+        this.baseSystemPrompt = buildBaseSystemPrompt({
+            personaSystemPrompt: this.currentPersona.systemPrompt,
+            projectContextBlock: this.projectContextBlock,
+            environmentTag: this.environmentTag,
+            previousSessionSummary: this.previousSessionSummary,
+            userPreferences: this.config.userPreferences,
+        });
+        this.engine.setPersona(this.currentPersona, this.baseSystemPrompt);
+        this.updateFooter();
+        this.updateEditorBorderColor();
+        this.addSystemMessage(`switched to ${persona.label} (${persona.model.id})`, palette.noticeSuccess);
+    }
+    insertPrompt(id) {
+        const prompt = this.prompts.find((p) => p.id.toLowerCase() === id.toLowerCase());
+        if (!prompt) {
+            this.addSystemMessage(`unknown prompt '${id}'.`, palette.noticeError);
+            return;
+        }
+        this.editor.setText(prompt.template);
+        this.ui.requestRender();
+    }
+    async runSavedBashCommand(id) {
+        const saved = this.bashCommands.find((b) => b.id.toLowerCase() === id.toLowerCase());
+        if (!saved) {
+            this.addSystemMessage(`unknown bash command '${id}'.`, palette.noticeError);
+            return;
+        }
+        await this.runBashCommand(saved.cmd, { cwd: this.repoRoot });
+    }
+    async reloadContent() {
+        if (this.isStreaming) {
+            this.addSystemMessage("cannot reload while streaming. try again after the response.", palette.noticeWarn);
+            return;
+        }
+        try {
+            const result = await loadAllContent();
+            const { personas, prompts, errors } = result;
+            const bashResult = loadBashCommands(process.cwd());
+            this.bashCommands = bashResult.commands;
+            // Update the personas and prompts lists
+            this.personas = personas;
+            this.prompts = prompts;
+            // Try to preserve the current persona; fall back to first if not found
+            const currentPersonaId = this.currentPersona.id.toLowerCase();
+            const updatedPersona = personas.find((p) => p.id.toLowerCase() === currentPersonaId);
+            if (updatedPersona) {
+                this.currentPersona = updatedPersona;
+                this.clampPersonaReasoning(this.currentPersona);
+            }
+            else {
+                // Persona no longer exists; switch to the first one
+                this.currentPersona = personas[0];
+                this.clampPersonaReasoning(this.currentPersona);
+                this.addSystemMessage(`previous persona no longer available; switched to ${this.currentPersona.label || this.currentPersona.id}.`, palette.noticeWarn);
+            }
+            // Rebuild system prompt and update the engine
+            this.baseSystemPrompt = buildBaseSystemPrompt({
+                personaSystemPrompt: this.currentPersona.systemPrompt,
+                projectContextBlock: this.projectContextBlock,
+                environmentTag: this.environmentTag,
+                previousSessionSummary: this.previousSessionSummary,
+                userPreferences: this.config.userPreferences,
+            });
+            this.engine.setPersona(this.currentPersona, this.baseSystemPrompt);
+            // Update UI
+            this.updateFooter();
+            this.updateEditorBorderColor();
+            // Display summary
+            const personaCount = personas.length;
+            const promptCount = prompts.length;
+            const bashCount = bashResult.commands.length;
+            const errorCount = errors.length + bashResult.errors.length;
+            const summary = errorCount > 0
+                ? `reloaded: ${personaCount} personas, ${promptCount} prompts, ${bashCount} bash commands (${errorCount} errors).`
+                : `reloaded: ${personaCount} personas, ${promptCount} prompts, ${bashCount} bash commands.`;
+            this.addSystemMessage(summary, palette.noticeSuccess);
+            this.ui.requestRender();
+        }
+        catch (err) {
+            this.addSystemMessage(`reload failed: ${err.message}`, palette.noticeError);
+        }
+    }
+    // Assistant Turn --------------------------------------------------------------------------------
+    async runAssistantTurn() {
+        this.isStreaming = true;
+        this.currentTurnAbort = new AbortController();
+        this.footer.startWorkingIcon();
+        try {
+            let currentAssistant;
+            const ensureCurrentAssistant = () => {
+                if (currentAssistant)
+                    return currentAssistant;
+                currentAssistant = {
+                    component: new AssistantMessageComponent(undefined, this.showThinking),
+                    inserted: false,
+                };
+                return currentAssistant;
+            };
+            const ensureAssistantInserted = () => {
+                const state = ensureCurrentAssistant();
+                if (state.inserted)
+                    return;
+                state.inserted = true;
+                this.addAssistantComponent(state.component);
+                state.component.setThinkingVisibility(this.showThinking);
+            };
+            for await (const event of this.engine.processTurn(this.currentTurnAbort.signal)) {
+                if (this.currentTurnAbort.signal.aborted)
+                    break;
+                switch (event.type) {
+                    case "assistant_start":
+                        currentAssistant = {
+                            component: new AssistantMessageComponent(undefined, this.showThinking),
+                            inserted: false,
+                        };
+                        break;
+                    case "assistant_partial": {
+                        const state = ensureCurrentAssistant();
+                        const { snapshot } = event;
+                        const shouldInsert = snapshot.hasTextStarted || (this.showThinking && snapshot.hasAnyThinking);
+                        if (shouldInsert && !state.inserted) {
+                            ensureAssistantInserted();
+                        }
+                        if (state.inserted) {
+                            // Capture visibility state before update
+                            const wasVisible = state.component.hasVisibleText;
+                            state.component.updatePartial(snapshot.hasTextStarted ? snapshot.text : "", snapshot.thinking);
+                            // If component became visible (e.g. text started after thoughts were hidden),
+                            // rebuild the container to show it
+                            if (!wasVisible && state.component.hasVisibleText) {
+                                this.chatContainer.rebuild();
+                            }
+                            this.ui.requestRender();
+                        }
+                        break;
+                    }
+                    case "assistant_final": {
+                        ensureAssistantInserted();
+                        ensureCurrentAssistant().component.updateFromMessage(event.message);
+                        this.chatContainer.rebuild();
+                        this.updateFooter();
+                        this.ui.requestRender();
+                        currentAssistant = undefined;
+                        break;
+                    }
+                    case "tool_ui": {
+                        const uiEvent = event.uiEvent;
+                        if (uiEvent.type === "bash_started") {
+                            // Create and add the running component, storing its index
+                            const index = this.chatContainer.addToolMessage((compact) => renderBashRunning(uiEvent.command, compact));
+                            this.runningBashComponents.set(uiEvent.toolCallId, index);
+                            this.ui.requestRender();
+                        }
+                        else if (uiEvent.type === "bash_execution") {
+                            // Check if we have a running component for this toolCallId
+                            const runningIndex = this.runningBashComponents.get(uiEvent.toolCallId);
+                            if (runningIndex !== undefined) {
+                                // Replace the running component with the finished execution component
+                                this.chatContainer.replaceToolMessageAtIndex(runningIndex, (compact) => renderBashExecution(uiEvent.command, uiEvent.exitCode, uiEvent.truncationInfo, compact));
+                                this.runningBashComponents.delete(uiEvent.toolCallId);
+                            }
+                            else {
+                                // Fallback: add as new component if no running component found
+                                this.chatContainer.addToolMessage((compact) => renderBashExecution(uiEvent.command, uiEvent.exitCode, uiEvent.truncationInfo, compact));
+                            }
+                            this.ui.requestRender();
+                        }
+                        else if (uiEvent.type === "bash_blocked") {
+                            // Check if this is a post-acceptance failure that has a running card
+                            if (uiEvent.toolCallId) {
+                                const runningIndex = this.runningBashComponents.get(uiEvent.toolCallId);
+                                if (runningIndex !== undefined) {
+                                    // Replace the running component with the blocked component
+                                    this.chatContainer.replaceToolMessageAtIndex(runningIndex, (compact) => renderBashBlocked(uiEvent.command, uiEvent.reason, compact));
+                                    this.runningBashComponents.delete(uiEvent.toolCallId);
+                                }
+                                else {
+                                    // Fallback: add as new component if no running component found
+                                    this.chatContainer.addToolMessage((compact) => renderBashBlocked(uiEvent.command, uiEvent.reason, compact));
+                                }
+                            }
+                            else {
+                                // Pre-acceptance blocked event; just append as before
+                                this.chatContainer.addToolMessage((compact) => renderBashBlocked(uiEvent.command, uiEvent.reason, compact));
+                            }
+                            this.ui.requestRender();
+                        }
+                        else if (uiEvent.type === "task_started") {
+                            if (!this.taskEvents.has(uiEvent.toolCallId)) {
+                                this.taskEvents.set(uiEvent.toolCallId, []);
+                            }
+                            const index = this.chatContainer.addToolMessage((compact) => renderTaskRunning(uiEvent.title, [], 0, 0, 0, compact, uiEvent.name));
+                            this.runningTaskComponents.set(uiEvent.toolCallId, index);
+                            this.ui.requestRender();
+                        }
+                        else if (uiEvent.type === "task_progress") {
+                            // Accumulate events for this task
+                            let events = this.taskEvents.get(uiEvent.toolCallId);
+                            if (!events) {
+                                events = [];
+                                this.taskEvents.set(uiEvent.toolCallId, events);
+                            }
+                            events.push(uiEvent.event);
+                            const runningIndex = this.runningTaskComponents.get(uiEvent.toolCallId);
+                            if (runningIndex !== undefined) {
+                                this.chatContainer.replaceToolMessageAtIndex(runningIndex, (compact) => renderTaskRunning(uiEvent.title, events, uiEvent.costTotal, uiEvent.turns, uiEvent.toolCalls, compact, uiEvent.name));
+                            }
+                            else {
+                                const index = this.chatContainer.addToolMessage((compact) => renderTaskRunning(uiEvent.title, events, uiEvent.costTotal, uiEvent.turns, uiEvent.toolCalls, compact, uiEvent.name));
+                                this.runningTaskComponents.set(uiEvent.toolCallId, index);
+                            }
+                            this.ui.requestRender();
+                        }
+                        else if (uiEvent.type === "task_finished") {
+                            const runningIndex = this.runningTaskComponents.get(uiEvent.toolCallId);
+                            if (runningIndex !== undefined) {
+                                this.chatContainer.replaceToolMessageAtIndex(runningIndex, (compact) => renderTaskFinished(uiEvent.title, uiEvent.costTotal, uiEvent.turns, uiEvent.toolCalls, uiEvent.status, uiEvent.finalOutput, compact, uiEvent.name));
+                                this.runningTaskComponents.delete(uiEvent.toolCallId);
+                            }
+                            else {
+                                this.chatContainer.addToolMessage((compact) => renderTaskFinished(uiEvent.title, uiEvent.costTotal, uiEvent.turns, uiEvent.toolCalls, uiEvent.status, uiEvent.finalOutput, compact, uiEvent.name));
+                            }
+                            this.taskEvents.delete(uiEvent.toolCallId);
+                            this.subagentCostTotal += uiEvent.costTotal;
+                            this.updateFooter();
+                            this.ui.requestRender();
+                        }
+                        else if (uiEvent.type === "task_blocked") {
+                            const runningIndex = this.runningTaskComponents.get(uiEvent.toolCallId);
+                            if (runningIndex !== undefined) {
+                                this.chatContainer.replaceToolMessageAtIndex(runningIndex, (compact) => renderTaskBlocked(uiEvent.title, uiEvent.reason, compact, uiEvent.name));
+                                this.runningTaskComponents.delete(uiEvent.toolCallId);
+                            }
+                            else {
+                                this.chatContainer.addToolMessage((compact) => renderTaskBlocked(uiEvent.title, uiEvent.reason, compact, uiEvent.name));
+                            }
+                            this.taskEvents.delete(uiEvent.toolCallId);
+                            this.ui.requestRender();
+                        }
+                        else if (uiEvent.type === "write_success") {
+                            this.chatContainer.addToolMessage((compact) => renderWriteSuccess(uiEvent.path, uiEvent.bytes, uiEvent.lines, uiEvent.preview, uiEvent.previewTruncation, compact));
+                            this.ui.requestRender();
+                        }
+                        else if (uiEvent.type === "write_blocked") {
+                            this.chatContainer.addToolMessage((compact) => renderWriteBlocked(uiEvent.path, uiEvent.reason, compact));
+                            this.ui.requestRender();
+                        }
+                        else if (uiEvent.type === "edit_success") {
+                            this.chatContainer.addToolMessage((compact) => renderEditSuccess(uiEvent.path, uiEvent.oldLength, uiEvent.newLength, uiEvent.diff, uiEvent.diffTruncation, compact));
+                            this.ui.requestRender();
+                        }
+                        else if (uiEvent.type === "edit_blocked") {
+                            this.chatContainer.addToolMessage((compact) => renderEditBlocked(uiEvent.path, uiEvent.reason, compact));
+                            this.ui.requestRender();
+                        }
+                        break;
+                    }
+                    case "notice": {
+                        const style = event.severity === "error"
+                            ? palette.noticeError
+                            : event.severity === "warn"
+                                ? palette.noticeWarn
+                                : palette.noticeSuccess;
+                        this.addSystemMessage(event.text, style);
+                        break;
+                    }
+                    case "tool_result":
+                        break;
+                }
+            }
+        }
+        catch (err) {
+            this.addSystemMessage(`error: ${err.message}`, palette.noticeError);
+        }
+        finally {
+            this.footer.stop();
+            this.isStreaming = false;
+            this.currentTurnAbort = undefined;
+            this.runningBashComponents.clear();
+            this.runningTaskComponents.clear();
+            this.taskEvents.clear();
+            this.ui.requestRender();
+            void this.drainQueuedUserMessages();
+        }
+    }
+    // Direct Bash Execution (user ! commands) -------------------------------------------------------
+    async runBashCommand(command, opts) {
+        this.isStreaming = true;
+        try {
+            const { stdout, stderr, exitCode, truncated: captureTruncated, } = await executeBashTool(command, { cwd: opts?.cwd });
+            const truncationInfo = prepareBashOutput(stdout, stderr, captureTruncated);
+            this.chatContainer.addMessage(renderBashExecution(command, exitCode, truncationInfo, false));
+            this.engine.addUserText(formatBashUserMessageText({ command, truncationInfo }));
+            this.ui.requestRender();
+        }
+        catch (err) {
+            this.addSystemMessage(`bash error: ${err.message}`, palette.noticeError);
+        }
+        finally {
+            this.isStreaming = false;
+            this.ui.requestRender();
+            void this.drainQueuedUserMessages();
+        }
+    }
+    // File Expansion (ctrl+f) -----------------------------------------------------------------------
+    shellQuote(path) {
+        // Wrap in single quotes and escape any single quotes within the path
+        return `'${path.replace(/'/g, "'\\''")}'`;
+    }
+    async expandFileMentions() {
+        if (this.isStreaming) {
+            this.addSystemMessage("cannot expand files while streaming. try again after the response.", palette.noticeWarn);
+            return;
+        }
+        const editorText = this.editor.getText();
+        // Extract @path tokens
+        const tokenRegex = /@([^\s]+)/g;
+        const tokens = [];
+        let match = null;
+        // biome-ignore lint/suspicious/noAssignInExpressions: regex iteration pattern
+        while ((match = tokenRegex.exec(editorText)) !== null) {
+            tokens.push(match[1]);
+        }
+        if (tokens.length === 0) {
+            return;
+        }
+        // Filter to only valid project files and de-duplicate
+        const projectFilesSet = new Set(this.projectFiles);
+        const filesToExpand = [];
+        for (const token of tokens) {
+            // Strip trailing punctuation to handle cases like "@src/app.ts," or "(see @README.md)"
+            const cleanToken = token.replace(/[.,;:)}\]]+$/, "");
+            if (projectFilesSet.has(cleanToken) && !this.expandedFilesInCurrentPrompt.has(cleanToken)) {
+                filesToExpand.push(cleanToken);
+            }
+        }
+        if (filesToExpand.length === 0) {
+            return;
+        }
+        // Run bash commands sequentially for each file
+        for (const filePath of filesToExpand) {
+            const quotedPath = this.shellQuote(filePath);
+            // Format: blank line before header, header, content, blank line after
+            // Ensure trailing newline so multiple files don't run together
+            // Use -- to prevent cat from interpreting filenames starting with - as options
+            const command = `printf '\\n===== %s =====\\n' ${quotedPath}; cat -- ${quotedPath}; printf '\\n'`;
+            await this.runBashCommand(command);
+            // Track this file as expanded in the current prompt
+            this.expandedFilesInCurrentPrompt.add(filePath);
+        }
+    }
+}
+//# sourceMappingURL=app.js.map