@kaynooo/cli-doctor 0.11.0 → 0.13.0

package/dist/cli-bin.js

@@ -2,13 +2,13 @@
 // @bun
 
 // src/cli-bin.ts
-import process18 from "process";
+import process21 from "process";
 // ../kit/src/args.ts
-import process7 from "process";
+import process9 from "process";
 import { parseArgs } from "util";
 
 // ../kit/src/format.ts
-import process5 from "process";
+import process7 from "process";
 
 // ../kit/src/mode.ts
 import process2 from "process";
@@ -32,7 +32,7 @@ function isInteractive(streams = process2) {
 }
 
 // ../kit/src/style.ts
-import process4 from "process";
+import process6 from "process";
 
 // ../../node_modules/.bun/@kaynooo+utils@2.31.2+d0769e28dc4dad16/node_modules/@kaynooo/utils/dist/chunk-mtetydvc.js
 function x(s) {
@@ -295,28 +295,188 @@ function le(i = {}) {
 }
 var t = le();
 
+// ../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 process5 from "process";
+
+// ../kit/src/config.ts
+import { existsSync } from "fs";
+import { dirname, join, resolve } from "path";
+import process3 from "process";
+function findUp(names, from = process3.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 } from "path";
-import process3 from "process";
+import { join as join2 } from "path";
+import process4 from "process";
 function configBase(where = {}) {
-  const xdg = where.xdg ?? (where.home === undefined ? process3.env.XDG_CONFIG_HOME : undefined);
-  return xdg !== undefined && xdg !== "" ? xdg : join(where.home ?? homedir(), ".config");
+  const xdg = where.xdg ?? (where.home === undefined ? process4.env.XDG_CONFIG_HOME : undefined);
+  return xdg !== undefined && xdg !== "" ? xdg : join2(where.home ?? homedir(), ".config");
 }
 function userConfigPath(bin, where = {}) {
-  return join(configBase(where), "kaynooo-cli", `${bin}.json`);
+  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: {}
+};
+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 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 = process5.env, from = process5.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 };
+}
 
 // ../kit/src/style.ts
