gflows 0.1.1

package/src/cli.ts

@@ -0,0 +1,358 @@
+/**
+ * CLI entrypoint for gflows. Parses argv, resolves -C/path, dispatches to commands,
+ * and ensures exit codes and unhandled rejections are handled.
+ * @module cli
+ */
+
+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 { exitCodeForError } from "./errors.js";
+
+/** Last parsed args, set at start of run(); used by catch/rejection to respect -v for stack trace. */
+let lastParsedArgs: ParsedArgs | null = null;
+
+const COMMANDS: Command[] = [
+  "init",
+  "start",
+  "finish",
+  "switch",
+  "delete",
+  "list",
+  "bump",
+  "completion",
+  "status",
+  "help",
+  "version",
+];
+
+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> = {
+  I: "init",
+  S: "start",
+  F: "finish",
+  W: "switch",
+  L: "delete",
+  l: "list",
+  t: "status",
+  h: "help",
+  V: "version",
+};
+
+function buildParseArgsOptions() {
+  return {
+    args: Bun.argv.slice(2),
+    strict: false,
+    allowPositionals: true,
+    options: {
+      // -C / --path (must be first conceptually for cwd resolution)
+      path: { type: "string" as const, short: "C" },
+      // Command shorts
+      init: { type: "boolean" as const, short: "I" },
+      start: { type: "boolean" as const, short: "S" },
+      finish: { type: "boolean" as const, short: "F" },
+      switch: { type: "boolean" as const, short: "W" },
+      delete: { type: "boolean" as const, short: "L" },
+      list: { type: "boolean" as const, short: "l" },
+      status: { type: "boolean" as const, short: "t" },
+      help: { type: "boolean" as const, short: "h" },
+      version: { type: "boolean" as const, short: "V" },
+      // Type shorts (-r is context-dependent: list → include-remote, start/finish → release)
+      feature: { type: "boolean" as const, short: "f" },
+      bugfix: { type: "boolean" as const, short: "b" },
+      chore: { type: "boolean" as const, short: "c" },
+      release: { type: "boolean" as const, short: "r" },
+      hotfix: { type: "boolean" as const, short: "x" },
+      spike: { type: "boolean" as const, short: "e" },
+      // Common
+      push: { type: "boolean" as const, short: "p" },
+      noPush: { type: "boolean" as const, short: "P" },
+      remote: { type: "string" as const, short: "R" },
+      from: { type: "string" as const, short: "o" },
+      branch: { type: "string" as const, short: "B" },
+      yes: { type: "boolean" as const, short: "y" },
+      dryRun: { type: "boolean" as const, short: "d" },
+      verbose: { type: "boolean" as const, short: "v" },
+      quiet: { type: "boolean" as const, short: "q" },
+      force: { type: "boolean" as const },
+      // finish (-D/--delete-branch, -N/--no-delete)
+      noFf: { type: "boolean" as const },
+      deleteBranch: { type: "boolean" as const, short: "D" },
+      noDelete: { type: "boolean" as const, short: "N" },
+      sign: { type: "boolean" as const, short: "s" },
+      noTag: { type: "boolean" as const, short: "T" },
+      tagMessage: { type: "string" as const, short: "M" },
+      message: { type: "string" as const, short: "m" },
+      // list (-r is context-dependent: list → include-remote; start/finish → release)
+      includeRemote: { type: "boolean" as const },
+      "include-remote": { type: "boolean" as const },
+    },
+  };
+}
+
+/** Resolve -C/--path to absolute directory; validate it exists and is a directory. */
+function resolveCwd(pathFlag: string | undefined): string {
+  if (!pathFlag || pathFlag.trim() === "") {
+    return process.cwd();
+  }
+  const absolute = resolve(process.cwd(), pathFlag.trim());
+  if (!existsSync(absolute)) {
+    console.error(`gflows: path does not exist: ${absolute}`);
+    process.exit(EXIT_USER);
+  }
+  const stat = statSync(absolute, { throwIfNoEntry: false });
+  if (!stat || !stat.isDirectory()) {
+    console.error(`gflows: path is not a directory: ${absolute}`);
+    process.exit(EXIT_USER);
+  }
+  return absolute;
+}
+
+/** Resolve command from positionals and short flags. Short wins if both present. */
+function resolveCommand(
+  positionals: string[],
+  values: Record<string, string | boolean | undefined>
+): Command | undefined {
+  for (const [short, cmd] of Object.entries(SHORT_TO_COMMAND)) {
+    const key = cmd === "delete" ? "delete" : cmd;
+    if (values[key] === true) return cmd as Command;
+  }
+  const first = positionals[0];
+  if (first && COMMANDS.includes(first as Command)) {
+    return first as Command;
+  }
+  return undefined;
+}
+
+/** Resolve branch type for start/finish/list. -r means release for start/finish; for list, -r means include-remote (handled in flags). */
+function resolveType(
+  command: Command,
+  positionals: string[],
+  values: Record<string, string | boolean | undefined>
+): BranchType | undefined {
+  if (command !== "start" && command !== "finish" && command !== "list") {
+    return undefined;
+  }
+  // Type from short flags (for start/finish, -r => release)
+  if (command === "list") {
+    // For list, -r is include-remote only (see includeRemote below); type from other shorts or positional (not -r)
+    if (values.feature === true) return "feature";
+    if (values.bugfix === true) return "bugfix";
+    if (values.chore === true) return "chore";
+    if (values.hotfix === true) return "hotfix";
+    if (values.spike === true) return "spike";
+    // release type for list only via positional, e.g. "gflows list release"
+  } else {
+    // start / finish: -r => release
+    if (values.release === true) return "release";
+    if (values.feature === true) return "feature";
+    if (values.bugfix === true) return "bugfix";
+    if (values.chore === true) return "chore";
+    if (values.hotfix === true) return "hotfix";
+    if (values.spike === true) return "spike";
+  }
+  // Type from second positional
+  const idx = positionals[0] && COMMANDS.includes(positionals[0] as Command) ? 1 : 0;
+  const pos = positionals[idx];
+  if (pos && BRANCH_TYPES.includes(pos as BranchType)) {
+    return pos as BranchType;
+  }
+  return undefined;
+}
+
+/** Resolve name (third positional for start; -B for finish; first positional for completion). */
+function resolveName(
+  command: Command,
+  positionals: string[],
+  values: Record<string, string | boolean | undefined>
+): string | undefined {
+  const branch = values.branch;
+  if (typeof branch === "string" && branch.trim() !== "") {
+    return branch.trim();
+  }
+  const skip = positionals[0] && COMMANDS.includes(positionals[0] as Command) ? 1 : 0;
+  if (command === "start") {
+    const typeFromPos = positionals[skip] && BRANCH_TYPES.includes(positionals[skip] as BranchType);
+    if (typeFromPos) {
+      return positionals[skip + 1];
+    }
+    return positionals[skip];
+  }
+  if (command === "completion") {
+    const shell = positionals[skip];
+    if (shell === "bash" || shell === "zsh" || shell === "fish") return shell;
+    return undefined;
+  }
+  if (command === "bump") {
+    const dir = positionals[skip];
+    const typ = positionals[skip + 1];
+    if (dir === "up" || dir === "down") {
+      return dir;
+    }
+    return undefined;
+  }
+  if (command === "switch") {
+    return positionals[skip];
+  }
+  return undefined;
+}
+
+/** Resolve bump direction and type from positionals (bump [up|down] [patch|minor|major]). */
+function resolveBump(
+  positionals: string[],
+  values: Record<string, string | boolean | undefined>
+): { direction?: "up" | "down"; type?: "patch" | "minor" | "major" } {
+  const skip = positionals[0] === "bump" ? 1 : 0;
+  const a = positionals[skip];
+  const b = positionals[skip + 1];
+  const direction = a === "up" || a === "down" ? a : undefined;
+  const type = b === "patch" || b === "minor" || b === "major" ? b : undefined;
+  return { direction, type };
+}
+
+/** Parse raw argv into ParsedArgs. Resolves -C first, then command/type/name and flags. */
+export function parse(argv: string[] = Bun.argv.slice(2)): ParsedArgs {
+  const config = {
+    ...buildParseArgsOptions(),
+    args: argv,
+  };
+  const { values, positionals } = parseArgs(config);
+  const v = values as Record<string, string | boolean | undefined>;
+
+  const pathRaw = v.path;
+  const pathStr = typeof pathRaw === "string" ? pathRaw : undefined;
+  const cwd = resolveCwd(pathStr);
+
+  const command = resolveCommand(positionals, v);
+  if (!command) {
+    console.error("gflows: missing command. Use 'gflows help' for usage.");
+    process.exit(EXIT_USER);
+  }
+
+  const type = resolveType(command, positionals, v);
+  const name = resolveName(command, positionals, v);
+  const { direction: bumpDirection, type: bumpType } =
+    command === "bump" ? resolveBump(positionals, v) : { direction: undefined, type: undefined };
+
+  const branchNames =
+    command === "delete"
+      ? positionals[0] && COMMANDS.includes(positionals[0] as Command)
+        ? positionals.slice(1)
+        : positionals
+      : undefined;
+
+  // -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)
+      : false;
+
+  let completionShell: "bash" | "zsh" | "fish" | undefined;
+  if (command === "completion" && name === "bash") completionShell = "bash";
+  else if (command === "completion" && name === "zsh") completionShell = "zsh";
+  else if (command === "completion" && name === "fish") completionShell = "fish";
+
+  return {
+    command,
+    cwd,
+    type,
+    name,
+    completionShell,
+    branchNames,
+    bumpDirection,
+    bumpType,
+    push: v.push === true,
+    noPush: v.noPush === true,
+    remote: typeof v.remote === "string" ? v.remote : undefined,
+    branch: typeof v.branch === "string" ? v.branch : undefined,
+    yes: v.yes === true,
+    dryRun: v.dryRun === true,
+    verbose: v.verbose === true,
+    quiet: v.quiet === true,
+    force: v.force === true,
+    path: pathStr,
+    fromMain: v.from === "main",
+    noFf: v.noFf === true,
+    deleteAfterFinish: v.deleteBranch === true,
+    noDeleteAfterFinish: v.noDelete === true,
+    signTag: v.sign === true,
+    noTag: v.noTag === true,
+    tagMessage: typeof v.tagMessage === "string" ? v.tagMessage : undefined,
+    message: typeof v.message === "string" ? v.message : undefined,
+    includeRemote,
+  };
+}
+
+/** Run the CLI: parse, dispatch, set exit code. */
+async function run(): Promise<void> {
+  const args = parse();
+  lastParsedArgs = args;
+  const { command } = args;
+
+  if (command === "help") {
+    const { run: runHelp } = await import("./commands/help.js");
+    await runHelp(args);
+    return;
+  }
+  if (command === "version") {
+    const { run: runVersion } = await import("./commands/version.js");
+    await runVersion(args);
+    return;
+  }
+
+  const mod = await import(`./commands/${command}.js`).catch(() => null);
+  if (!mod || typeof mod.run !== "function") {
+    console.error(`gflows: command '${command}' is not implemented.`);
+    process.exit(EXIT_GIT);
+  }
+  await mod.run(args);
+}
+
+// Top-level try/catch and unhandledRejection so exit code is always set
+function main(): void {
+  let exitCode: number | null = null;
+
+  const handleRejection = (reason: unknown): void => {
+    if (exitCode !== null) return;
+    console.error("gflows:", reason instanceof Error ? reason.message : String(reason));
+    const verbose = lastParsedArgs?.verbose ?? !!process.env.GFLOWS_VERBOSE;
+    if (verbose && reason instanceof Error && reason.stack) {
+      console.error(reason.stack);
+    }
+    exitCode = exitCodeForError(reason instanceof Error ? reason : new Error(String(reason)));
+    process.exit(exitCode);
+  };
+
+  process.on("unhandledRejection", handleRejection);
+
+  run()
+    .then(() => {
+      if (exitCode === null) exitCode = EXIT_OK;
+      process.exit(exitCode);
+    })
+    .catch((err: unknown) => {
+      if (exitCode !== null) return;
+      console.error("gflows:", err instanceof Error ? err.message : String(err));
+      const verbose = lastParsedArgs?.verbose ?? !!process.env.GFLOWS_VERBOSE;
+      if (verbose && err instanceof Error && err.stack) {
+        console.error(err.stack);
+      }
+      exitCode = exitCodeForError(err);
+      process.exit(exitCode);
+    });
+}
+
+main();

