@botconnector/bccli 0.5.0-rc.4 → 0.5.0

package/legacy/dist/prCli-FH7N26D4.js

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+import {
+  t
+} from "./chunk-IDZLHEVL.js";
+
+// src/prCli.ts
+import { spawn } from "child_process";
+function defaultGh(argv) {
+  return new Promise((resolve) => {
+    const child = spawn("gh", argv, { shell: false, stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (d) => {
+      stdout += d;
+    });
+    child.stderr?.on("data", (d) => {
+      stderr += d;
+    });
+    child.on("error", (e) => resolve({ code: 127, stdout, stderr: String(e) }));
+    child.on("close", (code) => resolve({ code: code ?? 1, stdout, stderr }));
+  });
+}
+function prTaskArgv(entry, opts) {
+  return [
+    entry,
+    ...opts.prompt ? ["-p", opts.prompt] : [],
+    ...opts.model ? ["-m", opts.model] : [],
+    ...opts.reasoning ? ["--reasoning", opts.reasoning] : [],
+    ...opts.permissionMode ? ["--permission-mode", opts.permissionMode] : [],
+    ...opts.allowedTools?.length ? ["--allowed-tools", opts.allowedTools.join(",")] : [],
+    ...opts.allowAll ? ["--allow-all"] : []
+  ];
+}
+async function defaultRunTask(opts) {
+  const entry = process.argv[1];
+  if (!entry) return 1;
+  return new Promise((resolve) => {
+    const child = spawn(process.execPath, prTaskArgv(entry, opts), {
+      shell: false,
+      stdio: "inherit",
+      cwd: opts.cwd
+    });
+    child.on("error", () => resolve(1));
+    child.on("close", (code) => resolve(code ?? 1));
+  });
+}
+async function runPrCommand(args, deps) {
+  const rest = [...args.subArgs];
+  let repo = args.repo;
+  const words = [];
+  for (let i = 0; i < rest.length; i++) {
+    if (rest[i] === "--repo") {
+      repo = rest[++i];
+      continue;
+    }
+    words.push(rest[i]);
+  }
+  const number = words.shift();
+  if (!number || !/^\d+$/.test(number)) {
+    deps.err?.(t("usage: bccli pr <number> [--repo owner/name] [task]"));
+    return 1;
+  }
+  const task = words.length ? words.join(" ") : void 0;
+  const gh = deps.gh ?? defaultGh;
+  const checkoutArgv = ["pr", "checkout", number, ...repo ? ["--repo", repo] : []];
+  let res;
+  try {
+    res = await gh(checkoutArgv);
+  } catch (e) {
+    deps.err?.(t("gh is not available ({error}); install GitHub CLI first", { error: String(e) }));
+    return 1;
+  }
+  if (res.code !== 0) {
+    deps.err?.(t("gh pr checkout {n} failed (exit {code})", { n: number, code: String(res.code) }));
+    return 1;
+  }
+  deps.out(t("checked out PR #{n}", { n: number }));
+  const runTask = deps.runTask ?? defaultRunTask;
+  const allowAll = args.allowAll === true;
+  if (allowAll) deps.err?.(t("--allow-all: the PR task runs every tool without asking"));
+  return runTask({
+    prompt: task,
+    allowAll,
+    cwd: args.cwd,
+    ...args.model ? { model: args.model } : {},
+    ...args.reasoning ? { reasoning: args.reasoning } : {},
+    ...args.permissionMode ? { permissionMode: args.permissionMode } : {},
+    ...args.allowedTools?.length ? { allowedTools: args.allowedTools } : {}
+  });
+}
+export {
+  prTaskArgv,
+  runPrCommand
+};

package/legacy/dist/prCli.d.ts

@@ -0,0 +1,46 @@
+export interface PrCliArgs {
+    subArgs: string[];
+    cwd: string;
+    /** Set only when the user asked for `bccli pr … --allow-all`. */
+    allowAll?: boolean;
+    repo?: string;
+    model?: string;
+    reasoning?: string;
+    permissionMode?: string;
+    allowedTools?: string[];
+}
+export interface PrDeps {
+    out(line: string): void;
+    err?(line: string): void;
+    /** gh argv runner (no shell). Defaults to `gh` on PATH. */
+    gh?(argv: string[]): Promise<{
+        code: number;
+        stdout: string;
+        stderr: string;
+    }>;
+    /** Run the agent task after checkout (injectable for tests). */
+    runTask?(opts: {
+        prompt?: string;
+        allowAll: boolean;
+        cwd: string;
+        model?: string;
+        reasoning?: string;
+        permissionMode?: string;
+        allowedTools?: string[];
+    }): Promise<number>;
+}
+/** argv for the child running the PR task; `--allow-all` only when the user asked for it. */
+export declare function prTaskArgv(entry: string, opts: {
+    prompt?: string;
+    allowAll?: boolean;
+    model?: string;
+    reasoning?: string;
+    permissionMode?: string;
+    allowedTools?: string[];
+}): string[];
+/**
+ * `bccli pr <number> [--repo owner/name] [task]` — check out a GitHub PR
+ * with `gh pr checkout`, then run an optional task on the checked-out branch.
+ * Read-only: never pushes, merges, or comments.
+ */
+export declare function runPrCommand(args: PrCliArgs, deps: PrDeps): Promise<number>;

package/legacy/dist/presets.d.ts

@@ -0,0 +1,8 @@
+export interface ProviderPreset {
+    id: string;
+    name: string;
+    baseURL: string;
+    apiKeyEnv?: string;
+    local?: boolean;
+}
+export declare const PRESETS: ProviderPreset[];

package/legacy/dist/print.d.ts

@@ -0,0 +1,17 @@
+import type { Runtime } from './setup';
+interface Writer {
+    write(s: string): unknown;
+}
+export declare function toolLabel(tool: string): string;
+export type OutputFormat = 'text' | 'json' | 'stream-json';
+/** Combines an optional piped stdin payload with the `-p` prompt argument. */
+export declare function resolvePrintPrompt(prompt: string | undefined, stdinText: string | undefined): string | undefined;
+export declare function runPrint(rt: Runtime, prompt: string, io?: {
+    out: Writer;
+    err: Writer;
+}, opts?: {
+    allowAll?: boolean;
+    outputFormat?: OutputFormat;
+    failOnToolError?: boolean;
+}): Promise<number>;
+export {};

package/legacy/dist/provider.d.ts

@@ -0,0 +1,145 @@
+import OpenAI from 'openai';
+import { ResponsesWS } from 'openai/resources/responses/ws';
+import type { ResponseOutputItem } from 'openai/resources/responses/responses';
+import { type ReasoningLevel } from './reasoning';
+import type { ToolDefinition } from './tools/index';
+import type { ImageAttachment } from './tools/types';
+export interface ResponsesProgramCaller {
+    type: 'program';
+    caller_id: string;
+}
+export interface ToolCall {
+    id: string;
+    name: string;
+    arguments: string;
+    caller?: ResponsesProgramCaller;
+}
+export type ContentPart = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'image_url';
+    image_url: {
+        url: string;
+    };
+};
+export type ChatMessage = {
+    role: 'system';
+    content: string;
+} | {
+    role: 'user';
+    content: string | ContentPart[];
+} | {
+    role: 'assistant';
+    content: string | null;
+    tool_calls?: {
+        id: string;
+        type: 'function';
+        function: {
+            name: string;
+            arguments: string;
+        };
+        caller?: ResponsesProgramCaller;
+    }[];
+    /** Exact OpenAI Responses output items for stateless Luna replay/reconnect. Hidden from normal UI/export. */
+    responses_output_items?: ResponseOutputItem[];
+} | {
+    role: 'tool';
+    tool_call_id: string;
+    content: string;
+    /** Program caller linkage must be round-tripped for PTC continuation. */
+    responses_caller?: ResponsesProgramCaller;
+};
+export interface Usage {
+    inputTokens: number;
+    outputTokens: number;
+    cachedInputTokens?: number;
+    cacheWriteTokens?: number;
+}
+export interface Completion {
+    text: string;
+    toolCalls: ToolCall[];
+    /** Exact OpenAI Responses output items, preserved for store:false replay. */
+    responsesOutputItems?: ResponseOutputItem[];
+    /** The model's reasoning, when it sends any (reasoning_content or <think> blocks); not part of the history. */
+    thinking?: string;
+    usage?: Usage;
+    finishReason?: string;
+}
+export interface ChatRequest {
+    messages: ChatMessage[];
+    tools?: ToolDefinition[];
+    /** Local-only allowlist for read-only PTC-safe tools; never serialized to Chat Completions. */
+    programmaticToolNames?: string[];
+    signal?: AbortSignal;
+    onText?: (delta: string) => void;
+    onThinking?: (delta: string) => void;
+    reasoning?: ReasoningLevel;
+}
+export interface Provider {
+    chat(req: ChatRequest): Promise<Completion>;
+    listModels(): Promise<string[]>;
+}
+export declare class ProviderError extends Error {
+    readonly status?: number | undefined;
+    readonly code?: string | undefined;
+    constructor(message: string, status?: number | undefined, code?: string | undefined);
+}
+interface ProviderOptions {
+    baseURL: string;
+    apiKey?: string;
+    model: string;
+    providerId?: string;
+    fetch?: typeof fetch;
+    retryDelayMs?: number;
+    responsesWebSocketFactory?: (client: OpenAI) => ResponsesWS;
+    /** Experimental Luna-only PTC canary. Kept opt-in until replay/cost canaries pass. */
+    enableProgrammaticToolCalling?: boolean;
+}
+/**
+ * Small models sometimes get stuck emitting the same few characters forever.
+ * Returns where the loop starts when the tail is one short unit (1-12 chars, not just
+ * whitespace) repeated at least 20 times over 300+ chars; otherwise -1. Normal markdown
+ * rules like 80 "=" stay under the length threshold.
+ */
+export declare function detectRepetition(text: string): number;
+/** Plain-text rendering of message content for previews, exports, and the chat UI. */
+export declare function contentText(content: string | ContentPart[]): string;
+/** The user message that carries read images to a vision-capable model. */
+export declare function imageUserMessage(images: ImageAttachment[]): ChatMessage;
+export declare function responseInputFromMessages(messages: ChatMessage[]): Record<string, unknown>[];
+export declare function shouldForceLunaPtc(messages: ChatMessage[], enabled: boolean): boolean;
+/**
+ * Cost-aware PTC gate for Luna.
+ * Beta.24 proved PTC is excellent for large read-heavy aggregation but expensive for one tiny read.
+ * Keep PTC available only when the current turn has multi-source/data-reduction intent, a large
+ * read-only intermediate result, or an already-started program that must be continued safely.
+ */
+export declare function shouldEnableLunaPtc(messages: ChatMessage[], enabled: boolean, programmaticToolNames?: string[]): boolean;
+export interface LunaToolPlan {
+    tools: Record<string, unknown>[];
+    useToolSearch: boolean;
+    useProgrammaticToolCalling: boolean;
+    deferredToolCount: number;
+    deferredSchemaChars: number;
+}
+export declare function lunaToolPlan(tools?: ToolDefinition[], enableProgrammaticToolCalling?: boolean, programmaticToolNames?: string[], forceProgrammaticOnly?: boolean): LunaToolPlan;
+export declare function hasPendingProgrammaticReplay(messages: ChatMessage[]): boolean;
+interface LunaWsContinuation {
+    responseId: string;
+    requestMessages: ChatMessage[];
+    completion: Completion;
+}
+export declare function completionAssistantMessage(completion: Completion): ChatMessage;
+export declare function responseContinuationInput(messages: ChatMessage[], continuation?: LunaWsContinuation): {
+    input: Record<string, unknown>[];
+    previousResponseId?: string;
+    incremental: boolean;
+};
+export declare function createProvider(options: ProviderOptions): Provider;
+/**
+ * Wraps a primary provider with automatic fallback providers tried in order when the primary
+ * fails before emitting any text (e.g. HTTP 429 rate-limit/quota, 5xx, or connection failure).
+ */
+export declare function withFallbackProvider(primary: Provider, fallbacks: () => Provider[]): Provider;
+export {};

