agent-afk 5.1.0 → 5.3.0

package/dist/cli/git-status-sampler.d.ts

@@ -0,0 +1,43 @@
+export type GitStatusExecFn = (file: string, args: string[], cwd: string) => Promise<{
+    stdout: string;
+    stderr: string;
+}>;
+export interface GitStatusSamplerOptions {
+    cwd: string;
+    exec?: GitStatusExecFn;
+    prTtlMs?: number;
+    branchTtlMs?: number;
+    now?: () => number;
+    timeoutMs?: number;
+    onUpdate?: () => void;
+}
+export declare class GitStatusSampler {
+    private readonly cwd;
+    private readonly exec;
+    private readonly prTtlMs;
+    private readonly branchTtlMs;
+    private readonly now;
+    private onUpdate;
+    private branch;
+    private pr;
+    private prBranch;
+    private prFetchedAt;
+    private branchFetchedAt;
+    private branchInFlight;
+    private prInFlight;
+    private disposed;
+    private resetToken;
+    constructor(opts: GitStatusSamplerOptions);
+    setOnUpdate(cb: (() => void) | undefined): void;
+    getBranch(): string | undefined;
+    getPr(): number | undefined;
+    refresh(opts?: {
+        blockOnPr?: boolean;
+    }): Promise<void>;
+    reset(): void;
+    dispose(): void;
+    private updateBranch;
+    private notify;
+    private gitBranch;
+    private maybeFetchPr;
+}

package/dist/cli/hyperlink.d.ts

@@ -0,0 +1,6 @@
+export declare const OSC8_CLOSE = "\u001B]8;;\u001B\\";
+export declare function supportsHyperlinks(env?: NodeJS.ProcessEnv, isTTY?: boolean): boolean;
+export declare function hyperlinksEnabled(): boolean;
+export declare function resetHyperlinksEnabledForTest(value?: boolean): void;
+export declare function hyperlink(text: string, url: string): string;
+export declare function fileHyperlink(text: string, absolutePath: string): string;

package/dist/cli/index.d.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+export { parseThinking, parseEffort, parseBudget, parseMaxOutputTokens, getMaxBudgetUsd, getTaskBudget, getMaxOutputTokens, } from './shared-helpers.js';
+export declare function needsCredentialGate(argv: string[]): boolean;
+export declare function runFirstRunDetector(argv?: string[]): Promise<void>;

package/dist/cli/input/attachments.d.ts

@@ -0,0 +1,10 @@
+export interface ImageAttachment {
+    readonly id: string;
+    readonly mediaType: 'image/png' | 'image/jpeg' | 'image/gif' | 'image/webp';
+    readonly bytes: Buffer;
+    readonly sizeBytes: number;
+}
+export declare function formatSize(bytes: number): string;
+export declare function renderStatusLine(attachments: ImageAttachment[]): string;
+export declare function describeForHistory(text: string, attachments: ImageAttachment[]): string;
+export declare function describeAttachmentSummary(attachments: ImageAttachment[]): string;

package/dist/cli/input/autocomplete-state.d.ts

@@ -0,0 +1,11 @@
+import type { Candidate, Trigger } from './types.js';
+export interface AutocompleteState {
+    dropdownOpen: boolean;
+    candidates: Candidate[];
+    selectedIndex: number;
+    viewportStart: number;
+    suppressedSignature: string | null;
+    trigger: Trigger | null;
+    reset(): void;
+}
+export declare function createAutocompleteState(): AutocompleteState;

package/dist/cli/input/caret-blink.d.ts

@@ -0,0 +1,21 @@
+export interface CaretBlinkControllerOptions {
+    enabled: boolean;
+    captureMode: boolean;
+    intervalMs: number;
+    onTick: () => void;
+}
+export declare const DEFAULT_CARET_BLINK_INTERVAL_MS = 530;
+export declare class CaretBlinkController {
+    private interval;
+    private visiblePhase;
+    private readonly enabled;
+    private readonly captureMode;
+    private readonly intervalMs;
+    private readonly onTick;
+    constructor(opts: CaretBlinkControllerOptions);
+    get visible(): boolean;
+    start(): void;
+    resetVisible(): boolean;
+    stop(): void;
+    private schedule;
+}

