@cam5/baby-bird 0.1.0 → 0.1.2

package/dist/cli.js

@@ -4,30 +4,37 @@ import {
   BbError,
   CliRenderer,
   CommandProvider,
+  ConfigError,
   NotARepoError,
   TourCache,
   UsageError,
   allPresets,
+  buildChatContext,
+  chatSlots,
   describeSource2 as describeSource,
   generateTour,
+  git,
   gitRoot,
+  launchChat,
   loadConfig,
   prepareTour,
   projectConfigPath,
   relativeTime,
+  resolveChat,
   resolveLlm,
+  wrap,
   writeMaybePaged,
   writeStdout
-} from "./chunk-RWSCST2I.js";
+} from "./chunk-YI2UL4IC.js";
 
 // src/cli/main.ts
 import { Command, InvalidArgumentError } from "commander";
-import pc4 from "picocolors";
+import pc6 from "picocolors";
 
 // package.json
 var package_default = {
   name: "@cam5/baby-bird",
-  version: "0.1.0",
+  version: "0.1.2",
   description: "Guided code tours for git changes, on the command line.",
   license: "MIT",
   type: "module",
@@ -73,6 +80,7 @@ var package_default = {
   },
   dependencies: {
     commander: "^15.0.0",
+    lowlight: "^3.3.0",
     picocolors: "^1.1.1",
     zod: "^4.6.2"
   },
@@ -101,6 +109,7 @@ function flagsToOverrides(flags) {
   else if (flags.color === false) o.render = { color: "never" };
   if (flags.cache === false) o.cache = { enabled: false };
   if (flags.pager === false) o.render = { ...o.render ?? {}, pager: "never" };
+  if (flags.highlight === false) o.render = { ...o.render ?? {}, highlight: "never" };
   return o;
 }
 async function openSession(flags, opts) {
@@ -126,6 +135,10 @@ function resolveColor(mode) {
   if (mode === "never") return false;
   return Boolean(process.stdout.isTTY) && process.env.TERM !== "dumb";
 }
+function resolveHighlight(mode, colorEnabled) {
+  if (mode === "never") return false;
+  return colorEnabled;
+}
 function terminalWidth(configured, stream = process.stdout) {
   return configured ?? (stream.columns || 80);
 }
@@ -191,6 +204,13 @@ async function configCommand(flags) {
   } catch (err) {
     out.push(`  ${c.red(err.message)}`);
   }
+  try {
+    const chat = resolveChat(config);
+    const provider = new CommandProvider({ command: chat.command, promptVia: "arg", timeoutMs: 1 });
+    out.push(`  chat:     ${provider.describe()}${c.dim("  (bb ask)")}`);
+  } catch (err) {
+    out.push(`  chat:     ${c.dim(`none: ${err.message}`)}`);
+  }
   out.push("");
   out.push(c.bold("Presets"));
   const presets = allPresets(config);
@@ -205,6 +225,311 @@ async function configCommand(flags) {
   process.stdout.write(out.join("\n") + "\n");
 }
 
+// src/cli/ask-cmd.ts
+import pc5 from "picocolors";
+
+// src/cli/progress.ts
+import pc4 from "picocolors";
+var SPINNER = ["\u2722", "\u2733", "\u2736", "\u273B", "\u273D", "\u273B", "\u2736", "\u2733"];
+var VERBS = ["Hatching", "Pecking", "Nesting", "Chirping", "Preening", "Fledging", "Brooding", "Warbling", "Peeping", "Squawking", "Swooping", "Tweeting", "Xeeting", "Cawing", "Twiddling About", "Hopping", "\u{1F425}-ing", "\u{1F423}-ing", "Masticating"];
+var THINKING_TAIL_CHARS = 2e3;
+var VERB_INTERVAL_MS = 7500;
+var LiveProgress = class {
+  constructor(stream, opts) {
+    this.stream = stream;
+    this.opts = opts;
+    this.now = opts.now ?? Date.now;
+    this.startedAt = this.now();
+    this.verbs = opts.verb ? [opts.verb] : opts.verbs && opts.verbs.length ? opts.verbs : shuffle(VERBS);
+    this.windowLines = opts.windowLines ?? 5;
+  }
+  stream;
+  opts;
+  phaseLabel = "";
+  stage = "prep";
+  thinking = "";
+  pulses = 0;
+  answer = "";
+  titles = [];
+  notices = [];
+  outputBytes = 0;
+  usage = {};
+  startedAt;
+  frameIndex = 0;
+  lastLines = 0;
+  timer = null;
+  stopped = false;
+  verbs;
+  now;
+  windowLines;
+  onSigint = () => {
+    this.stop();
+    process.exit(130);
+  };
+  start() {
+    this.stream.write("\x1B[?25l");
+    process.once("SIGINT", this.onSigint);
+    this.timer = setInterval(() => {
+      this.frameIndex++;
+      this.render();
+    }, this.opts.frameMs ?? 80);
+    this.timer.unref?.();
+    this.render();
+  }
+  phase(label) {
+    this.phaseLabel = label;
+    if (/^asking/i.test(label)) {
+      this.stage = "thinking";
+      this.thinking = "";
+      this.pulses = 0;
+      this.answer = "";
+      this.titles = [];
+      this.notices = [];
+      this.outputBytes = 0;
+    } else if (this.stage !== "prep") {
+      this.stage = "prep";
+    }
+    this.render();
+  }
+  llm(event) {
+    switch (event.type) {
+      case "thinking":
+        this.thinking += event.text;
+        this.stage = "thinking";
+        break;
+      case "thinking-pulse":
+        this.pulses++;
+        this.stage = "thinking";
+        break;
+      case "answer-start":
+        this.answer = "";
+        this.titles = [];
+        break;
+      case "notice":
+        this.notices.push(event.text);
+        break;
+      case "text":
+        this.answer += event.text;
+        this.titles = extractTitles(this.answer);
+        this.stage = "writing";
+        break;
+      case "output":
+        this.outputBytes = event.bytes;
+        this.stage = "output";
+        break;
+      case "usage":
+        if (event.outputTokens !== void 0) this.usage.outputTokens = event.outputTokens;
+        if (event.thinkingTokens !== void 0) this.usage.thinkingTokens = event.thinkingTokens;
+        if (event.model !== void 0) this.usage.model = event.model;
+        break;
+      default:
+        break;
+    }
+  }
+  /** The lines that make up the current status block. */
+  frame() {
+    const c = pc4.createColors(this.opts.color);
+    const width = Math.max(30, this.opts.width);
+    const spin = c.magenta(SPINNER[this.frameIndex % SPINNER.length]);
+    const elapsed = this.elapsed();
+    const fit = (s) => s.length > width - 1 ? s.slice(0, width - 2) + "\u2026" : s;
+    const lines = [];
+    switch (this.stage) {
+      case "prep":
+        lines.push(`${spin} ${fit(this.phaseLabel || "Starting")}\u2026 ${c.dim(elapsed)}`);
+        break;
+      case "thinking": {
+        const meta = [elapsed, this.phaseLabel.replace(/^asking\s+/i, "")].filter(Boolean).join(" \xB7 ");
+        lines.push(`${spin} ${this.verb()}\u2026 ${c.dim(meta)}`);
+        for (const n of this.notices.slice(-1)) lines.push(`  ${c.yellow("\u21BB")} ${c.yellow(fit(n).slice(0, width - 4))}`);
+        if (this.thinking) {
+          const tail = this.thinking.slice(-THINKING_TAIL_CHARS).replace(/\s+/g, " ").trim();
+          const wrapped = wrap(tail, width - 4).slice(-this.windowLines);
+          for (const l of wrapped) lines.push(`  ${c.dim("\u2502")} ${c.dim(l)}`);
+        } else if (this.pulses > 0) {
+          const room = Math.max(8, width - 16);
+          const n = this.pulses % (room + 1);
+          lines.push(`  ${c.dim("\u2502")} ${c.dim("reasoning")} ${c.magenta("\xB7".repeat(n))}`);
+        }
+        break;
+      }
+      case "writing": {
+        const n = Math.max(0, this.titles.length - 1);
+        lines.push(`${spin} Writing the tour\u2026 ${c.dim(`${elapsed} \xB7 ${n} section${n === 1 ? "" : "s"} so far`)}`);
+        for (const note of this.notices.slice(-1)) lines.push(`  ${c.yellow("\u21BB")} ${c.yellow(fit(note).slice(0, width - 4))}`);
+        const [tourTitle, ...sections] = this.titles;
+        const items = [];
+        if (tourTitle) items.push(`  \u{1F423} ${c.bold(fit(tourTitle).slice(0, width - 6))}`);
+        sections.forEach((t) => items.push(`  ${c.green("\u2713")} ${fit(t).slice(0, width - 5)}`));
+        for (const l of items.slice(-this.windowLines)) lines.push(l);
+        break;
+      }
+      case "output":
+        lines.push(`${spin} ${this.verb()}\u2026 ${c.dim(`${elapsed} \xB7 ${formatBytes(this.outputBytes)} received`)}`);
+        break;
+    }
+    return lines;
+  }
+  render() {
+    if (this.stopped) return;
+    const lines = this.frame();
+    this.stream.write(this.erase() + lines.join("\n") + "\n");
+    this.lastLines = lines.length;
+  }
+  /** Clear the block, restore the cursor, and optionally leave a final line behind. */
+  stop(finalLine) {
+    if (this.stopped) return;
+    this.stopped = true;
+    if (this.timer) clearInterval(this.timer);
+    process.removeListener("SIGINT", this.onSigint);
+    this.stream.write(this.erase() + (finalLine ? finalLine + "\n" : "") + "\x1B[?25h");
+    this.lastLines = 0;
+  }
+  /** A one-line summary of the model call, for the final line. */
+  summary() {
+    const c = pc4.createColors(this.opts.color);
+    const parts = [`Hatched in ${this.elapsed()}`];
+    if (this.usage.outputTokens) {
+      parts.push(`${formatCount(this.usage.outputTokens)} tokens${this.usage.thinkingTokens ? ` (${formatCount(this.usage.thinkingTokens)} thinking)` : ""}`);
+    }
+    if (this.usage.model) parts.push(this.usage.model);
+    return c.dim(`\u273B ${parts.join(" \xB7 ")}`);
+  }
+  /** The current verb; rotates every verbIntervalMs so long waits do not stare at one word. */
+  verb() {
+    const step = Math.floor((this.now() - this.startedAt) / (this.opts.verbIntervalMs ?? VERB_INTERVAL_MS));
+    return this.verbs[step % this.verbs.length];
+  }
+  elapsed() {
+    const s = Math.max(0, Math.round((this.now() - this.startedAt) / 1e3));
+    return s >= 60 ? `${Math.floor(s / 60)}m ${s % 60}s` : `${s}s`;
+  }
+  erase() {
+    return this.lastLines ? `\x1B[${this.lastLines}A\x1B[0J` : "";
+  }
+};
+function extractTitles(text) {
+  const out = [];
+  for (const m of text.matchAll(/"title"\s*:\s*"((?:[^"\\]|\\.)*)"/g)) {
+    out.push(m[1].replace(/\\(["\\/bfnrt]|u[0-9a-fA-F]{4})/g, (_, esc) => {
+      switch (esc[0]) {
+        case '"':
+          return '"';
+        case "\\":
+          return "\\";
+        case "/":
+          return "/";
+        case "n":
+          return "\n";
+        case "t":
+          return "	";
+        case "u":
+          return String.fromCharCode(parseInt(esc.slice(1), 16));
+        default:
+          return "";
+      }
+    }));
+  }
+  return out;
+}
+function loggingProgress(log) {
+  return {
+    phase: (label) => log(label),
+    llm: () => {
+    }
+  };
+}
+function shuffle(items) {
+  const out = [...items];
+  for (let i = out.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [out[i], out[j]] = [out[j], out[i]];
+  }
+  return out;
+}
+function formatBytes(n) {
+  return n < 1024 ? `${n} B` : `${(n / 1024).toFixed(1)} KB`;
+}
+function formatCount(n) {
+  return n >= 1e3 ? `${(n / 1e3).toFixed(1)}k` : String(n);
+}
+
+// src/cli/ask-cmd.ts
+async function splitAskArgs(words, opts) {
+  const [first, ...rest] = words;
+  if (first !== void 0 && opts.rangeAllowed && await isRange(first, opts.cwd)) {
+    return { range: first, message: joinMessage(rest) };
+  }
+  return { message: joinMessage(words) };
+}
+async function isRange(word, cwd) {
+  if (!word || /\s/.test(word)) return false;
+  const res = await git(["rev-parse", "--quiet", "--end-of-options", word], { cwd, allowFailure: true });
+  return res.code === 0;
+}
+function joinMessage(words) {
+  const text = words.join(" ").trim();
+  return text ? text : void 0;
+}
+async function askCommand(words, flags) {
+  const session = await openSession(flags, { requireRepo: true });
+  if (!session.root) throw new NotARepoError(session.cwd);
+  const { config } = session.loaded;
+  const c = pc5.createColors(session.colorEnabled);
+  const chat = resolveChat(config);
+  const slots = chatSlots(chat.command);
+  if (!slots.context) {
+    throw new ConfigError("The chat command has no {context-file} or {context} token, so the tour cannot be handed to it.", "Add one of them to the chatCommand; see the README.");
+  }
+  const llm = resolveLlm(config);
+  const { range, message } = await splitAskArgs(words, { cwd: session.root, rangeAllowed: !flags.working && !flags.staged });
+  session.debug(range ? `range: ${range}` : "no range argument");
+  session.debug(message ? `opening message: ${JSON.stringify(message)}` : "no opening message");
+  const live = flags.progress !== false && !flags.debug && Boolean(process.stderr.isTTY) && !flags.dumpContext;
+  const progress = live ? new LiveProgress(process.stderr, { color: session.colorEnabled, width: terminalWidth(null, process.stderr) }) : loggingProgress(session.debug);
+  const options = {
+    cwd: session.root,
+    config,
+    cacheDir: session.loaded.cacheDir,
+    range: { arg: range, working: flags.working, staged: flags.staged },
+    refresh: flags.refresh,
+    noCache: flags.cache === false,
+    debug: session.debug,
+    warn: session.warn,
+    progress
+  };
+  if (progress instanceof LiveProgress) progress.start();
+  let prepared;
+  let result;
+  try {
+    prepared = await prepareTour(options);
+    result = await generateTour(options, prepared);
+  } catch (err) {
+    if (progress instanceof LiveProgress) progress.stop();
+    throw err;
+  }
+  if (progress instanceof LiveProgress) progress.stop(result.fromCache ? void 0 : progress.summary());
+  const context = buildChatContext({ tour: result.tour, change: prepared.context, maxBytes: llm.maxPromptBytes, tourPath: result.cachePath });
+  if (context.truncation.truncated.length || context.truncation.omitted.length) {
+    session.warn(`Chat context exceeded ${llm.maxPromptBytes} bytes; truncated ${context.truncation.truncated.length} and omitted ${context.truncation.omitted.length} file diff(s).`);
+  }
+  if (flags.dumpContext) {
+    await writeStdout(context.text.endsWith("\n") ? context.text : context.text + "\n");
+    return;
+  }
+  const tour = result.tour;
+  const when = result.fromCache ? `cached ${relativeTime(tour.generatedAt)}` : "generated just now";
+  process.stderr.write(`${c.bold(`\u{1F423} ${tour.title}`)}${c.dim(` \xB7 ${describeSource(tour.source)} \xB7 ${when}`)}
+`);
+  if (message && !slots.message) {
+    session.warn("This chat command has no {message} slot; type your question into the chat once it opens.");
+  }
+  process.stderr.write(c.dim(`Opening ${chat.preset ?? chat.command[0]} with the tour as context\u2026
+`));
+  const outcome = await launchChat({ command: chat.command, context: context.text, message, cwd: session.root, env: chat.env, debug: session.debug });
+  process.exitCode = outcome.exitCode;
+}
+
 // src/cli/init-cmd.ts
 import { mkdir, writeFile } from "fs/promises";
 import { dirname } from "path";
@@ -232,6 +557,8 @@ async function tourCommand(rangeArg, flags) {
   const session = await openSession(flags, { requireRepo: true });
   if (!session.root) throw new NotARepoError(session.cwd);
   const { config } = session.loaded;
+  const live = flags.progress !== false && !flags.debug && Boolean(process.stderr.isTTY) && !flags.dumpPrompt;
+  const progress = live ? new LiveProgress(process.stderr, { color: session.colorEnabled, width: terminalWidth(null, process.stderr) }) : loggingProgress(session.debug);
   const options = {
     cwd: session.root,
     config,
@@ -240,14 +567,23 @@ async function tourCommand(rangeArg, flags) {
     refresh: flags.refresh,
     noCache: flags.cache === false,
     debug: session.debug,
-    warn: session.warn
+    warn: session.warn,
+    progress
   };
-  const prepared = await prepareTour(options);
-  if (flags.dumpPrompt) {
-    await writeStdout(prepared.built.prompt.endsWith("\n") ? prepared.built.prompt : prepared.built.prompt + "\n");
-    return;
+  if (progress instanceof LiveProgress) progress.start();
+  let result;
+  try {
+    const prepared = await prepareTour(options);
+    if (flags.dumpPrompt) {
+      await writeStdout(prepared.built.prompt.endsWith("\n") ? prepared.built.prompt : prepared.built.prompt + "\n");
+      return;
+    }
+    result = await generateTour(options, prepared);
+  } catch (err) {
+    if (progress instanceof LiveProgress) progress.stop();
+    throw err;
   }
-  const result = await generateTour(options, prepared);
+  if (progress instanceof LiveProgress) progress.stop(result.fromCache ? void 0 : progress.summary());
   if (flags.json) {
     await writeStdout(JSON.stringify(result.tour, null, 2) + "\n");
     return;
@@ -257,7 +593,8 @@ async function tourCommand(rangeArg, flags) {
     color: session.colorEnabled,
     width: terminalWidth(config.render.width),
     section: flags.section,
-    fromCache: result.fromCache
+    fromCache: result.fromCache,
+    highlight: resolveHighlight(config.render.highlight, session.colorEnabled)
   });
   await writeMaybePaged(output, {
     mode: config.render.pager,
@@ -272,6 +609,9 @@ function positiveInt(value) {
   if (!Number.isInteger(n) || n < 1) throw new InvalidArgumentError("must be a positive integer");
   return n;
 }
+function optsWithGlobals(cmd) {
+  return cmd.optsWithGlobals();
+}
 function addGlobalFlags(cmd) {
   return cmd.option("-C, --cwd <dir>", "run as if started in <dir>").option("--preset <name>", "LLM preset to use (see `bb config`)").option("--color", "force colored output").option("--no-color", "disable colored output").option("--debug", "print diagnostics (resolved range, prompt size, raw model output) to stderr");
 }
@@ -280,8 +620,8 @@ process.stdout.on("error", (err) => {
   throw err;
 });
 var program = new Command();
-program.name("bb").description("Guided code tours for git changes, on the command line.").version(package_default.version, "-V, --version").configureOutput({ outputError: (str, write) => write(pc4.red(str)) }).showHelpAfterError("(run with --help for usage)");
-addGlobalFlags(program).argument("[range]", "what to tour: A..B, A...B, or a single ref (compared at its merge-base with HEAD)").option("-w, --working", "tour uncommitted changes in the working tree (tracked and untracked)").option("-s, --staged", "tour staged changes only").option("--section <n>", "render only section <n>", positiveInt).option("--json", "print the tour as JSON instead of rendering it").option("--dump-prompt", "print the prompt that would be sent to the model and exit").option("--refresh", "ignore a cached tour and regenerate it").option("--no-cache", "neither read nor write the tour cache").option("--no-pager", "never pipe output through a pager").addHelpText(
+program.name("bb").description("Guided code tours for git changes, on the command line.").version(package_default.version, "-V, --version").enablePositionalOptions().configureOutput({ outputError: (str, write) => write(pc6.red(str)) }).showHelpAfterError("(run with --help for usage)");
+addGlobalFlags(program).argument("[range]", "what to tour: A..B, A...B, or a single ref (compared at its merge-base with HEAD)").option("-w, --working", "tour uncommitted changes in the working tree (tracked and untracked)").option("-s, --staged", "tour staged changes only").option("--section <n>", "render only section <n>", positiveInt).option("--json", "print the tour as JSON instead of rendering it").option("--dump-prompt", "print the prompt that would be sent to the model and exit").option("--refresh", "ignore a cached tour and regenerate it").option("--no-cache", "neither read nor write the tour cache").option("--no-pager", "never pipe output through a pager").option("--no-highlight", "plain excerpts with green/red +/- signs instead of syntax colors").option("--no-progress", "do not show the live status block while generating").addHelpText(
   "after",
   `
 Examples:
@@ -292,34 +632,51 @@ Examples:
   bb --section 2         show only the second section
   bb --json | jq         machine-readable output
   bb --preset claude-sonnet --refresh
+  bb ask HEAD~1 "what changed in progress.ts?"   chat about a tour (see bb ask --help)
 `
 ).action(async (range, flags) => {
   await tourCommand(range, flags);
 });
+addGlobalFlags(program.command("ask").description("chat with the LLM about a tour (the tour is generated or taken from the cache first)")).argument("[range]", "what to tour, as for `bb`; omit it to tour the same thing bare `bb` would").argument("[message...]", "opening message for the chat").option("-w, --working", "tour uncommitted changes in the working tree (tracked and untracked)").option("-s, --staged", "tour staged changes only").option("--refresh", "ignore a cached tour and regenerate it").option("--no-cache", "neither read nor write the tour cache").option("--no-progress", "do not show the live status block while generating").option("--dump-context", "print the context that would be handed to the chat and exit").addHelpText(
+  "after",
+  `
+The first word is taken as a range only when git can resolve it (HEAD~3, main..feature);
+everything else is the opening message. The chat command comes from the preset (see \`bb config\`).
+
+Examples:
+  bb ask                                     chat about the current branch's tour
+  bb ask "why does the cache key include the command?"
+  bb ask HEAD~1 "what is going on in progress.ts?"
+  bb ask main..feature --preset claude-opus
+  bb ask --staged "is this safe to commit?"
+`
+).action(async (range, message, _flags, cmd) => {
+  await askCommand([range, ...message].filter((w) => w !== void 0), optsWithGlobals(cmd));
+});
 var cache = program.command("cache").description("manage cached tours");
-addGlobalFlags(cache.command("ls").description("list cached tours")).action(cacheLsCommand);
-addGlobalFlags(cache.command("clear").description("delete all cached tours")).action(cacheClearCommand);
-addGlobalFlags(cache.command("path").description("print the cache directory")).action(cachePathCommand);
-addGlobalFlags(program.command("config").description("show the effective configuration, its sources, and available presets")).option("--json", "print only the effective config as JSON").action(configCommand);
-addGlobalFlags(program.command("init").description("write a starter .baby-bird/config.json in this repository")).option("--force", "overwrite an existing project config").action(initCommand);
+addGlobalFlags(cache.command("ls").description("list cached tours")).action((_flags, cmd) => cacheLsCommand(optsWithGlobals(cmd)));
+addGlobalFlags(cache.command("clear").description("delete all cached tours")).action((_flags, cmd) => cacheClearCommand(optsWithGlobals(cmd)));
+addGlobalFlags(cache.command("path").description("print the cache directory")).action((_flags, cmd) => cachePathCommand(optsWithGlobals(cmd)));
+addGlobalFlags(program.command("config").description("show the effective configuration, its sources, and available presets")).option("--json", "print only the effective config as JSON").action((_flags, cmd) => configCommand(optsWithGlobals(cmd)));
+addGlobalFlags(program.command("init").description("write a starter .baby-bird/config.json in this repository")).option("--force", "overwrite an existing project config").action((_flags, cmd) => initCommand(optsWithGlobals(cmd)));
 program.parseAsync(process.argv).catch((err) => {
   const debug = process.argv.includes("--debug");
   if (err instanceof BbError) {
-    process.stderr.write(pc4.red(`error: ${err.message}
+    process.stderr.write(pc6.red(`error: ${err.message}
 `));
-    if (err.hint) process.stderr.write(pc4.dim(`${err.hint}
+    if (err.hint) process.stderr.write(pc6.dim(`${err.hint}
 `));
-    if (debug && err instanceof BadLlmOutputError) process.stderr.write(pc4.dim(`--- raw model output ---
+    if (debug && err instanceof BadLlmOutputError) process.stderr.write(pc6.dim(`--- raw model output ---
 ${err.raw}
 `));
-    if (debug && err.cause) process.stderr.write(pc4.dim(`${String(err.cause.stack ?? err.cause)}
+    if (debug && err.cause) process.stderr.write(pc6.dim(`${String(err.cause.stack ?? err.cause)}
 `));
     process.exitCode = err.exitCode;
     return;
   }
-  process.stderr.write(pc4.red(`error: ${err.message ?? String(err)}
+  process.stderr.write(pc6.red(`error: ${err.message ?? String(err)}
 `));
-  if (debug && err.stack) process.stderr.write(pc4.dim(`${err.stack}
+  if (debug && err.stack) process.stderr.write(pc6.dim(`${err.stack}
 `));
   process.exitCode = 1;
 });