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

package/dist/tui/state.d.ts

@@ -2,7 +2,7 @@
  * Pure presentation logic for the TUI: formatting, command parsing and the reduction of
  * versioned runner events into a view model. No terminal or pi-tui imports here.
  */
-import type { Message, ModelInfo, RunEvent } from "@alisio/sdk";
+import type { Message, ModelInfo, RunEvent, ToolResult, TreeNode, UiBlock } from "@alisio/sdk";
 export type Level = "ok" | "warn" | "danger";
 export declare function formatTokens(n: number): string;
 /** Prefixes every model with its owning provider so identical model ids are never ambiguous. */
@@ -246,6 +246,8 @@ export interface EditSummary {
 }
 export declare function editSummary(name: string, args: string): EditSummary | undefined;
 export type ToolStatus = "running" | "approval" | "ok" | "error";
+/** Capability kind of a tool call; drives grouping labels and batch display. */
+export type ToolKind = "read" | "write" | "process" | "mcp" | "internal" | "other";
 export type TranscriptItem = {
     kind: "user";
     text: string;
@@ -254,6 +256,10 @@ export type TranscriptItem = {
     text: string;
     reasoning: string;
     done: boolean;
+    /** Epoch ms of the first reasoning delta; with `reasoningDoneAt` it approximates the thinking interval. */
+    reasoningStartedAt?: number;
+    /** Epoch ms of the last reasoning delta (the end of the visible thought section). */
+    reasoningDoneAt?: number;
 } | {
     kind: "tool";
     id: string;
@@ -263,6 +269,17 @@ export type TranscriptItem = {
     status: ToolStatus;
     durationMs?: number;
     preview?: string;
+    /** Structured block rendered natively by the TUI (from a `{type:"ui"}` result part). */
+    ui?: UiBlock;
+    /** Base64 image rendered inline by the TUI when the terminal supports it (from a `{type:"image"}` part). */
+    image?: {
+        mimeType: string;
+        data: string;
+    };
+    /** Effect-derived kind (grouping label); name-heuristic fallback for replayed history. */
+    toolKind?: ToolKind;
+    /** Exit code derived safely from the JSON preview when the tool reports one (run_process/shell/search_text). */
+    exitCode?: number;
 } | {
     kind: "notice";
     text: string;
@@ -302,7 +319,155 @@ export interface ViewState {
 }
 export declare function initialViewState(model: string, now?: number): ViewState;
 export declare function addItem(state: ViewState, item: TranscriptItem): ViewState;
+/** Approximated thinking interval of a completed reasoning section, when the events carried timestamps. */
+export declare function reasoningDurationMs(item: {
+    reasoningStartedAt?: number;
+    reasoningDoneAt?: number;
+}): number | undefined;
 export declare function reduceEvent(state: ViewState, event: RunEvent): ViewState;
 export declare function lastAssistantText(items: TranscriptItem[]): string | undefined;
+/**
+ * True when a printable key should copy the last assistant response instead of typing: bound to
+ * `c`/`y` (and uppercase) on an EMPTY editor line, while no autocomplete is showing and no turn
+ * is running — the same "empty input" convention Enter and Ctrl+D already use. A non-empty input
+ * never triggers, so typing `c` or `y` mid-message is unaffected.
+ */
+export declare function editorCopyKey(data: string, input: {
+    text: string;
+    autocomplete: boolean;
+    busy: boolean;
+}): boolean;
+/** True when an unknown event value is a `Node` of a tree UI block. */
+export declare function isTreeNode(value: unknown): value is TreeNode;
+/** True when an unknown event value is an Alisio `UiBlock` (validated defensively). */
+export declare function isUiBlock(value: unknown): value is UiBlock;
+/** True when an unknown event value is a `{type:"image"}`-style part (mime + base64 data). */
+export declare function isImagePart(value: unknown): value is {
+    mimeType: string;
+    data: string;
+};
+/** Rich (ui/image) parts of a persisted tool result, if any. */
+export declare function richPartsOf(result: ToolResult | undefined): {
+    ui?: UiBlock;
+    image?: {
+        mimeType: string;
+        data: string;
+    };
+};
+/**
+ * `read_file` → `Read File`, `search_text` → `Search Text`, `mcp_devforge_time_diff` →
+ * `MCP · Devforge Time Diff`. Splits on `_`/`-`/`.`/spaces, keeps known acronyms (MCP, HTTP…)
+ * and bare numeric suffixes (`read_file_2` → `Read File 2`). The machine name stays available
+ * dimmed in grouped detail rows and in the `/tools` and `/stats` reports.
+ */
+export declare function humanizeToolName(name: string): string;
+/** Verb and count noun used by grouped batch rows per tool kind. */
+export declare const TOOL_KIND_VERB: Record<ToolKind, string>;
+export declare const TOOL_KIND_WORD: Record<ToolKind, string>;
+/**
+ * Capability kind of a tool call. Live events carry the registry `effect` (exact); replayed
+ * history falls back to conservative name heuristics. `mcp_*` is always the mcp kind.
+ */
+export declare function toolKindOf(name: string, effect?: string): ToolKind;
+/** Terminal-preview caps for collapsed rows (same values the renderer always used). */
+export declare const OUTPUT_PREVIEW_LINES_OK = 3;
+export declare const OUTPUT_PREVIEW_LINES_ERROR = 6;
+export declare const previewLinesFor: (status: ToolStatus) => number;
+/** Preview rows as the renderer shows them: blank lines dropped, tabs kept for the caller to expand. */
+export declare const previewRows: (preview: string) => string[];
+/** True when the preview exceeds the collapsed cap (the row becomes a collapsible "output"). */
+export declare function previewTruncated(preview: string | undefined, status: ToolStatus): boolean;
+/**
+ * Exit code derived safely from a text preview. `run_process`/`shell`/`search_text` return
+ * `{stdout, stderr, exitCode, truncated}` JSON; read-effect tools may carry an appended
+ * `\n<instructions>…` block, retried on the JSON prefix. Any other shape yields nothing.
+ */
+export declare function exitCodeOf(preview: string | undefined): number | undefined;
+/** Renderable view of one tool call (singleton row, or a member of a grouped batch). */
+export interface ToolItemView {
+    id: string;
+    /** Machine name (kept for dimmed detail display). */
+    name: string;
+    /** Humanized display name. */
+    humanName: string;
+    kind: ToolKind;
+    summary: string;
+    status: ToolStatus;
+    durationMs?: number;
+    preview?: string;
+    ui?: UiBlock;
+    image?: {
+        mimeType: string;
+        data: string;
+    };
+    exitCode?: number;
+}
+/** A batch of consecutive same-kind, finished tool calls rendered as ONE collapsible row. */
+export interface GroupedTool {
+    /** Id of the first member call (stable fold key while the batch grows). */
+    id: string;
+    members: ToolItemView[];
+    kind: ToolKind;
+    /** Aggregate: `error` when any member failed, else `ok` (members are all terminal). */
+    status: ToolStatus;
+    /** Sum of member durations. */
+    totalMs: number;
+    /** Header name: the shared humanized tool name, or the kind verb for mixed batches. */
+    label: string;
+    /** Count noun matching `label` (`reads`, `files`, `commands`…). */
+    word: string;
+}
+/** Everything the transcript renders: a plain item, or one grouped batch row. */
+export type TranscriptEntry = TranscriptItem | {
+    kind: "group";
+    group: GroupedTool;
+};
+export declare function toolItemView(item: Extract<TranscriptItem, {
+    kind: "tool";
+}>): ToolItemView;
+/**
+ * Consecutive tool calls of the same kind whose statuses are ALL terminal (ok/error) merge into
+ * one `group` entry; running/approval calls always stay singleton so their spinner and live state
+ * stay visible. A kind change splits the run (`read` never merges with `shell`). Order is
+ * preserved; every entry carries its index within `items` (fold keys for assistant items need
+ * it). One linear pass — called on state changes only, never per frame.
+ */
+export declare function groupToolEntries(items: TranscriptItem[]): Array<{
+    entry: TranscriptEntry;
+    at: number;
+}>;
+/** Content identity of a group (fold/diff purposes): member ids, statuses and durations. */
+export declare function groupIdentity(group: GroupedTool): string;
+export type FoldableKind = "reasoning" | "group" | "output";
+/** A collapsible region of the transcript and how to address it (fold key, toggle target). */
+export interface FoldCandidate {
+    /** Stable key for the fold state map (`a:` assistant index, `g:`/`t:` tool ids). */
+    key: string;
+    kind: FoldableKind;
+    /** Running/live content defaults expanded; finished reasoning, batches and long output collapse. */
+    defaultExpanded: boolean;
+}
+/** Cap for the reasoning text when expanded; longer sections show a truncation note. */
+export declare const REASONING_EXPAND_MAX_LINES = 40;
+/**
+ * The fold contract of one transcript entry: nothing (not collapsible), or a candidate with its
+ * default state. `at` is the entry's index within the ORIGINAL items array (assistant fold keys
+ * are stable because transcript items are append-only).
+ */
+export declare function foldCandidateOf(entry: TranscriptEntry, at: number): FoldCandidate | undefined;
+/** Stable key of a transcript entry (used by the component sync to reuse row instances). */
+export declare function entryKeyOf(entry: TranscriptEntry, at: number): string;
+/** Every fold candidate of the transcript in display order; the keybinding targets the last one. */
+export declare function foldCandidates(items: TranscriptItem[]): FoldCandidate[];
+/**
+ * True when a printable key should toggle the nearest collapsible transcript row instead of
+ * typing: bound to `x`/`X` on an EMPTY editor line (no autocomplete), the same "empty input"
+ * convention Enter, Ctrl+D and `c`/`y` already use. Unlike copy, it also works while a turn runs
+ * (the nearest candidate may still exist mid-stream). A non-empty input never triggers.
+ */
+export declare function foldToggleKey(data: string, input: {
+    text: string;
+    autocomplete: boolean;
+}): boolean;
 /** Rebuilds transcript items from persisted history (used by /resume). */
 export declare function itemsFromHistory(messages: Message[]): TranscriptItem[];