@botconnector/bccli 0.5.0-rc.4 → 0.5.0

package/legacy/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/legacy/dist/ui/complete.d.ts

@@ -0,0 +1,8 @@
+export declare function listFileSuggestions(value: string, cwd: string, limit?: number): string[];
+export declare function applyFileSuggestion(value: string, pick: string): string;
+export declare function completeFile(value: string, cwd: string): string;
+/**
+ * Pre-attaches small non-secret project files referenced via `@path/to/file` in a user prompt,
+ * and records them in `readFiles` so the model can inspect or edit them without an extra tool turn.
+ */
+export declare function expandAtFileMentions(prompt: string, cwd: string, readFiles?: Set<string>): string;

package/legacy/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/legacy/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/legacy/dist/ui/liveCap.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Splits a frame budget between the live entries, newest first, so the entry being streamed is never the one dropped.
+ * A per-entry cap is not enough: an open thinking block and a streaming answer each fitting the budget still add up
+ * to a frame twice as tall as the terminal, and Ink rewrites (and duplicates) such a frame on every render.
+ */
+export declare function liveRowCaps(wanted: number[], budget: number): number[];
+/**
+ * Plain-text twin of `capLiveMarkdown`: keeps the tail that fits `maxRows` terminal rows and announces the rest.
+ * Used for thinking and tool output, which are drawn as plain wrapped text rather than markdown.
+ */
+export declare function capLiveText(raw: string, options: {
+    isRealTty: boolean;
+    maxRows: number;
+    width: number;
+}): string;
+/**
+ * Live assistant text is drawn inside the Ink frame, so on a real terminal it is capped to the rows left after the
+ * prompt and status bar; the hidden part is announced instead of silently dropped. Piped stdout has no rows to
+ * respect (`bccli | tee log`, CI harnesses), so the text is kept whole there.
+ *
+ * The budget is in terminal rows, not source lines: a 40-line answer at 100 columns is 120 rows, and an Ink frame
+ * taller than the terminal makes every render rewrite the whole screen, which stamps duplicate copies of the same
+ * block into the scrollback.
+ */
+export declare function capLiveMarkdown(raw: string, options: {
+    isRealTty: boolean;
+    maxRows: number;
+    width: number;
+}): string;

package/legacy/dist/ui/markdownLayout.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The line shapes `Markdown` draws. They live here so the renderer and the row counter below share one parse order:
+ * a drift between the two is what makes a live frame taller than the terminal believes.
+ */
+export declare const HEADING: RegExp;
+export declare const RULE: RegExp;
+export declare const QUOTE: RegExp;
+export declare const BULLET: RegExp;
+export declare const NUMBERED: RegExp;
+export declare const BULLETS: string[];
+/** Marker width for a list item indented by `spaces`, matching `bulletFor` in Markdown.tsx. */
+export declare const bulletFor: (spaces: number) => string;
+/** Text rows a single unwrapped line occupies at `width` columns; Ink wraps on spaces, so this is the safe bound. */
+export declare function wrappedRows(text: string, width: number): number;
+/**
+ * Rows `Markdown` will draw for `text` at `width`. It mirrors the render loop in Markdown.tsx line for line —
+ * `markdownLayout.test.ts` renders real markdown and compares, so the two cannot drift unnoticed.
+ *
+ * A live assistant message has to be sized in the rows it really occupies, not in the lines its source has: at
+ * 100 columns a single paragraph is three rows, and a live frame that is taller than the terminal makes Ink rewrite
+ * the whole screen on every render, which stamps copies of the same answer into the scrollback.
+ */
+export declare function markdownRowCount(text: string, width: number): number;

package/legacy/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/legacy/dist/ui/stdinFilter.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Terminals without SGR support answer mouse tracking (`\x1b[?1000h`, which bccli only turns on while the Thinking
+ * block is clickable) with legacy X10 reports: `ESC [ M` followed by three raw bytes. Ink 8 drops the `ESC [ M`
+ * prefix but passes those three bytes to `useInput` as if typed, so they land in the prompt as punctuation.
+ * Remove the whole report here, where the prefix is still visible.
+ *
+ * `carry` is the tail of a report split across chunks; feed it back as the second argument on the next chunk.
+ */
+export declare function stripLegacyMouseReports(chunk: string, carry?: string): {
+    text: string;
+    carry: string;
+};
+/**
+ * Ink owns the input stream, so a report can only be kept out of `useInput` if it never reaches Ink's reader.
+ * Ink 8 reads stdin with `read()`, so the filter wraps that single method: everything that is not an X10 report is
+ * forwarded byte for byte and every other stream property (raw mode, TTY flags, event handlers) stays the real one.
+ */
+export declare function installLegacyMouseFilter(source: NodeJS.ReadStream): () => void;

package/legacy/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/legacy/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/legacy/dist/ui/thinkingMouse.d.ts

@@ -0,0 +1,38 @@
+/** 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;
+/** Detect raw SGR wheel packets in a raw stdin data chunk (before ESC is stripped), used to suspend mouse capture. */
+export declare function hasMouseWheelSequence(chunk: string): boolean;
+/**
+ * Sequence fragments Ink 8 does not recognise (mouse, cursor reports) are dropped when complete, but an incomplete
+ * escape is flushed as literal input after ~20 ms. That fragment must never be typed into a prompt or filter.
+ */
+export declare function isControlReportFragment(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/legacy/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/legacy/dist/ui/tty.d.ts

@@ -0,0 +1,11 @@
+/** True when the stream reports itself as a TTY (fake test streams may still report `true`). */
+export declare function isTtyStream(stream: unknown): boolean;
+/** True only for a real terminal: a TTY that also exposes a file descriptor. */
+export declare function isRealTty(stream: unknown): boolean;
+/**
+ * Terminal width at render time. Reading it instead of listening to `resize` keeps the app to the single resize
+ * listener Ink already owns (it re-renders the tree on resize), instead of one listener per rendered message.
+ */
+export declare function streamColumns(stream: unknown): number;
+/** Terminal height at render time; same reasoning as `streamColumns`. */
+export declare function streamRows(stream: unknown): number;

package/legacy/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" or "c" so the next key picks the text object (dd, dw, cc, cw). */
+    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;