@oh-my-pi/pi-tui 18.2.3 → 18.2.5

package/dist/types/apps/debug/log-viewer.d.ts

@@ -0,0 +1,81 @@
+import type { Component } from "../../tui.js";
+/** Host capabilities for copying and fetching earlier log entries. */
+export interface LogViewerDeps {
+    copyToClipboard(text: string): void;
+    hasOlderLogs?(): boolean;
+    loadOlderLogs?(limitDays?: number): Promise<string>;
+}
+/** Separator marking logs captured before the current process started. */
+export declare const SESSION_BOUNDARY_WARNING = "### WARNING - Logs above are older than current session!";
+/** Action row for loading earlier log entries. */
+export declare const LOAD_OLDER_LABEL = "### MOVE UP TO LOAD MORE...";
+type DebugLogViewerModelOptions = {
+    processStartMs?: number;
+    processPid?: number;
+    hasOlderLogs?: () => boolean;
+    loadOlderLogs?: (limitDays?: number) => Promise<string>;
+};
+type ViewerRow = {
+    kind: "warning";
+} | {
+    kind: "load-older";
+} | {
+    kind: "log";
+    logIndex: number;
+};
+/** Split raw log text into nonempty entries. */
+export declare function splitLogText(logText: string): string[];
+/** Build sanitized clipboard text from selected log entries. */
+export declare function buildLogCopyPayload(lines: string[]): string;
+/** Filter, paginate, expand, and select captured log entries. */
+export declare class DebugLogViewerModel {
+    #private;
+    constructor(logText: string, options?: DebugLogViewerModelOptions);
+    get logCount(): number;
+    get visibleLogCount(): number;
+    get rows(): readonly ViewerRow[];
+    get cursorRowIndex(): number | undefined;
+    get cursorLogIndex(): number | undefined;
+    get filterQuery(): string;
+    get cursorRowKind(): ViewerRow["kind"] | undefined;
+    get expandedCount(): number;
+    isProcessFilterEnabled(): boolean;
+    isCursorAtFirstSelectableRow(): boolean;
+    getRawLine(logIndex: number): string;
+    setFilterQuery(query: string): void;
+    toggleProcessFilter(): void;
+    moveCursor(delta: number, extendSelection: boolean): void;
+    moveCursorToRow(rowIndex: number, extendSelection: boolean): boolean;
+    getSelectedLogIndices(): number[];
+    getSelectedCount(): number;
+    isSelected(logIndex: number): boolean;
+    isExpanded(logIndex: number): boolean;
+    expandSelected(): void;
+    collapseSelected(): void;
+    getSelectedRawLines(): string[];
+    selectAllVisible(): void;
+    canLoadOlder(): boolean;
+    loadOlder(additionalCount?: number): Promise<boolean>;
+    prependLogs(logText: string): number;
+}
+interface DebugLogViewerComponentOptions {
+    logs: string;
+    terminalRows: number;
+    onExit: () => void;
+    onStatus?: (message: string) => void;
+    onError?: (message: string) => void;
+    processStartMs?: number;
+    processPid?: number;
+    deps: LogViewerDeps;
+    onUpdate?: () => void;
+}
+/** Interactive log viewer with host-provided storage and clipboard capabilities. */
+export declare class DebugLogViewerComponent implements Component {
+    #private;
+    constructor(options: DebugLogViewerComponentOptions);
+    handleInput(keyData: string): void;
+    invalidate(): void;
+    dispose(): void;
+    render(width: number): readonly string[];
+}
+export {};

package/dist/types/apps/debug/protocol-probe.d.ts