package/dist/cli/input/clipboard-image.d.ts

@@ -0,0 +1,2 @@
+import type { ImageAttachment } from './attachments.js';
+export declare function readClipboardImage(): Promise<ImageAttachment | null>;

package/dist/cli/input/dropdown.d.ts

@@ -0,0 +1,4 @@
+import type { Candidate, Trigger } from './types.js';
+export declare function truncateToWidth(text: string, maxWidth: number): string;
+export declare function formatDropdownRow(candidate: Candidate, isSelected: boolean, maxWidth: number, triggerKind?: Trigger['kind']): string;
+export declare function formatHintRow(hint: string | undefined, maxWidth: number): string | null;

package/dist/cli/input/echo.d.ts

@@ -0,0 +1,12 @@
+export declare function formatSubmittedEcho(opts: {
+    buffer: string;
+    promptText: string;
+    isTTY: boolean;
+    terminalWidth?: number;
+    attachmentSummary?: string;
+}): string;
+export declare function visualRowCount(buffer: string, promptVisibleLen: number, cols: number): number;
+export declare function visualCursorPos(buffer: string, cursorIdx: number, promptVisibleLen: number, cols: number): {
+    row: number;
+    col: number;
+};

package/dist/cli/input/emit-keypress.d.ts

@@ -0,0 +1 @@
+export declare function emitKeypressEventsImmediateEscape(stream: NodeJS.ReadableStream): void;

package/dist/cli/input/history.d.ts

@@ -0,0 +1,15 @@
+export declare function flushHistoryWrites(): Promise<void>;
+export declare class ReplHistory {
+    private _entries;
+    private _index;
+    private _draft;
+    constructor(entries: string[]);
+    get length(): number;
+    getEntries(): readonly string[];
+    push(text: string): void;
+    back(currentDraft: string): string | null;
+    forward(): string | null;
+    resetRecall(): void;
+    get inRecall(): boolean;
+}
+export declare function loadHistory(): Promise<ReplHistory>;

package/dist/cli/input/input-surface.d.ts

@@ -0,0 +1,63 @@
+import type { Interface as ReadlineInterface } from 'readline';
+import { type AutocompleteState } from './autocomplete-state.js';
+import type { IHistoryRing, ReadWithAutocompleteResult } from './types.js';
+import { TerminalCompositor, type CompositorScrollRegionGuard, type SuggestEngine, type SuggestContext } from '../terminal-compositor.js';
+export interface InputSurfaceStatusLine {
+    getExtraRows(): number;
+    setExtraRows(n: number): void;
+    withFullScrollRegion?<T>(fn: () => T): T;
+}
+export interface InputSurfaceOptions {
+    rl: ReadlineInterface;
+    history: IHistoryRing;
+    statusLine?: InputSurfaceStatusLine;
+}
+export interface InputSurfaceReadOpts {
+    promptFn: () => string;
+    onSigint?: () => void;
+    onShiftTab?: () => void;
+    compositor?: TerminalCompositor;
+}
+export interface InputSurfaceRefs {
+    history?: IHistoryRing;
+    autocompleteState?: AutocompleteState;
+    promptText?: string;
+}
+export interface InputSurfaceArmOpts {
+    promptFn: () => string;
+    onCancel: () => void;
+    onShiftTab?: () => void;
+    scrollRegion?: CompositorScrollRegionGuard;
+    stdout?: NodeJS.WriteStream;
+    stdin?: NodeJS.ReadStream;
+    anchorRow?: number;
+    suggest?: {
+        engine: SuggestEngine;
+        getContext: () => SuggestContext;
+    };
+}
+export declare class InputSurface {
+    readonly history: IHistoryRing;
+    readonly autocompleteState: AutocompleteState;
+    private readonly rl;
+    private readonly statusLine;
+    private compositor;
+    private armedStdout;
+    private backgroundHandler;
+    private softStopHandler;
+    private pauseInterruptHandler;
+    private pendingReadReject;
+    private readonly slashRegistryView;
+    constructor(opts: InputSurfaceOptions);
+    armCompositor(opts: InputSurfaceArmOpts): Promise<void>;
+    dispose(): Promise<void>;
+    getCompositor(): TerminalCompositor | null;
+    setBackgroundHandler(handler: (() => void) | null): void;
+    setSoftStopHandler(handler: (() => void) | null): void;
+    setPauseInterruptHandler(handler: (() => void) | null): void;
+    setPausedState(paused: boolean): void;
+    suspendForElicitation(): void;
+    resumeAfterElicitation(): void;
+    readLine(opts: InputSurfaceReadOpts): Promise<ReadWithAutocompleteResult>;
+    toRunTurnRefs(promptText: string): InputSurfaceRefs;
+}

