@botconnector/bccli 0.4.0-beta.4 → 0.4.0-beta.40

package/dist/chunk-M7LLJQ7M.js

@@ -0,0 +1,310 @@
+#!/usr/bin/env node
+import {
+  t
+} from "./chunk-M23QBX3V.js";
+
+// src/presets.ts
+var PRESETS = [
+  { id: "bc-cloud", name: "BotConnector Cloud", baseURL: "https://api.botconnector.id/v1", apiKeyEnv: "BOTCONNECTOR_API_KEY" },
+  { id: "openrouter", name: "OpenRouter", baseURL: "https://openrouter.ai/api/v1", apiKeyEnv: "OPENROUTER_API_KEY" },
+  { id: "openai", name: "OpenAI", baseURL: "https://api.openai.com/v1", apiKeyEnv: "OPENAI_API_KEY" },
+  { id: "gemini", name: "Google Gemini", baseURL: "https://generativelanguage.googleapis.com/v1beta/openai", apiKeyEnv: "GEMINI_API_KEY" },
+  { id: "deepseek", name: "DeepSeek", baseURL: "https://api.deepseek.com/v1", apiKeyEnv: "DEEPSEEK_API_KEY" },
+  { id: "groq", name: "Groq", baseURL: "https://api.groq.com/openai/v1", apiKeyEnv: "GROQ_API_KEY" },
+  { id: "ollama-cloud", name: "Ollama Cloud", baseURL: "https://ollama.com/v1", apiKeyEnv: "OLLAMA_API_KEY" },
+  { id: "ollama", name: "Ollama lokal", baseURL: "http://127.0.0.1:11434/v1", local: true },
+  { id: "lmstudio", name: "LM Studio lokal", baseURL: "http://127.0.0.1:1234/v1", local: true }
+];
+
+// src/ui/theme.ts
+var THEMES = ["default", "blue", "amber", "magenta", "mono"];
+var REMAP = {
+  blue: { green: "blue" },
+  amber: { green: "yellow" },
+  magenta: { green: "magenta" }
+};
+var theme = "default";
+function setTheme(name) {
+  theme = name;
+}
+function color(name) {
+  if (process.env.NO_COLOR) return void 0;
+  if (theme === "mono") return void 0;
+  return REMAP[theme]?.[name] ?? name;
+}
+var ACCENT = "green";
+
+// src/config.ts
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+// src/keybinds.ts
+var KEYBIND_ACTIONS = ["thinking", "toolOutput", "pasteImage"];
+var DEFAULT_KEYBINDS = {
+  thinking: "ctrl+t",
+  toolOutput: "ctrl+o",
+  pasteImage: "alt+v"
+};
+function defaultKeybinds() {
+  return Object.fromEntries(KEYBIND_ACTIONS.map((action) => [action, parseKeybind(DEFAULT_KEYBINDS[action])]));
+}
+function parseKeybind(raw) {
+  const spec = raw.trim().toLowerCase();
+  const parts = spec.split("+");
+  const key = parts.pop() ?? "";
+  if (!/^[a-z]$/.test(key)) return void 0;
+  if (!parts.length || new Set(parts).size !== parts.length) return void 0;
+  if (parts.some((p) => p !== "ctrl" && p !== "alt")) return void 0;
+  return { spec, ctrl: parts.includes("ctrl"), meta: parts.includes("alt"), key };
+}
+function matchKeybind(kb, input, key) {
+  return kb.ctrl === !!key.ctrl && kb.meta === !!key.meta && input.toLowerCase() === kb.key;
+}
+
+// src/config.ts
+var ConfigError = class extends Error {
+};
+var DEFAULT_MAX_STEPS = 100;
+var DEFAULT_CONFIG = {
+  model: "bc-cloud/glm-5.3-flash",
+  permissionMode: "default",
+  reasoning: "auto",
+  vision: true,
+  networkPolicy: "allow",
+  keybinds: defaultKeybinds(),
+  verifyCommands: [],
+  repoMap: false,
+  theme: "default",
+  editor: "emacs",
+  sandbox: "off",
+  providers: Object.fromEntries(PRESETS.map((p) => [p.id, { baseURL: p.baseURL, apiKeyEnv: p.apiKeyEnv }])),
+  allow: []
+};
+function bccliHome(env = process.env) {
+  return env.BCCLI_HOME ?? join(homedir(), ".bccli");
+}
+function readJsonConfig(path) {
+  if (!existsSync(path)) return {};
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch (error) {
+    throw new ConfigError(t("Invalid config: {path} ({error})", { path, error: error.message }));
+  }
+}
+function resolvedMaxSteps(global) {
+  const value = global.maxSteps;
+  if (value === void 0) return DEFAULT_MAX_STEPS;
+  if (value === null || value === 0) return null;
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    throw new ConfigError(t("maxSteps must be a positive number, or 0/null to disable the limit."));
+  }
+  return Math.max(1, Math.floor(value));
+}
+function resolvedNetworkPolicy(global) {
+  const value = global.networkPolicy ?? "allow";
+  if (value !== "allow" && value !== "offline") {
+    throw new ConfigError(t('networkPolicy must be "allow" or "offline".'));
+  }
+  return value;
+}
+function resolvedPlugins(global) {
+  const value = global.plugins;
+  if (value === void 0) return [];
+  if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string")) {
+    throw new ConfigError(t("plugins must be an array of strings."));
+  }
+  return [...value];
+}
+function resolvedUpdateCheck(global) {
+  const value = global.updateCheck;
+  if (value === void 0) return void 0;
+  if (value !== "on" && value !== "off") throw new ConfigError(t('updateCheck must be "on" or "off".'));
+  return value;
+}
+function resolvedUsageCap(global) {
+  const cap = global.usageCap;
+  if (cap === void 0) return void 0;
+  if (typeof cap !== "object" || cap === null || Array.isArray(cap)) {
+    throw new ConfigError(t('usageCap must be an object, e.g. { "tokens": 2000000 }.'));
+  }
+  const { tokens, usd, prices } = cap;
+  const positive = (v) => typeof v === "number" && Number.isFinite(v) && v > 0;
+  const nonNegative = (v) => typeof v === "number" && Number.isFinite(v) && v >= 0;
+  if (tokens !== void 0 && !positive(tokens)) throw new ConfigError(t("usageCap.tokens must be a number greater than 0."));
+  if (usd !== void 0 && !positive(usd)) throw new ConfigError(t("usageCap.usd must be a number greater than 0."));
+  if (usd !== void 0 && (prices === void 0 || !Object.keys(prices).length)) {
+    throw new ConfigError(t("usageCap.usd requires usageCap.prices (USD per 1M tokens)."));
+  }
+  if (prices !== void 0) {
+    for (const [key, price] of Object.entries(prices)) {
+      if (!price || !nonNegative(price.input) || !nonNegative(price.output)) {
+        throw new ConfigError(t('usageCap.prices["{key}"] must have numeric input and output (USD per 1M tokens).', { key }));
+      }
+    }
+  }
+  if (tokens === void 0 && usd === void 0) throw new ConfigError(t("usageCap needs at least one of: tokens, usd."));
+  return { ...tokens !== void 0 ? { tokens } : {}, ...usd !== void 0 ? { usd } : {}, ...prices !== void 0 ? { prices } : {} };
+}
+function resolvedLsp(global) {
+  if (global.lsp === void 0) return void 0;
+  const lsp = global.lsp;
+  if (typeof global.lsp !== "object" || global.lsp === null || !Array.isArray(lsp.servers)) {
+    throw new ConfigError(t('lsp must be an object with a "servers" array.'));
+  }
+  for (const s of lsp.servers) {
+    const server = s;
+    if (typeof server?.command !== "string" || !server.command || !Array.isArray(server.extensions) || server.extensions.length === 0 || server.extensions.some((e) => typeof e !== "string" || !e.startsWith(".")) || server.args !== void 0 && (!Array.isArray(server.args) || server.args.some((a) => typeof a !== "string"))) {
+      throw new ConfigError(t('Each lsp server needs { "extensions": [".ts"], "command": "...", "args": ["..."] }.'));
+    }
+  }
+  return { servers: lsp.servers };
+}
+function resolvedSandbox(global) {
+  const value = global.sandbox ?? "off";
+  if (value !== "off" && value !== "on") throw new ConfigError(t('sandbox must be "off" or "on".'));
+  return value;
+}
+function resolvedEditor(global) {
+  const value = global.editor ?? "emacs";
+  if (value !== "emacs" && value !== "vim") throw new ConfigError(t('editor must be "emacs" or "vim".'));
+  return value;
+}
+function resolvedTheme(global) {
+  const value = global.theme ?? "default";
+  if (typeof value !== "string" || !THEMES.includes(value)) {
+    throw new ConfigError(t("theme must be one of: {themes}.", { themes: THEMES.join(", ") }));
+  }
+  return value;
+}
+function resolvedRepoMap(global) {
+  const value = global.repoMap ?? false;
+  if (typeof value !== "boolean") throw new ConfigError(t("repoMap must be true or false."));
+  return value;
+}
+function resolvedVerifyCommands(global) {
+  const value = global.verifyCommands;
+  if (value === void 0) return [];
+  if (!Array.isArray(value) || value.some((c) => typeof c !== "string" || !c.trim())) {
+    throw new ConfigError(t("verifyCommands must be an array of non-empty strings."));
+  }
+  return value.map((c) => c.trim());
+}
+function resolvedKeybinds(global) {
+  const raw = global.keybinds ?? {};
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    throw new ConfigError(t("keybinds must be an object mapping action to binding."));
+  }
+  const out = {};
+  for (const action of KEYBIND_ACTIONS) {
+    const spec = raw[action];
+    const value = spec === void 0 ? DEFAULT_KEYBINDS[action] : spec;
+    if (typeof value !== "string") {
+      throw new ConfigError(t('Keybind for "{action}" must be a string like "ctrl+t".', { action }));
+    }
+    const parsed = parseKeybind(value);
+    if (!parsed) {
+      throw new ConfigError(t('Keybind "{spec}" for "{action}" is invalid: use ctrl or alt plus one letter, e.g. "ctrl+t".', { spec: value, action }));
+    }
+    out[action] = parsed;
+  }
+  for (const key of Object.keys(raw)) {
+    if (!KEYBIND_ACTIONS.includes(key)) {
+      throw new ConfigError(t('Unknown keybind action "{action}". Known actions: {list}.', { action: key, list: KEYBIND_ACTIONS.join(", ") }));
+    }
+  }
+  return out;
+}
+function untrustedProviders(project, known) {
+  const out = {};
+  for (const [id, provider] of Object.entries(project.providers ?? {})) {
+    if (known[id] || typeof provider?.baseURL !== "string") continue;
+    out[id] = { baseURL: provider.baseURL };
+  }
+  return out;
+}
+function loadConfig(cwd, env = process.env) {
+  const global = readJsonConfig(join(bccliHome(env), "config.json"));
+  const project = readJsonConfig(join(cwd, ".bccli", "config.json"));
+  const known = { ...DEFAULT_CONFIG.providers, ...global.providers };
+  const fromProject = untrustedProviders(project, known);
+  return {
+    model: project.model ?? global.model ?? DEFAULT_CONFIG.model,
+    permissionMode: global.permissionMode ?? DEFAULT_CONFIG.permissionMode,
+    reasoning: global.reasoning ?? DEFAULT_CONFIG.reasoning,
+    maxSteps: resolvedMaxSteps(global),
+    hooks: global.hooks,
+    vision: global.vision ?? DEFAULT_CONFIG.vision,
+    networkPolicy: resolvedNetworkPolicy(global),
+    plugins: resolvedPlugins(global),
+    keybinds: resolvedKeybinds(global),
+    verifyCommands: resolvedVerifyCommands(global),
+    repoMap: resolvedRepoMap(global),
+    theme: resolvedTheme(global),
+    editor: resolvedEditor(global),
+    sandbox: resolvedSandbox(global),
+    lsp: resolvedLsp(global),
+    usageCap: resolvedUsageCap(global),
+    updateCheck: resolvedUpdateCheck(global),
+    providers: { ...known, ...fromProject },
+    projectProviders: Object.keys(fromProject),
+    allow: [...global.allow ?? []]
+  };
+}
+function readCredentials(env = process.env) {
+  const path = join(bccliHome(env), "credentials");
+  if (!existsSync(path)) return {};
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function saveCredential(providerId, key, env = process.env) {
+  const home = bccliHome(env);
+  mkdirSync(home, { recursive: true });
+  const path = join(home, "credentials");
+  writeFileSync(path, JSON.stringify({ ...readCredentials(env), [providerId]: key }, null, 2), { mode: 384 });
+  chmodSync(path, 384);
+}
+function resolveModel(config, modelRef, env = process.env) {
+  const slash = modelRef.indexOf("/");
+  if (slash <= 0 || slash === modelRef.length - 1) {
+    throw new ConfigError(t("Model must be in provider/model format, e.g. bc-cloud/glm-5.3-flash (got: {ref})", { ref: modelRef }));
+  }
+  const providerId = modelRef.slice(0, slash);
+  const provider = config.providers[providerId];
+  if (!provider) {
+    throw new ConfigError(t('Provider "{id}" is not in the config. Available: {list}', { id: providerId, list: Object.keys(config.providers).join(", ") }));
+  }
+  const apiKey = (provider.apiKeyEnv ? env[provider.apiKeyEnv] : void 0) || readCredentials(env)[providerId] || void 0;
+  if (provider.apiKeyEnv && !apiKey) {
+    throw new ConfigError(t("No API key for {id} yet. Run `bccli login` or set the env var {env}.", { id: providerId, env: provider.apiKeyEnv }));
+  }
+  return { providerId, model: modelRef.slice(slash + 1), baseURL: provider.baseURL.replace(/\/+$/, ""), apiKey };
+}
+function removeCredential(providerId, env = process.env) {
+  const creds = readCredentials(env);
+  if (!(providerId in creds)) return false;
+  delete creds[providerId];
+  const path = join(bccliHome(env), "credentials");
+  writeFileSync(path, JSON.stringify(creds, null, 2), { mode: 384 });
+  chmodSync(path, 384);
+  return true;
+}
+
+export {
+  PRESETS,
+  matchKeybind,
+  setTheme,
+  color,
+  ACCENT,
+  ConfigError,
+  bccliHome,
+  readJsonConfig,
+  loadConfig,
+  readCredentials,
+  saveCredential,
+  resolveModel,
+  removeCredential
+};

package/dist/chunk-NI5JZUZ3.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+import {
+  t
+} from "./chunk-M23QBX3V.js";
+
+// src/reasoning.ts
+var REASONING_LEVELS = ["auto", "off", "low", "medium", "high", "max"];
+var OPENAI_LEVELS = ["auto", "low", "medium", "high"];
+var BOTCONNECTOR_LEVELS = REASONING_LEVELS;
+function isReasoningLevel(value) {
+  return REASONING_LEVELS.includes(value);
+}
+function parseReasoningLevel(value, label = "reasoning") {
+  if (!isReasoningLevel(value)) {
+    throw new Error(t("{label} must be one of: {levels}", { label, levels: REASONING_LEVELS.join(", ") }));
+  }
+  return value;
+}
+function reasoningCapability(providerId) {
+  switch (providerId) {
+    case "bc-cloud":
+      return { levels: BOTCONNECTOR_LEVELS, parameter: "reasoning_effort" };
+    case "openai":
+      return { levels: OPENAI_LEVELS, parameter: "reasoning_effort" };
+    case "openrouter":
+      return { levels: ["auto", "low", "medium", "high"], parameter: "reasoning" };
+    default:
+      return void 0;
+  }
+}
+function supportedReasoningLevels(providerId) {
+  return reasoningCapability(providerId)?.levels ?? ["auto"];
+}
+function assertReasoningSupported(providerId, level) {
+  if (level === "auto") return;
+  const capability = reasoningCapability(providerId);
+  if (!capability) {
+    throw new Error(t("This provider has no manual reasoning setting yet. Use Auto."));
+  }
+  if (!capability.levels.includes(level)) {
+    const supported = capability.levels.filter((x) => x !== "auto").map(capitalize).join("/");
+    throw new Error(t("This model/provider does not support reasoning level '{level}'. Use Auto{supported}.", { level, supported: supported ? `/${supported}` : "" }));
+  }
+}
+function reasoningPayload(providerId, level) {
+  if (level === "auto") return {};
+  assertReasoningSupported(providerId, level);
+  const capability = reasoningCapability(providerId);
+  if (capability.parameter === "reasoning") return { reasoning: { effort: level } };
+  return { reasoning_effort: level };
+}
+function capitalize(value) {
+  return value.charAt(0).toUpperCase() + value.slice(1);
+}
+
+export {
+  REASONING_LEVELS,
+  isReasoningLevel,
+  parseReasoningLevel,
+  supportedReasoningLevels,
+  assertReasoningSupported,
+  reasoningPayload
+};

package/dist/chunk-PDVS4UWM.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+// src/version.ts
+var VERSION = true ? "0.4.0-beta.40" : "0.0.0-dev";
+
+export {
+  VERSION
+};

package/dist/chunk-PSO7R5AD.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+
+// src/tools/types.ts
+function defineTool(tool) {
+  return tool;
+}
+
+export {
+  defineTool
+};

package/dist/chunk-RV74TCEP.js

@@ -0,0 +1,231 @@
+#!/usr/bin/env node
+import {
+  runCommand,
+  runHooks
+} from "./chunk-ZMU7MXCH.js";
+import {
+  ConfigError
+} from "./chunk-M7LLJQ7M.js";
+import {
+  t
+} from "./chunk-M23QBX3V.js";
+
+// src/verify.ts
+var MAX_VERIFY_ROUNDS = 2;
+async function runVerify(commands, opts) {
+  const run = opts.run ?? runCommand;
+  const failures = [];
+  for (const cmd of commands) {
+    const r = await run(cmd, { cwd: opts.cwd, timeoutMs: opts.timeoutMs ?? 3e5, signal: opts.signal, env: opts.env });
+    const exitCode = r.exitCode ?? -1;
+    if (exitCode !== 0) failures.push({ cmd, exitCode, output: r.output });
+  }
+  return failures;
+}
+function verifyFollowup(failures, maxBytes = 8e3) {
+  const blocks = failures.map((f) => {
+    const output = f.output.length > maxBytes ? `${f.output.slice(0, maxBytes)}
+[truncated]` : f.output;
+    return `$ ${f.cmd}
+[exit code ${f.exitCode}]
+${output}`;
+  });
+  return t("Automatic verification after your edits failed. Fix the problems so these commands pass, then stop.\n\n{blocks}", {
+    blocks: blocks.join("\n\n")
+  });
+}
+
+// src/print.ts
+function toolLabel(tool) {
+  if (tool === "web_search") return "Search";
+  return tool.charAt(0).toUpperCase() + tool.slice(1);
+}
+async function runPrint(rt, prompt, io = { out: process.stdout, err: process.stderr }, opts = {}) {
+  const format = opts.outputFormat ?? "text";
+  const emit = (line) => io.out.write(`${JSON.stringify(line)}
+`);
+  let result = "";
+  const toolNames = /* @__PURE__ */ new Map();
+  rt.interaction.approvePlan = async () => {
+    if (opts.allowAll) return "allowAll";
+    io.err.write(`${t("Plan needs approval; run with --allow-all.")}
+`);
+    return "no";
+  };
+  let failed = false;
+  let wroteText = false;
+  let edited = false;
+  rt.agent.onEvent = (event) => {
+    switch (event.type) {
+      case "text":
+        if (format === "text") {
+          io.out.write(event.delta);
+          wroteText = true;
+        } else {
+          result += event.delta;
+        }
+        break;
+      case "toolStart":
+        toolNames.set(event.id, event.tool);
+        io.err.write(`\u23BF ${toolLabel(event.tool)}  ${event.target}
+`);
+        if (format === "stream-json") emit({ type: "tool_use", tool: event.tool, target: event.target });
+        break;
+      case "toolEnd":
+        if (event.isError) io.err.write(`  \u2717 ${event.output.split("\n")[0]}
+`);
+        if ((event.tool === "edit" || event.tool === "write") && !event.isError) edited = true;
+        if (format === "stream-json") emit({ type: "tool_result", tool: toolNames.get(event.id), isError: !!event.isError, output: event.output });
+        break;
+      case "stepLimit":
+        io.err.write(`${t("Step limit reached.")}
+`);
+        failed = true;
+        break;
+      case "budgetExceeded":
+        io.err.write(`${t("Budget exceeded ({kind}): {used} of {limit}. Further model calls are blocked; raise usageCap in ~/.bccli/config.json.", { kind: event.kind, used: Math.round(event.used * 100) / 100, limit: event.limit })}
+`);
+        if (format === "stream-json") emit({ type: "error", message: "budgetExceeded" });
+        failed = true;
+        break;
+      case "aborted":
+        io.err.write(`${t("Cancelled.")}
+`);
+        failed = true;
+        break;
+      case "error":
+        io.err.write(`Error: ${event.message}
+`);
+        if (format === "stream-json") emit({ type: "error", message: event.message });
+        failed = true;
+        break;
+    }
+  };
+  rt.agent.askPermission = async (req) => {
+    io.err.write(`  ${t("Needs permission for {tool}. Run with --allow-all or --allowed-tools {kind}.", { tool: req.tool, kind: req.kind })}
+`);
+    return "no";
+  };
+  const controller = new AbortController();
+  const onSigint = () => controller.abort();
+  process.once("SIGINT", onSigint);
+  const start = await runHooks(rt.config.hooks, "SessionStart", {}, { env: rt.env, cwd: rt.cwd });
+  for (const warning of start.warnings) io.err.write(`${warning}
+`);
+  await rt.emitPlugins("SessionStart");
+  try {
+    await rt.agent.run(prompt, controller.signal);
+    const commands = rt.config.verifyCommands;
+    if (edited && commands.length && !controller.signal.aborted) {
+      for (let round = 0; round < MAX_VERIFY_ROUNDS; round++) {
+        io.err.write(`${t("Verifying edits: {cmds}", { cmds: commands.join(", ") })}
+`);
+        const failures = await runVerify(commands, { cwd: rt.cwd, env: rt.env, signal: controller.signal });
+        if (!failures.length) {
+          io.err.write(`${t("Verification passed.")}
+`);
+          break;
+        }
+        if (round === MAX_VERIFY_ROUNDS - 1 || controller.signal.aborted) {
+          io.err.write(`${t("Verification still failing after {n} fix round(s). Run the commands manually to see why.", { n: MAX_VERIFY_ROUNDS })}
+`);
+          failed = true;
+          break;
+        }
+        await rt.agent.run(verifyFollowup(failures), controller.signal);
+      }
+    }
+  } finally {
+    process.off("SIGINT", onSigint);
+  }
+  const stop = await runHooks(rt.config.hooks, "Stop", {}, { env: rt.env, cwd: rt.cwd });
+  for (const warning of stop.warnings) io.err.write(`${warning}
+`);
+  await rt.emitPlugins("Stop");
+  if (format === "json") {
+    io.out.write(`${JSON.stringify({ status: failed ? "failed" : "ok", model: rt.modelRef, result })}
+`);
+  } else if (format === "stream-json") {
+    if (result) emit({ type: "message", text: result });
+    emit({ type: "result", status: failed ? "failed" : "ok", model: rt.modelRef });
+  } else if (wroteText) {
+    io.out.write("\n");
+  }
+  return failed ? 1 : 0;
+}
+
+// src/worktree.ts
+import { execFile } from "child_process";
+import { existsSync } from "fs";
+import { basename, dirname, join } from "path";
+function git(cwd, args, bin = "git") {
+  return new Promise((resolve) => {
+    execFile(
+      bin,
+      args,
+      { cwd, maxBuffer: 20 * 1024 * 1024 },
+      (error, stdout, stderr) => resolve({ ok: !error, out: error ? stderr : stdout, missing: error?.code === "ENOENT" })
+    );
+  });
+}
+var NAME_RE = /^[A-Za-z0-9._-]+$/;
+function samePath(a, b) {
+  const norm = (p) => process.platform === "win32" ? p.replace(/\//g, "\\").toLowerCase() : p.replace(/\\/g, "/");
+  return norm(a) === norm(b);
+}
+function worktreeEntries(porcelain) {
+  return porcelain.split(/\r?\n\r?\n/).map((block) => {
+    const path = /^worktree (.+)$/m.exec(block)?.[1]?.trim();
+    if (!path) return void 0;
+    const branch = /^branch refs\/heads\/(.+)$/m.exec(block)?.[1];
+    return branch ? { path, branch } : { path };
+  }).filter((entry) => !!entry);
+}
+async function resolveWorktree(cwd, name, bin = "git") {
+  if (!NAME_RE.test(name)) {
+    throw new ConfigError(t('Invalid worktree name "{name}": use letters, digits, dot, dash, or underscore (no slashes).', { name }));
+  }
+  const inside = await git(cwd, ["rev-parse", "--is-inside-work-tree"], bin);
+  if (inside.missing) throw new ConfigError(t("git is not installed or not on PATH, so -w cannot be used."));
+  if (!inside.ok || inside.out.trim() !== "true") throw new ConfigError(t("This folder is not a git repository, so -w cannot create a worktree."));
+  const list = await git(cwd, ["worktree", "list", "--porcelain"], bin);
+  if (!list.ok) throw new ConfigError(t("This folder is not a git repository, so -w cannot create a worktree."));
+  const entries = worktreeEntries(list.out);
+  const main = entries[0]?.path;
+  if (!main) throw new ConfigError(t("This folder is not a git repository, so -w cannot create a worktree."));
+  const path = join(dirname(main), `${basename(main)}.worktrees`, name);
+  if (entries.some((entry) => samePath(entry.path, path))) return { path, created: false };
+  if (existsSync(path)) {
+    throw new ConfigError(t("Worktree path {path} already exists but is not a registered worktree; remove or rename it first.", { path }));
+  }
+  const branch = `bccli/${name}`;
+  const hasBranch = (await git(main, ["rev-parse", "--verify", "-q", `refs/heads/${branch}`], bin)).ok;
+  const add = hasBranch ? await git(main, ["worktree", "add", path, branch], bin) : await git(main, ["worktree", "add", "-b", branch, path], bin);
+  if (!add.ok) throw new ConfigError(add.out.trim() || t("This folder is not a git repository, so -w cannot create a worktree."));
+  return { path, created: true };
+}
+async function worktreeListText(cwd, bin = "git") {
+  const inside = await git(cwd, ["rev-parse", "--is-inside-work-tree"], bin);
+  if (inside.missing) return t("git is not installed or not on PATH, so /worktree cannot be used.");
+  if (!inside.ok || inside.out.trim() !== "true") return t("This folder is not a git repository, so there is no diff.");
+  const list = await git(cwd, ["worktree", "list", "--porcelain"], bin);
+  if (!list.ok) return t("This folder is not a git repository, so there is no diff.");
+  const rows = worktreeEntries(list.out).map((entry) => `  ${entry.path}${entry.branch ? ` (${entry.branch})` : ""}`);
+  return [
+    t("Git worktrees:"),
+    ...rows,
+    "",
+    t("Create one with: bccli -w <name>"),
+    t("Remove with: git worktree remove <path>")
+  ].join("\n");
+}
+
+export {
+  MAX_VERIFY_ROUNDS,
+  runVerify,
+  verifyFollowup,
+  toolLabel,
+  runPrint,
+  resolveWorktree,
+  worktreeListText
+};

package/dist/{chunk-U7DLMVPZ.js → chunk-SESBH44L.js}

@@ -5,7 +5,7 @@ import {
   readCredentials,
   readJsonConfig,
   removeCredential
-} from "./chunk-RZUJYAQV.js";
+} from "./chunk-M7LLJQ7M.js";
 
 // src/providers.ts
 import { mkdirSync, writeFileSync } from "fs";
@@ -45,6 +45,7 @@ function removeGlobalProvider(id, env = process.env) {
 export {
   providerName,
   hasKey,
+  readGlobalConfigFile,
   writeGlobalConfig,
   removeGlobalProvider
 };

package/dist/{chunk-SJH3YLW4.js → chunk-VM7HYAJS.js}

@@ -1,4 +1,7 @@
 #!/usr/bin/env node
+import {
+  contentText
+} from "./chunk-GGNXHJL6.js";
 
 // src/session.ts
 import { randomBytes } from "crypto";
@@ -36,7 +39,7 @@ var Session = class _Session {
     return readdirSync(dir).filter((f) => f.endsWith(".jsonl")).map((f) => {
       const session = new _Session(join(dir, f));
       const first = session.load().find((m) => m.role === "user");
-      return { session, mtime: statSync(session.file).mtime, preview: first ? String(first.content).slice(0, 80) : "" };
+      return { session, mtime: statSync(session.file).mtime, preview: first ? contentText(first.content).slice(0, 80) : "" };
     }).sort((a, b) => b.mtime.getTime() - a.mtime.getTime() || b.session.file.localeCompare(a.session.file));
   }
   static latest(home, cwd) {