@botconnector/bccli 0.4.0-beta.9 → 0.4.1

package/dist/ui/PlanApproval.d.ts

@@ -0,0 +1,5 @@
+import type { PlanDecision } from '../tools/plan';
+export declare function PlanApproval({ plan, onAnswer }: {
+    plan: string;
+    onAnswer(d: PlanDecision): void;
+}): import("react").JSX.Element;

package/dist/ui/PromptInput.d.ts

@@ -0,0 +1,18 @@
+export interface PromptInputProps {
+    disabled?: boolean;
+    history: string[];
+    cwd: string;
+    onSubmit(text: string): void;
+    extraCommands?: {
+        name: string;
+        description: string;
+    }[];
+    /** Text inserted at the cursor from outside (e.g. a pasted clipboard image path); `n` triggers each insert. */
+    injected?: {
+        text: string;
+        n: number;
+    };
+    /** Vim editing: Esc enters normal mode (hjkl/w/b/0/$/x/dd/dw/i/a/A/o/O). */
+    vim?: boolean;
+}
+export declare function PromptInput({ disabled, history, cwd, onSubmit, extraCommands, injected, vim }: PromptInputProps): import("react").JSX.Element;

package/dist/ui/ProviderMenu.d.ts

@@ -0,0 +1,10 @@
+export interface ProviderEntry {
+    id: string;
+    name: string;
+    ready: boolean;
+    baseURL: string;
+}
+export declare function ProviderMenu({ entries, onPick }: {
+    entries: ProviderEntry[];
+    onPick(id: string | 'custom' | undefined): void;
+}): import("react").JSX.Element;

package/dist/ui/Spinner.d.ts

@@ -0,0 +1,4 @@
+export declare function Spinner({ label, startedAt }: {
+    label: string;
+    startedAt: number;
+}): import("react").JSX.Element;

package/dist/ui/StatusBar.d.ts

@@ -0,0 +1,9 @@
+import type { PermissionMode } from '../config';
+import type { ReasoningLevel } from '../reasoning';
+export declare function StatusBar({ mode, tokens, busy, model, reasoning }: {
+    mode: PermissionMode;
+    tokens: number;
+    busy: boolean;
+    model?: string;
+    reasoning?: ReasoningLevel;
+}): import("react").JSX.Element;

package/dist/ui/TodoList.d.ts

@@ -0,0 +1,4 @@
+import type { TodoItem } from '../tools/todo';
+export declare function TodoList({ items }: {
+    items: TodoItem[];
+}): import("react").JSX.Element | null;

package/dist/ui/ToolBlock.d.ts

@@ -0,0 +1,14 @@
+import type { SubLine } from './transcript';
+export interface ToolBlockProps {
+    tool: string;
+    target: string;
+    output?: string;
+    display?: string;
+    isError?: boolean;
+    done: boolean;
+    expanded?: boolean;
+    sub?: SubLine[];
+    /** Display spec of the "show full output" keybind, so the hint follows a rebound key. */
+    moreBind?: string;
+}
+export declare function ToolBlock({ tool, target, output, display, isError, done, expanded, sub, moreBind }: ToolBlockProps): import("react").JSX.Element;

package/dist/ui/complete.d.ts

@@ -0,0 +1 @@
+export declare function completeFile(value: string, cwd: string): string;

package/dist/ui/focusReport.d.ts

@@ -0,0 +1 @@
+export declare const isFocusReport: (input: string) => boolean;

package/dist/ui/index.d.ts

@@ -0,0 +1,7 @@
+import type { Runtime } from '../setup';
+export declare function startInteractive(rt: Runtime, opts: {
+    initialPrompt?: string;
+    resume: boolean;
+    version: string;
+    updateMessage?: string;
+}): Promise<number>;

package/dist/ui/lineEdit.d.ts

@@ -0,0 +1,42 @@
+export interface LineState {
+    value: string;
+    cursor: number;
+}
+export interface EditKey {
+    leftArrow?: boolean;
+    rightArrow?: boolean;
+    home?: boolean;
+    end?: boolean;
+    backspace?: boolean;
+    delete?: boolean;
+    ctrl?: boolean;
+    meta?: boolean;
+}
+export declare function prevBoundary(text: string, pos: number): number;
+export declare function nextBoundary(text: string, pos: number): number;
+/** Start of the word before the cursor: skips spaces, then the word itself. */
+export declare function wordLeft(text: string, pos: number): number;
+/** End of the word after the cursor: skips spaces, then the word itself. */
+export declare function wordRight(text: string, pos: number): number;
+export declare const lineStart: (text: string, pos: number) => number;
+export declare function lineEnd(text: string, pos: number): number;
+export declare const lineCount: (text: string) => number;
+/** Moves to the same column one line up or down; undefined when there is no such line. */
+export declare function moveLine(text: string, pos: number, direction: -1 | 1): number | undefined;
+export declare const atEnd: (s: LineState) => boolean;
+export declare function insert(s: LineState, text: string): LineState;
+/**
+ * The result of an editing key, or undefined when the key is not one of them (Enter, Esc, Tab and the arrows that
+ * walk through history belong to the caller). Printable text goes through `insert`.
+ */
+export declare function applyEditKey(s: LineState, input: string, key: EditKey): LineState | undefined;
+/** What to draw: the text before the cursor, the character under it (a space at the end or on a line break), the rest. */
+export declare function splitAtCursor(s: LineState): {
+    before: string;
+    at: string;
+    after: string;
+};
+/** The characters of a text as the user sees them. */
+export declare const graphemes: (text: string) => string[];
+/** The same cursor over a hidden text (an API key): one dot per character. */
+export declare function masked(s: LineState): LineState;

