@tertium/gith 0.0.0-stage → 0.1.0

package/bin/gith.js

@@ -0,0 +1,1777 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { exit } from "node:process";
+
+// src/components/args/args.constants.ts
+var SPECS = new Map([
+  ["branch", "auto"],
+  ["release", "auto"],
+  ["hotfix", "auto"],
+  ["limit", "value"],
+  ["message", "value"],
+  ["name", "value"],
+  ["commit", "value"],
+  ["file", "value"],
+  ["change", "value"],
+  ["regex", "switch"],
+  ["days", "value"],
+  ["patch", "switch"],
+  ["minor", "switch"],
+  ["major", "switch"],
+  ["remote", "switch"],
+  ["local", "switch"],
+  ["tags", "switch"],
+  ["commits", "switch"],
+  ["obsolete", "switch"],
+  ["graph", "switch"],
+  ["stashes", "switch"],
+  ["current-release", "switch"],
+  ["current-hotfix", "switch"],
+  ["pockets", "switch"],
+  ["detached", "switch"],
+  ["overall", "switch"],
+  ["current-year", "switch"],
+  ["current-month", "switch"],
+  ["current-week", "switch"],
+  ["last-year", "switch"],
+  ["last-month", "switch"],
+  ["last-week", "switch"]
+]);
+var ALIASES = new Map([
+  ["b", "branch"],
+  ["r", "release"],
+  ["h", "hotfix"],
+  ["l", "limit"],
+  ["m", "message"],
+  ["n", "name"]
+]);
+var SHORT = {
+  branch: "-b",
+  release: "-r",
+  hotfix: "-h"
+};
+
+// src/components/args/args.utils.ts
+function resolveFlag(token) {
+  const match = /^(--?)([a-z][a-z-]*)$/.exec(token);
+  if (!match)
+    return;
+  const word = match[2] ?? "";
+  const name = ALIASES.get(word) ?? word;
+  if (!SPECS.has(name))
+    return;
+  return { name, style: match[1] === "--" ? "double" : "single" };
+}
+function spelling(name) {
+  if (SPECS.get(name) === "value")
+    return `-${name}`;
+  return SHORT[name] ?? `--${name}`;
+}
+
+// src/components/args/args.ts
+function parseFlags(argv) {
+  const flags = new Map;
+  for (let i = 0;i < argv.length; i++) {
+    const token = argv[i] ?? "";
+    const resolved = resolveFlag(token);
+    if (!resolved)
+      throw new Error(`unknown option '${token}'.`);
+    const { name, style } = resolved;
+    const kind = SPECS.get(name) ?? "switch";
+    if (flags.has(name))
+      throw new Error(`'${name}' given more than once.`);
+    const next = argv[i + 1];
+    const hasNext = next !== undefined && !next.startsWith("-");
+    if (style === "single") {
+      if (kind === "switch")
+        throw new Error(`${token} is a switch; write --${name}.`);
+      if (!hasNext)
+        throw new Error(`${token} needs a value.`);
+      flags.set(name, next);
+      i++;
+    } else if (kind === "switch") {
+      flags.set(name, "true");
+    } else if (kind === "value") {
+      throw new Error(`${token} takes a value; write -${name} <value>.`);
+    } else {
+      if (hasNext)
+        throw new Error(`${token} takes no value. For an explicit value use -${name} <value>.`);
+      flags.set(name, "");
+    }
+  }
+  return flags;
+}
+function parseLimit(flags) {
+  const raw = flags.get("limit");
+  if (raw === undefined)
+    return;
+  if (!/^[1-9]\d*$/.test(raw))
+    throw new Error("-limit needs a positive whole number.");
+  return Number(raw);
+}
+function onlyOne(flags, names) {
+  const present = names.filter((name) => flags.has(name));
+  if (present.length > 1) {
+    throw new Error(`use only one of: ${names.map(spelling).join(", ")}.`);
+  }
+  return present[0];
+}
+
+// src/components/git/git.ts
+import { execFileSync } from "node:child_process";
+var verbose = false;
+function setVerbose(on) {
+  verbose = on;
+}
+var dryRun = false;
+function setDryRun(on) {
+  dryRun = on;
+}
+function isDryRun() {
+  return dryRun;
+}
+function git(args) {
+  act(args.split(" "));
+}
+function gitArgs(args, options = {}) {
+  act(args, options);
+}
+function captureArgs(args) {
+  return run(args);
+}
+function hasLocal(branch) {
+  return captureArgs(["branch", "--list", branch]) !== "";
+}
+function assertBranchName(name) {
+  try {
+    captureArgs(["check-ref-format", "--branch", name]);
+  } catch {
+    throw new Error(`'${name}' is not a valid branch name.`);
+  }
+}
+function capture(args) {
+  return run(args.split(" "));
+}
+function hasOnOrigin(branch) {
+  return capture(`ls-remote --heads origin ${branch}`) !== "";
+}
+function listTags() {
+  const local = capture("tag --list").split(`
+`);
+  const remote = capture("ls-remote --tags origin").split(`
+`).map((line) => line.split("\t")[1] ?? "").map((ref) => ref.replace(/^refs\/tags\//, "").replace(/\^\{\}$/, ""));
+  return [...local, ...remote].filter(Boolean);
+}
+function assertCleanTree() {
+  try {
+    captureArgs(["update-index", "-q", "--refresh"]);
+  } catch {}
+  const changed = captureArgs(["status", "--porcelain", "--untracked-files=no"]).split(`
+`).filter(Boolean);
+  if (changed.length === 0)
+    return;
+  const shown = changed.slice(0, 10).map((line) => `  ${line}`).join(`
+`);
+  const more = changed.length > 10 ? `
+  ... and ${changed.length - 10} more` : "";
+  throw new Error(`uncommitted changes to tracked files:
+${shown}${more}
+commit them, or stash them with gith stash.`);
+}
+function isDetached() {
+  try {
+    captureArgs(["symbolic-ref", "-q", "HEAD"]);
+    return false;
+  } catch {
+    return true;
+  }
+}
+function assertSynced(branches) {
+  if (dryRun) {
+    console.log("dry run: sync check skipped");
+    return;
+  }
+  git("fetch origin");
+  for (const branch of branches) {
+    if (capture(`rev-parse ${branch}`) !== capture(`rev-parse origin/${branch}`)) {
+      throw new Error(`'${branch}' is not in sync with origin/${branch}.`);
+    }
+  }
+}
+function show(args) {
+  const shown = args.map((arg) => /\s/.test(arg) ? `"${arg}"` : arg);
+  return `> git ${shown.join(" ")}`;
+}
+function run(args) {
+  if (verbose)
+    console.log(show(args));
+  return execFileSync("git", args, { encoding: "utf-8" }).trim();
+}
+function act(args, options = {}) {
+  console.log(show(args));
+  if (dryRun)
+    return;
+  execFileSync("git", args, { stdio: "inherit", ...options });
+}
+
+// src/components/doctor/doctor.utils.ts
+function check(name, test, failure = "fail") {
+  return {
+    name,
+    run: () => {
+      try {
+        const problem = test();
+        return problem === undefined ? { level: "ok", detail: "" } : { level: failure, detail: problem };
+      } catch (error) {
+        return {
+          level: failure,
+          detail: error instanceof Error ? error.message.split(`
+`)[0] ?? "" : String(error)
+        };
+      }
+    }
+  };
+}
+
+// src/components/doctor/doctor.constants.ts
+var CHECKS = [
+  check("git is installed", () => {
+    captureArgs(["--version"]);
+    return;
+  }),
+  check("inside a git repository", () => {
+    captureArgs(["rev-parse", "--is-inside-work-tree"]);
+    return;
+  }),
+  check("origin is configured", () => {
+    captureArgs(["remote", "get-url", "origin"]);
+    return;
+  }),
+  check("origin is reachable", () => {
+    captureArgs(["ls-remote", "--heads", "origin"]);
+    return;
+  }),
+  check("main exists on origin", () => hasOnOrigin("main") ? undefined : "missing"),
+  check("develop exists on origin", () => hasOnOrigin("develop") ? undefined : "missing: create it before work branches"),
+  check("working tree is clean", () => captureArgs(["status", "--porcelain"]) === "" ? undefined : "uncommitted changes", "warn")
+];
+
+// src/components/doctor/doctor.ts
+function doctor(flags) {
+  if (flags.size > 0)
+    throw new Error("usage: gith doctor");
+  let ok = true;
+  for (const item of CHECKS) {
+    const { level, detail } = item.run();
+    if (level === "fail")
+      ok = false;
+    const mark = level === "ok" ? "✔" : level === "warn" ? "!" : "✖";
+    console.log(`${mark} ${item.name}${detail ? `: ${detail}` : ""}`);
+  }
+  console.log(ok ? "ready" : "not ready: fix the ✖ items above");
+  return ok;
+}
+
+// src/components/find/find.constants.ts
+var DEFAULT_LIMIT = 5;
+var FILTERS = ["commit", "file", "change"];
+
+// src/components/find/find.utils.ts
+function describe(message, file, change, regex = false) {
+  const parts = [];
+  if (message !== undefined)
+    parts.push(`message "${message}"`);
+  if (file !== undefined)
+    parts.push(`file "${file}"`);
+  if (change !== undefined)
+    parts.push(`${regex ? "regex" : "change"} "${change}"`);
+  return parts.join(" and ");
+}
+
+// src/components/find/find.ts
+function find(flags) {
+  const message = flags.get("commit");
+  const file = flags.get("file");
+  const change = flags.get("change");
+  const extra = [...flags.keys()].filter((key) => key !== "limit" && key !== "regex" && !FILTERS.includes(key));
+  const usage = 'usage: gith find -commit "<text>" | -file "<pattern>" | -change "<text>" [--regex] [-limit <n>]';
+  if (message === undefined && file === undefined && change === undefined || extra.length > 0) {
+    throw new Error(usage);
+  }
+  if (flags.has("regex") && change === undefined) {
+    throw new Error("--regex only applies to -change.");
+  }
+  const limit = parseLimit(flags) ?? DEFAULT_LIMIT;
+  const args = [
+    "log",
+    `-n${limit}`,
+    "--date=short",
+    "--format=%x1e%h  %ad  %an  %s"
+  ];
+  if (message !== undefined) {
+    args.push("--fixed-strings", "--regexp-ignore-case", `--grep=${message}`);
+  }
+  if (change !== undefined) {
+    args.push(flags.has("regex") ? `-G${change}` : `-S${change}`);
+  }
+  if (file !== undefined) {
+    args.push("--name-only", "--", file);
+  }
+  const records = captureArgs(args).split("\x1E").map((record) => record.trim()).filter(Boolean);
+  if (records.length === 0) {
+    console.log(`No commits match ${describe(message, file, change, flags.has("regex"))}.`);
+    return;
+  }
+  console.log(records.map((record) => {
+    const [header = "", ...paths] = record.split(`
+`);
+    return [
+      header,
+      ...paths.filter(Boolean).map((path) => `    ${path.trim()}`)
+    ].join(`
+`);
+  }).join(`
+`));
+}
+
+// src/components/rules/rules.constants.ts
+var CONTAINER = /^(develop|main|release\/.+|hotfix\/.+)$/;
+var TARGET = /^(develop|release\/.+|hotfix\/.+)$/;
+
+// src/components/rules/rules.ts
+function isContainer(name) {
+  return CONTAINER.test(name);
+}
+function isTarget(name) {
+  return TARGET.test(name);
+}
+function containerName(kind, version) {
+  return `${kind}/${version}`;
+}
+function containerBase(kind) {
+  return kind === "release" ? "develop" : "main";
+}
+
+// src/components/versions/versions.constants.ts
+var SEMVER = /^v?(\d+)\.(\d+)\.(\d+)$/;
+
+// src/components/versions/versions.ts
+function parseSemver(tag) {
+  const match = SEMVER.exec(tag.trim());
+  if (!match)
+    return;
+  return [Number(match[1]), Number(match[2]), Number(match[3])];
+}
+function compare(a, b) {
+  for (let i = 0;i < 3; i++) {
+    const diff = (a[i] ?? 0) - (b[i] ?? 0);
+    if (diff !== 0)
+      return diff;
+  }
+  return 0;
+}
+function latestVersion(tags) {
+  let latest;
+  for (const tag of tags) {
+    const version = parseSemver(tag);
+    if (version && (!latest || compare(version, latest) > 0))
+      latest = version;
+  }
+  return latest;
+}
+function nextVersion(tags, bump) {
+  const [major, minor, patch] = latestVersion(tags) ?? [0, 0, 0];
+  return bump === "minor" ? `${major}.${minor + 1}.0` : `${major}.${minor}.${patch + 1}`;
+}
+
+// src/components/flow/flow.utils.ts
+function newestContainer(kind) {
+  const prefix = `${kind}/`;
+  const local = captureArgs([
+    "for-each-ref",
+    "--format=%(refname:short)",
+    "refs/heads"
+  ]).split(`
+`);
+  const origin = captureArgs(["ls-remote", "--heads", "origin"]).split(`
+`).map((line) => (line.split("\t")[1] ?? "").replace(/^refs\/heads\//, ""));
+  const candidates = new Set([...local, ...origin].filter((name) => name.startsWith(prefix)));
+  let newest;
+  for (const name of candidates) {
+    const version = parseSemver(name.slice(prefix.length));
+    if (version && (!newest || compare(version, newest.version) > 0))
+      newest = { name, version };
+  }
+  if (!newest)
+    throw new Error(`no ${kind} branch exists, locally or on origin.`);
+  return newest.name;
+}
+function nextContainerVersion(kind) {
+  const bump = kind === "release" ? "minor" : "patch";
+  const tags = listTags();
+  let version = nextVersion(tags, bump);
+  while (hasOnOrigin(containerName(kind, version))) {
+    tags.push(version);
+    version = nextVersion(tags, bump);
+  }
+  console.log(`Next ${kind} version from existing tags: ${version}`);
+  return version;
+}
+function open(kind, version) {
+  const name = containerName(kind, version);
+  if (hasOnOrigin(name))
+    throw new Error(`'${name}' already exists on origin.`);
+  const base = containerBase(kind);
+  gitArgs(["fetch", "origin", base]);
+  gitArgs(["branch", name, `origin/${base}`]);
+  gitArgs(["push", "-u", "origin", name]);
+}
+
+// src/components/flow/flow.ts
+function create(flags) {
+  const kind = onlyOne(flags, ["branch", "release", "hotfix"]);
+  if (!kind)
+    throw new Error("usage: gith create -b <branch> | -r [version] | -h [version]");
+  const value = flags.get(kind) ?? "";
+  if (kind === "branch") {
+    if (!value)
+      throw new Error("usage: gith create -b <branch>");
+    createBranch(value);
+    return;
+  }
+  open(kind, value || nextContainerVersion(kind));
+}
+function merge(flags) {
+  const kind = onlyOne(flags, [
+    "release",
+    "hotfix",
+    "current-release",
+    "current-hotfix"
+  ]);
+  let target = "develop";
+  if (kind === "current-release")
+    target = newestContainer("release");
+  else if (kind === "current-hotfix")
+    target = newestContainer("hotfix");
+  else if (kind) {
+    const version = flags.get(kind) ?? "";
+    if (!version) {
+      throw new Error(`usage: gith merge -${kind === "release" ? "r" : "h"} <version>`);
+    }
+    target = containerName(kind, version);
+  }
+  mergeInto(target);
+}
+function createBranch(goal, from) {
+  if (isContainer(goal))
+    throw new Error(`'${goal}' is a container name; pick a goal.`);
+  if (hasOnOrigin(goal))
+    throw new Error(`'${goal}' already exists on origin.`);
+  if (from === undefined) {
+    gitArgs(["fetch", "origin", "develop"]);
+    gitArgs(["branch", goal, "origin/develop"]);
+  } else {
+    gitArgs(["branch", goal, from]);
+  }
+  gitArgs(["push", "-u", "origin", goal]);
+}
+function mergeInto(target) {
+  if (!isTarget(target))
+    throw new Error(`'${target}' is not a valid target.`);
+  const source = capture("rev-parse --abbrev-ref HEAD");
+  if (isContainer(source))
+    throw new Error(`'${source}' is a container and cannot be merged from.`);
+  if (source === target)
+    throw new Error(`already on '${target}', nothing to merge.`);
+  if (!hasOnOrigin(target))
+    throw new Error(`'${target}' does not exist on origin.`);
+  assertCleanTree();
+  if (hasOnOrigin(source))
+    git(`pull origin ${source}`);
+  git(`push -u origin ${source}`);
+  git(`checkout ${target}`);
+  git("pull");
+  git(`checkout ${source}`);
+  try {
+    gitArgs(["merge", target, "--no-edit"]);
+  } catch {
+    gitArgs(["merge", "--abort"]);
+    throw new Error(`merging '${target}' into '${source}' conflicts; resolve on '${source}' and retry.`);
+  }
+  git(`push origin ${source}`);
+  git(`checkout ${target}`);
+  git(`merge --no-ff ${source} --no-edit`);
+  git(`push origin ${target}`);
+  assertSynced([target, source]);
+  console.log(`
+✅ '${source}' merged into '${target}', both in sync with origin.`);
+}
+
+// src/components/prompt/prompt.ts
+import { createInterface } from "node:readline/promises";
+var assumeYes = false;
+function setAssumeYes(on) {
+  assumeYes = on;
+}
+async function confirm(question) {
+  if (isDryRun()) {
+    console.log(`dry run: would ask: ${question}`);
+    return true;
+  }
+  if (assumeYes)
+    return true;
+  if (!process.stdin.isTTY)
+    throw new Error("this needs a terminal to confirm; pass --yes to skip the question.");
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = (await rl.question(question)).trim().toLowerCase();
+    return answer === "" || answer === "y" || answer === "yes";
+  } finally {
+    rl.close();
+  }
+}
+async function ask(question) {
+  if (isDryRun()) {
+    console.log(`dry run: would ask: ${question}`);
+    return "<message>";
+  }
+  if (!process.stdin.isTTY)
+    throw new Error("needs a terminal to ask; pass -m <message>.");
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    return (await rl.question(question)).trim();
+  } finally {
+    rl.close();
+  }
+}
+
+// src/components/history/history.utils.ts
+function noFlags(flags, command) {
+  if (flags.size > 0)
+    throw new Error(`usage: gith ${command}`);
+}
+function currentBranch() {
+  const name = capture("rev-parse --abbrev-ref HEAD");
+  if (name === "HEAD")
+    throw new Error("HEAD is detached; check out a branch first.");
+  return name;
+}
+function assertNotPushed() {
+  if (captureArgs(["branch", "-r", "--contains", "HEAD"]) !== "") {
+    throw new Error("HEAD is already on origin; changing it would need a force-push.");
+  }
+}
+function remoteSha(branch) {
+  return captureArgs(["ls-remote", "--heads", "origin", branch]).split("\t")[0] ?? "";
+}
+async function askMessage() {
+  const text = await ask("Commit message: ");
+  if (text === "")
+    throw new Error("a commit needs a message; nothing was committed.");
+  return text;
+}
+
+// src/components/history/history.ts
+function update(flags) {
+  noFlags(flags, "update");
+  const branch = currentBranch();
+  if (isContainer(branch))
+    throw new Error(`'${branch}' is a container; update works on a work branch.`);
+  assertCleanTree();
+  gitArgs(["fetch", "origin", "develop"]);
+  try {
+    gitArgs(["merge", "origin/develop", "--no-edit"]);
+  } catch {
+    if (isDryRun())
+      return;
+    gitArgs(["merge", "--abort"]);
+    throw new Error("merging origin/develop conflicts; the merge was aborted. Resolve it by hand, then retry.");
+  }
+}
+function undo(flags) {
+  noFlags(flags, "undo");
+  currentBranch();
+  assertCleanTree();
+  assertNotPushed();
+  gitArgs(["reset", "--soft", "HEAD~1"]);
+}
+async function save(flags) {
+  const message = flags.get("message");
+  const extra = [...flags.keys()].filter((key) => key !== "message");
+  if (extra.length > 0)
+    throw new Error("usage: gith save [-m <message>]");
+  const branch = currentBranch();
+  if (captureArgs(["diff", "--cached", "--name-only"]) === "") {
+    throw new Error("nothing staged; stage the changes to add to the last commit.");
+  }
+  const owned = hasOwnCommit();
+  const pushed = captureArgs(["branch", "-r", "--contains", "HEAD"]) !== "";
+  const rewrite = owned && pushed;
+  const remote = remoteSha(branch);
+  if (rewrite && remote === "") {
+    throw new Error("HEAD is already on origin under another branch; changing it would need a force-push.");
+  }
+  if (rewrite) {
+    const yes = await confirm(`HEAD is already on origin/${branch}. Save it and force-push ${branch}? [Y/n] `);
+    if (!yes) {
+      console.log("save cancelled; nothing changed.");
+      return;
+    }
+  }
+  if (owned) {
+    gitArgs(message ? ["commit", "--amend", "-m", message] : ["commit", "--amend", "--no-edit"]);
+  } else {
+    const text = message ?? await askMessage();
+    gitArgs(["commit", "-m", text]);
+  }
+  if (remote === "") {
+    console.log(`origin has no ${branch}; not pushed.`);
+    return;
+  }
+  if (!isDryRun() && captureArgs(["rev-parse", "HEAD"]) === remote) {
+    console.log("origin already has this commit; not pushed.");
+    return;
+  }
+  if (rewrite)
+    gitArgs(["push", "--force-with-lease", "origin", branch]);
+  else
+    gitArgs(["push", "origin", branch]);
+}
+async function squash(flags) {
+  const count = parseLimit(flags);
+  const message = flags.get("message");
+  const extra = [...flags.keys()].filter((key) => key !== "limit" && key !== "message");
+  if (count === undefined || extra.length > 0) {
+    throw new Error("usage: gith squash -limit <n> [-m <message>]");
+  }
+  if (count < 2)
+    throw new Error("-limit needs at least 2 commits to squash.");
+  const branch = currentBranch();
+  if (isContainer(branch))
+    throw new Error(`'${branch}' is a container; squash works on a work branch.`);
+  assertCleanTree();
+  const total = Number(captureArgs(["rev-list", "--count", "HEAD"]));
+  if (count >= total) {
+    throw new Error(`only ${total} commits on this branch; squashing ${count} would reach the first commit.`);
+  }
+  const commits = captureArgs(["rev-list", `-n${count}`, "HEAD"]).split(`
+`);
+  const oldest = commits[count - 1] ?? "";
+  if (captureArgs(["rev-list", "--merges", `-n${count}`, "HEAD"]) !== "") {
+    throw new Error("the commits include a merge; squashing would flatten it.");
+  }
+  if (captureArgs(["branch", "-r", "--contains", oldest]) !== "") {
+    throw new Error("these commits are already on origin; squashing them would need a force-push.");
+  }
+  console.log("Will combine:");
+  for (const line of captureArgs(["log", `-n${count}`, "--oneline"]).split(`
+`)) {
+    console.log(`  ${line}`);
+  }
+  if (!await confirm(`Combine these ${count} commits into one? [Y/n] `)) {
+    console.log("Nothing changed.");
+    return;
+  }
+  gitArgs(["reset", "--soft", `HEAD~${count}`]);
+  if (message)
+    gitArgs(["commit", "-m", message]);
+  else
+    gitArgs(["commit", "-C", oldest]);
+}
+function hasOwnCommit() {
+  for (const base of ["origin/develop", "origin/main"]) {
+    try {
+      return captureArgs(["rev-list", "--count", `${base}..HEAD`]) !== "0";
+    } catch {}
+  }
+  return true;
+}
+
+// src/components/list/list.constants.ts
+var DEFAULT_LIMIT2 = 5;
+var GORLUM = [
+  '      .-"""-.',
+  "     /  o o  \\",
+  "    |   ___   |   my precious pockets!",
+  "     \\ (___) /",
+  "      '-._.-'"
+];
+
+// src/components/list/list.utils.ts
+function yesNo(value) {
+  return value ? "yes" : "no";
+}
+function commits(limit, graph) {
+  if (!hasHead()) {
+    console.log("No commits.");
+    return;
+  }
+  const shape = graph ? ["--graph", "--oneline", "--decorate"] : ["--date=short", "--format=%h  %ad  %an  %s"];
+  console.log(captureArgs(["log", `-n${limit}`, ...shape]));
+}
+function hasHead() {
+  try {
+    captureArgs(["rev-parse", "--verify", "--quiet", "HEAD"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/components/list/list.ts
+function tagPairs(local, origin) {
+  const names = [...new Set([...local, ...origin])];
+  return names.map((name) => ({
+    name,
+    local: local.includes(name),
+    origin: origin.includes(name)
+  })).sort((a, b) => {
+    const va = parseSemver(a.name);
+    const vb = parseSemver(b.name);
+    if (va && vb)
+      return compare(vb, va);
+    if (va)
+      return -1;
+    if (vb)
+      return 1;
+    return a.name.localeCompare(b.name);
+  });
+}
+function list(flags) {
+  const kind = onlyOne(flags, ["tags", "commits", "stashes", "pockets"]);
+  if (!kind)
+    throw new Error("usage: gith list --tags | --commits [--graph] | --stashes | --pockets [-limit <n>]");
+  if (flags.has("graph") && kind !== "commits")
+    throw new Error("--graph only applies to --commits.");
+  const limit = parseLimit(flags) ?? DEFAULT_LIMIT2;
+  if (kind === "commits")
+    commits(limit, flags.has("graph"));
+  else if (kind === "stashes")
+    stashes(limit, false);
+  else if (kind === "pockets")
+    stashes(limit, true);
+  else
+    tags(limit);
+}
+function localTags() {
+  return captureArgs(["tag", "--list"]).split(`
+`).filter(Boolean);
+}
+function stashes(limit, withGorlum) {
+  if (withGorlum)
+    console.log(GORLUM.join(`
+`));
+  const rows = captureArgs([
+    "stash",
+    "list",
+    "--date=short",
+    "--format=%gd  %cd  %gs"
+  ]).split(`
+`).filter(Boolean);
+  if (rows.length === 0) {
+    console.log("No stashes.");
+    return;
+  }
+  const shown = rows.slice(0, limit);
+  console.log(shown.join(`
+`));
+  if (shown.length < rows.length) {
+    console.log(`showing ${shown.length} of ${rows.length}; -limit <n> shows more`);
+  }
+}
+function tags(limit) {
+  const pairs = tagPairs(localTags(), originTags());
+  if (pairs.length === 0) {
+    console.log("No tags.");
+    return;
+  }
+  const shown = pairs.slice(0, limit);
+  const width = Math.max("TAG".length, ...pairs.map((pair) => pair.name.length));
+  console.log(`${"TAG".padEnd(width)}  LOCAL  ORIGIN`);
+  for (const pair of shown) {
+    console.log(`${pair.name.padEnd(width)}  ${yesNo(pair.local).padEnd(5)}  ${yesNo(pair.origin)}`);
+  }
+  if (shown.length < pairs.length) {
+    console.log(`showing ${shown.length} of ${pairs.length}; -limit <n> shows more`);
+  }
+}
+function originTags() {
+  return captureArgs(["ls-remote", "--tags", "origin"]).split(`
+`).filter(Boolean).map((line) => (line.split("\t")[1] ?? "").replace(/^refs\/tags\//, "")).filter((ref) => ref && !ref.endsWith("^{}"));
+}
+
+// src/components/maintenance/maintenance.ts
+import { createInterface as createInterface2 } from "node:readline/promises";
+
+// src/components/maintenance/maintenance.constants.ts
+var DEFAULT_DAYS = 90;
+
+// src/components/maintenance/maintenance.utils.ts
+function noFlags2(flags, command) {
+  if (flags.size > 0)
+    throw new Error(`usage: gith ${command}`);
+}
+function requireBranch(flags, command) {
+  const branch = flags.get("branch");
+  if (!branch)
+    throw new Error(`usage: gith ${command} -b <branch>`);
+  assertBranchName(branch);
+  return branch;
+}
+function localBranches() {
+  return captureArgs([
+    "for-each-ref",
+    "--format=%(refname:short)",
+    "refs/heads"
+  ]).split(`
+`).filter(Boolean);
+}
+function remoteBranches() {
+  return captureArgs(["ls-remote", "--heads", "origin"]).split(`
+`).filter(Boolean).map((line) => (line.split("\t")[1] ?? "").replace(/^refs\/heads\//, ""));
+}
+function sidesLabel(sides) {
+  if (sides.local !== undefined && sides.origin !== undefined)
+    return "local + origin";
+  return sides.local !== undefined ? "local" : "origin";
+}
+function day(seconds) {
+  return new Date(seconds * 1000).toISOString().slice(0, 10);
+}
+function currentBranch2() {
+  return capture("rev-parse --abbrev-ref HEAD");
+}
+function parsePositive(flags, name) {
+  const raw = flags.get(name);
+  if (raw === undefined)
+    return;
+  if (!/^[1-9]\d*$/.test(raw))
+    throw new Error(`-${name} needs a positive whole number.`);
+  return Number(raw);
+}
+
+// src/components/maintenance/maintenance.ts
+function switchBranch(flags) {
+  const commit = flags.get("commit");
+  if (commit !== undefined) {
+    if (flags.has("branch") || flags.size > 1)
+      throw new Error("use only one of: -b, -commit.");
+    switchToCommit(commit);
+    return;
+  }
+  const branch = requireBranch(flags, "switch");
+  if (!hasLocal(branch) && !hasOnOrigin(branch)) {
+    createBranch(branch, isDetached() ? "HEAD" : undefined);
+  }
+  gitArgs(["switch", "--", branch]);
+}
+function candidates(scope, local, remote, current) {
+  const notContainer = (name) => !isContainer(name);
+  const notCurrent = (name) => name !== current;
+  if (scope === "remote") {
+    return remote.filter(notContainer).map((name) => ({ name, label: `${name}  (origin)` }));
+  }
+  if (scope === "local") {
+    return local.filter((name) => notContainer(name) && notCurrent(name)).map((name) => ({ name, label: name }));
+  }
+  return local.filter((name) => notContainer(name) && notCurrent(name) && remote.includes(name)).map((name) => ({ name, label: `${name}  (local + origin)` }));
+}
+function parseSelection(answer, count) {
+  const indexes = new Set;
+  for (const part of answer.split(",").map((s) => s.trim()).filter(Boolean)) {
+    const range = /^(\d+)-(\d+)$/.exec(part);
+    const from = Number(range ? range[1] : part);
+    const to = Number(range ? range[2] : part);
+    if (!Number.isInteger(from) || !Number.isInteger(to) || from < 1 || to > count || from > to) {
+      throw new Error(`'${part}' is not a choice from 1 to ${count}.`);
+    }
+    for (let n = from;n <= to; n++)
+      indexes.add(n - 1);
+  }
+  return [...indexes];
+}
+function branchTimes(output) {
+  const times = new Map;
+  for (const line of output.split(`
+`).filter(Boolean)) {
+    const [ref = "", time = "0"] = line.split("|");
+    const seconds = Number(time);
+    if (ref.startsWith("refs/heads/")) {
+      const name = ref.slice("refs/heads/".length);
+      times.set(name, { ...times.get(name), local: seconds });
+    } else if (ref.startsWith("refs/remotes/origin/") && ref !== "refs/remotes/origin/HEAD") {
+      const name = ref.slice("refs/remotes/origin/".length);
+      times.set(name, { ...times.get(name), origin: seconds });
+    }
+  }
+  return times;
+}
+function staleOptions(times, scope, cutoff, current) {
+  const options = [];
+  for (const [name, sides] of times) {
+    if (isContainer(name) || name === current)
+      continue;
+    if (scope === "local" && sides.local === undefined)
+      continue;
+    const last = scope === "local" ? sides.local : Math.max(sides.local ?? 0, sides.origin ?? 0);
+    if (last === undefined || last >= cutoff)
+      continue;
+    options.push({
+      name,
+      label: `${name}  (${sidesLabel(sides)}, last commit ${day(last)})`
+    });
+  }
+  return options.sort((x, y) => x.name.localeCompare(y.name));
+}
+function detachedOptions(times, current) {
+  const options = [];
+  for (const [name, sides] of times) {
+    if (sides.local === undefined || sides.origin !== undefined)
+      continue;
+    if (isContainer(name) || name === current)
+      continue;
+    options.push({ name, label: `${name}  (local only)` });
+  }
+  return options.sort((x, y) => x.name.localeCompare(y.name));
+}
+async function remove(flags) {
+  const name = flags.get("branch");
+  const side = onlyOne(flags, ["local", "remote"]);
+  const scope = side ?? "pair";
+  const obsoleteOn = flags.has("obsolete");
+  const detachedOn = flags.has("detached");
+  if (obsoleteOn && detachedOn)
+    throw new Error("use only one of: --obsolete, --detached.");
+  if (flags.has("days") && !obsoleteOn)
+    throw new Error("-days only applies to --obsolete.");
+  if (obsoleteOn || detachedOn) {
+    const usage = detachedOn ? "usage: gith remove --detached [-l <n>]" : "usage: gith remove --obsolete [--local] [-days <n>] [-l <n>]";
+    if (name !== undefined || obsoleteOn && side === "remote" || detachedOn && side)
+      throw new Error(usage);
+    if (detachedOn)
+      return detached(flags);
+    return obsolete(flags, side === "local" ? "local" : "pair");
+  }
+  if (name === undefined)
+    throw new Error("usage: gith remove -b <branch> [--local | --remote], or gith remove --branch to pick");
+  if (name) {
+    if (flags.has("limit"))
+      throw new Error("-limit only applies to listings: gith remove --branch.");
+    assertBranchName(name);
+    if (isContainer(name))
+      throw new Error(`'${name}' is a container and cannot be removed.`);
+    await removeBranches(scope, [name]);
+    return;
+  }
+  requireTerminal();
+  await removeBranches(scope, await pick(scope, parseLimit(flags)));
+}
+function sync(flags) {
+  noFlags2(flags, "sync");
+  gitArgs(["fetch", "--all", "--tags", "--prune"]);
+}
+async function reset(flags) {
+  noFlags2(flags, "reset");
+  const changes = captureArgs(["status", "--short"]).split(`
+`).filter(Boolean);
+  const untracked = untrackedPaths();
+  if (changes.length === 0 && untracked.length === 0) {
+    console.log("Nothing to discard.");
+    return;
+  }
+  console.log("Will discard:");
+  for (const line of changes)
+    console.log(`  ${line}`);
+  for (const path of untracked)
+    console.log(`  ?? ${path}`);
+  if (!await confirm("Discard all of this? It cannot be undone. [Y/n] ")) {
+    console.log("Nothing discarded.");
+    return;
+  }
+  gitArgs(["reset", "--hard"]);
+  if (untracked.length > 0)
+    gitArgs(["clean", "-fd"]);
+}
+async function clean(flags) {
+  noFlags2(flags, "clean");
+  const untracked = untrackedPaths();
+  if (untracked.length === 0) {
+    console.log("No untracked files to remove.");
+    return;
+  }
+  console.log("Will remove:");
+  for (const path of untracked)
+    console.log(`  ${path}`);
+  if (!await confirm(`Remove these ${untracked.length} untracked paths? [Y/n] `)) {
+    console.log("Nothing removed.");
+    return;
+  }
+  gitArgs(["clean", "-fd"]);
+}
+async function choose(options, limit) {
+  if (options.length === 0) {
+    console.log("No branches to remove.");
+    return [];
+  }
+  const shown = limit === undefined ? options : options.slice(0, limit);
+  for (const [i, option] of shown.entries()) {
+    console.log(`  ${i + 1}. ${option.label}`);
+  }
+  if (shown.length < options.length) {
+    console.log(`showing ${shown.length} of ${options.length}; -limit <n> shows more`);
+  }
+  const rl = createInterface2({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = await rl.question("Remove which? Numbers or ranges, e.g. 1,3-4 (empty cancels): ");
+    return parseSelection(answer, shown.length).map((i) => shown[i]?.name ?? "");
+  } finally {
+    rl.close();
+  }
+}
+function requireTerminal() {
+  if (!process.stdin.isTTY) {
+    throw new Error("pass a branch name with -b, e.g. gith remove -b <branch>; the list needs a terminal");
+  }
+}
+function pick(scope, limit) {
+  const remote = scope === "local" ? [] : remoteBranches();
+  return choose(candidates(scope, localBranches(), remote, currentBranch2()), limit);
+}
+async function removeBranches(scope, names, ask2 = true) {
+  const plan = names.map((name) => {
+    if (scope === "remote")
+      return { name, local: false, origin: true };
+    if (scope === "local")
+      return { name, local: true, origin: false };
+    const local = hasLocal(name);
+    const origin = hasOnOrigin(name);
+    if (!local && !origin) {
+      throw new Error(`'${name}' exists neither locally nor on origin.`);
+    }
+    return { name, local, origin };
+  });
+  if (plan.length > 0)
+    console.log("Will remove:");
+  if (ask2 && plan.length > 0 && !await confirm(plan.length === 1 ? "Remove this branch? [Y/n] " : `Remove these ${plan.length} branches? [Y/n] `)) {
+    console.log("Nothing removed.");
+    return;
+  }
+  for (const { name, local, origin } of plan) {
+    const sides = [local && "local", origin && "origin"].filter(Boolean).join(" + ");
+    console.log(`  ${name}  (${sides})`);
+  }
+  for (const { name, local, origin } of plan) {
+    if (local)
+      gitArgs(["branch", "-d", "--", name]);
+    if (origin)
+      gitArgs(["push", "origin", "--delete", name]);
+  }
+}
+function readTimes() {
+  return branchTimes(captureArgs([
+    "for-each-ref",
+    "--format=%(refname)|%(committerdate:unix)",
+    "refs/heads",
+    "refs/remotes/origin"
+  ]));
+}
+async function obsolete(flags, scope) {
+  gitArgs(["fetch", "--prune", "origin"]);
+  const days = parsePositive(flags, "days") ?? DEFAULT_DAYS;
+  const cutoff = Math.floor(Date.now() / 1000) - days * 86400;
+  const options = staleOptions(readTimes(), scope, cutoff, currentBranch2());
+  if (options.length === 0) {
+    console.log(`No branches untouched for ${days} days.`);
+    return;
+  }
+  const limit = parseLimit(flags);
+  const shown = limit === undefined ? options : options.slice(0, limit);
+  console.log(`Untouched for ${days} days or more:`);
+  for (const [i, option] of shown.entries()) {
+    console.log(`  ${i + 1}. ${option.label}`);
+  }
+  if (shown.length < options.length) {
+    console.log(`showing ${shown.length} of ${options.length}; -limit <n> shows more`);
+  }
+  const where = scope === "local" ? "here" : "here and on origin";
+  const yes = await confirm(`Remove these ${shown.length} branches ${where}? [Y/n] `);
+  if (!yes) {
+    console.log("Nothing removed.");
+    return;
+  }
+  await removeBranches(scope, shown.map((option) => option.name), false);
+}
+async function detached(flags) {
+  requireTerminal();
+  gitArgs(["fetch", "--prune", "origin"]);
+  const options = detachedOptions(readTimes(), currentBranch2());
+  await removeBranches("local", await choose(options, parseLimit(flags)));
+}
+function switchToCommit(ref) {
+  let sha;
+  try {
+    sha = captureArgs(["rev-parse", "--verify", "--quiet", `${ref}^{commit}`]);
+  } catch {
+    throw new Error(`'${ref}' is not a commit in this repository.`);
+  }
+  assertCleanTree();
+  gitArgs(["switch", "--detach", sha]);
+  console.log(`HEAD is detached at ${sha.slice(0, 7)}. To keep commits made here, run: gith switch -b <name>.`);
+}
+function untrackedPaths() {
+  return captureArgs(["clean", "-nd"]).split(`
+`).filter(Boolean).map((line) => line.replace(/^Would remove /, ""));
+}
+
+// src/components/open/open.ts
+import { spawn } from "node:child_process";
+function webUrl(remote) {
+  let url = remote.trim();
+  const scp = /^[^@/]+@([^:]+):(.+)$/.exec(url);
+  if (scp)
+    url = `https://${scp[1]}/${scp[2]}`;
+  else
+    url = url.replace(/^ssh:\/\/([^@]+@)?/, "https://");
+  url = url.replace(/\.git$/, "").replace(/\/$/, "");
+  if (!/^https?:\/\//.test(url))
+    throw new Error(`origin is not a web address: ${remote}`);
+  return url;
+}
+function open2(flags) {
+  if (flags.size > 0)
+    throw new Error("usage: gith open");
+  const url = webUrl(captureArgs(["remote", "get-url", "origin"]));
+  const [command, args] = openerFor(process.platform, url);
+  console.log(`> ${command} ${args.join(" ")}`);
+  if (isDryRun())
+    return;
+  spawn(command, args, { detached: true, stdio: "ignore" }).unref();
+}
+function openerFor(platform, url) {
+  if (platform === "win32")
+    return ["explorer.exe", [url]];
+  if (platform === "darwin")
+    return ["open", [url]];
+  return ["xdg-open", [url]];
+}
+
+// src/components/release/release.constants.ts
+var KINDS = ["patch", "minor", "major"];
+
+// src/components/release/release.utils.ts
+import { execSync } from "node:child_process";
+function npmVersion(kind) {
+  console.log(`> npm version ${kind}`);
+  if (isDryRun())
+    return;
+  execSync(`npm version ${kind}`, { stdio: "inherit" });
+}
+
+// src/components/release/release.ts
+function release(kind) {
+  if (!kind || !KINDS.includes(kind))
+    throw new Error("usage: gith release <patch|minor|major>");
+  assertCleanTree();
+  if (kind === "patch") {
+    releasePatch();
+  } else {
+    releaseFromDevelop(kind);
+  }
+}
+function releasePatch() {
+  console.log(`
+\uD83D\uDCCB Starting patch release from main...
+`);
+  git("checkout main");
+  git("pull");
+  npmVersion("patch");
+  git("push --follow-tags");
+  git("checkout develop");
+  git("pull");
+  git("rebase main");
+  git("push --force-with-lease");
+  git("checkout main");
+  assertSynced(["main", "develop"]);
+  console.log(`
+✅ Patch release complete!
+`);
+}
+function releaseFromDevelop(kind) {
+  console.log(`
+\uD83D\uDCCB Starting ${kind} release from develop...
+`);
+  const current = capture("rev-parse --abbrev-ref HEAD");
+  if (current !== "develop")
+    throw new Error(`must be on 'develop', currently on '${current}'.`);
+  git("pull");
+  npmVersion(kind);
+  git("push --follow-tags");
+  git("checkout main");
+  git("pull");
+  git("merge develop --no-edit");
+  git("push");
+  git("checkout develop");
+  git("pull origin main");
+  assertSynced(["main", "develop"]);
+  console.log(`
+✅ ${kind} release complete!
+`);
+}
+
+// src/components/stash/stash.ts
+function stash(flags) {
+  const name = flags.get("name");
+  if (flags.size > (name === undefined ? 0 : 1))
+    throw new Error("usage: gith stash [-n <name>]");
+  if (captureArgs(["status", "--porcelain"]) === "")
+    throw new Error("nothing to stash.");
+  const args = ["stash", "push", "--include-untracked"];
+  if (name)
+    args.push("-m", name);
+  gitArgs(args);
+}
+function unstash(flags) {
+  if (flags.size > 0)
+    throw new Error("usage: gith unstash");
+  gitArgs(["stash", "pop"]);
+}
+
+// src/components/stat/stat.constants.ts
+var PERIODS = [
+  "overall",
+  "current-year",
+  "current-month",
+  "current-week",
+  "last-year",
+  "last-month",
+  "last-week"
+];
+var DAYS = [
+  "Sunday",
+  "Monday",
+  "Tuesday",
+  "Wednesday",
+  "Thursday",
+  "Friday",
+  "Saturday"
+];
+
+// src/components/stat/stat.utils.ts
+function startOfWeek(date) {
+  const offset = (date.getDay() + 6) % 7;
+  return new Date(date.getFullYear(), date.getMonth(), date.getDate() - offset);
+}
+function dayKey(date) {
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day2 = String(date.getDate()).padStart(2, "0");
+  return `${date.getFullYear()}-${month}-${day2}`;
+}
+function top(counts) {
+  let best;
+  for (const [key, count] of counts) {
+    if (!best || count > best[1] || count === best[1] && key < best[0])
+      best = [key, count];
+  }
+  return best;
+}
+function count(keys) {
+  const counts = new Map;
+  for (const key of keys)
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+  return counts;
+}
+
+// src/components/stat/stat.ts
+function periodRange(period, now) {
+  const year = now.getFullYear();
+  const month = now.getMonth();
+  const week = startOfWeek(now);
+  const iso = (date) => date.toISOString();
+  switch (period) {
+    case "overall":
+      return { label: "overall" };
+    case "current-year":
+      return { label: `this year (${year})`, since: iso(new Date(year, 0, 1)) };
+    case "last-year":
+      return {
+        label: `last year (${year - 1})`,
+        since: iso(new Date(year - 1, 0, 1)),
+        until: iso(new Date(year, 0, 1))
+      };
+    case "current-month":
+      return { label: "this month", since: iso(new Date(year, month, 1)) };
+    case "last-month":
+      return {
+        label: "last month",
+        since: iso(new Date(year, month - 1, 1)),
+        until: iso(new Date(year, month, 1))
+      };
+    case "current-week":
+      return { label: "this week", since: iso(week) };
+    case "last-week":
+      return {
+        label: "last week",
+        since: iso(new Date(week.getFullYear(), week.getMonth(), week.getDate() - 7)),
+        until: iso(week)
+      };
+  }
+}
+function parseLog(output) {
+  return output.split("\x1E").filter((record) => record.trim() !== "").map((record) => {
+    const [header = "", ...lines] = record.trim().split(`
+`);
+    const [hash = "", author = "", date = "", subject = ""] = header.split("\x1F");
+    let added = 0;
+    let deleted = 0;
+    const files = [];
+    for (const line of lines) {
+      const [adds = "", dels = "", file = ""] = line.split("\t");
+      if (file === "")
+        continue;
+      added += Number(adds) || 0;
+      deleted += Number(dels) || 0;
+      files.push(file);
+    }
+    return {
+      hash,
+      author,
+      date: new Date(date),
+      subject,
+      added,
+      deleted,
+      files
+    };
+  });
+}
+function longestStreak(dates) {
+  const days = [...new Set(dates.map(dayKey))].sort();
+  let best = 0;
+  let run2 = 0;
+  let previous = -Infinity;
+  for (const key of days) {
+    const [y = 0, m = 1, d = 1] = key.split("-").map(Number);
+    const ms = Date.UTC(y, m - 1, d) / 86400000;
+    run2 = ms - previous === 1 ? run2 + 1 : 1;
+    best = Math.max(best, run2);
+    previous = ms;
+  }
+  return best;
+}
+function summarize(commits2) {
+  if (commits2.length === 0)
+    return [];
+  const rows = [];
+  const add = (stat, value, detail = "") => rows.push({ stat, value, detail });
+  const authors = count(commits2.map((c) => c.author));
+  const topAuthor = top(authors);
+  const oldest = commits2.reduce((a, b) => a.date <= b.date ? a : b);
+  const newest = commits2.reduce((a, b) => a.date >= b.date ? a : b);
+  const added = commits2.reduce((sum, c) => sum + c.added, 0);
+  const deleted = commits2.reduce((sum, c) => sum + c.deleted, 0);
+  add("Commits", String(commits2.length), `${dayKey(oldest.date)} to ${dayKey(newest.date)}`);
+  add("Authors", String(authors.size));
+  if (topAuthor)
+    add("Top author", topAuthor[0], `${topAuthor[1]} commits`);
+  const biggest = commits2.reduce((a, b) => b.added + b.deleted > a.added + a.deleted ? b : a);
+  add("Biggest commit", `+${biggest.added} -${biggest.deleted}`, `${biggest.hash.slice(0, 7)} ${biggest.subject} (${biggest.author})`);
+  add("Average size", `${Math.round((added + deleted) / commits2.length)} lines`, `per commit; +${added} -${deleted} in total`);
+  const files = count(commits2.flatMap((c) => c.files));
+  const topFile = top(files);
+  add("Files touched", String(files.size), topFile ? `most changed: ${topFile[0]} (${topFile[1]} commits)` : "");
+  const busiestDay = top(count(commits2.map((c) => dayKey(c.date))));
+  if (busiestDay)
+    add("Busiest day", busiestDay[0], `${busiestDay[1]} commits`);
+  const weekday = top(count(commits2.map((c) => DAYS[c.date.getDay()] ?? "")));
+  if (weekday)
+    add("Busiest weekday", weekday[0], `${weekday[1]} commits`);
+  const hour = top(count(commits2.map((c) => String(c.date.getHours()).padStart(2, "0"))));
+  if (hour)
+    add("Peak hour", `${hour[0]}:00`, `${hour[1]} commits`);
+  const streak = longestStreak(commits2.map((c) => c.date));
+  add("Longest streak", `${streak} ${streak === 1 ? "day" : "days"}`, "in a row with a commit");
+  const nightOwl = commits2.filter((c) => c.date.getHours() >= 22 || c.date.getHours() < 5).length;
+  const weekend = commits2.filter((c) => c.date.getDay() === 0 || c.date.getDay() === 6).length;
+  add("Night owl", `${nightOwl} commits`, "between 22:00 and 05:00");
+  add("Weekend", `${weekend} commits`, "on Saturday or Sunday");
+  const types = count(commits2.map((c) => /^(\w+)(\([^)]*\))?!?:/.exec(c.subject)?.[1]?.toLowerCase() ?? "").filter(Boolean));
+  if (types.size > 0) {
+    const list2 = [...types.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, 4).map(([type, n]) => `${type} ${n}`).join(", ");
+    add("Commit types", list2, "from conventional prefixes");
+  }
+  return rows;
+}
+function table(rows) {
+  const headers = ["Stat", "Value", "Detail"];
+  const cells = rows.map((row) => [row.stat, row.value, row.detail]);
+  const widths = headers.map((header, i) => Math.max(header.length, ...cells.map((cell) => cell[i]?.length ?? 0)));
+  const line = (values) => `│ ${values.map((value, i) => value.padEnd(widths[i] ?? 0)).join(" │ ")} │`;
+  const rule = (left, middle, right) => `${left}${widths.map((width) => "─".repeat(width + 2)).join(middle)}${right}`;
+  return [
+    rule("┌", "┬", "┐"),
+    line(headers),
+    rule("├", "┼", "┤"),
+    ...cells.map(line),
+    rule("└", "┴", "┘")
+  ].join(`
+`);
+}
+function stat(flags) {
+  const period = onlyOne(flags, PERIODS) ?? "overall";
+  const limit = parseLimit(flags);
+  const range = periodRange(period, new Date);
+  const args = [
+    "log",
+    "--numstat",
+    "--date=iso-strict",
+    "--format=%x1e%H%x1f%an%x1f%aI%x1f%s"
+  ];
+  if (range.since)
+    args.push(`--since=${range.since}`);
+  if (range.until)
+    args.push(`--until=${range.until}`);
+  if (limit !== undefined)
+    args.push(`-n${limit}`);
+  const commits2 = parseLog(captureArgs(args));
+  if (commits2.length === 0) {
+    console.log(`No commits ${range.label === "overall" ? "yet" : `in ${range.label}`}.`);
+    return;
+  }
+  console.log(`gith stat, ${range.label}${limit === undefined ? "" : `, last ${limit} commits`}`);
+  console.log(table(summarize(commits2)));
+}
+
+// src/components/status/status.ts
+function parseStatus(output) {
+  const status = {
+    branch: "",
+    ahead: 0,
+    behind: 0,
+    staged: 0,
+    unstaged: 0,
+    untracked: 0,
+    conflicts: 0
+  };
+  for (const line of output.split(`
+`)) {
+    if (line.startsWith("# branch.head ")) {
+      status.branch = line.slice("# branch.head ".length);
+    } else if (line.startsWith("# branch.upstream ")) {
+      status.upstream = line.slice("# branch.upstream ".length);
+    } else if (line.startsWith("# branch.ab ")) {
+      const [ahead = "+0", behind = "-0"] = line.slice("# branch.ab ".length).split(" ");
+      status.ahead = Number(ahead);
+      status.behind = Math.abs(Number(behind));
+    } else if (line.startsWith("1 ") || line.startsWith("2 ")) {
+      const code = line.split(" ")[1] ?? "..";
+      if (code[0] !== ".")
+        status.staged++;
+      if (code[1] !== ".")
+        status.unstaged++;
+    } else if (line.startsWith("u ")) {
+      status.conflicts++;
+    } else if (line.startsWith("? ")) {
+      status.untracked++;
+    }
+  }
+  return status;
+}
+function status(flags) {
+  if (flags.size > 0)
+    throw new Error("usage: gith status");
+  const info = parseStatus(captureArgs(["status", "--porcelain=v2", "--branch"]));
+  const against = info.upstream ? `${info.branch}  ->  ${info.upstream}  ahead ${info.ahead}, behind ${info.behind}` : `${info.branch}  (no upstream)`;
+  console.log(against);
+  const changed = info.staged + info.unstaged + info.untracked + info.conflicts;
+  if (changed === 0) {
+    console.log("working tree clean");
+    return;
+  }
+  console.log(`staged ${info.staged}, unstaged ${info.unstaged}, untracked ${info.untracked}, conflicts ${info.conflicts}`);
+}
+
+// src/components/tree/tree.utils.ts
+function flagsOf(worktree) {
+  return [
+    worktree.bare ? "bare" : "",
+    worktree.locked ? "locked" : "",
+    worktree.prunable ? "prunable" : ""
+  ].filter(Boolean).join(", ");
+}
+
+// src/components/tree/tree.ts
+function parseWorktrees(output) {
+  return output.split(/\n\s*\n/).map((block) => block.trim()).filter(Boolean).map((block) => {
+    const worktree = {
+      path: "",
+      head: "",
+      bare: false,
+      locked: false,
+      prunable: false
+    };
+    for (const line of block.split(`
+`)) {
+      const [key, ...rest] = line.split(" ");
+      const value = rest.join(" ");
+      if (key === "worktree")
+        worktree.path = value;
+      else if (key === "HEAD")
+        worktree.head = value.slice(0, 7);
+      else if (key === "branch")
+        worktree.branch = value.replace(/^refs\/heads\//, "");
+      else if (key === "bare")
+        worktree.bare = true;
+      else if (key === "locked")
+        worktree.locked = true;
+      else if (key === "prunable")
+        worktree.prunable = true;
+    }
+    return worktree;
+  });
+}
+function tree(flags) {
+  if (flags.size > 0 && !(flags.size === 1 && flags.has("limit")))
+    throw new Error("usage: gith tree [-limit <n>]");
+  const limit = parseLimit(flags);
+  const current = captureArgs(["rev-parse", "--show-toplevel"]);
+  const worktrees = parseWorktrees(captureArgs(["worktree", "list", "--porcelain"]));
+  const shown = limit === undefined ? worktrees : worktrees.slice(0, limit);
+  const rows = shown.map((worktree) => ({
+    mark: worktree.path === current ? "*" : " ",
+    path: worktree.path,
+    branch: worktree.bare ? "(bare)" : worktree.branch ?? "(detached)",
+    head: worktree.bare ? "" : worktree.head,
+    note: flagsOf(worktree)
+  }));
+  const width = Math.max("PATH".length, ...rows.map((row) => row.path.length));
+  const branchWidth = Math.max("BRANCH".length, ...rows.map((row) => row.branch.length));
+  console.log(`  ${"PATH".padEnd(width)}  ${"BRANCH".padEnd(branchWidth)}  HEAD`);
+  for (const row of rows) {
+    const line = `${row.mark} ${row.path.padEnd(width)}  ${row.branch.padEnd(branchWidth)}  ${row.head}`;
+    console.log(row.note ? `${line}  [${row.note}]` : line);
+  }
+  if (shown.length < worktrees.length) {
+    console.log(`showing ${shown.length} of ${worktrees.length}; -limit <n> shows more`);
+  }
+}
+
+// src/components/version/version.ts
+import { readFileSync as readFileSync2 } from "node:fs";
+
+// src/components/version/version.constants.ts
+var MASCOT = [
+  "          o",
+  "         /",
+  "   o----o----o",
+  "    \\   |   /",
+  "     \\  |  /",
+  "      (o_o)",
+  "      /|_|\\",
+  "       d b"
+];
+
+// src/components/version/version.utils.ts
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+function packageJsonPath() {
+  let dir = path.dirname(fileURLToPath(import.meta.url));
+  for (;; ) {
+    const candidate = path.join(dir, "package.json");
+    if (existsSync(candidate)) {
+      const pkg = JSON.parse(readFileSync(candidate, "utf8"));
+      if (pkg.name === "@tertium/gith")
+        return candidate;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir)
+      throw new Error("gith package.json not found");
+    dir = parent;
+  }
+}
+
+// src/components/version/version.ts
+function readVersion() {
+  const pkg = JSON.parse(readFileSync2(packageJsonPath(), "utf8"));
+  return pkg.version ?? "unknown";
+}
+function versionText() {
+  const version = readVersion();
+  const side = ["", "", "", "", "", `gith v${version}`, "git happens.", ""];
+  return MASCOT.map((line, i) => `${line.padEnd(16)}${side[i] ?? ""}`.trimEnd()).join(`
+`);
+}
+
+// src/cli.ts
+var USAGE = `gith - git helper: branch flow and everyday git commands
+
+Start and finish work
+  gith create -b <branch>            work branch from develop, named by its goal (no switch)
+  gith create -r <version>           release/<version> from develop
+  gith create -h <version>           hotfix/<version> from main
+  gith create --release | --hotfix   version from the latest tag: minor for release, patch for hotfix
+  gith switch -b <branch>            switch to a branch, creating it from develop if missing (on a detached HEAD: from that commit)
+  gith switch -commit <sha>          detach HEAD at a commit, to look at it (tracked files must be clean)
+  gith update                        merge origin/develop into this work branch
+  gith merge [-r <v> | -h <v>]       merge this branch into develop, release/<v> or hotfix/<v>
+  gith merge --current-release       merge this branch into the newest release (local or origin)
+  gith merge --current-hotfix        merge this branch into the newest hotfix (local or origin)
+  gith release --patch | --minor | --major   bump the version and publish
+
+Fix history
+  gith undo                          undo the last commit, keep its changes staged (not if pushed)
+  gith save [-m <msg>]               fold staged changes into the last commit, or commit them if the branch has none yet (asks for a message); pushes if origin differs (asks before a force-push)
+  gith squash -limit <n> [-m <msg>]  combine the last n commits into one (keeps the oldest message)
+
+Save and reset work
+  gith stash [-n <name>]             stash changes, including untracked files
+  gith unstash                       bring back the latest stash
+  gith reset                         discard uncommitted changes and untracked files
+  gith clean                         remove untracked files and directories (keeps ignored)
+
+Clean up branches (every removal shows what it will remove first)
+  gith remove -b <branch>            delete the branch here and on origin (either side may be missing)
+  gith remove -b <branch> --local    delete only the local branch
+  gith remove -b <branch> --remote   delete only the origin branch
+  gith remove --branch [-l <n>]      pick from branch pairs (here and on origin)
+  gith remove --branch --local       pick from local branches
+  gith remove --branch --remote      pick from origin branches
+  gith remove --obsolete [--local] [-days <n>]   remove branches untouched for 90 days, after Y/n
+  gith remove --detached [-l <n>]    pick local branches that have no origin copy
+  gith rm                            alias of remove
+
+Look at the repo
+  gith status                        branch vs origin, and staged, unstaged and untracked counts
+  gith list --commits [--graph] [-l <n>]   newest commits on this branch (default 5)
+  gith list --tags [-l <n>]          tags with a local and origin column (newest 5 by default)
+  gith list --stashes [-l <n>]       stashes, newest first (default 5); --pockets shows them with Gorlum
+  gith show ...                      same as gith list
+  gith tree [-l <n>]                 working trees: path, branch, HEAD (current marked *)
+  gith find|search [-commit <text>] [-file <pattern>] [-change <text>] [--regex] [-limit <n>]
+                                     newest commits on this branch matching every filter (default 5)
+  gith stat [period] [-limit <n>]    fun facts about this branch: biggest commit, busiest day, streaks
+                                     period: --overall (default), --current-year|-month|-week, --last-year|-month|-week
+
+Remote and health
+  gith sync                          fetch all remotes and tags, prune stale refs
+  gith open                          open origin in the browser
+  gith doctor                        check the repo is ready for the branch flow (exit 1 on failures)
+
+Help
+  gith help                          show this help
+  gith --version                     show the version with the mascot
+  --verbose                          (any command) also print read-only git calls
+  --dry-run                          (any command) print the git commands that would run, without running them
+  --yes                              (any command) answer yes to every question (for scripts)
+
+Flags: a single dash always takes a value, a double dash never does.
+  -b -r -h -l -m -n -limit -message -name -release -hotfix -branch   take a value, e.g. -limit 10
+  --patch --minor --major --local --remote --obsolete --detached --tags --commits --graph --stashes --pockets   switches
+  --branch --release --hotfix alone pick automatically (picker, latest tag)
+  -limit caps listings and stat (or -l); -days sets the age for remove --obsolete`;
+var args = process.argv.slice(2).filter((arg) => {
+  if (arg === "--verbose")
+    setVerbose(true);
+  else if (arg === "--dry-run")
+    setDryRun(true);
+  else if (arg === "--yes")
+    setAssumeYes(true);
+  else
+    return true;
+  return false;
+});
+var [command, ...rest] = args;
+if (isDryRun())
+  console.log("dry run: nothing below is changed.");
+try {
+  switch (command) {
+    case "create":
+      create(parseFlags(rest));
+      break;
+    case "merge":
+      merge(parseFlags(rest));
+      break;
+    case "switch":
+      switchBranch(parseFlags(rest));
+      break;
+    case "remove":
+    case "rm":
+      await remove(parseFlags(rest));
+      break;
+    case "sync":
+      sync(parseFlags(rest));
+      break;
+    case "clean":
+      await clean(parseFlags(rest));
+      break;
+    case "list":
+    case "show":
+      list(parseFlags(rest));
+      break;
+    case "status":
+      status(parseFlags(rest));
+      break;
+    case "update":
+      update(parseFlags(rest));
+      break;
+    case "undo":
+      undo(parseFlags(rest));
+      break;
+    case "save":
+      await save(parseFlags(rest));
+      break;
+    case "squash":
+      await squash(parseFlags(rest));
+      break;
+    case "find":
+    case "search":
+      find(parseFlags(rest));
+      break;
+    case "stat":
+      stat(parseFlags(rest));
+      break;
+    case "stash":
+      stash(parseFlags(rest));
+      break;
+    case "unstash":
+      unstash(parseFlags(rest));
+      break;
+    case "open":
+      open2(parseFlags(rest));
+      break;
+    case "doctor":
+      if (!doctor(parseFlags(rest)))
+        exit(1);
+      break;
+    case "tree":
+      tree(parseFlags(rest));
+      break;
+    case "reset":
+      await reset(parseFlags(rest));
+      break;
+    case "release": {
+      const flags = parseFlags(rest);
+      const kind = onlyOne(flags, ["patch", "minor", "major"]);
+      if (!kind)
+        throw new Error("usage: gith release --patch | --minor | --major");
+      release(kind);
+      break;
+    }
+    case "--version":
+      console.log(versionText());
+      break;
+    case undefined:
+    case "help":
+    case "--help":
+      console.log(USAGE);
+      break;
+    default:
+      console.error(`Unknown command '${command}'.
+
+${USAGE}`);
+      exit(1);
+  }
+} catch (error) {
+  console.error(`❌ ${error instanceof Error ? error.message : error}`);
+  exit(1);
+}