@botconnector/bccli 0.4.0-beta.9 → 0.4.0

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

@@ -1,4 +1,7 @@
 #!/usr/bin/env node
+import {
+  contentText
+} from "./chunk-PUN4HMAG.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) {
@@ -49,26 +52,77 @@ var Session = class _Session {
   append(message) {
     this.write({ t: "msg", m: message });
   }
+  appendUsage(usage) {
+    this.write({ t: "usage", ...usage });
+  }
   reset() {
     this.write({ t: "reset" });
   }
-  load() {
+  records() {
     if (!existsSync(this.file)) return [];
-    let messages = [];
+    const out = [];
     for (const line of readFileSync(this.file, "utf8").split("\n")) {
       if (!line.trim()) continue;
-      let record;
       try {
-        record = JSON.parse(line);
+        out.push(JSON.parse(line));
       } catch {
-        continue;
       }
+    }
+    return out;
+  }
+  /** What the model continues from: everything after the last reset (after a compaction that is the summary and the recent turns). */
+  load() {
+    let messages = [];
+    for (const record of this.records()) {
       if (record.t === "reset") messages = [];
       else if (record.t === "msg") messages.push(record.m);
     }
     return repairTail(messages);
   }
+  /**
+   * What the user sees on resume: the whole conversation. Compaction only shrinks what the model is sent, so
+   * its reset does not hide the older turns here. A real reset (/clear, rewind) still starts over, the
+   * synthetic summary pair is never shown, and the recent turns a compaction re-writes are not shown twice.
+   */
+  loadHistory() {
+    const segments = [[]];
+    for (const record of this.records()) {
+      if (record.t === "reset") segments.push([]);
+      else if (record.t === "msg") segments[segments.length - 1].push(record.m);
+    }
+    let shown = segments[0];
+    for (const segment of segments.slice(1)) {
+      if (!isCompactionSummary(segment[0])) {
+        shown = segment;
+        continue;
+      }
+      const kept = segment.slice(2);
+      let at = 0;
+      while (at <= shown.length && !endsWithPrefixOf(shown, at, kept)) at++;
+      shown = [...shown, ...kept.slice(shown.length - at)];
+    }
+    return repairTail(shown.filter((m) => !isCompactionSummary(m) && !isCompactionAck(m)));
+  }
 };
+var SUMMARY_PREFIX = "Summary of the previous conversation:";
+var SUMMARY_ACK = "OK, I will continue from this summary.";
+function isCompactionSummary(m) {
+  return m?.role === "user" && typeof m.content === "string" && m.content.startsWith(SUMMARY_PREFIX);
+}
+function isCompactionAck(m) {
+  return m.role === "assistant" && m.content === SUMMARY_ACK;
+}
+function sameMessage(a, b) {
+  if (a.role !== b.role) return false;
+  if (a.role === "tool" && b.role === "tool") return a.tool_call_id === b.tool_call_id;
+  return JSON.stringify(a.content) === JSON.stringify(b.content) && JSON.stringify("tool_calls" in a && a.tool_calls) === JSON.stringify("tool_calls" in b && b.tool_calls);
+}
+function endsWithPrefixOf(shown, at, kept) {
+  const n = shown.length - at;
+  if (n > kept.length) return false;
+  for (let j = 0; j < n; j++) if (!sameMessage(shown[at + j], kept[j])) return false;
+  return true;
+}
 function pruneSessions(home, now = Date.now(), maxAgeDays = 30) {
   const root = join(home, "sessions");
   if (!existsSync(root)) return 0;

package/dist/chunk-QZKLZELZ.js

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+
+// src/tokenBudget.ts
+var estimateTokens = (text) => Math.ceil(text.length / 4);
+var estimateMessages = (messages) => estimateTokens(JSON.stringify(messages));
+function trimToFit(messages, maxTokens) {
+  let out = messages;
+  while (estimateMessages(out) > maxTokens) {
+    const boundary = out.findIndex((m, i) => i > 0 && m.role === "user");
+    if (boundary === -1) return out;
+    out = out.slice(boundary);
+  }
+  return out;
+}
+function splitKeepRecent(messages, keepTokens) {
+  if (messages.length === 0) return [[], []];
+  let start = messages.length;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (i > 0 && messages[i].role !== "user") continue;
+    if (estimateMessages(messages.slice(i)) <= keepTokens) start = i;
+    else break;
+  }
+  if (start === messages.length) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+      if (messages[i].role === "user") {
+        start = i;
+        break;
+      }
+    }
+  }
+  return [messages.slice(0, start), messages.slice(start)];
+}
+var TOOL_STUB = "[Old tool result content cleared]";
+var TOOL_PRUNE_KEEP_TOKENS = 4e4;
+var TOOL_PRUNE_MIN_TOKENS = 2e4;
+var isToolStub = (content) => content.startsWith(TOOL_STUB);
+function pruneOldToolOutputs(messages) {
+  let kept = 0;
+  let oldTokens = 0;
+  const old = [];
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const m = messages[i];
+    if (m.role !== "tool" || isToolStub(m.content)) continue;
+    kept += estimateTokens(m.content);
+    if (kept > TOOL_PRUNE_KEEP_TOKENS) {
+      old.push(i);
+      oldTokens += estimateTokens(m.content);
+    }
+  }
+  if (oldTokens <= TOOL_PRUNE_MIN_TOKENS) return false;
+  for (const i of old) {
+    const m = messages[i];
+    messages[i] = { ...m, content: TOOL_STUB };
+  }
+  return true;
+}
+
+export {
+  estimateTokens,
+  estimateMessages,
+  trimToFit,
+  splitKeepRecent,
+  pruneOldToolOutputs
+};

package/dist/{chunk-7S6JXQCH.js → chunk-SPRNLS7K.js}

@@ -5,7 +5,7 @@ import {
   readCredentials,
   readJsonConfig,
   removeCredential
-} from "./chunk-2MGINW4O.js";
+} from "./chunk-LACUWBWS.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-TLPFQIS2.js

@@ -0,0 +1,231 @@
+#!/usr/bin/env node
+import {
+  runCommand,
+  runHooks
+} from "./chunk-M7CALSP3.js";
+import {
+  ConfigError
+} from "./chunk-LACUWBWS.js";
+import {
+  t
+} from "./chunk-UZWJQF67.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
+};