gflows 0.1.12 → 0.1.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gflows",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "description": "A lightweight CLI for consistent Git branching workflows (main + dev, feature/bugfix/chore/release/hotfix).",
   "license": "MIT",
   "type": "module",
@@ -10,7 +10,10 @@
   },
   "scripts": {
     "test": "bun test",
-    "lint": "tsc --noEmit",
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check .",
+    "lint:fix": "biome check . --write",
+    "format": "biome format . --write",
     "gflows": "bun run src/cli.ts",
     "publish:all": "bun run scripts/publish.ts",
     "publish:npm": "bun run scripts/publish.ts -- --npm-only",
@@ -33,6 +36,7 @@
     "@inquirer/prompts": "^8"
   },
   "devDependencies": {
+    "@biomejs/biome": "^2.4.4",
     "@types/bun": "latest",
     "typescript": "^5"
   }

package/src/cli.ts

@@ -9,9 +9,9 @@
 import { existsSync, statSync } from "node:fs";
 import { resolve } from "node:path";
 import { parseArgs } from "node:util";
-import type { Command, BranchType, ParsedArgs } from "./types.js";
-import { EXIT_OK, EXIT_USER, EXIT_GIT } from "./constants.js";
+import { EXIT_GIT, EXIT_OK, EXIT_USER } from "./constants.js";
 import { exitCodeForError } from "./errors.js";
+import type { BranchType, Command, ParsedArgs } from "./types.js";
 
 /** Last parsed args, set at start of run(); used by catch/rejection to respect -v for stack trace. */
 let lastParsedArgs: ParsedArgs | null = null;
@@ -30,14 +30,7 @@ const COMMANDS: Command[] = [
   "version",
 ];
 
