@alisio/alisio-code 0.1.0-alpha.15 → 0.1.0-alpha.16

package/dist/tui/app.js

@@ -1,5 +1,5 @@
 import { homedir } from "node:os";
-import { CombinedAutocompleteProvider, Container, Editor, getImageDimensions, getNativeClipboard, Key, matchesKey, ProcessTerminal, ScrollView, SelectList, TuiAltScreen, truncateToWidth, VStack, } from "@earendil-works/pi-tui";
+import { CombinedAutocompleteProvider, Container, Editor, getImageDimensions, getNativeClipboard, Key, MouseRegion, matchesKey, ProcessTerminal, ScrollView, SelectList, TuiAltScreen, truncateToWidth, VStack, } from "@earendil-works/pi-tui";
 import { loadVersion } from "../version.js";
 import { activeAgentCatalog, agentPickerItems, agentRunOptions, mainAgentFromRecord, resolveActiveAgent, } from "./agents.js";
 import { MAX_ATTACHMENTS_PER_MESSAGE, MAX_IMAGE_BYTES, pasteImageFromClipboard, removeLastAttachment, toApiAttachment, } from "./attachments.js";
@@ -14,7 +14,7 @@ import { InteractiveQueue } from "./queue.js";
 import { settingsMenuRows } from "./settings.js";
 import { SettingsMenu } from "./settings-menu.js";
 import { SkillsManager } from "./skills-manager.js";
-import { addItem, COMMANDS, configuredProviderModelItems, effectiveEffort, effortPickerItems, formatContext, formatDuration, formatTokens, hostOf, initialViewState, itemsFromHistory, lastAssistantText, mcpServerItems, mcpToolItems, parseCommand, pluginCatalogItems, pluginToggleNeedsConfirmation, providerModelItems, reduceEvent, reservedCommandNames, resolveCommand, shortenPath, shortId, slashCompletionCommands, summarizeToolArgs, validateEffortLevel, } from "./state.js";
+import { addItem, COMMANDS, configuredProviderModelItems, editorCopyKey, effectiveEffort, effortPickerItems, foldCandidates, foldToggleKey, formatContext, formatDuration, formatTokens, hostOf, initialViewState, itemsFromHistory, lastAssistantText, mcpServerItems, mcpToolItems, parseCommand, pluginCatalogItems, pluginToggleNeedsConfirmation, providerModelItems, reduceEvent, reservedCommandNames, resolveCommand, richPartsOf, shortenPath, shortId, slashCompletionCommands, summarizeToolArgs, validateEffortLevel, } from "./state.js";
 import { editorTheme, selectListTheme, style } from "./theme.js";
 const VERSION = loadVersion(import.meta.url);
 /** Inline selection list with type-to-filter, rendered above the editor. */