package/legacy/dist/providerCli-YMG4G56R.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+import {
+  addProviderKey,
+  runProviderCommand
+} from "./chunk-RLSQAZBT.js";
+import "./chunk-2IP5F3EK.js";
+import "./chunk-FY543EQW.js";
+import "./chunk-OCEQ2TRJ.js";
+import "./chunk-NGFWBVHD.js";
+import "./chunk-ZXWRLN7E.js";
+import "./chunk-IDZLHEVL.js";
+export {
+  addProviderKey,
+  runProviderCommand
+};

package/legacy/dist/providerCli.d.ts

@@ -0,0 +1,17 @@
+import type { CliArgs } from './args';
+export interface CliDeps {
+    env: NodeJS.ProcessEnv;
+    cwd: string;
+    out: (s: string) => void;
+    err: (s: string) => void;
+    readSecret: (prompt: string) => Promise<string>;
+    fetch?: typeof fetch;
+}
+export declare function addProviderKey(providerId: string, key: string, deps: CliDeps): Promise<{
+    ok: true;
+    models: number;
+} | {
+    ok: false;
+    error: string;
+}>;
+export declare function runProviderCommand(args: CliArgs, deps: CliDeps): Promise<number>;

package/legacy/dist/providers.d.ts

@@ -0,0 +1,6 @@
+import { type Config } from './config';
+export declare function providerName(config: Config, id: string): string;
+export declare function hasKey(config: Config, id: string, env?: NodeJS.ProcessEnv): boolean;
+export declare function readGlobalConfigFile(env?: NodeJS.ProcessEnv): Partial<Config>;
+export declare function writeGlobalConfig(patch: Partial<Config>, env?: NodeJS.ProcessEnv): void;
+export declare function removeGlobalProvider(id: string, env?: NodeJS.ProcessEnv): void;