@@ -0,0 +1,42 @@
+import { Container } from "../../tui.js";
+import { type TextSizingScale } from "../../utils.js";
+import { type ImageBudget } from "../../components/image.js";
+/**
+ * Encode raw 8-bit RGB pixels (`width * height * 3` bytes, row-major) as a PNG
+ * (color type 2, no interlacing). The IDAT payload is a real zlib stream from
+ * {@link zlib.deflateSync}, so the output is a fully valid PNG that every image
+ * protocol — including Sixel, which decodes the bytes natively — accepts.
+ */
+export declare function encodeRgbPng(width: number, height: number, rgb: Uint8Array): Uint8Array;
+/** Encoded image and geometry used by terminal protocol probes. */
+export interface SampleImage {
+    base64: string;
+    mimeType: string;
+    dimensions: {
+        widthPx: number;
+        heightPx: number;
+    };
+}
+/** Build a deterministic RGB gradient PNG (red across, green down, constant blue). */
+export declare function buildSampleImage(width?: number, height?: number): SampleImage;
+/**
+ * OSC 66 text-sizing sample lines, one scaled span per requested scale. Each
+ * scaled row is followed by `scale - 1` blank rows that reserve the vertical
+ * cells its multi-cell glyphs occupy — mirroring the markdown H1 renderer so
+ * the next line does not paint over the bottom of the glyphs.
+ */
+export declare function buildLargeTextLines(scales?: readonly TextSizingScale[]): string[];
+/** Image budget and notification state for the protocol panel. */
+export interface ProtocolProbeOptions {
+    image: SampleImage;
+    imageBudget: ImageBudget;
+    /** Whether the desktop notification was suppressed (e.g. `PI_NOTIFICATIONS=off`). */
+    notificationSuppressed: boolean;
+}
+/**
+ * Self-contained panel that renders one sample of every special terminal
+ * protocol into the chat transcript.
+ */
+export declare class ProtocolProbeComponent extends Container {
+    constructor(options: ProtocolProbeOptions);
+}

package/dist/types/apps/debug/raw-sse-buffer.d.ts

@@ -0,0 +1,58 @@
+import type { Model, ProviderResponseMetadata, RawSseEvent } from "@oh-my-pi/pi-ai";
+/** A captured provider response or raw server-sent event. */
+export type RawSseDebugRecord = {
+    kind: "response";
+    sequence: number;
+    timestamp: number;
+    provider?: string;
+    model?: string;
+    api?: string;
+    status: number;
+    requestId?: string | null;
+    transport?: string;
+} | {
+    kind: "event";
+    sequence: number;
+    timestamp: number;
+    provider?: string;
+    model?: string;
+    api?: string;
+    event: string | null;
+    raw: string[];
+    truncated: boolean;
+    originalChars: number;
+};
+/** Retained events and eviction counters at a point in time. */
+export interface RawSseDebugSnapshot {
+    records: readonly RawSseDebugRecord[];
+    droppedRecords: number;
+    droppedChars: number;
+    totalEvents: number;
+    lastUpdatedAt?: number;
+}
+/** Format a captured event timestamp as an ISO instant. */
+export declare function formatRawSseIsoTime(timestamp: number): string;
+/** Encode response metadata as an SSE comment. */
+export declare function formatRawSseResponseComment(record: Extract<RawSseDebugRecord, {
+    kind: "response";
+}>): string;
+/** Return wire-format lines for a captured record. */
+export declare function rawSseRecordLines(record: RawSseDebugRecord): string[];
+/** Bounded, observable capture of raw provider responses and SSE frames. */
+export declare class RawSseDebugBuffer {
+    #private;
+    subscribe(listener: () => void): () => void;
+    recordResponse(response: ProviderResponseMetadata, model?: Model): void;
+    recordEvent(event: RawSseEvent, model?: Model): void;
+    snapshot(): RawSseDebugSnapshot;
+    toRawText(): string;
+    /**
+     * Drop every retained record and reset accounting. Called from
+     * {@link AgentSession} teardown so a disposed (e.g. parked subagent) session
+     * releases its bounded captured wire records. Notifies subscribers so a live
+     * debug viewer redraws empty.
+     */
+    clear(): void;
+}
+/** Resolve an owner's capture buffer or the process-wide fallback. */
+export declare function resolveRawSseDebugBuffer(owner?: object): RawSseDebugBuffer;

package/dist/types/apps/debug/raw-sse.d.ts

