@kaynooo/cli-workspace 0.2.0 → 0.3.0

package/dist/cli.js

@@ -2,7 +2,7 @@
 // @bun
 
 // src/cli.ts
-import process16 from "process";
+import process18 from "process";
 
 // ../kit/src/advisory.ts
 var SEVERITIES = ["low", "moderate", "high", "critical"];
@@ -13,14 +13,14 @@ function isIgnored(advisory, ignore) {
   return ignore.includes(advisory.ghsa ?? "") || ignore.includes(String(advisory.id));
 }
 // ../kit/src/args.ts
-import process5 from "process";
+import process8 from "process";
 import { parseArgs } from "util";
 
 // ../kit/src/format.ts
-import process3 from "process";
+import process6 from "process";
 
 // ../kit/src/style.ts
-import process2 from "process";
+import process5 from "process";
 
 // ../../node_modules/.bun/@kaynooo+utils@2.31.2+d0769e28dc4dad16/node_modules/@kaynooo/utils/dist/chunk-mtetydvc.js
 function x(s) {
@@ -283,52 +283,236 @@ function le(i = {}) {
 }
 var t = le();
 
-// ../kit/src/style.ts
-var MARKS = {
-  ok: { symbol: "\u2713", word: "ok:", paint: (colors) => colors.green },
-  warn: { symbol: "!", word: "warning:", paint: (colors) => colors.yellow },
-  problem: { symbol: "\u2717", word: "error:", paint: (colors) => colors.red },
-  note: { symbol: "\xB7", word: "note:", paint: (colors) => colors.dim }
+// ../kit/src/theme.ts
+import { existsSync as existsSync3, readFileSync, statSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join3, resolve as resolve2 } from "path";
+import process4 from "process";
+
+// ../kit/src/config.ts
+import { existsSync } from "fs";
+import { dirname, join, resolve } from "path";
+import process2 from "process";
+function findUp(names, from = process2.cwd(), stop = () => false) {
+  const wanted = typeof names === "string" ? [names] : names;
+  for (let dir = resolve(from);; dir = dirname(dir)) {
+    const found = wanted.map((name) => join(dir, name)).find((path) => existsSync(path));
+    if (found !== undefined)
+      return found;
+    if (stop(dir) || dirname(dir) === dir)
+      return;
+  }
+}
+
+// ../kit/src/user-config.ts
+import { existsSync as existsSync2 } from "fs";
+import { homedir } from "os";
+import { join as join2 } from "path";
+import process3 from "process";
+function configBase(where = {}) {
+  const xdg = where.xdg ?? (where.home === undefined ? process3.env.XDG_CONFIG_HOME : undefined);
+  return xdg !== undefined && xdg !== "" ? xdg : join2(where.home ?? homedir(), ".config");
+}
+function userConfigPath(bin, where = {}) {
+  return join2(configBase(where), "kaynooo-cli", `${bin}.json`);
+}
+function userConfigReadPath(bin, legacy = [], where = {}) {
+  const current = userConfigPath(bin, where);
+  if (existsSync2(current))
+    return current;
+  const base = configBase(where);
+  return legacy.map((parts) => join2(base, ...parts)).find((path) => existsSync2(path)) ?? current;
+}
+
+// ../kit/src/theme.ts
+var DEFAULT = {
+  colors: { accent: "cyan", id: "yellow", path: "blue", label: "dim", value: "bold", ok: "green", warn: "yellow", problem: "red", note: "dim", passed: "green", failed: "red", running: "cyan", queued: "yellow", skipped: "dim" },
+  glyphs: { ok: "\u2713", warn: "\u25B2", problem: "\u2717", note: "\u203A", passed: "\u2713", failed: "\u2717", running: "\u25CF", queued: "\u25CB", skipped: "-", bar: "\u2501" },
+  accents: ["cyan", "magenta", "green", "blue", "yellow", "redBright"],
+  bins: {}
 };
-function takesControlCodes(stream, env = process2.env) {
+var BRIGHT = { accent: "cyanBright", id: "yellowBright", path: "blueBright", label: "white", value: "bold whiteBright", ok: "greenBright", warn: "yellowBright", problem: "redBright", note: "white", passed: "greenBright", failed: "redBright", running: "cyanBright", queued: "yellowBright", skipped: "white" };
+var MONO = { accent: "bold", id: "bold", path: "underline", label: "dim", value: "bold", ok: "bold", warn: "bold", problem: "bold", note: "dim", passed: "bold", failed: "bold", running: "bold", queued: "dim", skipped: "dim" };
+var ASCII = { ok: "+", warn: "!", problem: "x", note: ">", passed: "+", failed: "x", running: "*", queued: "o", skipped: "-", bar: "#" };
+var PRESETS = {
+  default: {},
+  "high-contrast": { colors: BRIGHT, accents: ["cyanBright", "magentaBright", "greenBright", "blueBright", "yellowBright", "redBright"] },
+  mono: { colors: MONO, accents: ["bold"] },
+  ascii: { glyphs: ASCII }
+};
+var STYLES = new Set(["bold", "dim", "italic", "underline", "inverse", "strikethrough", "black", "red", "green", "yellow", "blue", "magenta", "cyan", "white", "gray", "grey", "blackBright", "redBright", "greenBright", "yellowBright", "blueBright", "magentaBright", "cyanBright", "whiteBright"]);
+var HEX = /^#[0-9a-f]{6}$/i;
+var CONTROL = /\p{Cc}/u;
+var MAX_FILE_BYTES = 64 * 1024;
+var SPACES = /\s+/;
+function isColorSpec(spec) {
+  if (typeof spec === "number")
+    return Number.isInteger(spec) && spec >= 0 && spec <= 255;
+  return typeof spec === "string" && spec.trim() !== "" && spec.trim().split(SPACES).every((token) => STYLES.has(token) || HEX.test(token));
+}
+function tinted(colors, spec) {
+  if (typeof spec === "number")
+    return colors.ansi256(spec);
+  return spec.trim().split(SPACES).reduce((chain, token) => HEX.test(token) ? chain.hex(token) : chain[token] ?? chain, colors);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readThemeFile(path, warn) {
+  try {
+    const stat = statSync(path, { throwIfNoEntry: false });
+    if (stat === undefined)
+      return;
+    if (!stat.isFile() || stat.size > MAX_FILE_BYTES) {
+      warn(`${path} is not a regular file under ${MAX_FILE_BYTES / 1024} KiB, theme ignored`);
+      return;
+    }
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (isRecord(parsed))
+      return parsed;
+    warn(`${path} is not a JSON object, theme ignored`);
+  } catch (error) {
+    warn(`${path} does not parse (${error instanceof Error ? error.message : String(error)}), theme ignored`);
+  }
+  return;
+}
+function applyPreset(theme, name, warn, where) {
+  if (name === undefined)
+    return;
+  if (typeof name !== "string" || !Object.hasOwn(PRESETS, name)) {
+    warn(`${where}: no preset ${String(name)}, one of ${Object.keys(PRESETS).join(", ")}`);
+    return;
+  }
+  const preset = PRESETS[name];
+  Object.assign(theme.colors, preset.colors);
+  Object.assign(theme.glyphs, preset.glyphs);
+  if (preset.accents !== undefined)
+    theme.accents = [...preset.accents];
+  return name;
+}
+function applyFile(theme, file, where, warn) {
+  if (isRecord(file.colors)) {
+    for (const [key, value] of Object.entries(file.colors)) {
+      if (!Object.hasOwn(DEFAULT.colors, key))
+        warn(`${where}: no colour ${key}, one of ${Object.keys(DEFAULT.colors).join(", ")}`);
+      else if (!isColorSpec(value))
+        warn(`${where}: colour ${key} is not an ANSI name, \`#rrggbb\` or a number up to 255`);
+      else
+        theme.colors[key] = value;
+    }
+  }
+  if (isRecord(file.glyphs)) {
+    for (const [key, value] of Object.entries(file.glyphs)) {
+      if (!Object.hasOwn(DEFAULT.glyphs, key))
+        warn(`${where}: no glyph ${key}, one of ${Object.keys(DEFAULT.glyphs).join(", ")}`);
+      else if (typeof value !== "string" || CONTROL.test(value) || Bun.stringWidth(value) !== 1)
+        warn(`${where}: glyph ${key} must be one visible character wide, with no control character`);
+      else
+        theme.glyphs[key] = value;
+    }
+  }
+  if (Array.isArray(file.accents) && file.accents.length > 0 && file.accents.every(isColorSpec))
+    theme.accents = [...file.accents];
+  else if (file.accents !== undefined)
+    warn(`${where}: accents must be a non-empty list of colours`);
+  if (isRecord(file.bins)) {
+    for (const [bin, value] of Object.entries(file.bins)) {
+      if (isColorSpec(value))
+        theme.bins[bin] = value;
+      else
+        warn(`${where}: bin ${bin} has no valid colour`);
+    }
+  }
+}
+function endsWalk(home) {
+  return (dir) => dir === resolve2(home) || existsSync3(join3(dir, ".git"));
+}
+var warned = new Set;
+function warnOnce(message) {
+  if (warned.has(message))
+    return;
+  warned.add(message);
+  console.error(`warning: theme ${message}`);
+}
+function isPath(chosen) {
+  return chosen.includes("/") || chosen.endsWith(".json");
+}
+function loadTheme({ env = process4.env, from = process4.cwd(), home = homedir2(), warn = warnOnce } = {}) {
+  const theme = { colors: { ...DEFAULT.colors }, glyphs: { ...DEFAULT.glyphs }, accents: [...DEFAULT.accents], bins: Object.create(null) };
+  const sources = [];
+  const chosen = env.KIT_THEME ?? "";
+  const wanted = chosen === "" ? [userConfigPath("theme", { home, xdg: env.XDG_CONFIG_HOME }), findUp(join3(".kaynooo", "theme.json"), from, endsWalk(home))] : [];
+  if (isPath(chosen))
+    wanted.push(resolve2(from, chosen));
+  const files = [];
+  for (const path of wanted) {
+    const file = path === undefined ? undefined : readThemeFile(path, warn);
+    if (path !== undefined && file !== undefined)
+      files.push({ path, file });
+  }
+  let preset = "default";
+  if (chosen !== "" && !isPath(chosen)) {
+    preset = applyPreset(theme, chosen, warn, "KIT_THEME") ?? preset;
+  } else {
+    const named = files.findLast(({ file }) => file.preset !== undefined);
+    if (named !== undefined)
+      preset = applyPreset(theme, named.file.preset, warn, named.path) ?? preset;
+  }
+  for (const { path, file } of files) {
+    applyFile(theme, file, path, warn);
+    sources.push(path);
+  }
+  return { theme, sources, preset };
+}
+var current;
+var currentKey = "";
+function activeTheme() {
+  const key = `${process4.cwd()}\x00${process4.env.KIT_THEME ?? ""}\x00${process4.env.XDG_CONFIG_HOME ?? ""}`;
+  if (current === undefined || key !== currentKey) {
+    current = loadTheme();
+    currentKey = key;
+  }
+  return current;
+}
+
+// ../kit/src/style.ts
+var MARK_WORDS = { ok: "ok:", warn: "warning:", problem: "error:", note: "note:" };
+function takesControlCodes(stream, env = process5.env) {
   return stream.isTTY === true && env.NO_COLOR === undefined && env.NODE_DISABLE_COLORS === undefined && env.TERM !== "dumb";
 }
-function paint(stream, env = process2.env) {
+function paint(stream, env = process5.env) {
   return le({ stream: { isTTY: takesControlCodes(stream, env) }, env });
 }
-function marked(mark, text, stream, detail, env = process2.env) {
+function marked(mark, text, stream, detail, env = process5.env) {
   const colors = paint(stream, env);
-  const { symbol, word, paint: tint } = MARKS[mark];
-  const head = takesControlCodes(stream, env) ? tint(colors)(symbol) : word;
+  let head = MARK_WORDS[mark];
+  if (takesControlCodes(stream, env)) {
+    const { theme } = activeTheme();
+    head = tinted(colors.bold, theme.colors[mark])(theme.glyphs[mark]);
+  }
   return `${head} ${text}${detail === undefined ? "" : ` ${colors.dim(detail)}`}`;
 }
 function ok(text, detail) {
-  console.log(marked("ok", text, process2.stdout, detail));
+  console.log(marked("ok", text, process5.stdout, detail));
 }
 function note(text, detail) {
-  console.log(marked("note", text, process2.stdout, detail));
+  console.log(marked("note", text, process5.stdout, detail));
 }
 function problem(text, detail) {
-  console.error(marked("problem", text, process2.stderr, detail));
-}
-var ROLES = {
-  accent: (colors) => colors.cyan,
-  id: (colors) => colors.yellow,
-  path: (colors) => colors.blue,
-  label: (colors) => colors.dim,
-  value: (colors) => colors.bold
-};
-function role(name, stream, env = process2.env) {
-  return ROLES[name](paint(stream, env));
-}
-var STATUSES = {
-  passed: { symbol: "\u2713", words: ["passed", "success", "succeeded", "ok"], paint: (colors) => colors.green },
-  failed: { symbol: "\u2717", words: ["failed", "failure", "error", "errored"], paint: (colors) => colors.red },
-  running: { symbol: "\u25CF", words: ["running", "in_progress", "started"], paint: (colors) => colors.cyan },
-  queued: { symbol: "\u25CB", words: ["queued", "waiting", "pending", "created", "blocked", "scheduled"], paint: (colors) => colors.yellow },
-  skipped: { symbol: "-", words: ["skipped", "cancelled", "canceled", "manual"], paint: (colors) => colors.dim }
+  console.error(marked("problem", text, process5.stderr, detail));
+}
+function role(name, stream, env = process5.env) {
+  const colors = paint(stream, env);
+  return takesControlCodes(stream, env) ? tinted(colors, activeTheme().theme.colors[name]) : colors;
+}
+var STATUS_WORDS = {
+  passed: ["passed", "success", "succeeded", "ok"],
+  failed: ["failed", "failure", "error", "errored"],
+  running: ["running", "in_progress", "started"],
+  queued: ["queued", "waiting", "pending", "created", "blocked", "scheduled"],
+  skipped: ["skipped", "cancelled", "canceled", "manual"]
 };
-var STATUS_OF = new Map(Object.entries(STATUSES).flatMap(([status, { words }]) => words.map((word) => [word, status])));
+var STATUS_OF = new Map(Object.entries(STATUS_WORDS).flatMap(([status, words]) => words.map((word) => [word, status])));
 // ../../node_modules/.bun/@kaynooo+utils@2.31.2+d0769e28dc4dad16/node_modules/@kaynooo/utils/dist/chunk-hrsswv1w.js
 function $e(t, e = false, i = 1) {
   let n = typeof e === "object" ? e : { units: e ? "si" : "iec", dp: i }, { units: s = "iec", dp: u = 1 } = n, r = s === "si" ? 1000 : 1024;
@@ -378,7 +562,7 @@ var ESCAPE = String.fromCharCode(27);
 function textWidth(text) {
   return Bun.stringWidth(text);
 }
-function table(rows, { cellWidth, header = false, align = [], fit } = {}) {
+function table(rows, { cellWidth, header = false, align = [], fit, stream = process6.stdout } = {}) {
   const cells = cellWidth === undefined ? rows : rows.map((row) => row.map((cell) => truncate(cell.replaceAll(LINE_BREAKS, " "), cellWidth)));
   const widths = [];
   for (const row of cells) {
@@ -386,7 +570,7 @@ function table(rows, { cellWidth, header = false, align = [], fit } = {}) {
       widths[index] = Math.max(widths[index] ?? 0, textWidth(cell));
   }
   const shown = fit === undefined ? cells : narrow(cells, widths, fit);
-  const colors = paint(process3.stdout);
+  const colors = paint(stream);
   const lines = shown.map((row) => row.map((cell, index) => {
     const width = widths[index] ?? 0;
     const gap = " ".repeat(Math.max(0, width - textWidth(cell)));
@@ -394,7 +578,8 @@ function table(rows, { cellWidth, header = false, align = [], fit } = {}) {
       return `${gap}${cell}`;
     return index === row.length - 1 ? cell : `${cell}${gap}`;
   }).join("  ").trimEnd());
-  return lines.map((line, index) => header && index === 0 ? colors.bold(line) : line).join(`
+  const rule = header && takesControlCodes(stream) && lines.length > 1 ? [colors.dim("\u2500".repeat(Math.max(...lines.map(textWidth))))] : [];
+  return lines.flatMap((line, index) => header && index === 0 ? [colors.bold(line), ...rule] : [line]).join(`
 `);
 }
 function narrow(rows, widths, limit) {
@@ -418,27 +603,27 @@ function printJson(value) {
 }
 
 // ../kit/src/help.ts
-import process4 from "process";
+import process7 from "process";
 var OPTIONAL = /\[[^\]]+\]/g;
 var USAGE_PREFIX = /^usage:\s*/i;
 var FULL_STOP = /\.$/;
-function usageLine(usage, colors = paint(process4.stdout)) {
+function usageLine(usage, colors = paint(process7.stdout)) {
   return `${colors.bold("Usage:")} ${usage.replace(USAGE_PREFIX, "").replaceAll(OPTIONAL, (part) => colors.dim(part))}`;
 }
-function helpText(usage, options, colors = paint(process4.stdout), { examples = [], replaces, exits = [] } = {}) {
+function helpText(usage, options, colors = paint(process7.stdout), { examples = [], replaces, exits = [] } = {}) {
   return [usageLine(usage, colors), ...replacesRows(replaces, colors), "", colors.bold("Options:"), ...optionRows(options, colors), ...exitRows(exits, colors), ...exampleRows(examples, colors)].join(`
 `);
 }
-function exitRows(exits, colors = paint(process4.stdout)) {
+function exitRows(exits, colors = paint(process7.stdout)) {
   if (exits.length === 0)
     return [];
   const width = Math.max(...exits.map(([code]) => String(code).length));
   return ["", colors.bold("Exits:"), ...exits.map(([code, meaning]) => `  ${colors.cyan(String(code).padEnd(width))}  ${meaning}`)];
 }
-function replacesRows(replaces, colors = paint(process4.stdout)) {
+function replacesRows(replaces, colors = paint(process7.stdout)) {
   return replaces === undefined ? [] : ["", `${colors.bold("Instead of:")} ${replaces}`];
 }
-function wantsHelpJson(env = process4.env) {
+function wantsHelpJson(env = process7.env) {
   return env.KIT_HELP === "json";
 }
 function description(usage, { examples = [], replaces, exits } = {}, options) {
@@ -457,12 +642,12 @@ function description(usage, { examples = [], replaces, exits } = {}, options) {
     ...options === undefined ? {} : { options: Object.entries(options).map(([name, { short, description }]) => ({ name, ...short === undefined ? {} : { short }, ...description === undefined ? {} : { description } })) }
   };
 }
-function exampleRows(examples, colors = paint(process4.stdout)) {
+function exampleRows(examples, colors = paint(process7.stdout)) {
   if (examples.length === 0)
     return [];
   return ["", colors.bold("Examples:"), ...examples.map((example) => typeof example === "string" ? `  ${example}` : `  ${example[0]}  ${colors.dim(`# ${example[1]}`)}`)];
 }
-function optionRows(options, colors = paint(process4.stdout)) {
+function optionRows(options, colors = paint(process7.stdout)) {
   const rows = Object.entries(options).map(([name, option]) => {
     const short = option.short === undefined ? "    " : `${colors.cyan(`-${option.short}`)}, `;
     const named = option.choices === undefined ? "<value>" : `<${option.choices.join("|")}>`;
@@ -555,7 +740,7 @@ var OUTPUT_OPTIONS = {
   color: { type: "string", description: "auto (on a terminal alone), always or never" },
   plain: { type: "boolean", description: "plain text, no colour or spinner: --color never" }
 };
-function applyOutput(color, plain, env = process5.env) {
+function applyOutput(color, plain, env = process8.env) {
   const when = plain === true ? "never" : color ?? "auto";
   if (when === "auto")
     return;
@@ -726,7 +911,7 @@ function nearestOption(message, options, allowNegative) {
 }
 // ../kit/src/process.ts
 import { constants } from "os";
-import process6 from "process";
+import process9 from "process";
 var KILL_GRACE_MS = 2000;
 function exitCodeOf(code, signal) {
   if (code !== null)
@@ -746,7 +931,7 @@ async function runCommand(argv, { cwd, env, stdin = "ignore", timeoutMs, signal,
       return;
     try {
       if (grouped)
-        process6.kill(-proc.pid, killing);
+        process9.kill(-proc.pid, killing);
       else
         proc.kill(killing);
     } catch {}
@@ -821,10 +1006,10 @@ var RESET_STYLE = `${ESC}[0m`;
 var CLOSE_LINK = `${ESC}]8;;${ESC}\\`;
 
 // ../kit/src/tool.ts
-import process7 from "process";
+import process10 from "process";
 function cwdGone() {
   try {
-    process7.cwd();
+    process10.cwd();
     return false;
   } catch {
     return true;
@@ -846,7 +1031,7 @@ function spawnFailure(command, error) {
 async function runTool(label, argv, { timeoutMs, cwd, onStart } = {}) {
   let ran;
   try {
-    ran = await runCommand(argv, { env: process7.env, ...timeoutMs === undefined ? {} : { timeoutMs }, ...cwd === undefined ? {} : { cwd }, ...onStart === undefined ? {} : { onStart } });
+    ran = await runCommand(argv, { env: process10.env, ...timeoutMs === undefined ? {} : { timeoutMs }, ...cwd === undefined ? {} : { cwd }, ...onStart === undefined ? {} : { onStart } });
   } catch (error) {
     throw spawnFailure(label, error);
   }
@@ -861,15 +1046,15 @@ async function runTool(label, argv, { timeoutMs, cwd, onStart } = {}) {
   return { code: ran.code, ...streams };
 }
 // ../kit/src/cli.ts
-import { readFileSync, realpathSync } from "fs";
-import { dirname as dirname2, join as join2 } from "path";
-import process9 from "process";
+import { readFileSync as readFileSync2, realpathSync } from "fs";
+import { dirname as dirname3, join as join5 } from "path";
+import process12 from "process";
 
 // ../kit/src/usage.ts
 import { appendFileSync, mkdirSync } from "fs";
-import { homedir } from "os";
-import { dirname, isAbsolute, join } from "path";
-import process8 from "process";
+import { homedir as homedir3 } from "os";
+import { dirname as dirname2, isAbsolute, join as join4 } from "path";
+import process11 from "process";
 
 // ../kit/src/logs.ts
 var DAY_MS = 24 * 60 * 60 * 1000;
@@ -883,14 +1068,14 @@ var usageError;
 function noteUsageError(message) {
   usageError = message;
 }
-function stateHome(env = process8.env) {
+function stateHome(env = process11.env) {
   const dir = env.XDG_STATE_HOME;
-  return dir !== undefined && isAbsolute(dir) ? dir : join(homedir(), ".local", "state");
+  return dir !== undefined && isAbsolute(dir) ? dir : join4(homedir3(), ".local", "state");
 }
-function usagePath(env = process8.env) {
-  return join(stateHome(env), CLI_FOLDER, "usage.jsonl");
+function usagePath(env = process11.env) {
+  return join4(stateHome(env), CLI_FOLDER, "usage.jsonl");
 }
-function usageRecorded(env = process8.env) {
+function usageRecorded(env = process11.env) {
   const off = env.KAYNOOO_CLI_NO_USAGE;
   return env.NODE_ENV !== "test" && (off === undefined || off === "" || off === "0");
 }
@@ -904,12 +1089,12 @@ function usageEntry(bin, command, argv, code, now = new Date) {
   usageError = undefined;
   return { at: now.toISOString(), bin, ...command === undefined ? {} : { command }, flags: flagNames(argv), code, ...unknown === undefined ? {} : { unknown } };
 }
-function recordUsage(entry, env = process8.env) {
+function recordUsage(entry, env = process11.env) {
   if (!usageRecorded(env))
     return;
   try {
     const path = usagePath(env);
-    mkdirSync(dirname(path), { recursive: true, mode: 448 });
+    mkdirSync(dirname2(path), { recursive: true, mode: 448 });
     appendFileSync(path, `${JSON.stringify(entry)}
 `, { mode: 384 });
   } catch {}
@@ -995,8 +1180,8 @@ async function help2({ path, header, summary: lazySummary, commands, defaultComm
 `);
 }
 function printError(prefix, message, hint, cause) {
-  const colors = paint(process9.stderr);
-  const styled = takesControlCodes(process9.stderr);
+  const colors = paint(process12.stderr);
+  const styled = takesControlCodes(process12.stderr);
   const head = styled ? `${colors.red.bold("error")} ${colors.dim(`${prefix}:`)}` : `error: ${prefix}:`;
   const under = (label, text, tint) => text === undefined ? "" : `
   ${styled ? tint(label) : `${label}:`} ${text}`;
@@ -1039,11 +1224,11 @@ async function dispatch(level, typed, { version, redact }) {
     }
   }
   if (name === undefined && level.path.length > 1) {
-    console.error(await help2(await expand(level, [...level.path.slice(1), ...argv]), process9.stderr));
+    console.error(await help2(await expand(level, [...level.path.slice(1), ...argv]), process12.stderr));
     return 2;
   }
   if (name === undefined || name === "help" || name === "--help" || name === "-h") {
-    console.log(await help2(await expand(level, [...level.path.slice(1), ...argv]), process9.stdout));
+    console.log(await help2(await expand(level, [...level.path.slice(1), ...argv]), process12.stdout));
     return 0;
   }
   if (level.path.length === 1 && (name === "--version" || name === "-v")) {
@@ -1160,17 +1345,17 @@ async function printCandidates(found) {
   return 0;
 }
 function packageVersion(entry = Bun.main) {
-  for (let dir = dirname2(realpathSync(entry));; dir = dirname2(dir)) {
+  for (let dir = dirname3(realpathSync(entry));; dir = dirname3(dir)) {
     try {
-      const { version } = JSON.parse(readFileSync(join2(dir, "package.json"), "utf8"));
+      const { version } = JSON.parse(readFileSync2(join5(dir, "package.json"), "utf8"));
       if (typeof version === "string")
         return version;
     } catch {}
-    if (dirname2(dir) === dir)
+    if (dirname3(dir) === dir)
       return "0.0.0";
   }
 }
-async function runCli(cli, argv = process9.argv.slice(2)) {
+async function runCli(cli, argv = process12.argv.slice(2)) {
   const version = cli.version ?? packageVersion();
   if (argv[0] === COMPLETE)
     return printCandidates(candidates(scopeOf(cli.commands, cli.extraCommands, cli.aliases), cli.defaultCommand, argv.slice(1)));
@@ -1197,7 +1382,7 @@ function commandPath(scope, argv) {
   }
   return path.length === 0 ? undefined : path.join(" ");
 }
-async function runMain({ name, version, run, redact, usage }, argv = process9.argv.slice(2)) {
+async function runMain({ name, version, run, redact, usage }, argv = process12.argv.slice(2)) {
   if (argv[0] === COMPLETE)
     return printCandidates(leafCandidates(run, argv.slice(1)));
   if (argv.length === 1 && (argv[0] === "--version" || argv[0] === "-v")) {
@@ -1233,34 +1418,15 @@ function parseSize(text, bareUnit = 1) {
   const suffix = match[2].toLowerCase();
   return Math.round(Number(match[1]) * (suffix === "" ? bareUnit : 1024 ** POWERS[suffix]));
 }
-// ../kit/src/user-config.ts
-import { existsSync } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join3 } from "path";
-import process10 from "process";
-function configBase(where = {}) {
-  const xdg = where.xdg ?? (where.home === undefined ? process10.env.XDG_CONFIG_HOME : undefined);
-  return xdg !== undefined && xdg !== "" ? xdg : join3(where.home ?? homedir2(), ".config");
-}
-function userConfigPath(bin, where = {}) {
-  return join3(configBase(where), "kaynooo-cli", `${bin}.json`);
-}
-function userConfigReadPath(bin, legacy = [], where = {}) {
-  const current = userConfigPath(bin, where);
-  if (existsSync(current))
-    return current;
-  const base = configBase(where);
-  return legacy.map((parts) => join3(base, ...parts)).find((path) => existsSync(path)) ?? current;
-}
 // src/audit.ts
-import { existsSync as existsSync3, readdirSync, statSync } from "fs";
+import { existsSync as existsSync5, readdirSync, statSync as statSync2 } from "fs";
 import { readdir } from "fs/promises";
-import { join as join5, relative, resolve } from "path";
-import process12 from "process";
+import { join as join7, relative, resolve as resolve3 } from "path";
+import process14 from "process";
 
 // src/report.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
-import { join as join4 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+import { join as join6 } from "path";
 var UPPER_BOUND = /<\s*(\d[\w.+-]*)/;
 var DEPENDENCY_KINDS = ["dependencies", "devDependencies", "optionalDependencies", "peerDependencies"];
 var GHSA = /GHSA-[\w-]+$/;
@@ -1304,7 +1470,7 @@ function findingsOf(audit, reaching, direct, level, ignore = []) {
 }
 function readManifest(path) {
   try {
-    return existsSync2(path) ? JSON.parse(readFileSync2(path, "utf8")) : {};
+    return existsSync4(path) ? JSON.parse(readFileSync3(path, "utf8")) : {};
   } catch {
     return {};
   }
@@ -1316,9 +1482,9 @@ function namesIn(manifest) {
   });
 }
 function directDependencies(root, workspaces) {
-  const names = new Set(namesIn(readManifest(join4(root, "package.json"))));
+  const names = new Set(namesIn(readManifest(join6(root, "package.json"))));
   for (const workspace of workspaces) {
-    for (const name of namesIn(readManifest(join4(root, workspace, "package.json"))))
+    for (const name of namesIn(readManifest(join6(root, workspace, "package.json"))))
       names.add(name);
   }
   return names;
@@ -1330,8 +1496,8 @@ function workspacePatterns(field) {
   return Array.isArray(packages) ? packages : [];
 }
 function workspaceFolders(root, children) {
-  const patterns = workspacePatterns(readManifest(join4(root, "package.json")).workspaces);
-  return patterns.filter((pattern) => typeof pattern === "string").flatMap((pattern) => pattern.endsWith("/*") ? children(pattern.slice(0, -2)).map((name) => join4(pattern.slice(0, -2), name)) : [pattern]);
+  const patterns = workspacePatterns(readManifest(join6(root, "package.json")).workspaces);
+  return patterns.filter((pattern) => typeof pattern === "string").flatMap((pattern) => pattern.endsWith("/*") ? children(pattern.slice(0, -2)).map((name) => join6(pattern.slice(0, -2), name)) : [pattern]);
 }
 
 // src/audit.ts
@@ -1352,7 +1518,7 @@ var MAX_DEPTH = 3;
 var CONCURRENCY = 4;
 var AUDIT_MS = 60000;
 function holdsLock(dir) {
-  return existsSync3(join5(dir, "bun.lock")) || existsSync3(join5(dir, "bun.lockb"));
+  return existsSync5(join7(dir, "bun.lock")) || existsSync5(join7(dir, "bun.lockb"));
 }
 async function findRepos(root) {
   if (holdsLock(root))
@@ -1368,7 +1534,7 @@ async function findRepos(root) {
     for (const entry of entries.toSorted((a, b) => a.name.localeCompare(b.name))) {
       if (!entry.isDirectory() || entry.name === "node_modules" || entry.name.startsWith("."))
         continue;
-      const path = join5(dir, entry.name);
+      const path = join7(dir, entry.name);
       if (holdsLock(path))
         found.push(path);
       else if (depth < MAX_DEPTH)
@@ -1393,7 +1559,7 @@ async function pool(items, limit, task) {
 function children(root) {
   return (folder) => {
     try {
-      return readdirSync(join5(root, folder), { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
+      return readdirSync(join7(root, folder), { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
     } catch {
       return [];
     }
@@ -1420,7 +1586,7 @@ function failure(ran) {
 `).at(-1) ?? `exit ${ran.code}`;
 }
 function tint(severity) {
-  const colors = paint(process12.stdout);
+  const colors = paint(process14.stdout);
   if (severity === "critical" || severity === "high")
     return colors.red;
   return severity === "moderate" ? colors.yellow : colors.dim;
@@ -1437,8 +1603,8 @@ function rows(findings) {
 }
 async function audit(args) {
   const { values, positionals } = parse(args, USAGE, OPTIONS, { positionals: ["[root]"], exits: EXITS, replaces: "a bun audit run in each repository and a read of every advisory to find what is worth fixing", examples: ["audit", "audit ~/Workspace --level high --prod"] });
-  const root = resolve(positionals[0] ?? ".");
-  if (!existsSync3(root) || !statSync(root).isDirectory())
+  const root = resolve3(positionals[0] ?? ".");
+  if (!existsSync5(root) || !statSync2(root).isDirectory())
     fail(`no folder ${root}`);
   const level = oneOf(values.level, "level", SEVERITIES);
   const paths = await findRepos(root);
@@ -1455,8 +1621,8 @@ async function audit(args) {
   return kept.some((each) => each.findings.length > 0) ? 1 : 0;
 }
 function show(audits, total) {
-  const label = role("label", process12.stdout);
-  const path = role("path", process12.stdout);
+  const label = role("label", process14.stdout);
+  const path = role("path", process14.stdout);
   const flagged = audits.filter((each) => each.error !== undefined || each.findings.length > 0);
   if (flagged.length === 0) {
     console.log(label(`no advisory in ${total} ${total === 1 ? "repository" : "repositories"}`));
@@ -1470,16 +1636,16 @@ function show(audits, total) {
 }
 
 // src/repos.ts
-import { existsSync as existsSync5, statSync as statSync2 } from "fs";
-import { homedir as homedir3 } from "os";
-import { join as join7, relative as relative2, resolve as resolve2 } from "path";
-import process14 from "process";
+import { existsSync as existsSync7, statSync as statSync3 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join9, relative as relative2, resolve as resolve4 } from "path";
+import process16 from "process";
 
 // src/repos-scan.ts
-import { existsSync as existsSync4 } from "fs";
+import { existsSync as existsSync6 } from "fs";
 import { readdir as readdir2 } from "fs/promises";
-import { basename, join as join6 } from "path";
-import process13 from "process";
+import { basename, join as join8 } from "path";
+import process15 from "process";
 var MAX_DEPTH2 = 3;
 var CONCURRENCY2 = 8;
 var GIT_MS = 1e4;
@@ -1500,7 +1666,7 @@ function reasonsOf(repo) {
   return reasons;
 }
 async function findRepos2(root, skip) {
-  if (existsSync4(join6(root, ".git")))
+  if (existsSync6(join8(root, ".git")))
     return [root];
   const found = [];
   async function walk(dir, depth) {
@@ -1513,8 +1679,8 @@ async function findRepos2(root, skip) {
     for (const entry of entries.toSorted((a, b) => a.name.localeCompare(b.name))) {
       if (!entry.isDirectory() || entry.name === "node_modules" || entry.name.startsWith(".") || skip.has(entry.name))
         continue;
-      const path = join6(dir, entry.name);
-      if (existsSync4(join6(path, ".git")))
+      const path = join8(dir, entry.name);
+      if (existsSync6(join8(path, ".git")))
         found.push(path);
       else if (depth < MAX_DEPTH2)
         await walk(path, depth + 1);
@@ -1525,7 +1691,7 @@ async function findRepos2(root, skip) {
 }
 async function read(path, args, timeoutMs = GIT_MS) {
   try {
-    const ran = await runCommand(["git", "--no-optional-locks", ...args], { cwd: path, env: { ...process13.env, GIT_TERMINAL_PROMPT: "0" }, timeoutMs });
+    const ran = await runCommand(["git", "--no-optional-locks", ...args], { cwd: path, env: { ...process15.env, GIT_TERMINAL_PROMPT: "0" }, timeoutMs });
     return ran.code === 0 && !ran.timedOut ? ran.text.trim() : undefined;
   } catch {
     return;
@@ -1545,7 +1711,7 @@ async function packageReleases(path) {
   }
   const releases = [];
   for (const name of [...names].toSorted()) {
-    const folder = [join6("packages", name), name].find((candidate) => existsSync4(join6(path, candidate)));
+    const folder = [join8("packages", name), name].find((candidate) => existsSync6(join8(path, candidate)));
     const tag = folder === undefined ? undefined : await read(path, ["describe", "--tags", "--abbrev=0", "--match", `${name}-v*`]);
     if (folder !== undefined && tag !== undefined && tag !== "")
       releases.push({ name, tag, unreleased: await commitsSince(path, tag, folder) });
@@ -1604,7 +1770,7 @@ function firstLine(text) {
 }
 async function fastForward(path) {
   try {
-    const ran = await runCommand(["git", "--no-optional-locks", "merge", "--ff-only", "--quiet", "@{upstream}"], { cwd: path, env: { ...process13.env, GIT_TERMINAL_PROMPT: "0" }, timeoutMs: GIT_MS });
+    const ran = await runCommand(["git", "--no-optional-locks", "merge", "--ff-only", "--quiet", "@{upstream}"], { cwd: path, env: { ...process15.env, GIT_TERMINAL_PROMPT: "0" }, timeoutMs: GIT_MS });
     if (ran.timedOut)
       return "timed out";
     return ran.code === 0 ? undefined : firstLine(ran.text.trim()) || `exit ${ran.code}`;
@@ -1644,7 +1810,7 @@ var OPTIONS2 = {
 };
 async function skipped() {
   const file = userConfigReadPath("repos");
-  if (!existsSync5(file))
+  if (!existsSync7(file))
     return new Set;
   try {
     const config = await Bun.file(file).json();
@@ -1658,17 +1824,39 @@ function releasedCell(repo) {
     return repo.packages.filter((release) => release.unreleased > 0).map((release) => `${release.name} ${release.unreleased}`).join(", ") || "-";
   return repo.tag === null || repo.unreleased === 0 ? "-" : `${repo.unreleased} since ${repo.tag}`;
 }
-function row(repo, shown) {
-  const tint = role("path", process14.stdout);
+function syncCell(repo, stream = process16.stdout) {
+  const colors = paint(stream);
   const ahead = repo.ahead ?? 0;
   const behind = repo.behind ?? 0;
-  const sync = repo.upstream === null ? "no upstream" : [ahead > 0 ? `+${ahead}` : "", behind > 0 ? `-${behind}` : ""].filter(Boolean).join(" ") || "-";
-  return [tint(shown), repo.unreadable ? "? (unreadable)" : repo.branch, repo.dirty === 0 ? "-" : String(repo.dirty), sync, repo.worktrees === 0 ? "-" : String(repo.worktrees), releasedCell(repo)];
+  if (repo.upstream === null)
+    return colors.dim("no upstream");
+  const parts = [ahead > 0 ? colors.green(`+${ahead}`) : "", behind > 0 ? colors.red(`-${behind}`) : ""].filter(Boolean);
+  const diverged = takesControlCodes(stream) && ahead > 0 && behind > 0;
+  return parts.length === 0 ? colors.dim("-") : `${parts.join(" ")}${diverged ? colors.yellow(" diverged") : ""}`;
+}
+function branchCell(repo) {
+  const colors = paint(process16.stdout);
+  if (repo.unreadable)
+    return colors.red("? (unreadable)");
+  return repo.branch === "(detached)" ? colors.yellow(repo.branch) : repo.branch;
+}
+function row(repo, shown) {
+  const colors = paint(process16.stdout);
+  const tint = role("path", process16.stdout);
+  const unreleased = releasedCell(repo);
+  return [
+    tint(shown),
+    branchCell(repo),
+    repo.dirty === 0 ? colors.dim("-") : colors.yellow(String(repo.dirty)),
+    syncCell(repo),
+    repo.worktrees === 0 ? colors.dim("-") : String(repo.worktrees),
+    unreleased === "-" ? colors.dim("-") : colors.cyan(unreleased)
+  ];
 }
 async function repos(args) {
   const { values, positionals } = parse(args, USAGE2, OPTIONS2, { positionals: ["[root]"], exits: EXITS2, replaces: "a cd, git status, git log and git tag loop over each repository of the workspace", examples: ["repos", "repos ~/Workspace --only unreleased --fetch", ["repos --only behind --pull", "fast-forward what is behind and clean"], ["repos --only dirty --path", "the paths, for xargs"]] });
-  const root = resolve2(positionals[0] ?? join7(homedir3(), "Workspace"));
-  if (!existsSync5(root) || !statSync2(root).isDirectory())
+  const root = resolve4(positionals[0] ?? join9(homedir4(), "Workspace"));
+  if (!existsSync7(root) || !statSync3(root).isDirectory())
     fail(`no folder ${root}`);
   const only = values.only === undefined ? undefined : oneOf(values.only, "only", REASONS);
   const paths = await findRepos2(root, await skipped());
@@ -1686,12 +1874,12 @@ async function repos(args) {
       const blocker = pullBlocker(repo);
       const refused = blocker === undefined ? await fastForward(repo.path) : undefined;
       if (blocker !== undefined) {
-        log(marked("note", `${repo.name} skipped`, process14.stdout, blocker));
+        log(marked("note", `${repo.name} skipped`, process16.stdout, blocker));
       } else if (refused !== undefined) {
         failedPulls++;
-        log(marked("problem", `${repo.name} not pulled`, process14.stdout, refused));
+        log(marked("problem", `${repo.name} not pulled`, process16.stdout, refused));
       } else {
-        log(marked("ok", `${repo.name} pulled`, process14.stdout, `${repo.behind} ${repo.behind === 1 ? "commit" : "commits"}`));
+        log(marked("ok", `${repo.name} pulled`, process16.stdout, `${repo.behind} ${repo.behind === 1 ? "commit" : "commits"}`));
         states[index] = await inspect(repo.path, false);
       }
     }
@@ -1706,7 +1894,7 @@ async function repos(args) {
     printJson(kept.map((repo) => ({ ...repo, reasons: reasonsOf(repo) })));
     return failedPulls > 0 ? 1 : 0;
   }
-  const label = role("label", process14.stdout);
+  const label = role("label", process16.stdout);
   if (kept.length === 0) {
     console.log(label(`nothing needs attention in ${states.length} repositories`));
     return failedPulls > 0 ? 1 : 0;
@@ -1721,17 +1909,17 @@ async function repos(args) {
 }
 
 // src/sweep.ts
-import { existsSync as existsSync8, statSync as statSync3 } from "fs";
-import { homedir as homedir5 } from "os";
-import { join as join11, relative as relative3, resolve as resolve3 } from "path";
+import { existsSync as existsSync10, statSync as statSync4 } from "fs";
+import { homedir as homedir6 } from "os";
+import { join as join13, relative as relative3, resolve as resolve5 } from "path";
 
 // ../kit/src/prompt.ts
-import process15 from "process";
+import process17 from "process";
 var KEY_SEQUENCES = /\x1B\[[0-9;]*[A-Z~]|\x1BO[A-Z]|[\s\S]/giu;
-var CONTROL = /^[\x00-\x1F\x7F]/;
+var CONTROL2 = /^[\x00-\x1F\x7F]/;
 var KEYS = { "\x1B[A": "up", "\x1BOA": "up", "\x1B[B": "down", "\x1BOB": "down", "\r": "enter", "\n": "enter", "\x03": "cancel", "\x1B": "cancel", "\x7F": "erase", "\b": "erase" };
 function readKeys(input) {
-  return (input.match(KEY_SEQUENCES) ?? []).flatMap((sequence) => KEYS[sequence] ?? (CONTROL.test(sequence) ? [] : [{ text: sequence }]));
+  return (input.match(KEY_SEQUENCES) ?? []).flatMap((sequence) => KEYS[sequence] ?? (CONTROL2.test(sequence) ? [] : [{ text: sequence }]));
 }
 async function confirm(question, { default: fallback, ...settings } = {}) {
   let answered = fallback;
@@ -1755,7 +1943,7 @@ function asking(colors, question, typed, keys) {
 function answer(colors, question, state, picked) {
   return state === "enter" ? `${colors.green("\u2713")} ${question} ${colors.cyan(picked)}` : `${colors.red("\u2717")} ${question} ${colors.dim("cancelled")}`;
 }
-async function ask(question, { hint, terminal = process15 }, render, press) {
+async function ask(question, { hint, terminal = process17 }, render, press) {
   const { stdin, stderr } = terminal;
   if (stdin.isTTY !== true || stderr.isTTY !== true)
     fail(`cannot ask "${question}" off a terminal`, 2, hint);
@@ -1806,19 +1994,19 @@ async function ask(question, { hint, terminal = process15 }, render, press) {
 }
 
 // src/apply.ts
-import { existsSync as existsSync7 } from "fs";
+import { existsSync as existsSync9 } from "fs";
 import { lstat as lstat3, rm } from "fs/promises";
-import { basename as basename3, join as join10 } from "path";
+import { basename as basename3, join as join12 } from "path";
 
 // src/sweep-scan.ts
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync8 } from "fs";
 import { lstat as lstat2, readdir as readdir4, realpath } from "fs/promises";
-import { homedir as homedir4 } from "os";
-import { basename as basename2, dirname as dirname3, join as join9 } from "path";
+import { homedir as homedir5 } from "os";
+import { basename as basename2, dirname as dirname4, join as join11 } from "path";
 
 // src/size.ts
 import { lstat, readdir as readdir3 } from "fs/promises";
-import { join as join8 } from "path";
+import { join as join10 } from "path";
 async function pooled(items, limit, work) {
   const results = Array.from({ length: items.length });
   let next = 0;
@@ -1855,7 +2043,7 @@ async function sizeOf(folder) {
       return;
     }
     await Promise.all(entries.map(async (entry) => {
-      const path = join8(dir, entry.name);
+      const path = join10(dir, entry.name);
       if (entry.isDirectory())
         return visit(path);
       try {
@@ -1879,8 +2067,8 @@ var FOLDER_NAMES = new Set(["node_modules", ".nuxt", ".next", ".output", "dist",
 var MAX_DEPTH3 = 3;
 var PROJECT_CACHE_NAMES = new Set([".turbo", ".nuxt", ".next", ".svelte-kit"]);
 var GLOBAL_CACHES = [".bun/install/cache", ".npm/_cacache", ".cache/pip", ".cache/uv", ".cache/ms-playwright", ".cache/puppeteer", ".cache/go-build", ".cache/typescript", ".cargo/registry"];
-function isCachePath(path, home = homedir4()) {
-  return GLOBAL_CACHES.some((cache) => join9(home, cache) === path) || basename2(path) === ".cache" && basename2(dirname3(path)) === "node_modules";
+function isCachePath(path, home = homedir5()) {
+  return GLOBAL_CACHES.some((cache) => join11(home, cache) === path) || basename2(path) === ".cache" && basename2(dirname4(path)) === "node_modules";
 }
 async function listing(dir) {
   try {
@@ -1891,7 +2079,7 @@ async function listing(dir) {
 }
 async function addGlobalCaches(found, home) {
   for (const cache of GLOBAL_CACHES) {
-    const path = join9(home, cache);
+    const path = join11(home, cache);
     try {
       const stat = await lstat2(path);
       if (stat.isSymbolicLink())
@@ -1901,12 +2089,12 @@ async function addGlobalCaches(found, home) {
     } catch {}
   }
 }
-async function findCandidates(root, home = homedir4(), withGlobal = true) {
+async function findCandidates(root, home = homedir5(), withGlobal = true) {
   const found = { candidates: [], skipped: [] };
   const visit = async (dir, depth) => {
     const entries = await listing(dir);
     for (const entry of entries) {
-      const path = join9(dir, entry.name);
+      const path = join11(dir, entry.name);
       if (entry.name === ".git")
         continue;
       if (entry.name === ".worktrees" || entry.name === "worktrees" && basename2(dir) === ".claude") {
@@ -1916,13 +2104,13 @@ async function findCandidates(root, home = homedir4(), withGlobal = true) {
         }
         for (const worktree of await listing(path)) {
           if (worktree.isDirectory())
-            found.candidates.push({ path: join9(path, worktree.name), kind: "worktree" });
+            found.candidates.push({ path: join11(path, worktree.name), kind: "worktree" });
           else if (worktree.isSymbolicLink())
-            found.skipped.push({ path: join9(path, worktree.name), reason: "symlink" });
+            found.skipped.push({ path: join11(path, worktree.name), reason: "symlink" });
         }
         continue;
       }
-      if (FOLDER_NAMES.has(entry.name) && (entry.name !== "target" || existsSync6(join9(dir, "Cargo.toml")))) {
+      if (FOLDER_NAMES.has(entry.name) && (entry.name !== "target" || existsSync8(join11(dir, "Cargo.toml")))) {
         if (entry.isSymbolicLink()) {
           found.skipped.push({ path, reason: "symlink" });
         } else if (entry.isDirectory()) {
@@ -1930,9 +2118,9 @@ async function findCandidates(root, home = homedir4(), withGlobal = true) {
           if (entry.name === "node_modules") {
             const cache = (await listing(path)).find((inner) => inner.name === ".cache");
             if (cache?.isSymbolicLink())
-              found.skipped.push({ path: join9(path, ".cache"), reason: "symlink" });
+              found.skipped.push({ path: join11(path, ".cache"), reason: "symlink" });
             else if (cache?.isDirectory())
-              found.candidates.push({ path: join9(path, ".cache"), kind: "cache", inside: path });
+              found.candidates.push({ path: join11(path, ".cache"), kind: "cache", inside: path });
           }
         }
         continue;
@@ -2003,12 +2191,12 @@ var worktreesOf = memo(async (repo) => {
   return branches;
 });
 async function judgeFolder(path, kind, inside) {
-  const parent = dirname3(path);
+  const parent = dirname4(path);
   const name = basename2(path);
   const located = await toplevelOf(parent);
   if (located === "failed")
     return { skip: "git failed" };
-  if (existsSync6(join9(path, ".git")))
+  if (existsSync8(join11(path, ".git")))
     return { skip: "holds a git repository" };
   if (located === "none")
     return name === "node_modules" || inside !== undefined ? { entry: { path, kind, committedAt: undefined, action: "remove", inside } } : { skip: "not in a git repository" };
@@ -2020,7 +2208,7 @@ async function judgeFolder(path, kind, inside) {
   return { entry: { path, kind, committedAt: await lastCommitOf(located.top), action: "remove", inside } };
 }
 async function judgeWorktree(path) {
-  const located = await toplevelOf(dirname3(path));
+  const located = await toplevelOf(dirname4(path));
   if (located === "failed")
     return { skip: "git failed" };
   if (located === "none")
@@ -2076,7 +2264,7 @@ async function removeFolder(entry) {
     const stat = await lstat3(entry.path);
     if (stat.isSymbolicLink() || !stat.isDirectory() || !(FOLDER_NAMES.has(basename3(entry.path)) || entry.kind === "cache" && isCachePath(entry.path)))
       return { path: entry.path, removed: false, error: "no longer a plain folder" };
-    if (existsSync7(join10(entry.path, ".git")))
+    if (existsSync9(join12(entry.path, ".git")))
       return { path: entry.path, removed: false, error: "holds a git repository" };
     await rm(entry.path, { recursive: true, force: true });
     return { path: entry.path, removed: true };
@@ -2107,6 +2295,8 @@ async function applyAll(entries, done) {
 }
 
 // src/sweep.ts
+var LARGE = 100 * 1024 ** 2;
+var BIG = 1024 ** 3;
 var USAGE3 = `sweep [options] [root]: lists the regenerable folders (node_modules, .output, dist, build, target beside a Cargo.toml), the caches (.nuxt, .next, .turbo, .svelte-kit and node_modules/.cache per project; ~/.bun/install/cache, ~/.npm/_cacache, ~/.cache/{pip,uv,ms-playwright,puppeteer,go-build,typescript} and ~/.cargo/registry, exact paths only, listed only when no root is given or with --only caches) and the .worktrees/* and .claude/worktrees/* entries under root (~/Workspace by default, ${MAX_DEPTH3} levels down), largest first with the age of the repo's last commit; --only worktrees, folders or caches keeps one kind
 
 Dry unless --apply, which deletes after a confirm showing the total (read from the terminal; off one, pass --yes). A folder is deleted for good, not trashed. Never touched: a symlink, a folder git tracks files in, a build folder git does not ignore. A worktree is removed with git worktree remove, never forced, and only when it is clean and every commit of its branch is on another branch or a remote; the others stay listed as kept and count for nothing in the total. With --docker the Docker usage comes after the list, left to dclean.
@@ -2136,8 +2326,8 @@ async function sweep(args) {
   const { values, positionals } = parse(args, USAGE3, OPTIONS3, { positionals: ["[root]"], replaces: "find ~/Workspace -name node_modules, du -sh and rm -rf by hand", examples: ["sweep", "sweep ~/Workspace --older 30d --min 100M --apply", "sweep --only worktrees --apply"] });
   if (positionals.length > 1)
     badUsage("give one root");
-  const root = resolve3(positionals[0] ?? join11(homedir5(), "Workspace"));
-  if (!existsSync8(root) || !statSync3(root).isDirectory())
+  const root = resolve5(positionals[0] ?? join13(homedir6(), "Workspace"));
+  if (!existsSync10(root) || !statSync4(root).isDirectory())
     fail(`${root} is not a folder`);
   if (values.only !== undefined && !Object.hasOwn(ONLY_KINDS, values.only))
     badUsage(`--only takes worktrees, folders or caches, not ${values.only}`);
@@ -2146,7 +2336,7 @@ async function sweep(args) {
   if (minBytes === undefined)
     badUsage(`--min takes a size such as 500K, 10M or 1G, not ${values.min}`);
   const now = Date.now();
-  const found = await findCandidates(root, homedir5(), positionals.length === 0 || values.only === "caches");
+  const found = await findCandidates(root, homedir6(), positionals.length === 0 || values.only === "caches");
   const wanted = values.only === undefined ? found.candidates : found.candidates.filter((candidate) => candidate.kind === ONLY_KINDS[values.only]);
   const { entries: all, skipped } = await inspect2({ candidates: wanted, skipped: found.skipped });
   const entries = all.filter((entry) => entry.bytes >= minBytes && (olderMs === undefined || entry.committedAt !== undefined && now - entry.committedAt >= olderMs)).sort((a, b) => b.bytes - a.bytes || a.path.localeCompare(b.path));
@@ -2198,13 +2388,20 @@ function print(root, entries, skipped, reclaimable, now) {
     console.log("nothing to sweep");
     return;
   }
-  console.log(table([["size", "age", "what", "path", "note"], ...entries.map((entry) => [$e(entry.bytes), entry.committedAt === undefined ? "-" : formatAge(entry.committedAt, now), entry.kind, relative3(root, entry.path), entry.action === "keep" ? `kept: ${entry.reason}` : ""])], { header: true, align: ["right", "right", "left", "left", "left"] }));
+  const colors = paint(process.stdout);
+  const path = role("path", process.stdout);
+  const sized = (bytes) => {
+    if (bytes >= BIG)
+      return colors.red($e(bytes));
+    return bytes >= LARGE ? colors.yellow($e(bytes)) : $e(bytes);
+  };
+  console.log(table([["size", "age", "what", "path", "note"], ...entries.map((entry) => [sized(entry.bytes), entry.committedAt === undefined ? colors.dim("-") : colors.dim(formatAge(entry.committedAt, now)), entry.kind, path(relative3(root, entry.path)), entry.action === "keep" ? colors.dim(`kept: ${entry.reason}`) : ""])], { header: true, align: ["right", "right", "left", "left", "left"] }));
   console.log(`
 ${$e(reclaimable)} reclaimable${skipped === 0 ? "" : `, ${skipped} skipped (symlinks, tracked or not ignored by git)`}`);
 }
 
 // src/cli.ts
-process16.exitCode = await runCli({
+process18.exitCode = await runCli({
   name: "ws",
   about: "the repositories under a root: the ones needing attention, the folders worth reclaiming and their known vulnerabilities",
   replaces: "a cd, git status and du loop over each repository of the workspace, and a bun audit run in each",