shellrecap 0.1.0

package/dist/cli.js

@@ -0,0 +1,1590 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// 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")}`;
+}
+function hourLabel(h) {
+  const period = h < 12 ? "AM" : "PM";
+  const base = h % 12 === 0 ? 12 : h % 12;
+  return `${base} ${period}`;
+}
+var WEEKDAY_NAMES, WEEKDAY_SHORT;
+var init_date = __esm({
+  "src/date.ts"() {
+    "use strict";
+    WEEKDAY_NAMES = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+    WEEKDAY_SHORT = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+  }
+});
+
+// src/stats/secrets.ts
+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 DETECTORS, SECRET_KIND_LABELS;
+var init_secrets = __esm({
+  "src/stats/secrets.ts"() {
+    "use strict";
+    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,}/ }
+    ];
+    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/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;");
+}
+var init_format = __esm({
+  "src/format.ts"() {
+    "use strict";
+  }
+});
+
+// src/report/console.ts
+var console_exports = {};
+__export(console_exports, {
+  renderConsole: () => renderConsole
+});
+import pc from "picocolors";
+function sparkline(values, peakIndex) {
+  const max = Math.max(...values, 1);
+  let out = "";
+  for (let i = 0; i < values.length; i++) {
+    const v = values[i] ?? 0;
+    if (v === 0) {
+      out += pc.dim("\u2581");
+      continue;
+    }
+    const idx = Math.min(7, Math.max(0, Math.round(v / max * 7)));
+    out += i === peakIndex ? pc.magenta(SPARK[idx]) : pc.cyan(SPARK[idx]);
+  }
+  return out;
+}
+function renderConsole(r) {
+  const L = [];
+  const ind = "  ";
+  const t = r.totals;
+  L.push("");
+  L.push(`${ind}${pc.cyan("\u25CF")} ${pc.bold("shellrecap")}  ${pc.dim("\xB7")}  ${pc.bold(r.source.label)} ${pc.dim(`(${r.source.format})`)}`);
+  L.push(`${ind}${pc.dim("\u{1F512} 100% local \u2014 your history never leaves this machine")}`);
+  L.push("");
+  L.push(`${ind}${r.persona.emoji}  ${pc.bold(pc.magenta(r.persona.title))}`);
+  L.push(`${ind}   ${pc.dim(r.persona.blurb)}`);
+  L.push("");
+  L.push(
+    `${ind}${pc.bold(pc.cyan(num(t.entries)))} commands   ${pc.dim("\xB7")}   ${pc.bold(num(t.uniqueCommands))} unique   ${pc.dim("\xB7")}   ${pc.bold(num(t.uniqueBases))} different programs`
+  );
+  if (r.time.hasTimestamps && r.time.firstDate) {
+    L.push(`${ind}${pc.dim(`${r.time.firstDate} \u2192 ${r.time.lastDate}`)}`);
+  }
+  L.push("");
+  if (r.topCommands.length > 0) {
+    L.push(`${ind}${pc.bold("Top commands")}`);
+    const max = r.topCommands[0].count;
+    const nameW = Math.min(14, Math.max(...r.topCommands.map((c) => c.name.length)));
+    for (const c of r.topCommands) {
+      L.push(
+        `${ind}${pc.cyan(ellipsize(c.name, nameW).padEnd(nameW))} ${pc.cyan(bar(c.count, max, 22, "\u2588", " "))} ${pc.dim(num(c.count))}`
+      );
+    }
+    L.push("");
+  }
+  if (r.topSubcommands.length > 0) {
+    const subs = r.topSubcommands.slice(0, 5).map((s) => `${pc.bold(s.name)}${pc.dim("\xD7" + num(s.count))}`);
+    L.push(`${ind}${pc.bold("Favorite moves")}  ${subs.join(pc.dim(" \xB7 "))}`);
+    L.push("");
+  }
+  if (r.time.hasTimestamps) {
+    L.push(`${ind}${pc.bold("When you type")}  ${pc.dim(`(peak ${hourLabel(r.time.peakHour)} \xB7 ${WEEKDAY_NAMES[r.time.peakWeekday]})`)}`);
+    L.push(`${ind}${sparkline(r.time.byHour, r.time.peakHour)}`);
+    L.push(`${ind}${pc.dim("12a   3    6    9    12p   3    6    9   11")}`);
+    if (r.time.busiestDay) {
+      L.push(`${ind}${pc.dim(`busiest day: ${r.time.busiestDay.date} (${num(r.time.busiestDay.commands)} commands)`)}`);
+    }
+    L.push("");
+  }
+  if (r.typos.hits.length > 0) {
+    const shown = r.typos.hits.slice(0, 5).map((h) => `${pc.red(h.typo)}${pc.dim(`\u2192${h.target} \xD7${num(h.count)}`)}`);
+    L.push(`${ind}${pc.bold("Typos")}  ${shown.join(pc.dim(" \xB7 "))}`);
+    L.push(`${ind}${pc.dim(`${num(r.typos.total)} mistyped commands \xB7 ${num(r.typos.wastedKeystrokes)} wasted keystrokes`)}`);
+    L.push("");
+  }
+  if (r.aliases.suggestions.length > 0) {
+    L.push(`${ind}${pc.bold("Aliases you're owed")}  ${pc.dim(`(could have saved ${num(r.aliases.totalSavable)} keystrokes)`)}`);
+    for (const a of r.aliases.suggestions.slice(0, 3)) {
+      L.push(`${ind}${pc.green(`alias ${a.alias}='${a.command}'`)}`);
+      L.push(`${ind}${pc.dim(`  typed ${num(a.count)}\xD7 \u2014 saves ${num(a.saves)} keystrokes`)}`);
+    }
+    L.push("");
+  }
+  if (r.secrets.length > 0) {
+    L.push(`${ind}${pc.bold(pc.yellow(`\u26A0 ${num(r.secrets.length)} possible secret${r.secrets.length === 1 ? "" : "s"} in your history`))}`);
+    for (const s of r.secrets.slice(0, 5)) {
+      L.push(`${ind}${pc.yellow(`  ${s.masked}`)} ${pc.dim(`${SECRET_KIND_LABELS[s.kind]} \u2014 entry #${num(s.entryIndex)}`)}`);
+    }
+    if (r.secrets.length > 5) L.push(`${ind}${pc.dim(`  \u2026and ${num(r.secrets.length - 5)} more`)}`);
+    L.push(`${ind}${pc.dim("  values are masked; edit your history file to remove the lines")}`);
+    L.push("");
+  }
+  L.push(`${ind}${pc.dim(`sudo ${pct(t.sudoPct)} \xB7 pipes ${pct(t.pipePct)} \xB7 avg ${Math.round(t.avgLength)} chars \xB7 generated locally by shellrecap`)}`);
+  L.push("");
+  return L.join("\n");
+}
+var SPARK;
+var init_console = __esm({
+  "src/report/console.ts"() {
+    "use strict";
+    init_format();
+    init_date();
+    init_secrets();
+    SPARK = ["\u2581", "\u2582", "\u2583", "\u2584", "\u2585", "\u2586", "\u2587", "\u2588"];
+  }
+});
+
+// src/cli.ts
+import { cac } from "cac";
+import { readFileSync as readFileSync2, writeFileSync, mkdirSync, existsSync as existsSync3 } from "fs";
+import { resolve as resolve2, join as join3 } from "path";
+
+// 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/stats/time.ts
+init_date();
+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/analyze.ts
+init_secrets();
+
+// 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/load-config.ts
+import { readFileSync, existsSync } from "fs";
+import { resolve, dirname, join } from "path";
+import { homedir } from "os";
+
+// 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 THEMES = ["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" && THEMES.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 THEMES.includes(t);
+}
+
+// src/load-config.ts
+function findConfigFile(startDir, explicit) {
+  if (explicit) {
+    const abs = resolve(startDir, explicit);
+    return existsSync(abs) ? abs : null;
+  }
+  let dir = resolve(startDir);
+  while (true) {
+    for (const name of CONFIG_FILENAMES) {
+      const candidate2 = join(dir, name);
+      if (existsSync(candidate2)) return candidate2;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  for (const name of CONFIG_FILENAMES) {
+    const candidate2 = join(homedir(), name);
+    if (existsSync(candidate2)) return candidate2;
+  }
+  return null;
+}
+function loadConfig(startDir, explicit) {
+  const file = findConfigFile(startDir, explicit);
+  if (!file) {
+    if (explicit) throw new Error(`Config file not found: ${explicit}`);
+    return { config: DEFAULT_CONFIG, path: null };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(file, "utf8"));
+  } catch (err) {
+    throw new Error(`Could not parse config ${file}: ${err.message}`);
+  }
+  return { config: mergeConfig(DEFAULT_CONFIG, parseConfig(parsed)), path: file };
+}
+
+// src/locate.ts
+import { existsSync as existsSync2, statSync } from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+function candidate(path, hint) {
+  try {
+    if (!existsSync2(path)) return null;
+    const st = statSync(path);
+    if (!st.isFile() || st.size === 0) return null;
+    const home = homedir2();
+    const label = path.startsWith(home) ? "~" + path.slice(home.length) : path;
+    return { path, label, hint, mtimeMs: st.mtimeMs, size: st.size };
+  } catch {
+    return null;
+  }
+}
+function locateHistoryFiles(env = process.env) {
+  const home = homedir2();
+  const found = [];
+  const histfile = env["HISTFILE"];
+  if (histfile) {
+    const c = candidate(histfile);
+    if (c) found.push(c);
+  }
+  const defaults = [
+    [join2(home, ".zsh_history"), void 0],
+    [join2(home, ".histfile"), void 0],
+    // zsh on some distros
+    [join2(home, ".bash_history"), void 0],
+    [join2(home, ".local", "share", "fish", "fish_history"), "fish"],
+    [join2(home, ".config", "fish", "fish_history"), "fish"]
+  ];
+  for (const [p, hint] of defaults) {
+    if (found.some((f) => f.path === p)) continue;
+    const c = candidate(p, hint);
+    if (c) found.push(c);
+  }
+  return found.sort((a, b) => b.mtimeMs - a.mtimeMs);
+}
+
+// src/card.ts
+init_format();
+init_date();
+var THEMES2 = {
+  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 = THEMES2[theme] ?? THEMES2.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
+init_format();
+init_date();
+init_secrets();
+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/cli.ts
+var VERSION = "0.1.0";
+function fail(message) {
+  process.stderr.write(`
+shellrecap: ${message}
+
+`);
+  process.exit(2);
+}
+var SHELL_TO_FORMAT = {
+  zsh: "zsh-extended",
+  bash: "bash",
+  fish: "fish",
+  plain: "plain"
+};
+async function runRecap(fileArg, flags, mode) {
+  let loaded;
+  try {
+    loaded = loadConfig(process.cwd(), flags.config);
+  } catch (err) {
+    fail(err.message);
+  }
+  const config = { ...loaded.config };
+  if (flags.theme) {
+    if (!isValidTheme(flags.theme)) fail(`Unknown theme "${flags.theme}". Try: tokyonight, dark, light, candy`);
+    config.theme = flags.theme;
+  }
+  if (flags.top !== void 0) config.top = Math.max(1, Math.min(50, Math.floor(flags.top)));
+  if (flags.noSecrets) config.secretScan = false;
+  let forcedFormat;
+  if (flags.shell) {
+    forcedFormat = SHELL_TO_FORMAT[flags.shell.toLowerCase()];
+    if (!forcedFormat) fail(`Unknown --shell "${flags.shell}". Try: zsh, bash, fish, plain`);
+  }
+  let raw;
+  let label;
+  if (flags.stdin) {
+    try {
+      raw = readFileSync2(0, "utf8");
+    } catch {
+      fail("Could not read history from stdin.");
+    }
+    label = "stdin";
+  } else if (fileArg) {
+    const abs = resolve2(fileArg);
+    if (!existsSync3(abs)) fail(`File not found: ${abs}`);
+    raw = readFileSync2(abs, "utf8");
+    label = fileArg;
+  } else {
+    const candidates = locateHistoryFiles();
+    if (candidates.length === 0) {
+      fail(
+        "No shell history file found.\nLooked for ~/.zsh_history, ~/.bash_history, ~/.histfile, and the fish history.\nPoint me at one: shellrecap scan <file>, or pipe with --stdin."
+      );
+    }
+    const chosen = candidates[0];
+    raw = readFileSync2(chosen.path, "utf8");
+    label = chosen.label;
+    if (chosen.hint && !forcedFormat) forcedFormat = chosen.hint;
+    if (candidates.length > 1 && !flags.quiet) {
+      const others = candidates.slice(1).map((c) => c.label).join(", ");
+      process.stderr.write(`  (using ${chosen.label} \u2014 most recently written; also found: ${others})
+`);
+    }
+  }
+  const { entries, format } = parseHistory(raw, forcedFormat);
+  if (entries.length === 0) {
+    fail(`No commands found in ${label}. Is this a shell history file?`);
+  }
+  const tzOffsetMin = flags.tz !== void 0 ? Math.max(-840, Math.min(840, Math.floor(flags.tz))) : -(/* @__PURE__ */ new Date()).getTimezoneOffset();
+  const ctx = { sourceLabel: label, format, tzOffsetMin };
+  const report = analyze(entries, config, ctx);
+  if (mode === "scan" && !flags.quiet) {
+    if (flags.color === false) process.env["NO_COLOR"] = "1";
+    const { renderConsole: renderConsole2 } = await Promise.resolve().then(() => (init_console(), console_exports));
+    process.stdout.write(renderConsole2(report) + "\n");
+  }
+  const wantExplicit = flags.json !== void 0 || flags.md !== void 0 || flags.svg !== void 0;
+  const writeAll = mode === "report" && !wantExplicit;
+  const outDir = resolve2(process.cwd(), flags.out ?? ".");
+  const target = (flag, fallback) => {
+    if (flag === void 0) return null;
+    return typeof flag === "string" ? resolve2(process.cwd(), flag) : join3(outDir, fallback);
+  };
+  const svgPath = writeAll ? join3(outDir, "shellrecap.svg") : target(flags.svg, "shellrecap.svg");
+  const mdPath = writeAll ? join3(outDir, "shellrecap.md") : target(flags.md, "shellrecap.md");
+  const jsonPath = writeAll ? join3(outDir, "shellrecap.json") : target(flags.json, "shellrecap.json");
+  const written = [];
+  if (svgPath || mdPath || jsonPath) {
+    if (!existsSync3(outDir)) mkdirSync(outDir, { recursive: true });
+  }
+  if (svgPath) {
+    writeFileSync(svgPath, renderCard(report, config.theme), "utf8");
+    written.push(svgPath);
+  }
+  if (mdPath) {
+    writeFileSync(mdPath, toMarkdown(report), "utf8");
+    written.push(mdPath);
+  }
+  if (jsonPath) {
+    writeFileSync(jsonPath, toJSON(report) + "\n", "utf8");
+    written.push(jsonPath);
+  }
+  if (written.length > 0 && !flags.quiet) {
+    process.stdout.write(`
+  Wrote:
+${written.map((w) => `    ${w}`).join("\n")}
+`);
+    if (svgPath) {
+      process.stdout.write(
+        `
+  The card shows only command names and counts \u2014 never full command lines.
+  Open the .svg in a browser and screenshot it to share.
+
+`
+      );
+    }
+  }
+}
+function addScanOptions(cmd) {
+  return cmd.option("--shell <shell>", "Force the history format: zsh | bash | fish | plain").option("--stdin", "Read history from stdin instead of a file").option("--theme <theme>", "Card theme: tokyonight | dark | light | candy").option("--top <n>", "How many top commands / suggestions to show").option("--tz <minutes>", "UTC offset in minutes for time stats (default: this machine's)").option("--no-secrets", "Skip the secret scan").option("--config <file>", "Path to a shellrecap config file").option("--json [file]", "Also write a JSON report").option("--md [file]", "Also write a Markdown report").option("--svg [file]", "Also write the SVG card").option("--quiet", "Suppress the terminal card").option("--no-color", "Disable colored terminal output");
+}
+var cli = cac("shellrecap");
+addScanOptions(cli.command("[file]", "Show your shell recap in the terminal (default)")).action(
+  (file, flags) => runRecap(file, flags, "scan")
+);
+addScanOptions(cli.command("scan [file]", "Show your shell recap in the terminal")).action(
+  (file, flags) => runRecap(file, flags, "scan")
+);
+addScanOptions(cli.command("report [file]", "Write shareable recap files (svg + md + json)")).option("--out <dir>", "Output directory (default: current dir)").action((file, flags) => runRecap(file, flags, "report"));
+cli.command("init", "Write a shellrecap.config.json in the current directory").action(() => {
+  const file = resolve2(".", "shellrecap.config.json");
+  if (existsSync3(file)) fail(`${file} already exists.`);
+  writeFileSync(file, JSON.stringify(DEFAULT_CONFIG, null, 2) + "\n", "utf8");
+  process.stdout.write(`
+  Wrote ${file}
+  Tune aliasMinCount/aliasMinLength, ignoreCommands, theme.
+
+`);
+});
+cli.command("doctor", "List the history files shellrecap can see (paths only)").action(() => {
+  const found = locateHistoryFiles();
+  if (found.length === 0) {
+    process.stdout.write("\n  No history files found in the usual places.\n\n");
+    return;
+  }
+  process.stdout.write("\n  History files found (most recently written first):\n");
+  for (const f of found) {
+    process.stdout.write(`    ${f.label}  (${Math.round(f.size / 1024)} KB)
+`);
+  }
+  process.stdout.write("\n  shellrecap reads these locally and never uploads them.\n\n");
+});
+cli.help();
+cli.version(VERSION);
+try {
+  cli.parse();
+} catch (err) {
+  fail(err.message);
+}