package/legacy/dist/reasoning.d.ts

@@ -0,0 +1,12 @@
+export declare const REASONING_LEVELS: readonly ['auto', 'off', 'low', 'medium', 'high', 'max'];
+export type ReasoningLevel = (typeof REASONING_LEVELS)[number];
+export interface ReasoningCapability {
+    levels: readonly ReasoningLevel[];
+    parameter: 'reasoning_effort' | 'reasoning';
+}
+export declare function isReasoningLevel(value: string): value is ReasoningLevel;
+export declare function parseReasoningLevel(value: string, label?: string): ReasoningLevel;
+export declare function reasoningCapability(providerId?: string): ReasoningCapability | undefined;
+export declare function supportedReasoningLevels(providerId?: string): readonly ReasoningLevel[];
+export declare function assertReasoningSupported(providerId: string | undefined, level: ReasoningLevel): void;
+export declare function reasoningPayload(providerId: string | undefined, level: ReasoningLevel): Record<string, unknown>;

package/legacy/dist/repomap.d.ts

@@ -0,0 +1,10 @@
+/** Top-level function/class/type names of one file, capped, in source order. */
+export declare function extractSymbols(text: string, ext: string): string[];
+/**
+ * Aider-style repo map: every code file (node_modules/.git excluded) with its top-level
+ * symbols, shallowest paths first, cut off at a token budget. Synchronous on purpose —
+ * it is computed once at boot for the system prompt.
+ */
+export declare function buildRepoMapSync(cwd: string, opts?: {
+    maxTokens?: number;
+}): string;

