@tertium/gith 0.1.1 → 0.3.0

package/README.md

@@ -35,10 +35,16 @@ gith create -r 1.2.0                # release/1.2.0 from develop
 gith create -h 1.2.1                # hotfix/1.2.1 from main
 gith create --release               # release, version = minor after the latest tag
 gith create --hotfix                # hotfix, version = patch after the latest tag
+gith switch                         # list local and origin branches, and switch to the one you pick
 gith switch -b login-redirect       # switch to the branch, creating it from develop if it is missing
 gith switch -commit 3f2a1b9         # detach HEAD at that commit, to look at old code
+gith switch --release               # switch to the newest release/* (local or origin); -r 1.9.0 for one version
+gith switch --hotfix                # switch to the newest hotfix/* (local or origin); -h 1.2.1 for one version
 gith update                         # merge origin/develop into this work branch
 gith merge                          # this branch into develop
+gith finish --current-release    # release the newest release/*: version, changelog, merge to main, tag, merge main to develop, then ask before deleting the branch
+gith finish --current-hotfix      # the same for the newest hotfix/*
+gith merge                          # pick the branch to merge, then the target from the list
 gith merge -r 1.2.0                 # this branch into release/1.2.0
 gith merge -h 1.2.1                 # this branch into hotfix/1.2.1
 gith merge --current-release        # this branch into the newest release/* (local or origin)
@@ -59,6 +65,7 @@ gith reset                          # discard uncommitted changes, then clean
 gith clean                          # remove untracked files and directories
 
 # Clean up branches (every removal shows what it will remove first)
+gith remove                         # pick branches to delete from the list (here and on origin)
 gith remove -b login-redirect       # delete the branch here and on origin (rm is an alias)
 gith remove -b login-redirect --local    # delete only the local branch
 gith remove -b login-redirect --remote   # delete only the origin branch
@@ -93,6 +100,8 @@ gith stat --last-week -limit 50     # the same for last week, looking at no more
 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
+gith changelog --dry-run            # preview the CHANGELOG.md entry for package.json's version
+gith changelog                      # write it as its own commit (docs(changelog): <version>); --no-commit only writes
 
 # Help
 gith help                           # full usage