package/dist/cli/input/non-tty.d.ts

@@ -0,0 +1,2 @@
+import type { ReadWithAutocompleteOpts, ReadWithAutocompleteResult } from './types.js';
+export declare function readNonTty(opts: ReadWithAutocompleteOpts): Promise<ReadWithAutocompleteResult>;

package/dist/cli/input/raw-mode.d.ts

@@ -0,0 +1,4 @@
+export interface RawModeHandle {
+    restore(): void;
+}
+export declare function enterRawMode(stdin: NodeJS.ReadStream, stdout: NodeJS.WriteStream): RawModeHandle;

package/dist/cli/input/reader.d.ts

@@ -0,0 +1,2 @@
+import type { ReadWithAutocompleteOpts, ReadWithAutocompleteResult } from './types.js';
+export declare function readWithAutocompleteTty(opts: ReadWithAutocompleteOpts): Promise<ReadWithAutocompleteResult>;

package/dist/cli/input/selectors.d.ts

@@ -0,0 +1,3 @@
+export declare const CUSTOM_ANSWER_SENTINEL = "\u270E Type your own answer";
+export declare function renderSelector(choices: string[], _abortSignal: AbortSignal): Promise<number | ':cancel' | null>;
+export declare function renderMultiSelector(choices: string[], _abortSignal: AbortSignal): Promise<number[] | ':cancel' | null>;

package/dist/cli/input/spinner.d.ts

@@ -0,0 +1,19 @@
+export interface SpinnerControllerOptions {
+    captureMode: boolean;
+    onTick: () => void;
+}
+export declare class SpinnerController {
+    private state;
+    private interval;
+    private readonly captureMode;
+    private readonly onTick;
+    constructor(opts: SpinnerControllerOptions);
+    set(config: {
+        enabled: boolean;
+        rotateVerbEveryMs?: number;
+    }): void;
+    dispose(): void;
+    renderSpinnerRow(): string | null;
+    renderTipRow(cols: number): string | null;
+    private tick;
+}

package/dist/cli/input/stdin-claim.d.ts

@@ -0,0 +1,7 @@
+export interface StdinClaimHandle {
+    release(): void;
+}
+export declare function acquireStdinClaim(holderName: string): StdinClaimHandle;
+export declare function withStdinClaim<T>(holderName: string, fn: () => Promise<T> | T): Promise<T>;
+export declare function currentStdinClaimHolder(): string | null;
+export declare function __resetStdinClaimForTests(): void;

package/dist/cli/input/suggest.d.ts

