croo-cli 0.0.0-stage → 0.1.0

package/dist/cli.js

@@ -0,0 +1,1694 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import readline from "readline";
+
+// package.json
+var package_default = {
+  name: "croo-cli",
+  version: "0.1.0",
+  description: "Croo: a quick, minimal, open-source terminal AI coding agent. Bring your own API key.",
+  type: "module",
+  bin: {
+    croo: "dist/cli.js"
+  },
+  files: [
+    "dist"
+  ],
+  engines: {
+    node: ">=20"
+  },
+  scripts: {
+    build: "tsup",
+    dev: "tsup --watch",
+    test: "vitest run",
+    typecheck: "tsc --noEmit",
+    prepublishOnly: "npm run build"
+  },
+  keywords: [
+    "ai",
+    "agent",
+    "cli",
+    "coding",
+    "llm",
+    "openai",
+    "anthropic",
+    "gemini",
+    "ollama"
+  ],
+  repository: {
+    type: "git",
+    url: "git+https://github.com/xandertaylorx/croo.git"
+  },
+  bugs: {
+    url: "https://github.com/xandertaylorx/croo/issues"
+  },
+  homepage: "https://github.com/xandertaylorx/croo#readme",
+  license: "MIT",
+  author: "Xander Taylor",
+  devDependencies: {
+    "@types/node": "^22.20.5",
+    tsup: "^9.0.0",
+    typescript: "^7.0.2",
+    vitest: "^5.0.5"
+  },
+  publishConfig: {
+    access: "public"
+  }
+};
+
+// src/args.ts
+function parseArgs(argv) {
+  const a = { prompt: "", yolo: false, noPet: false, continue: false, help: false, version: false };
+  const rest = [];
+  for (let i = 0; i < argv.length; i++) {
+    const x = argv[i];
+    if (x === "--profile" || x === "-p") a.profile = argv[++i];
+    else if (x.startsWith("--profile=")) a.profile = x.slice("--profile=".length);
+    else if (x === "--yolo") a.yolo = true;
+    else if (x === "--no-pet") a.noPet = true;
+    else if (x === "--continue" || x === "-c") a.continue = true;
+    else if (x === "--help" || x === "-h") a.help = true;
+    else if (x === "--version" || x === "-v") a.version = true;
+    else if (x.startsWith("-") && x !== "-") throw new Error(`Unknown option: ${x}`);
+    else rest.push(x);
+  }
+  a.prompt = rest.join(" ").trim();
+  return a;
+}
+var HELP = `Usage:
+  croo                  start an interactive session in the current directory
+  croo "prompt"         run a one-shot task and exit
+
+Options:
+  -p, --profile <name>  use a named profile from the config
+  -c, --continue        resume the last session in this directory
+      --yolo            do not ask before writing files or running commands
+      --no-pet          hide the frog
+  -v, --version         print version
+  -h, --help            show this help
+
+Config: ~/.config/croo/config.json`;
+
+// src/tools/index.ts
+import fs2 from "fs";
+import path2 from "path";
+import { spawn } from "child_process";
+
+// src/tools/edit.ts
+function applyEdit(content, oldStr, newStr, replaceAll = false) {
+  if (oldStr === "") throw new Error("old_string must not be empty (use write_file to create files).");
+  if (oldStr === newStr) throw new Error("old_string and new_string are identical.");
+  const first = content.indexOf(oldStr);
+  if (first === -1) throw new Error("old_string was not found in the file. It must match exactly, including whitespace.");
+  if (replaceAll) return content.split(oldStr).join(newStr);
+  if (content.indexOf(oldStr, first + oldStr.length) !== -1) {
+    throw new Error("old_string matches more than once. Add surrounding context to make it unique, or set replace_all.");
+  }
+  return content.slice(0, first) + newStr + content.slice(first + oldStr.length);
+}
+
+// src/tools/ignore.ts
+import fs from "fs";
+import path from "path";
+function globToRegexSource(glob) {
+  let out2 = "";
+  for (let i = 0; i < glob.length; i++) {
+    const c = glob[i];
+    if (c === "*") {
+      if (glob[i + 1] === "*") {
+        if (glob[i + 2] === "/") {
+          out2 += "(?:.*/)?";
+          i += 2;
+        } else {
+          out2 += ".*";
+          i += 1;
+        }
+      } else out2 += "[^/]*";
+    } else if (c === "?") out2 += "[^/]";
+    else if (c === "{") {
+      const end = glob.indexOf("}", i);
+      if (end > i) {
+        out2 += "(?:" + glob.slice(i + 1, end).split(",").map(globToRegexSource).join("|") + ")";
+        i = end;
+      } else out2 += "\\{";
+    } else out2 += c.replace(/[.+^$()|[\]\\]/g, "\\$&");
+  }
+  return out2;
+}
+function globMatcher(pattern) {
+  const re = new RegExp("^" + (pattern.includes("/") ? "" : "(?:.*/)?") + globToRegexSource(pattern.replace(/^\.\//, "")) + "$");
+  return (rel) => re.test(rel);
+}
+function parseIgnore(text) {
+  const rules = [];
+  for (let line of text.split("\n")) {
+    line = line.replace(/\r$/, "").replace(/(?<!\\)\s+$/, "");
+    if (!line || line.startsWith("#")) continue;
+    const negate = line.startsWith("!");
+    if (negate) line = line.slice(1);
+    const dirOnly = line.endsWith("/");
+    if (dirOnly) line = line.slice(0, -1);
+    const anchored = line.startsWith("/") || line.includes("/");
+    line = line.replace(/^\//, "");
+    const re = new RegExp("^" + (anchored ? "" : "(?:.*/)?") + globToRegexSource(line) + "(?:/.*)?$");
+    rules.push({ re, negate, dirOnly });
+  }
+  return rules;
+}
+var Ignore = class {
+  layers = [];
+  addDir(absDir, root) {
+    try {
+      const text = fs.readFileSync(path.join(absDir, ".gitignore"), "utf8");
+      this.layers.push({ base: path.relative(root, absDir).split(path.sep).join("/"), rules: parseIgnore(text) });
+    } catch {
+    }
+  }
+  /** rel: posix path relative to root. */
+  ignored(rel, isDir) {
+    let result = false;
+    for (const { base, rules } of this.layers) {
+      if (base && !rel.startsWith(base + "/")) continue;
+      const sub = base ? rel.slice(base.length + 1) : rel;
+      for (const r of rules) {
+        if (r.dirOnly && !isDir && !r.re.test(sub.split("/").slice(0, -1).join("/"))) continue;
+        if (r.re.test(sub)) result = !r.negate;
+      }
+    }
+    return result;
+  }
+};
+var ALWAYS_SKIP = /* @__PURE__ */ new Set([".git", "node_modules"]);
+function* walk(root, dir, ig = new Ignore(), limit = { n: 2e4 }) {
+  ig.addDir(dir, root);
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  entries.sort((a, b) => a.name.localeCompare(b.name));
+  for (const e of entries) {
+    if (limit.n <= 0) return;
+    if (ALWAYS_SKIP.has(e.name)) continue;
+    const abs = path.join(dir, e.name);
+    const rel = path.relative(root, abs).split(path.sep).join("/");
+    if (e.isDirectory()) {
+      if (ig.ignored(rel, true)) continue;
+      yield* walk(root, abs, ig, limit);
+    } else if (e.isFile()) {
+      if (ig.ignored(rel, false)) continue;
+      limit.n--;
+      yield rel;
+    }
+  }
+}
+
+// src/tools/index.ts
+var MAX_OUTPUT = 3e4;
+var MAX_FILE_BYTES = 1e6;
+function truncate(s, max = MAX_OUTPUT) {
+  if (s.length <= max) return s;
+  const half = Math.floor(max / 2);
+  return `${s.slice(0, half)}
+\u2026 [${s.length - max} characters truncated] \u2026
+${s.slice(-half)}`;
+}
+function safePath(cwd2, p) {
+  if (typeof p !== "string" || !p) throw new Error("path is required.");
+  const root = fs2.realpathSync(cwd2);
+  const abs = path2.resolve(root, p);
+  let probe = abs;
+  while (!fs2.existsSync(probe)) {
+    const parent = path2.dirname(probe);
+    if (parent === probe) break;
+    probe = parent;
+  }
+  const real = path2.join(fs2.realpathSync(probe), path2.relative(probe, abs));
+  const rel = path2.relative(root, real);
+  if (rel === ".." || rel.startsWith(".." + path2.sep) || path2.isAbsolute(rel)) {
+    throw new Error(`Path "${p}" is outside the working directory.`);
+  }
+  return abs;
+}
+var relPath = (cwd2, abs) => path2.relative(fs2.realpathSync(cwd2), abs) || ".";
+function readText(abs) {
+  const stat = fs2.statSync(abs);
+  if (!stat.isFile()) throw new Error("Not a file.");
+  if (stat.size > MAX_FILE_BYTES * 5) throw new Error("File too large.");
+  const buf = fs2.readFileSync(abs);
+  if (buf.subarray(0, 8e3).includes(0)) throw new Error("Binary file.");
+  return buf.toString("utf8");
+}
+var str = (type = "string", description = "") => ({ type, description });
+var readFile = {
+  spec: {
+    name: "read_file",
+    description: "Read a text file. Returns numbered lines. Use offset/limit for large files.",
+    parameters: {
+      type: "object",
+      properties: { path: str("string", "File path relative to the working directory"), offset: str("integer", "1-based start line"), limit: str("integer", "Max lines (default 2000)") },
+      required: ["path"]
+    }
+  },
+  summarize: (a) => a.path ?? "",
+  async run(a, ctx) {
+    const text = readText(safePath(ctx.cwd, a.path));
+    const lines = text.split("\n");
+    const start = Math.max(1, Number(a.offset) || 1);
+    const limit = Math.max(1, Number(a.limit) || 2e3);
+    const slice = lines.slice(start - 1, start - 1 + limit);
+    const out2 = slice.map((l, i) => `${String(start + i).padStart(5)}	${l}`).join("\n");
+    const more = start - 1 + limit < lines.length ? `
+\u2026 ${lines.length - (start - 1 + limit)} more lines` : "";
+    return truncate(out2 + more) || "(empty file)";
+  }
+};
+var writeFile = {
+  spec: {
+    name: "write_file",
+    description: "Create or overwrite a file with the given content. Parent directories are created.",
+    parameters: { type: "object", properties: { path: str("string", "File path"), content: str("string", "Full file content") }, required: ["path", "content"] }
+  },
+  summarize: (a) => a.path ?? "",
+  prepare(a, ctx) {
+    const abs = safePath(ctx.cwd, a.path);
+    if (typeof a.content !== "string") throw new Error("content is required.");
+    const before = fs2.existsSync(abs) ? readText(abs) : "";
+    return { kind: "diff", path: relPath(ctx.cwd, abs), before, after: a.content };
+  },
+  async run(a, ctx) {
+    const abs = safePath(ctx.cwd, a.path);
+    const existed = fs2.existsSync(abs);
+    fs2.mkdirSync(path2.dirname(abs), { recursive: true });
+    fs2.writeFileSync(abs, a.content);
+    return `${existed ? "Overwrote" : "Created"} ${relPath(ctx.cwd, abs)} (${a.content.split("\n").length} lines)`;
+  }
+};
+var editFile = {
+  spec: {
+    name: "edit_file",
+    description: "Replace an exact string in a file. old_string must match exactly once unless replace_all is true.",
+    parameters: {
+      type: "object",
+      properties: { path: str(), old_string: str(), new_string: str(), replace_all: str("boolean", "Replace every occurrence") },
+      required: ["path", "old_string", "new_string"]
+    }
+  },
+  summarize: (a) => a.path ?? "",
+  prepare(a, ctx) {
+    const abs = safePath(ctx.cwd, a.path);
+    const before = readText(abs);
+    const after = applyEdit(before, String(a.old_string ?? ""), String(a.new_string ?? ""), !!a.replace_all);
+    return { kind: "diff", path: relPath(ctx.cwd, abs), before, after };
+  },
+  async run(a, ctx) {
+    const abs = safePath(ctx.cwd, a.path);
+    fs2.writeFileSync(abs, applyEdit(readText(abs), a.old_string, a.new_string, !!a.replace_all));
+    return `Edited ${relPath(ctx.cwd, abs)}`;
+  }
+};
+var listFiles = {
+  spec: {
+    name: "list_files",
+    description: 'List files (respects .gitignore). Optional glob pattern like "src/**/*.ts" or "*.md".',
+    parameters: { type: "object", properties: { pattern: str("string", "Glob pattern"), path: str("string", "Directory to search (default .)") } }
+  },
+  summarize: (a) => a.pattern || a.path || ".",
+  async run(a, ctx) {
+    const dir = safePath(ctx.cwd, a.path || ".");
+    const root = fs2.realpathSync(ctx.cwd);
+    const match = a.pattern ? globMatcher(a.pattern) : () => true;
+    const out2 = [];
+    for (const rel of walk(root, dir)) {
+      if (match(rel)) out2.push(rel);
+      if (out2.length >= 500) {
+        out2.push("\u2026 (truncated at 500 files)");
+        break;
+      }
+    }
+    return out2.join("\n") || "(no files)";
+  }
+};
+var grep = {
+  spec: {
+    name: "grep",
+    description: "Search file contents with a regular expression (respects .gitignore). Returns path:line:text.",
+    parameters: {
+      type: "object",
+      properties: { pattern: str("string", "JavaScript regular expression"), path: str("string", "Directory (default .)"), glob: str("string", "Only files matching this glob"), ignore_case: str("boolean") },
+      required: ["pattern"]
+    }
+  },
+  summarize: (a) => `/${a.pattern ?? ""}/${a.glob ? " " + a.glob : ""}`,
+  async run(a, ctx) {
+    let re;
+    try {
+      re = new RegExp(a.pattern, a.ignore_case ? "i" : "");
+    } catch (e) {
+      throw new Error(`Invalid regex: ${e.message}`);
+    }
+    const dir = safePath(ctx.cwd, a.path || ".");
+    const root = fs2.realpathSync(ctx.cwd);
+    const match = a.glob ? globMatcher(a.glob) : () => true;
+    const out2 = [];
+    for (const rel of walk(root, dir)) {
+      if (!match(rel)) continue;
+      const abs = path2.join(root, rel);
+      let text;
+      try {
+        if (fs2.statSync(abs).size > MAX_FILE_BYTES) continue;
+        const buf = fs2.readFileSync(abs);
+        if (buf.subarray(0, 8e3).includes(0)) continue;
+        text = buf.toString("utf8");
+      } catch {
+        continue;
+      }
+      const lines = text.split("\n");
+      for (let i = 0; i < lines.length; i++) {
+        if (re.test(lines[i])) out2.push(`${rel}:${i + 1}:${lines[i].slice(0, 300)}`);
+        if (out2.length >= 200) return out2.join("\n") + "\n\u2026 (truncated at 200 matches)";
+      }
+    }
+    return out2.join("\n") || "(no matches)";
+  }
+};
+var bash = {
+  spec: {
+    name: "bash",
+    description: "Run a shell command in the working directory. Default timeout 120s. Output is truncated.",
+    parameters: { type: "object", properties: { command: str(), timeout_ms: str("integer", "Timeout in ms (max 600000)") }, required: ["command"] }
+  },
+  summarize: (a) => String(a.command ?? "").split("\n")[0],
+  prepare(a) {
+    if (typeof a.command !== "string" || !a.command.trim()) throw new Error("command is required.");
+    return { kind: "command", command: a.command };
+  },
+  run(a, ctx) {
+    const timeout = Math.min(Math.max(Number(a.timeout_ms) || 12e4, 1e3), 6e5);
+    return new Promise((resolve) => {
+      const child = spawn(a.command, { shell: true, cwd: ctx.cwd, detached: process.platform !== "win32", env: process.env });
+      let out2 = "";
+      let note = "";
+      const add = (d) => {
+        if (out2.length < MAX_OUTPUT * 4) out2 += d.toString();
+      };
+      child.stdout.on("data", add);
+      child.stderr.on("data", add);
+      const kill = () => {
+        try {
+          if (process.platform !== "win32" && child.pid) process.kill(-child.pid, "SIGKILL");
+          else child.kill("SIGKILL");
+        } catch {
+        }
+      };
+      const timer = setTimeout(() => {
+        note = `
+[timed out after ${timeout / 1e3}s]`;
+        kill();
+      }, timeout);
+      const onAbort = () => {
+        note = "\n[cancelled]";
+        kill();
+      };
+      ctx.signal?.addEventListener("abort", onAbort, { once: true });
+      child.on("error", (e) => {
+        clearTimeout(timer);
+        resolve(`Failed to start: ${e.message}`);
+      });
+      child.on("close", (code) => {
+        clearTimeout(timer);
+        ctx.signal?.removeEventListener("abort", onAbort);
+        resolve((truncate(out2.trimEnd()) + note + (code ? `
+[exit code ${code}]` : "")).trim() || "(no output)");
+      });
+    });
+  }
+};
+var TOOLS = [readFile, writeFile, editFile, listFiles, grep, bash];
+var toolByName = (name) => TOOLS.find((t) => t.spec.name === name);
+
+// src/agent.ts
+var Cancelled = class extends Error {
+  constructor() {
+    super("Cancelled");
+  }
+};
+async function runTurn(o) {
+  const { hooks, signal } = o;
+  for (let step = 0; step < (o.maxSteps ?? 50); step++) {
+    hooks.onThinking();
+    let res;
+    try {
+      res = await o.provider.chat(
+        { system: o.system, messages: o.messages, tools: TOOLS.map((t) => t.spec), signal },
+        hooks.onText
+      );
+    } catch (e) {
+      hooks.onTextEnd();
+      if (signal.aborted) throw new Cancelled();
+      throw e;
+    }
+    hooks.onTextEnd();
+    hooks.onUsage(res.usage);
+    o.messages.push({ role: "assistant", content: res.text, toolCalls: res.toolCalls.length ? res.toolCalls : void 0 });
+    if (!res.toolCalls.length) return;
+    for (let i = 0; i < res.toolCalls.length; i++) {
+      if (signal.aborted) {
+        for (const c of res.toolCalls.slice(i)) o.messages.push(toolMsg(c, "Cancelled by user.", true));
+        throw new Cancelled();
+      }
+      o.messages.push(await execute(res.toolCalls[i], o));
+    }
+  }
+  throw new Error(`Stopped after ${o.maxSteps ?? 50} steps.`);
+}
+function toolMsg(c, content, isError) {
+  return { role: "tool", toolCallId: c.id, name: c.name, content, isError: isError || void 0 };
+}
+async function execute(c, o) {
+  const { hooks } = o;
+  const tool = toolByName(c.name);
+  if (!tool) return toolMsg(c, `Unknown tool "${c.name}".`, true);
+  let summary = "";
+  try {
+    summary = tool.summarize(c.args);
+    const ctx = { cwd: o.cwd, signal: o.signal };
+    const preview = tool.prepare?.(c.args, ctx);
+    if (preview && o.permissions.needsApproval(c.name)) {
+      const answer = await hooks.confirm(c.name, preview);
+      if (answer === "n") {
+        hooks.onToolDone(c.name, summary, false, "denied");
+        return toolMsg(c, "The user denied this action. Do not retry it; ask what they would like instead.", true);
+      }
+      if (answer === "a") o.permissions.allowAlways(c.name);
+    }
+    hooks.onToolRunning(c.name, summary);
+    const result = truncate(await tool.run(c.args, ctx));
+    hooks.onToolDone(c.name, summary, true, result);
+    return toolMsg(c, result, false);
+  } catch (e) {
+    const msg = e?.message ?? String(e);
+    hooks.onToolDone(c.name, summary, false, msg);
+    return toolMsg(c, `Error: ${msg}`, true);
+  }
+}
+
+// src/config.ts
+import fs3 from "fs";
+import os from "os";
+import path3 from "path";
+var DEFAULT_BASE_URLS = {
+  openai: "https://api.openai.com/v1",
+  anthropic: "https://api.anthropic.com",
+  gemini: "https://generativelanguage.googleapis.com"
+};
+var ENV_KEYS = {
+  openai: "OPENAI_API_KEY",
+  anthropic: "ANTHROPIC_API_KEY",
+  gemini: "GEMINI_API_KEY"
+};
+function configPath(env = process.env) {
+  const base = env.XDG_CONFIG_HOME || path3.join(os.homedir(), ".config");
+  return path3.join(base, "croo", "config.json");
+}
+function dataDir(env = process.env) {
+  const base = env.XDG_DATA_HOME || path3.join(os.homedir(), ".local", "share");
+  return path3.join(base, "croo");
+}
+function defaultConfig() {
+  return { activeProfile: "", profiles: {}, pet: true, animations: true };
+}
+function loadConfig(file = configPath()) {
+  let raw;
+  try {
+    raw = fs3.readFileSync(file, "utf8");
+  } catch (e) {
+    if (e.code === "ENOENT") return null;
+    throw e;
+  }
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch {
+    throw new Error(`Config at ${file} is not valid JSON.`);
+  }
+  const cfg = { ...defaultConfig(), ...data };
+  if (!cfg.profiles || typeof cfg.profiles !== "object") cfg.profiles = {};
+  for (const [name, p] of Object.entries(cfg.profiles)) {
+    if (!p || !["openai", "anthropic", "gemini"].includes(p.type) || !p.model) {
+      throw new Error(`Profile "${name}" in ${file} needs a valid "type" and "model".`);
+    }
+  }
+  if (!cfg.activeProfile || !cfg.profiles[cfg.activeProfile]) {
+    cfg.activeProfile = Object.keys(cfg.profiles)[0] ?? "";
+  }
+  return cfg;
+}
+function saveConfig(cfg, file = configPath()) {
+  fs3.mkdirSync(path3.dirname(file), { recursive: true });
+  fs3.writeFileSync(file, JSON.stringify(cfg, null, 2) + "\n", { mode: 384 });
+  fs3.chmodSync(file, 384);
+}
+function resolveApiKey(profile, env = process.env) {
+  return profile.apiKey || env.CROO_API_KEY || env[ENV_KEYS[profile.type]] || void 0;
+}
+function maskKey(key) {
+  if (!key) return "(none)";
+  return key.length <= 8 ? "****" : `${key.slice(0, 3)}\u2026${key.slice(-4)}`;
+}
+function isLocalUrl(url) {
+  if (!url) return false;
+  try {
+    const h = new URL(url).hostname;
+    return h === "localhost" || h === "127.0.0.1" || h === "[::1]" || h === "::1" || h === "0.0.0.0";
+  } catch {
+    return false;
+  }
+}
+
+// src/permissions.ts
+var READ_ONLY_TOOLS = /* @__PURE__ */ new Set(["read_file", "list_files", "grep"]);
+var Permissions = class {
+  constructor(yolo = false) {
+    this.yolo = yolo;
+  }
+  yolo;
+  always = /* @__PURE__ */ new Set();
+  needsApproval(tool) {
+    if (this.yolo) return false;
+    if (READ_ONLY_TOOLS.has(tool)) return false;
+    return !this.always.has(tool);
+  }
+  allowAlways(tool) {
+    this.always.add(tool);
+  }
+};
+
+// src/prompt.ts
+import fs4 from "fs";
+import path4 from "path";
+var INSTRUCTION_FILES = ["CROO.md", "AGENTS.md"];
+var MAX_INSTRUCTIONS = 2e4;
+function loadProjectInstructions(cwd2) {
+  for (const name of INSTRUCTION_FILES) {
+    try {
+      const text = fs4.readFileSync(path4.join(cwd2, name), "utf8").trim();
+      if (text) return `# Project instructions (${name})
+${text.slice(0, MAX_INSTRUCTIONS)}`;
+    } catch {
+    }
+  }
+  return null;
+}
+function buildSystemPrompt(cwd2, now = /* @__PURE__ */ new Date()) {
+  const parts = [
+    `You are Croo, a small, friendly, open-source coding agent running in the user's terminal. You are working in the directory: ${cwd2}`,
+    `Platform: ${process.platform}. Date: ${now.toISOString().slice(0, 10)}.`,
+    [
+      "Guidelines:",
+      "- Use the tools to inspect and change the project. Read files before editing them.",
+      "- Prefer edit_file for small changes and write_file for new files. Keep diffs minimal.",
+      "- File tools only work inside the working directory. Paths are relative to it.",
+      "- Use bash for builds, tests and git. Avoid destructive commands unless the user asked.",
+      "- Be concise. Explain what you did in a sentence or two; do not paste whole files back.",
+      "- If a tool call is denied by the user, do not retry it; ask how they would like to proceed."
+    ].join("\n")
+  ];
+  const project = loadProjectInstructions(cwd2);
+  if (project) parts.push(project);
+  return parts.join("\n\n");
+}
+
+// src/providers/sse.ts
+async function* sseData(res) {
+  if (!res.body) throw new Error("Response has no body.");
+  const reader = res.body.getReader();
+  const dec = new TextDecoder();
+  let buf = "";
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buf += dec.decode(value, { stream: true });
+    let nl;
+    while ((nl = buf.indexOf("\n")) >= 0) {
+      const line = buf.slice(0, nl).replace(/\r$/, "");
+      buf = buf.slice(nl + 1);
+      if (line.startsWith("data:")) yield line.slice(5).trim();
+    }
+  }
+  const last = buf.trim();
+  if (last.startsWith("data:")) yield last.slice(5).trim();
+}
+async function postJson(url, headers, body, signal) {
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { "content-type": "application/json", ...headers },
+    body: JSON.stringify(body),
+    signal
+  });
+  if (!res.ok) {
+    const text = (await res.text().catch(() => "")).slice(0, 600);
+    throw new Error(`API error ${res.status} ${res.statusText}: ${text}`);
+  }
+  return res;
+}
+function parseArgs2(raw) {
+  if (!raw.trim()) return {};
+  try {
+    const v = JSON.parse(raw);
+    return v && typeof v === "object" ? v : {};
+  } catch {
+    return {};
+  }
+}
+
+// src/providers/anthropic.ts
+function toAnthropicMessages(messages) {
+  const out2 = [];
+  for (const m of messages) {
+    if (m.role === "user") out2.push({ role: "user", content: m.content });
+    else if (m.role === "assistant") {
+      const blocks = [];
+      if (m.content) blocks.push({ type: "text", text: m.content });
+      for (const c of m.toolCalls ?? []) blocks.push({ type: "tool_use", id: c.id, name: c.name, input: c.args });
+      out2.push({ role: "assistant", content: blocks });
+    } else {
+      const block = { type: "tool_result", tool_use_id: m.toolCallId, content: m.content, is_error: m.isError || void 0 };
+      const last = out2[out2.length - 1];
+      if (last?.role === "user" && Array.isArray(last.content)) last.content.push(block);
+      else out2.push({ role: "user", content: [block] });
+    }
+  }
+  return out2;
+}
+function anthropicProvider(profile, apiKey) {
+  const base = (profile.baseUrl || DEFAULT_BASE_URLS.anthropic).replace(/\/+$/, "");
+  return {
+    async chat(req, onText) {
+      const body = {
+        model: profile.model,
+        max_tokens: 8192,
+        system: req.system,
+        messages: toAnthropicMessages(req.messages),
+        stream: true
+      };
+      if (req.tools.length) body.tools = req.tools.map((t) => ({ name: t.name, description: t.description, input_schema: t.parameters }));
+      const res = await postJson(
+        `${base}/v1/messages`,
+        { "x-api-key": apiKey ?? "", "anthropic-version": "2023-06-01" },
+        body,
+        req.signal
+      );
+      let text = "";
+      const blocks = /* @__PURE__ */ new Map();
+      const usage = { input: 0, output: 0 };
+      for await (const data of sseData(res)) {
+        let ev;
+        try {
+          ev = JSON.parse(data);
+        } catch {
+          continue;
+        }
+        if (ev.type === "message_start") usage.input = ev.message?.usage?.input_tokens ?? 0;
+        else if (ev.type === "message_delta") usage.output = ev.usage?.output_tokens ?? usage.output;
+        else if (ev.type === "content_block_start" && ev.content_block?.type === "tool_use") {
+          blocks.set(ev.index, { id: ev.content_block.id, name: ev.content_block.name, json: "" });
+        } else if (ev.type === "content_block_delta") {
+          if (ev.delta?.type === "text_delta") {
+            text += ev.delta.text;
+            onText(ev.delta.text);
+          } else if (ev.delta?.type === "input_json_delta") {
+            const b = blocks.get(ev.index);
+            if (b) b.json += ev.delta.partial_json;
+          }
+        } else if (ev.type === "error") {
+          throw new Error(`API error: ${ev.error?.message ?? data}`);
+        }
+      }
+      const toolCalls = [...blocks.entries()].sort((a, b) => a[0] - b[0]).map(([, b]) => ({ id: b.id, name: b.name, args: parseArgs2(b.json) }));
+      return { text, toolCalls, usage };
+    }
+  };
+}
+
+// src/providers/gemini.ts
+function toGeminiContents(messages) {
+  const out2 = [];
+  for (const m of messages) {
+    if (m.role === "user") out2.push({ role: "user", parts: [{ text: m.content }] });
+    else if (m.role === "assistant") {
+      const parts = [];
+      if (m.content) parts.push({ text: m.content });
+      for (const c of m.toolCalls ?? []) {
+        const part = { functionCall: { name: c.name, args: c.args } };
+        if (c.meta) part.thoughtSignature = c.meta;
+        parts.push(part);
+      }
+      out2.push({ role: "model", parts });
+    } else {
+      const part = { functionResponse: { name: m.name, response: m.isError ? { error: m.content } : { output: m.content } } };
+      const last = out2[out2.length - 1];
+      if (last?.role === "user" && last.parts[0]?.functionResponse) last.parts.push(part);
+      else out2.push({ role: "user", parts: [part] });
+    }
+  }
+  return out2;
+}
+function geminiProvider(profile, apiKey) {
+  const base = (profile.baseUrl || DEFAULT_BASE_URLS.gemini).replace(/\/+$/, "");
+  return {
+    async chat(req, onText) {
+      const body = {
+        systemInstruction: { parts: [{ text: req.system }] },
+        contents: toGeminiContents(req.messages)
+      };
+      if (req.tools.length) {
+        body.tools = [{ functionDeclarations: req.tools.map((t) => ({ name: t.name, description: t.description, parameters: t.parameters })) }];
+      }
+      const model = profile.model.replace(/^models\//, "");
+      const res = await postJson(`${base}/v1beta/models/${model}:streamGenerateContent?alt=sse`, { "x-goog-api-key": apiKey ?? "" }, body, req.signal);
+      let text = "";
+      const toolCalls = [];
+      const usage = { input: 0, output: 0 };
+      for await (const data of sseData(res)) {
+        let chunk;
+        try {
+          chunk = JSON.parse(data);
+        } catch {
+          continue;
+        }
+        if (chunk.usageMetadata) {
+          usage.input = chunk.usageMetadata.promptTokenCount ?? usage.input;
+          usage.output = chunk.usageMetadata.candidatesTokenCount ?? usage.output;
+        }
+        for (const part of chunk.candidates?.[0]?.content?.parts ?? []) {
+          if (part.thought) continue;
+          if (part.text) {
+            text += part.text;
+            onText(part.text);
+          }
+          if (part.functionCall) {
+            toolCalls.push({
+              id: `call_${toolCalls.length}_${Date.now()}`,
+              name: part.functionCall.name,
+              args: part.functionCall.args ?? {},
+              meta: part.thoughtSignature
+            });
+          }
+        }
+      }
+      return { text, toolCalls, usage };
+    }
+  };
+}
+
+// src/providers/openai.ts
+function toOpenAIMessages(system, messages) {
+  const out2 = [{ role: "system", content: system }];
+  for (const m of messages) {
+    if (m.role === "user") out2.push({ role: "user", content: m.content });
+    else if (m.role === "tool") out2.push({ role: "tool", tool_call_id: m.toolCallId, content: m.content });
+    else {
+      const msg = { role: "assistant", content: m.content || null };
+      if (m.toolCalls?.length) {
+        msg.tool_calls = m.toolCalls.map((c) => ({ id: c.id, type: "function", function: { name: c.name, arguments: JSON.stringify(c.args) } }));
+      }
+      out2.push(msg);
+    }
+  }
+  return out2;
+}
+function openaiProvider(profile, apiKey) {
+  const base = (profile.baseUrl || DEFAULT_BASE_URLS.openai).replace(/\/+$/, "");
+  return {
+    async chat(req, onText) {
+      const body = {
+        model: profile.model,
+        messages: toOpenAIMessages(req.system, req.messages),
+        stream: true,
+        stream_options: { include_usage: true }
+      };
+      if (req.tools.length) {
+        body.tools = req.tools.map((t) => ({ type: "function", function: { name: t.name, description: t.description, parameters: t.parameters } }));
+      }
+      const headers = apiKey ? { authorization: `Bearer ${apiKey}` } : {};
+      const res = await postJson(`${base}/chat/completions`, headers, body, req.signal);
+      let text = "";
+      const calls = /* @__PURE__ */ new Map();
+      const usage = { input: 0, output: 0 };
+      for await (const data of sseData(res)) {
+        if (data === "[DONE]") break;
+        let chunk;
+        try {
+          chunk = JSON.parse(data);
+        } catch {
+          continue;
+        }
+        if (chunk.usage) {
+          usage.input = chunk.usage.prompt_tokens ?? usage.input;
+          usage.output = chunk.usage.completion_tokens ?? usage.output;
+        }
+        const delta = chunk.choices?.[0]?.delta;
+        if (!delta) continue;
+        if (delta.content) {
+          text += delta.content;
+          onText(delta.content);
+        }
+        for (const tc of delta.tool_calls ?? []) {
+          const i = tc.index ?? 0;
+          const cur = calls.get(i) ?? { id: "", name: "", args: "" };
+          if (tc.id) cur.id = tc.id;
+          if (tc.function?.name) cur.name += tc.function.name;
+          if (tc.function?.arguments) cur.args += tc.function.arguments;
+          calls.set(i, cur);
+        }
+      }
+      const toolCalls = [...calls.entries()].sort((a, b) => a[0] - b[0]).map(([i, c]) => ({ id: c.id || `call_${i}_${Date.now()}`, name: c.name, args: parseArgs2(c.args) }));
+      return { text, toolCalls, usage };
+    }
+  };
+}
+
+// src/providers/index.ts
+function createProvider(profile, env = process.env) {
+  const key = resolveApiKey(profile, env);
+  if (!key && !(profile.type === "openai" && isLocalUrl(profile.baseUrl))) {
+    throw new Error(`No API key for this profile. Set one in the config or via CROO_API_KEY / ${profile.type.toUpperCase()}_API_KEY.`);
+  }
+  if (profile.type === "anthropic") return anthropicProvider(profile, key);
+  if (profile.type === "gemini") return geminiProvider(profile, key);
+  return openaiProvider(profile, key);
+}
+
+// src/session.ts
+import fs5 from "fs";
+import path5 from "path";
+var sessionsDir = (dir = dataDir()) => path5.join(dir, "sessions");
+function newSession(cwd2, profile) {
+  const id = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-") + "-" + Math.random().toString(36).slice(2, 6);
+  return { id, cwd: cwd2, profile, updatedAt: (/* @__PURE__ */ new Date()).toISOString(), messages: [] };
+}
+function saveSession(s, dir = dataDir()) {
+  if (!s.messages.length) return;
+  s.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  fs5.mkdirSync(sessionsDir(dir), { recursive: true, mode: 448 });
+  fs5.writeFileSync(path5.join(sessionsDir(dir), `${s.id}.json`), JSON.stringify(s), { mode: 384 });
+}
+function loadLastSession(cwd2, dir = dataDir()) {
+  let files;
+  try {
+    files = fs5.readdirSync(sessionsDir(dir)).filter((f) => f.endsWith(".json"));
+  } catch {
+    return null;
+  }
+  const sessions = [];
+  for (const f of files) {
+    try {
+      const s = JSON.parse(fs5.readFileSync(path5.join(sessionsDir(dir), f), "utf8"));
+      if (s.cwd === cwd2 && Array.isArray(s.messages)) sessions.push(s);
+    } catch {
+    }
+  }
+  sessions.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+  return sessions[0] ?? null;
+}
+
+// src/ui/pet.ts
+var W = 11;
+var H = 8;
+function frog(eyes, mouth, offset) {
+  const rows = [
+    ".###...###.",
+    "####...####",
+    "###########",
+    "###########",
+    ".#########.",
+    ".##.....##."
+  ].map((r) => r.split(""));
+  const carve = (r, ...cols) => cols.forEach((c) => rows[r][c] = ".");
+  if (eyes === "center") carve(1, 2, 8);
+  if (eyes === "left") carve(1, 1, 7);
+  if (eyes === "right") carve(1, 3, 9);
+  if (eyes === "wide") carve(1, 2, 8), carve(0, 2, 8);
+  if (mouth === "smile") carve(3, 2, 8), carve(4, 3, 4, 5, 6, 7);
+  if (mouth === "flat") carve(3, 3, 4, 5, 6, 7);
+  if (mouth === "open") carve(3, 2, 3, 4, 5, 6, 7, 8), carve(4, 3, 4, 5, 6, 7);
+  if (mouth === "frown") carve(3, 4, 5, 6), carve(4, 3, 7);
+  const grid = Array.from({ length: H }, () => Array(W).fill("."));
+  rows.forEach((row, i) => {
+    const y = i + offset;
+    if (y >= 0 && y < H) grid[y] = row;
+  });
+  const lines = [];
+  for (let y = 0; y < H; y += 2) {
+    let line = "";
+    for (let x = 0; x < W; x++) {
+      const top = grid[y][x] === "#";
+      const bot = grid[y + 1][x] === "#";
+      line += top && bot ? "\u2588" : top ? "\u2580" : bot ? "\u2584" : " ";
+    }
+    lines.push(line);
+  }
+  return lines;
+}
+var frogPet = {
+  name: "frog",
+  frames: {
+    // A long open-eyed pause, then a blink (the animator holds frame 0 for a few seconds).
+    idle: [frog("center", "smile", 1), frog("closed", "smile", 1)],
+    thinking: [frog("left", "flat", 1), frog("center", "flat", 1), frog("right", "flat", 1), frog("center", "flat", 1)],
+    working: [frog("center", "smile", 2), frog("center", "smile", 0)],
+    happy: [frog("closed", "open", 1), frog("closed", "open", 0), frog("closed", "open", 1)],
+    oops: [frog("wide", "frown", 1), frog("wide", "frown", 2)]
+  },
+  mini: {
+    idle: ["(o.o)", "(-.-)"],
+    thinking: ["(o.o )", "( o.o)"],
+    working: ["\\(o.o)/", " (o.o) "],
+    happy: ["\\(^.^)/"],
+    oops: ["(x.x)"]
+  },
+  sayings: [
+    "ribbit. ready when you are.",
+    "croo! what are we building?",
+    "hop in, I will read the code.",
+    "small diffs, big wins.",
+    "lily pad cleared. let us code."
+  ]
+};
+
+// src/ui/theme.ts
+var palette = {
+  accent: [94, 214, 126],
+  muted: [128, 134, 130],
+  error: [240, 98, 98],
+  warn: [236, 201, 75],
+  text: [220, 224, 220]
+};
+function detectColorLevel(env = process.env, isTTY2 = !!process.stdout.isTTY) {
+  if (env.NO_COLOR !== void 0 && env.NO_COLOR !== "") return 0;
+  const force = env.FORCE_COLOR;
+  if (force === "0") return 0;
+  if (!isTTY2 && !force) return 0;
+  if (env.TERM === "dumb") return 0;
+  if (force === "1") return 1;
+  if (force === "2") return 2;
+  if (force === "3") return 3;
+  const ct = (env.COLORTERM || "").toLowerCase();
+  if (ct === "truecolor" || ct === "24bit") return 3;
+  if ((env.TERM || "").includes("256color") || env.TERM_PROGRAM === "Apple_Terminal") return 2;
+  return 1;
+}
+function to256([r, g, b]) {
+  if (r === g && g === b) {
+    if (r < 8) return 16;
+    if (r > 248) return 231;
+    return 232 + Math.round((r - 8) / 247 * 24);
+  }
+  const c = (v) => Math.round(v / 255 * 5);
+  return 16 + 36 * c(r) + 6 * c(g) + c(b);
+}
+function to16([r, g, b]) {
+  const max = Math.max(r, g, b);
+  if (max < 60) return 30;
+  const bright = max > 200 ? 60 : 0;
+  const bit = (v) => v > max * 0.6 ? 1 : 0;
+  return 30 + bright + bit(r) + bit(g) * 2 + bit(b) * 4;
+}
+function createTheme(level) {
+  const wrap = (open, close) => (s) => level === 0 ? s : `\x1B[${open}m${s}\x1B[${close}m`;
+  const fg = (rgb) => {
+    if (level === 0) return (s) => s;
+    const open = level === 3 ? `38;2;${rgb[0]};${rgb[1]};${rgb[2]}` : level === 2 ? `38;5;${to256(rgb)}` : `${to16(rgb)}`;
+    return (s) => `\x1B[${open}m${s}\x1B[39m`;
+  };
+  return {
+    level,
+    enabled: level > 0,
+    accent: fg(palette.accent),
+    muted: fg(palette.muted),
+    error: fg(palette.error),
+    warn: fg(palette.warn),
+    text: fg(palette.text),
+    bold: wrap("1", "22"),
+    dim: wrap("2", "22"),
+    italic: wrap("3", "23")
+  };
+}
+var theme = createTheme(detectColorLevel());
+var ANSI_RE = /\x1b\[[0-9;?]*[A-Za-z]/g;
+var stripAnsi = (s) => s.replace(ANSI_RE, "");
+var visibleLength = (s) => [...stripAnsi(s)].length;
+
+// src/ui/markdown.ts
+var MarkdownStream = class {
+  constructor(theme2, write) {
+    this.theme = theme2;
+    this.write = write;
+  }
+  theme;
+  write;
+  buf = "";
+  inCode = false;
+  push(delta) {
+    if (!this.theme.enabled) return this.write(delta);
+    this.buf += delta;
+    let nl;
+    while ((nl = this.buf.indexOf("\n")) >= 0) {
+      const line = this.buf.slice(0, nl);
+      this.buf = this.buf.slice(nl + 1);
+      this.write(this.renderLine(line) + "\n");
+    }
+  }
+  flush() {
+    if (this.buf) {
+      this.write(this.theme.enabled ? this.renderLine(this.buf) : this.buf);
+      this.buf = "";
+    }
+    this.inCode = false;
+  }
+  /** Whether the last emitted char was mid-line (so callers know to add a newline). */
+  get pending() {
+    return this.buf.length > 0;
+  }
+  renderLine(line) {
+    const t = this.theme;
+    const fence = line.match(/^\s*```\s*([\w+-]*)\s*$/);
+    if (fence) {
+      this.inCode = !this.inCode;
+      return this.inCode && fence[1] ? t.muted(`  \u258E ${fence[1]}`) : "";
+    }
+    if (this.inCode) return `${t.muted("  \u258E")} ${t.text(line)}`;
+    const h = line.match(/^(#{1,6})\s+(.*)$/);
+    if (h) return t.bold(t.accent(this.inline(h[2])));
+    if (/^\s*([-*_])\1{2,}\s*$/.test(line)) return t.muted("\u2500".repeat(24));
+    const q = line.match(/^>\s?(.*)$/);
+    if (q) return `${t.muted("\u258E")} ${t.italic(this.inline(q[1]))}`;
+    const li = line.match(/^(\s*)([-*+]|\d+[.)])\s+(.*)$/);
+    if (li) {
+      const bullet = /\d/.test(li[2]) ? t.accent(li[2]) : t.accent("\u2022");
+      return `${li[1]}${bullet} ${this.inline(li[3])}`;
+    }
+    return this.inline(line);
+  }
+  inline(s) {
+    const t = this.theme;
+    return s.split(/(`[^`]+`)/g).map((part) => {
+      if (part.length > 1 && part.startsWith("`") && part.endsWith("`")) return t.accent(part.slice(1, -1));
+      return part.replace(/\*\*([^*]+)\*\*/g, (_, x) => t.bold(x)).replace(/(^|[^*\w])\*([^*\s][^*]*)\*(?!\*)/g, (_, p, x) => p + t.italic(x));
+    }).join("");
+  }
+};
+
+// src/ui/term.ts
+var out = process.stdout;
+var isTTY = !!out.isTTY;
+var columns = () => out.isTTY && out.columns ? out.columns : 80;
+var cursorHidden = false;
+var handlersInstalled = false;
+function restoreCursor() {
+  if (cursorHidden && out.isTTY) out.write("\x1B[?25h");
+  cursorHidden = false;
+}
+function hideCursor() {
+  if (!out.isTTY) return;
+  if (!handlersInstalled) {
+    handlersInstalled = true;
+    process.on("exit", restoreCursor);
+    process.on("uncaughtException", (e) => {
+      restoreCursor();
+      console.error(theme.error(String(e instanceof Error ? e.stack || e.message : e)));
+      process.exit(1);
+    });
+    for (const sig of ["SIGTERM", "SIGHUP"]) {
+      process.on(sig, () => {
+        restoreCursor();
+        process.exit(1);
+      });
+    }
+  }
+  cursorHidden = true;
+  out.write("\x1B[?25l");
+}
+var showCursor = restoreCursor;
+function shortenPath(p, home = process.env.HOME || "") {
+  return home && p.startsWith(home) ? "~" + p.slice(home.length) : p;
+}
+function truncateMiddle(s, max) {
+  if (s.length <= max) return s;
+  const keep = Math.max(4, max - 1);
+  const head = Math.ceil(keep / 2);
+  return s.slice(0, head) + "\u2026" + s.slice(s.length - (keep - head));
+}
+
+// src/ui/spinner.ts
+var FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var THINKING_VERBS = ["Thinking", "Hatching a plan", "Pondering", "Ribbiting", "Mulling it over", "Hopping to conclusions"];
+var TOOL_VERBS = {
+  read_file: "Reading",
+  list_files: "Looking around",
+  grep: "Searching",
+  write_file: "Writing",
+  edit_file: "Editing",
+  bash: "Running"
+};
+var Spinner = class {
+  constructor(o) {
+    this.o = o;
+  }
+  o;
+  timer;
+  startedAt = 0;
+  tick = 0;
+  verbs = THINKING_VERBS;
+  state = "thinking";
+  detail = "";
+  tokens = 0;
+  get active() {
+    return !!this.timer;
+  }
+  start(state, verbs, detail = "") {
+    this.stop();
+    if (!this.o.enabled) return;
+    this.state = state;
+    this.verbs = verbs;
+    this.detail = detail;
+    this.startedAt = Date.now();
+    this.tick = 0;
+    hideCursor();
+    this.render();
+    this.timer = setInterval(() => this.render(), 120);
+  }
+  stop() {
+    if (!this.timer) return;
+    clearInterval(this.timer);
+    this.timer = void 0;
+    process.stdout.write("\r\x1B[2K");
+    showCursor();
+  }
+  render() {
+    const { theme: t, pet, showPet } = this.o;
+    const secs = Math.floor((Date.now() - this.startedAt) / 1e3);
+    const verb = this.verbs[Math.floor(this.tick / 25) % this.verbs.length];
+    const mini = pet.mini[this.state];
+    const glyph = showPet ? t.accent(mini[Math.floor(this.tick / 4) % mini.length]) + " " : "";
+    const stats = [`${secs}s`, this.tokens ? `~${this.tokens} tokens` : ""].filter(Boolean).join(" \xB7 ");
+    const label = `${verb}\u2026${this.detail ? " " + this.detail : ""}`;
+    const head = `${t.accent(FRAMES[this.tick % FRAMES.length])} ${glyph}`;
+    const room = Math.max(10, columns() - 12 - stats.length - (showPet ? 9 : 0));
+    process.stdout.write(`\r\x1B[2K${head}${truncateMiddle(label, room)} ${t.muted(stats)}`);
+    this.tick++;
+  }
+};
+
+// src/tools/diff.ts
+var MAX_MIDDLE = 2e3;
+function diffLines(before, after) {
+  const a = before === "" ? [] : before.split("\n");
+  const b = after === "" ? [] : after.split("\n");
+  let head = 0;
+  while (head < a.length && head < b.length && a[head] === b[head]) head++;
+  let tail = 0;
+  while (tail < a.length - head && tail < b.length - head && a[a.length - 1 - tail] === b[b.length - 1 - tail]) tail++;
+  const am = a.slice(head, a.length - tail);
+  const bm = b.slice(head, b.length - tail);
+  const ops = [];
+  let oldNo = 1;
+  let newNo = 1;
+  for (let i = 0; i < head; i++) ops.push({ type: " ", text: a[i], oldNo: oldNo++, newNo: newNo++ });
+  if (am.length > MAX_MIDDLE || bm.length > MAX_MIDDLE) {
+    for (const t of am) ops.push({ type: "-", text: t, oldNo: oldNo++ });
+    for (const t of bm) ops.push({ type: "+", text: t, newNo: newNo++ });
+  } else {
+    const n = am.length;
+    const m = bm.length;
+    const dp = Array.from({ length: n + 1 }, () => new Uint32Array(m + 1));
+    for (let i2 = n - 1; i2 >= 0; i2--)
+      for (let j2 = m - 1; j2 >= 0; j2--)
+        dp[i2][j2] = am[i2] === bm[j2] ? dp[i2 + 1][j2 + 1] + 1 : Math.max(dp[i2 + 1][j2], dp[i2][j2 + 1]);
+    let i = 0;
+    let j = 0;
+    while (i < n || j < m) {
+      if (i < n && j < m && am[i] === bm[j]) {
+        ops.push({ type: " ", text: am[i], oldNo: oldNo++, newNo: newNo++ });
+        i++;
+        j++;
+      } else if (i < n && (j >= m || dp[i + 1][j] >= dp[i][j + 1])) {
+        ops.push({ type: "-", text: am[i++], oldNo: oldNo++ });
+      } else {
+        ops.push({ type: "+", text: bm[j++], newNo: newNo++ });
+      }
+    }
+  }
+  for (let i = a.length - tail; i < a.length; i++) ops.push({ type: " ", text: a[i], oldNo: oldNo++, newNo: newNo++ });
+  return ops;
+}
+function collapseContext(lines, context = 2) {
+  const keep = new Array(lines.length).fill(false);
+  lines.forEach((l, i) => {
+    if (l.type === " ") return;
+    for (let k = Math.max(0, i - context); k <= Math.min(lines.length - 1, i + context); k++) keep[k] = true;
+  });
+  const out2 = [];
+  let gap = false;
+  lines.forEach((l, i) => {
+    if (keep[i]) {
+      out2.push(l);
+      gap = false;
+    } else if (!gap) {
+      out2.push(null);
+      gap = true;
+    }
+  });
+  return out2;
+}
+
+// src/ui/render.ts
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+var fmtTokens = (n) => n >= 1e3 ? `${(n / 1e3).toFixed(n >= 1e4 ? 0 : 1)}k` : String(n);
+var Ui = class {
+  constructor(o) {
+    this.o = o;
+    this.animate = isTTY && o.animations;
+    this.spinner = new Spinner({ theme: o.theme, enabled: this.animate, pet: o.pet, showPet: o.showPet });
+    this.md = new MarkdownStream(o.theme, (s) => {
+      process.stdout.write(s);
+      this.midLine = !s.endsWith("\n");
+    });
+  }
+  o;
+  spinner;
+  md;
+  midLine = false;
+  // streamed text without trailing newline
+  streamed = false;
+  animate;
+  get t() {
+    return this.o.theme;
+  }
+  // ---------- banner ----------
+  async banner(info) {
+    const { t, o } = this;
+    const cols = columns();
+    const hint = t.muted("/help for commands");
+    if (!o.showPet || cols < 60) {
+      console.log(`${t.accent(t.bold("Croo"))} ${t.muted("v" + info.version)}  ${t.muted(`${info.model} \xB7 ${info.profile}`)}`);
+      console.log(t.muted(truncateMiddle(shortenPath(info.cwd), cols - 2)));
+      console.log(hint + "\n");
+      return;
+    }
+    const say = o.pet.sayings[Math.floor(Math.random() * o.pet.sayings.length)];
+    const right = [
+      t.muted(`\u201C${say}\u201D`),
+      `${t.accent(t.bold("Croo"))} ${t.muted("v" + info.version)}`,
+      t.muted(`${info.model} \xB7 ${info.profile}`),
+      t.muted(truncateMiddle(shortenPath(info.cwd), cols - 20))
+    ];
+    const compose = (frame) => frame.map((l, i) => `${t.accent(l)}   ${right[i] ?? ""}`);
+    const frames = o.pet.frames.idle;
+    let lines = compose(frames[0]);
+    console.log(lines.join("\n"));
+    console.log(" ".repeat(14) + hint + "\n");
+    if (!this.animate) return;
+    const redraw = (frame) => {
+      const up = lines.length + 2;
+      process.stdout.write(`\x1B[${up}A` + compose(frame).map((l) => `\r\x1B[2K${l}
+`).join("") + `\x1B[2B`);
+    };
+    hideCursor();
+    try {
+      await sleep(550);
+      redraw(frames[1]);
+      await sleep(140);
+      redraw(frames[0]);
+    } finally {
+      showCursor();
+    }
+  }
+  // ---------- streaming ----------
+  think(verbs = THINKING_VERBS) {
+    this.spinner.start("thinking", verbs);
+  }
+  work(tool, detail) {
+    this.spinner.start("working", [TOOL_VERBS[tool] ?? "Working"], detail);
+  }
+  idle() {
+    this.spinner.stop();
+  }
+  text(delta) {
+    this.spinner.stop();
+    if (!this.streamed) {
+      this.streamed = true;
+      if (this.animate || this.t.enabled) process.stdout.write("\n");
+    }
+    this.spinner.tokens += Math.ceil(delta.length / 4);
+    this.md.push(delta);
+  }
+  endText() {
+    this.spinner.stop();
+    this.md.flush();
+    if (this.midLine) process.stdout.write("\n");
+    this.midLine = false;
+    this.streamed = false;
+  }
+  /** Reset per-turn counters. */
+  beginTurn() {
+    this.spinner.tokens = 0;
+    this.streamed = false;
+  }
+  // ---------- messages ----------
+  line(s = "") {
+    this.spinner.stop();
+    if (this.midLine) process.stdout.write("\n"), this.midLine = false;
+    console.log(s);
+  }
+  info(s) {
+    this.line(this.t.muted(s));
+  }
+  warn(s) {
+    this.line(this.t.warn(s));
+  }
+  error(s) {
+    const mini = this.o.showPet ? this.o.pet.mini.oops[0] + " " : "";
+    this.line(this.t.error(`${mini}${s}`));
+  }
+  done(seconds) {
+    if (!this.animate && !this.t.enabled) return;
+    const mini = this.o.showPet ? this.o.pet.mini.happy[0] + " " : "";
+    this.line(this.t.muted(`${mini}done in ${seconds.toFixed(1)}s`));
+  }
+  /** Full-size pet reaction, used for startup problems. Plain text when narrow or piped. */
+  petSays(state, message) {
+    const { t, o } = this;
+    if (!o.showPet || !this.animate || columns() < 60) return console.error(t.error(message));
+    const frame = o.pet.frames[state][0];
+    const color = state === "oops" ? t.error : t.accent;
+    frame.forEach((l, i) => console.error(`${color(l)}   ${i === 1 ? state === "oops" ? t.error(message) : message : ""}`));
+  }
+  toolCard(name, summary, ok, result) {
+    const { t } = this;
+    const icon = { read_file: "\u25C7", list_files: "\u2315", grep: "\u2315", write_file: "\u270E", edit_file: "\u270E", bash: "$" }[name] ?? "\u25C6";
+    const status = ok ? t.accent("\u2713") : t.error("\u2717");
+    const room = Math.max(20, columns() - 6 - name.length);
+    const first = result.split("\n")[0];
+    const tail = first && first !== "(no output)" ? t.muted(` \xB7 ${truncateMiddle(first, 40)}`) : "";
+    const head = `  ${t.accent(icon)} ${t.bold(name)} ${t.muted(truncateMiddle(summary.replace(/\s+/g, " "), room - 45))}`;
+    this.line(`${head} ${status}${ok ? "" : tail}`);
+  }
+  // ---------- permission prompt ----------
+  async confirm(name, preview) {
+    const { t } = this;
+    const w = Math.min(columns() - 2, 100);
+    const title = preview.kind === "diff" ? `${name} ${preview.path}` : `${name}`;
+    const top = `\u256D\u2500 ${title} `;
+    this.line("\n" + t.warn(top + "\u2500".repeat(Math.max(0, w - visibleLength(top)))));
+    const bar = t.warn("\u2502");
+    if (preview.kind === "command") {
+      for (const l of preview.command.split("\n").slice(0, 20)) this.line(`${bar} ${t.bold(truncateMiddle(l, w - 4))}`);
+    } else {
+      this.printDiff(preview.before, preview.after, bar, w - 4);
+    }
+    const answer = await this.o.ask(`${t.warn("\u2570")} Allow? ${t.muted("[y]es / [n]o / [a]lways")} `);
+    const c = answer.trim().toLowerCase()[0];
+    return c === "y" ? "y" : c === "a" ? "a" : "n";
+  }
+  printDiff(before, after, bar, width) {
+    const { t } = this;
+    const rows = collapseContext(diffLines(before, after), 2);
+    const numW = String(Math.max(before.split("\n").length, after.split("\n").length)).length;
+    const MAX = 60;
+    let shown = 0;
+    for (const r of rows) {
+      if (shown >= MAX) {
+        this.line(`${bar} ${t.muted(`\u2026 ${rows.length - shown} more lines`)}`);
+        break;
+      }
+      shown++;
+      if (r === null) {
+        this.line(`${bar} ${t.muted("\u2026")}`);
+        continue;
+      }
+      const no = String(r.type === "-" ? r.oldNo : r.newNo).padStart(numW);
+      const body = truncateMiddle(r.text, Math.max(10, width - numW - 4));
+      if (r.type === "+") this.line(`${bar} ${t.accent(`${no} + ${body}`)}`);
+      else if (r.type === "-") this.line(`${bar} ${t.error(`${no} - ${body}`)}`);
+      else this.line(`${bar} ${t.muted(`${no}   ${body}`)}`);
+    }
+  }
+  // ---------- status ----------
+  statusLine(s) {
+    const { t } = this;
+    const tokens = s.input + s.output > 0 ? ` \xB7 ${fmtTokens(s.input)} in / ${fmtTokens(s.output)} out` : "";
+    const cost = s.cost !== void 0 ? ` \xB7 ~$${s.cost.toFixed(s.cost < 0.1 ? 3 : 2)}` : "";
+    const text = `${s.model} \xB7 ${shortenPath(s.cwd)}${tokens}${cost}`;
+    this.line(t.muted("  " + truncateMiddle(text, columns() - 3)));
+  }
+};
+
+// src/cli.ts
+var VERSION = package_default.version;
+var cwd = process.cwd();
+var rl;
+var cancelAsk;
+var getRl = () => rl ??= readline.createInterface({ input: process.stdin, output: process.stdout, terminal: !!process.stdin.isTTY });
+var ask = (question, opts) => {
+  if (!process.stdin.isTTY) return Promise.resolve("");
+  return new Promise((resolve) => {
+    const r = getRl();
+    let muted = false;
+    const original = r._writeToOutput;
+    if (opts?.secret && typeof original === "function") {
+      r._writeToOutput = (s) => {
+        if (!muted) original.call(r, s);
+      };
+    }
+    const finish = (answer) => {
+      r._writeToOutput = original;
+      cancelAsk = void 0;
+      if (opts?.secret) process.stdout.write("\n");
+      resolve(answer);
+    };
+    cancelAsk = () => finish("");
+    r.question(question, (a) => finish(a));
+    muted = !!opts?.secret;
+  });
+};
+var DEFAULT_MODELS = { openai: "gpt-4o", anthropic: "claude-sonnet-4-5", gemini: "gemini-2.5-pro" };
+async function setupProfile(a, cfg) {
+  console.log(theme.bold("\nSet up a provider") + theme.muted("  (stored in " + configPath() + ", mode 600)\n"));
+  console.log("  1) OpenAI-compatible  (OpenAI, OpenRouter, Groq, Ollama, LM Studio, ...)\n  2) Anthropic\n  3) Google Gemini\n");
+  const choice = (await a("Provider [1]: ")).trim() || "1";
+  const type = choice === "2" ? "anthropic" : choice === "3" ? "gemini" : "openai";
+  const profile = { type, model: "" };
+  if (type === "openai") {
+    const url = (await a(`Base URL [${DEFAULT_BASE_URLS.openai}] (Ollama: http://localhost:11434/v1): `)).trim();
+    if (url) profile.baseUrl = url;
+  }
+  const key = (await a("API key (leave blank to use an env var, or for local models): ", { secret: true })).trim();
+  if (key) profile.apiKey = key;
+  profile.model = (await a(`Model [${DEFAULT_MODELS[type]}]: `)).trim() || DEFAULT_MODELS[type];
+  let base = type === "openai" && profile.baseUrl ? new URL(profile.baseUrl).hostname.replace(/^api\./, "").split(".")[0] : type;
+  let name = base;
+  for (let i = 2; cfg.profiles[name]; i++) name = `${base}${i}`;
+  const next = { ...cfg, profiles: { ...cfg.profiles, [name]: profile }, activeProfile: name };
+  saveConfig(next);
+  console.log(theme.accent(`
+Saved profile "${name}".
+`));
+  return next;
+}
+async function main() {
+  let args;
+  try {
+    args = parseArgs(process.argv.slice(2));
+  } catch (e) {
+    console.error(e.message + "\n\n" + HELP);
+    process.exit(2);
+  }
+  if (args.help) return console.log(HELP);
+  if (args.version) return console.log(VERSION);
+  let cfg = loadConfig();
+  if (!cfg || !Object.keys(cfg.profiles).length) {
+    if (!process.stdin.isTTY) {
+      console.error(`No config found. Run \`croo\` in a terminal to set one up, or create ${configPath()}.`);
+      process.exit(1);
+    }
+    console.log(theme.accent(theme.bold("Welcome to Croo.")) + " No config yet, so let us set one up.");
+    cfg = await setupProfile(ask, cfg ?? defaultConfig());
+  }
+  let profileName = args.profile ?? cfg.activeProfile;
+  if (!cfg.profiles[profileName]) {
+    console.error(`Unknown profile "${profileName}". Available: ${Object.keys(cfg.profiles).join(", ")}`);
+    process.exit(1);
+  }
+  const ui = new Ui({ theme, pet: frogPet, showPet: cfg.pet && !args.noPet, animations: cfg.animations, ask });
+  const permissions = new Permissions(args.yolo);
+  const interactive = !args.prompt;
+  let provider;
+  const useProfile = (name) => {
+    provider = createProvider(cfg.profiles[name]);
+    profileName = name;
+  };
+  try {
+    useProfile(profileName);
+  } catch (e) {
+    ui.petSays("oops", e.message);
+    process.exit(1);
+  }
+  let session = args.continue && loadLastSession(cwd) || newSession(cwd, profileName);
+  const messages = session.messages;
+  if (args.continue && messages.length) ui.info(`Resumed session with ${messages.length} messages.`);
+  const system = buildSystemPrompt(cwd);
+  const totals = { input: 0, output: 0 };
+  let current;
+  let lastInterrupt = 0;
+  async function runPrompt(text) {
+    const before = messages.length;
+    messages.push({ role: "user", content: text });
+    const ac = current = new AbortController();
+    const t0 = Date.now();
+    ui.beginTurn();
+    try {
+      await runTurn({
+        provider,
+        system,
+        messages,
+        cwd,
+        permissions,
+        signal: ac.signal,
+        hooks: {
+          onThinking: () => ui.think(),
+          onText: (d) => ui.text(d),
+          onTextEnd: () => ui.endText(),
+          onToolRunning: (n, s) => ui.work(n, s),
+          onToolDone: (n, s, ok, r) => ui.toolCard(n, s, ok, r),
+          confirm: (n, p) => ui.confirm(n, p),
+          onUsage: (u) => (totals.input += u.input, totals.output += u.output)
+        }
+      });
+      ui.done((Date.now() - t0) / 1e3);
+      return true;
+    } catch (e) {
+      if (e instanceof Cancelled) ui.warn("Cancelled.");
+      else {
+        messages.length = before;
+        ui.error(e?.message ?? String(e));
+      }
+      return false;
+    } finally {
+      ui.idle();
+      current = void 0;
+      session.profile = profileName;
+      saveSession(session);
+    }
+  }
+  function interrupt() {
+    const now = Date.now();
+    if (current && !current.signal.aborted) {
+      current.abort();
+      cancelAsk?.();
+      lastInterrupt = now;
+      return;
+    }
+    if (now - lastInterrupt < 2e3 || !interactive) {
+      ui.idle();
+      process.stdout.write("\n");
+      process.exit(130);
+    }
+    lastInterrupt = now;
+    ui.info("\n(press Ctrl+C again to exit)");
+    if (rl) {
+      rl.write(null, { ctrl: true, name: "u" });
+      rl.prompt();
+    }
+  }
+  process.on("SIGINT", interrupt);
+  if (!interactive) {
+    const ok = await runPrompt(args.prompt);
+    rl?.close();
+    process.exit(ok ? 0 : 1);
+  }
+  const profile = () => cfg.profiles[profileName];
+  const showBanner = () => ui.banner({ version: VERSION, profile: profileName, model: profile().model, cwd });
+  await showBanner();
+  const reader = getRl();
+  reader.setPrompt(theme.accent("\u203A "));
+  reader.on("SIGINT", interrupt);
+  const status = () => {
+    const p = profile();
+    const cost = p.inputPerMTok !== void 0 || p.outputPerMTok !== void 0 ? (totals.input * (p.inputPerMTok ?? 0) + totals.output * (p.outputPerMTok ?? 0)) / 1e6 : void 0;
+    ui.statusLine({ model: p.model, cwd, input: totals.input, output: totals.output, cost });
+  };
+  let closed = false;
+  reader.on("close", () => closed = true);
+  const next = () => {
+    if (closed) return;
+    status();
+    reader.prompt();
+  };
+  const commands = {
+    help: () => ui.line(
+      ["/help          show this help", "/model         list profiles; /model <name> switches; /model add adds one", "/clear         start a fresh conversation", "/config        show config location and profiles", "/exit          quit (Ctrl+C twice also works)"].map((l) => theme.muted("  " + l)).join("\n")
+    ),
+    exit: () => {
+      reader.close();
+    },
+    clear: async () => {
+      messages.length = 0;
+      session = newSession(cwd, profileName);
+      totals.input = totals.output = 0;
+      if (process.stdout.isTTY) process.stdout.write("\x1B[2J\x1B[H");
+      await showBanner();
+    },
+    config: () => {
+      ui.line(theme.muted(`  config: ${configPath()}`));
+      for (const [n, p] of Object.entries(cfg.profiles)) {
+        ui.line(`  ${n === profileName ? theme.accent("\u25CF") : " "} ${n}  ${theme.muted(`${p.type} \xB7 ${p.model}${p.baseUrl ? " \xB7 " + p.baseUrl : ""} \xB7 key ${maskKey(p.apiKey)}`)}`);
+      }
+      ui.line(theme.muted(`  pet: ${cfg.pet}  animations: ${cfg.animations}`));
+    },
+    model: async (arg) => {
+      if (arg === "add") {
+        cfg = await setupProfile(ask, cfg);
+        arg = cfg.activeProfile;
+      }
+      if (!arg) {
+        for (const [n, p] of Object.entries(cfg.profiles)) ui.line(`  ${n === profileName ? theme.accent("\u25CF") : " "} ${n}  ${theme.muted(`${p.type} \xB7 ${p.model}`)}`);
+        return ui.info("  switch with /model <name>");
+      }
+      if (!cfg.profiles[arg]) return ui.error(`Unknown profile "${arg}".`);
+      try {
+        useProfile(arg);
+        cfg.activeProfile = arg;
+        saveConfig(cfg);
+        ui.info(`  now using ${arg} (${profile().model})`);
+      } catch (e) {
+        ui.error(e.message);
+      }
+    }
+  };
+  next();
+  for await (const raw of reader) {
+    const line = raw.trim();
+    if (line.startsWith("/")) {
+      const [cmd, ...rest] = line.slice(1).split(/\s+/);
+      const fn = commands[cmd];
+      if (fn) await fn(rest.join(" "));
+      else ui.error(`Unknown command /${cmd}. Try /help.`);
+    } else if (line) {
+      await runPrompt(line);
+    }
+    next();
+  }
+  saveSession(session);
+  process.exit(0);
+}
+main().catch((e) => {
+  console.error(theme.error(e?.message ?? String(e)));
+  process.exit(1);
+});
+export {
+  setupProfile
+};