package/dist/ui/replay.d.ts

@@ -0,0 +1,4 @@
+import { type ChatMessage } from '../provider';
+import { type Entry } from './transcript';
+/** The screen rows for a resumed conversation: a notice, then every user and assistant text message in order. */
+export declare function replayEntries(history: ChatMessage[]): Entry[];

package/dist/ui/table.d.ts

@@ -0,0 +1,20 @@
+export type Style = 'plain' | 'bold' | 'italic' | 'strike' | 'link' | 'code' | 'dim';
+export interface Seg {
+    text: string;
+    style: Style;
+}
+export type Align = 'left' | 'center' | 'right';
+export interface TableData {
+    header: Seg[][];
+    align: Align[];
+    rows: Seg[][][];
+}
+export declare function charWidth(cp: number): number;
+export declare function displayWidth(text: string): number;
+export declare function parseInline(text: string): Seg[];
+/** A table starting at lines[start] (header row, separator row, body rows), or undefined. `end` is the next line to read. */
+export declare function parseTable(lines: string[], start: number): {
+    table: TableData;
+    end: number;
+} | undefined;
+export declare function layoutTable(table: TableData, width: number): Seg[][];

package/dist/ui/theme.d.ts

@@ -0,0 +1,5 @@
+export declare const THEMES: readonly ['default', 'blue', 'amber', 'magenta', 'mono'];
+export declare function setTheme(name: string): void;
+export declare function currentTheme(): string;
+export declare function color(name: string): string | undefined;
+export declare const ACCENT = "green";

package/dist/ui/thinkingMouse.d.ts

@@ -0,0 +1,33 @@
+/** SGR terminal mouse position (1-based), used only for the live Thinking status. */
+export interface MousePress {
+    x: number;
+    y: number;
+}
+export declare function parseMousePress(value: string): MousePress | undefined;
+export declare function parseCursorPosition(value: string): {
+    row: number;
+    col: number;
+} | undefined;
+/** Ink returns local element positions, not viewport coordinates. The cursor rests after the live frame. */
+export declare function clickedThinking(click: MousePress, cursorRow: number, rootHeight: number, target: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}): boolean;
+/** Ink useInput receives these control reports too; they must not enter the prompt. */
+export declare function isMouseControlInput(input: string): boolean;
+/** Tokenize split/coalesced Windows ConPTY SGR presses and cursor reports. */
+export declare function parseThinkingReports(value: string): {
+    events: Array<{
+        type: 'mouse';
+        press: MousePress;
+    } | {
+        type: 'cursor';
+        cursor: {
+            row: number;
+            col: number;
+        };
+    }>;
+    rest: string;
+};

package/dist/ui/transcript.d.ts

@@ -0,0 +1,55 @@
+import type { AgentEvent } from '../agent';
+export interface SubLine {
+    id: string;
+    tool: string;
+    target: string;
+    done: boolean;
+    isError?: boolean;
+}
+export type Entry = {
+    id: number;
+} & ({
+    kind: 'header';
+} | {
+    kind: 'user';
+    text: string;
+}
+/** cont: continuation of the entry above (no bullet); flushed: chars of this completion already moved to scrollback. */
+ | {
+    kind: 'assistant';
+    text: string;
+    cont?: boolean;
+    flushed?: number;
+}
+/** open: fixed state for a reprint; otherwise follows the ctrl+t toggle. */
+ | {
+    kind: 'thinking';
+    text: string;
+    open?: boolean;
+} | {
+    kind: 'tool';
+    callId: string;
+    tool: string;
+    target: string;
+    output?: string;
+    display?: string;
+    isError?: boolean;
+    done: boolean;
+    sub?: SubLine[];
+} | {
+    kind: 'notice';
+    text: string;
+    tone: 'info' | 'warn' | 'error';
+});
+/** done = printed once to scrollback (Ink <Static>); live = still changing, redrawn every frame. */
+export interface Transcript {
+    done: Entry[];
+    live: Entry[];
+}
+type EntryInput = Entry extends infer E ? (E extends {
+    id: number;
+} ? Omit<E, 'id'> : never) : never;
+export declare const entry: (e: EntryInput) => Entry;
+export declare function endTurn(t: Transcript): Transcript;
+export declare function applyEvent(t: Transcript, event: AgentEvent): Transcript;
+export {};

package/dist/ui/vim.d.ts

@@ -0,0 +1,26 @@
+import { type LineState } from './lineEdit';
+export type VimMode = 'normal' | 'insert';
+/** The subset of ink's key flags applyVim looks at (EditKey is too narrow for Esc/Enter/arrows). */
+export interface VimKey {
+    escape?: boolean;
+    upArrow?: boolean;
+    downArrow?: boolean;
+    leftArrow?: boolean;
+    rightArrow?: boolean;
+    ctrl?: boolean;
+    meta?: boolean;
+    tab?: boolean;
+    return?: boolean;
+}
+export interface VimResult {
+    state: LineState;
+    mode: VimMode;
+    /** Set by "d" so the next key picks the text object (dd, dw). */
+    pending?: string;
+    handled: boolean;
+}
+/**
+ * Vim key handling for the prompt. Returns handled=false for keys the host input loop
+ * should process itself (insert-mode typing, arrows, ctrl/meta combos, Enter).
+ */
+export declare function applyVim(s: LineState, mode: VimMode, input: string, key: VimKey, pending?: string): VimResult;