@@ -0,0 +1,26 @@
+import type { Component } from "../../tui.js";
+import { type RawSseDebugBuffer } from "./raw-sse-buffer.js";
+/** @internal Exported for tests. */
+export declare function expandPrettyDataLines(raw: readonly string[]): string[];
+/** Host clipboard capability for the raw event viewer. */
+export interface RawSseViewerDeps {
+    copyToClipboard(text: string): void;
+}
+/** Raw event viewer content, callbacks, and host capabilities. */
+export interface RawSseViewerOptions {
+    deps: RawSseViewerDeps;
+    buffer: RawSseDebugBuffer;
+    terminalRows: number;
+    onExit: () => void;
+    onStatus?: (message: string) => void;
+    onUpdate?: () => void;
+}
+/** Scrollable live view of captured provider events. */
+export declare class RawSseViewerComponent implements Component {
+    #private;
+    constructor(options: RawSseViewerOptions);
+    dispose(): void;
+    handleInput(keyData: string): void;
+    invalidate(): void;
+    render(width: number): readonly string[];
+}

package/dist/types/apps/debug/terminal-info.d.ts

@@ -0,0 +1,34 @@
+/** Live values the debug view reads off the running TUI, not the static capability table. */
+export interface TerminalRuntimeState {
+    columns: number;
+    rows: number;
+    /** Whether DEC 2026 synchronized-output wrappers are currently emitted. */
+    synchronizedOutput: boolean;
+}
+/** Terminal capabilities, geometry, and detection environment. */
+export interface TerminalStateInfo {
+    detectedId: string;
+    columns: number;
+    rows: number;
+    cellWidthPx: number;
+    cellHeightPx: number;
+    trueColor: boolean;
+    imageProtocol: string;
+    notifyProtocol: string;
+    osc99Confirmed: boolean;
+    hyperlinks: boolean;
+    deccara: boolean;
+    screenToScrollback: boolean;
+    synchronizedOutput: boolean;
+    multiplexer: string | null;
+    env: {
+        TERM?: string;
+        TERM_PROGRAM?: string;
+        TERM_PROGRAM_VERSION?: string;
+        COLORTERM?: string;
+    };
+}
+/** Snapshot the active terminal capabilities and the live runtime geometry. */
+export declare function collectTerminalState(runtime: TerminalRuntimeState): TerminalStateInfo;
+/** Format terminal state for display in the debug menu. */
+export declare function formatTerminalState(info: TerminalStateInfo): string;

package/dist/types/apps/debug/viewer-frame.d.ts

@@ -0,0 +1,52 @@
+import type { Component } from "../../tui.js";
+import { type ScrollRangeAnchor } from "../../components/scroll-view.js";
+/** One complete debug-viewer frame. */
+export interface DebugViewerFrameContent {
+    readonly header: readonly string[];
+    readonly body: {
+        readonly lines: readonly string[];
+        readonly anchor?: ScrollRangeAnchor;
+    };
+    readonly footer: readonly string[];
+}
+/** Dimensions supplied while a debug viewer prepares its domain rows. */
+export interface DebugViewerFrameContext {
+    /** Panel content width with one column reserved for an overflowing viewport's scrollbar. */
+    readonly contentWidth: number;
+    readonly bodyHeight: number;
+}
+export interface DebugViewerFrameOptions {
+    readonly title: string;
+    readonly getHeight: () => number;
+    readonly headerRows: number;
+    readonly footerRows: number;
+    readonly frame: (context: DebugViewerFrameContext) => DebugViewerFrameContent;
+    readonly minimumBodyRows?: number;
+    readonly followTail?: boolean;
+}
+/**
+ * Debug-local adapter for the fullscreen viewers' common rounded panel and viewport.
+ * Domain controllers retain filtering, selection, formatting, copy, and live data;
+ * this component owns chrome sizing, persistent scroll state, selection reveal, and
+ * frame-row to logical-body translation.
+ */
+export declare class DebugViewerFrame implements Component {
+    #private;
+    constructor(options: DebugViewerFrameOptions);
+    get debugChildren(): readonly Component[];
+    getBodyHeight(): number;
+    isFollowingTail(): boolean;
+    setFollowTail(follow: boolean): void;
+    /** Manual viewport movement suspends append-follow, including at the current tail. */
+    scroll(delta: number): void;
+    setScrollOffset(offset: number): void;
+    /** Whether a 0-based rendered frame row lies inside the last rendered body region. */
+    isBodyFrameRow(frameRow: number): boolean;
+    /** Map a 0-based rendered frame row into the complete logical body buffer. */
+    toBodyRow(frameRow: number): number | undefined;
+    /** Map a 0-based rendered frame row into the fixed header region. */
+    toHeaderRow(frameRow: number): number | undefined;
+    invalidate(): void;
+    dispose(): void;
+    render(width: number): readonly string[];
+}