@@ -0,0 +1,36 @@
+import { type ProviderRouteHints } from '../../agent/providers/index.js';
+import type { ModelProvider } from '../../agent/provider.js';
+export interface SuggestContext {
+    model: string;
+    apiKey?: string;
+    baseUrl?: string;
+    cwd: string;
+    getHistory(): string[];
+    getDropdownTopCandidate(buffer: string): string | null;
+    getTranscriptTail(): string;
+    getRecentCommands(): string[];
+    llmEnabled(): boolean;
+}
+export declare function stripGhostControlChars(text: string): string;
+export interface SuggestEngineOptions {
+    completeFn?: (args: {
+        system: string;
+        user: string;
+        model: string;
+        maxTokens: number;
+        signal: AbortSignal;
+        apiKey?: string;
+        baseUrl?: string;
+    }) => Promise<string>;
+    resolveProviderFn?: (model: string | undefined, hints: ProviderRouteHints | undefined) => ModelProvider;
+    debounceMs?: number;
+    timeoutMs?: number;
+    onError?: (err: unknown) => void;
+}
+export interface SuggestEngine {
+    getDeterministicGhost(buffer: string, ctx: SuggestContext): string | null;
+    getGhost(buffer: string, ctx: SuggestContext): Promise<string | null>;
+    dispose(): void;
+}
+export declare function createSuggestEngine(opts?: SuggestEngineOptions): SuggestEngine;
+export declare function pickModel(ctx: SuggestContext): string;

package/dist/cli/input/trigger.d.ts

@@ -0,0 +1,5 @@
+import type { Candidate, Trigger } from './types.js';
+export declare function detectTrigger(buffer: string, cursorCol: number): Trigger | null;
+export declare function filterSlashCandidates(query: string): Candidate[];
+export declare function filterFileCandidates(query: string, rootDir?: string, homeDir?: string): Candidate[];
+export declare function filterFlagCandidates(command: string, query: string): Candidate[];

package/dist/cli/input/types.d.ts

@@ -0,0 +1,53 @@
+import type { Interface as ReadlineInterface } from 'readline';
+import type { ImageAttachment } from './attachments.js';
+import type { AutocompleteState } from './autocomplete-state.js';
+export interface IHistoryRing {
+    back(draft: string): string | null;
+    forward(): string | null;
+    resetRecall(): void;
+    readonly inRecall: boolean;
+}
+export type Trigger = {
+    kind: 'slash';
+    query: string;
+} | {
+    kind: 'file';
+    query: string;
+} | {
+    kind: 'flag';
+    command: string;
+    query: string;
+};
+export interface Candidate {
+    value: string;
+    summary?: string;
+    hint?: string;
+}
+export interface ReadWithAutocompleteOpts {
+    rl: ReadlineInterface;
+    promptFn: () => string;
+    onSigint?: () => void;
+    initialBuffer?: string;
+    onShiftTab?: () => void;
+    history?: IHistoryRing;
+    compositor?: {
+        isArmed(): boolean;
+    };
+    autocompleteState?: AutocompleteState;
+    statusLine?: {
+        getExtraRows(): number;
+        setExtraRows(n: number): void;
+        withFullScrollRegion?<T>(fn: () => T): T;
+    };
+}
+export interface ReadWithAutocompleteResult {
+    text: string;
+    attachments: ImageAttachment[];
+}
+export interface KeyInfo {
+    name?: string;
+    sequence?: string;
+    ctrl?: boolean;
+    meta?: boolean;
+    shift?: boolean;
+}

package/dist/cli/input-box.d.ts

@@ -0,0 +1,5 @@
+import type { ReadWithAutocompleteOpts, ReadWithAutocompleteResult } from './input/types.js';
+export { detectTrigger, filterFlagCandidates } from './input/trigger.js';
+export { formatSubmittedEcho, visualRowCount } from './input/echo.js';
+export type { ReadWithAutocompleteOpts, ReadWithAutocompleteResult, } from './input/types.js';
+export declare function readWithAutocomplete(opts: ReadWithAutocompleteOpts): Promise<ReadWithAutocompleteResult>;

package/dist/cli/input-core.d.ts

