@ymy88/pi-subagents 0.0.0-stage → 0.24.0

package/dist/ui/conversation-viewer.d.ts

@@ -0,0 +1,177 @@
+/**
+ * conversation-viewer.ts — Live conversation overlay for viewing agent sessions.
+ *
+ * Displays a scrollable, live-updating view of an agent's conversation.
+ * Subscribes to session events for real-time streaming updates.
+ */
+import { type AgentSession } from "@earendil-works/pi-coding-agent";
+import { type Component, type Focusable, type OverlayOptions, type ScrollViewScrollbar, type TUI, type TuiMouseEvent, type TuiMouseEventResult } from "@earendil-works/pi-tui";
+import type { AgentRecord, ViewerMarkdownMode } from "../types.js";
+import type { Theme } from "./agent-widget.js";
+import { type AgentActivity } from "./agent-widget.js";
+import { type ViewerKeybindings } from "./viewer-keys.js";
+/** Height ceiling shared by the overlay's `maxHeight` and the viewer's internal viewport cap. */
+export declare const VIEWPORT_HEIGHT_PCT = 70;
+/** Follow the active renderer, not a setting that may require a restart. */
+export declare function getConversationOverlayOptions(tui: Pick<TUI, "mode">): OverlayOptions;
+/**
+ * Cap on a single tool result or bash output before the viewer elides the rest.
+ *
+ * The cap is not cosmetic — it bounds render cost. `buildContentLines()` runs on
+ * every render *and* on every scroll key (`handleInput` calls it to compute
+ * `maxScroll`), so an uncapped 200 KB result costs ~6 ms per keystroke to parse
+ * as Markdown, against ~0.5 ms once capped and effectively nothing on a cache
+ * hit (best of 5, width 76). 16 KB is roughly a screenful at every terminal size
+ * and still ~30x the 500 characters this replaces, which was small enough to cut
+ * most real results mid-sentence.
+ */
+export declare const RESULT_MAX_CHARS = 16000;
+/** The `b` affordance: whether this run can be handed to the background now, and the handoff. */
+export interface ViewerBackgroundAction {
+    available(): boolean;
+    send(): void;
+}
+export declare class ConversationViewer implements Component, Focusable {
+    private tui;
+    private session;
+    private record;
+    private activity;
+    private theme;
+    private done;
+    /** Abort the agent shown here. Omitted → no stop affordance (e.g. read-only history). */
+    private onStop?;
+    /** Send a steering message to the agent. Omitted → no compose affordance. */
+    private onSteer?;
+    /**
+     * Whether the header shows an estimated cost after the token count. Read
+     * once, at construction: the overlay is opened from a menu, so the setting
+     * cannot change while it is on screen.
+     */
+    private showCost;
+    /**
+     * The current `viewerMarkdown` setting. Read live rather than captured,
+     * unlike `showCost`: `m` changes it while the overlay is on screen.
+     * Omitted → `assistant`.
+     */
+    private viewerMarkdown?;
+    /**
+     * Persist a mode chosen with `m`, so the key and `/agents → Settings` mean
+     * the same thing. Omitted → `m` still cycles, viewer-locally.
+     */
+    private onMarkdownMode?;
+    /**
+     * Hand this run to the background. `available` is read live — it turns
+     * false the instant the handoff lands or the run ends. Omitted → no `b`
+     * affordance (history views).
+     */
+    private onBackground?;
+    private scrollOffset;
+    private autoScroll;
+    focused: boolean;
+    private readonly fullscreen;
+    private viewport;
+    private scrollbarGrabOffset;
+    private footerTargets;
+    private latestTarget;
+    private newMessages;
+    private readonly scrollView;
+    private unsubscribe;
+    private lastInnerW;
+    private closed;
+    /** Two-press confirm guard for the stop key, so a stray key can't kill the agent. */
+    private stopArmed;
+    private keys;
+    /** Steering composer — present while the user is typing a message to the agent. */
+    private composer;
+    /** Resolved once: pi's Markdown theme is fixed for the life of the process. */
+    private readonly markdownTheme;
+    /** Set by the `m` key. Wins over the setting so `m` works without a persist hook. */
+    private markdownModeOverride;
+    /**
+     * One `Markdown` per message, so its own text/width cache does the work. A
+     * fresh instance per render would re-parse the whole transcript on every
+     * keystroke — the component caches, but only across calls to the same object.
+     * Weak so a compacted-away message doesn't pin its render.
+     */
+    private readonly markdownCache;
+    /** One block per tool call id, so a redraw reuses the component's own caches. */
+    private readonly toolBlocks;
+    /**
+     * Whether calls render through pi's components. Probe-gated: without pi's
+     * theme the viewer keeps its own plain rendering rather than throwing.
+     */
+    private readonly toolRendering;
+    /** Whether tool blocks show their full output; toggled with pi's expand key. */
+    private toolsExpanded;
+    constructor(tui: TUI, session: AgentSession, record: AgentRecord, activity: AgentActivity | undefined, theme: Theme, done: (result: undefined) => void, 
+    /** Abort the agent shown here. Omitted → no stop affordance (e.g. read-only history). */
+    onStop?: (() => void) | undefined, 
+    /** User keybindings from `ctx.ui.custom()`. Omitted → hardcoded defaults. */
+    keybindings?: ViewerKeybindings, 
+    /** Send a steering message to the agent. Omitted → no compose affordance. */
+    onSteer?: ((message: string) => void) | undefined, 
+    /**
+     * Whether the header shows an estimated cost after the token count. Read
+     * once, at construction: the overlay is opened from a menu, so the setting
+     * cannot change while it is on screen.
+     */
+    showCost?: boolean, 
+    /**
+     * The current `viewerMarkdown` setting. Read live rather than captured,
+     * unlike `showCost`: `m` changes it while the overlay is on screen.
+     * Omitted → `assistant`.
+     */
+    viewerMarkdown?: (() => ViewerMarkdownMode) | undefined, 
+    /**
+     * Persist a mode chosen with `m`, so the key and `/agents → Settings` mean
+     * the same thing. Omitted → `m` still cycles, viewer-locally.
+     */
+    onMarkdownMode?: ((mode: ViewerMarkdownMode) => void) | undefined, 
+    /** Pi's fullscreen scrollbar preference, captured when the observer opens. */
+    scrollbarMode?: ScrollViewScrollbar, 
+    /**
+     * Hand this run to the background. `available` is read live — it turns
+     * false the instant the handoff lands or the run ends. Omitted → no `b`
+     * affordance (history views).
+     */
+    onBackground?: ViewerBackgroundAction | undefined);
+    handleInput(data: string): void;
+    private jumpToLatest;
+    handleMouse(event: TuiMouseEvent): TuiMouseEventResult;
+    render(width: number): string[];
+    /** Stoppable only when a stop handler exists and the agent is still active. */
+    private isStoppable;
+    /** The mode in force: an `m` press, else the setting, else the default. */
+    private markdownMode;
+    /** Wrap `text` literally — the pre-Markdown path, and the fallback from it. */
+    private rawLines;
+    /** Render `text` as Markdown, reusing this message's component instance. */
+    private markdownLines;
+    /** Steerable only when a steer handler exists and the agent is still active. */
+    private canSteer;
+    /**
+     * Asked of the owner rather than derived from the record: only the caller
+     * blocked on this run knows it can let go of it, and `blocking` alone also
+     * matches spawns nobody can hand off (the agent generator).
+     */
+    private canSendToBackground;
+    /** Open the inline steering composer and route subsequent input to it. */
+    private openComposer;
+    invalidate(): void;
+    dispose(): void;
+    private viewportHeight;
+    private chromeLines;
+    private invocationLine;
+    private buildContentLines;
+    /**
+     * One tool call as pi draws it in the main transcript: the arguments on the
+     * call, then the result in that tool's own format — a bash box, read line
+     * numbers, an edit diff. Blocks are cached per call id because
+     * `ToolExecutionComponent` rebuilds its renderer tree on every update.
+     *
+     * A tool without a renderer still renders: the component falls back to a
+     * generic `name key=value` header plus a bounded preview that the expand key
+     * unfolds.
+     */
+    private toolBlockLines;
+}