-function takesControlCodes(stream, env = process4.env) {
+function takesControlCodes(stream, env = process6.env) {
   return stream.isTTY === true && env.NO_COLOR === undefined && env.NODE_DISABLE_COLORS === undefined && env.TERM !== "dumb" && outputMode(stream, env) === "terminal";
 }
-function paint(stream, env = process4.env) {
+function paint(stream, env = process6.env) {
   return le({ stream: { isTTY: takesControlCodes(stream, env) }, env });
 }
 var STATUS_WORDS = {
@@ -341,7 +501,7 @@ var ESCAPE = String.fromCharCode(27);
 function textWidth(text) {
   return Bun.stringWidth(text);
 }
-function table(rows, { cellWidth, header = false, align = [], fit, stream = process5.stdout, env = process5.env } = {}) {
+function table(rows, { cellWidth, header = false, align = [], fit, stream = process7.stdout, env = process7.env } = {}) {
   const cells = cellWidth === undefined ? rows : rows.map((row) => row.map((cell) => truncate(cell.replaceAll(LINE_BREAKS, " "), cellWidth)));
   if (outputMode(stream, env) === "agent")
     return cells.map((row) => row.map((cell) => Bun.stripANSI(cell).replaceAll(/[\t\r\n]+/g, " ")).join("\t")).join(`
@@ -380,7 +540,7 @@ function narrow(rows, widths, limit) {
   }
   return rows.map((row) => row.map((cell, index) => textWidth(cell) > (widths[index] ?? 0) ? truncate(cell, widths[index] ?? 0) : cell));
 }
-function jsonText(value, replacer, { stream = process5.stdout, env = process5.env } = {}) {
+function jsonText(value, replacer, { stream = process7.stdout, env = process7.env } = {}) {
   return JSON.stringify(value, replacer, outputMode(stream, env) === "agent" ? undefined : 2);
 }
 function printJson(value) {
@@ -388,27 +548,27 @@ function printJson(value) {
 }
 
 // ../kit/src/help.ts
-import process6 from "process";
+import process8 from "process";
 var OPTIONAL = /\[[^\]]+\]/g;
 var USAGE_PREFIX = /^usage:\s*/i;
 var FULL_STOP = /\.$/;
-function usageLine(usage, colors = paint(process6.stdout)) {
+function usageLine(usage, colors = paint(process8.stdout)) {
   return `${colors.bold("Usage:")} ${usage.replace(USAGE_PREFIX, "").replaceAll(OPTIONAL, (part) => colors.dim(part))}`;
 }
-function helpText(usage, options, colors = paint(process6.stdout), { examples = [], replaces, exits = [] } = {}) {
+function helpText(usage, options, colors = paint(process8.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(process6.stdout)) {
+function exitRows(exits, colors = paint(process8.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(process6.stdout)) {
+function replacesRows(replaces, colors = paint(process8.stdout)) {
   return replaces === undefined || outputMode() === "agent" ? [] : ["", `${colors.bold("Instead of:")} ${replaces}`];
 }
-function wantsHelpJson(env = process6.env) {
+function wantsHelpJson(env = process8.env) {
   return env.KIT_HELP === "json";
 }
 function description(usage, { examples = [], replaces, exits } = {}, options) {
@@ -427,12 +587,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(process6.stdout)) {
+function exampleRows(examples, colors = paint(process8.stdout)) {
   if (examples.length === 0 || outputMode() === "agent")
     return [];
   return ["", colors.bold("Examples:"), ...examples.map((example) => typeof example === "string" ? `  ${example}` : `  ${example[0]}  ${colors.dim(`# ${example[1]}`)}`)];
 }
-function optionRows(options, colors = paint(process6.stdout)) {
+function optionRows(options, colors = paint(process8.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("|")}>`;
@@ -524,7 +684,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 = process7.env) {
+function applyOutput(color, plain, env = process9.env) {
   const when = plain === true ? "never" : color ?? "auto";
   if (when === "auto")
     return;
@@ -695,7 +855,7 @@ function nearestOption(message, options, allowNegative) {
 }
 // ../kit/src/process.ts
 import { constants } from "os";
-import process8 from "process";
+import process10 from "process";
 var KILL_GRACE_MS = 2000;
 function exitCodeOf(code, signal) {
   if (code !== null)
@@ -715,7 +875,7 @@ async function runCommand(argv, { cwd, env, stdin = "ignore", timeoutMs, signal,
       return;
     try {
       if (grouped)
-        process8.kill(-proc.pid, killing);
+        process10.kill(-proc.pid, killing);
       else
         proc.kill(killing);
     } catch {}
@@ -789,15 +949,15 @@ var ESCAPE_CODE = new RegExp(`${ESC}(?:\\[[\\x30-\\x3F]*[\\x20-\\x2F]*[\\x40-\\x
 var RESET_STYLE = `${ESC}[0m`;
 var CLOSE_LINK = `${ESC}]8;;${ESC}\\`;
 // ../kit/src/cli.ts
-import { readFileSync, realpathSync } from "fs";
-import { dirname as dirname2, join as join3 } from "path";
-import process10 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 as homedir2 } from "os";
-import { dirname, isAbsolute, join as join2 } from "path";
-import process9 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;
@@ -811,14 +971,14 @@ var usageError;
 function noteUsageError(message) {
   usageError = message;
 }
-function stateHome(env = process9.env) {
+function stateHome(env = process11.env) {
   const dir = env.XDG_STATE_HOME;
-  return dir !== undefined && isAbsolute(dir) ? dir : join2(homedir2(), ".local", "state");
+  return dir !== undefined && isAbsolute(dir) ? dir : join4(homedir3(), ".local", "state");
 }
-function usagePath(env = process9.env) {
-  return join2(stateHome(env), CLI_FOLDER, "usage.jsonl");
+function usagePath(env = process11.env) {
+  return join4(stateHome(env), CLI_FOLDER, "usage.jsonl");
 }
-function usageRecorded(env = process9.env) {
+function usageRecorded(env = process11.env) {
   const off = env.KAYNOOO_CLI_NO_USAGE;
   return env.NODE_ENV !== "test" && (off === undefined || off === "" || off === "0");
 }
@@ -832,12 +992,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 = process9.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 {}
@@ -971,8 +1131,8 @@ async function help2({ path, header, summary: lazySummary, commands, defaultComm
 `);
 }
 function printError(prefix, message, hint, cause) {
-  const colors = paint(process10.stderr);
-  const styled = takesControlCodes(process10.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}`;
@@ -1015,11 +1175,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]), process10.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]), process10.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")) {
@@ -1136,17 +1296,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(join3(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 = process10.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)));
@@ -1173,7 +1333,7 @@ function commandPath(scope, argv) {
   }
   return path.length === 0 ? undefined : path.join(" ");
 }
-async function runMain({ name, version, run, redact, usage }, argv = process10.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")) {
@@ -1193,6 +1353,8 @@ async function runMain({ name, version, run, redact, usage }, argv = process10.a
   }
   return code;
 }
+// ../kit/src/folders.ts
+var SKIPPED_FOLDERS = new Set(["node_modules", "vendor", "dist", "build", "target", "coverage", "venv", "__pycache__"]);
 // ../kit/src/secrets.ts
 var SECRET_WORDS = new Set(["key", "pass", "pwd", "auth", "salt", "cookie", "session", "jwt", "ssn", "iban", "card", "cvv", "otp"]);
 // ../kit/src/sessions.ts
@@ -1200,40 +1362,40 @@ var {Glob } = globalThis.Bun;
 var SESSION_FILES = new Glob("*.json");
 var ACCOUNT_DIRS = new Glob("*/sessions");
 // ../kit/src/workspace-root.ts
-import { existsSync, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
-import { homedir as homedir3 } from "os";
-import { dirname as dirname3, join as join4, resolve } from "path";
-import process11 from "process";
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync } from "fs";
+import { homedir as homedir4 } from "os";
+import { dirname as dirname4, join as join6, resolve as resolve3 } from "path";
+import process13 from "process";
 function expandHome(path, home) {
   if (path === "~")
     return home;
-  return path.startsWith("~/") ? join4(home, path.slice(2)) : path;
+  return path.startsWith("~/") ? join6(home, path.slice(2)) : path;
 }
 function configured(env, home) {
   const path = userConfigPath("config", { home, xdg: env.XDG_CONFIG_HOME });
-  if (!existsSync(path))
+  if (!existsSync4(path))
     return;
   try {
-    const parsed = JSON.parse(readFileSync2(path, "utf8"));
+    const parsed = JSON.parse(readFileSync3(path, "utf8"));
     const folder = typeof parsed === "object" && parsed !== null ? parsed.workspace : undefined;
     return typeof folder === "string" && folder !== "" ? folder : undefined;
   } catch {
     return;
   }
 }
-function workspaceRoot({ given, env = process11.env, home = homedir3() } = {}) {
+function workspaceRoot({ given, env = process13.env, home = homedir4() } = {}) {
   const fromEnv = env.KAYNOOO_WORKSPACE === "" ? undefined : env.KAYNOOO_WORKSPACE;
-  return resolve(expandHome(given ?? fromEnv ?? configured(env, home) ?? join4(home, "Workspace"), home));
+  return resolve3(expandHome(given ?? fromEnv ?? configured(env, home) ?? join6(home, "Workspace"), home));
 }
-function workspaceChosen({ env = process11.env, home = homedir3() } = {}) {
+function workspaceChosen({ env = process13.env, home = homedir4() } = {}) {
   return (env.KAYNOOO_WORKSPACE ?? "") !== "" || configured(env, home) !== undefined;
 }
-function saveWorkspace(folder, { env = process11.env, home = homedir3() } = {}) {
+function saveWorkspace(folder, { env = process13.env, home = homedir4() } = {}) {
   const path = userConfigPath("config", { home, xdg: env.XDG_CONFIG_HOME });
   let current = {};
-  if (existsSync(path)) {
+  if (existsSync4(path)) {
     try {
-      const parsed = JSON.parse(readFileSync2(path, "utf8"));
+      const parsed = JSON.parse(readFileSync3(path, "utf8"));
       if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
         return false;
       current = parsed;
@@ -1241,19 +1403,19 @@ function saveWorkspace(folder, { env = process11.env, home = homedir3() } = {})
       return false;
     }
   }
-  mkdirSync2(dirname3(path), { recursive: true });
+  mkdirSync2(dirname4(path), { recursive: true });
   writeFileSync(path, `${JSON.stringify({ ...current, workspace: folder }, undefined, 2)}
 `);
   return true;
 }
 // src/completions.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync3, readdirSync, readFileSync as readFileSync4, rmSync } from "fs";
-import { join as join6 } from "path";
-import process13 from "process";
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, readdirSync, readFileSync as readFileSync5, rmSync } from "fs";
+import { join as join8 } from "path";
+import process15 from "process";
 
 // src/checks.ts
-import { existsSync as existsSync2, readFileSync as readFileSync3 } from "fs";
-import { basename, join as join5 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
+import { basename, join as join7 } from "path";
 
 // src/catalog.ts
 var HOOKS_REQUIRES = "@kaynooo/cli-guard";
@@ -1329,7 +1491,7 @@ function readJsonText(text) {
   }
 }
 function readJson(path) {
-  return existsSync2(path) ? readJsonText(readFileSync3(path, "utf8")) : undefined;
+  return existsSync5(path) ? readJsonText(readFileSync4(path, "utf8")) : undefined;
 }
 function firstLine(text) {
   const trimmed = text.trim();
@@ -1338,7 +1500,7 @@ function firstLine(text) {
   return end === -1 ? trimmed : trimmed.slice(0, end);
 }
 function installed(host, name) {
-  return readJson(join5(host.globalModules, name, "package.json"));
+  return readJson(join7(host.globalModules, name, "package.json"));
 }
 function isInstalled(host, name) {
   return installed(host, name)?.version !== undefined;
@@ -1346,7 +1508,7 @@ function isInstalled(host, name) {
 function ownBin(host, name, bin) {
   const declared = installed(host, name)?.bin;
   const file = typeof declared === "string" ? declared : declared?.[bin];
-  return file === undefined ? undefined : join5(host.globalModules, name, file);
+  return file === undefined ? undefined : join7(host.globalModules, name, file);
 }
 async function checkTool(host, name, bins) {
   const check = name.slice(name.indexOf("/") + 1);
@@ -1361,17 +1523,29 @@ async function checkTool(host, name, bins) {
   if (latest !== "" && Bun.semver.order(version, latest) < 0)
     return { check, ok: false, detail: `${version}, ${latest} released${off.length > 0 ? `, ${off.join(", ")} not on the PATH` : ""}`, fix: `bun install -g ${name}@${latest}` };
   if (off.length > 0)
-    return { check, ok: false, detail: `${version}, ${off.join(", ")} not on the PATH`, fix: `add ${join5(host.globalModules, "..", "..", "..", "bin")} to the PATH` };
+    return { check, ok: false, detail: `${version}, ${off.join(", ")} not on the PATH`, fix: `add ${join7(host.globalModules, "..", "..", "..", "bin")} to the PATH` };
   if (latest === "")
     return { check, ok: true, detail: `${version}, the registry did not answer: ${firstLine(info.stderr) || answered || "no version"}` };
   return { check, ok: true, detail: version };
 }
+function extraForgeHosts(home) {
+  try {
+    const path = userConfigReadPath("doctor", [], { home, xdg: process.env.XDG_CONFIG_HOME });
+    if (!existsSync5(path))
+      return [];
+    const raw = Bun.JSONC.parse(readFileSync4(path, "utf8"));
+    return Array.isArray(raw?.forgeHosts) ? raw.forgeHosts.filter((each) => typeof each === "string") : [];
+  } catch {
+    return [];
+  }
+}
 async function checkTea(host) {
   if (host.which("tea") === null)
     return { check: "tea", ok: false, detail: "not installed, and ft goes through it", fix: "install tea from https://gitea.com/gitea/tea/releases" };
   const logins = await host.run(["tea", "login", "list", "-o", "json"]);
   const parsed = logins.code === 0 ? readJsonText(logins.stdout) : undefined;
-  const login = parsed?.find((each) => URL.canParse(each.url) && FORGE_HOSTS.has(new URL(each.url).host));
+  const hosts = new Set([...FORGE_HOSTS, ...extraForgeHosts(host.home)]);
+  const login = parsed?.find((each) => URL.canParse(each.url) && hosts.has(new URL(each.url).host));
   if (login === undefined)
     return { check: "tea", ok: false, detail: `no login to ${FORGE}`, fix: `tea login add --url https://${FORGE} --oauth` };
   const version = await host.run(["tea", "api", "--login", login.name, "version"]);
@@ -1382,9 +1556,9 @@ async function checkTea(host) {
   return { check: "tea", ok: true, detail: `logged in to ${forge} as ${login.name}, Forgejo ${served}` };
 }
 function hooksWiring(host) {
-  const settings = readJson(join5(host.home, ".claude", "settings.json")) ?? {};
+  const settings = readJson(join7(host.home, ".claude", "settings.json")) ?? {};
   const plugin = settings.enabledPlugins?.[PLUGIN] === true;
-  const mod = (settings.env?.CLAUDE_CODE_PLUGIN_DIRS ?? "").split(":").map((dir) => dir.replace(LEADING_TILDE, host.home)).find((dir) => basename(dir) === "cli" && existsSync2(join5(dir, "hooks", "hooks.json")));
+  const mod = (settings.env?.CLAUDE_CODE_PLUGIN_DIRS ?? "").split(":").map((dir) => dir.replace(LEADING_TILDE, host.home)).find((dir) => basename(dir) === "cli" && existsSync5(join7(dir, "hooks", "hooks.json")));
   return { plugin, mod };
 }
 function checkHooks(host) {
@@ -1427,7 +1601,7 @@ var FORGEJO = "@kaynooo/cli-forgejo";
 var WORKSPACE = "@kaynooo/cli-workspace";
 function checkWorkspace(host, env = process.env) {
   const folder = workspaceRoot({ home: host.home, env });
-  if (existsSync2(folder))
+  if (existsSync5(folder))
     return { check: "workspace", ok: true, detail: folder };
   return { check: "workspace", ok: false, detail: `${folder} does not exist`, fix: `mkdir -p ${folder}, or set "workspace" in ~/.config/kaynooo-cli/config.json to your folder` };
 }
@@ -1479,14 +1653,36 @@ var BASH_FUNCTION = `__kaynooo_cli_complete() {
     done
     COMPREPLY+=($(compgen -W "$words" -- "$cur"))
 }`;
+var ZSH_FUNCTION = `__kaynooo_cli_complete() {
+    local line
+    local -a described plain
+    for line in \${(f)"$("\${words[1]}" __complete "\${(@)words[2,CURRENT]}" 2>/dev/null)"}; do
+        if [[ $line == __files__ ]]; then
+            _files
+        elif [[ $line == *$'\\t'* ]]; then
+            described+=("\${\${line%%$'\\t'*}//:/\\\\:}:\${line#*$'\\t'}")
+        else
+            plain+=("$line")
+        fi
+    done
+    (( \${#described} )) && _describe -V value described
+    (( \${#plain} )) && compadd -- "\${plain[@]}"
+    return 0
+}`;
+function zshScript(bins) {
+  return `# Generated by \`cli completions zsh\`
+${ZSH_FUNCTION}
+compdef __kaynooo_cli_complete ${bins.join(" ")}
+`;
+}
 function bashScript(bins) {
   return `# Generated by \`cli completions bash\`
 ${BASH_FUNCTION}
 complete -F __kaynooo_cli_complete ${bins.join(" ")}
 `;
 }
-function completionDir(home, env = process13.env) {
-  return join6(env.XDG_CACHE_HOME ?? join6(home, ".cache"), "fish", "kaynooo-cli");
+function completionDir(home, env = process15.env) {
+  return join8(env.XDG_CACHE_HOME ?? join8(home, ".cache"), "fish", "kaynooo-cli");
 }
 function installedBins(host) {
   return Object.values(TOOLS).flat().filter((bin) => host.which(bin) !== null);
@@ -1500,18 +1696,55 @@ complete -c ${bin} -f -a '(__kaynooo_cli_complete ${bin})'
 async function installCompletions(host, dir) {
   const bins = installedBins(host);
   mkdirSync3(dir, { recursive: true });
-  const removed = readdirSync(dir).filter((name) => FISH_FILE.test(name) && !bins.includes(name.replace(FISH_FILE, "")) && readFileSync4(join6(dir, name), "utf8").startsWith(MARKER));
+  const removed = readdirSync(dir).filter((name) => FISH_FILE.test(name) && !bins.includes(name.replace(FISH_FILE, "")) && readFileSync5(join8(dir, name), "utf8").startsWith(MARKER));
   for (const name of removed)
-    rmSync(join6(dir, name));
-  await Promise.all(bins.map(async (bin) => Bun.write(join6(dir, `${bin}.fish`), completionFile(bin))));
+    rmSync(join8(dir, name));
+  await Promise.all(bins.map(async (bin) => Bun.write(join8(dir, `${bin}.fish`), completionFile(bin))));
   return { written: bins, removed: removed.map((name) => name.replace(FISH_FILE, "")) };
 }
 function missingCompletions(host, dir) {
-  return installedBins(host).filter((bin) => !existsSync3(join6(dir, `${bin}.fish`)));
+  return installedBins(host).filter((bin) => !existsSync6(join8(dir, `${bin}.fish`)));
+}
+
+// src/config-report.ts
+import { existsSync as existsSync7, readFileSync as readFileSync6 } from "fs";
+import { join as join9, resolve as resolve4 } from "path";
+import process16 from "process";
+var USER_FILES = [["config", []], ["theme", []], ["doctor", []], ["ft", [["ft", "config.json"]]], ["db", [["db", "config.json"]]], ["pkg", []], ["pkg-excluded", []], ["repos", []]];
+var PROJECT_FILES = [join9(".kaynooo", "theme.json"), ".pkgrc.json"];
+var ENV = ["KAYNOOO_WORKSPACE", "KAYNOOO_CLI_NO_USAGE", "KIT_MODE", "KIT_THEME", "KIT_HELP", "CI", "CLAUDECODE", "AI_AGENT", "NO_COLOR", "FORCE_COLOR", "NODE_DISABLE_COLORS", "COLORTERM", "TERM", "BROWSER", "EDITOR", "VISUAL", "SLOT_DIR", "XDG_CONFIG_HOME", "XDG_CACHE_HOME", "XDG_STATE_HOME", "XDG_RUNTIME_DIR", "BUN_INSTALL", "COMPOSE_FILE", "COMPOSE_PATH_SEPARATOR", "CLAUDE_CONFIG_DIR", "CLAUDE_CODE_TMPDIR", "GITHUB_TOKEN", "DISCORD_WEBHOOK"];
+var SECRETS = new Set(["GITHUB_TOKEN", "DISCORD_WEBHOOK"]);
+function fileStatus(path) {
+  if (!existsSync7(path))
+    return "absent";
+  try {
+    Bun.JSONC.parse(readFileSync6(path, "utf8"));
+    return "set";
+  } catch {
+    return "invalid";
+  }
+}
+function configReport(host, env = process16.env, from = process16.cwd()) {
+  const sources = USER_FILES.map(([bin, legacy]) => {
+    const where = userConfigReadPath(bin, legacy, { home: host.home, xdg: env.XDG_CONFIG_HOME });
+    return { kind: "file", name: `${bin}.json`, where, status: fileStatus(where) };
+  });
+  for (const name of PROJECT_FILES) {
+    const where = findUp(name, from, (dir) => dir === resolve4(host.home) || existsSync7(join9(dir, ".git")));
+    sources.push({ kind: "file", name, where: where ?? `${name} (none found upward from ${from})`, status: where === undefined ? "absent" : fileStatus(where) });
+  }
+  for (const name of ENV) {
+    const value = env[name];
+    sources.push({ kind: "env", name, where: "environment", status: value === undefined || value === "" ? "absent" : "set", ...value === undefined || value === "" ? {} : { value: SECRETS.has(name) ? "(hidden)" : value } });
+  }
+  const { sources: themes, preset } = loadTheme({ env, from, home: host.home, warn: () => {
+    return;
+  } });
+  return { workspace: workspaceRoot({ env, home: host.home }), theme: { preset, sources: themes }, sources };
 }
 
 // src/doctor.ts
-import process17 from "process";
+import process20 from "process";
 
 // src/fix.ts
 var INSTALL = /^bun install -g (\S+)$/;
@@ -1551,19 +1784,19 @@ async function applyFixes(host, steps, dry) {
 }
 
 // src/host.ts
-import { homedir as homedir4 } from "os";
-import { join as join7 } from "path";
-import process14 from "process";
+import { homedir as homedir5 } from "os";
+import { join as join10 } from "path";
+import process17 from "process";
 var RUN_TIMEOUT_MS = 20000;
 function hostHere() {
-  const home = homedir4();
+  const home = homedir5();
   return {
     home,
-    globalModules: join7(process14.env.BUN_INSTALL ?? join7(home, ".bun"), "install", "global", "node_modules"),
+    globalModules: join10(process17.env.BUN_INSTALL ?? join10(home, ".bun"), "install", "global", "node_modules"),
     bunVersion: Bun.version,
     which: (bin) => Bun.which(bin),
     run: async (argv, env) => {
-      const ran = await runCommand(argv, { timeoutMs: RUN_TIMEOUT_MS, ...env === undefined ? {} : { env: { ...process14.env, ...env } } });
+      const ran = await runCommand(argv, { timeoutMs: RUN_TIMEOUT_MS, ...env === undefined ? {} : { env: { ...process17.env, ...env } } });
       if (ran.timedOut)
         return { code: 1, stdout: "", stderr: `timed out after ${RUN_TIMEOUT_MS / 1000}s` };
       const of = (stream) => Buffer.concat(ran.chunks.filter((chunk) => chunk.stream === stream).map((chunk) => chunk.data)).toString();
@@ -1573,19 +1806,53 @@ function hostHere() {
 }
 
 // src/install.ts
-import process16 from "process";
+import process19 from "process";
 
 // ../kit/src/prompt.ts
-import process15 from "process";
-var KEY_SEQUENCES = /\x1B\[[0-9;]*[A-Z~]|\x1BO[A-Z]|[\s\S]/giu;
-var CONTROL = /^[\x00-\x1F\x7F]/;
-var WORDS = /\s+/;
-var MAX_ROWS = 10;
+import process18 from "process";
+
+// ../kit/src/picker/score.ts
+var BOUNDARY_AFTER = new Set([" ", "/", "-", "_", ".", ":", "\\", "(", "[", ",", "\t"]);
+var NONE = Number.NEGATIVE_INFINITY;
+
+// ../kit/src/picker/state.ts
+var IS_CONTROL = /[\x00-\x1F\x7F-\x9F]/;
 var PASTE_START = "\x1B[200~";
 var PASTE_END = "\x1B[201~";
-var KEYS = { "\x1B[A": "up", "\x1BOA": "up", "\x1B[B": "down", "\x1BOB": "down", "\x1B[5~": "pageup", "\x1B[6~": "pagedown", "\x1B[H": "home", "\x1B[1~": "home", "\x1BOH": "home", "\x1B[F": "end", "\x1B[4~": "end", "\x1BOF": "end", "\r": "enter", "\n": "enter", "\x03": "cancel", "\x1B": "cancel", "\x7F": "erase", "\b": "erase" };
-function readKeys(input, paste = { active: false }) {
+var KEY_SEQUENCES = /\x1B\[[0-9;]*[A-Z~]|\x1BO[A-Z]|\x1B[\s\S]|[\s\S]/gu;
+var KEYS = {
+  "\x1B[A": "up",
+  "\x1BOA": "up",
+  "\x10": "up",
+  "\x1B[B": "down",
+  "\x1BOB": "down",
+  "\x0E": "down",
+  "\x1B[5~": "pageup",
+  "\x1B[6~": "pagedown",
+  "\x1B[H": "home",
+  "\x1B[1~": "home",
+  "\x1BOH": "home",
+  "\x1B[F": "end",
+  "\x1B[4~": "end",
+  "\x1BOF": "end",
+  "\r": "enter",
+  "\n": "enter",
+  "\x03": "cancel",
+  "\x1B": "cancel",
+  "\x7F": "erase",
+  "\b": "erase",
+  "\x15": "clear",
+  "\x17": "word",
+  "\t": "tab",
+  "\x1F": "help",
+  "\x1BOP": "help",
+  "\x1B[11~": "help"
+};
+function parseKeys(input, paste = { active: false }, ctrls = []) {
+  const codes = new Map(ctrls.map((name) => [String.fromCharCode(name.codePointAt(name.length - 1) - 96), name]));
   return (input.match(KEY_SEQUENCES) ?? []).flatMap((sequence) => {
+    const named = codes.get(sequence);
+    const key = named === undefined ? KEYS[sequence] : { ctrl: named };
     if (sequence === PASTE_START || sequence === PASTE_END) {
       paste.active = sequence === PASTE_START;
       return [];
@@ -1593,9 +1860,19 @@ function readKeys(input, paste = { active: false }) {
     if (paste.active && (sequence === "\r" || sequence === `
 `))
       return [];
-    return KEYS[sequence] ?? (CONTROL.test(sequence) ? [] : [{ text: sequence }]);
+    if (key !== undefined)
+      return [key];
+    return IS_CONTROL.test(sequence) || sequence.startsWith("\x1B") ? [] : [{ text: sequence }];
   });
 }
+
+// ../kit/src/prompt.ts
+var WORDS = /\s+/;
+var MAX_ROWS = 10;
+var PROMPT_KEYS = new Set(["up", "down", "pageup", "pagedown", "home", "end", "enter", "cancel", "erase"]);
+function readKeys(input, paste = { active: false }) {
+  return parseKeys(input, paste).filter((key) => typeof key === "object" ? "text" in key : PROMPT_KEYS.has(key));
+}
 function flip(checked, value) {
   const next = new Set(checked);
   if (!next.delete(value))
@@ -1735,7 +2012,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 = process18 }, render, press) {
   const { stdin, stderr } = terminal;
   if (!isInteractive(terminal))
     fail(`cannot ask "${question}" off a terminal`, 2, hint);
@@ -1870,7 +2147,7 @@ async function askWorkspace(host) {
 async function install(host, options, recheck, choosing = ask2) {
   const all = candidates2(host);
   const pool = all.filter((each) => !each.installed);
-  const { dim, green, red, yellow } = paint(process16.stdout);
+  const { dim, green, red, yellow } = paint(process19.stdout);
   if (options.list) {
     for (const each of pool)
       console.log(`${each.label.padEnd(12)} ${dim(each.hint)}`);
@@ -1978,7 +2255,7 @@ var OPTIONS = {
 function print(results) {
   if (results.length === 0)
     return;
-  const { green, red, dim } = paint(process17.stdout);
+  const { green, red, dim } = paint(process20.stdout);
   const width = Math.max(...results.map((result) => result.check.length));
   for (const { check, ok, detail, fix } of results)
     console.log(`${ok ? green("ok  ") : red("FAIL")}  ${check.padEnd(width)}  ${detail}${fix === undefined ? "" : `  ${dim("fix:")} ${fix}`}`);
@@ -1988,7 +2265,7 @@ function print(results) {
 ${dim("fix them all:")} ${INSTALL2}${installs.join(" ")}`);
 }
 function printOutcomes(outcomes, log) {
-  const { green, red, dim } = paint(process17.stdout);
+  const { green, red, dim } = paint(process20.stdout);
   const marks = { ran: green("ran    "), failed: red("failed "), "dry-run": dim("would  "), "not run": dim("not run") };
   for (const { command, status, detail } of outcomes)
     log(`${marks[status]}  ${command}${detail === undefined ? "" : `  ${dim(detail)}`}`);
@@ -2028,7 +2305,7 @@ after the fixes:`);
   const absent = Object.keys(TOOLS).filter((name) => !isInstalled(host, name)).length;
   if (!json && only.length === 0 && absent > 0)
     console.log(`
-${paint(process17.stdout).dim(`${absent} packages not installed: doctor --install`)}`);
+${paint(process20.stdout).dim(`${absent} packages not installed: doctor --install`)}`);
   return results.every((result) => result.ok) ? 0 : 1;
 }
 
@@ -2057,7 +2334,7 @@ var LIST_OPTIONS = {
   json: jsonOption("[{bin, package, installed, synopsis?, summary?, replaces?, examples?}]")
 };
 function print2(listed) {
-  const { cyan, dim } = paint(process18.stdout);
+  const { cyan, dim } = paint(process21.stdout);
   const width = Math.max(...listed.map((each) => each.bin.length));
   for (const each of listed) {
     const what = !each.installed ? dim(`not installed: bun install -g ${each.package}`) : `${each.summary ?? ""}${each.replaces === undefined ? "" : dim(`; instead of ${each.replaces}`)}`;
@@ -2073,26 +2350,24 @@ async function list(args, host = hostHere()) {
     print2(listed);
   return 0;
 }
-var COMPLETIONS_USAGE = `cli completions <fish|bash> [--install] [--dir <folder>]: shell completions for every installed bin of the @kaynooo/cli-* packages
+var COMPLETIONS_USAGE = `cli completions <fish|bash|zsh> [--install] [--dir <folder>]: shell completions for every installed bin of the @kaynooo/cli-* packages
 
 Each bin completes itself through \`<bin> __complete\`; this writes the glue a shell needs per bin.
 fish: without --install the files print on stdout, with it they go to ~/.cache/fish/kaynooo-cli (or $XDG_CACHE_HOME), one <bin>.fish each, the stale ones this command wrote taken out. That folder has to be in fish_complete_path, first so a completion fish ships for the same name does not win: \`set -p fish_complete_path ~/.cache/fish/kaynooo-cli\`.
 bash: one script on stdout, sourced from ~/.bashrc with \`source <(cli completions bash)\`; --install and --dir are fish's.
-zsh: has no script of its own, it reads the bash one through bashcompinit: \`autoload -U +X compinit && compinit\`, \`autoload -U +X bashcompinit && bashcompinit\`, then the bash line above in ~/.zshrc (untested, zsh is not installed on the machine this was written on).`;
+zsh: one script on stdout like bash's, after compinit in ~/.zshrc: \`autoload -U +X compinit && compinit\`, then \`source <(cli completions zsh)\` (written without zsh at hand to run it, so untested).`;
 var COMPLETIONS_OPTIONS = {
   install: { type: "boolean", description: "write the files to the folder instead of printing them" },
   dir: { type: "string", short: "d", description: "the folder to write to, instead of ~/.cache/fish/kaynooo-cli" }
 };
 async function completions(args, host = hostHere()) {
-  const { values, positionals } = parse(args, COMPLETIONS_USAGE, COMPLETIONS_OPTIONS, { positionals: ["<shell>"], exits: [[0, "it printed or wrote them"], [2, "a usage error or a shell without a script"]], candidates: { "<shell>": () => ["fish", "bash"] }, examples: ["cli completions fish", ["cli completions fish --install", "write one file per bin"], ["source <(cli completions bash)", "in ~/.bashrc"]] });
-  if (positionals[0] === "zsh")
-    badUsage("zsh has no script of its own: it reads the bash one through bashcompinit, see cli completions --help");
-  if (positionals[0] !== "fish" && positionals[0] !== "bash")
-    badUsage("completions exist for fish and bash: cli completions fish");
-  if (positionals[0] === "bash") {
+  const { values, positionals } = parse(args, COMPLETIONS_USAGE, COMPLETIONS_OPTIONS, { positionals: ["<shell>"], exits: [[0, "it printed or wrote them"], [2, "a usage error or a shell without a script"]], candidates: { "<shell>": () => ["fish", "bash", "zsh"] }, examples: ["cli completions fish", ["cli completions fish --install", "write one file per bin"], ["source <(cli completions bash)", "in ~/.bashrc"], ["source <(cli completions zsh)", "in ~/.zshrc after compinit"]] });
+  if (positionals[0] !== "fish" && positionals[0] !== "bash" && positionals[0] !== "zsh")
+    badUsage("completions exist for fish, bash and zsh: cli completions fish");
+  if (positionals[0] === "bash" || positionals[0] === "zsh") {
     if (values.install === true || values.dir !== undefined)
-      badUsage("--install and --dir are for fish: source the bash script instead");
-    console.log(bashScript(installedBins(host)).trimEnd());
+      badUsage(`--install and --dir are for fish: source the ${positionals[0]} script instead`);
+    console.log((positionals[0] === "zsh" ? zshScript : bashScript)(installedBins(host)).trimEnd());
     return 0;
   }
   if (values.install !== true) {
@@ -2113,6 +2388,31 @@ var STATS_OPTIONS = {
   since: { type: "string", description: "only the runs this recent (7d, 12h)" },
   json: jsonOption("{runs, bins: [{bin, runs, failed, usageErrors}], commands: [{bin, command, runs, failed, usageErrors}], usageErrors: [{bin, command?, unknown, count}]}")
 };
+var CONFIG_USAGE = `cli config [--json]: where every bin looks for its config and which environment variables are set
+
+Lists each user and project config file with the path read and whether it is there (set, absent, or invalid when it does not parse), then the main environment variables that change a bin's behaviour (docs/config.md has the rest); a token or webhook shows as hidden. Ends on the workspace folder and the theme in force. docs/config.md in the repository describes every key.
+Exits 0 when it printed the report, 2 on a usage error.`;
+var CONFIG_OPTIONS = {
+  json: jsonOption("{workspace, theme: {preset, sources}, sources: [{kind, name, where, status, value?}]}")
+};
+function config2(args, host = hostHere()) {
+  const { values } = parse(args, CONFIG_USAGE, CONFIG_OPTIONS, { positionals: [], examples: ["cli config", ["cli config --json", "for a script"]] });
+  const report = configReport(host);
+  if (values.json === true) {
+    printJson(report);
+    return 0;
+  }
+  const { dim } = paint(process21.stdout);
+  console.log(table(report.sources.filter((each) => each.kind === "file").map((each) => [each.name, each.status === "absent" ? dim(each.status) : each.status, dim(each.where)])));
+  const variables = report.sources.filter((each) => each.kind === "env" && each.status === "set");
+  console.log(variables.length === 0 ? `
+${dim("no variable set")}` : `
+${table(variables.map((each) => [each.name, each.value ?? ""]))}`);
+  console.log(`
+workspace  ${report.workspace}
+theme      ${report.theme.preset}${report.theme.sources.length === 0 ? "" : `, from ${report.theme.sources.join(", ")}`}`);
+  return 0;
+}
 async function stats(args, path = usagePath()) {
   const { values } = parse(args, STATS_USAGE, STATS_OPTIONS, { positionals: [], examples: ["cli stats", ["cli stats --since 7d", "the last week"]] });
   const window = values.since === undefined ? undefined : duration(values.since, "since", 0, "h");
@@ -2140,7 +2440,7 @@ ${table(summary.usageErrors.map((each) => [`${each.bin}${each.command === undefi
   return 0;
 }
 if (import.meta.main) {
-  process18.exitCode = await runCli({
+  process21.exitCode = await runCli({
     name: "cli",
     about: "the bins of the @kaynooo/cli-* packages, described by their own help",
     replaces: "running each bin's --help to find the one that fits",
@@ -2148,6 +2448,7 @@ if (import.meta.main) {
     commands: {
       doctor: { summary: "checks this host's install of the bins, one line per check, the command that fixes a failing one beside it", run: async (args) => main(args) },
       list: { summary: "every bin in one line: what it does and what it is reached for instead of", run: async (args) => list(args) },
+      config: { summary: "where every bin looks for its config and which environment variables are set", run: async (args) => Promise.resolve(config2(args)) },
       stats: { summary: "how often each bin ran and the options usage errors did not know", run: async (args) => stats(args) },
       completions: { summary: "fish completions for every installed bin, printed or written to the folder fish reads", run: async (args) => completions(args) }
     }
@@ -2155,6 +2456,7 @@ if (import.meta.main) {
 }
 export {
   completions,
+  config2 as config,
   list,
   stats
 };