@@ -0,0 +1,37 @@
+export type MoveLineResult = {
+    moved: true;
+    state: InputCoreState;
+} | {
+    moved: false;
+};
+export interface InputCoreState {
+    readonly buffer: string;
+    readonly cursor: number;
+}
+export interface InputCoreRange {
+    readonly start: number;
+    readonly end: number;
+}
+declare function replaceRange(state: InputCoreState, range: InputCoreRange, text: string): InputCoreState;
+export declare const InputCore: {
+    readonly seed: (buffer?: string) => InputCoreState;
+    readonly replaceRange: typeof replaceRange;
+    readonly insert: (state: InputCoreState, text: string) => InputCoreState;
+    readonly backspace: (state: InputCoreState) => InputCoreState;
+    readonly deleteForward: (state: InputCoreState) => InputCoreState;
+    readonly deleteWordBackward: (state: InputCoreState) => InputCoreState;
+    readonly deleteWordForward: (state: InputCoreState) => InputCoreState;
+    readonly deleteToLineStart: (state: InputCoreState) => InputCoreState;
+    readonly deleteToLineEnd: (state: InputCoreState) => InputCoreState;
+    readonly moveLeft: (state: InputCoreState) => InputCoreState;
+    readonly moveRight: (state: InputCoreState) => InputCoreState;
+    readonly moveHome: (state: InputCoreState) => InputCoreState;
+    readonly moveEnd: (state: InputCoreState) => InputCoreState;
+    readonly moveLineStart: (state: InputCoreState) => InputCoreState;
+    readonly moveLineEnd: (state: InputCoreState) => InputCoreState;
+    readonly moveWordBackward: (state: InputCoreState) => InputCoreState;
+    readonly moveWordForward: (state: InputCoreState) => InputCoreState;
+    readonly moveUpLine: (state: InputCoreState, terminalWidth: number, promptVisibleLen: number) => MoveLineResult;
+    readonly moveDownLine: (state: InputCoreState, terminalWidth: number, promptVisibleLen: number) => MoveLineResult;
+};
+export {};

package/dist/cli/input-highlight.d.ts

@@ -0,0 +1,4 @@
+export interface SlashRegistryView {
+    has(name: string): boolean;
+}
+export declare function colorizeInputBuffer(buffer: string, registry: SlashRegistryView): string;

package/dist/cli/keychain.d.ts

@@ -0,0 +1 @@
+export { loadClaudeCodeOauthToken, refreshClaudeCodeOauthToken, parseAccountIdentifier, } from '../agent/auth/keychain.js';

package/dist/cli/loading-tips.d.ts

@@ -0,0 +1,14 @@
+export interface LoadingTip {
+    text: string;
+    id: string;
+    source: 'static' | 'command' | 'skill';
+}
+export declare function buildTipPool(): LoadingTip[];
+export declare function _resetSeenTipsForTesting(): void;
+export interface SelectTipOpts {
+    startedAt: number;
+    now?: number;
+    rotateMs?: number;
+    warmupMs?: number;
+}
+export declare function selectTip(pool: readonly LoadingTip[], opts: SelectTipOpts): LoadingTip | null;

package/dist/cli/markdown-stream-format.d.ts

@@ -0,0 +1,30 @@
+export declare function calculateContentWidth(indentLength: number): number;
+export declare function renderTextBlock(text: string, contentWidth: number): string;
+export declare function formatPendingBuffer(buffer: string, contentWidth: number, shouldRender: boolean): string;
+export declare function applyIndent(text: string, indentStr: string): string;
+export declare function formatBlockForCommit(blockText: string, indentStr: string, contentWidth: number): string;
+export declare function hasMarkdownContent(text: string): boolean;
+export declare function isInOpenCodeFence(text: string): boolean;
+export declare function isInOpenTable(text: string): boolean;
+export declare function findBlockBoundary(text: string): number;
+export declare function initLogUpdateModule(): Promise<{
+    (str: string): void;
+    clear: () => void;
+} | null>;
+export interface OverlayRoutingParams {
+    indented: string;
+    overlayComposer: {
+        markDirty(slot: string): void;
+        flush(): void;
+    } | null | undefined;
+    compositor: {
+        setOverlay(str: string): void;
+    } | null;
+    logUpdate: {
+        (str: string): void;
+        clear: () => void;
+    } | null;
+}
+export declare function routeOverlayOutput(params: OverlayRoutingParams): boolean;
+export declare function accumulateCommitted(current: string, trimmed: string): string;
+export declare function scheduleWithThrottle(callback: () => void, throttleMs: number, currentTimer: NodeJS.Timeout | null): NodeJS.Timeout;

