@alisio/alisio-code 0.1.0-alpha.9 → 0.1.1

package/dist/tui/state.d.ts

@@ -1,8 +1,4 @@
-/**
- * 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. */
@@ -39,11 +35,46 @@ export interface PluginCatalogView {
 }
 /** Text markers remain meaningful without color: [x] active, [ ] inactive, [!] failed, [*] pending. */
 /** Group headings are derived from the primary category (or "General") of each plugin. */
-export declare function pluginCatalogItems(entries: PluginCatalogView[]): {
+/**
+ * Reserved value prefix marking a non-selectable group-header row in picker item lists. It can
+ * never collide with real entry ids (plugin ids, server names), which never start with "_".
+ */
+export declare const GROUP_HEADER_PREFIX = "__group:";
+/** True when the item is a group header emitted under GROUP_HEADER_PREFIX (never selectable). */
+export declare const isGroupHeader: (item: {
+    value: string;
+}) => boolean;
+/**
+ * Nearest non-header index from `index` stepping `dir` (1 = down, -1 = up), wrapping at the
+ * edges exactly like a plain list would, so navigation skips header rows in both directions and
+ * never stops on one. Returns -1 for an empty list and `index` unchanged when every item is a
+ * header (callers then treat it as "no move").
+ */
+export declare function skipGroupHeaders(items: readonly {
+    value: string;
+}[], index: number, dir: 1 | -1): number;
+/**
+ * The display sequence a picker should render for a filter: rows matching SelectList's own
+ * prefix semantics, plus the group header of every group that still has at least one visible
+ * row, in original order. Groups with no match emit no header.
+ */
+export declare function visibleGroupedItems(items: ReadonlyArray<{
+    value: string;
+    label: string;
+    description?: string;
+}>, filter: string): Array<{
+    value: string;
+    label: string;
+    description?: string;
+}>;
+export declare function pluginCatalogItems(entries: PluginCatalogView[]): ({
+    value: string;
+    label: string;
+} | {
     value: string;
     label: string;
     description: string;
-}[];
+})[];
 export declare const pluginToggleNeedsConfirmation: (entry: PluginCatalogView) => boolean;
 export interface McpServerView {
     name: string;
@@ -116,6 +147,10 @@ export interface CommandSpec {
     argumentHint?: string;
     aliases?: string[];
 }
+/**
+ * Built-in slash commands the TUI offers, derived from the core `CommandCatalog` (the TUI
+ * surface of `BUILTIN_COMMANDS`). Kept as `COMMANDS` for compatibility.
+ */
 export declare const COMMANDS: CommandSpec[];
 /** Every TUI slash name (commands, aliases and routing prefixes); templates cannot take them. */
 export declare function reservedCommandNames(): string[];
@@ -124,6 +159,117 @@ export declare function parseCommand(input: string): {
     name: string;
     args: string;
 } | undefined;
+/** Reasoning-effort capability advertised by a model's catalog entry (`ModelInfo.effort`). */
+export interface EffortCapability {
+    supportedLevels: string[];
+    defaultLevel?: string;
+}
+/**
+ * The effective reasoning effort to send for a model: the persisted level when the model
+ * supports it, otherwise the model's default level (silent fallback), and nothing when the
+ * model advertises no effort levels at all.
+ */
+export declare function effectiveEffort(persisted: string | undefined, capability: EffortCapability | undefined): string | undefined;
+/** Validates a `/effort <level>` argument against the active model; returns an error or nothing. */
+export declare function validateEffortLevel(level: string, capability: EffortCapability | undefined): string | undefined;
+export declare function effortPickerItems(capability: EffortCapability, active: string | undefined): Array<{
+    value: string;
+    label: string;
+    description?: string;
+}>;
+/** Role of a status-line identity part; the renderer maps each role to a distinct color. */
+export type IdentityRole = "agent" | "mode" | "model" | "provider" | "effort";
+export interface IdentityPart extends Segment {
+    role: IdentityRole;
+}
+export interface IdentityInput {
+    agent: string;
+    /** Permission mode (`ask`, `auto`, `full`, `custom`, `read-only`); omitted when unknown. */
+    mode?: string;
+    model: string;
+    provider?: string;
+    effort?: string;
+}
+/**
+ * The ordered identity parts for the status line below the editor:
+ * `agent: <name> · <model> · <provider> · <effort>`, with the effort part omitted when the
+ * active model advertises no supported levels (`effort === undefined`). Colors are applied by
+ * the renderer per role; this module stays terminal-free and testable.
+ */
+export declare function identityParts(input: IdentityInput): IdentityPart[];
+/** Drops the lowest-priority identity parts until the line fits `width`; truncates the survivor. */
+export declare function fitIdentityParts(input: IdentityInput, width: number): IdentityPart[];
+/** Minimal structural view of a skill for slash autocompletion (subset of the core catalog entry). */
+export interface SkillCompletionEntry {
+    id: string;
+    name: string;
+    displayId: string;
+    description: string;
+    /** Catalog scope of the skill: user | project | config | plugin (drives the [u]/[p]/[c]/[l] marker). */
+    scope?: string;
+    enabled: boolean;
+    locked: boolean;
+    effective: boolean;
+}
+export interface SlashCompletionItem {
+    value: string;
+    label: string;
+    description?: string;
+}
+export declare const SKILL_COMPLETION_DESCRIPTION_LIMIT = 80;
+/**
+ * OpenCode-style scope marker for a skill's slash entry, mirroring the catalog scopes the /skills
+ * manager shows: user, project, config and plugin (plugin skills are locked by their owner plugin).
+ */
+export declare const skillScopeMarker: (skill: SkillCompletionEntry) => string | undefined;
+/**
+ * Description for a skill's first-class `skill:<id>` slash entry: scope marker, status hint, then
+ * the skill description truncated to the shared limit. The marker and status are prepended before
+ * truncating, so they survive the cap just like the /skills argument completions.
+ */
+export declare function skillSlashDescription(skill: SkillCompletionEntry): string;
+/**
+ * Suggested completions for `/skills <prefix>`: every entry the /skills manager shows, filtered by
+ * prefix (case-insensitive) on name or description. Selecting a suggestion only fills the argument;
+ * submitting still opens the skills manager.
+ */
+export declare function skillCompletions(catalog: SkillCompletionEntry[], prefix: string, limit?: number): SlashCompletionItem[];
+export interface SlashCompletionSource {
+    name: string;
+    description?: string;
+    argumentHint?: string;
+    aliases?: string[];
+}
+export interface SlashCompletionContext {
+    /** Live session rows for `/resume`: already filtered to the typed prefix and mapped. */
+    sessions?: (prefix: string) => SlashCompletionItem[];
+    /** Effective skill catalog backing `/skills` (the same entries the skills manager shows). */
+    skills: SkillCompletionEntry[];
+}
+/**
+ * Builds the editor slash-autocomplete command list. Aliases get their own entries with the same
+ * description and argument completions, because the provider matches commands by fuzzy name.
+ * Effective skills are appended as first-class `skill:<id>` entries so `/ski…`, `/skill:b…` and
+ * even `/branch…` all surface them; submitting already routes `skill:` commands to skill load, so
+ * selecting an entry only needs to insert the command name. `options.skillEntries: false` gates
+ * ONLY those standalone `skill:` entries (e.g. the `tui.skillSlashCommands` toggle): the `/skills`
+ * manager and its argument completion keep working, since `context.skills` still feeds both.
+ */
+export interface SlashCompletionOptions {
+    /** Include first-class `skill:<id>` entries for effective skills (default true). */
+    skillEntries?: boolean;
+}
+export declare function slashCompletionCommands(sources: SlashCompletionSource[], context: SlashCompletionContext, options?: SlashCompletionOptions): ({
+    getArgumentCompletions: (prefix: string) => SlashCompletionItem[];
+    name: string;
+    description: string | undefined;
+    argumentHint?: string | undefined;
+} | {
+    getArgumentCompletions?: undefined;
+    name: string;
+    description: string | undefined;
+    argumentHint?: string | undefined;
+})[];
 export declare function summarizeToolArgs(name: string, args: string): string;
 export interface DiffLine {
     sign: "+" | "-";
@@ -137,6 +283,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;
@@ -145,6 +293,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;
@@ -154,6 +306,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;
@@ -182,6 +345,16 @@ export interface ViewState {
     items: TranscriptItem[];
     streaming: boolean;
     compacting: boolean;
+    /** The runner is sending a silent request again (`request_retry`); cleared by any output. */
+    retry?: {
+        attempt: number;
+        of: number;
+    };
+    /** The response was cut by the output limit and is requested again (`truncation_recovery`). */
+    recovery?: {
+        attempt: number;
+        of: number;
+    };
     model: string;
     /** Context size in tokens: provider-reported, or estimated (`~`). */
     context?: {
@@ -189,11 +362,174 @@ export interface ViewState {
         estimated: boolean;
     };
     runStartedAt?: number;
+    /** Epoch ms of the latest event of the live run (any type); undefined when no run is live. */
+    lastEventAt?: number;
     stats: Stats;
 }
 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;
+/** No event for this long: the footer says how long the run has been quiet. */
+export declare const QUIET_MS = 15000;
+/** No event for this long: the footer marks the run as possibly stuck. */
+export declare const STALLED_MS = 60000;
+export interface RunPhase {
+    label: string;
+    /** Silence is expected here (the user's turn, or a sub-agent working in its own session). */
+    silentByDesign: boolean;
+}
+/** What the live run is doing, from the transcript items and flags the events already update. */
+export declare function runPhase(view: ViewState): RunPhase;
+/** Milliseconds of silence worth reporting (0 when the run is busy, or silent by design). */
+export declare function quietFor(view: ViewState, now: number): number;
 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, toolName?: string): {
+    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[];