@botconnector/bccli 0.4.0-beta.5 → 0.4.0-beta.51

package/dist/cli.js

@@ -1,1337 +1,213 @@
 #!/usr/bin/env node
 import {
-  HELP_TEXT,
-  parseCliArgs
-} from "./chunk-UN7QXPCB.js";
+  resolveWorktree,
+  runPrint
+} from "./chunk-TQWCM5RO.js";
 import {
-  addProviderKey,
-  createProvider,
-  listAllModels
-} from "./chunk-C5AFWX7H.js";
+  createRuntime
+} from "./chunk-KIZC5XV4.js";
+import "./chunk-QZKLZELZ.js";
+import "./chunk-YIYX3FFS.js";
+import "./chunk-DP7EBW53.js";
+import "./chunk-PSO7R5AD.js";
 import {
-  runLogin
-} from "./chunk-GW36UMHZ.js";
+  VERSION
+} from "./chunk-VU5HNQHX.js";
 import {
-  BUILTIN_AGENTS,
-  buildSystemPrompt,
-  ignorePatterns,
-  loadAgentDefs,
-  loadCommands,
-  loadSkills,
-  parseFrontmatter,
-  runPrint
-} from "./chunk-5O4HD7IU.js";
+  helpText,
+  parseCliArgs
+} from "./chunk-FTFVW7XD.js";
+import "./chunk-GAFJEQTJ.js";
+import "./chunk-N7KP6RNP.js";
+import "./chunk-QXOV4DUZ.js";
 import {
-  Permissions
-} from "./chunk-ELML4KVQ.js";
+  readGlobalConfigFile
+} from "./chunk-2QYHSESB.js";
 import {
-  providerName
-} from "./chunk-U7DLMVPZ.js";
+  defaultLoginDeps,
+  runLogin
+} from "./chunk-KD2LMIS4.js";
+import "./chunk-7F3IWBPQ.js";
 import {
-  Session,
   pruneSessions
-} from "./chunk-SJH3YLW4.js";
+} from "./chunk-F6ACN47V.js";
+import "./chunk-R4BJBTWC.js";
+import "./chunk-SNKVS26H.js";
+import "./chunk-H73FO5YK.js";
 import {
   ConfigError,
-  bccliHome,
-  loadConfig,
-  resolveModel
-} from "./chunk-RZUJYAQV.js";
-
-// src/tools/index.ts
-import { z as z8 } from "zod";
-
-// src/tools/bash.ts
-import { spawn } from "child_process";
-import { z } from "zod";
-
-// src/tools/types.ts
-function defineTool(tool) {
-  return tool;
+  setTheme
+} from "./chunk-NDEJUL44.js";
+import {
+  resolveLanguage,
+  setLanguage,
+  t
+} from "./chunk-XLC6T4SX.js";
+
+// src/exit.ts
+var EXIT_GRACE_MS = 1e3;
+function settleExit(code, deps) {
+  const d = {
+    setExitCode: (c) => {
+      process.exitCode = c;
+    },
+    exit: (c) => process.exit(c),
+    setTimer: (fn, ms) => setTimeout(fn, ms),
+    ...deps
+  };
+  d.setExitCode(code);
+  const force = d.setTimer(() => d.exit(code), EXIT_GRACE_MS);
+  force.unref();
 }
 