package/legacy/dist/sdk.d.ts

@@ -0,0 +1,61 @@
+import type { Provider } from './provider';
+/**
+ * Programmatic API: run one bccli task in-process. Permissions are allowAll — the caller
+ * is the supervisor. MCP servers are not started; tools are the built-ins + global plugins.
+ */
+export interface SdkOptions {
+    prompt: string;
+    cwd?: string;
+    /** provider/model ref, e.g. "bc-cloud/glm-5.3-flash" (default: the config model). */
+    model?: string;
+    provider?: Provider;
+    env?: NodeJS.ProcessEnv;
+    fetch?: typeof fetch;
+    signal?: AbortSignal;
+}
+export interface SdkToolCall {
+    name: string;
+    target: string;
+    output?: string;
+    isError?: boolean;
+}
+export interface SdkResult {
+    text: string;
+    toolCalls: SdkToolCall[];
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+    };
+    stopReason: 'done' | 'stepLimit' | 'aborted' | 'budgetExceeded' | 'error';
+    error?: string;
+}
+export type SdkEvent = {
+    type: 'text';
+    delta: string;
+} | {
+    type: 'thinking';
+    delta: string;
+} | {
+    type: 'toolStart';
+    name: string;
+    target: string;
+} | {
+    type: 'toolEnd';
+    name: string;
+    target: string;
+    output: string;
+    isError?: boolean;
+} | {
+    type: 'usage';
+    inputTokens: number;
+    outputTokens: number;
+} | {
+    type: 'error';
+    message: string;
+} | {
+    type: 'result';
+    result: SdkResult;
+};
+export declare function streamTask(opts: SdkOptions): AsyncGenerator<SdkEvent>;
+/** One-shot helper: runs the task and returns only the final result. */
+export declare function runTask(opts: SdkOptions): Promise<SdkResult>;