package/dist/types/apps/git/avatar.d.ts

@@ -0,0 +1,9 @@
+/** Cached author photos supplied by the command host. */
+export interface AvatarSource {
+    get(email: string, cwd: string): string | null | undefined;
+}
+/**
+ * Deterministic 5x5 mirrored identicon rendered as half-block rows (3 lines,
+ * 10 columns). Used while an avatar loads and when none exists.
+ */
+export declare function identiconLines(email: string, colorize: (hex: string, text: string) => string): string[];

package/dist/types/apps/git/colors.d.ts

@@ -0,0 +1,49 @@
+/** Decode a hex color into RGB channels. */
+export declare function hexChannels(hex: string): [number, number, number];
+/** Linear blend of two hex colors (`t` = 0 → `a`, 1 → `b`). */
+export declare function mixHex(a: string, b: string, t: number): string;
+/** Encode a truecolor background escape sequence. */
+export declare function bgAnsiHex(hex: string): string;
+/** Encode a truecolor foreground escape sequence. */
+export declare function fgAnsiHex(hex: string): string;
+/** True when the theme sits on a dark surface. */
+export declare function isDark(): boolean;
+/** The theme's canvas color: the surface diff tints and pills blend toward. */
+export declare function canvasHex(): string;
+/** The theme's default text color, used as the "bright" mix pole. */
+export declare function textHex(): string;
+/** Perceptual luminance of a hex color (0..1). */
+export declare function luminance(hex: string): number;
+/**
+ * Re-assert a background after any reset inside syntax-highlighted text so a
+ * row tint survives token boundaries emitted by the highlighter.
+ */
+export declare function withBg(text: string, bg: string): string;
+/**
+ * Filled pill button with half-block end caps (`▐ label ▌`), colored from a
+ * theme hex. Label contrast follows the fill's luminance. Visible width is
+ * `label.length + 2`.
+ */
+export declare function pill(label: string, hex: string, options?: {
+    selected?: boolean;
+    dim?: boolean;
+}): string;
+/**
+ * Flat filled chip with a contrast-computed label — readable on any theme,
+ * unlike accent-on-selection combinations that can collapse (e.g. dark blue
+ * on light blue).
+ */
+export declare function chipFill(label: string, hex: string): string;
+/**
+ * Selection-row background: a canvas-adjacent surface (canvas nudged toward
+ * the text color) so every theme foreground stays readable on it — unlike
+ * `selectedBg`, which some themes define as a saturated color.
+ * `dim` renders a fainter band for cursors in unfocused panes.
+ */
+export declare function selectionBgAnsi(dim?: boolean): string;
+/** Tinted chip: faint fill of a theme color with the full color as label. */
+export declare function tintChip(label: string, hex: string): string;
+/** Subtle toggle chip: accent fill when active, neutral surface otherwise. */
+export declare function softPill(label: string, options?: {
+    active?: boolean;
+}): string;

package/dist/types/apps/git/diff-pane.d.ts

