@botconnector/bccli 0.4.0 → 0.4.2

package/dist/tools/fetch.d.ts

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+export declare function htmlToText(html: string): string;
+export declare function isPrivateHost(host: string): boolean;
+export interface PinnedAddress {
+    address: string;
+    family: number;
+}
+type LookupCallback = (err: NodeJS.ErrnoException | null, address: string | PinnedAddress[], family?: number) => void;
+/**
+ * A DNS lookup that answers with the address the rebinding guard already validated,
+ * so the socket connects to exactly the IP that was checked (closes the
+ * resolve-then-fetch gap). An empty pin falls back to the real resolver; a family
+ * mismatch refuses instead of re-resolving, and unknown hostnames use real DNS.
+ */
+export declare function pinLookup(pinned: PinnedAddress[]): (hostname: string, options: unknown, callback: LookupCallback) => void;
+/** Best BM25 chunks for `query`, in page order; null when no chunk shares a word with it. */
+export declare function pickRelevant(text: string, query: string, count?: number, size?: number): string | null;
+export declare const clearFetchCache: () => void;
+export interface FetchToolOptions {
+    /** Keenable fetch endpoint used when `prompt` is given; null disables it. */
+    keenableURL?: string | null;
+    isPrivate?: (host: string) => boolean;
+    /** DNS resolver for the rebinding guard; injectable for tests. */
+    lookup?: (hostname: string) => Promise<Array<{
+        address: string;
+        family: number;
+    }>>;
+    /** Page fetch override for tests; receives the same init (including `dispatcher`). */
+    fetchPage?: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+}
+export declare function createFetchTool(opts?: FetchToolOptions): import("./types").Tool<z.ZodObject<{
+    url: z.ZodString;
+    prompt: z.ZodOptional<z.ZodString>;
+    offset: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>>;
+export declare const fetchTool: import("./types").Tool<z.ZodObject<{
+    url: z.ZodString;
+    prompt: z.ZodOptional<z.ZodString>;
+    offset: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>>;
+export {};

package/dist/tools/glob.d.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+export declare const globTool: import("./types").Tool<z.ZodObject<{
+    pattern: z.ZodString;
+    path: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;

package/dist/tools/globSafety.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Reject glob inputs that can trigger pathological brace expansion before they
+ * reach the glob engine. Backslash-escaped braces are literals.
+ */
+export declare function validateGlobPattern(pattern: string): string | undefined;
+/** Keep tool/UI path output stable across Windows and POSIX. */
+export declare function normalizeGlobPath(path: string): string;

package/dist/tools/grep.d.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+export interface GrepOptions {
+    root: string;
+    projectRoot?: string;
+    glob?: string;
+    ignoreCase?: boolean;
+    literal?: boolean;
+    context?: number;
+    outputMode?: 'content' | 'files_with_matches' | 'count';
+    signal?: AbortSignal;
+}
+export declare function grepJs(pattern: string, opts: GrepOptions): Promise<string[]>;
+export declare const grepTool: import("./types").Tool<z.ZodObject<{
+    pattern: z.ZodString;
+    path: z.ZodOptional<z.ZodString>;
+    glob: z.ZodOptional<z.ZodString>;
+    ignore_case: z.ZodOptional<z.ZodBoolean>;
+    literal: z.ZodOptional<z.ZodBoolean>;
+    context: z.ZodOptional<z.ZodNumber>;
+    output_mode: z.ZodOptional<z.ZodEnum<{
+        content: "content";
+        count: "count";
+        files_with_matches: "files_with_matches";
+    }>>;
+}, z.core.$strip>>;

package/dist/tools/ignore.d.ts

@@ -0,0 +1,2 @@
+/** Native glob exclude patterns: node_modules, .git, and .gitignore entries up to projectRoot. */
+export declare function ignorePatterns(root: string, projectRoot?: string): string[];

package/dist/tools/index.d.ts

@@ -0,0 +1,12 @@
+import type { Tool } from './types';
+export interface ToolDefinition {
+    type: 'function';
+    function: {
+        name: string;
+        description: string;
+        parameters: Record<string, unknown>;
+        output_schema?: Record<string, unknown>;
+    };
+}
+export declare const ALL_TOOLS: Tool[];
+export declare function toolDefinitions(tools: Tool[]): ToolDefinition[];

package/dist/tools/memory.d.ts

@@ -0,0 +1,13 @@
+import { defineTool } from './types';
+export interface SaveMemoryOptions {
+    /** Global store lives at <home>/BCCLI.md; project store at <cwd>/AGENTS.md. */
+    home: string;
+    /** Called after the instruction files changed so the system prompt can be rebuilt. */
+    onSaved?: () => void;
+}
+/**
+ * Lets the model persist durable facts itself (same store as /memory): project rules
+ * go to AGENTS.md, cross-project preferences to the global BCCLI.md. Duplicate lines
+ * are not written again.
+ */
+export declare function createSaveMemoryTool(opts: SaveMemoryOptions): ReturnType<typeof defineTool>;

package/dist/tools/paths.d.ts

@@ -0,0 +1,4 @@
+export declare function resolvePath(cwd: string, path: string): string;
+export declare function errorCode(error: unknown): string;
+export declare function recordFileMtime(readFiles: Set<string>, abs: string): void;
+export declare function isFileModifiedSinceRead(readFiles: Set<string>, abs: string): boolean;

package/dist/tools/plan.d.ts

@@ -0,0 +1,10 @@
+import type { Permissions } from '../permissions';
+import { type Tool } from './types';
+export type PlanDecision = 'acceptEdits' | 'default' | 'allowAll' | 'no';
+export interface Interaction {
+    approvePlan(plan: string): Promise<PlanDecision>;
+}
+export declare function createExitPlanTool(opts: {
+    permissions: Permissions;
+    interaction: Interaction;
+}): Tool;

package/dist/tools/read.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+export declare const MAX_IMAGE_BYTES: number;
+export interface ReadToolOptions {
+    /** Attach images to the conversation as vision parts instead of refusing binary files. Default true. */
+    vision?: boolean;
+}
+export declare function createReadTool(options?: ReadToolOptions): import("./types").Tool<z.ZodObject<{
+    path: z.ZodString;
+    offset: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>>;
+export declare const readTool: import("./types").Tool<z.ZodObject<{
+    path: z.ZodString;
+    offset: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>>;

package/dist/tools/repomap.d.ts

@@ -0,0 +1,2 @@
+import { z } from 'zod';
+export declare function createRepoMapTool(): import("./types").Tool<z.ZodObject<{}, z.core.$strip>>;

package/dist/tools/sandbox.d.ts

@@ -0,0 +1,12 @@
+export declare function sandboxSupported(platform: NodeJS.Platform): boolean;
+/** Seatbelt profile: read everything, write only under cwd + temp areas, network only when allowed. */
+export declare function darwinProfile(cwd: string, network: boolean): string;
+/**
+ * Wrap a shell command in the platform sandbox, or undefined when the platform has none
+ * (the caller then refuses to run it sandboxed rather than silently running it raw).
+ */
+export declare function sandboxArgv(command: string, opts: {
+    platform: NodeJS.Platform;
+    cwd: string;
+    network: boolean;
+}): string[] | undefined;

package/dist/tools/shell.d.ts

@@ -0,0 +1,18 @@
+/**
+ * How a command string is run. `undefined` (posix) keeps the default `sh -c` behaviour.
+ * On Windows we never use cmd.exe: Git Bash gives the usual Unix tools (tail, grep, ls,
+ * sed); without it we fall back to Windows PowerShell with UTF-8 output.
+ */
+export interface ShellSpec {
+    name: 'bash' | 'powershell';
+    file: string;
+    args: (command: string) => string[];
+}
+export interface ShellDeps {
+    platform: NodeJS.Platform;
+    env: NodeJS.ProcessEnv;
+    exists: (path: string) => boolean;
+}
+export declare function resolveShell(deps: ShellDeps): ShellSpec | undefined;
+/** Shell for the current machine, resolved once. */
+export declare function defaultShell(): ShellSpec | undefined;

package/dist/tools/skill.d.ts

@@ -0,0 +1,3 @@
+import { type SkillDef } from '../extensions';
+import { type Tool } from './types';
+export declare function createSkillTool(skills: SkillDef[]): Tool;

package/dist/tools/task.d.ts

@@ -0,0 +1,28 @@
+import type { AgentDef } from '../extensions';
+import type { Permissions } from '../permissions';
+import type { Provider } from '../provider';
+import type { ReasoningLevel } from '../reasoning';
+import { type Tool } from './types';
+import type { HooksConfig } from '../hooks';
+type TaskToolOptionsPluginEmit = (event: 'PreToolUse' | 'PostToolUse' | 'SessionStart' | 'Stop', payload?: {
+    tool?: string;
+    input?: unknown;
+    output?: string;
+}) => Promise<void>;
+export interface TaskToolOptions {
+    agents: AgentDef[];
+    baseTools: () => Tool[];
+    permissions: Permissions;
+    provider: () => Provider;
+    providerFor: (modelRef: string) => Provider;
+    systemPrompt: string | ((modelRef?: string) => string);
+    cwd: string;
+    reasoning?: () => ReasoningLevel;
+    /** Inherited by subagents so their tool calls fire the same hooks as the main agent. */
+    hooks?: HooksConfig;
+    /** Inherited by subagents so their tool calls fire the same plugin observers as the main agent. */
+    pluginEmit?: TaskToolOptionsPluginEmit;
+    env?: NodeJS.ProcessEnv;
+}
+export declare function createTaskTool(opts: TaskToolOptions): Tool;
+export {};

package/dist/tools/todo.d.ts

@@ -0,0 +1,13 @@
+import { type Tool } from './types';
+export type TodoStatus = 'pending' | 'in_progress' | 'completed';
+export interface TodoItem {
+    content: string;
+    status: TodoStatus;
+}
+export declare class TodoStore {
+    items: TodoItem[];
+    private readonly listeners;
+    set(items: TodoItem[]): void;
+    subscribe(fn: (items: TodoItem[]) => void): () => void;
+}
+export declare function createTodoTool(store: TodoStore): Tool;

package/dist/tools/types.d.ts

@@ -0,0 +1,52 @@
+import type { z } from 'zod';
+import type { AgentEvent, AskPermission } from '../agent';
+import type { Usage } from '../provider';
+export type PermissionKind = 'read' | 'edit' | 'bash' | 'fetch' | 'mcp';
+export interface ToolContext {
+    cwd: string;
+    signal: AbortSignal;
+    /** Absolute paths read in this session; edit/write of existing files require membership. */
+    readFiles: Set<string>;
+    callId?: string;
+    emit?: (event: AgentEvent) => void;
+    ask?: AskPermission;
+    addUsage?: (usage: Usage) => void;
+    /** A fetch that was answered from cache calls this so it does not count against the per-turn fetch limit. */
+    refundFetch?: () => void;
+    /** Called with the absolute path before a file is written, so the change can be undone. */
+    checkpoint?: (absPath: string) => Promise<void>;
+}
+export interface ImageAttachment {
+    mediaType: string;
+    /** Base64 (no data: prefix). */
+    data: string;
+    path: string;
+}
+export interface ToolResult {
+    /** Sent back to the model. */
+    output: string;
+    isError?: boolean;
+    /** Optional richer text for the UI (e.g. a diff). */
+    display?: string;
+    /** Image files read this call; the agent injects them as a user message with image parts. */
+    images?: ImageAttachment[];
+}
+export interface Tool<S extends z.ZodType = z.ZodType> {
+    name: string;
+    description: string;
+    schema: S;
+    kind: PermissionKind;
+    /** Raw JSON schema sent to the model instead of converting `schema` (used for MCP tools). */
+    jsonSchema?: Record<string, unknown>;
+    outputJsonSchema?: Record<string, unknown>;
+    target(input: z.infer<S>): string;
+    preview?(input: z.infer<S>, ctx: ToolContext): Promise<string | undefined>;
+    /** Cheap pre-check run before asking permission; returns an error message when the call cannot succeed. */
+    validate?(input: z.infer<S>, ctx: ToolContext): Promise<string | undefined>;
+    /** Consecutive calls whose tool returns true here run concurrently. */
+    parallelSafe?(input: z.infer<S>): boolean;
+    /** Internal safety metadata: safe to call from a bounded read-only PTC program. */
+    programmaticSafe?: boolean;
+    run(input: z.infer<S>, ctx: ToolContext): Promise<ToolResult>;
+}
+export declare function defineTool<S extends z.ZodType>(tool: Tool<S>): Tool<S>;

package/dist/tools/websearch.d.ts

@@ -0,0 +1,9 @@
+import { type Tool } from './types';
+export declare function createWebSearchTool(opts: {
+    /** BotConnector Cloud endpoint + key, when the user has one; searches then go through our server. */
+    botconnector: () => {
+        baseURL: string;
+        apiKey: string;
+    } | undefined;
+    keenableURL?: string;
+}): Tool;

package/dist/tools/write.d.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+export declare const writeTool: import("./types").Tool<z.ZodObject<{
+    path: z.ZodString;
+    content: z.ZodString;
+}, z.core.$strip>>;

package/dist/{transferCli-TK2GSVRK.js → transferCli-R2KEIWQR.js}

@@ -1,21 +1,23 @@
 #!/usr/bin/env node
 import {
   Session
-} from "./chunk-QDQU6VY2.js";
-import "./chunk-PUN4HMAG.js";
-import "./chunk-BLOYFIAD.js";
+} from "./chunk-SVD4LHJC.js";
+import "./chunk-5YJ3ZQVR.js";
+import "./chunk-KPTML72Q.js";
 import {
   t
-} from "./chunk-UZWJQF67.js";
+} from "./chunk-3WHI4LN3.js";
 
 // src/transferCli.ts
 import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "fs";
-import { dirname, join } from "path";
+import { dirname, join, resolve } from "path";
 function runExportCommand(args, deps) {
   const first = (args.subArgs[0] ?? "").trim();
   let source;
   let dest;
-  if (first && first.endsWith(".jsonl") && existsSync(first) && statSync(first).isFile()) {
+  const sessionsRoot = resolve(args.home, "sessions");
+  const isSourceSession = first.endsWith(".jsonl") && existsSync(first) && statSync(first).isFile() && (args.subArgs.length >= 2 || resolve(first).startsWith(sessionsRoot));
+  if (isSourceSession) {
     source = first;
     dest = args.subArgs[1];
   } else {

package/dist/transferCli.d.ts

@@ -0,0 +1,23 @@
+import { readdirSync } from 'node:fs';
+export interface TransferCliArgs {
+    subArgs: string[];
+    home: string;
+    cwd: string;
+}
+export interface TransferDeps {
+    out(line: string): void;
+    err?(line: string): void;
+}
+/**
+ * `bccli export [file]` — copy the latest session in this folder to `file`
+ * (or stdout when no file is given). Older sessions can be exported by
+ * passing their absolute JSONL path as the first argument.
+ */
+export declare function runExportCommand(args: TransferCliArgs, deps: TransferDeps): number;
+/**
+ * `bccli import <file>` — copy a session JSONL into the current project.
+ * Every line must parse as JSON before anything is written (atomic).
+ */
+export declare function runImportCommand(args: TransferCliArgs, deps: TransferDeps): number;
+/** Re-exported for tests that need the latest-session helper. */
+export { readdirSync };

package/dist/ui/App.d.ts

@@ -0,0 +1,7 @@
+import type { Runtime } from '../setup';
+export declare function App({ runtime, initialPrompt, version, updateMessage }: {
+    runtime: Runtime;
+    initialPrompt?: string;
+    version: string;
+    updateMessage?: string;
+}): import("react").JSX.Element;

package/dist/ui/DiffView.d.ts

@@ -0,0 +1,3 @@
+export declare function DiffView({ diff }: {
+    diff: string;
+}): import("react").JSX.Element;

package/dist/ui/EditableText.d.ts

@@ -0,0 +1,7 @@
+import { type LineState } from './lineEdit';
+/** A line of text with the cursor drawn where it is (the character under it, or a space at the end, in reverse video). */
+export declare function EditableText({ state, mask, showCursor }: {
+    state: LineState;
+    mask?: boolean;
+    showCursor?: boolean;
+}): import("react").JSX.Element;

package/dist/ui/LinePrompt.d.ts

@@ -0,0 +1,6 @@
+export declare function LinePrompt({ label, mask, onSubmit, onCancel }: {
+    label: string;
+    mask?: boolean;
+    onSubmit(value: string): void;
+    onCancel(): void;
+}): import("react").JSX.Element;

package/dist/ui/ListPicker.d.ts

@@ -0,0 +1,11 @@
+export interface ListItem {
+    id: string;
+    label: string;
+    hint?: string;
+    disabled?: boolean;
+}
+export declare function ListPicker({ title, items, onPick }: {
+    title: string;
+    items: ListItem[];
+    onPick(id?: string): void;
+}): import("react").JSX.Element;

package/dist/ui/Markdown.d.ts

@@ -0,0 +1,8 @@
+/**
+ * `indent` is how many columns the surrounding UI already uses (a bullet, a border), so tables and rules are
+ * sized to what is really left of the terminal width.
+ */
+export declare function Markdown({ text, indent }: {
+    text: string;
+    indent?: number;
+}): import("react").JSX.Element;

package/dist/ui/McpMenu.d.ts

@@ -0,0 +1,11 @@
+export interface McpMenuItem {
+    name: string;
+    description: string;
+    status: 'ready' | 'error' | 'starting' | 'off';
+    error?: string;
+    installed: boolean;
+}
+export declare function McpMenu({ items, onPick }: {
+    items: McpMenuItem[];
+    onPick(name: string | undefined): void;
+}): import("react").JSX.Element;

package/dist/ui/ModelPicker.d.ts

@@ -0,0 +1,6 @@
+import type { ModelGroup } from '../models';
+export declare function ModelPicker({ groups, current, onPick }: {
+    groups: ModelGroup[];
+    current: string;
+    onPick(ref?: string): void;
+}): import("react").JSX.Element;

package/dist/ui/PermissionPrompt.d.ts

@@ -0,0 +1,5 @@
+import type { PermissionAnswer, PermissionAsk } from '../agent';
+export declare function PermissionPrompt({ request, onAnswer, }: {
+    request: PermissionAsk;
+    onAnswer: (answer: PermissionAnswer) => void;
+}): import("react").JSX.Element;

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,6 @@
+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/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";