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

package/dist/tui/components.d.ts

@@ -1,24 +1,57 @@
-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 BtwAction, type BtwState } from "./btw.ts";
+import { type PlanReviewEffect, type PlanReviewOption } from "./plan-review.ts";
 import { type QuestionPanelState, type QuestionSpec } from "./questions.ts";
-import { type ContextBudget, 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[];
+export declare function setArtifactPathResolver(resolve: ((id: string) => string | undefined) | undefined): void;
+/** The two-line announcement of an `artifact` block (kind, name, size and local path). */
+export declare function renderArtifactBlock(block: Extract<UiBlock, {
+    kind: "artifact";
+}>, width: number, unicode: boolean, path?: string): string[];
+/**
+ * Renders a `{type:"ui"}` block to styled lines for the given inner width. Blocks come from
+ * persisted transcripts too, so anything that does not validate (a kind added by a newer Alisio,
+ * or a malformed plugin block) falls back to labeled JSON instead of throwing.
+ */
+export declare function renderUiBlock(block: UiBlock, width: number, unicode: boolean): string[];
 export type PermissionState = "on" | "ask" | "off";
 export interface HeaderInfo {
     version: string;
     host: string;
     apiMode: string;
     provider?: string;
+    /** Model display name (catalog `name`), falling back to the session model id. */
+    modelName?: string;
+    /** Effective reasoning effort of the active model, when it advertises supported levels. */
+    effort?: string;
     cwd: string;
     session: string;
+    /** Git branch (or short SHA on a detached HEAD) of the session workspace; undefined when unavailable. */
+    branch?: string;
     write: PermissionState;
     process: PermissionState;
+    /** Permission mode shown as `mode:<name>` next to the effect states. */
+    mode?: string;
     mcp: boolean;
     readOnly: boolean;
 }
@@ -34,7 +67,8 @@ export declare class Footer implements Component {
     private budget;
     private hint;
     private statuses;
-    constructor(view: () => ViewState, budget: () => ContextBudget | undefined, hint: () => string | undefined, statuses?: () => string[]);
+    private identity?;
+    constructor(view: () => ViewState, budget: () => ContextBudget | undefined, hint: () => string | undefined, statuses?: () => string[], identity?: (() => IdentityInput | undefined) | undefined);
     invalidate(): void;
     render(width: number): string[];
 }
@@ -46,13 +80,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[];
 }
@@ -60,9 +98,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[];
 }
@@ -79,22 +142,66 @@ export declare class InfoBlock implements Component {
     invalidate(): void;
     render(width: number): string[];
 }
-export declare function componentFor(item: TranscriptItem): Component;
-/** Startup screen rendered by core for the current width (cached until the width changes). */
-export declare class BannerBlock implements Component {
-    private renderLines;
-    private cache?;
-    constructor(renderLines: (width: number) => string[]);
+/**
+ * Minimum usable inner width (cells) the transcript keeps no matter how narrow the terminal is or
+ * how large the configured inset grows. The effective inset is clamped so this floor is honored,
+ * which also keeps the inner width positive.
+ */
+export declare const MIN_CONTENT_WIDTH = 20;
+/**
+ * Inset actually applied on each side: the configured value capped so the inner column stays at
+ * least `MIN_CONTENT_WIDTH` wide. On terminals narrower than that floor the inset degrades to 0
+ * rather than overflowing (the inner width then simply equals the terminal width).
+ */
+export declare function effectiveContentInset(width: number, inset: number): number;
+/** Inner width handed to transcript children after the effective inset is applied. Always >= 1. */
+export declare function contentInnerWidth(width: number, inset: number): number;
+/**
+ * Applies the transcript's horizontal inset in ONE place: it hands children a reduced width and
+ * prefixes every produced line with the inset, so all transcript chrome (text, copy hint, tool
+ * sub-lines, reasoning lines, group headers) shares the same visual column. The reduced width is a
+ * deterministic function of the terminal width, so per-row caches keyed by width stay effective.
+ */
+export declare class ContentInset implements Component {
+    private readonly inner;
+    private readonly inset;
+    constructor(inner: Component, inset: () => number);
     invalidate(): void;
     render(width: number): string[];
 }
-/** Keeps a container of transcript components in step with view-model items. */
+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 rendered;
+    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;
+    private cache?;
+    constructor(renderLines: (width: number) => string[]);
+    invalidate(): void;
+    render(width: number): string[];
+}
 /** Renders one of several components (main conversation or a read-only child view). */
 export declare class Switch implements Component {
     private pick;
@@ -157,3 +264,58 @@ export declare class QuestionPanel implements Component {
     handleInput(data: string): void;
     render(width: number): string[];
 }
+/**
+ * The plan review panel (`exit_plan`): the three decisions under the plan the transcript already
+ * shows. "Add context" turns the panel into a one-line text field (Enter sends, Esc goes back);
+ * Esc while choosing is "Skip for now". The logic lives in `plan-review.ts`.
+ */
+export declare class PlanReviewPanel implements Component {
+    private header;
+    private onSubmit;
+    private placeholder;
+    private state;
+    constructor(options: PlanReviewOption[], header: {
+        title: string;
+        revision: number;
+        artifactId?: string;
+        question: string;
+    }, onSubmit: (effect: PlanReviewEffect) => void, placeholder?: string);
+    invalidate(): void;
+    private dispatch;
+    handleInput(data: string): void;
+    render(width: number): string[];
+}
+/**
+ * The `/btw` side-question panel (picker slot, never the transcript): a pending question with a
+ * spinner, then the answer rendered as Markdown like assistant text, scrollable, with ←/→ through
+ * the session's earlier side answers. `onClose` runs on Esc (the app cancels a pending question).
+ */
+/**
+ * A scrollable Markdown panel in the picker slot (`/changelog`): Up/Down and PgUp/PgDn scroll,
+ * Home/End jump, Esc or q closes. Pure rendering: the text and the height come from the caller.
+ */
+export declare class MarkdownPanel implements Component {
+    private readonly title;
+    private readonly markdown;
+    private readonly onClose;
+    private readonly height;
+    private scroll;
+    private cache?;
+    constructor(title: string, markdown: string, onClose: () => void, height: () => number);
+    invalidate(): void;
+    handleInput(data: string): void;
+    render(width: number): string[];
+}
+export declare class BtwPanel implements Component {
+    private state;
+    private readonly onClose;
+    private readonly height;
+    private markdown?;
+    constructor(state: BtwState, onClose: () => void, height: () => number);
+    get pending(): boolean;
+    dispatch(action: BtwAction): void;
+    invalidate(): void;
+    handleInput(data: string): void;
+    private answerLines;
+    render(width: number): string[];
+}