@@ -0,0 +1,188 @@
+/**
+ * Diff pane of the git TUI, with four view modes:
+ *
+ * - `split` (default): old file left, new file right, aligned line-by-line
+ *   with word-level intraline emphasis and faint fillers for one-sided rows.
+ * - `inline`: the full file with deletions/additions stacked in place.
+ * - `hunk`: only the changed regions (3 context lines), one block per hunk
+ *   with `@@` headers and per-hunk stage/unstage/discard buttons.
+ * - `file`: the current (new) side only, plain syntax-highlighted view.
+ *
+ * The right edge carries a minimap-style scrollbar encoding change density
+ * (deletions > additions > changes > context, hunk headers in accent) with
+ * the visible viewport brightened; clicking it seeks. Long lines either pan
+ * horizontally (`←`/`→`) or soft-wrap when word wrap is enabled.
+ */
+import type { DiffStreamResult } from "@oh-my-pi/pi-natives";
+import { type ImageBudget } from "../../components/image.js";
+import { type FileAssetSide, type FileStreamUpdate } from "./state.js";
+/** Column ranges (inclusive start, exclusive end) carrying intraline emphasis. */
+type MarkRanges = readonly (readonly [number, number])[];
+type RowKind = "context" | "change" | "add" | "del";
+interface DiffRow {
+    readonly kind: RowKind;
+    readonly oldNum?: number;
+    readonly newNum?: number;
+    /** Tab-expanded line for each side ("" when absent). */
+    readonly oldText: string;
+    readonly newText: string;
+    readonly oldWidth: number;
+    readonly newWidth: number;
+    readonly oldMarks?: MarkRanges;
+    readonly newMarks?: MarkRanges;
+    /** Raw (untab-expanded) source lines, for patch construction. */
+    readonly oldRaw?: string;
+    readonly newRaw?: string;
+}
+/** One changed region with its applyable patch for hunk-level staging. */
+export interface HunkBlock {
+    /** `@@ -a,b +c,d @@` header shown above the block. */
+    readonly header: string;
+    /** Standalone patch text for this hunk, or "" when not applyable. */
+    readonly patch: string;
+    readonly rows: readonly DiffRow[];
+}
+/** Aligned diff document produced by {@link buildDiffDocument}. */
+export interface DiffDocument {
+    readonly filePath: string;
+    readonly rows: readonly DiffRow[];
+    readonly hunks: readonly HunkBlock[];
+    /** Tab-expanded new-side lines for the `file` view. */
+    readonly fileLines: readonly {
+        text: string;
+        width: number;
+    }[];
+    /** Tab-expanded source lines, retained for progressive syntax highlighting. */
+    readonly oldDisplayLines: readonly string[];
+    /** Tab-expanded source lines, retained for progressive syntax highlighting. */
+    readonly newDisplayLines: readonly string[];
+    readonly additions: number;
+    readonly deletions: number;
+    readonly gutterWidth: number;
+    readonly maxLineWidth: number;
+    /** False when built with whitespace-ignore: hunk patches would not apply. */
+    readonly canPatch: boolean;
+    /** Raw input texts and newline state, for line-selection patches. */
+    readonly rawOld: string;
+    readonly rawNew: string;
+    readonly oldEndsNewline: boolean;
+    readonly newEndsNewline: boolean;
+    /** Index into {@link rows} for each 1-based new-file line number. */
+    readonly rowIndexByNewLine: readonly number[];
+}
+/** How the pane presents the document. */
+export type ViewMode = "split" | "inline" | "hunk" | "file";
+/** Hunk-button actions raised to the root component. */
+export type HunkAction = "stage" | "unstage" | "discard";
+/**
+ * Whitespace handling for {@link buildDiffDocument}:
+ *
+ * - `off`: exact, byte-level alignment.
+ * - `whitespace`: align ignoring leading/trailing whitespace (disables hunk
+ *   patches — the alignment no longer matches git's view of the file).
+ * - `formatting`: exact alignment, but changed blocks that only move
+ *   whitespace around (indentation, line splits/joins, blank lines) or only
+ *   touch import statements (ts/js, rust, go) are demoted to context.
+ */
+export type WhitespaceMode = "off" | "whitespace" | "formatting";
+/** Options for {@link buildDiffDocument}. */
+export interface DiffBuildOptions {
+    /** Whitespace handling; defaults to `off`. */
+    whitespace?: WhitespaceMode;
+    /** Exact runs/hunks already computed by the native streaming differ. */
+    streamResult?: DiffStreamResult;
+}
+/** Build the aligned document for one file from its raw old/new texts. */
+export declare function buildDiffDocument(oldRaw: string, newRaw: string, filePath: string, options?: DiffBuildOptions): DiffDocument;
+/**
+ * Build a patch covering only the changed rows inside `[from, to]` (indices
+ * into `doc.rows`).
+ *
+ * - `apply`: base is the old side; the target adopts only the selected
+ *   changes. Staging selected lines = apply this to the index.
+ * - `revert`: base is the new side; the target undoes only the selected
+ *   changes. Unstaging selected lines = apply `--cached`; discarding
+ *   selected lines = apply to the worktree.
+ *
+ * Returns `null` when the selection touches no changes or the document
+ * cannot produce patches (whitespace-ignore alignment).
+ */
+export declare function buildLineSelectionPatch(doc: DiffDocument, from: number, to: number, intent: "apply" | "revert"): string | null;
+/** Placeholder states shown instead of a document. */
+export type DiffPaneState = "empty" | "loading" | "streaming" | "asset" | "ready";
+/** Result of a left click inside the pane. */
+export type PaneClick = {
+    type: "hunk-action";
+    hunk: HunkBlock;
+    action: HunkAction;
+} | {
+    type: "handled";
+} | null;
+/**
+ * Scrollable diff viewport. The root component feeds it key/mouse input and
+ * composes its rendered lines into the frame.
+ */
+export declare class DiffPane {
+    #private;
+    state: DiffPaneState;
+    /** Message shown in the empty state. */
+    emptyMessage: string;
+    mode: ViewMode;
+    wrap: boolean;
+    /** Which hunk buttons apply: staging (unstaged), unstaging (staged), or none. */
+    patchTarget: "stage" | "unstage" | null;
+    selectedHunk: number;
+    scrollTop: number;
+    scrollLeft: number;
+    /** Pane holds keyboard focus: the cursor band renders at full strength (dimmed otherwise). */
+    focused: boolean;
+    /** Cursor as a visual-row index; navigation keys move it. */
+    cursor: number;
+    /** Shift-selection anchor (visual-row index), or null when no selection. */
+    anchor: number | null;
+    constructor(imageBudget?: ImageBudget);
+    get doc(): DiffDocument | null;
+    setDocument(doc: DiffDocument | null, state: DiffPaneState): void;
+    /** Show media previews and safe placeholders for non-text Git objects. */
+    setAsset(filePath: string, old: FileAssetSide, next: FileAssetSide): void;
+    /** Start a provisional file view while the native stream ingests both sides. */
+    startStream(filePath: string): void;
+    /** Merge newly completed native-stream lines into the provisional viewport. */
+    updateStream(update: FileStreamUpdate): void;
+    /** Incrementally syntax-highlight the active document without blocking input. */
+    highlightAsync(signal: AbortSignal, requestRender: () => void): Promise<void>;
+    setMode(mode: ViewMode): void;
+    cycleMode(): void;
+    toggleWrap(): void;
+    scrollBy(delta: number): void;
+    pageBy(direction: 1 | -1): void;
+    scrollLeftBy(delta: number): void;
+    /** Move the read-only cursor; `extend` grows the shift selection. */
+    moveCursor(delta: number, extend: boolean): void;
+    /** Drop the shift selection. True when there was one. */
+    clearSelection(): boolean;
+    /**
+     * Selected span as indices into `doc.rows` (shift selection, or the cursor
+     * row alone). Null when the cursor sits on rows that cannot map back to the
+     * document (hunk-view rows, headers).
+     */
+    get selection(): {
+        from: number;
+        to: number;
+        explicit: boolean;
+    } | null;
+    /** Center the viewport on a visual row (minimap seek, hunk jump). */
+    seekTo(row: number): void;
+    /** Jump to the next/previous hunk. False when already at the boundary. */
+    jumpHunk(direction: 1 | -1): boolean;
+    /** Snap to the first/last hunk — the landing spot when hunk nav crosses files. */
+    seekHunk(edge: "first" | "last"): void;
+    /** Move the cursor to the first/last visual row (home/end, `g`/`G`). */
+    cursorToEdge(edge: "start" | "end"): void;
+    /** Currently selected hunk (hunk view), if any. */
+    get currentHunk(): HunkBlock | null;
+    /** Handle a left click at pane-local coordinates. */
+    clickAt(col: number, row: number, shift?: boolean): PaneClick;
+    render(width: number, height: number): string[];
+}
+export {};