@@ -139,7 +148,7 @@ Commands that choose between flags (for example `create -b`, `-r` and `-h`, or `
 - **`switch -b`** switches to a branch. If the branch exists neither locally nor on origin, it is created first, the same way as `create -b`, and then checked out.
 - **`switch -commit <sha>`** detaches HEAD at that commit so you can look at old code. It refuses a commit that does not exist, and it refuses while tracked files have changes (untracked files do not block it). It lists the files that block it, and points to `gith stash`. On a detached HEAD, `gith switch -b <name>` creates the branch at the current commit, so commits made there stay on it. It does not create or switch branches for other commits, so commits made on a detached HEAD are easy to lose: name a branch before you leave.
 - **`remove -b <branch>`** removes the branch on both sides: the local branch first (with `git branch -d`, so git refuses to delete an unmerged branch), then the origin branch. A side that does not exist is skipped, so a branch that lives only here is still removed. A name that exists in neither place is an error. `--local` touches only this clone; `--remote` touches only origin. Containers (`develop`, `main`, `release/*`, `hotfix/*`) are refused.
-- **`remove --branch`** with no name lists the branches and asks which to remove. By default it lists branch pairs, meaning branches that exist both here and on origin. `--local` lists local branches and `--remote` lists origin branches. Each choice is removed on the same sides as above. `-limit <n>` shows only the first `n` (all by default), and the picker numbers only those. Answer with numbers or ranges, such as `1,3-4`; an empty answer cancels. The list needs a terminal, and that is checked before anything is listed. The checked-out branch and containers are never listed. Choosing items is the confirmation, so nothing else is asked. If a delete fails (for example, an unmerged branch), the removal stops there and earlier picks stay deleted.
+- **`remove`** with no name opens the list of branches and asks which to remove, the same as `remove --branch`. By default it lists branch pairs, meaning branches that exist both here and on origin. `--local` lists local branches and `--remote` lists origin branches. Each choice is removed on the same sides as above. `-limit <n>` shows only the first `n` (all by default), and the picker numbers only those. Pick with the arrow keys: up and down move, space checks an item, enter confirms the checked items, and esc cancels. `switch` takes one item with enter. The list needs a terminal, and that is checked before anything is listed. The checked-out branch and containers are never listed. Choosing items is the confirmation, so nothing else is asked. If a delete fails (for example, an unmerged branch), the removal stops there and earlier picks stay deleted.
 - **`status`** prints the branch and how far it is ahead of or behind its origin branch, then counts staged, unstaged, untracked and conflicting files. It changes nothing.
 - **`update`** fetches `origin/develop` and merges it into the current work branch. It needs a clean working tree and refuses containers. If the merge conflicts, it aborts the merge and says so. It does not push.
 - **`undo`** runs `git reset --soft HEAD~1`: the last commit is removed and its changes stay staged. It refuses when HEAD is already on origin, because undoing a pushed commit needs a force-push.
@@ -174,6 +183,8 @@ Commands that choose between flags (for example `create -b`, `-r` and `-h`, or `
 - **`create -r` / `create -h`** creates a container from its base (`develop` for release, `main` for hotfix), refusing names that already exist on origin. Like `create -b`, it does not switch.
 - **With `--release` or `--hotfix` (no value)**, the version is worked out from the highest `vX.Y.Z` tag across local tags and origin: `-r` takes the next minor (`1.2.1` → `1.3.0`), `-h` takes the next patch (`1.2.1` → `1.2.2`). With no tags yet, the first release is `0.1.0` and the first hotfix `0.0.1`. The version is printed before the branch is created.
 - **`merge --current-release`** and **`--current-hotfix`** pick the newest `release/*` or `hotfix/*` branch by version (numbers compare as numbers, so `1.10.0` beats `1.9.0`), checking both local branches and origin, and merge into it. The target must exist on origin, because the merge pushes it; a newest branch that only exists here stops the command with a message.
+- **`finish --current-release`** (and `--current-hotfix`) releases the newest `release/*` (or `hotfix/*`), named by its version X.Y.Z. It makes `package.json`'s version match the name (committed as `X.Y.Z`, only when they differ), adds the changelog entry as its own commit (when it is missing), merges the branch into `main` with `--no-ff`, tags `vX.Y.Z` and pushes, merges `main` into `develop` when `develop` exists on origin, and then asks before deleting the branch. A conflict aborts the merge and stops. Projects without a `package.json` keep their version by hand.
+- **`merge`** with no flags asks which branch to merge and which target to merge it into (develop, release/*, hotfix/*), with the arrow keys. After a merge into a target, the work branch is deleted here and on origin, after a Y/n question. Without a terminal, or on a no, it is kept. Release and hotfix branches are never deleted this way.
 - **`merge`** pushes the work branch, merges the target into it first (so conflicts happen on the work branch and are aborted cleanly), then merges it into the target with `--no-ff`, pushes, and checks that both branches match origin.
 
 Containers (`develop`, `main`, `release/*`, `hotfix/*`) can't be merged from, and only `develop`, `release/*` and `hotfix/*` can be merged into.

package/bin/gith.js

@@ -28,9 +28,11 @@ var SPECS = new Map([
   ["stashes", "switch"],
   ["current-release", "switch"],
   ["current-hotfix", "switch"],
+  ["develop", "switch"],
   ["pockets", "switch"],
   ["detached", "switch"],
   ["all", "switch"],
+  ["no-commit", "switch"],
   ["overall", "switch"],
   ["current-year", "switch"],
   ["current-month", "switch"],
@@ -119,6 +121,10 @@ function onlyOne(flags, names) {
   return present[0];
 }
 
+// src/components/changelog/changelog.ts
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+
 // src/components/git/git.ts
 import { execFileSync } from "node:child_process";
 var verbose = false;
@@ -216,6 +222,92 @@ function act(args, options = {}) {
   execFileSync("git", args, { stdio: "inherit", ...options });
 }
 
+// src/components/changelog/changelog.constants.ts
+var CHANGELOG_FILE_NAME = "CHANGELOG.md";
+var CHANGELOG_TITLE = "# Changelog";
+var SEMVER_ONLY_PATTERN = /^\d+\.\d+\.\d+$/;
+
+// src/components/changelog/changelog.utils.ts
+function filterCommitSubjects(rawLog) {
+  if (!rawLog.trim())
+    return [];
+  return rawLog.split(`
+`).map((line) => line.trim()).filter((line) => line.length > 0 && !SEMVER_ONLY_PATTERN.test(line));
+}
+function buildEntry(notes) {
+  const bullets = notes.subjects.length > 0 ? notes.subjects.map((subject) => `- ${subject}`).join(`
+`) : "- (no changes recorded)";
+  return `## ${notes.version} - ${notes.date}
+
+${bullets}
+`;
+}
+function mergeChangelogContent(existing, entry) {
+  const heading = `${CHANGELOG_TITLE}
+`;
+  if (existing === null)
+    return `${heading}
+${entry}
+`;
+  const body = existing.startsWith(heading) ? existing.slice(heading.length).replace(/^\n+/, "") : existing;
+  return `${heading}
+${entry}
+${body}`;
+}
+function parsePackageVersion(rawPackageJson) {
+  const pkg = JSON.parse(rawPackageJson);
+  if (!pkg.version)
+    throw new Error('No "version" field found in package.json');
+  return pkg.version;
+}
+function todayIso(date = new Date) {
+  return date.toISOString().slice(0, 10);
+}
+
+// src/components/changelog/changelog.ts
+function previousTag() {
+  try {
+    return captureArgs(["describe", "--tags", "--abbrev=0"]);
+  } catch {
+    return null;
+  }
+}
+function commitSubjectsSince(tag) {
+  const range = tag ? `${tag}..HEAD` : "HEAD";
+  return filterCommitSubjects(captureArgs(["log", range, "--no-merges", "--pretty=format:%s"]));
+}
+function changelog(flags) {
+  const noCommit = flags.has("no-commit");
+  if (flags.size > (noCommit ? 1 : 0))
+    throw new Error("usage: gith changelog [--dry-run] [--no-commit]");
+  const root = process.cwd();
+  const version = parsePackageVersion(readFileSync(path.join(root, "package.json"), "utf8"));
+  const entry = buildEntry({
+    version,
+    date: todayIso(),
+    subjects: commitSubjectsSince(previousTag())
+  });
+  if (isDryRun()) {
+    console.log(entry);
+    console.log(`dry run: would update ${CHANGELOG_FILE_NAME}`);
+    return;
+  }
+  const file = path.join(root, CHANGELOG_FILE_NAME);
+  const existing = existsSync(file) ? readFileSync(file, "utf8") : null;
+  writeFileSync(file, mergeChangelogContent(existing, entry));
+  console.log(`✅ ${CHANGELOG_FILE_NAME} updated for ${version}`);
+  if (noCommit)
+    return;
+  gitArgs(["add", "--", CHANGELOG_FILE_NAME]);
+  gitArgs([
+    "commit",
+    "-m",
+    `docs(changelog): ${version}`,
+    "--",
+    CHANGELOG_FILE_NAME
+  ]);
+}
+
 // src/components/doctor/doctor.utils.ts
 function check(name, test, failure = "fail") {
   return {
@@ -336,6 +428,124 @@ function find(flags) {
 `));
 }
 
+// src/components/flow/flow.ts
+import { execSync } from "node:child_process";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+
+// src/components/prompt/prompt.ts
+import { emitKeypressEvents } from "node:readline";
+import { createInterface } from "node:readline/promises";
+
+// src/components/prompt/prompt.utils.ts
+function moveIndex(index, delta, length) {
+  if (length <= 0)
+    return 0;
+  return ((index + delta) % length + length) % length;
+}
+function toggled(checked, index) {
+  const next = new Set(checked);
+  if (next.has(index))
+    next.delete(index);
+  else
+    next.add(index);
+  return next;
+}
+
+// src/components/prompt/prompt.ts
+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();
+  }
+}
+async function select(question, options, multi) {
+  if (!process.stdin.isTTY)
+    throw new Error("this needs a terminal to pick.");
+  return new Promise((resolve) => {
+    const stdin = process.stdin;
+    let index = 0;
+    let checked = new Set;
+    let drawnLines = 0;
+    const draw = () => {
+      if (drawnLines > 0)
+        process.stdout.write(`\x1B[${drawnLines}A\x1B[0J`);
+      const hint = multi ? "space checks, enter confirms, esc cancels" : "enter selects, esc cancels";
+      const lines = [`${question} (${hint})`];
+      options.forEach((option, i) => {
+        const cursor = i === index ? ">" : " ";
+        const mark = multi ? checked.has(i) ? "[x]" : "[ ]" : "";
+        lines.push(`${cursor} ${mark} ${option.label}`.replace(/ +$/, ""));
+      });
+      process.stdout.write(`${lines.join(`
+`)}
+`);
+      drawnLines = lines.length;
+    };
+    const finish = (picked) => {
+      stdin.off("keypress", onKey);
+      stdin.setRawMode(false);
+      stdin.pause();
+      process.stdout.write(`
+`);
+      resolve(picked);
+    };
+    const onKey = (_text, key) => {
+      if (!key)
+        return;
+      if (key.ctrl && key.name === "c" || key.name === "escape") {
+        finish([]);
+        return;
+      }
+      if (key.name === "return") {
+        const picked = multi ? [...checked].sort((a, b) => a - b).map((i) => options[i]?.name ?? "") : [options[index]?.name ?? ""];
+        finish(picked.filter(Boolean));
+        return;
+      }
+      if (key.name === "up")
+        index = moveIndex(index, -1, options.length);
+      else if (key.name === "down")
+        index = moveIndex(index, 1, options.length);
+      else if (key.name === "space" && multi)
+        checked = toggled(checked, index);
+      draw();
+    };
+    emitKeypressEvents(stdin);
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.on("keypress", onKey);
+    draw();
+  });
+}
+
 // src/components/rules/rules.constants.ts
 var CONTAINER = /^(develop|main|release\/.+|hotfix\/.+)$/;
 var TARGET = /^(develop|release\/.+|hotfix\/.+)$/;
@@ -443,15 +653,20 @@ function create(flags) {
   }
   open(kind, value || nextContainerVersion(kind));
 }
-function merge(flags) {
+async function merge(flags) {
+  if (flags.size === 0)
+    return mergePick();
   const kind = onlyOne(flags, [
+    "develop",
     "release",
     "hotfix",
     "current-release",
     "current-hotfix"
   ]);
   let target = "develop";
-  if (kind === "current-release")
+  if (kind === "develop")
+    target = "develop";
+  else if (kind === "current-release")
     target = newestContainer("release");
   else if (kind === "current-hotfix")
     target = newestContainer("hotfix");
@@ -462,7 +677,7 @@ function merge(flags) {
     }
     target = containerName(kind, version);
   }
-  mergeInto(target);
+  await mergeInto(target);
 }
 function createBranch(goal, from) {
   if (isContainer(goal))
@@ -477,10 +692,11 @@ function createBranch(goal, from) {
   }
   gitArgs(["push", "-u", "origin", goal]);
 }
-function mergeInto(target) {
+async function mergeInto(target, from) {
   if (!isTarget(target))
     throw new Error(`'${target}' is not a valid target.`);
-  const source = capture("rev-parse --abbrev-ref HEAD");
+  const current = capture("rev-parse --abbrev-ref HEAD");
+  const source = from ?? current;
   if (isContainer(source))
     throw new Error(`'${source}' is a container and cannot be merged from.`);
   if (source === target)
@@ -488,6 +704,8 @@ function mergeInto(target) {
   if (!hasOnOrigin(target))
     throw new Error(`'${target}' does not exist on origin.`);
   assertCleanTree();
+  if (source !== current)
+    gitArgs(["switch", "--", source]);
   if (hasOnOrigin(source))
     git(`pull origin ${source}`);
   git(`push -u origin ${source}`);
@@ -507,44 +725,116 @@ function mergeInto(target) {
   assertSynced([target, source]);
   console.log(`
 ✅ '${source}' merged into '${target}', both in sync with origin.`);
+  await deleteMergedBranch(source);
 }
-
-// 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 });
+async function deleteMergedBranch(source) {
+  const local = hasLocal(source);
+  const origin = hasOnOrigin(source);
+  let yes;
   try {
-    const answer = (await rl.question(question)).trim().toLowerCase();
-    return answer === "" || answer === "y" || answer === "yes";
-  } finally {
-    rl.close();
+    yes = await confirm(`Delete '${source}' here and on origin, it is merged? [Y/n] `);
+  } catch {
+    yes = false;
+  }
+  if (!yes) {
+    console.log(`'${source}' kept.`);
+    return;
   }
+  if (local)
+    gitArgs(["branch", "-d", "--", source]);
+  if (origin)
+    gitArgs(["push", "origin", "--delete", source]);
 }
-async function ask(question) {
+async function mergePick() {
+  if (!process.stdin.isTTY) {
+    throw new Error("pass -r <version> or -h <version> instead; the pickers need a terminal");
+  }
+  const current = capture("rev-parse --abbrev-ref HEAD");
+  const local = captureArgs([
+    "for-each-ref",
+    "--format=%(refname:short)",
+    "refs/heads"
+  ]).split(`
+`).filter(Boolean);
+  const sources = local.filter((name) => !isContainer(name)).sort((a, b) => a.localeCompare(b)).map((name) => ({
+    name,
+    label: name === current ? `${name}  (current)` : name
+  }));
+  if (sources.length === 0)
+    throw new Error("no work branch to merge.");
+  const [source] = await select("Which branch to merge?", sources, false);
+  if (source === undefined)
+    return;
+  const origin = captureArgs(["ls-remote", "--heads", "origin"]).split(`
+`).map((line) => (line.split("\t")[1] ?? "").replace(/^refs\/heads\//, "")).filter(Boolean);
+  const targets = [...new Set([...local, ...origin])].filter((name) => isTarget(name) && name !== source).sort((a, b) => a.localeCompare(b)).map((name) => ({
+    name,
+    label: local.includes(name) ? name : `${name}  (origin)`
+  }));
+  if (targets.length === 0)
+    throw new Error("no develop, release or hotfix branch to merge into.");
+  const [target] = await select(`Merge '${source}' into which?`, targets, false);
+  if (target === undefined)
+    return;
+  await mergeInto(target, source);
+}
+function alignVersion(version) {
+  if (!existsSync2("package.json"))
+    return;
+  const current = parsePackageVersion(readFileSync2("package.json", "utf8"));
+  if (current === version)
+    return;
   if (isDryRun()) {
-    console.log(`dry run: would ask: ${question}`);
-    return "<message>";
+    console.log(`> npm version ${version} --no-git-tag-version --ignore-scripts`);
+  } else {
+    execSync(`npm version ${version} --no-git-tag-version --ignore-scripts`, {
+      stdio: "inherit"
+    });
   }
-  if (!process.stdin.isTTY)
-    throw new Error("needs a terminal to ask; pass -m <message>.");
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  gitArgs(["add", "--", "package.json"]);
+  gitArgs(["commit", "-m", version, "--", "package.json"]);
+}
+function addChangelogEntry(version) {
+  if (!existsSync2("package.json"))
+    return;
+  const file = "CHANGELOG.md";
+  if (existsSync2(file) && readFileSync2(file, "utf8").includes(`## ${version} - `))
+    return;
+  changelog(new Map);
+}
+async function finish(flags) {
+  const kind = onlyOne(flags, ["current-release", "current-hotfix"]);
+  if (!kind || flags.size > 1)
+    throw new Error("usage: gith finish --current-release | --current-hotfix");
+  const containerKind = kind === "current-release" ? "release" : "hotfix";
+  const branch = newestContainer(containerKind);
+  const version = branch.slice(containerKind.length + 1);
+  if (parseSemver(version) === undefined)
+    throw new Error(`'${branch}' is not named with a version (X.Y.Z).`);
+  assertCleanTree();
+  gitArgs(["switch", "--", branch]);
+  gitArgs(["pull", "--ff-only", "origin", branch]);
+  alignVersion(version);
+  addChangelogEntry(version);
+  gitArgs(["switch", "--", "main"]);
+  gitArgs(["pull", "--ff-only", "origin", "main"]);
   try {
-    return (await rl.question(question)).trim();
-  } finally {
-    rl.close();
+    gitArgs(["merge", "--no-ff", branch, "-m", `Merge '${branch}' into main`]);
+  } catch {
+    gitArgs(["merge", "--abort"]);
+    throw new Error(`merging '${branch}' into main conflicts; resolve it by hand, then retry.`);
+  }
+  gitArgs(["tag", "-a", `v${version}`, "-m", `v${version}`]);
+  gitArgs(["push", "origin", "main"]);
+  gitArgs(["push", "origin", `v${version}`]);
+  if (hasOnOrigin("develop")) {
+    gitArgs(["switch", "--", "develop"]);
+    gitArgs(["pull", "--ff-only", "origin", "develop"]);
+    gitArgs(["merge", "--no-edit", "main"]);
+    gitArgs(["push", "origin", "develop"]);
   }
+  gitArgs(["switch", "--", "main"]);
+  await deleteMergedBranch(branch);
 }
 
 // src/components/history/history.utils.ts
@@ -771,7 +1061,7 @@ function stashes(limit, withGorlum) {
   ]).split(`
 `).filter(Boolean);
   if (rows.length === 0) {
-    console.log("No stashes.");
+    console.log(withGorlum ? "There is nothing in my pockets!" : "No stashes.");
     return;
   }
   const shown = rows.slice(0, limit);
@@ -802,9 +1092,6 @@ function originTags() {
 `).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;
 
@@ -853,7 +1140,21 @@ function parsePositive(flags, name) {
 }
 
 // src/components/maintenance/maintenance.ts
-function switchBranch(flags) {
+async function switchBranch(flags) {
+  if (flags.size === 0)
+    return switchPick();
+  const kind = onlyOne(flags, ["release", "hotfix"]);
+  if (kind !== undefined) {
+    if (flags.size > 1)
+      throw new Error(`usage: gith switch --${kind} | -${kind === "release" ? "r" : "h"} <version>`);
+    const version = flags.get(kind) ?? "";
+    const name = version === "" ? newestContainer(kind) : containerName(kind, version);
+    if (!hasLocal(name) && !hasOnOrigin(name)) {
+      throw new Error(`'${name}' does not exist, locally or on origin.`);
+    }
+    gitArgs(["switch", "--", name]);
+    return;
+  }
   const commit = flags.get("commit");
   if (commit !== undefined) {
     if (flags.has("branch") || flags.size > 1)
@@ -878,20 +1179,6 @@ function candidates(scope, local, remote, current) {
   }
   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(`
@@ -937,7 +1224,7 @@ function detachedOptions(times, current) {
   return options.sort((x, y) => x.name.localeCompare(y.name));
 }
 async function remove(flags) {
-  const name = flags.get("branch");
+  const name = flags.get("branch") ?? "";
   const side = onlyOne(flags, ["local", "remote"]);
   const scope = side ?? "pair";
   const obsoleteOn = flags.has("obsolete");
@@ -950,14 +1237,12 @@ async function remove(flags) {
     throw new Error("--all only applies to --detached.");
   if (obsoleteOn || detachedOn) {
     const usage = detachedOn ? "usage: gith remove --detached [--all | -l <n>]" : "usage: gith remove --obsolete [--local] [-days <n>] [-l <n>]";
-    if (name !== undefined || obsoleteOn && side === "remote" || detachedOn && side)
+    if (flags.has("branch") || 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.");
@@ -1012,25 +1297,49 @@ async function clean(flags) {
   }
   gitArgs(["clean", "-fd"]);
 }
-async function choose(options, limit) {
+var REMOVE_ACTION = {
+  empty: "No branches to remove.",
+  prompt: "Remove which?",
+  multi: true
+};
+async function choose(options, limit, action = REMOVE_ACTION) {
   if (options.length === 0) {
-    console.log("No branches to remove.");
+    console.log(action.empty);
     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();
+  return select(action.prompt, shown, action.multi);
+}
+function switchOptions() {
+  const local = localBranches();
+  const origin = remoteBranches();
+  const current = currentBranch2();
+  const names = [...new Set([...local, ...origin])].sort((a, b) => a.localeCompare(b));
+  return names.map((name) => {
+    const where = local.includes(name) && origin.includes(name) ? "local + origin" : local.includes(name) ? "local" : "origin";
+    return {
+      name,
+      label: `${name}  (${where}${name === current ? ", current" : ""})`
+    };
+  });
+}
+async function switchPick() {
+  if (!process.stdin.isTTY) {
+    throw new Error("pass a branch name with -b, e.g. gith switch -b <branch>; the list needs a terminal");
   }
+  const picked = await choose(switchOptions(), undefined, {
+    empty: "No branches.",
+    prompt: "Switch to which?",
+    multi: false
+  });
+  if (picked.length === 0)
+    return;
+  if (picked.length > 1)
+    throw new Error("pick exactly one branch to switch to.");
+  gitArgs(["switch", "--", picked[0] ?? ""]);
 }
 function requireTerminal() {
   if (!process.stdin.isTTY) {
@@ -1056,14 +1365,14 @@ async function removeBranches(scope, names, ask = true) {
   });
   if (plan.length > 0)
     console.log("Will remove:");
-  if (ask && 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})`);
   }
+  if (ask && 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) {
     if (local)
       gitArgs(["branch", "-d", "--", name]);
@@ -1173,12 +1482,12 @@ function openerFor(platform, url) {
 var KINDS = ["patch", "minor", "major"];
 
 // src/components/release/release.utils.ts
-import { execSync } from "node:child_process";
+import { execSync as execSync2 } from "node:child_process";
 function npmVersion(kind) {
   console.log(`> npm version ${kind}`);
   if (isDryRun())
     return;
-  execSync(`npm version ${kind}`, { stdio: "inherit" });
+  execSync2(`npm version ${kind}`, { stdio: "inherit" });
 }
 
 // src/components/release/release.ts
@@ -1569,7 +1878,7 @@ function tree(flags) {
 }
 
 // src/components/version/version.ts
-import { readFileSync as readFileSync2 } from "node:fs";
+import { readFileSync as readFileSync4 } from "node:fs";
 
 // src/components/version/version.constants.ts
 var MASCOT = [
@@ -1584,19 +1893,19 @@ var MASCOT = [
 ];
 
 // src/components/version/version.utils.ts
-import { existsSync, readFileSync } from "node:fs";
-import path from "node:path";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
+import path2 from "node:path";
 import { fileURLToPath } from "node:url";
 function packageJsonPath() {
-  let dir = path.dirname(fileURLToPath(import.meta.url));
+  let dir = path2.dirname(fileURLToPath(import.meta.url));
   for (;; ) {
-    const candidate = path.join(dir, "package.json");
-    if (existsSync(candidate)) {
-      const pkg = JSON.parse(readFileSync(candidate, "utf8"));
+    const candidate = path2.join(dir, "package.json");
+    if (existsSync3(candidate)) {
+      const pkg = JSON.parse(readFileSync3(candidate, "utf8"));
       if (pkg.name === "@tertium/gith")
         return candidate;
     }
-    const parent = path.dirname(dir);
+    const parent = path2.dirname(dir);
     if (parent === dir)
       throw new Error("gith package.json not found");
     dir = parent;
@@ -1605,7 +1914,7 @@ function packageJsonPath() {
 
 // src/components/version/version.ts
 function readVersion() {
-  const pkg = JSON.parse(readFileSync2(packageJsonPath(), "utf8"));
+  const pkg = JSON.parse(readFileSync4(packageJsonPath(), "utf8"));
   return pkg.version ?? "unknown";
 }
 function versionText() {
@@ -1623,9 +1932,14 @@ Start and finish work
   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                        list local and origin branches, and switch to the one picked
   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 switch --release | --hotfix   switch to the newest release/* or hotfix/* (local or origin); -r <v> / -h <v> for one version
   gith update                        merge origin/develop into this work branch
+  gith finish --current-release | --current-hotfix  release the newest release/* or hotfix/*: version, changelog, merge to main, tag, back to develop
+  gith merge --develop               merge this branch into develop
+  gith merge                         pick the branch to merge, then the target (develop, release/*, hotfix/*)
   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)
@@ -1646,7 +1960,8 @@ 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                        pick branches to delete from a list (here and on origin)
+  gith remove --branch [-l <n>]      same list, for 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
@@ -1670,6 +1985,7 @@ 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)
+  gith changelog [--dry-run]         add an entry for package.json's version to CHANGELOG.md (commits since the last tag)
 
 Help
   gith help                          show this help
@@ -1702,11 +2018,14 @@ try {
     case "create":
       create(parseFlags(rest));
       break;
+    case "finish":
+      await finish(parseFlags(rest));
+      break;
     case "merge":
-      merge(parseFlags(rest));
+      await merge(parseFlags(rest));
       break;
     case "switch":
-      switchBranch(parseFlags(rest));
+      await switchBranch(parseFlags(rest));
       break;
     case "remove":
     case "rm":
@@ -1753,6 +2072,9 @@ try {
     case "open":
       open2(parseFlags(rest));
       break;
+    case "changelog":
+      changelog(parseFlags(rest));
+      break;
     case "doctor":
       if (!doctor(parseFlags(rest)))
         exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tertium/gith",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "description": "Git helper: branch flow with goal branches, release and hotfix containers, and everyday git commands.",
   "type": "module",
   "bin": {
@@ -18,7 +18,8 @@
     "typecheck": "tsc --noEmit",
     "release:patch": "node bin/gith.js release --patch",
     "release:minor": "node bin/gith.js release --minor",
-    "release:major": "node bin/gith.js release --major"
+    "release:major": "node bin/gith.js release --major",
+    "version": "bun run build && node bin/gith.js changelog"
   },
   "license": "ISC",
   "author": "Vitalii Balabanov",