@botconnector/bccli 0.4.0-beta.9 → 0.4.1

package/dist/statsCli.d.ts

@@ -0,0 +1,62 @@
+export interface StatsRow {
+    project: string;
+    sessions: number;
+    messages: number;
+    /** Estimated tokens (messages without recorded usage only). */
+    inputTokens: number;
+    outputTokens: number;
+    /** Tokens from persisted `t:usage` records. */
+    usageInputTokens: number;
+    usageOutputTokens: number;
+    cachedInputTokens: number;
+    cacheWriteTokens: number;
+    toolCalls: Record<string, number>;
+    /** Total tokens per session (recorded basis when present, estimate otherwise). */
+    sessionTotals: number[];
+    /** Per-model token totals from `t:usage` records that carry a model ref. */
+    modelUsage: Record<string, ModelTotals>;
+}
+export interface ModelTotals {
+    turns: number;
+    inputTokens: number;
+    outputTokens: number;
+    cachedInputTokens: number;
+    cacheWriteTokens: number;
+}
+export interface AggregateOptions {
+    days: number;
+    now?: number;
+}
+/**
+ * Walk home/sessions/<project>/*.jsonl, keep files with mtime within `days`,
+ * and aggregate per project. Token basis switches per session: sessions with
+ * recorded usage records use them (incl. cache counters); older sessions fall
+ * back to ~4 chars/token estimates from message content.
+ */
+export declare function aggregateSessions(home: string, opts: AggregateOptions): StatsRow[];
+/** Compact token formatting like the opencode stats boxes: 291.6K / 41.0M / 627.4M. */
+export declare function fmtCompact(n: number): string;
+export interface StatsCliArgs {
+    subArgs: string[];
+    home: string;
+    cwd?: string;
+    now?: number;
+    /** Already-parsed `--days` from parseCliArgs (subArgs never contains it). */
+    days?: number;
+    /** Already-parsed `--tools` top-N cap. */
+    tools?: number;
+    /** Already-parsed `--models` ("all" or a number as string). */
+    models?: string;
+    /** Already-parsed `--project` filter (empty string = current project). */
+    project?: string;
+}
+export interface StatsDeps {
+    out(line: string): void;
+    err?(line: string): void;
+}
+/**
+ * `bccli stats [--days N] [--tools N] [--models [N|all]] [--project slug]` —
+ * token usage and tool-call stats from local session files, rendered as
+ * opencode-style overview/tokens/model/tool boxes.
+ */
+export declare function runStatsCommand(args: StatsCliArgs, deps: StatsDeps): number;

package/dist/textToolCalls.d.ts

@@ -0,0 +1,6 @@
+import type { ToolCall } from './provider';
+import type { ToolDefinition } from './tools/index';
+export declare function recoverTextToolCalls(text: string, tools: ToolDefinition[]): {
+    text: string;
+    toolCalls: ToolCall[];
+} | null;

package/dist/thinking.d.ts

@@ -0,0 +1,17 @@
+export declare class ThinkSplitter {
+    private inside;
+    private held;
+    push(delta: string): {
+        text: string;
+        thinking: string;
+    };
+    /** Whatever was held back as a possible tag start is plain text after all. */
+    flush(): {
+        text: string;
+        thinking: string;
+    };
+}
+export declare function splitThinking(text: string): {
+    text: string;
+    thinking: string;
+};

package/dist/tokenBudget.d.ts

@@ -0,0 +1,22 @@
+import type { ChatMessage } from './provider';
+/** ~4 chars per token, the same conservative estimate the usage fallback uses. */
+export declare const estimateTokens: (text: string) => number;
+export declare const estimateMessages: (messages: ChatMessage[]) => number;
+/**
+ * Drops whole oldest turns (everything up to the next user message) until the history fits the
+ * budget. Cutting only at turn boundaries keeps assistant tool_calls paired with their tool
+ * replies, so the trimmed history is always valid for a provider request.
+ */
+export declare function trimToFit(messages: ChatMessage[], maxTokens: number): ChatMessage[];
+/**
+ * Splits history into [old, keep]: the newest whole turns that fit `keepTokens` (at least the
+ * last user turn) stay verbatim; everything older goes to `old` for summarization. Cutting at
+ * user boundaries keeps tool_calls paired with their replies.
+ */
+export declare function splitKeepRecent(messages: ChatMessage[], keepTokens: number): [ChatMessage[], ChatMessage[]];
+export declare const isToolStub: (content: string) => boolean;
+/**
+ * Replaces old tool results with a one-line stub once they add up past PRUNE_MIN_TOKENS, so the
+ * prompt prefix (and its cache) changes rarely. The newest KEEP_TOKENS worth stay intact.
+ */
+export declare function pruneOldToolOutputs(messages: ChatMessage[]): boolean;

package/dist/tools/bash.d.ts

@@ -0,0 +1,52 @@
+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>;
+}
+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,5 @@
+import { z } from 'zod';
+import { type LspServer } from '../lsp';
+export declare function createDiagnosticsTool(servers: LspServer[]): import("./types").Tool<z.ZodObject<{
+    path: z.ZodString;
+}, z.core.$strip>>;

package/dist/tools/edit.d.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+export declare const editTool: import("./types").Tool<z.ZodObject<{
+    path: z.ZodString;
+    old_string: z.ZodString;
+    new_string: z.ZodString;
+    replace_all: z.ZodOptional<z.ZodBoolean>;
+}, 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,13 @@
+import { z } from 'zod';
+export declare function grepJs(pattern: string, opts: {
+    root: string;
+    glob?: string;
+    ignoreCase?: boolean;
+    signal?: AbortSignal;
+}): 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>;
+}, z.core.$strip>>;

package/dist/tools/ignore.d.ts

@@ -0,0 +1,2 @@
+/** Native glob exclude patterns: node_modules, .git, and simple root .gitignore entries. */
+export declare function ignorePatterns(root: 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,2 @@
+export declare function resolvePath(cwd: string, path: string): string;
+export declare function errorCode(error: unknown): string;

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-YUFPI6AH.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+import {
+  Session
+} from "./chunk-BC7UXFE4.js";
+import "./chunk-WNACAUDK.js";
+import "./chunk-BLOYFIAD.js";
+import {
+  t
+} from "./chunk-UZWJQF67.js";
+
+// src/transferCli.ts
+import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+function runExportCommand(args, deps) {
+  const first = (args.subArgs[0] ?? "").trim();
+  let source;
+  let dest;
+  if (first.endsWith(".jsonl") && existsSync(first) && statSync(first).isFile()) {
+    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;