package/dist/types/apps/git/git-tui.d.ts

@@ -0,0 +1,66 @@
+/**
+ * `omp git` — fullscreen repository TUI.
+ *
+ * Layout: header (file path, encoding, stage-file button, close), toolbar
+ * (scope chip, file/diff toggle, hunk navigation, hunk/inline/split view
+ * buttons, whitespace + word-wrap toggles), center diff pane with a minimap
+ * scrollbar, right sidebar (file management + commit form while dirty, HEAD
+ * commit details with author avatar when clean). Submitting an empty commit
+ * form generates an llm-git-compatible message; submitting populated fields
+ * commits them. A footer shows key hints.
+ *
+ * `tab` moves focus between the diff and the sidebar; both panes take
+ * arrows/PgUp/PgDn, vim motions (`j`/`k`/`h`/`l`/`g`/`G`), and mouse
+ * clicks/wheel. All toolbar buttons are clickable and mirrored by keys:
+ * `v` cycles the view (`1`–`4` pick one), `alt+↓`/`alt+↑` jump hunks and roll
+ * into the adjacent file at the edges, `]`/`[` switch files, `s`/`u`
+ * stage/unstage (hunk-aware), `x` discards a hunk, `delete` discards the
+ * whole file (press twice to confirm), `w` wraps, `b` cycles
+ * whitespace handling (exact → ignore whitespace → ignore
+ * formatting/import-only changes), `c` jumps to the commit form, `r`
+ * refreshes. In the sidebar tree `←`/`→` collapse/expand directories,
+ * `enter` opens the selected file in the diff pane, `space` stages or
+ * unstages the selected row, and `delete` discards it — on a directory,
+ * every file underneath it.
+ */
+import { TUI } from "../../tui.js";
+import type { AvatarSource } from "./avatar.js";
+import { type GitCommitMessage } from "./sidebar.js";
+import type { ChangedFile, GitTuiModel } from "./state.js";
+/** AI staging counts displayed after filtering the working tree. */
+export interface AiStageOutcome {
+    matchedFiles: number;
+    totalFiles: number;
+    stagedHunks: number;
+    totalHunks: number;
+    wholeFiles: number;
+}
+/** Repository, avatar, and generation capabilities owned by the command host. */
+export interface GitTuiHost {
+    model: GitTuiModel;
+    createAvatarSource(onReady: () => void): AvatarSource;
+    aiStage(options: {
+        cwd: string;
+        instruction: string;
+        files: readonly Pick<ChangedFile, "path" | "kind">[];
+        signal?: AbortSignal;
+        onProgress?: (message: string) => void;
+    }): Promise<AiStageOutcome>;
+    generateCommitMessage(options: {
+        cwd: string;
+        stageIfEmpty: boolean;
+        signal?: AbortSignal;
+        onProgress?: (message: string) => void;
+    }): Promise<{
+        commit: GitCommitMessage;
+        validationError?: string | null;
+        stagedAll: boolean;
+    }>;
+}
+/**
+ * Mount the git TUI as a fullscreen overlay on an existing TUI (the `/git`
+ * slash command). Resolves when the user closes it; the caller restores focus.
+ */
+export declare function showGitOverlay(ui: TUI, host: GitTuiHost): Promise<void>;
+/** Run the fullscreen git TUI standalone (`omp git`) until the user quits. */
+export declare function runGitTui(host: GitTuiHost): Promise<void>;