-const BRANCH_TYPES: BranchType[] = [
-  "feature",
-  "bugfix",
-  "chore",
-  "release",
-  "hotfix",
-  "spike",
-];
+const BRANCH_TYPES: BranchType[] = ["feature", "bugfix", "chore", "release", "hotfix", "spike"];
 
 /** Short flag → command (when used as main command). */
 const SHORT_TO_COMMAND: Record<string, Command> = {
@@ -80,6 +73,7 @@ function buildParseArgsOptions() {
       // Common
       push: { type: "boolean" as const, short: "p" },
       noPush: { type: "boolean" as const, short: "P" },
+      "no-push": { type: "boolean" as const },
       main: { type: "string" as const },
       dev: { type: "string" as const },
       remote: { type: "string" as const, short: "R" },
@@ -123,12 +117,57 @@ function resolveCwd(pathFlag: string | undefined): string {
   return absolute;
 }
 
+/**
+ * Returns the command name closest to `input` by edit distance, or undefined if no close match.
+ * Used for "did you mean?" when the user mistypes a command.
+ */
+function closestCommand(input: string): Command | undefined {
+  if (!input || input.length < 2) return undefined;
+  const target = input.toLowerCase();
+  let best: Command | undefined;
+  let bestDistance = 3; // only suggest if within 2 edits
+  for (const cmd of COMMANDS) {
+    const d = editDistance(target, cmd);
+    if (d < bestDistance) {
+      bestDistance = d;
+      best = cmd as Command;
+    }
+  }
+  return best;
+}
+
+/** Levenshtein edit distance between two strings. */
+function editDistance(a: string, b: string): number {
+  const m = a.length;
+  const n = b.length;
+  const dp: number[][] = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
+  for (let i = 0; i <= m; i++) {
+    const row = dp[i];
+    if (row) row[0] = i;
+  }
+  for (let j = 0; j <= n; j++) {
+    const row = dp[0];
+    if (row) row[j] = j;
+  }
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      const v1 = dp[i - 1]?.[j] ?? 0;
+      const v2 = dp[i]?.[j - 1] ?? 0;
+      const v3 = dp[i - 1]?.[j - 1] ?? 0;
+      const rowI = dp[i];
+      if (rowI) rowI[j] = Math.min(v1 + 1, v2 + 1, v3 + cost);
+    }
+  }
+  return dp[m]?.[n] ?? 0;
+}
+
 /** Resolve command from positionals and short flags. Short wins if both present. */
 function resolveCommand(
   positionals: string[],
-  values: Record<string, string | boolean | undefined>
+  values: Record<string, string | boolean | undefined>,
 ): Command | undefined {
-  for (const [short, cmd] of Object.entries(SHORT_TO_COMMAND)) {
+  for (const [_short, cmd] of Object.entries(SHORT_TO_COMMAND)) {
     const key = cmd === "delete" ? "delete" : cmd;
     if (values[key] === true) return cmd as Command;
   }
@@ -143,7 +182,7 @@ function resolveCommand(
 function resolveType(
   command: Command,
   positionals: string[],
-  values: Record<string, string | boolean | undefined>
+  values: Record<string, string | boolean | undefined>,
 ): BranchType | undefined {
   if (command !== "start" && command !== "finish" && command !== "list") {
     return undefined;
@@ -179,7 +218,7 @@ function resolveType(
 function resolveName(
   command: Command,
   positionals: string[],
-  values: Record<string, string | boolean | undefined>
+  values: Record<string, string | boolean | undefined>,
 ): string | undefined {
   const branch = values.branch;
   if (typeof branch === "string" && branch.trim() !== "") {
@@ -200,7 +239,7 @@ function resolveName(
   }
   if (command === "bump") {
     const dir = positionals[skip];
-    const typ = positionals[skip + 1];
+    const _typ = positionals[skip + 1];
     if (dir === "up" || dir === "down") {
       return dir;
     }
@@ -215,7 +254,7 @@ function resolveName(
 /** Resolve bump direction and type from positionals (bump [up|down] [patch|minor|major]). */
 function resolveBump(
   positionals: string[],
-  values: Record<string, string | boolean | undefined>
+  _values: Record<string, string | boolean | undefined>,
 ): { direction?: "up" | "down"; type?: "patch" | "minor" | "major" } {
   const skip = positionals[0] === "bump" ? 1 : 0;
   const a = positionals[skip];
@@ -240,7 +279,13 @@ export function parse(argv: string[] = Bun.argv.slice(2)): ParsedArgs {
 
   const command = resolveCommand(positionals, v);
   if (!command) {
-    console.error("gflows: missing command. Use 'gflows help' for usage.");
+    const first = positionals[0];
+    const suggestion = typeof first === "string" ? closestCommand(first) : undefined;
+    if (suggestion) {
+      console.error(`gflows: unknown command '${first}'. Did you mean '${suggestion}'?`);
+    } else {
+      console.error("gflows: missing command. Use 'gflows help' for usage.");
+    }
     process.exit(EXIT_USER);
   }
 
@@ -259,9 +304,7 @@ export function parse(argv: string[] = Bun.argv.slice(2)): ParsedArgs {
   // -r context: for list → includeRemote; for start/finish → already used as type release
   const includeRemote =
     command === "list"
-      ? (v.includeRemote === true ||
-         v["include-remote"] === true ||
-         v.release === true)
+      ? v.includeRemote === true || v["include-remote"] === true || v.release === true
       : false;
 
   let completionShell: "bash" | "zsh" | "fish" | undefined;
@@ -279,7 +322,7 @@ export function parse(argv: string[] = Bun.argv.slice(2)): ParsedArgs {
     bumpDirection,
     bumpType,
     push: v.push === true,
-    noPush: v.noPush === true,
+    noPush: v.noPush === true || v["no-push"] === true,
     main: typeof v.main === "string" && v.main.trim() !== "" ? v.main.trim() : undefined,
     dev: typeof v.dev === "string" && v.dev.trim() !== "" ? v.dev.trim() : undefined,
     remote: typeof v.remote === "string" ? v.remote : undefined,

package/src/commands/bump.ts

@@ -1,20 +1,51 @@
 /**
- * Bump command: bump or rollback root package version (patch/minor/major).
+ * Bump command: bump or rollback package version (patch/minor/major).
+ * Supports monorepos: discovers all package.json and jsr.json under cwd and bumps them to the same version.
  * Keeps package.json and jsr.json in sync; no git operations.
  * @module commands/bump
  */
 
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import type { ParsedArgs } from "../types.js";
-import type { BumpDirection, BumpType } from "../types.js";
+import { existsSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { join, relative } from "node:path";
 import { EXIT_OK, EXIT_USER } from "../constants.js";
 import { InvalidVersionError } from "../errors.js";
 import { hint, success } from "../out.js";
+import type { BumpDirection, BumpType, ParsedArgs } from "../types.js";
 
 const PACKAGE_JSON = "package.json";
 const JSR_JSON = "jsr.json";
 
+/** Directory names to skip when discovering package roots (monorepo). */
+const SKIP_DIRS = new Set(["node_modules", ".git"]);
+
+/**
+ * Recursively finds all directories under `root` that contain a package.json.
+ * Skips node_modules and .git.
+ */
+function findPackageRoots(root: string): string[] {
+  const acc: string[] = [];
+  if (!existsSync(root) || !statSync(root, { throwIfNoEntry: false })?.isDirectory()) {
+    return acc;
+  }
+  if (existsSync(join(root, PACKAGE_JSON))) {
+    acc.push(root);
+  }
+  let entries: Array<{ isDirectory(): boolean; name: string }>;
+  try {
+    entries = readdirSync(root, { withFileTypes: true }) as Array<{
+      isDirectory(): boolean;
+      name: string;
+    }>;
+  } catch {
+    return acc;
+  }
+  for (const e of entries) {
+    if (!e.isDirectory() || SKIP_DIRS.has(e.name)) continue;
+    acc.push(...findPackageRoots(join(root, e.name)));
+  }
+  return acc;
+}
+
 /** Semver triplet. */
 interface Semver {
   major: number;
@@ -30,18 +61,16 @@ function parseVersion(version: string): Semver {
   const trimmed = version.trim();
   const normalized = trimmed.startsWith("v") ? trimmed.slice(1) : trimmed;
   const parts = normalized.split(".");
-  if (
-    parts.length !== 3 ||
-    parts.some((p) => !/^\d+$/.test(p))
-  ) {
+  if (parts.length !== 3 || parts.some((p) => !/^\d+$/.test(p))) {
     throw new InvalidVersionError(
-      `Invalid version '${version}'. Expected format: X.Y.Z or vX.Y.Z (e.g. 1.2.3 or v1.2.3).`
+      `Invalid version '${version}'. Expected format: X.Y.Z or vX.Y.Z (e.g. 1.2.3 or v1.2.3).`,
     );
   }
+  const [p0, p1, p2] = parts;
   return {
-    major: parseInt(parts[0]!, 10),
-    minor: parseInt(parts[1]!, 10),
-    patch: parseInt(parts[2]!, 10),
+    major: parseInt(p0 ?? "0", 10),
+    minor: parseInt(p1 ?? "0", 10),
+    patch: parseInt(p2 ?? "0", 10),
   };
 }
 
@@ -103,7 +132,7 @@ function readPackageVersion(dir: string): { raw: string; semver: Semver } {
   const path = join(dir, PACKAGE_JSON);
   if (!existsSync(path)) {
     throw new InvalidVersionError(
-      `No package.json found at ${path}. Run from project root or use -C <dir>.`
+      `No package.json found at ${path}. Run from project root or use -C <dir>.`,
     );
   }
   const raw = readFileSync(path, "utf-8");
@@ -111,7 +140,7 @@ function readPackageVersion(dir: string): { raw: string; semver: Semver } {
   const version = data.version;
   if (typeof version !== "string" || version.trim() === "") {
     throw new InvalidVersionError(
-      "package.json has no valid 'version' field."
+      'package.json has no valid \'version\' field. Add a "version" field (e.g. "0.0.0") to package.json.',
     );
   }
   const semver = parseVersion(version);
@@ -127,7 +156,7 @@ function writePackageVersion(dir: string, newVersion: string): void {
   const raw = readFileSync(path, "utf-8");
   const data = JSON.parse(raw) as Record<string, unknown>;
   data.version = newVersion;
-  writeFileSync(path, JSON.stringify(data, null, 2) + "\n", "utf-8");
+  writeFileSync(path, `${JSON.stringify(data, null, 2)}\n`, "utf-8");
 }
 
 /**
@@ -139,7 +168,7 @@ function syncJsrVersion(dir: string, newVersion: string): boolean {
   const raw = readFileSync(path, "utf-8");
   const data = JSON.parse(raw) as Record<string, unknown>;
   data.version = newVersion;
-  writeFileSync(path, JSON.stringify(data, null, 2) + "\n", "utf-8");
+  writeFileSync(path, `${JSON.stringify(data, null, 2)}\n`, "utf-8");
   return true;
 }
 
@@ -154,15 +183,14 @@ export async function run(args: ParsedArgs): Promise<void> {
   let direction: BumpDirection;
   let type: BumpType;
 
-  const isTTY =
-    typeof process.stdin.isTTY === "boolean" && process.stdin.isTTY;
+  const isTTY = typeof process.stdin.isTTY === "boolean" && process.stdin.isTTY;
 
   if (bumpDirection && bumpType) {
     direction = bumpDirection;
     type = bumpType;
   } else if (!isTTY) {
     console.error(
-      "gflows bump: when not in a TTY, both direction and type are required. Example: gflows bump up patch"
+      "gflows bump: when not in a TTY, both direction and type are required. Example: gflows bump up patch",
     );
     process.exit(EXIT_USER);
   } else {
@@ -184,14 +212,33 @@ export async function run(args: ParsedArgs): Promise<void> {
     });
   }
 
-  const { raw: oldVersion, semver } = readPackageVersion(cwd);
-  const newSemver =
-    direction === "up" ? bumpUp(semver, type) : bumpDown(semver, type);
+  let roots = findPackageRoots(cwd);
+  roots = [...roots].sort((a, b) => {
+    if (a === cwd && b !== cwd) return -1;
+    if (a !== cwd && b === cwd) return 1;
+    return a.localeCompare(b);
+  });
+  if (roots.length === 0) {
+    throw new InvalidVersionError(
+      `No package.json found under ${cwd}. Run from project root or use -C <dir>.`,
+    );
+  }
+  const primaryRoot = roots[0];
+  if (primaryRoot === undefined) {
+    throw new InvalidVersionError(
+      `No package.json found under ${cwd}. Run from project root or use -C <dir>.`,
+    );
+  }
+  const { raw: oldVersion, semver } = readPackageVersion(primaryRoot);
+  const newSemver = direction === "up" ? bumpUp(semver, type) : bumpDown(semver, type);
   const newVersion = formatVersion(newSemver);
 
-  const filesToUpdate: string[] = [PACKAGE_JSON];
-  if (existsSync(join(cwd, JSR_JSON))) {
-    filesToUpdate.push(JSR_JSON);
+  const filesToUpdate: string[] = [];
+  for (const dir of roots) {
+    filesToUpdate.push(relative(cwd, join(dir, PACKAGE_JSON)) || PACKAGE_JSON);
+    if (existsSync(join(dir, JSR_JSON))) {
+      filesToUpdate.push(relative(cwd, join(dir, JSR_JSON)) || JSR_JSON);
+    }
   }
 
   if (dryRun) {
@@ -202,15 +249,18 @@ export async function run(args: ParsedArgs): Promise<void> {
     process.exit(EXIT_OK);
   }
 
-  writePackageVersion(cwd, newVersion);
-  const jsrUpdated = syncJsrVersion(cwd, newVersion);
+  const updated: string[] = [];
+  for (const dir of roots) {
+    writePackageVersion(dir, newVersion);
+    updated.push(relative(cwd, join(dir, PACKAGE_JSON)) || PACKAGE_JSON);
+    if (syncJsrVersion(dir, newVersion)) {
+      updated.push(relative(cwd, join(dir, JSR_JSON)) || JSR_JSON);
+    }
+  }
 
   if (!quiet) {
     success(`Bumped version: ${oldVersion} → ${newVersion}`);
-    const updated = [PACKAGE_JSON];
-    if (jsrUpdated) updated.push(JSR_JSON);
     success(`Updated: ${updated.join(", ")}`);
-    // Hint: suggest next step — commit and start release branch
     hint("Commit the change, then run gflows start release vX.Y.Z to release.");
   }
 }

package/src/commands/completion.ts

@@ -5,8 +5,8 @@
  * @module commands/completion
  */
 
-import type { ParsedArgs } from "../types.js";
 import { EXIT_USER } from "../constants.js";
+import type { ParsedArgs } from "../types.js";
 
 const COMMANDS = [
   "init",
@@ -22,14 +22,7 @@ const COMMANDS = [
   "version",
 ];
 
-const BRANCH_TYPES = [
-  "feature",
-  "bugfix",
-  "chore",
-  "release",
-  "hotfix",
-  "spike",
-];
+const BRANCH_TYPES = ["feature", "bugfix", "chore", "release", "hotfix", "spike"];
 
 const COMPLETION_SHELLS = ["bash", "zsh", "fish"] as const;
 
@@ -46,7 +39,7 @@ function bashScript(): string {
 _gflows() {
   local cur prev words cword cmd_idx cmd
   words=(${D}COMP_WORDS[@]})
-  cword=\$COMP_CWORD
+  cword=$COMP_CWORD
   cur="${D}words[cword]:-}"
   prev="${D}words[cword-1]:-}"
 
@@ -72,58 +65,58 @@ _gflows() {
         break
       fi
     done
-    if [[ -n "\$path" ]]; then
-      gflows -C "\$path" list 2>/dev/null
+    if [[ -n "$path" ]]; then
+      gflows -C "$path" list 2>/dev/null
     else
       gflows list 2>/dev/null
     fi
   }
 
   # Completing -C/--path value: suggest directories
-  if [[ "\$prev" == "-C" ]] || [[ "\$prev" == "--path" ]]; then
+  if [[ "$prev" == "-C" ]] || [[ "$prev" == "--path" ]]; then
     compopt -o dirnames 2>/dev/null
-    COMPREPLY=($(compgen -d -S / -- "\$cur"))
+    COMPREPLY=($(compgen -d -S / -- "$cur"))
     return
   fi
 
   # First positional: command
   if (( cword == cmd_idx )); then
-    COMPREPLY=($(compgen -W "${COMMANDS.join(" ")}" -- "\$cur"))
+    COMPREPLY=($(compgen -W "${COMMANDS.join(" ")}" -- "$cur"))
     return
   fi
 
   # After command: type/name/branches/shell/bump by command
   case "$cmd" in
     completion)
-      COMPREPLY=($(compgen -W "${COMPLETION_SHELLS.join(" ")}" -- "\$cur"))
+      COMPREPLY=($(compgen -W "${COMPLETION_SHELLS.join(" ")}" -- "$cur"))
       ;;
     start)
       if (( cword == cmd_idx + 1 )); then
-        COMPREPLY=($(compgen -W "${BRANCH_TYPES.join(" ")}" -- "\$cur"))
+        COMPREPLY=($(compgen -W "${BRANCH_TYPES.join(" ")}" -- "$cur"))
       else
         COMPREPLY=()
       fi
       ;;
     finish)
-      if [[ "\$prev" == "-B" ]] || [[ "\$prev" == "--branch" ]]; then
-        COMPREPLY=($(compgen -W "$(_gflows_path)" -- "\$cur"))
+      if [[ "$prev" == "-B" ]] || [[ "$prev" == "--branch" ]]; then
+        COMPREPLY=($(compgen -W "$(_gflows_path)" -- "$cur"))
       elif (( cword == cmd_idx + 1 )); then
-        COMPREPLY=($(compgen -W "${BRANCH_TYPES.join(" ")}" -- "\$cur"))
+        COMPREPLY=($(compgen -W "${BRANCH_TYPES.join(" ")}" -- "$cur"))
       else
         COMPREPLY=()
       fi
       ;;
     list)
-      COMPREPLY=($(compgen -W "${BRANCH_TYPES.join(" ")}" -- "\$cur"))
+      COMPREPLY=($(compgen -W "${BRANCH_TYPES.join(" ")}" -- "$cur"))
       ;;
     switch|delete)
-      COMPREPLY=($(compgen -W "$(_gflows_path)" -- "\$cur"))
+      COMPREPLY=($(compgen -W "$(_gflows_path)" -- "$cur"))
       ;;
     bump)
       if (( cword == cmd_idx + 1 )); then
-        COMPREPLY=($(compgen -W "${BUMP_DIRECTIONS.join(" ")}" -- "\$cur"))
+        COMPREPLY=($(compgen -W "${BUMP_DIRECTIONS.join(" ")}" -- "$cur"))
       elif (( cword == cmd_idx + 2 )); then
-        COMPREPLY=($(compgen -W "${BUMP_TYPES.join(" ")}" -- "\$cur"))
+        COMPREPLY=($(compgen -W "${BUMP_TYPES.join(" ")}" -- "$cur"))
       else
         COMPREPLY=()
       fi
@@ -169,7 +162,7 @@ _gflows() {
 
   case $state in
     args)
-      cur=\$words[CURRENT]
+      cur=$words[CURRENT]
       cmd_idx=1
       while (( cmd_idx < CURRENT )); do
         if [[ "${D}words[cmd_idx]}" == "-C" ]] || [[ "${D}words[cmd_idx]}" == "--path" ]]; then
@@ -190,7 +183,7 @@ _gflows() {
           ;;
         finish)
           if [[ "${D}words[CURRENT-1]}" == "-B" ]] || [[ "${D}words[CURRENT-1]}" == "--branch" ]]; then
-            _values "branch" \$(_gflows_list_branches)
+            _values "branch" $(_gflows_list_branches)
           else
             _values "type" ${BRANCH_TYPES.map((t) => `"${t}"`).join(" ")}
           fi
@@ -199,7 +192,7 @@ _gflows() {
           _values "type" ${BRANCH_TYPES.map((t) => `"${t}"`).join(" ")}
           ;;
         switch|delete)
-          _values "branch" \$(_gflows_list_branches)
+          _values "branch" $(_gflows_list_branches)
           ;;
         bump)
           if [[ "${D}words[CURRENT-1]}" == "up" ]] || [[ "${D}words[CURRENT-1]}" == "down" ]]; then
@@ -326,9 +319,7 @@ complete -c gflows -f -n "__fish_seen_subcommand_from ${COMMANDS.join(" ")}" -l
 export async function run(args: ParsedArgs): Promise<void> {
   const shell = args.completionShell;
   if (!shell) {
-    console.error(
-      "gflows: completion requires a shell. Use: gflows completion bash | zsh | fish"
-    );
+    console.error("gflows: completion requires a shell. Use: gflows completion bash | zsh | fish");
     process.exit(EXIT_USER);
   }
 

package/src/commands/delete.ts

@@ -3,38 +3,24 @@
  * @module commands/delete
  */
 
-import type { BranchType } from "../types.js";
-import type { ParsedArgs } from "../types.js";
 import { resolveConfig } from "../config.js";
 import { EXIT_OK, EXIT_USER } from "../constants.js";
 import { CannotDeleteMainOrDevError, NotRepoError } from "../errors.js";
-import {
-  branchList,
-  deleteBranch,
-  resolveRepoRoot,
-} from "../git.js";
+import { branchList, deleteBranch, resolveRepoRoot } from "../git.js";
 import { hint, success } from "../out.js";
+import type { BranchType, ParsedArgs } from "../types.js";
 
-const BRANCH_TYPES: BranchType[] = [
-  "feature",
-  "bugfix",
-  "chore",
-  "release",
-  "hotfix",
-  "spike",
-];
+const BRANCH_TYPES: BranchType[] = ["feature", "bugfix", "chore", "release", "hotfix", "spike"];
 
 /**
  * Returns local branch names that match any workflow prefix (feature/, bugfix/, etc.).
  */
 function getWorkflowBranches(
   allBranches: string[],
-  prefixes: Record<BranchType, string>
+  prefixes: Record<BranchType, string>,
 ): string[] {
   const prefixed = BRANCH_TYPES.map((t) => prefixes[t]).filter(Boolean);
-  return allBranches.filter((b) =>
-    prefixed.some((p) => p && b.startsWith(p))
-  );
+  return allBranches.filter((b) => prefixed.some((p) => p && b.startsWith(p)));
 }
 
 /**
@@ -58,16 +44,12 @@ export async function run(args: ParsedArgs): Promise<void> {
   });
   const { main, dev, prefixes } = config;
 
-  const fromPositionals = (rawBranchNames ?? [])
-    .map((s) => s.trim())
-    .filter(Boolean);
+  const fromPositionals = (rawBranchNames ?? []).map((s) => s.trim()).filter(Boolean);
 
   if (fromPositionals.length > 0) {
     for (const branch of fromPositionals) {
       if (branch === main || branch === dev) {
-        throw new CannotDeleteMainOrDevError(
-          `Cannot delete the long-lived branch '${branch}'.`
-        );
+        throw new CannotDeleteMainOrDevError(`Cannot delete the long-lived branch '${branch}'.`);
       }
     }
     for (const branch of fromPositionals) {
@@ -89,7 +71,7 @@ export async function run(args: ParsedArgs): Promise<void> {
   const isTTY = typeof process.stdin.isTTY === "boolean" && process.stdin.isTTY;
   if (!isTTY) {
     console.error(
-      "gflows delete: no branch name(s) given and stdin is not a TTY. Pass branch name(s) (e.g. gflows delete feature/my-branch) or run from an interactive terminal."
+      "gflows delete: no branch name(s) given and stdin is not a TTY. Pass branch name(s) (e.g. gflows delete feature/my-branch) or run from an interactive terminal.",
     );
     process.exit(EXIT_USER);
   }
@@ -103,7 +85,7 @@ export async function run(args: ParsedArgs): Promise<void> {
   if (workflowBranches.length === 0) {
     if (!quiet) {
       console.error(
-        "No workflow branches to delete. Create one with 'gflows start <type> <name>'."
+        "No workflow branches to delete. Create one with 'gflows start <type> <name>'.",
       );
     }
     process.exit(EXIT_USER);
@@ -124,9 +106,7 @@ export async function run(args: ParsedArgs): Promise<void> {
 
   for (const branch of chosen) {
     if (branch === main || branch === dev) {
-      throw new CannotDeleteMainOrDevError(
-        `Cannot delete the long-lived branch '${branch}'.`
-      );
+      throw new CannotDeleteMainOrDevError(`Cannot delete the long-lived branch '${branch}'.`);
     }
   }