@botconnector/bccli 0.5.0-rc.4 → 0.5.1

package/dist/tools/bash.d.ts

@@ -0,0 +1,54 @@
+import { spawn } from 'node:child_process';
+import { z } from 'zod';
+import { type ShellDeps, type ShellSpec } from './shell';
+type Spawn = typeof spawn;
+/** Kill a command and everything it started. Never throws (e.g. taskkill missing on Windows). */
+export declare function killProcessTree(pid: number, platform?: NodeJS.Platform, spawnFn?: Spawn): void;
+export declare function killAllCommands(): void;
+/** Human-readable list for the /tasks slash command. */
+export declare function renderBackgroundTasks(): string;
+/** Test/exit helper: stop every background task and forget them. */
+export declare function resetBackgroundTasks(): void;
+export interface CommandResult {
+    output: string;
+    exitCode: number | null;
+    timedOut: boolean;
+    aborted: boolean;
+}
+export declare function needsNetwork(command: string): boolean;
+/** Proxy env pointing at a dead local port: tools that honour proxy vars fail fast offline. */
+export declare function offlineEnv(env?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+export declare function runCommand(command: string | string[], opts: {
+    cwd: string;
+    timeoutMs: number;
+    signal: AbortSignal;
+    env?: NodeJS.ProcessEnv;
+    shell?: ShellSpec;
+}): Promise<CommandResult>;
+export interface BashToolOptions {
+    /** "offline" blocks known network commands and points proxy env at a dead local port. */
+    networkPolicy?: 'allow' | 'offline';
+    /** Run every command inside the OS sandbox (sandbox-exec on macOS, bwrap on Linux). */
+    sandbox?: boolean;
+    /** Test hook: pretend to be another platform. */
+    platform?: NodeJS.Platform;
+    /** Test hook: fake environment / file lookup used to pick the Windows shell. */
+    shellDeps?: Partial<ShellDeps>;
+    /** How many finished background tasks are kept for polling (default 50). */
+    maxRetainedTasks?: number;
+}
+export declare function createBashTool(options?: BashToolOptions): import("./types").Tool<z.ZodObject<{
+    command: z.ZodOptional<z.ZodString>;
+    timeout_ms: z.ZodOptional<z.ZodNumber>;
+    background: z.ZodOptional<z.ZodBoolean>;
+    task_id: z.ZodOptional<z.ZodNumber>;
+    kill: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>>;
+export declare const bashTool: import("./types").Tool<z.ZodObject<{
+    command: z.ZodOptional<z.ZodString>;
+    timeout_ms: z.ZodOptional<z.ZodNumber>;
+    background: z.ZodOptional<z.ZodBoolean>;
+    task_id: z.ZodOptional<z.ZodNumber>;
+    kill: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>>;
+export {};

package/dist/tools/diagnostics.d.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { type LspServer } from '../lsp';
+export declare function createDiagnosticsTool(servers: LspServer[]): import("./types").Tool<z.ZodObject<{
+    path: z.ZodString;
+    action: z.ZodOptional<z.ZodEnum<{
+        definition: "definition";
+        diagnostics: "diagnostics";
+        hover: "hover";
+        references: "references";
+    }>>;
+    line: z.ZodOptional<z.ZodNumber>;
+    character: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>>;

package/dist/tools/edit.d.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+export declare const editTool: import("./types").Tool<z.ZodObject<{
+    path: z.ZodString;
+    old_string: z.ZodOptional<z.ZodString>;
+    new_string: z.ZodOptional<z.ZodString>;
+    replace_all: z.ZodOptional<z.ZodBoolean>;
+    edits: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        old_string: z.ZodString;
+        new_string: z.ZodString;
+        replace_all: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>>;

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,15 @@
+export declare function sandboxSupported(platform: NodeJS.Platform): boolean;
+/** Converts a Windows drive path (`C:\Users\foo`) into its WSL `/mnt/c/Users/foo` mount path. */
+export declare function winPathToWsl(winPath: string): string;
+/** 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;
+    wslBwrap?: 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-3B4LMOYI.js

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+import {
+  Session
+} from "./chunk-6LO6YRDY.js";
+import "./chunk-OCEQ2TRJ.js";
+import "./chunk-NGFWBVHD.js";
+import {
+  t
+} from "./chunk-IDZLHEVL.js";
+
+// src/transferCli.ts
+import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "fs";
+import { dirname, join, resolve } from "path";
+function runExportCommand(args, deps) {
+  const first = (args.subArgs[0] ?? "").trim();
+  let source;
+  let dest;
+  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 {
+    const latest = Session.latest(args.home, args.cwd);
+    if (!latest) {
+      deps.err?.(t("no session to export in this folder"));
+      return 1;
+    }
+    source = latest.file;
+    dest = first || void 0;
+  }
+  if (!dest) {
+    for (const line of readFileSync(source, "utf8").split("\n")) {
+      if (line.trim()) deps.out(line);
+    }
+    return 0;
+  }
+  mkdirSync(dirname(dest), { recursive: true });
+  copyFileSync(source, dest);
+  deps.out(t("exported {file}", { file: dest }));
+  return 0;
+}
+function runImportCommand(args, deps) {
+  const src = (args.subArgs[0] ?? "").trim();
+  if (!src || !existsSync(src)) {
+    deps.err?.(t("file not found: {file}", { file: src || "(none)" }));
+    return 1;
+  }
+  const raw = readFileSync(src, "utf8");
+  const lines = raw.split("\n").filter((l) => l.trim());
+  for (const line of lines) {
+    try {
+      JSON.parse(line);
+    } catch {
+      deps.err?.(t("invalid session file (non-JSON line): {file}", { file: src }));
+      return 1;
+    }
+  }
+  const slug = args.cwd.replace(/[^a-zA-Z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(-100) || "root";
+  const dir = join(args.home, "sessions", slug);
+  mkdirSync(dir, { recursive: true });
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const dest = join(dir, `${stamp}-imported.jsonl`);
+  writeFileSync(dest, lines.length ? `${lines.join("\n")}
+` : "");
+  deps.out(t("imported {n} record(s) into {file}", { n: String(lines.length), file: dest }));
+  return 0;
+}
+export {
+  readdirSync,
+  runExportCommand,
+  runImportCommand
+};

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,20 @@
+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;
+    /** Called when Tab is pressed on an empty prompt (e.g. to toggle Thinking without Ctrl+T). */
+    onEmptyTab?: () => void;
+}
+export declare function PromptInput({ disabled, history, cwd, onSubmit, extraCommands, injected, vim, onEmptyTab }: 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,14 @@
+import type { PermissionMode } from '../config';
+import type { ReasoningLevel } from '../reasoning';
+export declare function StatusBar({ mode, tokens, cached, estimated, busy, model, reasoning, }: {
+    mode: PermissionMode;
+    /** Prompt tokens of the last model call: the size of the context, not the session total. */
+    tokens: number;
+    /** Cache reads for the latest provider-reported model call. */
+    cached?: number;
+    /** Local chars/4 fallback rather than provider-reported usage. */
+    estimated?: boolean;
+    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;