package/dist/cli/markdown-stream.d.ts

@@ -0,0 +1,39 @@
+import type { TerminalCompositor } from './terminal-compositor.js';
+import type { OverlayComposer } from './_lib/overlay-composer.js';
+interface StreamingMarkdownRendererOptions {
+    out?: NodeJS.WriteStream;
+    throttleMs?: number;
+    indent?: string;
+    compositor?: TerminalCompositor;
+    overlayComposer?: OverlayComposer | null;
+}
+export declare class StreamingMarkdownRenderer {
+    private out;
+    private throttleMs;
+    private indent;
+    private buffer;
+    private committed;
+    private throttleTimer;
+    private logUpdate;
+    private isTTY;
+    private flushing;
+    private compositor;
+    private overlayComposer;
+    private resizeUnsub;
+    constructor(opts?: StreamingMarkdownRendererOptions);
+    private initLogUpdate;
+    private commitBlock;
+    private scheduleRepaint;
+    renderPending(): string;
+    private syncPendingOverlay;
+    private repaint;
+    push(chunk: string): void;
+    flush(): Promise<void>;
+    getCommittedOutput(): string;
+    hasEmitted(): boolean;
+    getPendingBuffer(): string;
+    commitPending(): void;
+    discardPending(): void;
+    dispose(): void;
+}
+export {};

package/dist/cli/mascot.d.ts

@@ -0,0 +1,6 @@
+export type MascotState = 'idle' | 'working' | 'alert';
+export declare const MASCOT_WIDTH = 19;
+export declare const MASCOT_HEIGHT = 8;
+export declare function renderMascotLines(state?: MascotState): string[];
+export declare function mascotSuppressed(): boolean;
+export declare const __GOBLIN_GRID_FOR_TESTS: readonly string[];

package/dist/cli/model-limits.d.ts

@@ -0,0 +1 @@
+export { MODEL_CONTEXT_LIMITS, contextLimitFor, MODEL_MAX_OUTPUT_TOKENS, maxOutputTokensFor, } from '../agent/model-limits.js';

package/dist/cli/multi-line-reader.d.ts

@@ -0,0 +1,16 @@
+import type { Interface as ReadlineInterface } from 'readline';
+export type Completer = (line: string) => [string[], string];
+export declare function buildCompleter(rootDir?: string): Completer;
+export declare const MAX_FILE_MATCHES = 50;
+export declare function resolveQuery(query: string, rootDir: string, homeDir?: string): {
+    scanDir: string;
+    leafPrefix: string;
+    displayPrefix: string;
+};
+export declare function fileMatchesFor(prefix: string, rootDir?: string): string[];
+export interface MultiLineReaderOptions {
+    rl: ReadlineInterface;
+    promptFn: () => string;
+    continuationPrompt?: string;
+}
+export declare function readInput(opts: MultiLineReaderOptions): Promise<string>;

package/dist/cli/palette.d.ts

@@ -0,0 +1,29 @@
+export declare const palette: {
+    readonly brand: import("chalk").ChalkInstance;
+    readonly mint: import("chalk").ChalkInstance;
+    readonly goblin: import("chalk").ChalkInstance;
+    readonly user: import("chalk").ChalkInstance;
+    readonly caret: import("chalk").ChalkInstance;
+    readonly tool: import("chalk").ChalkInstance;
+    readonly chrome: import("chalk").ChalkInstance;
+    readonly syntaxString: import("chalk").ChalkInstance;
+    readonly toolArg: import("chalk").ChalkInstance;
+    readonly thinking: import("chalk").ChalkInstance;
+    readonly success: import("chalk").ChalkInstance;
+    readonly error: import("chalk").ChalkInstance;
+    readonly warning: import("chalk").ChalkInstance;
+    readonly plan: import("chalk").ChalkInstance;
+    readonly bypass: import("chalk").ChalkInstance;
+    readonly meta: import("chalk").ChalkInstance;
+    readonly info: import("chalk").ChalkInstance;
+    readonly fileRef: import("chalk").ChalkInstance;
+    readonly heading: import("chalk").ChalkInstance;
+    readonly label: import("chalk").ChalkInstance;
+    readonly dim: import("chalk").ChalkInstance;
+    readonly bold: import("chalk").ChalkInstance;
+    readonly italic: import("chalk").ChalkInstance;
+    readonly diffAdd: import("chalk").ChalkInstance;
+    readonly diffRemove: import("chalk").ChalkInstance;
+    readonly diffHunk: import("chalk").ChalkInstance;
+};
+export type Palette = typeof palette;

