@kaynooo/cli-doctor 0.11.0 → 0.13.0

package/dist/cli.js

@@ -2,13 +2,13 @@
 // @bun
 
 // src/cli.ts
-import process18 from "process";
+import process20 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,17 +1403,17 @@ 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/doctor.ts
-import process17 from "process";
+import process19 from "process";
 
 // src/checks.ts
-import { existsSync as existsSync3, readFileSync as readFileSync4 } from "fs";
-import { basename, join as join6 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
+import { basename, join as join8 } from "path";
 
 // src/catalog.ts
 var HOOKS_REQUIRES = "@kaynooo/cli-guard";
@@ -1287,9 +1449,9 @@ var NEEDS = {
 };
 
 // src/completions.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync3, readdirSync, readFileSync as readFileSync3, rmSync } from "fs";
-import { join as join5 } from "path";
-import process13 from "process";
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readdirSync, readFileSync as readFileSync4, rmSync } from "fs";
+import { join as join7 } from "path";
+import process15 from "process";
 var MARKER = "# Generated by `cli completions fish`";
 var FISH_FILE = /\.fish$/;
 var FUNCTION = `functions -q __kaynooo_cli_complete; or function __kaynooo_cli_complete --argument-names bin --description 'what a @kaynooo/cli-* bin offers for the word being typed'
@@ -1317,14 +1479,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 join5(env.XDG_CACHE_HOME ?? join5(home, ".cache"), "fish", "kaynooo-cli");
+function completionDir(home, env = process15.env) {
+  return join7(env.XDG_CACHE_HOME ?? join7(home, ".cache"), "fish", "kaynooo-cli");
 }
 function installedBins(host) {
   return Object.values(TOOLS).flat().filter((bin) => host.which(bin) !== null);
@@ -1338,14 +1522,14 @@ 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, "")) && readFileSync3(join5(dir, name), "utf8").startsWith(MARKER));
+  const removed = readdirSync(dir).filter((name) => FISH_FILE.test(name) && !bins.includes(name.replace(FISH_FILE, "")) && readFileSync4(join7(dir, name), "utf8").startsWith(MARKER));
   for (const name of removed)
-    rmSync(join5(dir, name));
-  await Promise.all(bins.map(async (bin) => Bun.write(join5(dir, `${bin}.fish`), completionFile(bin))));
+    rmSync(join7(dir, name));
+  await Promise.all(bins.map(async (bin) => Bun.write(join7(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) => !existsSync2(join5(dir, `${bin}.fish`)));
+  return installedBins(host).filter((bin) => !existsSync5(join7(dir, `${bin}.fish`)));
 }
 
 // src/checks.ts
@@ -1389,7 +1573,7 @@ function readJsonText(text) {
   }
 }
 function readJson(path) {
-  return existsSync3(path) ? readJsonText(readFileSync4(path, "utf8")) : undefined;
+  return existsSync6(path) ? readJsonText(readFileSync5(path, "utf8")) : undefined;
 }
 function firstLine(text) {
   const trimmed = text.trim();
@@ -1398,7 +1582,7 @@ function firstLine(text) {
   return end === -1 ? trimmed : trimmed.slice(0, end);
 }
 function installed(host, name) {
-  return readJson(join6(host.globalModules, name, "package.json"));
+  return readJson(join8(host.globalModules, name, "package.json"));
 }
 function isInstalled(host, name) {
   return installed(host, name)?.version !== undefined;
@@ -1406,7 +1590,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 : join6(host.globalModules, name, file);
+  return file === undefined ? undefined : join8(host.globalModules, name, file);
 }
 async function checkTool(host, name, bins) {
   const check = name.slice(name.indexOf("/") + 1);
@@ -1421,17 +1605,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 ${join6(host.globalModules, "..", "..", "..", "bin")} to the PATH` };
+    return { check, ok: false, detail: `${version}, ${off.join(", ")} not on the PATH`, fix: `add ${join8(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 (!existsSync6(path))
+      return [];
+    const raw = Bun.JSONC.parse(readFileSync5(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"]);
@@ -1442,9 +1638,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(join6(host.home, ".claude", "settings.json")) ?? {};
+  const settings = readJson(join8(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" && existsSync3(join6(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" && existsSync6(join8(dir, "hooks", "hooks.json")));
   return { plugin, mod };
 }
 function checkHooks(host) {
@@ -1487,7 +1683,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 (existsSync3(folder))
+  if (existsSync6(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` };
 }
@@ -1549,19 +1745,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 join9 } from "path";
+import process16 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: join9(process16.env.BUN_INSTALL ?? join9(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: { ...process16.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();
@@ -1571,19 +1767,53 @@ function hostHere() {
 }
 
 // src/install.ts
-import process16 from "process";
+import process18 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 process17 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 [];
@@ -1591,9 +1821,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))
@@ -1733,7 +1973,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 (!isInteractive(terminal))
     fail(`cannot ask "${question}" off a terminal`, 2, hint);
@@ -1868,7 +2108,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(process18.stdout);
   if (options.list) {
     for (const each of pool)
       console.log(`${each.label.padEnd(12)} ${dim(each.hint)}`);
@@ -1976,7 +2216,7 @@ var OPTIONS = {
 function print(results) {
   if (results.length === 0)
     return;
-  const { green, red, dim } = paint(process17.stdout);
+  const { green, red, dim } = paint(process19.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}`}`);
@@ -1986,7 +2226,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(process19.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)}`}`);
@@ -2026,9 +2266,9 @@ 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(process19.stdout).dim(`${absent} packages not installed: doctor --install`)}`);
   return results.every((result) => result.ok) ? 0 : 1;
 }
 
 // src/cli.ts
-process18.exitCode = await runMain({ name: "doctor", run: async (args) => main(args) });
+process20.exitCode = await runMain({ name: "doctor", run: async (args) => main(args) });