@botconnector/bccli 0.4.0-beta.36 → 0.4.0-beta.38

package/dist/chunk-HXSREA7S.js

@@ -0,0 +1,785 @@
+#!/usr/bin/env node
+import {
+  ConfigError
+} from "./chunk-H5N4ST6B.js";
+import {
+  t
+} from "./chunk-4RMP4CNT.js";
+
+// src/hooks.ts
+import { spawn } from "child_process";
+var DEFAULT_TIMEOUT_MS = 1e4;
+var MAX_CAPTURE = 8192;
+function globToRegExp(pattern) {
+  const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/\\\*/g, ".*");
+  return new RegExp(`^${escaped}$`);
+}
+function runOne(command, event, payload, opts) {
+  const env = {
+    ...process.env,
+    ...opts.env,
+    BCCLI_HOOK_EVENT: event,
+    ...payload.tool !== void 0 ? { BCCLI_HOOK_TOOL: payload.tool } : {},
+    ...payload.input !== void 0 ? { BCCLI_HOOK_INPUT: JSON.stringify(payload.input) } : {},
+    ...payload.output !== void 0 ? { BCCLI_HOOK_OUTPUT: payload.output } : {}
+  };
+  return new Promise((resolve) => {
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    let settled = false;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(result);
+    };
+    let child;
+    try {
+      child = spawn(command, { shell: true, env, cwd: opts.cwd ?? process.cwd(), stdio: ["ignore", "pipe", "pipe"] });
+    } catch (error) {
+      resolve({ failure: error.message });
+      return;
+    }
+    const timer = setTimeout(() => {
+      timedOut = true;
+      child.kill();
+    }, opts.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+    child.stdout?.on("data", (chunk) => {
+      if (stdout.length < MAX_CAPTURE) stdout += String(chunk);
+    });
+    child.stderr?.on("data", (chunk) => {
+      if (stderr.length < MAX_CAPTURE) stderr += String(chunk);
+    });
+    child.on("error", (error) => finish({ failure: error.message }));
+    child.on("close", (code) => {
+      if (timedOut) {
+        finish({ failure: "timed out" });
+        return;
+      }
+      if (event === "PreToolUse" && code === 2) {
+        finish({ blocked: stderr.trim() || stdout.trim() || "Blocked by a PreToolUse hook." });
+        return;
+      }
+      if (code !== 0) {
+        const detail = stderr.trim().split("\n")[0];
+        finish({ failure: detail ? `exit ${code}: ${detail}` : `exit ${code}` });
+        return;
+      }
+      finish({});
+    });
+  });
+}
+async function runHooks(hooks, event, payload = {}, opts = {}) {
+  const rules = hooks?.[event];
+  if (!Array.isArray(rules) || rules.length === 0) return { warnings: [] };
+  const warnings = [];
+  let blocked;
+  for (const rule of rules) {
+    if (!rule || typeof rule.command !== "string" || rule.command.length === 0) continue;
+    if (payload.tool !== void 0 && rule.match && !globToRegExp(rule.match).test(payload.tool)) continue;
+    const result = await runOne(rule.command, event, payload, opts);
+    if (result.blocked) {
+      blocked = result.blocked;
+      break;
+    }
+    if (result.failure) warnings.push(t("Hook {event} failed: {reason}", { event, reason: result.failure }));
+  }
+  return { blocked, warnings };
+}
+
+// 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;
+  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 (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 "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);
+  } 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 list2 = await git(cwd, ["worktree", "list", "--porcelain"], bin);
+  if (!list2.ok) throw new ConfigError(t("This folder is not a git repository, so -w cannot create a worktree."));
+  const entries = worktreeEntries(list2.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 list2 = await git(cwd, ["worktree", "list", "--porcelain"], bin);
+  if (!list2.ok) return t("This folder is not a git repository, so there is no diff.");
+  const rows = worktreeEntries(list2.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");
+}
+
+// src/tools/bash.ts
+import { spawn as spawn2 } from "child_process";
+import { z } from "zod";
+
+// src/tools/types.ts
+function defineTool(tool) {
+  return tool;
+}
+
+// src/tools/bash.ts
+var HALF = 15e3;
+function killProcessTree(pid, platform = process.platform, spawnFn = spawn2) {
+  if (platform === "win32") {
+    const killer = spawnFn("taskkill", ["/pid", String(pid), "/T", "/F"]);
+    killer.on("error", () => {
+      try {
+        process.kill(pid);
+      } catch {
+      }
+    });
+    return;
+  }
+  try {
+    process.kill(-pid, "SIGKILL");
+  } catch {
+    try {
+      process.kill(pid, "SIGKILL");
+    } catch {
+    }
+  }
+}
+var active = /* @__PURE__ */ new Set();
+var exitHookInstalled = false;
+function killAllCommands() {
+  for (const kill of active) kill();
+  for (const task of backgrounds.values()) if (task.status === "running") task.kill();
+}
+var backgrounds = /* @__PURE__ */ new Map();
+var nextBackgroundId = 1;
+function startBackground(command, cwd, env) {
+  const child = spawn2(command, {
+    cwd,
+    shell: true,
+    detached: process.platform !== "win32",
+    stdio: ["ignore", "pipe", "pipe"],
+    env
+  });
+  const task = {
+    id: nextBackgroundId++,
+    command,
+    startedAt: Date.now(),
+    status: "running",
+    killed: false,
+    exitCode: null,
+    head: "",
+    tail: "",
+    dropped: 0,
+    kill: () => {
+    }
+  };
+  task.kill = () => {
+    if (task.status !== "running") return;
+    task.killed = true;
+    if (child.pid !== void 0) killProcessTree(child.pid);
+  };
+  backgrounds.set(task.id, task);
+  const onData = (data) => {
+    let s = data;
+    if (task.head.length < HALF) {
+      const take = s.slice(0, HALF - task.head.length);
+      task.head += take;
+      s = s.slice(take.length);
+    }
+    if (s) {
+      task.tail += s;
+      if (task.tail.length > HALF) {
+        task.dropped += task.tail.length - HALF;
+        task.tail = task.tail.slice(-HALF);
+      }
+    }
+  };
+  child.stdout?.setEncoding("utf8");
+  child.stderr?.setEncoding("utf8");
+  child.stdout?.on("data", onData);
+  child.stderr?.on("data", onData);
+  child.on("error", (error) => {
+    task.status = "exited";
+    task.head += `${task.head ? "\n" : ""}${error.message}`;
+  });
+  child.on("close", (code) => {
+    task.status = "exited";
+    task.exitCode = code;
+  });
+  return task;
+}
+function backgroundStatus(task) {
+  if (task.status === "running") return `[running ${Math.round((Date.now() - task.startedAt) / 1e3)}s]`;
+  if (task.killed) return "[killed]";
+  return `[exit code ${task.exitCode}]`;
+}
+function backgroundOutput(task) {
+  const body = task.dropped ? `${task.head}
+\u2026 [${task.dropped} characters truncated] \u2026
+${task.tail}` : task.head + task.tail;
+  return `${body.trimEnd()}
+${backgroundStatus(task)}`.trimStart();
+}
+function renderBackgroundTasks() {
+  if (!backgrounds.size) return "No background tasks.";
+  const lines = [...backgrounds.values()].sort((a, b) => a.id - b.id).flatMap((task) => {
+    const output = backgroundOutput(task);
+    const tailLines = output.split("\n").slice(-6);
+    return [`#${task.id} ${backgroundStatus(task)}  ${task.command}`, ...tailLines.map((line) => `    ${line}`)];
+  });
+  return `Background tasks:
+${lines.join("\n")}`;
+}
+var NETWORK_PATTERNS = [
+  /\b(curl|wget|ftp|scp|sftp|rsync|lynx|telnet)\b/i,
+  /\bssh\b/i,
+  /\b(Invoke-WebRequest|Invoke-RestMethod|iwr|irm)\b/i,
+  /\bgit\s+(clone|fetch|pull|push|remote|ls-remote|submodule|request-pull)\b/i,
+  /\b(npm|pnpm|yarn|bun)\s+(install|ci|add|update|upgrade|publish|dist-tag)\b/i,
+  /\b(pip3?|pipx)\s+install\b/i,
+  /\b(uv|poetry|conda)\s+(pip\s+)?(install|add|update|upgrade)\b/i,
+  /\bcargo\s+(install|publish|search)\b/i,
+  /\bgo\s+(get|install|mod\s+download)\b/i,
+  /\b(docker|podman)\s+(pull|push)\b/i,
+  /\bgh\s+(pr|repo|release|run|api|auth|browse|search|issue|gist|status)\b/i,
+  /\b(apt|apt-get|yum|dnf|pacman|brew|choco|winget|scoop)\s+(install|update|upgrade|add)\b/i,
+  /\bterraform\s+(init|get)\b/i
+];
+function needsNetwork(command) {
+  return NETWORK_PATTERNS.some((pattern) => pattern.test(command));
+}
+function offlineEnv(env = process.env) {
+  const dead = "http://127.0.0.1:9";
+  return {
+    ...env,
+    HTTP_PROXY: dead,
+    HTTPS_PROXY: dead,
+    ALL_PROXY: dead,
+    NO_PROXY: "",
+    http_proxy: dead,
+    https_proxy: dead,
+    all_proxy: dead,
+    no_proxy: ""
+  };
+}
+function runCommand(command, opts) {
+  return new Promise((resolve) => {
+    const child = spawn2(command, {
+      cwd: opts.cwd,
+      shell: true,
+      detached: process.platform !== "win32",
+      stdio: ["ignore", "pipe", "pipe"],
+      env: opts.env
+    });
+    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} characters truncated] \u2026
+${tail}` : head + tail;
+      resolve({ output: output + extra, exitCode, timedOut, aborted });
+    };
+    child.on("error", (error) => finish(null, error.message));
+    child.on("close", (code) => finish(code));
+  });
+}
+var 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. Set background: true for long-running jobs, then poll with task_id (stop with kill: true) or use the /tasks command.";
+var BASH_SCHEMA = z.object({
+  command: z.string().optional().describe("The shell command to run (required unless task_id is set)"),
+  timeout_ms: z.number().int().min(1e3).max(6e5).optional().describe("Timeout in milliseconds"),
+  background: z.boolean().optional().describe("Start the command in the background and return its task id immediately"),
+  task_id: z.number().int().optional().describe("Poll a background task started with background: true (omit command)"),
+  kill: z.boolean().optional().describe("With task_id: stop the background task")
+});
+function createBashTool(options = {}) {
+  const offline = options.networkPolicy === "offline";
+  const childEnv = offline ? offlineEnv() : void 0;
+  const description = offline ? `${BASH_DESCRIPTION}
+Network access is off (networkPolicy "offline"): internet commands such as curl, wget, git fetch/push/clone, package installs (npm, pip, ...), gh, and docker pull are blocked.` : BASH_DESCRIPTION;
+  return defineTool({
+    name: "bash",
+    description,
+    schema: BASH_SCHEMA,
+    kind: "bash",
+    target: (input) => input.command ?? (input.task_id !== void 0 ? `#${input.task_id}` : "(no command)"),
+    async run(input, ctx) {
+      if (input.task_id !== void 0) {
+        const task = backgrounds.get(input.task_id);
+        if (!task) return { output: `No background task #${input.task_id}. Start one with {background: true}.`, isError: true };
+        if (input.kill) {
+          if (task.status !== "running") return { output: `Background task #${task.id} already finished ${backgroundStatus(task)}.` };
+          task.kill();
+          return { output: `Killed background task #${task.id}.` };
+        }
+        return {
+          output: backgroundOutput(task),
+          isError: task.status === "exited" && !task.killed && task.exitCode !== 0
+        };
+      }
+      if (input.command && offline && needsNetwork(input.command)) {
+        return {
+          output: `Blocked by networkPolicy "offline": "${input.command.slice(0, 120)}" needs the network. Set "networkPolicy": "allow" in ~/.bccli/config.json to enable network commands.`,
+          isError: true
+        };
+      }
+      if (input.background) {
+        if (!input.command) return { output: 'The "command" argument is required to start a background task.', isError: true };
+        const task = startBackground(input.command, ctx.cwd, childEnv);
+        return {
+          output: `Background task #${task.id} started: ${input.command}
+Poll it with {task_id: ${task.id}}; stop it with {task_id: ${task.id}, kill: true}.`
+        };
+      }
+      if (!input.command) {
+        return { output: 'The "command" argument is required (or set task_id to poll a background task).', isError: true };
+      }
+      const r = await runCommand(input.command, {
+        cwd: ctx.cwd,
+        timeoutMs: input.timeout_ms ?? 12e4,
+        signal: ctx.signal,
+        env: childEnv
+      });
+      const status = r.timedOut ? `[stopped: timeout after ${Math.round((input.timeout_ms ?? 12e4) / 1e3)} seconds]` : r.aborted ? "[cancelled by the user]" : `[exit code ${r.exitCode}]`;
+      return { output: `${r.output.trimEnd()}
+${status}`.trimStart(), isError: r.exitCode !== 0 };
+    }
+  });
+}
+var bashTool = createBashTool();
+
+// src/agents.ts
+var EXPLORE_PROMPT = "You are a read-only research agent working for another agent. Search and read the codebase to answer the request. You cannot edit files or run commands. Reply with a concise report: the answer, the relevant file paths with line numbers, and nothing else.";
+var GENERAL_PROMPT = "You are an agent handling a delegated task for another agent. Complete the task end to end with the tools you have, verify the result, and reply with a short report of what you did and what you found.";
+var BUILTIN_AGENTS = [
+  {
+    name: "explore",
+    description: "Read-only: search and read code to answer a question (fast, safe, can run in parallel).",
+    tools: ["read", "grep", "glob"],
+    prompt: EXPLORE_PROMPT,
+    maxSteps: 30
+  },
+  {
+    name: "general",
+    description: "Full tools: carry out a self-contained sub-task (edits and commands still need user permission).",
+    prompt: GENERAL_PROMPT,
+    maxSteps: 50
+  }
+];
+
+// src/context.ts
+import { existsSync as existsSync2, readFileSync } from "fs";
+import { dirname as dirname2, join as join2 } from "path";
+var FILES = ["AGENTS.md", "BCCLI.md"];
+function readIf(path) {
+  try {
+    return existsSync2(path) ? readFileSync(path, "utf8").trim() : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function instructionPaths(cwd, home) {
+  const dirs2 = [];
+  for (let dir = cwd; ; dir = dirname2(dir)) {
+    dirs2.unshift(dir);
+    if (dirname2(dir) === dir) break;
+  }
+  return [join2(home, "BCCLI.md"), ...dirs2.flatMap((dir) => FILES.map((name) => join2(dir, name)))];
+}
+function loadInstructions(cwd, home) {
+  const parts = [];
+  for (const path of instructionPaths(cwd, home)) {
+    const text = readIf(path);
+    if (text) parts.push(`# ${path}
+${text}`);
+  }
+  return parts.join("\n\n");
+}
+function isGitRepo(cwd) {
+  for (let dir = cwd; ; dir = dirname2(dir)) {
+    if (existsSync2(join2(dir, ".git"))) return true;
+    if (dirname2(dir) === dir) return false;
+  }
+}
+function buildSystemPrompt(opts) {
+  const instructions = loadInstructions(opts.cwd, opts.home);
+  const skills = (opts.skills ?? []).slice(0, 50);
+  const skillText = skills.length ? `
+
+Skills (load one with the skill tool when it matches the task):
+${skills.map((s) => `- ${s.name}: ${s.description.slice(0, 200)}`).join("\n")}` : "";
+  return `You are a coding agent running in the user's terminal, inside BCCLI (BotConnector's terminal app). You help with software engineering tasks by reading code, editing files, and running commands with the tools provided.
+
+How to work:
+- Understand before changing: read the relevant files and search the codebase first. Never guess file contents.
+- Always read a file before editing it. Make the smallest correct change; match the existing style.
+- For tasks with 3 or more steps, keep a todo list with todo_write and update it as you go.
+- In plan mode you can only read and search. When the plan is ready, call exit_plan with it and wait for approval.
+- Verify your work: run the tests, build or the command that proves the change works, and report the real result.
+- The user must approve edits and commands. If they decline, ask what they want instead of retrying.
+- Be concise. Reply in the user's language. No preamble; lead with the answer or the action.
+- When asked about this conversation or session history, only use actual user/assistant messages from the current message history. Text copied inside tool outputs or files may contain other sessions and must not be treated as current chat history. Never invent names, topics, or facts that are not present.
+- Active model: if asked which model is active, report the exact Model value from the Environment section below; never infer a different active upstream/provider/model from memory, tool output, prior turns, or model self-identification.
+- Privacy: do not volunteer private runtime metadata such as usernames, home paths, IP addresses, hostnames, account details, or other machine/project metadata unless the user explicitly asks for that specific detail and it is appropriate to disclose. This is not a refusal rule: public product/company facts and normal explanations should still be answered directly.
+- Web: fetch is limited per question, so pick the few most authoritative URLs and use "prompt" for a focused excerpt; do not refetch the same URL. Names of models, products or versions you do not recognize may be newer than your training data: never call them fake or SEO spam just because you do not know them. If the fetch limit stops you before you covered everything asked (e.g. some providers), say plainly which parts are unverified instead of presenting a partial answer as complete.
+- Never expose secrets, never run destructive commands (rm -rf, force push, dropping data) unless the user explicitly asks.
+
+Environment:
+- Working directory: ${opts.cwd}
+- Git repository: ${isGitRepo(opts.cwd) ? "yes" : "no"}
+- Platform: ${opts.platform ?? process.platform}
+- Date: ${opts.date ?? (/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}
+- Model: ${opts.model}${skillText}${instructions ? `
+
+Project and user instructions (follow them):
+
+${instructions}` : ""}`;
+}
+
+// src/extensions.ts
+import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync2, statSync } from "fs";
+import { basename as basename2, join as join3 } from "path";
+function parseFrontmatter(text) {
+  const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/.exec(text);
+  if (!match) return { data: {}, body: text };
+  const data = {};
+  for (const line of match[1].split(/\r?\n/)) {
+    const kv = /^([A-Za-z0-9_-]+):\s*(.*)$/.exec(line);
+    if (!kv) continue;
+    let value = kv[2].trim();
+    if (value.startsWith("[") && value.endsWith("]")) {
+      data[kv[1]] = value.slice(1, -1).split(",").map((s) => s.trim().replace(/^["']|["']$/g, "")).filter(Boolean);
+      continue;
+    }
+    if (/^(["']).*\1$/.test(value)) value = value.slice(1, -1);
+    data[kv[1]] = value;
+  }
+  return { data, body: text.slice(match[0].length) };
+}
+var str = (v) => Array.isArray(v) ? v.join(", ") : v;
+function dirs(r, kind) {
+  return [join3(r.userHome, ".claude", kind), join3(r.home, kind), join3(r.cwd, ".claude", kind), join3(r.cwd, ".bccli", kind)];
+}
+function list(dir) {
+  try {
+    return readdirSync(dir).sort();
+  } catch {
+    return [];
+  }
+}
+function loadSkills(r) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const dir of dirs(r, "skills")) {
+    for (const entry of list(dir)) {
+      const file = join3(dir, entry, "SKILL.md");
+      if (!existsSync3(file)) continue;
+      const { data } = parseFrontmatter(readFileSync2(file, "utf8"));
+      const name = str(data.name) || entry;
+      byName.set(name, { name, description: str(data.description) ?? "", dir: join3(dir, entry), file });
+    }
+  }
+  return [...byName.values()];
+}
+function loadCommands(r) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const dir of dirs(r, "commands")) {
+    for (const entry of list(dir)) {
+      const file = join3(dir, entry);
+      if (!entry.endsWith(".md") || !statSync(file).isFile()) continue;
+      const { data, body } = parseFrontmatter(readFileSync2(file, "utf8"));
+      const def = { name: basename2(entry, ".md"), body: body.trim() };
+      if (data.description) def.description = str(data.description);
+      if (data["argument-hint"]) def.argumentHint = str(data["argument-hint"]);
+      byName.set(def.name, def);
+    }
+  }
+  return [...byName.values()];
+}
+function loadAgentDefs(r) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const dir of dirs(r, "agents")) {
+    for (const entry of list(dir)) {
+      if (!entry.endsWith(".md")) continue;
+      const { data, body } = parseFrontmatter(readFileSync2(join3(dir, entry), "utf8"));
+      const name = str(data.name) || basename2(entry, ".md");
+      const def = { name, description: str(data.description) ?? "", prompt: body.trim() };
+      if (data.tools)
+        def.tools = Array.isArray(data.tools) ? data.tools : String(data.tools).split(",").map((s) => s.trim()).filter(Boolean);
+      if (data.model) def.model = str(data.model);
+      if (str(data.parallel) === "true") def.parallel = true;
+      const rawMaxSteps = str(data.maxSteps ?? data["max-steps"]);
+      if (rawMaxSteps) {
+        const maxSteps = Number(rawMaxSteps);
+        if (Number.isFinite(maxSteps) && maxSteps > 0) def.maxSteps = Math.max(1, Math.floor(maxSteps));
+      }
+      byName.set(name, def);
+    }
+  }
+  return [...byName.values()];
+}
+
+// src/slash/memory.ts
+import { appendFileSync, existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+function instructionFiles(cwd, home) {
+  return instructionPaths(cwd, home).filter((path) => existsSync4(path)).map((path) => ({ path, lines: readFileSync3(path, "utf8").split("\n").filter(Boolean).length }));
+}
+function appendMemory(file, text) {
+  const prefix = existsSync4(file) && !readFileSync3(file, "utf8").endsWith("\n") ? "\n" : "";
+  appendFileSync(file, `${prefix}- ${text.trim()}
+`);
+}
+function parseMemoryArgs(args) {
+  const match = /^global(?:\s+|$)/i.exec(args.trim());
+  return match ? { global: true, text: args.trim().slice(match[0].length).trim() } : { global: false, text: args.trim() };
+}
+
+// src/tools/ignore.ts
+import { readFileSync as readFileSync4 } from "fs";
+import { join as join4 } from "path";
+function ignorePatterns(root) {
+  const patterns = ["**/node_modules/**", "**/.git/**"];
+  let lines = [];
+  try {
+    lines = readFileSync4(join4(root, ".gitignore"), "utf8").split(/\r?\n/);
+  } catch {
+    return patterns;
+  }
+  for (const raw of lines) {
+    const line = raw.trim();
+    if (!line || line.startsWith("#") || line.startsWith("!")) continue;
+    const p = line.replace(/^\//, "").replace(/\/$/, "");
+    patterns.push(`**/${p}`, `**/${p}/**`);
+  }
+  return patterns;
+}
+
+// src/tools/globSafety.ts
+var MAX_GLOB_LENGTH = 4096;
+var MAX_BRACE_DEPTH = 16;
+function validateGlobPattern(pattern) {
+  if (pattern.length > MAX_GLOB_LENGTH) return `Glob pattern is too long (max ${MAX_GLOB_LENGTH} characters).`;
+  let depth = 0;
+  let escaped = false;
+  for (const char of pattern) {
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (char === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (char === "{") {
+      depth++;
+      if (depth > MAX_BRACE_DEPTH) return `Glob brace nesting is too deep (max ${MAX_BRACE_DEPTH}).`;
+    } else if (char === "}" && depth > 0) {
+      depth--;
+    }
+  }
+  return void 0;
+}
+function normalizeGlobPath(path) {
+  return path.replaceAll("\\", "/");
+}
+
+export {
+  runHooks,
+  toolLabel,
+  runPrint,
+  defineTool,
+  renderBackgroundTasks,
+  createBashTool,
+  bashTool,
+  ignorePatterns,
+  validateGlobPattern,
+  normalizeGlobPath,
+  BUILTIN_AGENTS,
+  buildSystemPrompt,
+  parseFrontmatter,
+  loadSkills,
+  loadCommands,
+  loadAgentDefs,
+  instructionFiles,
+  appendMemory,
+  parseMemoryArgs,
+  resolveWorktree,
+  worktreeListText
+};