package/dist/cli/permission-mode-cycle.d.ts

@@ -0,0 +1,3 @@
+import type { SlashContext } from './slash/types.js';
+export declare const PERMISSION_CYCLE: readonly ["default", "plan", "bypassPermissions"];
+export declare function cyclePermissionMode(ctx: SlashContext): Promise<void>;

package/dist/cli/plan-mode-toggle.d.ts

@@ -0,0 +1,2 @@
+import type { SlashContext } from './slash/types.js';
+export declare function togglePlanMode(ctx: SlashContext, desired?: boolean): Promise<void>;

package/dist/cli/render/box.d.ts

@@ -0,0 +1,8 @@
+import type { ChalkInstance } from 'chalk';
+export interface DrawBoxOptions {
+    border?: ChalkInstance;
+    title?: string;
+    width?: number;
+    padding?: number;
+}
+export declare function drawBox(content: string | string[], opts?: DrawBoxOptions): string;

package/dist/cli/render/card.d.ts

@@ -0,0 +1,8 @@
+export type CardKind = 'plan' | 'status' | 'checkpoint' | 'diagnosis' | 'user';
+export interface CardSpec {
+    kind: CardKind;
+    title?: string;
+    body: string | string[];
+    leftPad?: number;
+}
+export declare function card(spec: CardSpec): string;

package/dist/cli/render/divider.d.ts

@@ -0,0 +1 @@
+export declare function divider(title?: string): string;

package/dist/cli/render/error-box.d.ts

@@ -0,0 +1 @@
+export declare function errorBox(title: string, details?: string): string;

package/dist/cli/render/help-table.d.ts

@@ -0,0 +1,9 @@
+export interface HelpEntry {
+    cmd: string;
+    desc: string;
+}
+export interface HelpSection {
+    title: string;
+    entries: HelpEntry[];
+}
+export declare function helpTable(sections: HelpSection[]): string;

package/dist/cli/render/index.d.ts

@@ -0,0 +1,9 @@
+export * from './status-panel.js';
+export * from './welcome-banner.js';
+export * from './help-table.js';
+export * from './error-box.js';
+export * from './usage-limit-box.js';
+export * from './card.js';
+export * from './divider.js';
+export * from './progress-bar.js';
+export * from './box.js';

package/dist/cli/render/picker.d.ts

@@ -0,0 +1,15 @@
+import type { PickerController } from '../terminal-compositor.js';
+export interface PickerHost {
+    enterPickerMode(controller: PickerController): void;
+    exitPickerMode(): void;
+    repaintPicker(): void;
+}
+export interface RunPickerOptions {
+    header: readonly string[];
+    options: readonly string[];
+    multi?: boolean;
+    signal?: AbortSignal;
+    initialIndex?: number;
+    initialSelected?: ReadonlySet<number>;
+}
+export declare function runPicker(host: PickerHost, opts: RunPickerOptions): Promise<readonly string[] | null>;

package/dist/cli/render/progress-bar.d.ts

@@ -0,0 +1 @@
+export declare function progressBar(ratio: number, width?: number): string;

package/dist/cli/render/status-panel.d.ts

@@ -0,0 +1,7 @@
+export type StatusKind = 'ok' | 'warn' | 'error' | 'info';
+export interface StatusRow {
+    label: string;
+    value: string;
+    kind?: StatusKind;
+}
+export declare function statusPanel(title: string, rows: StatusRow[]): string;