shellrecap 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1308 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CONFIG_FILENAMES: () => CONFIG_FILENAMES,
+  DEFAULT_CONFIG: () => DEFAULT_CONFIG,
+  KNOWN_COMMANDS: () => KNOWN_COMMANDS,
+  KNOWN_TYPOS: () => KNOWN_TYPOS,
+  PERSONAS: () => PERSONAS,
+  SECRET_KIND_LABELS: () => SECRET_KIND_LABELS,
+  WEEKDAY_NAMES: () => WEEKDAY_NAMES,
+  WEEKDAY_SHORT: () => WEEKDAY_SHORT,
+  analyze: () => analyze,
+  computeAliasStats: () => computeAliasStats,
+  computeSecretHits: () => computeSecretHits,
+  computeTimeStats: () => computeTimeStats,
+  computeTypoStats: () => computeTypoStats,
+  daysToYMD: () => daysToYMD,
+  derivePersona: () => derivePersona,
+  detectFormat: () => detectFormat,
+  editDistance: () => editDistance,
+  epochToDate: () => epochToDate,
+  epochToHour: () => epochToHour,
+  epochToWeekday: () => epochToWeekday,
+  hourLabel: () => hourLabel,
+  isValidTheme: () => isValidTheme,
+  mask: () => mask,
+  mergeConfig: () => mergeConfig,
+  parseBash: () => parseBash,
+  parseConfig: () => parseConfig,
+  parseFish: () => parseFish,
+  parseHistory: () => parseHistory,
+  parsePlain: () => parsePlain,
+  parseZshExtended: () => parseZshExtended,
+  renderCard: () => renderCard,
+  splitSegments: () => splitSegments,
+  suggestAliasName: () => suggestAliasName,
+  toJSON: () => toJSON,
+  toMarkdown: () => toMarkdown,
+  toSegment: () => toSegment,
+  tokenizeEntry: () => tokenizeEntry,
+  tokens: () => tokens
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/parse.ts
+var ZSH_EXT_RE = /^: (\d{9,12}):(\d+);(.*)$/;
+var BASH_TS_RE = /^#(\d{9,12})\s*$/;
+var FISH_CMD_RE = /^- cmd: (.*)$/;
+var FISH_WHEN_RE = /^\s+when: (\d{9,12})\s*$/;
+function detectFormat(raw) {
+  const lines = raw.split("\n", 400).filter((l) => l.length > 0).slice(0, 200);
+  let zsh = 0;
+  let bashTs = 0;
+  let fish = 0;
+  for (const l of lines) {
+    if (ZSH_EXT_RE.test(l)) zsh++;
+    else if (BASH_TS_RE.test(l)) bashTs++;
+    else if (FISH_CMD_RE.test(l)) fish++;
+  }
+  if (fish > 0 && fish >= zsh) return "fish";
+  if (zsh > 0) return "zsh-extended";
+  if (bashTs > 0) return "bash";
+  return "plain";
+}
+function parseZshExtended(raw) {
+  const out = [];
+  for (const line of raw.split("\n")) {
+    const m = line.match(ZSH_EXT_RE);
+    if (m) {
+      out.push({ cmd: m[3], ts: Number(m[1]) });
+    } else if (line.length > 0 && out.length > 0) {
+      out[out.length - 1].cmd += "\n" + line;
+    }
+  }
+  return finalize(out);
+}
+function parseBash(raw) {
+  const out = [];
+  let pendingTs;
+  for (const line of raw.split("\n")) {
+    if (line.length === 0) continue;
+    const ts = line.match(BASH_TS_RE);
+    if (ts) {
+      pendingTs = Number(ts[1]);
+      continue;
+    }
+    out.push(pendingTs === void 0 ? { cmd: line } : { cmd: line, ts: pendingTs });
+    pendingTs = void 0;
+  }
+  return finalize(out);
+}
+function unescapeFish(s) {
+  let out = "";
+  for (let i = 0; i < s.length; i++) {
+    const c = s[i];
+    if (c === "\\" && i + 1 < s.length) {
+      const n = s[i + 1];
+      if (n === "n") {
+        out += "\n";
+        i++;
+        continue;
+      }
+      if (n === "\\") {
+        out += "\\";
+        i++;
+        continue;
+      }
+    }
+    out += c;
+  }
+  return out;
+}
+function parseFish(raw) {
+  const out = [];
+  for (const line of raw.split("\n")) {
+    const cmd = line.match(FISH_CMD_RE);
+    if (cmd) {
+      out.push({ cmd: unescapeFish(cmd[1]) });
+      continue;
+    }
+    const when = line.match(FISH_WHEN_RE);
+    if (when && out.length > 0) {
+      out[out.length - 1].ts = Number(when[1]);
+    }
+  }
+  return finalize(out);
+}
+function parsePlain(raw) {
+  const out = [];
+  for (const line of raw.split("\n")) {
+    if (line.trim().length === 0) continue;
+    out.push({ cmd: line });
+  }
+  return finalize(out);
+}
+function finalize(entries) {
+  return entries.filter((e) => e.cmd.trim().length > 0);
+}
+function parseHistory(raw, format) {
+  const f = format ?? detectFormat(raw);
+  switch (f) {
+    case "zsh-extended":
+      return { entries: parseZshExtended(raw), format: f };
+    case "bash":
+      return { entries: parseBash(raw), format: f };
+    case "fish":
+      return { entries: parseFish(raw), format: f };
+    case "plain":
+      return { entries: parsePlain(raw), format: f };
+  }
+}
+
+// src/tokenize.ts
+var WRAPPERS = /* @__PURE__ */ new Set(["sudo", "command", "builtin", "exec", "nohup", "time", "doas", "env"]);
+var SUBCOMMAND_CLIS = /* @__PURE__ */ new Set([
+  "git",
+  "docker",
+  "podman",
+  "kubectl",
+  "helm",
+  "npm",
+  "pnpm",
+  "yarn",
+  "bun",
+  "deno",
+  "cargo",
+  "go",
+  "pip",
+  "pip3",
+  "uv",
+  "poetry",
+  "brew",
+  "apt",
+  "apt-get",
+  "dnf",
+  "pacman",
+  "gh",
+  "glab",
+  "aws",
+  "gcloud",
+  "az",
+  "terraform",
+  "pulumi",
+  "vagrant",
+  "systemctl",
+  "service",
+  "make",
+  "just",
+  "rails",
+  "bundle",
+  "mix",
+  "composer",
+  "dotnet",
+  "flutter",
+  "gem",
+  "conda",
+  "nix",
+  "tmux",
+  "svn"
+]);
+function splitSegments(cmd) {
+  const parts = [];
+  let cur = "";
+  let q = null;
+  let pipes = 0;
+  const push = () => {
+    const t = cur.trim();
+    if (t.length > 0) parts.push(t);
+    cur = "";
+  };
+  for (let i = 0; i < cmd.length; i++) {
+    const c = cmd[i];
+    if (q) {
+      cur += c;
+      if (c === q && cmd[i - 1] !== "\\") q = null;
+      continue;
+    }
+    if (c === "'" || c === '"') {
+      q = c;
+      cur += c;
+      continue;
+    }
+    if (c === "\\" && i + 1 < cmd.length) {
+      cur += c + cmd[i + 1];
+      i++;
+      continue;
+    }
+    if (c === "|") {
+      pipes++;
+      if (cmd[i + 1] === "|") i++;
+      push();
+      continue;
+    }
+    if (c === "&" && cmd[i + 1] === "&") {
+      i++;
+      push();
+      continue;
+    }
+    if (c === ";" || c === "\n") {
+      push();
+      continue;
+    }
+    cur += c;
+  }
+  push();
+  return { parts, pipes };
+}
+function tokens(segment) {
+  const out = [];
+  let cur = "";
+  let q = null;
+  for (let i = 0; i < segment.length; i++) {
+    const c = segment[i];
+    if (q) {
+      if (c === q) q = null;
+      else cur += c;
+      continue;
+    }
+    if (c === "'" || c === '"') {
+      q = c;
+      continue;
+    }
+    if (c === "\\" && i + 1 < segment.length) {
+      cur += segment[i + 1];
+      i++;
+      continue;
+    }
+    if (c === " " || c === "	") {
+      if (cur) out.push(cur);
+      cur = "";
+      continue;
+    }
+    cur += c;
+  }
+  if (cur) out.push(cur);
+  return out;
+}
+var ENV_ASSIGN_RE = /^[A-Za-z_][A-Za-z0-9_]*=/;
+function toSegment(part) {
+  let tks = tokens(part);
+  if (tks.length === 0) return null;
+  let sudo = false;
+  let guard = 0;
+  while (tks.length > 0 && guard++ < 10) {
+    const head = tks[0];
+    if (ENV_ASSIGN_RE.test(head)) {
+      tks = tks.slice(1);
+      continue;
+    }
+    if (WRAPPERS.has(head)) {
+      if (head === "sudo" || head === "doas") sudo = true;
+      tks = tks.slice(1);
+      while (tks.length > 0 && tks[0].startsWith("-")) tks = tks.slice(1);
+      continue;
+    }
+    break;
+  }
+  if (tks.length === 0) return null;
+  let base = tks[0];
+  if (base.includes("/")) base = base.slice(base.lastIndexOf("/") + 1);
+  base = base.toLowerCase();
+  if (base.length === 0) return null;
+  let withSub = base;
+  if (SUBCOMMAND_CLIS.has(base)) {
+    const next = tks.find((t, i) => i > 0 && /^[a-z][a-z0-9_-]{0,19}$/i.test(t));
+    if (next) withSub = `${base} ${next.toLowerCase()}`;
+  }
+  return { base, withSub, tokens: tks, sudo };
+}
+function tokenizeEntry(entry) {
+  const { parts, pipes } = splitSegments(entry.cmd);
+  const segments = [];
+  for (const p of parts) {
+    const s = toSegment(p);
+    if (s) segments.push(s);
+  }
+  return { raw: entry.cmd, ts: entry.ts, segments, pipes };
+}
+
+// src/date.ts
+function epochToDays(ts, tzOffsetMin) {
+  return Math.floor((ts + tzOffsetMin * 60) / 86400);
+}
+function epochToHour(ts, tzOffsetMin) {
+  const sec = ((ts + tzOffsetMin * 60) % 86400 + 86400) % 86400;
+  return Math.floor(sec / 3600);
+}
+function epochToWeekday(ts, tzOffsetMin) {
+  const days = epochToDays(ts, tzOffsetMin);
+  return ((days + 4) % 7 + 7) % 7;
+}
+function daysToYMD(z) {
+  z += 719468;
+  const era = Math.floor(z / 146097);
+  const doe = z - era * 146097;
+  const yoe = Math.floor((doe - Math.floor(doe / 1460) + Math.floor(doe / 36524) - Math.floor(doe / 146096)) / 365);
+  const y = yoe + era * 400;
+  const doy = doe - (365 * yoe + Math.floor(yoe / 4) - Math.floor(yoe / 100));
+  const mp = Math.floor((5 * doy + 2) / 153);
+  const d = doy - Math.floor((153 * mp + 2) / 5) + 1;
+  const m = mp < 10 ? mp + 3 : mp - 9;
+  return { y: m <= 2 ? y + 1 : y, m, d };
+}
+function epochToDate(ts, tzOffsetMin) {
+  const { y, m, d } = daysToYMD(epochToDays(ts, tzOffsetMin));
+  return `${String(y).padStart(4, "0")}-${String(m).padStart(2, "0")}-${String(d).padStart(2, "0")}`;
+}
+var WEEKDAY_NAMES = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+var WEEKDAY_SHORT = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+function hourLabel(h) {
+  const period = h < 12 ? "AM" : "PM";
+  const base = h % 12 === 0 ? 12 : h % 12;
+  return `${base} ${period}`;
+}
+
+// src/stats/time.ts
+var NIGHT_HOURS = /* @__PURE__ */ new Set([22, 23, 0, 1, 2, 3, 4]);
+function argmax(arr) {
+  let best = 0;
+  for (let i = 1; i < arr.length; i++) if (arr[i] > arr[best]) best = i;
+  return best;
+}
+function computeTimeStats(entries, tzOffsetMin) {
+  const byHour = new Array(24).fill(0);
+  const byWeekday = new Array(7).fill(0);
+  const byDate = /* @__PURE__ */ new Map();
+  let stamped = 0;
+  let night = 0;
+  let weekend = 0;
+  let firstTs;
+  let lastTs;
+  for (const e of entries) {
+    if (e.ts === void 0) continue;
+    stamped++;
+    const h = epochToHour(e.ts, tzOffsetMin);
+    const w = epochToWeekday(e.ts, tzOffsetMin);
+    byHour[h] = (byHour[h] ?? 0) + 1;
+    byWeekday[w] = (byWeekday[w] ?? 0) + 1;
+    if (NIGHT_HOURS.has(h)) night++;
+    if (w === 0 || w === 6) weekend++;
+    const date = epochToDate(e.ts, tzOffsetMin);
+    byDate.set(date, (byDate.get(date) ?? 0) + 1);
+    if (firstTs === void 0 || e.ts < firstTs) firstTs = e.ts;
+    if (lastTs === void 0 || e.ts > lastTs) lastTs = e.ts;
+  }
+  let busiestDay;
+  for (const [date, commands] of byDate) {
+    if (!busiestDay || commands > busiestDay.commands || commands === busiestDay.commands && date < busiestDay.date) {
+      busiestDay = { date, commands };
+    }
+  }
+  const n = stamped || 1;
+  return {
+    hasTimestamps: stamped > 0,
+    byHour,
+    byWeekday,
+    peakHour: argmax(byHour),
+    peakWeekday: argmax(byWeekday),
+    nightOwlPct: night / n * 100,
+    weekendPct: weekend / n * 100,
+    firstDate: firstTs === void 0 ? void 0 : epochToDate(firstTs, tzOffsetMin),
+    lastDate: lastTs === void 0 ? void 0 : epochToDate(lastTs, tzOffsetMin),
+    busiestDay
+  };
+}
+
+// src/stats/typos.ts
+var KNOWN_TYPOS = {
+  gti: "git",
+  gut: "git",
+  igt: "git",
+  sl: "ls",
+  lls: "ls",
+  grpe: "grep",
+  gerp: "grep",
+  claer: "clear",
+  celar: "clear",
+  clera: "clear",
+  exti: "exit",
+  eixt: "exit",
+  pdw: "pwd",
+  mkdri: "mkdir",
+  mkidr: "mkdir",
+  suod: "sudo",
+  sduo: "sudo",
+  dokcer: "docker",
+  dcoker: "docker",
+  kubeclt: "kubectl",
+  kubctl: "kubectl",
+  pyhton: "python",
+  pythno: "python",
+  nmp: "npm",
+  yanr: "yarn",
+  vmi: "vim",
+  ivm: "vim",
+  nvmi: "nvim",
+  cd_: "cd",
+  "cd..": "cd ..",
+  shh: "ssh",
+  tial: "tail",
+  taill: "tail",
+  cta: "cat",
+  act: "cat",
+  hsitory: "history",
+  histroy: "history"
+};
+var KNOWN_COMMANDS = /* @__PURE__ */ new Set([
+  "ls",
+  "cd",
+  "cp",
+  "mv",
+  "rm",
+  "ln",
+  "cat",
+  "cal",
+  "sh",
+  "ssh",
+  "sed",
+  "set",
+  "see",
+  "pwd",
+  "ps",
+  "du",
+  "df",
+  "dd",
+  "id",
+  "bg",
+  "fg",
+  "jobs",
+  "top",
+  "htop",
+  "btop",
+  "git",
+  "gh",
+  "go",
+  "gd",
+  "gs",
+  "g",
+  "vi",
+  "vim",
+  "nvim",
+  "vd",
+  "ed",
+  "emacs",
+  "man",
+  "make",
+  "make",
+  "node",
+  "npm",
+  "npx",
+  "nvm",
+  "pnpm",
+  "yarn",
+  "bun",
+  "deno",
+  "python",
+  "python3",
+  "pip",
+  "pip3",
+  "ruby",
+  "gem",
+  "cargo",
+  "rustc",
+  "java",
+  "javac",
+  "docker",
+  "podman",
+  "kubectl",
+  "helm",
+  "k9s",
+  "k",
+  "terraform",
+  "ansible",
+  "curl",
+  "wget",
+  "http",
+  "jq",
+  "yq",
+  "fzf",
+  "rg",
+  "ag",
+  "fd",
+  "find",
+  "grep",
+  "egrep",
+  "awk",
+  "cut",
+  "sort",
+  "uniq",
+  "wc",
+  "xargs",
+  "tee",
+  "tr",
+  "head",
+  "tail",
+  "less",
+  "more",
+  "tar",
+  "zip",
+  "unzip",
+  "gzip",
+  "gunzip",
+  "xz",
+  "zstd",
+  "7z",
+  "kill",
+  "killall",
+  "pkill",
+  "pgrep",
+  "watch",
+  "cron",
+  "crontab",
+  "at",
+  "echo",
+  "printf",
+  "test",
+  "true",
+  "false",
+  "env",
+  "export",
+  "alias",
+  "source",
+  "which",
+  "whoami",
+  "who",
+  "w",
+  "uname",
+  "uptime",
+  "date",
+  "cal",
+  "clear",
+  "exit",
+  "history",
+  "chmod",
+  "chown",
+  "chgrp",
+  "touch",
+  "mkdir",
+  "rmdir",
+  "stat",
+  "file",
+  "diff",
+  "patch",
+  "mount",
+  "umount",
+  "sync",
+  "free",
+  "vmstat",
+  "iostat",
+  "lsof",
+  "dig",
+  "host",
+  "ping",
+  "traceroute",
+  "nc",
+  "nmap",
+  "rsync",
+  "scp",
+  "sftp",
+  "ftp",
+  "telnet",
+  "tmux",
+  "screen",
+  "brew",
+  "apt",
+  "dnf",
+  "yum",
+  "pacman",
+  "snap",
+  "flatpak",
+  "nix",
+  "code",
+  "subl",
+  "open",
+  "pbcopy",
+  "pbpaste",
+  "say",
+  "osascript",
+  "defaults",
+  "launchctl",
+  "systemctl",
+  "service",
+  "journalctl",
+  "dmesg",
+  "sudo",
+  "doas",
+  "su",
+  "passwd",
+  "useradd",
+  "usermod",
+  "ts",
+  "tsc",
+  "tsx",
+  "vite",
+  "next",
+  "nuxt",
+  "astro",
+  "eslint",
+  "prettier",
+  "jest",
+  "vitest",
+  "mysql",
+  "psql",
+  "sqlite3",
+  "redis-cli",
+  "mongo",
+  "mongosh"
+]);
+function editDistance(a, b, max = 2) {
+  if (a === b) return 0;
+  const la = a.length;
+  const lb = b.length;
+  if (Math.abs(la - lb) > max) return max + 1;
+  let prev2 = null;
+  let prev = new Array(lb + 1);
+  let cur = new Array(lb + 1);
+  for (let j = 0; j <= lb; j++) prev[j] = j;
+  for (let i = 1; i <= la; i++) {
+    cur[0] = i;
+    let rowMin = i;
+    for (let j = 1; j <= lb; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      let d = Math.min(prev[j] + 1, cur[j - 1] + 1, prev[j - 1] + cost);
+      if (prev2 && i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
+        d = Math.min(d, prev2[j - 2] + 1);
+      }
+      cur[j] = d;
+      if (d < rowMin) rowMin = d;
+    }
+    if (rowMin > max) return max + 1;
+    prev2 = prev.slice();
+    [prev, cur] = [cur, prev];
+  }
+  return prev[lb];
+}
+function computeTypoStats(entries) {
+  const baseCounts = /* @__PURE__ */ new Map();
+  for (const e of entries) {
+    for (const s of e.segments) baseCounts.set(s.base, (baseCounts.get(s.base) ?? 0) + 1);
+  }
+  const hits = /* @__PURE__ */ new Map();
+  for (const [typo, target] of Object.entries(KNOWN_TYPOS)) {
+    const count = baseCounts.get(typo) ?? 0;
+    if (count > 0) hits.set(typo, { typo, target, count });
+  }
+  const top = [...baseCounts.entries()].filter(([b]) => !KNOWN_TYPOS[b]).sort((a, b) => b[1] - a[1]).slice(0, 20);
+  for (const [base, count] of baseCounts) {
+    if (hits.has(base)) continue;
+    if (KNOWN_COMMANDS.has(base)) continue;
+    if (base.length < 2) continue;
+    for (const [target, targetCount] of top) {
+      if (target === base) continue;
+      if (targetCount < 50) continue;
+      if (count > Math.max(3, targetCount * 0.01)) continue;
+      if (!KNOWN_COMMANDS.has(target) && targetCount < 200) continue;
+      if (editDistance(base, target, 1) === 1) {
+        hits.set(base, { typo: base, target, count });
+        break;
+      }
+    }
+  }
+  const list = [...hits.values()].sort((a, b) => b.count - a.count || a.typo.localeCompare(b.typo));
+  const total = list.reduce((s, h) => s + h.count, 0);
+  const wastedKeystrokes = list.reduce((s, h) => s + h.typo.length * h.count, 0);
+  return { hits: list, total, wastedKeystrokes };
+}
+
+// src/stats/aliases.ts
+var SKIP_BASES = /* @__PURE__ */ new Set(["cd", "ls", "alias", "export", "source", "history", "man", "echo"]);
+function suggestAliasName(command, taken) {
+  const words = command.split(/\s+/).filter((w) => w.length > 0 && !w.startsWith("-") && !/^[A-Z_]+=/.test(w) && !/^\d/.test(w)).slice(0, 4);
+  let name = words.map((w) => w[0].toLowerCase()).join("");
+  if (name.length === 0) name = command.slice(0, 2).toLowerCase();
+  if (!taken.has(name) && name.length >= 2) {
+    taken.add(name);
+    return name;
+  }
+  const second = words[1] ?? words[0] ?? "x";
+  for (let i = 1; i < second.length; i++) {
+    const cand = name + second[i];
+    if (!taken.has(cand)) {
+      taken.add(cand);
+      return cand;
+    }
+  }
+  for (let n = 2; n < 100; n++) {
+    const cand = name + n;
+    if (!taken.has(cand)) {
+      taken.add(cand);
+      return cand;
+    }
+  }
+  taken.add(name);
+  return name;
+}
+function computeAliasStats(entries, opts) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const e of entries) {
+    const line = e.raw.trim().replace(/\s+/g, " ");
+    if (line.length < opts.minLength) continue;
+    if (line.includes("\n")) continue;
+    const first = e.segments[0];
+    if (!first) continue;
+    if (SKIP_BASES.has(first.base)) continue;
+    counts.set(line, (counts.get(line) ?? 0) + 1);
+  }
+  const candidates = [...counts.entries()].filter(([, c]) => c >= opts.minCount).map(([command, count]) => ({ command, count })).sort((a, b) => b.count * b.command.length - a.count * a.command.length || a.command.localeCompare(b.command));
+  const taken = /* @__PURE__ */ new Set();
+  const suggestions = [];
+  for (const { command, count } of candidates) {
+    const alias = suggestAliasName(command, taken);
+    const saves = Math.max(0, (command.length - alias.length) * count);
+    if (saves === 0) continue;
+    suggestions.push({ command, alias, count, saves });
+  }
+  suggestions.sort((a, b) => b.saves - a.saves || a.command.localeCompare(b.command));
+  const sliced = suggestions.slice(0, opts.top);
+  const totalSavable = suggestions.reduce((s, x) => s + x.saves, 0);
+  return { suggestions: sliced, totalSavable };
+}
+
+// src/stats/secrets.ts
+var DETECTORS = [
+  { kind: "aws-access-key", re: /\b(AKIA|ASIA)[0-9A-Z]{16}\b/ },
+  { kind: "github-token", re: /\b(gh[pousr]_[A-Za-z0-9]{20,}|github_pat_[A-Za-z0-9_]{20,})\b/ },
+  { kind: "slack-token", re: /\bxox[abprs]-[A-Za-z0-9-]{10,}\b/ },
+  { kind: "stripe-key", re: /\b[sr]k_live_[A-Za-z0-9]{16,}\b/ },
+  { kind: "npm-token", re: /\bnpm_[A-Za-z0-9]{30,}\b/ },
+  { kind: "openai-key", re: /\bsk-[A-Za-z0-9_-]{20,}\b/ },
+  { kind: "jwt", re: /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{5,}\b/ },
+  { kind: "bearer-header", re: /\bAuthorization:\s*Bearer\s+[A-Za-z0-9._~+/-]{16,}=*/i },
+  // mysql-style -pSECRET / --password=SECRET / --password SECRET / --token=SECRET
+  { kind: "password-flag", re: /(?:^|\s)(?:-p[^\s'"=-][^\s'"]*|--(?:password|passwd|token|api-key|apikey)[= ][^\s'"]{4,})/ },
+  // PASSWORD=... / TOKEN=... / SECRET=... / API_KEY=... env assignments with a real-looking value
+  { kind: "password-env", re: /\b[A-Z0-9_]*(?:PASSWORD|PASSWD|SECRET|TOKEN|API_KEY|APIKEY)=[^\s'"$]{6,}/ }
+];
+function mask(value) {
+  const trimmed = value.trim();
+  const keep = Math.min(6, Math.max(4, Math.floor(trimmed.length / 6)));
+  return `${trimmed.slice(0, keep)}\u2026`;
+}
+function computeSecretHits(entries) {
+  const hits = [];
+  for (let i = 0; i < entries.length; i++) {
+    const raw = entries[i].raw;
+    for (const d of DETECTORS) {
+      const m = raw.match(d.re);
+      if (m) {
+        hits.push({ kind: d.kind, masked: mask(m[0]), entryIndex: i + 1 });
+        break;
+      }
+    }
+  }
+  return hits;
+}
+var SECRET_KIND_LABELS = {
+  "aws-access-key": "AWS access key",
+  "github-token": "GitHub token",
+  "slack-token": "Slack token",
+  "stripe-key": "Stripe live key",
+  "npm-token": "npm token",
+  "openai-key": "API key (sk-\u2026)",
+  jwt: "JWT",
+  "bearer-header": "Bearer token in a header",
+  "password-flag": "password passed as a flag",
+  "password-env": "secret in an inline env var"
+};
+
+// src/stats/persona.ts
+var PERSONAS = {
+  nightOwl: {
+    id: "night-owl",
+    title: "The Night Owl",
+    emoji: "\u{1F989}",
+    blurb: "Your terminal sees more moonlight than sunlight."
+  },
+  pipeWizard: {
+    id: "pipe-wizard",
+    title: "The Pipe Wizard",
+    emoji: "\u{1F9D9}",
+    blurb: "Why run one command when five can hold hands?"
+  },
+  sudoSummoner: {
+    id: "sudo-summoner",
+    title: "The Sudo Summoner",
+    emoji: "\u{1F531}",
+    blurb: "Asking for forgiveness, never for permission."
+  },
+  gitGremlin: {
+    id: "git-gremlin",
+    title: "The Git Gremlin",
+    emoji: "\u{1F419}",
+    blurb: "Your shell is basically a git client with extra steps."
+  },
+  containerCaptain: {
+    id: "container-captain",
+    title: "The Container Captain",
+    emoji: "\u{1F433}",
+    blurb: "Everything's fine \u2014 it works in the container."
+  },
+  vimMonk: {
+    id: "vim-monk",
+    title: "The Vim Monk",
+    emoji: "\u{1F9D8}",
+    blurb: "You live inside the editor. The shell is just the hallway."
+  },
+  typoArtist: {
+    id: "typo-artist",
+    title: "The Typo Artist",
+    emoji: "\u{1F3A8}",
+    blurb: "gti, sl, dokcer \u2014 close enough, every time."
+  },
+  navigator: {
+    id: "navigator",
+    title: "The Navigator",
+    emoji: "\u{1F9ED}",
+    blurb: "cd, ls, cd, ls \u2014 forever exploring, never lost (mostly)."
+  },
+  polyglot: {
+    id: "polyglot",
+    title: "The Polyglot",
+    emoji: "\u{1F310}",
+    blurb: "Is there a CLI you haven't tried?"
+  },
+  steadyOperator: {
+    id: "steady-operator",
+    title: "The Steady Operator",
+    emoji: "\u{1F39B}\uFE0F",
+    blurb: "Calm, consistent, quietly unstoppable."
+  }
+};
+function share(top, totalSegments, names) {
+  if (totalSegments === 0) return 0;
+  const set = new Set(names);
+  let n = 0;
+  for (const c of top) if (set.has(c.name)) n += c.count;
+  return n / totalSegments * 100;
+}
+function derivePersona(input, allBases) {
+  const { totals, time, typos } = input;
+  const entries = totals.entries || 1;
+  const gitShare = share(allBases, totals.segments, ["git"]);
+  const containerShare = share(allBases, totals.segments, ["docker", "podman", "kubectl", "helm", "docker-compose", "k9s"]);
+  const vimShare = share(allBases, totals.segments, ["vim", "nvim", "vi"]);
+  const navShare = share(allBases, totals.segments, ["cd", "ls", "ll", "la", "z", "pwd"]);
+  if (time.hasTimestamps && time.nightOwlPct >= 35) return PERSONAS.nightOwl;
+  if (typos.total / entries >= 0.015 && typos.total >= 20) return PERSONAS.typoArtist;
+  if (totals.pipePct >= 12) return PERSONAS.pipeWizard;
+  if (totals.sudoPct >= 8) return PERSONAS.sudoSummoner;
+  if (gitShare >= 25) return PERSONAS.gitGremlin;
+  if (containerShare >= 15) return PERSONAS.containerCaptain;
+  if (vimShare >= 10) return PERSONAS.vimMonk;
+  if (navShare >= 30) return PERSONAS.navigator;
+  if (totals.uniqueBases >= 300) return PERSONAS.polyglot;
+  return PERSONAS.steadyOperator;
+}
+
+// src/analyze.ts
+function topOf(map, n) {
+  return [...map.entries()].map(([name, count]) => ({ name, count })).sort((a, b) => b.count - a.count || a.name.localeCompare(b.name)).slice(0, n);
+}
+function analyze(rawEntries, config, ctx) {
+  const ignore = new Set(config.ignoreCommands.map((c) => c.toLowerCase()));
+  const entries = [];
+  for (const e of rawEntries) {
+    const p = tokenizeEntry(e);
+    if (p.segments.length === 0) continue;
+    if (p.segments.every((s) => ignore.has(s.base))) continue;
+    entries.push(p);
+  }
+  const baseCounts = /* @__PURE__ */ new Map();
+  const subCounts = /* @__PURE__ */ new Map();
+  const uniqueLines = /* @__PURE__ */ new Set();
+  let segments = 0;
+  let piped = 0;
+  let sudoed = 0;
+  let totalLen = 0;
+  for (const e of entries) {
+    uniqueLines.add(e.raw.trim());
+    totalLen += e.raw.length;
+    if (e.pipes > 0) piped++;
+    let sawSudo = false;
+    for (const s of e.segments) {
+      segments++;
+      if (ignore.has(s.base)) continue;
+      baseCounts.set(s.base, (baseCounts.get(s.base) ?? 0) + 1);
+      if (s.withSub !== s.base) subCounts.set(s.withSub, (subCounts.get(s.withSub) ?? 0) + 1);
+      if (s.sudo) sawSudo = true;
+    }
+    if (sawSudo) sudoed++;
+  }
+  const n = entries.length || 1;
+  const totals = {
+    entries: entries.length,
+    segments,
+    uniqueCommands: uniqueLines.size,
+    uniqueBases: baseCounts.size,
+    pipePct: piped / n * 100,
+    sudoPct: sudoed / n * 100,
+    avgLength: totalLen / n
+  };
+  const time = computeTimeStats(entries, ctx.tzOffsetMin);
+  const typos = computeTypoStats(entries);
+  const aliases = computeAliasStats(entries, {
+    minCount: config.aliasMinCount,
+    minLength: config.aliasMinLength,
+    top: config.top
+  });
+  const secrets = config.secretScan ? computeSecretHits(entries) : [];
+  const topCommands = topOf(baseCounts, config.top);
+  const topSubcommands = topOf(subCounts, config.top);
+  const allBases = topOf(baseCounts, baseCounts.size);
+  const persona = derivePersona({ totals, time, typos, topCommands }, allBases);
+  return {
+    source: { label: ctx.sourceLabel, format: ctx.format },
+    totals,
+    time,
+    topCommands,
+    topSubcommands,
+    typos,
+    aliases,
+    secrets,
+    persona
+  };
+}
+
+// src/format.ts
+function num(n) {
+  const neg = n < 0;
+  const s = Math.abs(Math.round(n)).toString();
+  let out = "";
+  for (let i = 0; i < s.length; i++) {
+    if (i > 0 && (s.length - i) % 3 === 0) out += ",";
+    out += s[i];
+  }
+  return neg ? `-${out}` : out;
+}
+function pct(n) {
+  return `${Math.round(n)}%`;
+}
+function bar(value, max, width, full = "\u2588", empty = " ") {
+  if (max <= 0 || width <= 0) return empty.repeat(Math.max(0, width));
+  const filled = Math.round(value / max * width);
+  const clamped = Math.max(value > 0 ? 1 : 0, Math.min(width, filled));
+  return full.repeat(clamped) + empty.repeat(width - clamped);
+}
+function ellipsize(s, max) {
+  if (s.length <= max) return s;
+  if (max <= 1) return s.slice(0, max);
+  return s.slice(0, max - 1) + "\u2026";
+}
+function xmlEscape(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+
+// src/card.ts
+var THEMES = {
+  tokyonight: {
+    bgTop: "#1a1b26",
+    bgBottom: "#24283b",
+    text: "#c0caf5",
+    dim: "#565f89",
+    accent: "#7aa2f7",
+    accent2: "#bb9af7",
+    card: "#1f2335"
+  },
+  dark: {
+    bgTop: "#0d1117",
+    bgBottom: "#161b22",
+    text: "#e6edf3",
+    dim: "#8b949e",
+    accent: "#58a6ff",
+    accent2: "#3fb950",
+    card: "#161b22"
+  },
+  light: {
+    bgTop: "#ffffff",
+    bgBottom: "#eef2f7",
+    text: "#111827",
+    dim: "#6b7280",
+    accent: "#2563eb",
+    accent2: "#7c3aed",
+    card: "#f3f4f6"
+  },
+  candy: {
+    bgTop: "#ff6ec4",
+    bgBottom: "#7873f5",
+    text: "#ffffff",
+    dim: "#ffe3f4",
+    accent: "#ffffff",
+    accent2: "#fff27a",
+    card: "rgba(255,255,255,0.14)"
+  }
+};
+var FONT = "-apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, system-ui, sans-serif";
+var MONO = "'SF Mono', 'JetBrains Mono', 'Fira Code', ui-monospace, Menlo, Consolas, monospace";
+var W = 1080;
+var H = 1350;
+var PAD = 80;
+function text(x, y, content, o) {
+  return `<text x="${x}" y="${y}" font-family="${o.family ?? FONT}" font-size="${o.size}" font-weight="${o.weight ?? 400}" fill="${o.fill}" text-anchor="${o.anchor ?? "start"}">${xmlEscape(content)}</text>`;
+}
+function rect(x, y, w, h, rx, fill) {
+  return `<rect x="${x}" y="${y}" width="${w}" height="${h}" rx="${rx}" fill="${fill}"/>`;
+}
+function statCard(x, y, w, h, p, value, label) {
+  return rect(x, y, w, h, 22, p.card) + text(x + w / 2, y + 74, value, { size: 50, weight: 800, fill: p.text, anchor: "middle", family: MONO }) + text(x + w / 2, y + 116, label, { size: 23, weight: 500, fill: p.dim, anchor: "middle" });
+}
+function renderCard(report, theme = "tokyonight") {
+  const p = THEMES[theme] ?? THEMES.tokyonight;
+  const t = report.totals;
+  const parts = [];
+  parts.push(`<defs>
+    <linearGradient id="bg" x1="0" y1="0" x2="0" y2="1">
+      <stop offset="0%" stop-color="${p.bgTop}"/>
+      <stop offset="100%" stop-color="${p.bgBottom}"/>
+    </linearGradient>
+    <radialGradient id="glow" cx="80%" cy="8%" r="60%">
+      <stop offset="0%" stop-color="${p.accent}" stop-opacity="0.22"/>
+      <stop offset="100%" stop-color="${p.accent}" stop-opacity="0"/>
+    </radialGradient>
+  </defs>`);
+  parts.push(`<rect width="${W}" height="${H}" fill="url(#bg)"/>`);
+  parts.push(`<rect width="${W}" height="${H}" fill="url(#glow)"/>`);
+  parts.push(text(PAD, 92, "\u276F shellrecap", { size: 30, weight: 800, fill: p.text, family: MONO }));
+  parts.push(text(W - PAD, 92, "\u{1F512} nothing uploaded", { size: 24, weight: 500, fill: p.dim, anchor: "end" }));
+  const range = report.time.hasTimestamps && report.time.firstDate ? `${report.time.firstDate} \u2192 ${report.time.lastDate}` : "your shell history";
+  parts.push(text(PAD, 182, range, { size: 40, weight: 700, fill: p.text }));
+  parts.push(text(PAD, 326, report.persona.emoji, { size: 118, fill: p.text }));
+  parts.push(text(PAD + 168, 296, report.persona.title, { size: 58, weight: 800, fill: p.accent }));
+  parts.push(text(PAD + 168, 344, ellipsize(report.persona.blurb, 58), { size: 24, weight: 500, fill: p.dim }));
+  parts.push(text(PAD, 466, num(t.entries), { size: 104, weight: 800, fill: p.text, family: MONO }));
+  parts.push(text(PAD + 8, 514, "commands typed", { size: 29, weight: 600, fill: p.dim }));
+  const wasted = report.typos.wastedKeystrokes;
+  parts.push(
+    text(W - PAD, 436, num(t.uniqueBases), { size: 44, weight: 800, fill: p.accent, anchor: "end", family: MONO }) + text(W - PAD, 470, "different programs", { size: 22, weight: 500, fill: p.dim, anchor: "end" }) + text(W - PAD, 514, wasted > 0 ? `${num(wasted)} keys lost to typos` : `${num(t.uniqueCommands)} unique lines`, {
+      size: 22,
+      weight: 600,
+      fill: p.accent2,
+      anchor: "end"
+    })
+  );
+  const chartTop = 596;
+  parts.push(text(PAD, chartTop, "Top commands", { size: 28, weight: 700, fill: p.text }));
+  const tops = report.topCommands.slice(0, 5);
+  const maxCount = tops[0]?.count ?? 1;
+  const rowH = 56;
+  const barMax = W - PAD * 2 - 320;
+  tops.forEach((c, i) => {
+    const y = chartTop + 46 + i * rowH;
+    const bw = Math.max(8, Math.round(c.count / maxCount * barMax));
+    parts.push(text(PAD, y + 27, ellipsize(c.name, 13), { size: 26, weight: 700, fill: p.text, family: MONO }));
+    parts.push(`<rect x="${PAD + 220}" y="${y}" width="${bw}" height="36" rx="9" fill="${i === 0 ? p.accent2 : p.accent}" opacity="${i === 0 ? 1 : 0.85 - i * 0.12}"/>`);
+    parts.push(text(PAD + 232 + bw, y + 27, num(c.count), { size: 24, weight: 600, fill: p.dim, family: MONO }));
+  });
+  const gridTop = chartTop + 46 + 5 * rowH + 40;
+  const gap = 24;
+  const cw = (W - PAD * 2 - gap) / 2;
+  const ch = 140;
+  const peak = report.time.hasTimestamps ? hourLabel(report.time.peakHour) : "\u2014";
+  const day = report.time.hasTimestamps ? WEEKDAY_SHORT[report.time.peakWeekday] ?? "\u2014" : "\u2014";
+  parts.push(statCard(PAD, gridTop, cw, ch, p, peak, "peak hour"));
+  parts.push(statCard(PAD + cw + gap, gridTop, cw, ch, p, day, "favorite day"));
+  parts.push(statCard(PAD, gridTop + ch + gap, cw, ch, p, `${Math.round(t.sudoPct)}%`, "sudo rate"));
+  parts.push(
+    statCard(
+      PAD + cw + gap,
+      gridTop + ch + gap,
+      cw,
+      ch,
+      p,
+      report.aliases.totalSavable > 0 ? num(report.aliases.totalSavable) : num(t.uniqueCommands),
+      report.aliases.totalSavable > 0 ? "keystrokes an alias would save" : "unique command lines"
+    )
+  );
+  parts.push(`<line x1="${PAD}" y1="${H - 64}" x2="${W - PAD}" y2="${H - 64}" stroke="${p.dim}" stroke-opacity="0.3" stroke-width="1"/>`);
+  parts.push(text(PAD, H - 32, "what does your terminal say about you?", { size: 24, weight: 500, fill: p.dim }));
+  parts.push(text(W - PAD, H - 32, "github.com/didrod205/shellrecap", { size: 24, weight: 500, fill: p.dim, anchor: "end" }));
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${W}" height="${H}" viewBox="0 0 ${W} ${H}" role="img" aria-label="shellrecap card">${parts.join("")}</svg>`;
+}
+
+// src/report/json.ts
+function toJSON(report) {
+  return JSON.stringify(report, null, 2);
+}
+
+// src/report/markdown.ts
+function toMarkdown(r) {
+  const L = [];
+  const t = r.totals;
+  L.push(`# \u276F shellrecap \u2014 ${r.source.label}`);
+  L.push("");
+  L.push(`> **${r.persona.emoji} ${r.persona.title}** \u2014 ${r.persona.blurb}`);
+  L.push("");
+  L.push(
+    `**${num(t.entries)} commands** \xB7 ${num(t.uniqueCommands)} unique lines \xB7 ${num(t.uniqueBases)} different programs` + (r.time.hasTimestamps && r.time.firstDate ? ` \xB7 ${r.time.firstDate} \u2192 ${r.time.lastDate}` : "")
+  );
+  L.push("");
+  if (r.topCommands.length > 0) {
+    L.push("## Top commands");
+    L.push("");
+    L.push("| Command | Count | |");
+    L.push("| ------- | ----: | --- |");
+    const max = r.topCommands[0].count;
+    for (const c of r.topCommands) {
+      L.push(`| \`${c.name}\` | ${num(c.count)} | \`${bar(c.count, max, 18, "\u2588", "\xB7")}\` |`);
+    }
+    L.push("");
+  }
+  if (r.topSubcommands.length > 0) {
+    L.push("**Favorite moves:** " + r.topSubcommands.slice(0, 6).map((s) => `\`${s.name}\` \xD7${num(s.count)}`).join(" \xB7 "));
+    L.push("");
+  }
+  if (r.time.hasTimestamps) {
+    L.push("## When you type");
+    L.push("");
+    L.push(`Peak hour **${hourLabel(r.time.peakHour)}**, favorite day **${WEEKDAY_NAMES[r.time.peakWeekday]}**, night-owl share ${pct(r.time.nightOwlPct)}, weekends ${pct(r.time.weekendPct)}.`);
+    if (r.time.busiestDay) {
+      L.push(`Busiest day: **${r.time.busiestDay.date}** (${num(r.time.busiestDay.commands)} commands).`);
+    }
+    L.push("");
+  }
+  if (r.typos.hits.length > 0) {
+    L.push("## Typos");
+    L.push("");
+    L.push(r.typos.hits.slice(0, 8).map((h) => `\`${h.typo}\`\u2192\`${h.target}\` \xD7${num(h.count)}`).join(" \xB7 "));
+    L.push("");
+    L.push(`*${num(r.typos.total)} mistyped commands, ${num(r.typos.wastedKeystrokes)} wasted keystrokes.*`);
+    L.push("");
+  }
+  if (r.aliases.suggestions.length > 0) {
+    L.push("## Aliases you're owed");
+    L.push("");
+    L.push("```sh");
+    for (const a of r.aliases.suggestions.slice(0, 5)) {
+      L.push(`alias ${a.alias}='${a.command}'  # typed ${num(a.count)}\xD7 \u2014 saves ${num(a.saves)} keystrokes`);
+    }
+    L.push("```");
+    L.push("");
+    L.push(`*Total savable: **${num(r.aliases.totalSavable)} keystrokes**.*`);
+    L.push("");
+  }
+  if (r.secrets.length > 0) {
+    L.push("## \u26A0 Possible secrets in your history");
+    L.push("");
+    for (const s of r.secrets.slice(0, 10)) {
+      L.push(`- \`${s.masked}\` \u2014 ${SECRET_KIND_LABELS[s.kind]} (entry #${num(s.entryIndex)})`);
+    }
+    L.push("");
+    L.push("*Values are masked. Edit your history file to remove these lines.*");
+    L.push("");
+  }
+  L.push("---");
+  L.push("");
+  L.push(`<sub>sudo ${pct(t.sudoPct)} \xB7 pipes ${pct(t.pipePct)} \xB7 generated locally by [shellrecap](https://github.com/didrod205/shellrecap) \u2014 nothing was uploaded.</sub>`);
+  return L.join("\n") + "\n";
+}
+
+// src/config.ts
+var DEFAULT_CONFIG = {
+  theme: "tokyonight",
+  top: 8,
+  aliasMinCount: 10,
+  aliasMinLength: 12,
+  ignoreCommands: [],
+  secretScan: true
+};
+var CONFIG_FILENAMES = ["shellrecap.config.json", ".shellrecaprc.json", ".shellrecaprc"];
+var THEMES2 = ["tokyonight", "dark", "light", "candy"];
+function asStringArray(v) {
+  if (!Array.isArray(v)) return void 0;
+  return v.filter((x) => typeof x === "string");
+}
+function asClampedInt(v, lo, hi) {
+  if (typeof v !== "number" || !Number.isFinite(v)) return void 0;
+  return Math.max(lo, Math.min(hi, Math.floor(v)));
+}
+function parseConfig(raw) {
+  if (!raw || typeof raw !== "object") return {};
+  const o = raw;
+  const out = {};
+  if (typeof o["theme"] === "string" && THEMES2.includes(o["theme"])) {
+    out.theme = o["theme"];
+  }
+  const top = asClampedInt(o["top"], 1, 50);
+  if (top !== void 0) out.top = top;
+  const minCount = asClampedInt(o["aliasMinCount"], 2, 1e4);
+  if (minCount !== void 0) out.aliasMinCount = minCount;
+  const minLength = asClampedInt(o["aliasMinLength"], 4, 500);
+  if (minLength !== void 0) out.aliasMinLength = minLength;
+  const ignore = asStringArray(o["ignoreCommands"]);
+  if (ignore) out.ignoreCommands = ignore;
+  if (typeof o["secretScan"] === "boolean") out.secretScan = o["secretScan"];
+  return out;
+}
+function mergeConfig(base, override) {
+  return {
+    theme: override.theme ?? base.theme,
+    top: override.top ?? base.top,
+    aliasMinCount: override.aliasMinCount ?? base.aliasMinCount,
+    aliasMinLength: override.aliasMinLength ?? base.aliasMinLength,
+    ignoreCommands: override.ignoreCommands ?? base.ignoreCommands,
+    secretScan: override.secretScan ?? base.secretScan
+  };
+}
+function isValidTheme(t) {
+  return THEMES2.includes(t);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CONFIG_FILENAMES,
+  DEFAULT_CONFIG,
+  KNOWN_COMMANDS,
+  KNOWN_TYPOS,
+  PERSONAS,
+  SECRET_KIND_LABELS,
+  WEEKDAY_NAMES,
+  WEEKDAY_SHORT,
+  analyze,
+  computeAliasStats,
+  computeSecretHits,
+  computeTimeStats,
+  computeTypoStats,
+  daysToYMD,
+  derivePersona,
+  detectFormat,
+  editDistance,
+  epochToDate,
+  epochToHour,
+  epochToWeekday,
+  hourLabel,
+  isValidTheme,
+  mask,
+  mergeConfig,
+  parseBash,
+  parseConfig,
+  parseFish,
+  parseHistory,
+  parsePlain,
+  parseZshExtended,
+  renderCard,
+  splitSegments,
+  suggestAliasName,
+  toJSON,
+  toMarkdown,
+  toSegment,
+  tokenizeEntry,
+  tokens
+});