@@ -170,6 +170,23 @@ export async function runTui(options) {
     // Read-only views of child sessions (subagents), fed by their events.
     const childViews = new Map();
     const childView = new TranscriptSync();
+    // Fold state of every collapsible transcript row (reasoning sections, tool batches, long
+    // outputs). Keyed by stable fold keys from state.ts; absent entries use the pure defaults.
+    const folded = new Map();
+    const foldOf = (candidate) => folded.get(candidate.key) ?? candidate.defaultExpanded;
+    main.setFoldResolver(foldOf);
+    childView.setFoldResolver(foldOf);
+    /** Which transcript is on screen right now (child view while viewing a subagent, else main). */
+    const visibleTranscript = () => viewedState()
+        ? { items: viewedState()?.items ?? [], sync: childView }
+        : { items: view.items, sync: main };
+    /** Applies one fold toggle and re-syncs only the affected transcript (cheap: events, not frames). */
+    const toggleFold = (candidate) => {
+        folded.set(candidate.key, !(folded.get(candidate.key) ?? candidate.defaultExpanded));
+        const visible = visibleTranscript();
+        visible.sync.sync(visible.items);
+        tui.requestRender();
+    };
     let panelState = initialPanelState();
     const startupDiagnostics = [];
     let hint;
@@ -312,18 +329,32 @@ export async function runTui(options) {
     bottom.addChild(editor);
     bottom.addChild(treePanel);
     bottom.addChild(footer);
+    // Click-to-toggle on collapsible transcript rows: pi-tui synthesizes `click` events after a
+    // press+release without movement, so plain clicks fold/unfold while drag-selection keeps
+    // working (copyOnSelect must never be disturbed). The region sits between the ScrollView and
+    // the content switch; content rows = visible rows + the scroll offset.
+    let transcriptScroll;
+    const transcriptRegion = new MouseRegion(new Switch(() => (viewedState() ? childView.container : transcript)), (event) => {
+        if (picker || event.type !== "click" || event.button !== "left")
+            return undefined;
+        const scroll = transcriptScroll;
+        if (!scroll)
+            return undefined;
+        const visible = visibleTranscript();
+        const candidate = visible.sync.entryAt(event.y + scroll.scrollTop, event.width);
+        if (!candidate)
+            return undefined;
+        toggleFold(candidate);
+        return { handled: true };
+    });
+    transcriptScroll = new ScrollView(transcriptRegion, {
+        follow: "end",
+        primary: true,
+        overscroll: "chain",
+    });
     tui.setLayoutRoot(new VStack([
         { component: header, basis: "auto" },
-        {
-            component: new ScrollView(new Switch(() => (viewedState() ? childView.container : transcript)), {
-                follow: "end",
-                primary: true,
-                overscroll: "chain",
-            }),
-            basis: 0,
-            grow: 1,
-            minSize: 1,
-        },
+        { component: transcriptScroll, basis: 0, grow: 1, minSize: 1 },
         { component: bottom, basis: "auto", shrink: 1, minSize: 3 },
     ]));
     // Prime the active provider's catalog so the context bar shows the model's real window
@@ -373,6 +404,14 @@ export async function runTui(options) {
     const info = (text) => push({ kind: "info", text });
     let terminalEvent = false;
     dispatch = (event) => {
+        // The event stream stays text-only (headless/JSONL consumers see the projection); the TUI
+        // pulls the persisted rich parts (ui/image) itself so native rendering survives resume.
+        if (event.type === "tool_completed") {
+            const data = (event.data ?? {});
+            const rich = richPartsOf(app.store.callResult(event.sessionId, String(data.id ?? "")));
+            if (rich.ui !== undefined || rich.image !== undefined)
+                event = { ...event, data: { ...data, ...rich } };
+        }
         if (event.sessionId !== session) {
             // Child session (e.g. a subagent): keep a view model for its read-only view.
             const child = childViews.get(event.sessionId) ?? initialViewState(view.model);
@@ -1316,7 +1355,7 @@ export async function runTui(options) {
         "- `/init` (above) writes AGENTS.md; the shell command `alisio setup` only scaffolds `.alisio/config.json`",
         "- `/command plugin.id:name args` — run a plugin command",
         "",
-        "**Keys**: Enter send · Shift+Enter / Alt+Enter / Ctrl+J newline · Tab complete · ↑↓ history · Esc interrupt · Ctrl+C clear input (twice to exit) · Ctrl+D exit on empty input · PgUp/PgDn or mouse wheel scroll · Ctrl+X agent panel · Ctrl+B background running agents",
+        "**Keys**: Enter send · Shift+Enter / Alt+Enter / Ctrl+J newline · Tab complete · ↑↓ history · Esc interrupt · Ctrl+C clear input (twice to exit) · Ctrl+D exit on empty input · c / y copy last response (empty input) · x expand/collapse latest thought/tool batch/output (empty input) · click a collapsible header row to toggle it · PgUp/PgDn or mouse wheel scroll · Ctrl+X agent panel · Ctrl+B background running agents",
         `**Paste**: multi-line text pastes as one block automatically · Ctrl+V attach a clipboard image (PNG/JPEG/GIF/WebP, up to ${(MAX_IMAGE_BYTES / (1024 * 1024)).toFixed(0)} MB, up to ${MAX_ATTACHMENTS_PER_MESSAGE} per message) · Ctrl+R remove the last attached image`,
     ].join("\n");
     const mutating = new Set([
@@ -1607,6 +1646,20 @@ export async function runTui(options) {
                 removeAttachment();
                 return { consume: true };
             }
+            // `x` on an EMPTY editor line toggles the nearest collapsible transcript row — a finished
+            // `Thought` section, a grouped batch of tool calls, or a long command output. Same
+            // empty-input convention as Enter, Ctrl+D and `c`/`y`; typing `x` mid-message is never
+            // intercepted, and with nothing collapsible it types normally.
+            if (foldToggleKey(data, {
+                text: editor.getText(),
+                autocomplete: editor.isShowingAutocomplete(),
+            })) {
+                const target = foldCandidates(visibleTranscript().items).at(-1);
+                if (target) {
+                    toggleFold(target);
+                    return { consume: true };
+                }
+            }
         }
         if (!picker) {
             if (matchesKey(data, Key.ctrl("x"))) {
@@ -1643,6 +1696,24 @@ export async function runTui(options) {
                     return { consume: true };
                 }
             }
+            // `c`/`y` on an EMPTY editor line copies the last assistant response as raw text, the same
+            // as /copy; typing `c` or `y` mid-message is never intercepted.
+            if (editorCopyKey(data, {
+                text: editor.getText(),
+                autocomplete: editor.isShowingAutocomplete(),
+                busy,
+            })) {
+                const last = lastAssistantText(view.items);
+                if (last) {
+                    void copy(last).then((result) => {
+                        const message = copyMessage(result);
+                        tui.flash(message);
+                        if (!result.ok)
+                            notice(message);
+                    });
+                }
+                return { consume: true };
+            }
         }
         if (matchesKey(data, Key.escape)) {
             if (busy && !picker && !editor.isShowingAutocomplete()) {

package/dist/tui/components.d.ts

@@ -1,14 +1,28 @@
-import type { PanelNode } from "@alisio/sdk";
+import type { PanelNode, TreeNode, UiBlock } from "@alisio/sdk";
 import { type Component, Container } from "@earendil-works/pi-tui";
 import { type PendingAttachment } from "./attachments.ts";
 import { type QuestionPanelState, type QuestionSpec } from "./questions.ts";
-import { type ContextBudget, type IdentityInput, type TranscriptItem, type ViewState } from "./state.ts";
+import { type ContextBudget, type FoldableKind, type FoldCandidate, type GroupedTool, type IdentityInput, type TranscriptEntry, type TranscriptItem, type ViewState } from "./state.ts";
 export declare const SPINNER: string[];
 /** Shared animation clock advanced by the app while work is running. */
 export declare const clock: {
     frame: number;
     now: number;
 };
+/** Fold state the components receive: neither knows keys nor defaults (components stay dumb). */
+export interface FoldInfo {
+    expanded: boolean;
+    kind: FoldableKind;
+}
+/** `Command exited with code 0.` (green) / `Command exited with code N.` (red) when known. */
+export declare const exitCodeLine: (code: number | undefined, indent?: string) => string | undefined;
+/**
+ * Tree rendering with branch glyphs: `├─`/`└─`/`│` when the terminal supports Unicode, ASCII
+ * `|-`/`` `- ``/`|` otherwise.
+ */
+export declare function renderTreeLines(nodes: TreeNode[], unicode: boolean): string[];
+/** Renders a `{type:"ui"}` block to styled lines for the given inner width. */
+export declare function renderUiBlock(block: UiBlock, width: number, unicode: boolean): string[];
 export type PermissionState = "on" | "ask" | "off";
 export interface HeaderInfo {
     version: string;
@@ -53,13 +67,17 @@ export declare class UserBlock implements Component {
 }
 export declare class AssistantBlock implements Component {
     private markdown;
+    /** Bumped by TranscriptSync when this row's content changes; render caches on it. */
+    version: number;
+    fold?: FoldInfo;
     private item;
+    private cache?;
     constructor(item: Extract<TranscriptItem, {
         kind: "assistant";
     }>);
     update(item: Extract<TranscriptItem, {
         kind: "assistant";
-    }>): void;
+    }>, fold?: FoldInfo | undefined): void;
     invalidate(): void;
     render(width: number): string[];
 }
@@ -67,9 +85,34 @@ export declare class ToolBlock implements Component {
     item: Extract<TranscriptItem, {
         kind: "tool";
     }>;
+    /** Bumped by TranscriptSync when this row's content changes; render caches on it. */
+    version: number;
+    fold?: FoldInfo;
+    private markdown?;
+    private cache?;
     constructor(item: Extract<TranscriptItem, {
         kind: "tool";
     }>);
+    update(item: Extract<TranscriptItem, {
+        kind: "tool";
+    }>, fold?: FoldInfo | undefined): void;
+    invalidate(): void;
+    render(width: number): string[];
+}
+/**
+ * One collapsible row for a GROUPED batch of finished tool calls (e.g. `✓ Read File — 3 reads`).
+ * Collapsed it shows the aggregate header; expanded, each call with its status, duration,
+ * summary and capped preview/rich body. All members are terminal, so lines are cached per
+ * version/width/fold just like the other terminal rows.
+ */
+export declare class ToolGroupBlock implements Component {
+    group: GroupedTool;
+    /** Bumped by TranscriptSync when this row's content changes; render caches on it. */
+    version: number;
+    fold?: FoldInfo;
+    private cache?;
+    constructor(group: GroupedTool);
+    update(group: GroupedTool, fold?: FoldInfo | undefined): void;
     invalidate(): void;
     render(width: number): string[];
 }
@@ -86,7 +129,31 @@ export declare class InfoBlock implements Component {
     invalidate(): void;
     render(width: number): string[];
 }
-export declare function componentFor(item: TranscriptItem): Component;
+export declare function componentFor(entry: TranscriptEntry): Component;
+/**
+ * Keeps a container of transcript components in step with view-model items. Rows are keyed
+ * (stable per fold candidate: tool ids, group ids, append-only item indices) and reused across
+ * syncs; batch groups replace their members' singleton components with one row once all of them
+ * finish. Content versions bump only when a row's entry actually changed, so clock frames
+ * between events reuse each component's cached lines instead of re-rendering. `setFoldResolver`
+ * supplies the effective expanded state; the same resolution feeds `entryAt`, so keybindings
+ * and mouse clicks agree with the renderer.
+ */
+export declare class TranscriptSync {
+    readonly container: Container;
+    private rows;
+    private order;
+    private foldOf;
+    setFoldResolver(resolver: (candidate: FoldCandidate) => boolean): void;
+    sync(items: TranscriptItem[]): void;
+    /**
+     * Fold candidate at a transcript content row, when the click landed on the row's header
+     * (assistant entries start with a blank spacer line, so their first two rows count). Used by
+     * click-to-toggle; keyboard toggling uses `foldCandidates` instead and needs no heights.
+     */
+    entryAt(contentY: number, width: number): FoldCandidate | undefined;
+    reset(): void;
+}
 /** Startup screen rendered by core for the current width (cached until the width changes). */
 export declare class BannerBlock implements Component {
     private renderLines;
@@ -95,13 +162,6 @@ export declare class BannerBlock implements Component {
     invalidate(): void;
     render(width: number): string[];
 }
-/** Keeps a container of transcript components in step with view-model items. */
-export declare class TranscriptSync {
-    readonly container: Container;
-    private rendered;
-    sync(items: TranscriptItem[]): void;
-    reset(): void;
-}
 /** Renders one of several components (main conversation or a read-only child view). */
 export declare class Switch implements Component {
     private pick;