gflows 1.1.1 → 1.2.1

package/src/commands/mcp.ts

@@ -93,6 +93,27 @@ const TOOLS = [
       },
     },
   },
+  {
+    name: "gflows_release",
+    description:
+      "Quick release from dev: optional bump (or keep current version), merge into main, tag, sync main→dev. Pass bumpType or keepCurrent.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string" },
+        bumpType: {
+          type: "string",
+          description: "Semver segment to bump: patch, minor, or major (omit when keepCurrent)",
+        },
+        keepCurrent: {
+          type: "boolean",
+          description: "Tag the package version already on disk (no bump commit)",
+        },
+        push: { type: "boolean" },
+        preview: { type: "boolean" },
+      },
+    },
+  },
   {
     name: "gflows_schema",
     description: "Return the gflows command schema JSON.",
@@ -159,6 +180,19 @@ async function runTool(
       if (args.push) argv.push("-p");
       else argv.push("-P");
       break;
+    case "gflows_release": {
+      if (args.keepCurrent === true) {
+        argv.push("release", "current");
+      } else if (typeof args.bumpType === "string" && args.bumpType.trim() !== "") {
+        argv.push("release", "up", args.bumpType.trim());
+      } else {
+        throw new Error("gflows_release: pass bumpType (patch|minor|major) or keepCurrent: true");
+      }
+      if (args.preview) argv.push("--preview");
+      if (args.push) argv.push("-p");
+      else argv.push("-P");
+      break;
+    }
     case "gflows_schema":
       argv.push("schema");
       break;
@@ -185,7 +219,7 @@ async function runTool(
  */
 export async function run(_args: ParsedArgs): Promise<void> {
   console.error(
-    "gflows mcp: listening on stdio (JSON-RPC). Tools: status, doctor, info, list, start, sync, finish, schema.",
+    "gflows mcp: listening on stdio (JSON-RPC). Tools: status, doctor, info, list, start, sync, finish, release, schema.",
   );
 
   const decoder = new TextDecoder();

package/src/commands/release.ts

@@ -0,0 +1,280 @@
+/**
+ * Quick release from the long-lived `dev` branch: bump (or keep), merge into main, tag, sync main→dev.
+ * @module commands/release
+ */
+
+import { join } from "node:path";
+import { resolveConfig } from "../config.js";
+import { EXIT_USER } from "../constants.js";
+import { DirtyWorkingTreeError, NothingToFinishError } from "../errors.js";
+import { normalizeTagVersion } from "../flow.js";
+import {
+  assertNoRebaseOrMerge,
+  assertNotDetached,
+  getAheadBehind,
+  getCurrentBranch,
+  isClean,
+  resolveRepoRoot,
+  runGit,
+  tagExists,
+} from "../git.js";
+import { hint, success } from "../out.js";
+import { PACKAGE_JSON } from "../packages.js";
+import type { BumpType, ParsedArgs } from "../types.js";
+import {
+  applyVersionToPackages,
+  computeBump,
+  JSR_JSON,
+  readPackageVersion,
+  sortedPackageRoots,
+} from "../version-bump.js";
+import { type FinishContext, runFinishPlan } from "./finish.js";
+
+/** Interactive choice: keep package version as-is, or bump a semver segment. */
+type ReleaseVersionChoice = "current" | BumpType;
+
+/**
+ * Runs quick release: only valid when HEAD is the configured `dev` branch.
+ */
+export async function run(args: ParsedArgs): Promise<void> {
+  const repoRoot = await resolveRepoRoot(args.cwd);
+  const config = resolveConfig(
+    repoRoot,
+    { main: args.main, dev: args.dev, remote: args.remote },
+    { verbose: args.verbose },
+  );
+
+  const opts = { dryRun: args.dryRun, verbose: args.verbose, quiet: args.quiet };
+  const isTTY = Boolean(process.stdin.isTTY);
+
+  await assertNotDetached(repoRoot);
+  assertNoRebaseOrMerge(repoRoot);
+
+  const current = await getCurrentBranch(repoRoot, opts);
+  if (!current || current !== config.dev) {
+    console.error(
+      `gflows release: must be on '${config.dev}' (currently ${current ? `'${current}'` : "detached"}).`,
+    );
+    hint("Checkout dev, or use: gflows start release vX.Y.Z && gflows finish release -y -P");
+    process.exit(2);
+  }
+
+  if (!args.force) {
+    const clean = await isClean(repoRoot, opts);
+    if (!clean) {
+      throw new DirtyWorkingTreeError(
+        "Working tree has uncommitted changes. Commit or stash them before release, or use --force.",
+      );
+    }
+  }
+
+  const { ahead } = await getAheadBehind(repoRoot, config.main, config.dev, opts);
+  if (ahead === 0) {
+    throw new NothingToFinishError(
+      `Nothing to release: '${config.dev}' has no commits beyond '${config.main}'.`,
+    );
+  }
+
+  let keepCurrent = args.keepCurrent === true;
+  let bumpType: BumpType | undefined = args.bumpType;
+
+  if (args.bumpDirection === "down") {
+    console.error(
+      "gflows release: only 'up' or 'current' is supported (not 'down'). Example: gflows release up patch",
+    );
+    process.exit(EXIT_USER);
+  }
+  if (args.bumpDirection && args.bumpDirection !== "up") {
+    console.error(
+      "gflows release: expected 'up <patch|minor|major>' or 'current'. Example: gflows release up patch",
+    );
+    process.exit(EXIT_USER);
+  }
+  if (keepCurrent && (args.bumpDirection || bumpType)) {
+    console.error("gflows release: use either 'current' or 'up <patch|minor|major>', not both.");
+    process.exit(EXIT_USER);
+  }
+
+  if (!keepCurrent && !bumpType) {
+    if (!isTTY) {
+      console.error(
+        "gflows release: when not in a TTY, specify version mode. Examples: gflows release current -y -P  or  gflows release up patch -y -P",
+      );
+      process.exit(EXIT_USER);
+    }
+    const { selectPrompt } = await import("../prompts.js");
+    const computedPreview = (() => {
+      try {
+        return computeBump(repoRoot, "up", "patch");
+      } catch {
+        return null;
+      }
+    })();
+    const currentVer = computedPreview?.oldVersion ?? "?";
+    // `release up` already chose bumping — only ask which segment.
+    if (args.bumpDirection === "up") {
+      bumpType = await selectPrompt<BumpType>({
+        message: `Bump version (current ${currentVer})`,
+        options: [
+          { label: "patch (x.y.Z)", value: "patch" },
+          { label: "minor (x.Y.0)", value: "minor" },
+          { label: "major (X.0.0)", value: "major" },
+        ],
+      });
+    } else {
+      const choice = await selectPrompt<ReleaseVersionChoice>({
+        message: `Version for release (current ${currentVer})`,
+        options: [
+          { label: `keep current (${currentVer})`, value: "current" },
+          { label: "bump patch (x.y.Z)", value: "patch" },
+          { label: "bump minor (x.Y.0)", value: "minor" },
+          { label: "bump major (X.0.0)", value: "major" },
+        ],
+      });
+      if (choice === "current") {
+        keepCurrent = true;
+      } else {
+        bumpType = choice;
+      }
+    }
+  }
+
+  let doPush = false;
+  if (args.push && !args.noPush) doPush = true;
+  else if (args.noPush) doPush = false;
+  else if (!isTTY) {
+    console.error("gflows release: specify --push (-p) or --no-push (-P) when not interactive.");
+    process.exit(EXIT_USER);
+  } else if (!args.yes) {
+    const { confirmPrompt } = await import("../prompts.js");
+    doPush = await confirmPrompt({
+      message: "Push after release?",
+      initialValue: false,
+    });
+  } else {
+    // -y without push polarity in TTY: default no-push (same as finish when -y alone)
+    doPush = false;
+  }
+
+  let oldVersion: string;
+  let newVersion: string;
+  let roots: string[];
+
+  if (keepCurrent) {
+    roots = sortedPackageRoots(repoRoot);
+    if (roots.length === 0) {
+      console.error(
+        `gflows release: no package.json found under ${repoRoot}. Run from project root or use -C <dir>.`,
+      );
+      process.exit(EXIT_USER);
+    }
+    const primaryRoot = roots[0];
+    if (primaryRoot === undefined) {
+      console.error(
+        `gflows release: no package.json found under ${repoRoot}. Run from project root or use -C <dir>.`,
+      );
+      process.exit(EXIT_USER);
+    }
+    oldVersion = readPackageVersion(primaryRoot).raw;
+    newVersion = oldVersion;
+  } else {
+    if (!bumpType) {
+      console.error(
+        "gflows release: expected 'up <patch|minor|major>' or 'current'. Example: gflows release up patch",
+      );
+      process.exit(EXIT_USER);
+    }
+    ({ oldVersion, newVersion, roots } = computeBump(repoRoot, "up", bumpType));
+  }
+
+  const tagName = normalizeTagVersion(newVersion);
+
+  if (await tagExists(repoRoot, tagName, opts)) {
+    console.error(`gflows release: tag '${tagName}' already exists.`);
+    hint(
+      keepCurrent
+        ? "Bump the version first, or delete the tag if you intend to recreate it."
+        : "Use a different bump (minor/major), or delete the tag if you intend to recreate it.",
+    );
+    process.exit(2);
+  }
+
+  console.error("gflows release plan:");
+  console.error(`  from:    ${config.dev}`);
+  if (keepCurrent) {
+    console.error(`  version: ${newVersion} (keep current, no bump)`);
+  } else {
+    console.error(`  bump:    ${oldVersion} → ${newVersion}`);
+  }
+  console.error(`  merge:   → ${config.main}, then ${config.main} → ${config.dev}`);
+  console.error(`  tag:     ${tagName}`);
+  console.error(`  push:    ${doPush ? "yes" : "no"}`);
+
+  if (args.preview) {
+    success("gflows: preview only (no changes).");
+    return;
+  }
+
+  if (!args.yes && isTTY) {
+    const { confirmPrompt } = await import("../prompts.js");
+    const ok = await confirmPrompt({
+      message: "Proceed with quick release?",
+      initialValue: true,
+    });
+    if (!ok) {
+      success("gflows: release cancelled.");
+      return;
+    }
+  } else if (!args.yes && !isTTY) {
+    console.error("gflows release: pass -y to accept the plan when not interactive.");
+    process.exit(EXIT_USER);
+  }
+
+  if (!keepCurrent && !opts.dryRun) {
+    applyVersionToPackages(repoRoot, roots, newVersion);
+    for (const dir of roots) {
+      await runGit(["add", "--", join(dir, PACKAGE_JSON)], {
+        cwd: repoRoot,
+        dryRun: false,
+        verbose: args.verbose,
+      }).catch(() => undefined);
+      await runGit(["add", "--", join(dir, JSR_JSON)], {
+        cwd: repoRoot,
+        dryRun: false,
+        verbose: args.verbose,
+      }).catch(() => undefined);
+    }
+    await runGit(["commit", "-m", `chore: bump to ${newVersion}`], {
+      cwd: repoRoot,
+      dryRun: false,
+      verbose: args.verbose,
+    });
+    if (!args.quiet) {
+      success(`gflows: bumped version ${oldVersion} → ${newVersion} and committed.`);
+    }
+  }
+
+  const ctx: FinishContext = {
+    branchToFinish: config.dev,
+    type: "release",
+    version: newVersion,
+    mergeTarget: "main-then-dev",
+    shouldDelete: false,
+    doPush,
+    noFf: args.noFf,
+    squash: false,
+    message: args.message,
+    signTag: args.signTag,
+    noTag: false,
+    tagMessage: args.tagMessage,
+    remote: args.remote ?? config.remote,
+    main: config.main,
+    dev: config.dev,
+    bumpOnFinish: false,
+  };
+
+  await runFinishPlan(repoRoot, ctx, {
+    ...opts,
+    printPlan: false,
+  });
+}

package/src/commands/schema.ts

@@ -56,6 +56,14 @@ export async function run(_args: ParsedArgs): Promise<void> {
         "-M/--tag-message",
         "-m/--message",
       ],
+      release: [
+        "up patch|minor|major | current",
+        "-y",
+        "-p/--push",
+        "-P/--no-push",
+        "--preview",
+        "-s/--sign",
+      ],
       start: ["-o/--from", "--force", "-p/--push"],
       sync: ["--rebase", "--force"],
       list: ["-r/--include-remote", "--json"],
@@ -66,6 +74,7 @@ export async function run(_args: ParsedArgs): Promise<void> {
     agentNotes: [
       "Always pass explicit flags in non-TTY (never assume interactive hub).",
       "Prefer -y to accept finish plan (delete defaults on); pass -P or -p for push.",
+      "Quick release from dev: gflows release up patch -y -p (or -P); or gflows release current -y -p after a manual bump.",
       "On conflict: gflows continue | gflows abort | gflows undo.",
       "Use gflows schema and AGENTS.md as source of truth.",
     ],
@@ -78,6 +87,10 @@ function commandMeta(command: string): { summary: string; interactiveOk: boolean
     init: { summary: "Ensure main; create dev", interactiveOk: true },
     start: { summary: "Create workflow branch", interactiveOk: true },
     finish: { summary: "Merge and close workflow branch", interactiveOk: true },
+    release: {
+      summary: "Quick release from dev (bump or keep version, merge main, tag)",
+      interactiveOk: true,
+    },
     switch: { summary: "Switch workflow branch", interactiveOk: true },
     delete: { summary: "Delete local workflow branches", interactiveOk: true },
     list: { summary: "List workflow branches", interactiveOk: false },

package/src/interactive.ts

@@ -82,6 +82,11 @@ function buildLegacyOptions(
     { value: "sync", label: "Sync this branch with base" },
     { value: "pr", label: "Open a pull request" },
     { value: "finish", label: "Finish / merge this branch" },
+  );
+  if (snap?.current === snap?.dev) {
+    items.push({ value: "release", label: "Quick release to main" });
+  }
+  items.push(
     { value: "switch", label: "Switch branch" },
     { value: "list", label: "List branches" },
     { value: "viz", label: "Refresh map" },
@@ -121,6 +126,24 @@ async function runHubAction(cwd: string, action: string): Promise<void> {
     await dispatch(cwd, ["finish", "-y", push ? "-p" : "-P"]);
     return;
   }
+  if (action === "release") {
+    const choice = await selectPrompt<"current" | "patch" | "minor" | "major">({
+      message: "Version for release",
+      options: [
+        { label: "keep current", value: "current" },
+        { label: "bump patch (x.y.Z)", value: "patch" },
+        { label: "bump minor (x.Y.0)", value: "minor" },
+        { label: "bump major (X.0.0)", value: "major" },
+      ],
+    });
+    const push = await confirmPrompt({ message: "Push after release?", initialValue: false });
+    const releaseArgv =
+      choice === "current"
+        ? (["release", "current", "-y", push ? "-p" : "-P"] as string[])
+        : (["release", "up", choice, "-y", push ? "-p" : "-P"] as string[]);
+    await dispatch(cwd, releaseArgv);
+    return;
+  }
   if (action === "sync") {
     const rebase = await confirmPrompt({
       message: "Rebase onto base (instead of merge)?",

package/src/parse.ts

@@ -234,9 +234,11 @@ function resolveName(
     if (shell === "bash" || shell === "zsh" || shell === "fish") return shell;
     return undefined;
   }
-  if (command === "bump") {
+  if (command === "bump" || command === "release") {
     const dir = positionals[skip];
-    if (dir === "up" || dir === "down") return dir;
+    if (dir === "up" || dir === "down" || (command === "release" && dir === "current")) {
+      return dir;
+    }
     return undefined;
   }
   if (command === "switch" || command === "pr" || command === "sync") {
@@ -248,11 +250,15 @@ function resolveName(
 function resolveBump(positionals: string[]): {
   direction?: "up" | "down";
   type?: "patch" | "minor" | "major";
+  keepCurrent?: boolean;
 } {
-  // Skip leading "bump" when present; with -U, positionals start at up/down
-  const skip = positionals[0] === "bump" ? 1 : 0;
+  // Skip leading command when present; with -U, positionals start at up/down
+  const skip = positionals[0] === "bump" || positionals[0] === "release" ? 1 : 0;
   const a = positionals[skip];
   const b = positionals[skip + 1];
+  if (positionals[0] === "release" && a === "current") {
+    return { keepCurrent: true };
+  }
   const direction = a === "up" || a === "down" ? a : undefined;
   const type = b === "patch" || b === "minor" || b === "major" ? b : undefined;
   return { direction, type };
@@ -297,6 +303,7 @@ function emptyArgs(cwd: string, pathStr: string | undefined): ParsedArgs {
     squash: false,
     preview: false,
     bumpOnFinish: false,
+    keepCurrent: false,
     includeRemote: false,
     json: false,
     rebase: false,
@@ -336,8 +343,13 @@ export function parse(
 
   const type = resolveType(command, positionals, v);
   const name = resolveName(command, positionals, v);
-  const { direction: bumpDirection, type: bumpType } =
-    command === "bump" ? resolveBump(positionals) : { direction: undefined, type: undefined };
+  const bumpResolved =
+    command === "bump" || command === "release"
+      ? resolveBump(positionals)
+      : { direction: undefined, type: undefined, keepCurrent: undefined };
+  const bumpDirection = bumpResolved.direction;
+  const bumpType = bumpResolved.type;
+  const keepCurrent = bumpResolved.keepCurrent === true;
   const configArgs = command === "config" ? resolveConfigArgs(positionals) : {};
 
   const branchNames =
@@ -393,6 +405,7 @@ export function parse(
     branchNames,
     bumpDirection,
     bumpType,
+    keepCurrent,
     configAction: configArgs.action,
     configKey: configArgs.key,
     configValue: configArgs.value,

package/src/recommend.ts

@@ -11,6 +11,7 @@ export type RecommendAction =
   | "continue"
   | "sync"
   | "finish"
+  | "release"
   | "pr"
   | "start"
   | "commit"
@@ -79,7 +80,7 @@ export function recommend(snap: VizSnapshot): Recommendation {
     return {
       action: "start",
       label: "Start a feature (or chore / bugfix)",
-      detail: "Integration line — short-lived branches start here",
+      detail: "Integration line — short-lived branches start here; /release for quick ship to main",
       menuLabel: "Start new work",
     };
   }

package/src/tui/HubHome.tsx

@@ -289,7 +289,7 @@ export function HubHome({
           ) : (
             <Text color={MUTED}>
               {showHelp
-                ? "/init /start /sync /pr /finish /doctor /info /help  ·  esc clear  ·  ctrl+c quit"
+                ? "/init /start /sync /pr /finish /release /doctor /info /help  ·  esc clear  ·  ctrl+c quit"
                 : "? for shortcuts · / for command menu"}
             </Text>
           )}
@@ -372,6 +372,7 @@ function buildActions(snap: VizSnapshot | null, recommended: RecommendAction | n
   push("sync", "Sync with base", "/sync");
   push("pr", "Open pull request", "/pr");
   push("finish", "Finish / merge branch", "/finish");
+  if (snap?.current === snap?.dev) push("release", "Quick release to main", "/release");
   if (snap?.suspended) push("continue", "Continue suspended", "/continue");
   push("switch", "Switch branch", "/switch");
   push("list", "List branches", "/list");

package/src/tui/HubShell.tsx

@@ -11,6 +11,7 @@ import {
   FinishFlow,
   InitFlow,
   ListFlow,
+  ReleaseFlow,
   StartFlow,
   SwitchFlow,
   SyncFlow,
@@ -31,6 +32,7 @@ type Screen =
   | { id: "home"; flash?: string }
   | { id: "start" }
   | { id: "finish" }
+  | { id: "release" }
   | { id: "sync" }
   | { id: "list" }
   | { id: "switch" }
@@ -87,6 +89,9 @@ export function HubShell({ cwd, onDone }: HubShellProps): React.ReactElement {
       case "finish":
         setScreen({ id: "finish" });
         return true;
+      case "release":
+        setScreen({ id: "release" });
+        return true;
       case "sync":
         setScreen({ id: "sync" });
         return true;
@@ -156,6 +161,14 @@ export function HubShell({ cwd, onDone }: HubShellProps): React.ReactElement {
       setScreen({ id: "finish" });
       return;
     }
+    if (cmd === "release") {
+      if (rest.length > 0) {
+        runArgv(["release", "-y", "-P", ...rest]);
+        return;
+      }
+      setScreen({ id: "release" });
+      return;
+    }
     if (cmd === "sync") {
       if (rest.length > 0) {
         runArgv(["sync", "--force", ...rest]);
@@ -217,6 +230,9 @@ export function HubShell({ cwd, onDone }: HubShellProps): React.ReactElement {
   if (screen.id === "finish") {
     return <FinishFlow onCancel={cancelWizard} onDone={runArgv} />;
   }
+  if (screen.id === "release") {
+    return <ReleaseFlow onCancel={cancelWizard} onDone={runArgv} />;
+  }
   if (screen.id === "sync") {
     return <SyncFlow onCancel={cancelWizard} onDone={runArgv} />;
   }

package/src/tui/flows.tsx

@@ -124,6 +124,60 @@ export function FinishFlow({
   );
 }
 
+/**
+ * Collects argv for `gflows release …` (quick release from dev) inside Ink.
+ */
+export function ReleaseFlow({
+  onDone,
+  onCancel,
+}: {
+  onDone: (argv: string[]) => void;
+  onCancel: () => void;
+}): React.ReactElement {
+  const [step, setStep] = useState<"type" | "push">("type");
+  const [choice, setChoice] = useState<"current" | "patch" | "minor" | "major">("current");
+
+  if (step === "type") {
+    return (
+      <WizardFrame title="Quick release from dev">
+        <InkSelect<"current" | "patch" | "minor" | "major">
+          message="Version for release"
+          options={[
+            { value: "current", label: "keep current" },
+            { value: "patch", label: "bump patch (x.y.Z)" },
+            { value: "minor", label: "bump minor (x.Y.0)" },
+            { value: "major", label: "bump major (X.0.0)" },
+          ]}
+          onCancel={onCancel}
+          onSubmit={(t) => {
+            setChoice(t);
+            setStep("push");
+          }}
+        />
+      </WizardFrame>
+    );
+  }
+
+  const title = choice === "current" ? "Release · keep current" : `Release · up ${choice}`;
+
+  return (
+    <WizardFrame title={title}>
+      <InkConfirm
+        message="Push after release?"
+        initialValue={false}
+        onCancel={onCancel}
+        onSubmit={(push) => {
+          onDone(
+            choice === "current"
+              ? ["release", "current", "-y", push ? "-p" : "-P"]
+              : ["release", "up", choice, "-y", push ? "-p" : "-P"],
+          );
+        }}
+      />
+    </WizardFrame>
+  );
+}
+
 /**
  * Collects argv for `gflows sync …` entirely inside Ink.
  */

package/src/tui/slash.ts

@@ -20,6 +20,7 @@ export const SLASH_COMMANDS: readonly SlashCommand[] = [
   { name: "sync", hint: "Sync with base (wizard)" },
   { name: "pr", hint: "Open pull request" },
   { name: "finish", hint: "Finish / merge (wizard)" },
+  { name: "release", hint: "Quick release from dev" },
   { name: "continue", hint: "Continue suspended run" },
   { name: "switch", hint: "Switch branch" },
   { name: "list", hint: "List branches" },

package/src/types.ts

@@ -27,6 +27,7 @@ export type Command =
   | "init"
   | "start"
   | "finish"
+  | "release"
   | "switch"
   | "delete"
   | "list"
@@ -52,6 +53,7 @@ export const ALL_COMMANDS: Command[] = [
   "init",
   "start",
   "finish",
+  "release",
   "switch",
   "delete",
   "list",
@@ -132,6 +134,11 @@ export interface ParsedArgs {
   bumpDirection?: BumpDirection;
   /** Bump type (patch | minor | major). */
   bumpType?: BumpType;
+  /**
+   * Quick release: tag the package version already on disk (no bump commit).
+   * From `gflows release current`.
+   */
+  keepCurrent?: boolean;
   /** Config get/set action. */
   configAction?: ConfigAction;
   /** Config key (main, dev, remote, or prefixes.<type>). */