-// src/tools/bash.ts
-var HALF = 15e3;
-function killProcessTree(pid, platform = process.platform, spawnFn = spawn) {
-  if (platform === "win32") {
-    const killer = spawnFn("taskkill", ["/pid", String(pid), "/T", "/F"]);
-    killer.on("error", () => {
-      try {
-        process.kill(pid);
-      } catch {
-      }
-    });
-    return;
-  }
+// src/cli.ts
+function chooseLanguage(argv) {
+  let fromConfig;
   try {
-    process.kill(-pid, "SIGKILL");
+    fromConfig = readGlobalConfigFile(process.env).language;
   } catch {
-    try {
-      process.kill(pid, "SIGKILL");
-    } catch {
-    }
-  }
-}
-var active = /* @__PURE__ */ new Set();
-var exitHookInstalled = false;
-function killAllCommands() {
-  for (const kill of active) kill();
-}
-function runCommand(command, opts) {
-  return new Promise((resolve2) => {
-    const child = spawn(command, {
-      cwd: opts.cwd,
-      shell: true,
-      detached: process.platform !== "win32",
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    if (!exitHookInstalled) {
-      process.on("exit", killAllCommands);
-      exitHookInstalled = true;
-    }
-    child.stdout.setEncoding("utf8");
-    child.stderr.setEncoding("utf8");
-    let head = "";
-    let tail = "";
-    let dropped = 0;
-    let timedOut = false;
-    let aborted = false;
-    const onData = (data) => {
-      let s = data;
-      if (head.length < HALF) {
-        const take = s.slice(0, HALF - head.length);
-        head += take;
-        s = s.slice(take.length);
-      }
-      if (s) {
-        tail += s;
-        if (tail.length > HALF) {
-          dropped += tail.length - HALF;
-          tail = tail.slice(-HALF);
-        }
-      }
-    };
-    child.stdout.on("data", onData);
-    child.stderr.on("data", onData);
-    const kill = () => {
-      if (child.pid !== void 0) killProcessTree(child.pid);
-    };
-    const killAsAborted = () => {
-      aborted = true;
-      kill();
-    };
-    active.add(killAsAborted);
-    const timer = setTimeout(() => {
-      timedOut = true;
-      kill();
-    }, opts.timeoutMs);
-    const onAbort = () => {
-      aborted = true;
-      kill();
-    };
-    if (opts.signal.aborted) onAbort();
-    opts.signal.addEventListener("abort", onAbort, { once: true });
-    const finish = (exitCode, extra = "") => {
-      active.delete(killAsAborted);
-      clearTimeout(timer);
-      opts.signal.removeEventListener("abort", onAbort);
-      const output = dropped ? `${head}
-\u2026 [${dropped} karakter dipotong] \u2026
-${tail}` : head + tail;
-      resolve2({ output: output + extra, exitCode, timedOut, aborted });
-    };
-    child.on("error", (error) => finish(null, error.message));
-    child.on("close", (code) => finish(code));
-  });
-}
-var bashTool = defineTool({
-  name: "bash",
-  description: "Run a shell command in the project directory. No interactive input. Default timeout 2 minutes (max 10). Use for tests, builds, git, and other CLI tasks.",
-  schema: z.object({
-    command: z.string().describe("The shell command to run"),
-    timeout_ms: z.number().int().min(1e3).max(6e5).optional().describe("Timeout in milliseconds")
-  }),
-  kind: "bash",
-  target: (input) => input.command,
-  async run(input, ctx) {
-    const r = await runCommand(input.command, { cwd: ctx.cwd, timeoutMs: input.timeout_ms ?? 12e4, signal: ctx.signal });
-    const status = r.timedOut ? `[dihentikan: timeout ${Math.round((input.timeout_ms ?? 12e4) / 1e3)} detik]` : r.aborted ? "[dibatalkan user]" : `[exit code ${r.exitCode}]`;
-    return { output: `${r.output.trimEnd()}
-${status}`.trimStart(), isError: r.exitCode !== 0 };
-  }
-});
-
-// src/tools/edit.ts
-import { readFile, writeFile } from "fs/promises";
-import { z as z2 } from "zod";
-
-// src/diff.ts
-import { structuredPatch } from "diff";
-function diffLines(oldText, newText) {
-  const patch = structuredPatch("a", "b", oldText, newText, "", "", { context: 2 });
-  const out = [];
-  for (const hunk of patch.hunks) {
-    let oldLine = hunk.oldStart;
-    let newLine = hunk.newStart;
-    for (const raw of hunk.lines) {
-      const text = raw.slice(1);
-      if (raw[0] === "-") out.push({ kind: "del", line: oldLine++, text });
-      else if (raw[0] === "+") out.push({ kind: "add", line: newLine++, text });
-      else if (raw[0] === " ") {
-        out.push({ kind: "ctx", line: newLine, text });
-        oldLine++;
-        newLine++;
-      }
-    }
-  }
-  return out;
-}
-function formatDiff(lines) {
-  const mark = { add: "+", del: "-", ctx: " " };
-  return lines.map((l) => `${String(l.line).padStart(5)} ${mark[l.kind]} ${l.text}`).join("\n");
-}
-
-// src/tools/paths.ts
-import { isAbsolute, resolve } from "path";
-function resolvePath(cwd, path) {
-  return isAbsolute(path) ? path : resolve(cwd, path);
-}
-function errorCode(error) {
-  return error.code ?? error.message;
-}
-
-// src/tools/edit.ts
-var schema = z2.object({
-  path: z2.string().describe("File path, relative to the project or absolute"),
-  old_string: z2.string().describe("Exact text to replace; must be unique unless replace_all"),
-  new_string: z2.string().describe("Replacement text"),
-  replace_all: z2.boolean().optional().describe("Replace every occurrence")
-});
-function countOccurrences(haystack, needle) {
-  let count = 0;
-  for (let i = haystack.indexOf(needle); i !== -1; i = haystack.indexOf(needle, i + needle.length)) count++;
-  return count;
-}
-function applyEdit(content, input) {
-  if (input.old_string === input.new_string) {
-    return { output: "old_string dan new_string sama; tidak ada perubahan.", isError: true };
-  }
-  const eol = content.includes("\r\n") ? "\r\n" : "\n";
-  const toEol = (s) => s.replace(/\r?\n/g, eol);
-  const attempts = [[input.old_string, input.new_string]];
-  if (toEol(input.old_string) !== input.old_string) attempts.push([toEol(input.old_string), toEol(input.new_string)]);
-  for (const [oldText, newText] of attempts) {
-    const count = oldText ? countOccurrences(content, oldText) : 0;
-    if (count === 0) continue;
-    if (count > 1 && !input.replace_all) {
-      return {
-        output: `old_string muncul ${count} kali di ${input.path}. Tambah konteks agar unik, atau pakai replace_all.`,
-        isError: true
-      };
-    }
-    return input.replace_all ? content.split(oldText).join(newText) : content.replace(oldText, () => newText);
-  }
-  return { output: `old_string tidak ditemukan di ${input.path}. Baca ulang file-nya.`, isError: true };
-}
-var editTool = defineTool({
-  name: "edit",
-  description: "Replace exact text in a file. The file must have been read first. old_string must match exactly (including indentation) and be unique unless replace_all is true.",
-  schema,
-  kind: "edit",
-  target: (input) => input.path,
-  async validate(input, ctx) {
-    const abs = resolvePath(ctx.cwd, input.path);
-    if (!ctx.readFiles.has(abs)) return `Baca ${input.path} dulu dengan read sebelum mengedit.`;
-    let content;
-    try {
-      content = await readFile(abs, "utf8");
-    } catch (error) {
-      return `Tidak bisa membaca ${input.path}: ${errorCode(error)}`;
-    }
-    const next = applyEdit(content, input);
-    return typeof next === "string" ? void 0 : next.output;
-  },
-  async preview(input, ctx) {
-    const abs = resolvePath(ctx.cwd, input.path);
-    const content = await readFile(abs, "utf8");
-    const next = applyEdit(content, input);
-    return typeof next === "string" ? formatDiff(diffLines(content, next)) : void 0;
-  },
-  async run(input, ctx) {
-    const abs = resolvePath(ctx.cwd, input.path);
-    if (!ctx.readFiles.has(abs)) {
-      return { output: `Baca ${input.path} dulu dengan read sebelum mengedit.`, isError: true };
-    }
-    let content;
-    try {
-      content = await readFile(abs, "utf8");
-    } catch (error) {
-      return { output: `Tidak bisa membaca ${input.path}: ${errorCode(error)}`, isError: true };
-    }
-    const next = applyEdit(content, input);
-    if (typeof next !== "string") return next;
-    await ctx.checkpoint?.(abs);
-    await writeFile(abs, next);
-    return { output: `Mengedit ${input.path}.`, display: formatDiff(diffLines(content, next)) };
-  }
-});
-
-// src/tools/fetch.ts
-import { z as z3 } from "zod";
-var MAX_CHARS = 5e4;
-var MAX_BYTES = 5 * 1024 * 1024;
-async function readCapped(res) {
-  const reader = res.body?.getReader();
-  if (!reader) return { text: "", truncated: false };
-  const chunks = [];
-  let size = 0;
-  for (; ; ) {
-    const { done, value } = await reader.read();
-    if (done) return { text: Buffer.concat(chunks).toString("utf8"), truncated: false };
-    size += value.length;
-    if (size > MAX_BYTES) {
-      chunks.push(value.subarray(0, value.length - (size - MAX_BYTES)));
-      await reader.cancel();
-      return { text: Buffer.concat(chunks).toString("utf8"), truncated: true };
-    }
-    chunks.push(value);
   }
+  setLanguage(resolveLanguage(argv, process.env, fromConfig));
 }
-function htmlToText(html) {
-  return html.replace(/<(script|style|noscript)[\s\S]*?<\/\1>/gi, "").replace(/<(br|\/p|\/div|\/h[1-6]|\/li|\/tr)\s*\/?>/gi, "\n").replace(/<[^>]+>/g, "").replace(/&nbsp;/g, " ").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&amp;/g, "&").split("\n").map((l) => l.replace(/\s+/g, " ").trim()).filter(Boolean).join("\n");
-}
-var fetchTool = defineTool({
-  name: "fetch",
-  description: "Fetch a URL (http/https). HTML is converted to plain text. Max 50k characters.",
-  schema: z3.object({ url: z3.string().describe("Absolute http(s) URL") }),
-  kind: "fetch",
-  target: (input) => input.url,
-  async run(input, ctx) {
-    if (!/^https?:\/\//i.test(input.url)) return { output: "URL harus diawali http:// atau https://", isError: true };
-    let url = new URL(input.url);
-    let res;
-    try {
-      for (let hop = 0; hop < 5; hop++) {
-        res = await fetch(url, { signal: AbortSignal.any([ctx.signal, AbortSignal.timeout(3e4)]), redirect: "manual" });
-        const location = res.status >= 300 && res.status < 400 ? res.headers.get("location") : null;
-        if (!location) break;
-        const next = new URL(location, url);
-        if (next.host !== url.host) {
-          await res.body?.cancel();
-          return {
-            output: `Redirect ke host lain: ${next.href}. Panggil fetch lagi dengan URL itu kalau memang perlu (akan diminta izin).`,
-            isError: true
-          };
-        }
-        await res.body?.cancel();
-        url = next;
-      }
-    } catch (error) {
-      return { output: `Gagal mengambil ${input.url}: ${error.message}`, isError: true };
-    }
-    if (!res) return { output: `Gagal mengambil ${input.url}`, isError: true };
-    const { text: body, truncated } = await readCapped(res);
-    if (!res.ok) return { output: `HTTP ${res.status} dari ${input.url}: ${body.slice(0, 500)}`, isError: true };
-    const text = (res.headers.get("content-type") ?? "").includes("html") ? htmlToText(body) : body;
-    const clipped = text.length > MAX_CHARS || truncated ? `${text.slice(0, MAX_CHARS)}
-\u2026 [dipotong]` : text;
-    const display = truncated ? "lebih dari 5 MB, dipotong" : `${text.length} karakter`;
-    return { output: clipped, display };
-  }
-});
-
-// src/tools/glob.ts
-import fg from "fast-glob";
-import { z as z4 } from "zod";
-var globTool = defineTool({
-  name: "glob",
-  description: 'Find files by glob pattern, e.g. "src/**/*.ts". Respects .gitignore. Max 500 results.',
-  schema: z4.object({
-    pattern: z4.string().describe("Glob pattern"),
-    path: z4.string().optional().describe("Base directory, default project root")
-  }),
-  kind: "read",
-  target: (input) => input.pattern,
-  async run(input, ctx) {
-    const root = resolvePath(ctx.cwd, input.path ?? ".");
-    const files = (await fg(input.pattern, { cwd: root, ignore: ignorePatterns(root), onlyFiles: true, dot: true })).sort();
-    if (!files.length) return { output: "Tidak ada file yang cocok." };
-    const shown = files.slice(0, 500);
-    const more = files.length > shown.length ? `
-\u2026 ${files.length - shown.length} file lagi` : "";
-    return { output: shown.join("\n") + more, display: `${files.length} file` };
-  }
-});
-
-// src/tools/grep.ts
-import { execFile } from "child_process";
-import { readFile as readFile2 } from "fs/promises";
-import fg2 from "fast-glob";
-import { z as z5 } from "zod";
-var MAX_MATCHES = 200;
-async function grepJs(pattern, opts) {
-  const regex = new RegExp(pattern, opts.ignoreCase ? "i" : "");
-  const files = await fg2(opts.glob ?? "**/*", { cwd: opts.root, ignore: ignorePatterns(opts.root), onlyFiles: true, dot: true });
-  const out = [];
-  for (const file of files.sort()) {
-    let text;
-    try {
-      const buffer = await readFile2(resolvePath(opts.root, file));
-      if (buffer.subarray(0, 8e3).includes(0)) continue;
-      text = buffer.toString("utf8");
-    } catch {
-      continue;
-    }
-    const lines = text.split(/\r?\n/);
-    for (let i = 0; i < lines.length && out.length < MAX_MATCHES; i++) {
-      if (regex.test(lines[i])) out.push(`${file}:${i + 1}:${lines[i].slice(0, 300)}`);
-    }
-    if (out.length >= MAX_MATCHES) break;
-  }
-  return out;
-}
-function grepRg(pattern, opts) {
-  const args = ["--line-number", "--no-heading", "--color", "never", "--max-columns", "300", "-e", pattern];
-  if (opts.ignoreCase) args.push("-i");
-  if (opts.glob) args.push("-g", opts.glob);
-  args.push(".");
-  return new Promise((resolve2) => {
-    execFile("rg", args, { cwd: opts.root, maxBuffer: 10 * 1024 * 1024 }, (error, stdout) => {
-      const code = error?.code;
-      if (code === "ENOENT") return resolve2(void 0);
-      if (error && error.code !== 1) return resolve2(void 0);
-      resolve2(stdout.split("\n").filter(Boolean).map((l) => l.replace(/^\.\//, "")).slice(0, MAX_MATCHES));
-    });
-  });
-}
-var grepTool = defineTool({
-  name: "grep",
-  description: "Search file contents with a regular expression. Respects .gitignore. Returns path:line:text (max 200).",
-  schema: z5.object({
-    pattern: z5.string().describe("Regular expression"),
-    path: z5.string().optional().describe("Directory to search, default project root"),
-    glob: z5.string().optional().describe('Only files matching this glob, e.g. "**/*.ts"'),
-    ignore_case: z5.boolean().optional()
-  }),
-  kind: "read",
-  target: (input) => input.pattern,
-  async run(input, ctx) {
-    const opts = { root: resolvePath(ctx.cwd, input.path ?? "."), glob: input.glob, ignoreCase: input.ignore_case };
-    try {
-      new RegExp(input.pattern);
-    } catch (error) {
-      return { output: `Regex tidak valid: ${error.message}`, isError: true };
-    }
-    const matches = await grepRg(input.pattern, opts) ?? await grepJs(input.pattern, opts);
-    if (!matches.length) return { output: "Tidak ada yang cocok." };
-    return { output: matches.join("\n"), display: `${matches.length} hasil` };
-  }
-});
-
-// src/tools/read.ts
-import { readFile as readFile3 } from "fs/promises";
-import { z as z6 } from "zod";
-var MAX_LINE = 2e3;
-var readTool = defineTool({
-  name: "read",
-  description: "Read a text file. Returns numbered lines (default first 2000). Use offset/limit for large files. Always read a file before editing it.",
-  schema: z6.object({
-    path: z6.string().describe("File path, relative to the project or absolute"),
-    offset: z6.number().int().min(1).optional().describe("First line to read, 1-based"),
-    limit: z6.number().int().min(1).optional().describe("Number of lines, default 2000")
-  }),
-  kind: "read",
-  target: (input) => input.path,
-  async run(input, ctx) {
-    const abs = resolvePath(ctx.cwd, input.path);
-    let buffer;
-    try {
-      buffer = await readFile3(abs);
-    } catch (error) {
-      return { output: `Tidak bisa membaca ${input.path}: ${errorCode(error)}`, isError: true };
-    }
-    if (buffer.subarray(0, 8e3).includes(0)) {
-      return { output: `${input.path} adalah file biner, tidak dibaca.`, isError: true };
-    }
-    const lines = buffer.toString("utf8").split(/\r?\n/);
-    const start = (input.offset ?? 1) - 1;
-    const limit = input.limit ?? 2e3;
-    const slice = lines.slice(start, start + limit);
-    const body = slice.map((line, i) => {
-      const text = line.length > MAX_LINE ? `${line.slice(0, MAX_LINE)}\u2026 [baris dipotong]` : line;
-      return `${String(start + i + 1).padStart(6)}	${text}`;
-    }).join("\n");
-    const remaining = lines.length - start - slice.length;
-    ctx.readFiles.add(abs);
-    return {
-      output: remaining > 0 ? `${body}
-\u2026 ${remaining} baris lagi (pakai offset)` : body,
-      display: `${slice.length} baris`
-    };
-  }
-});
-
-// src/tools/write.ts
-import { existsSync } from "fs";
-import { mkdir, readFile as readFile4, writeFile as writeFile2 } from "fs/promises";
-import { dirname } from "path";
-import { z as z7 } from "zod";
-var writeTool = defineTool({
-  name: "write",
-  description: "Create or overwrite a file with the given content. Read an existing file first. Prefer edit for changes.",
-  schema: z7.object({
-    path: z7.string().describe("File path, relative to the project or absolute"),
-    content: z7.string().describe("Full new file content")
-  }),
-  kind: "edit",
-  target: (input) => input.path,
-  async validate(input, ctx) {
-    const abs = resolvePath(ctx.cwd, input.path);
-    return existsSync(abs) && !ctx.readFiles.has(abs) ? `${input.path} sudah ada. Baca dulu dengan read sebelum menimpanya.` : void 0;
-  },
-  async preview(input, ctx) {
-    const abs = resolvePath(ctx.cwd, input.path);
-    const old = existsSync(abs) ? await readFile4(abs, "utf8") : "";
-    return formatDiff(diffLines(old, input.content));
-  },
-  async run(input, ctx) {
-    const abs = resolvePath(ctx.cwd, input.path);
-    if (existsSync(abs) && !ctx.readFiles.has(abs)) {
-      return { output: `${input.path} sudah ada. Baca dulu dengan read sebelum menimpanya.`, isError: true };
-    }
-    try {
-      await ctx.checkpoint?.(abs);
-      await mkdir(dirname(abs), { recursive: true });
-      await writeFile2(abs, input.content);
-    } catch (error) {
-      return { output: `Gagal menulis ${input.path}: ${errorCode(error)}`, isError: true };
-    }
-    ctx.readFiles.add(abs);
-    const lines = input.content.split("\n").length;
-    return { output: `Menulis ${input.path} (${lines} baris).`, display: `${lines} baris ditulis` };
-  }
-});
-
-// src/tools/index.ts
-var ALL_TOOLS = [readTool, writeTool, editTool, bashTool, grepTool, globTool, fetchTool];
-function toolDefinitions(tools) {
-  return tools.map((tool) => {
-    const { $schema: _ignored, ...parameters } = tool.jsonSchema ?? z8.toJSONSchema(tool.schema);
-    return { type: "function", function: { name: tool.name, description: tool.description, parameters } };
-  });
-}
-
-// src/textToolCalls.ts
-var PAIR = /(?:<arg_key>\s*|`)?([A-Za-z_]\w*)(?:\s*<\/arg_key>)?`?\s*(?:=\s*`|<arg_value>)([\s\S]*?)<\/arg_value>/g;
-var CALL_START = /<tool_call>|\n?[^\n]*\bTool call list\b[^\n]*|\n\s*\d+\.\s*Tool:/g;
-function coerce(value, type) {
-  const types = Array.isArray(type) ? type : [type];
-  const v = value.trim();
-  if ((types.includes("integer") || types.includes("number")) && v !== "" && !Number.isNaN(Number(v))) return Number(v);
-  if (types.includes("boolean") && /^(true|false)$/i.test(v)) return v.toLowerCase() === "true";
-  if ((types.includes("object") || types.includes("array")) && /^[[{]/.test(v)) {
-    try {
-      return JSON.parse(v);
-    } catch {
-    }
-  }
-  return value.replace(/^\n+|\n+$/g, "");
-}
-function pickTool(name, keys, tools) {
-  const named = name && tools.find((t) => t.function.name === name);
-  if (named) return named;
-  let best;
-  let bestScore = 0;
-  let tie = false;
-  for (const t of tools) {
-    const params = t.function.parameters;
-    const props = Object.keys(params.properties ?? {});
-    if (!(params.required ?? []).every((r) => keys.includes(r))) continue;
-    const score = keys.filter((k) => props.includes(k)).length;
-    if (score > bestScore) [best, bestScore, tie] = [t, score, false];
-    else if (score === bestScore && score > 0) tie = true;
-  }
-  return tie ? void 0 : best;
-}
-function recoverTextToolCalls(text, tools) {
-  if (!/<\/arg_value>|<tool_call>/.test(text)) return null;
-  const starts = [...text.matchAll(CALL_START)].map((m) => m.index ?? 0);
-  const firstPair = text.search(PAIR);
-  const cut = Math.min(...[...starts, firstPair].filter((i) => i >= 0));
-  const bounds = starts.filter((i) => i >= cut);
-  if (!bounds.length || bounds[0] > cut) bounds.unshift(cut);
-  const toolCalls = [];
-  bounds.forEach((start, n) => {
-    const segment = text.slice(start, bounds[n + 1] ?? text.length);
-    const name = /<tool_call>\s*([A-Za-z_][\w.-]*)/.exec(segment)?.[1] ?? /Tool:\s*`?([A-Za-z_][\w.-]*)`?/.exec(segment)?.[1];
-    let args = [];
-    const flush = () => {
-      if (!args.length) return;
-      const keys = args.map(([k]) => k);
-      const tool = pickTool(name, keys, tools);
-      if (tool) {
-        const props = tool.function.parameters.properties ?? {};
-        const input = Object.fromEntries(args.filter(([k]) => k in props).map(([k, v]) => [k, coerce(v, props[k].type)]));
-        toolCalls.push({ id: `text_call_${toolCalls.length}`, name: tool.function.name, arguments: JSON.stringify(input) });
-      }
-      args = [];
-    };
-    for (const m of segment.matchAll(PAIR)) {
-      if (args.some(([k]) => k === m[1])) flush();
-      args.push([m[1], m[2]]);
-    }
-    flush();
-  });
-  if (!toolCalls.length) return null;
-  return { text: text.slice(0, cut).trim(), toolCalls };
-}
-
-// src/agent.ts
-var estimateTokens = (text) => Math.ceil(text.length / 4);
-var COMPACT_PROMPT = "Summarize the conversation so far for yourself so you can continue the work with no other context. Include: the user goals, decisions made, files touched and their current state, commands run and results, the task in progress and the next step. Be concise but complete.";
-var Agent = class {
-  constructor(opts) {
-    this.opts = opts;
-    this.provider = opts.provider;
-    this.permissions = opts.permissions;
-    this.tools = opts.tools;
-    this.definitions = toolDefinitions(opts.tools);
-    this.turnTools = this.tools;
-    this.turnDefinitions = this.definitions;
-    this.messages = [...opts.history ?? []];
-    this.maxSteps = opts.maxSteps ?? 50;
-    this.contextWindow = opts.contextWindow ?? 128e3;
-    this.systemPrompt = opts.systemPrompt;
-  }
-  opts;
-  provider;
-  permissions;
-  messages;
-  totalUsage = { inputTokens: 0, outputTokens: 0 };
-  lastInputTokens = 0;
-  onEvent = () => {
-  };
-  askPermission = async () => "no";
-  tools;
-  definitions;
-  // Snapshot for the running turn: tools added/removed mid-turn (e.g. an MCP server connecting) apply from the next turn.
-  turnTools;
-  turnDefinitions;
-  readFiles = /* @__PURE__ */ new Set();
-  maxSteps;
-  // ponytail: one window for every model; read it from /v1/models metadata when providers expose it.
-  contextWindow;
-  systemPrompt;
-  setSystemPrompt(text) {
-    this.systemPrompt = text;
-  }
-  setTools(tools) {
-    this.tools = tools;
-    this.definitions = toolDefinitions(tools);
-  }
-  isParallelSafe(call) {
-    const tool = this.turnTools.find((t) => t.name === call.name);
-    if (!tool?.parallelSafe) return false;
-    try {
-      const parsed = tool.schema.safeParse(JSON.parse(call.arguments || "{}"));
-      return parsed.success && tool.parallelSafe(parsed.data);
-    } catch {
-      return false;
-    }
-  }
-  push(message) {
-    this.messages.push(message);
-    this.opts.onMessage?.(message);
-  }
-  /** Swaps in another conversation (resume, new session) without writing to the session log. */
-  load(messages) {
-    this.messages = messages;
-    this.readFiles.clear();
-    this.lastInputTokens = 0;
-  }
-  clear() {
-    this.messages = [];
-    this.readFiles.clear();
-    this.lastInputTokens = 0;
-    this.opts.onReset?.();
-  }
-  async compact(signal) {
-    const completion = await this.provider.chat({
-      messages: [{ role: "system", content: this.systemPrompt }, ...this.messages, { role: "user", content: COMPACT_PROMPT }],
-      // Some gateways reject tool_calls in history when no tools are declared.
-      tools: this.definitions,
-      signal
-    });
-    this.clear();
-    this.push({ role: "user", content: `Ringkasan percakapan sebelumnya:
-${completion.text}` });
-    this.push({ role: "assistant", content: "Oke, saya lanjutkan dari ringkasan ini." });
-    this.onEvent({ type: "compacted" });
-  }
-  async run(text, signal) {
-    this.turnTools = this.tools;
-    this.turnDefinitions = this.definitions;
-    this.opts.onTurnStart?.();
-    try {
-      if (this.lastInputTokens > this.contextWindow * 0.8) await this.compact(signal);
-      this.push({ role: "user", content: text });
-      for (let step = 0; step < this.maxSteps; step++) {
-        if (step > 0 && this.lastInputTokens > this.contextWindow * 0.8) {
-          await this.compact(signal);
-          this.push({ role: "user", content: `Lanjutkan tugas ini sesuai ringkasan di atas: ${text}` });
-        }
-        let completion = await this.provider.chat({
-          messages: [{ role: "system", content: this.systemPrompt }, ...this.messages],
-          tools: this.turnDefinitions,
-          signal,
-          onText: (delta) => this.onEvent({ type: "text", delta }),
-          onThinking: (delta) => this.onEvent({ type: "thinking", delta })
-        });
-        if (!completion.toolCalls.length && completion.finishReason !== "repetition") {
-          const recovered = recoverTextToolCalls(completion.text, this.turnDefinitions);
-          if (recovered) {
-            completion = { ...completion, ...recovered };
-            this.onEvent({ type: "textReplace", text: recovered.text });
-          }
-        }
-        const usage = completion.usage ?? {
-          inputTokens: estimateTokens(this.systemPrompt) + estimateTokens(JSON.stringify(this.messages)),
-          outputTokens: estimateTokens(completion.text) + (completion.toolCalls.length ? estimateTokens(JSON.stringify(completion.toolCalls)) : 0)
-        };
-        this.totalUsage.inputTokens += usage.inputTokens;
-        this.totalUsage.outputTokens += usage.outputTokens;
-        this.lastInputTokens = usage.inputTokens;
-        this.onEvent({ type: "usage", ...this.totalUsage });
-        this.push({
-          role: "assistant",
-          content: completion.text || null,
-          ...completion.toolCalls.length ? {
-            tool_calls: completion.toolCalls.map((c) => ({
-              id: c.id,
-              type: "function",
-              function: { name: c.name, arguments: c.arguments }
-            }))
-          } : {}
-        });
-        if (completion.finishReason === "repetition") {
-          this.onEvent({ type: "textReplace", text: completion.text });
-          this.onEvent({
-            type: "error",
-            message: "Model terjebak mengulang teks, jawaban dihentikan. Coba ulangi atau ganti model dengan /model."
-          });
-          return;
-        }
-        if (!completion.toolCalls.length) {
-          this.onEvent({ type: "done" });
-          return;
-        }
-        const calls = completion.toolCalls;
-        let i = 0;
-        while (i < calls.length) {
-          if (signal.aborted) {
-            for (const pending of calls.slice(i)) this.push({ role: "tool", tool_call_id: pending.id, content: "Dibatalkan oleh user." });
-            this.onEvent({ type: "aborted" });
-            return;
-          }
-          let j = i + 1;
-          if (this.isParallelSafe(calls[i])) while (j < calls.length && this.isParallelSafe(calls[j])) j++;
-          const batch = calls.slice(i, j);
-          const results = await Promise.all(batch.map((c) => this.runTool(c, signal)));
-          batch.forEach((c, k) => {
-            this.push({ role: "tool", tool_call_id: c.id, content: results[k] });
-          });
-          i = j;
-        }
-        if (signal.aborted) {
-          this.onEvent({ type: "aborted" });
-          return;
-        }
-      }
-      this.onEvent({ type: "stepLimit" });
-    } catch (error) {
-      if (signal.aborted) {
-        this.onEvent({ type: "aborted" });
-        return;
-      }
-      const message = error.message;
-      const noTools = error.status === 400 && /tool/i.test(message);
-      this.onEvent({
-        type: "error",
-        message: noTools ? `${message}
-Model ini sepertinya tidak mendukung tool calling. Coba model lain dengan /model.` : message
-      });
-    }
-  }
-  async runTool(call, signal) {
-    const fail = (output, target2 = "") => {
-      this.onEvent({ type: "toolStart", id: call.id, tool: call.name, target: target2 });
-      this.onEvent({ type: "toolEnd", id: call.id, tool: call.name, output, isError: true });
-      return output;
-    };
-    const tool = this.turnTools.find((t) => t.name === call.name);
-    if (!tool) return fail(`Alat "${call.name}" tidak ada. Alat yang tersedia: ${this.turnTools.map((t) => t.name).join(", ")}`);
-    let args;
-    try {
-      args = JSON.parse(call.arguments || "{}");
-    } catch {
-      return fail(`Argumen bukan JSON valid: ${call.arguments.slice(0, 200)}`);
-    }
-    const parsed = tool.schema.safeParse(args);
-    if (!parsed.success) {
-      return fail(`Argumen tidak valid: ${parsed.error.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`).join("; ")}`);
-    }
-    const input = parsed.data;
-    const target = tool.target(input);
-    const ctx = {
-      cwd: this.opts.cwd,
-      signal,
-      readFiles: this.readFiles,
-      callId: call.id,
-      emit: (event) => this.onEvent(event),
-      ask: (req) => this.askPermission(req),
-      checkpoint: this.opts.checkpoint,
-      addUsage: (u) => {
-        this.totalUsage.inputTokens += u.inputTokens;
-        this.totalUsage.outputTokens += u.outputTokens;
-        this.onEvent({ type: "usage", ...this.totalUsage });
-      }
-    };
-    this.onEvent({ type: "toolStart", id: call.id, tool: tool.name, target });
-    const invalid = await tool.validate?.(input, ctx).catch((error) => error.message);
-    if (invalid) {
-      this.onEvent({ type: "toolEnd", id: call.id, tool: tool.name, output: invalid, isError: true });
-      return invalid;
-    }
-    const request = { tool: tool.name, kind: tool.kind, target };
-    let decision = this.permissions.check(request);
-    if (decision === "ask") {
-      const preview = await tool.preview?.(input, ctx).catch(() => void 0);
-      const answer = await this.askPermission({
-        ...request,
-        preview,
-        sessionRules: this.permissions.rulesFor(request),
-        ...this.opts.label ? { agent: this.opts.label } : {}
-      });
-      if (answer === "session") this.permissions.allowForSession(request);
-      if (answer === "all") this.permissions.mode = "allowAll";
-      decision = answer === "no" ? "deny" : "allow";
-    }
-    if (decision === "deny") {
-      const output = this.permissions.mode === "plan" ? "Ditolak: mode plan hanya boleh membaca dan mencari. Susun rencana untuk user tanpa mengubah apa pun." : "User menolak menjalankan alat ini. Tanyakan ke user apa yang diinginkan, atau coba cara lain.";
-      this.onEvent({ type: "toolEnd", id: call.id, tool: tool.name, output, isError: true });
-      return output;
-    }
-    let result;
-    try {
-      result = await tool.run(input, ctx);
-    } catch (error) {
-      result = { output: `Error: ${error.message}`, isError: true };
-    }
-    this.onEvent({ type: "toolEnd", id: call.id, tool: tool.name, output: result.output, display: result.display, isError: !!result.isError });
-    return result.output;
-  }
-};
-
-// src/checkpoints.ts
-import { existsSync as existsSync2, statSync } from "fs";
-import { readFile as readFile5, rm, writeFile as writeFile3 } from "fs/promises";
-var MAX_TURNS = 20;
-var MAX_BYTES2 = 2 * 1024 * 1024;
-var CheckpointStore = class {
-  history = [];
-  current;
-  beginTurn() {
-    if (this.current?.size === 0) return;
-    this.current = /* @__PURE__ */ new Map();
-    this.history.push(this.current);
-  }
-  /** Call before writing a file; only the first snapshot per file per turn is kept. */
-  async snapshot(path) {
-    if (!this.current) this.beginTurn();
-    const turn = this.current;
-    if (turn.has(path)) return;
-    if (!existsSync2(path)) turn.set(path, null);
-    else if (statSync(path).size > MAX_BYTES2) turn.set(path, "skipped");
-    else turn.set(path, await readFile5(path));
-    while (this.turns() > MAX_TURNS) this.history.shift();
-  }
-  turns() {
-    return this.history.filter((t) => t.size).length;
-  }
-  async undo() {
-    while (this.history.length && !this.history.at(-1)?.size) this.history.pop();
-    const turn = this.history.pop();
-    this.current = void 0;
-    if (!turn) return void 0;
-    const result = { restored: [], deleted: [], skipped: [], failed: [] };
-    for (const [path, original] of turn) {
-      try {
-        if (original === "skipped") result.skipped.push(path);
-        else if (original === null) {
-          await rm(path, { force: true });
-          result.deleted.push(path);
-        } else {
-          await writeFile3(path, original);
-          result.restored.push(path);
-        }
-      } catch {
-        result.failed.push(path);
-      }
-    }
-    return result;
-  }
-  clear() {
-    this.history.length = 0;
-    this.current = void 0;
-  }
-};
-
-// src/mcp/manager.ts
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import { z as z9 } from "zod";
-function mcpToolName(server, tool, taken) {
-  const clean = (s) => s.replace(/[^A-Za-z0-9_-]+/g, "_");
-  const base = `mcp__${clean(server)}__${clean(tool)}`.slice(0, 64);
-  let name = base;
-  for (let n = 2; taken.has(name); n++) name = `${base.slice(0, 64 - String(n).length - 1)}_${n}`;
-  taken.add(name);
-  return name;
-}
-function withTimeout(promise, ms) {
-  let timer;
-  const timeout = new Promise((_, reject) => {
-    timer = setTimeout(() => reject(new Error(`timeout ${Math.round(ms / 1e3)} detik`)), ms);
-  });
-  return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
-}
-var McpManager = class {
-  constructor(opts = {}) {
-    this.opts = opts;
-  }
-  opts;
-  servers = /* @__PURE__ */ new Map();
-  taken = /* @__PURE__ */ new Set();
-  async start(specs) {
-    await Promise.all(specs.map((spec) => this.add(spec)));
-  }
-  async add(spec) {
-    await this.remove(spec.name);
-    const entry = { spec, state: { name: spec.name, source: spec.source, status: "starting", tools: 0 }, tools: [] };
-    this.servers.set(spec.name, entry);
-    this.opts.onChange?.();
-    const client = new Client({ name: "bccli", version: "0.3.0" });
-    entry.client = client;
-    const timeoutMs = this.opts.connectTimeoutMs ?? 3e4;
-    try {
-      const config = spec.config;
-      const transport = config.type === "http" ? new StreamableHTTPClientTransport(new URL(config.url), { requestInit: { headers: config.headers ?? {} } }) : new StdioClientTransport({
-        command: config.command,
-        args: config.args ?? [],
-        env: { ...process.env, ...config.env },
-        stderr: "ignore"
-      });
-      await withTimeout(client.connect(transport), timeoutMs);
-      const { tools } = await withTimeout(client.listTools(), timeoutMs);
-      if (this.servers.get(spec.name) !== entry) {
-        await client.close().catch(() => {
-        });
-        return;
-      }
-      entry.tools = tools.map((t) => this.wrap(spec.name, client, t));
-      entry.state = { ...entry.state, status: "ready", tools: entry.tools.length };
-    } catch (error) {
-      entry.state = { ...entry.state, status: "error", error: error.message };
-      await client.close().catch(() => {
-      });
-      if (this.servers.get(spec.name) !== entry) return;
-    }
-    this.opts.onChange?.();
-  }
-  wrap(server, client, tool) {
-    return {
-      name: mcpToolName(server, tool.name, this.taken),
-      description: `[MCP ${server}] ${tool.description ?? tool.name}`.slice(0, 1024),
-      schema: z9.record(z9.string(), z9.unknown()),
-      jsonSchema: tool.inputSchema,
-      kind: "mcp",
-      target: (input) => {
-        const text = JSON.stringify(input);
-        return text.length > 80 ? `${text.slice(0, 77)}\u2026` : text;
-      },
-      async run(input, ctx) {
-        try {
-          const result = await client.callTool({ name: tool.name, arguments: input }, void 0, { signal: ctx.signal });
-          const output = (result.content ?? []).map((c) => c.type === "text" ? c.text ?? "" : `[${c.type}]`).join("\n") || "(kosong)";
-          return { output: output.length > 5e4 ? `${output.slice(0, 5e4)}
-\u2026 [dipotong]` : output, isError: !!result.isError };
-        } catch (error) {
-          return { output: `Server MCP ${server} error: ${error.message}`, isError: true };
-        }
-      }
-    };
-  }
-  async remove(name) {
-    const entry = this.servers.get(name);
-    if (!entry) return;
-    this.servers.delete(name);
-    for (const t of entry.tools) this.taken.delete(t.name);
-    if (entry.tools.length) this.opts.onToolsRemoved?.(entry.tools.map((t) => t.name));
-    await entry.client?.close().catch(() => {
-    });
-    this.opts.onChange?.();
-  }
-  tools() {
-    return [...this.servers.values()].flatMap((s) => s.tools);
-  }
-  states() {
-    return [...this.servers.values()].map((s) => s.state);
-  }
-  async stop() {
-    await Promise.all([...this.servers.keys()].map((name) => this.remove(name)));
-  }
-};
-
-// src/setup.ts
-import { homedir } from "os";
-
-// src/tools/plan.ts
-import { z as z10 } from "zod";
-function createExitPlanTool(opts) {
-  return defineTool({
-    name: "exit_plan",
-    description: "Plan mode only: present the finished plan to the user for approval. If approved you may start implementing it.",
-    schema: z10.object({ plan: z10.string().describe("The plan, in markdown") }),
-    kind: "read",
-    target: () => "rencana",
-    async run(input) {
-      if (opts.permissions.mode !== "plan") return { output: "exit_plan hanya dipakai di mode plan.", isError: true };
-      const decision = await opts.interaction.approvePlan(input.plan);
-      if (decision === "no") {
-        return { output: "User belum menyetujui. Tanyakan apa yang perlu diperbaiki, perbaiki rencananya, lalu panggil exit_plan lagi." };
-      }
-      opts.permissions.mode = decision;
-      return { output: `Rencana disetujui. Mode sekarang ${decision}. Mulai kerjakan rencananya sekarang.` };
-    }
-  });
-}
-
-// src/tools/skill.ts
-import { readFileSync } from "fs";
-import { z as z11 } from "zod";
-function createSkillTool(skills) {
-  return defineTool({
-    name: "skill",
-    description: "Load a skill (instructions for a kind of task) by name. Use it when a listed skill matches the task, then follow it.",
-    schema: z11.object({ name: z11.string().describe("Skill name from the list in the system prompt") }),
-    kind: "read",
-    target: (input) => input.name,
-    async run(input) {
-      const skill = skills.find((s) => s.name === input.name);
-      if (!skill) return { output: `Skill "${input.name}" tidak ada. Tersedia: ${skills.map((s) => s.name).join(", ") || "(tidak ada)"}`, isError: true };
-      const { body } = parseFrontmatter(readFileSync(skill.file, "utf8"));
-      return { output: `Base directory for this skill: ${skill.dir}
-
-${body}`, display: skill.description.slice(0, 60) };
-    }
-  });
-}
-
-// src/tools/task.ts
-import { z as z12 } from "zod";
-function createTaskTool(opts) {
-  const byName = new Map(opts.agents.map((a) => [a.name, a]));
-  const list = opts.agents.map((a) => `- ${a.name}: ${a.description}`).join("\n");
-  return defineTool({
-    name: "task",
-    description: `Delegate a self-contained sub-task to a subagent. It starts with an empty context and returns only its final report. Available agents:
-${list}`,
-    schema: z12.object({
-      agent: z12.string().describe("Agent name"),
-      description: z12.string().describe("3-6 word summary shown to the user"),
-      prompt: z12.string().describe("Full instructions; the subagent sees nothing else")
-    }),
-    kind: "read",
-    target: (input) => `[${input.agent}] ${input.description}`,
-    // Parallel only when the resolved agent can do nothing but read (a project file may redefine "explore").
-    parallelSafe: (input) => {
-      const allowed = byName.get(input.agent)?.tools;
-      if (!allowed) return false;
-      const base = opts.baseTools();
-      return allowed.every((name) => base.find((t) => t.name === name)?.kind === "read");
-    },
-    async run(input, ctx) {
-      const def = byName.get(input.agent);
-      if (!def) return { output: `Agent "${input.agent}" tidak ada. Tersedia: ${[...byName.keys()].join(", ")}`, isError: true };
-      const base = opts.baseTools().filter((t) => t.name !== "task" && t.name !== "exit_plan");
-      const unknown = (def.tools ?? []).filter((n) => !base.some((t) => t.name === n));
-      if (unknown.length) return { output: `Agent "${def.name}": alat tidak dikenal: ${unknown.join(", ")}`, isError: true };
-      const allowed = def.tools;
-      const tools = allowed ? base.filter((t) => allowed.includes(t.name)) : base;
-      let provider;
-      try {
-        provider = def.model ? opts.providerFor(def.model) : opts.provider();
-      } catch (error) {
-        return { output: `Agent "${def.name}": ${error.message}`, isError: true };
-      }
-      const child = new Agent({
-        provider,
-        tools,
-        permissions: opts.permissions,
-        systemPrompt: `${opts.systemPrompt}
-
-# Your role
-${def.prompt}`,
-        cwd: opts.cwd,
-        maxSteps: def.maxSteps ?? 50,
-        label: def.name,
-        // Subagent edits belong to the parent's turn so /undo reverts them too.
-        checkpoint: ctx.checkpoint
-      });
-      let outcome;
-      let steps = 0;
-      child.onEvent = (event) => {
-        if (event.type === "toolStart") steps++;
-        if (event.type === "error" || event.type === "stepLimit" || event.type === "aborted" || event.type === "done") outcome = event;
-        if (event.type !== "usage" && ctx.callId) ctx.emit?.({ type: "subagent", parentId: ctx.callId, agent: def.name, event });
-      };
-      if (ctx.ask) child.askPermission = ctx.ask;
-      await child.run(input.prompt, ctx.signal);
-      ctx.addUsage?.(child.totalUsage);
-      const tokens = child.totalUsage.inputTokens + child.totalUsage.outputTokens;
-      const display = `${steps} langkah \xB7 ${tokens >= 1e3 ? `${Math.round(tokens / 1e3)}k` : tokens} token`;
-      if (outcome?.type === "error") return { output: `Subagent ${def.name} gagal: ${outcome.message}`, isError: true, display };
-      if (outcome?.type === "aborted") return { output: `Subagent ${def.name} dibatalkan.`, isError: true, display };
-      const last = [...child.messages].reverse().find((m) => m.role === "assistant" && m.content);
-      const report = last && typeof last.content === "string" ? last.content : "(tidak ada laporan)";
-      const suffix = outcome?.type === "stepLimit" ? `
-
-(Subagent berhenti di batas ${def.maxSteps ?? 50} langkah.)` : "";
-      return { output: report + suffix, display };
-    }
-  });
-}
-
-// src/tools/todo.ts
-import { z as z13 } from "zod";
-var TodoStore = class {
-  items = [];
-  listeners = /* @__PURE__ */ new Set();
-  set(items) {
-    this.items = items;
-    for (const fn of this.listeners) fn(items);
-  }
-  subscribe(fn) {
-    this.listeners.add(fn);
-    return () => this.listeners.delete(fn);
-  }
-};
-function createTodoTool(store) {
-  return defineTool({
-    name: "todo_write",
-    description: "Write the task list for multi-step work (3+ steps). Send the whole list every time; exactly one item in_progress while working. Mark items completed as soon as they are done.",
-    schema: z13.object({
-      todos: z13.array(z13.object({ content: z13.string(), status: z13.enum(["pending", "in_progress", "completed"]) }))
-    }),
-    kind: "read",
-    target: (input) => `${input.todos.length} item`,
-    async run(input) {
-      if (input.todos.filter((t) => t.status === "in_progress").length > 1) {
-        return { output: "Hanya boleh satu item in_progress.", isError: true };
-      }
-      store.set(input.todos);
-      const done = input.todos.filter((t) => t.status === "completed").length;
-      return { output: `Todo diperbarui: ${done}/${input.todos.length} selesai.` };
-    }
-  });
-}
-
-// src/setup.ts
-var TOOL_RULES = { bash: "bash", edit: "edit", write: "edit", fetch: "fetch" };
-function createRuntime(opts) {
-  const env = opts.env ?? process.env;
-  const home = bccliHome(env);
-  let config = loadConfig(opts.cwd, env);
-  let modelRef = opts.args.model ?? config.model;
-  const makeProvider = (ref) => {
-    const resolved = resolveModel(config, ref, env);
-    return opts.provider ?? createProvider({ baseURL: resolved.baseURL, apiKey: resolved.apiKey, model: resolved.model });
-  };
-  const provider = makeProvider(modelRef);
-  const mode = opts.args.allowAll ? "allowAll" : opts.args.permissionMode ?? config.permissionMode;
-  const rules = [...config.allow, ...opts.args.allowedTools.map((t) => TOOL_RULES[t] ?? t)];
-  const permissions = new Permissions(mode, rules, opts.cwd);
-  const roots = { cwd: opts.cwd, home, userHome: opts.userHome ?? homedir() };
-  const skills = loadSkills(roots);
-  const commands = loadCommands(roots);
-  const agentDefs = loadAgentDefs(roots);
-  const todos = new TodoStore();
-  const checkpoints = new CheckpointStore();
-  let startedAt = /* @__PURE__ */ new Date();
-  const interaction = { approvePlan: async () => "no" };
-  let session = Session.create(home, opts.cwd);
-  let history = opts.history;
-  if (!history && opts.args.continue) {
-    const latest = Session.latest(home, opts.cwd);
-    if (latest) {
-      session = latest;
-      history = latest.load();
-    }
-  }
-  const systemPrompt = buildSystemPrompt({ cwd: opts.cwd, home, model: modelRef, skills });
-  const baseTools = [...ALL_TOOLS, createSkillTool(skills), createTodoTool(todos), createExitPlanTool({ permissions, interaction })];
-  const task = createTaskTool({
-    agents: [...BUILTIN_AGENTS, ...agentDefs],
-    // Subagents get whatever the main agent has right now (incl. MCP tools), minus task itself.
-    baseTools: () => agent.tools.filter((t) => t.name !== "task"),
-    permissions,
-    provider: () => agent.provider,
-    providerFor: makeProvider,
-    systemPrompt,
-    cwd: opts.cwd
-  });
-  const agent = new Agent({
-    provider,
-    tools: [...baseTools, task],
-    permissions,
-    systemPrompt,
-    cwd: opts.cwd,
-    history,
-    onMessage: (m) => session.append(m),
-    onReset: () => session.reset(),
-    onTurnStart: () => checkpoints.beginTurn(),
-    checkpoint: (path) => checkpoints.snapshot(path)
-  });
-  const mcp = new McpManager({
-    onChange: () => agent.setTools([...baseTools, task, ...mcp.tools()]),
-    // A later server may reuse a sanitized name; it must not inherit this one's "[a]" grants.
-    onToolsRemoved: (names) => {
-      for (const name of names) permissions.revoke(`mcp(${name})`);
-    }
-  });
-  return {
-    cwd: opts.cwd,
-    home,
-    env,
-    skills,
-    commands,
-    agentDefs,
-    todos,
-    interaction,
-    mcp,
-    startMcp: (specs) => mcp.start(specs),
-    get config() {
-      return config;
-    },
-    reloadConfig() {
-      config = loadConfig(opts.cwd, env);
-    },
-    providerLabel() {
-      return providerName(config, modelRef.slice(0, modelRef.indexOf("/")));
-    },
-    listModels: (only) => listAllModels(config, env, { fetch: opts.fetch, only }),
-    addProviderKey(id, key) {
-      return addProviderKey(id, key, { env, cwd: opts.cwd, out: () => {
-      }, err: () => {
-      }, readSecret: async () => "", fetch: opts.fetch });
-    },
-    get modelRef() {
-      return modelRef;
-    },
-    agent,
-    get session() {
-      return session;
-    },
-    resume(previous) {
-      session = previous;
-      agent.load(previous.load());
-      agent.totalUsage = { inputTokens: 0, outputTokens: 0 };
-      todos.set([]);
-      checkpoints.clear();
-    },
-    newSession() {
-      session = Session.create(home, opts.cwd);
-      agent.load([]);
-      agent.totalUsage = { inputTokens: 0, outputTokens: 0 };
-      todos.set([]);
-      checkpoints.clear();
-      startedAt = /* @__PURE__ */ new Date();
-    },
-    rebuildSystemPrompt() {
-      agent.setSystemPrompt(buildSystemPrompt({ cwd: opts.cwd, home, model: modelRef, skills }));
-    },
-    checkpoints,
-    get startedAt() {
-      return startedAt;
-    },
-    setModel(ref) {
-      agent.provider = makeProvider(ref);
-      modelRef = ref;
-    }
-  };
-}
-
-// src/version.ts
-var VERSION = true ? "0.4.0-beta.5" : "0.0.0-dev";
-
-// src/cli.ts
 async function main() {
+  chooseLanguage(process.argv.slice(2));
   const args = parseCliArgs(process.argv.slice(2));
   if (args.version) {
     console.log(VERSION);
     return 0;
   }
   if (args.help) {
-    console.log(HELP_TEXT);
+    console.log(helpText());
     return 0;
   }
-  const cwd = process.cwd();
-  if (args.command === "login") return runLogin(args.loginProvider ?? "bc-cloud", cwd);
+  let cwd = process.cwd();
+  if (args.worktree) cwd = (await resolveWorktree(cwd, args.worktree)).path;
+  if (args.command === "login") return runLogin(args.loginProvider ?? "bc-cloud", cwd, args, defaultLoginDeps());
   if (args.command === "mcp") {
-    const { runMcpCommand } = await import("./mcpCli-Q2H63ISP.js");
-    const { readSecret } = await import("./login-F4G5QXOU.js");
+    const { runMcpCommand } = await import("./mcpCli-5QISTOFK.js");
+    const { readSecret } = await import("./login-W4Y6WHLV.js");
     return runMcpCommand(args, { env: process.env, cwd, out: (s) => console.log(s), err: (s) => console.error(s), readSecret });
   }
   if (args.command === "provider") {
-    const { runProviderCommand } = await import("./providerCli-MXV6PD6F.js");
-    const { readSecret } = await import("./login-F4G5QXOU.js");
+    const { runProviderCommand } = await import("./providerCli-EUZGKP5F.js");
+    const { readSecret } = await import("./login-W4Y6WHLV.js");
     return runProviderCommand(args, { env: process.env, cwd, out: (s) => console.log(s), err: (s) => console.error(s), readSecret });
   }
+  if (args.command === "connect" || args.command === "disconnect" || args.command === "integrations") {
+    const { runIntegrationCommand } = await import("./integrationCli-ZMTSILYF.js");
+    return runIntegrationCommand(args, {
+      env: process.env,
+      cwd,
+      out: (s) => console.log(s),
+      err: (s) => console.error(s),
+      fetch: globalThis.fetch
+    });
+  }
   if (args.command === "models") {
-    const config = loadConfig(cwd);
-    const resolved = resolveModel(config, args.model ?? config.model);
-    const models = await createProvider(resolved).listModels();
-    console.log(models.map((m) => `${resolved.providerId}/${m}`).join("\n"));
+    const { runModelsCommand } = await import("./modelsCli-FZMBD4OE.js");
+    return runModelsCommand(args, { env: process.env, cwd, out: (s) => console.log(s), err: (s) => console.error(s), fetch: globalThis.fetch });
+  }
+  if (args.command === "update") {
+    const { runUpdateCommand } = await import("./update-O4WCLKOO.js");
+    return runUpdateCommand({ env: process.env });
+  }
+  if (args.command === "acp") {
+    const { runtimeAgent, runAcp } = await import("./acp-NWP4FFTG.js");
+    await runAcp(process.stdin, process.stdout, { cwd, newAgent: (c) => runtimeAgent(c, args.allowAll) });
+    return 0;
+  }
+  if (args.command === "serve") {
+    const { startServe } = await import("./serve-YSUJD57D.js");
+    const handle = await startServe({ port: args.port, host: args.host, token: args.token, cwd, env: process.env });
+    process.stderr.write(`bccli serve ${handle.url} \u2014 Authorization: Bearer ${handle.token}
+`);
+    await new Promise((resolve) => {
+      const stop = () => {
+        void handle.close().finally(resolve);
+      };
+      process.once("SIGINT", stop);
+      process.once("SIGTERM", stop);
+    });
     return 0;
   }
+  if (args.command === "plugins") {
+    const { runPluginsCommand } = await import("./pluginsCli-GEHR7FQR.js");
+    const { readGlobalPlugins, updateGlobalConfig } = await import("./config-H5A7XHHK.js");
+    const { runNpmSync } = await import("./npmRunner-LU43GM3W.js");
+    return runPluginsCommand(args, {
+      out: (s) => console.log(s),
+      err: (s) => console.error(s),
+      env: process.env,
+      runNpm: async (prefix, argv) => runNpmSync(prefix, argv),
+      readPlugins: () => readGlobalPlugins(process.env),
+      savePlugins: (entries) => updateGlobalConfig(process.env, (cfg) => {
+        cfg.plugins = entries;
+      })
+    });
+  }
+  if (args.command === "gh-bot") {
+    const { runGhBotCommand } = await import("./ghBotCli-7WDYF4L7.js");
+    return runGhBotCommand(args, { env: process.env, cwd, out: (s) => console.log(s), err: (s) => console.error(s) });
+  }
+  if (args.command === "completion") {
+    const { runCompletionCommand } = await import("./completion-OV3MW2N4.js");
+    return runCompletionCommand(args, { out: (s) => console.log(s), err: (s) => console.error(s) });
+  }
+  if (args.command === "stats") {
+    const { runStatsCommand } = await import("./statsCli-H4HEY5ID.js");
+    const { bccliHome } = await import("./config-H5A7XHHK.js");
+    return runStatsCommand(
+      { subArgs: args.subArgs, home: bccliHome(process.env), cwd, days: args.days, tools: args.tools, models: args.models, project: args.project },
+      { out: (s) => console.log(s), err: (s) => console.error(s) }
+    );
+  }
+  if (args.command === "export" || args.command === "import") {
+    const { runExportCommand, runImportCommand } = await import("./transferCli-2XUKBG2L.js");
+    const { bccliHome } = await import("./config-H5A7XHHK.js");
+    const deps = { subArgs: args.subArgs, home: bccliHome(process.env), cwd };
+    const io = { out: (s) => console.log(s), err: (s) => console.error(s) };
+    return args.command === "export" ? runExportCommand(deps, io) : runImportCommand(deps, io);
+  }
+  if (args.command === "pr") {
+    const { runPrCommand } = await import("./prCli-JXA7DJW4.js");
+    return runPrCommand({ subArgs: args.subArgs, cwd }, { out: (s) => console.log(s), err: (s) => console.error(s) });
+  }
   const rt = createRuntime({ cwd, args });
+  setTheme(rt.config.theme);
   try {
-    pruneSessions(rt.home);
+    if (rt.config.sessionRetentionDays) pruneSessions(rt.home, Date.now(), rt.config.sessionRetentionDays);
   } catch {
   }
   if (args.print) {
-    if (!args.prompt) throw new ConfigError('Mode -p butuh tugas, contoh: bccli -p "jelaskan repo ini"');
-    const { serversToStart } = await import("./config-NPSYFAFD.js");
+    if (!args.prompt) throw new ConfigError(t('-p mode needs a task, e.g. bccli -p "explain this repo"'));
+    const { serversToStart } = await import("./config-AZZFOXKV.js");
     const plan = serversToStart(rt.home, cwd);
     for (const s of plan.needTrust) {
-      console.error(`Server MCP project "${s.name}" dilewati (belum diizinkan; jalankan bccli interaktif sekali untuk menyetujuinya).`);
+      console.error(t('Project MCP server "{name}" skipped (not approved yet; run interactive bccli once to approve it).', { name: s.name }));
     }
     await rt.startMcp(plan.start);
     try {
-      return await runPrint(rt, args.prompt, void 0, { allowAll: args.allowAll });
+      return await runPrint(rt, args.prompt, void 0, { allowAll: args.allowAll, outputFormat: args.outputFormat });
     } finally {
       await rt.mcp.stop();
     }
   }
-  if (!process.stdin.isTTY) throw new ConfigError('Mode interaktif butuh terminal. Untuk skrip/CI pakai: bccli -p "tugas"');
-  const { startInteractive } = await import("./ui-RYTSKEIA.js");
+  if (!process.stdin.isTTY) throw new ConfigError(t('Interactive mode needs a terminal. For scripts/CI use: bccli -p "task"'));
+  if (rt.config.updateCheck !== "off" && !process.env.BCCLI_NO_UPDATE_CHECK) {
+    try {
+      const { checkForUpdate } = await import("./update-O4WCLKOO.js");
+      const update = await checkForUpdate({ home: rt.home, fetch: globalThis.fetch, now: /* @__PURE__ */ new Date() });
+      if (update) console.error(update);
+    } catch {
+    }
+  }
+  const { startInteractive } = await import("./ui-6HJVYI46.js");
   return startInteractive(rt, { initialPrompt: args.prompt, resume: args.resume, version: VERSION });
 }
 main().then(
-  (code) => process.exit(code),
+  (code) => settleExit(code),
   (error) => {
     console.error(error instanceof ConfigError || error?.code === "ERR_PARSE_ARGS_UNKNOWN_OPTION" ? error.message : error);
-    process.exit(1);
+    settleExit(1);
   }
 );