package/src/commands/bump.ts

@@ -0,0 +1,213 @@
+/**
+ * Bump command: bump or rollback root package version (patch/minor/major).
+ * 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 { EXIT_OK, EXIT_USER } from "../constants.js";
+import { InvalidVersionError } from "../errors.js";
+
+const PACKAGE_JSON = "package.json";
+const JSR_JSON = "jsr.json";
+
+/** Semver triplet. */
+interface Semver {
+  major: number;
+  minor: number;
+  patch: number;
+}
+
+/**
+ * Parses a version string (vX.Y.Z or X.Y.Z) into components.
+ * @throws InvalidVersionError if format is invalid
+ */
+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))
+  ) {
+    throw new InvalidVersionError(
+      `Invalid version '${version}'. Expected format: X.Y.Z or vX.Y.Z (e.g. 1.2.3 or v1.2.3).`
+    );
+  }
+  return {
+    major: parseInt(parts[0]!, 10),
+    minor: parseInt(parts[1]!, 10),
+    patch: parseInt(parts[2]!, 10),
+  };
+}
+
+/**
+ * Formats semver as string (no leading v, for package.json).
+ */
+function formatVersion(semver: Semver): string {
+  return `${semver.major}.${semver.minor}.${semver.patch}`;
+}
+
+/**
+ * Computes new version for bump up (patch/minor/major).
+ */
+function bumpUp(semver: Semver, type: BumpType): Semver {
+  switch (type) {
+    case "patch":
+      return { ...semver, patch: semver.patch + 1 };
+    case "minor":
+      return { major: semver.major, minor: semver.minor + 1, patch: 0 };
+    case "major":
+      return { major: semver.major + 1, minor: 0, patch: 0 };
+    default:
+      return semver;
+  }
+}
+
+/**
+ * Computes new version for rollback (down), with floor at 0.
+ */
+function bumpDown(semver: Semver, type: BumpType): Semver {
+  switch (type) {
+    case "patch":
+      return {
+        ...semver,
+        patch: Math.max(0, semver.patch - 1),
+      };
+    case "minor":
+      return {
+        major: semver.major,
+        minor: Math.max(0, semver.minor - 1),
+        patch: 0,
+      };
+    case "major":
+      return {
+        major: Math.max(0, semver.major - 1),
+        minor: semver.minor,
+        patch: semver.patch,
+      };
+    default:
+      return semver;
+  }
+}
+
+/**
+ * Reads version from package.json in dir.
+ * @throws InvalidVersionError if version is missing or invalid
+ */
+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>.`
+    );
+  }
+  const raw = readFileSync(path, "utf-8");
+  const data = JSON.parse(raw) as Record<string, unknown>;
+  const version = data.version;
+  if (typeof version !== "string" || version.trim() === "") {
+    throw new InvalidVersionError(
+      "package.json has no valid 'version' field."
+    );
+  }
+  const semver = parseVersion(version);
+  return { raw: version.trim(), semver };
+}
+
+/**
+ * Writes version to package.json, preserving other keys and formatting as much as possible.
+ * Uses JSON.stringify with 2 spaces for consistency.
+ */
+function writePackageVersion(dir: string, newVersion: string): void {
+  const path = join(dir, PACKAGE_JSON);
+  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");
+}
+
+/**
+ * Updates version in jsr.json if the file exists; preserves other keys.
+ */
+function syncJsrVersion(dir: string, newVersion: string): boolean {
+  const path = join(dir, JSR_JSON);
+  if (!existsSync(path)) return false;
+  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");
+  return true;
+}
+
+/**
+ * Run the bump command.
+ * Interactive (select direction and type) when TTY and args omitted; otherwise require both.
+ * With --dry-run, only prints old→new and files that would be updated.
+ */
+export async function run(args: ParsedArgs): Promise<void> {
+  const { cwd, bumpDirection, bumpType, dryRun, quiet } = args;
+
+  let direction: BumpDirection;
+  let type: BumpType;
+
+  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"
+    );
+    process.exit(EXIT_USER);
+  } else {
+    const { select } = await import("@inquirer/prompts");
+    direction = await select({
+      message: "Direction",
+      choices: [
+        { name: "Up (bump)", value: "up" as const },
+        { name: "Down (rollback)", value: "down" as const },
+      ],
+    });
+    type = await select({
+      message: "Type",
+      choices: [
+        { name: "patch (x.y.Z)", value: "patch" as const },
+        { name: "minor (x.Y.0)", value: "minor" as const },
+        { name: "major (X.0.0)", value: "major" as const },
+      ],
+    });
+  }
+
+  const { raw: oldVersion, semver } = readPackageVersion(cwd);
+  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);
+  }
+
+  if (dryRun) {
+    if (!quiet) {
+      console.error(`Would bump version: ${oldVersion} → ${newVersion}`);
+      console.error(`Would update: ${filesToUpdate.join(", ")}`);
+    }
+    process.exit(EXIT_OK);
+  }
+
+  writePackageVersion(cwd, newVersion);
+  const jsrUpdated = syncJsrVersion(cwd, newVersion);
+
+  if (!quiet) {
+    console.error(`Bumped version: ${oldVersion} → ${newVersion}`);
+    const updated = [PACKAGE_JSON];
+    if (jsrUpdated) updated.push(JSR_JSON);
+    console.error(`Updated: ${updated.join(", ")}`);
+  }
+}