gflows 1.1.0 → 1.2.0

package/src/commands/mcp.ts

@@ -93,6 +93,24 @@ const TOOLS = [
       },
     },
   },
+  {
+    name: "gflows_release",
+    description:
+      "Quick release from dev: bump package version, merge into main, tag, sync main→dev. Requires bumpType.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string" },
+        bumpType: {
+          type: "string",
+          description: "Semver segment to bump: patch, minor, or major",
+        },
+        push: { type: "boolean" },
+        preview: { type: "boolean" },
+      },
+      required: ["bumpType"],
+    },
+  },
   {
     name: "gflows_schema",
     description: "Return the gflows command schema JSON.",
@@ -159,6 +177,14 @@ async function runTool(
       if (args.push) argv.push("-p");
       else argv.push("-P");
       break;
+    case "gflows_release": {
+      const bumpType = String(args.bumpType ?? "patch");
+      argv.push("release", "up", bumpType);
+      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 +211,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,209 @@
+/**
+ * Quick release from the long-lived `dev` branch: bump, 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 } from "../version-bump.js";
+import { type FinishContext, runFinishPlan } from "./finish.js";
+
+/**
+ * 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 bumpType: BumpType | undefined = args.bumpType;
+  if (args.bumpDirection === "down") {
+    console.error(
+      "gflows release: only 'up' 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>'. Example: gflows release up patch",
+    );
+    process.exit(EXIT_USER);
+  }
+
+  if (!bumpType) {
+    if (!isTTY) {
+      console.error(
+        "gflows release: when not in a TTY, bump type is required. Example: 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 ?? "?";
+    bumpType = await selectPrompt<"patch" | "minor" | "major">({
+      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" },
+      ],
+    });
+  }
+
+  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;
+  }
+
+  const { 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("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}`);
+  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 (!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",
+        "-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).",
       "On conflict: gflows continue | gflows abort | gflows undo.",
       "Use gflows schema and AGENTS.md as source of truth.",
     ],
@@ -78,6 +87,7 @@ 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, 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,19 @@ async function runHubAction(cwd: string, action: string): Promise<void> {
     await dispatch(cwd, ["finish", "-y", push ? "-p" : "-P"]);
     return;
   }
+  if (action === "release") {
+    const bumpType = await selectPrompt<"patch" | "minor" | "major">({
+      message: "Bump version",
+      options: [
+        { label: "patch (x.y.Z)", value: "patch" },
+        { label: "minor (x.Y.0)", value: "minor" },
+        { label: "major (X.0.0)", value: "major" },
+      ],
+    });
+    const push = await confirmPrompt({ message: "Push after release?", initialValue: false });
+    await dispatch(cwd, ["release", "up", bumpType, "-y", push ? "-p" : "-P"]);
+    return;
+  }
   if (action === "sync") {
     const rebase = await confirmPrompt({
       message: "Rebase onto base (instead of merge)?",

package/src/parse.ts

@@ -234,7 +234,7 @@ 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;
     return undefined;
@@ -249,8 +249,8 @@ function resolveBump(positionals: string[]): {
   direction?: "up" | "down";
   type?: "patch" | "minor" | "major";
 } {
-  // 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];
   const direction = a === "up" || a === "down" ? a : undefined;
@@ -337,7 +337,9 @@ 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 };
+    command === "bump" || command === "release"
+      ? resolveBump(positionals)
+      : { direction: undefined, type: undefined };
   const configArgs = command === "config" ? resolveConfigArgs(positionals) : {};
 
   const branchNames =

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/soft-exit.ts

@@ -0,0 +1,36 @@
+/**
+ * Soft process.exit for hub-embedded command dispatch.
+ * Commands that call process.exit would otherwise kill the hub loop.
+ * @module soft-exit
+ */
+
+/**
+ * Thrown instead of terminating the process when soft-exit mode is active.
+ */
+export class SoftExitError extends Error {
+  /**
+   * @param code - Exit code the command requested.
+   */
+  constructor(readonly code: number) {
+    super(`process.exit(${code})`);
+    this.name = "SoftExitError";
+  }
+}
+
+/**
+ * Runs `fn` while intercepting `process.exit` as {@link SoftExitError}.
+ * Restores the real `process.exit` afterward.
+ */
+export async function runWithSoftExit<T>(fn: () => Promise<T>): Promise<T> {
+  const realExit = process.exit;
+  const softExit = ((code?: number) => {
+    throw new SoftExitError(code ?? 0);
+  }) as typeof process.exit;
+
+  process.exit = softExit;
+  try {
+    return await fn();
+  } finally {
+    process.exit = realExit;
+  }
+}

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,53 @@ 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 [bumpType, setBumpType] = useState<"patch" | "minor" | "major">("patch");
+
+  if (step === "type") {
+    return (
+      <WizardFrame title="Quick release from dev">
+        <InkSelect<"patch" | "minor" | "major">
+          message="Bump version"
+          options={[
+            { value: "patch", label: "patch (x.y.Z)" },
+            { value: "minor", label: "minor (x.Y.0)" },
+            { value: "major", label: "major (X.0.0)" },
+          ]}
+          onCancel={onCancel}
+          onSubmit={(t) => {
+            setBumpType(t);
+            setStep("push");
+          }}
+        />
+      </WizardFrame>
+    );
+  }
+
+  return (
+    <WizardFrame title={`Release · up ${bumpType}`}>
+      <InkConfirm
+        message="Push after release?"
+        initialValue={false}
+        onCancel={onCancel}
+        onSubmit={(push) => {
+          onDone(["release", "up", bumpType, "-y", push ? "-p" : "-P"]);
+        }}
+      />
+    </WizardFrame>
+  );
+}
+
 /**
  * Collects argv for `gflows sync …` entirely inside Ink.
  */

package/src/tui/hub.ts

@@ -7,6 +7,7 @@ import { render } from "ink";
 import React from "react";
 import { dispatch } from "../dispatch.js";
 import { PromptCancelledError } from "../prompts.js";
+import { runWithSoftExit, SoftExitError } from "../soft-exit.js";
 import { type HubSessionResult, HubShell } from "./HubShell.js";
 import { prepareStdinAfterInk } from "./stdin.js";
 
@@ -25,17 +26,22 @@ export async function runTuiHub(cwd: string): Promise<boolean> {
   if (!canUseTui()) return false;
 
   for (;;) {
+    // Ink needs a live, referenced stdin after waitEnter / Clack / prior unmount.
+    prepareStdinAfterInk();
     const result = await runHubSession(cwd);
     if (result.kind === "quit") break;
 
     if (result.kind === "run") {
-      // Ink unrefs stdin on unmount — re-arm before Clack / git prompts.
       prepareStdinAfterInk();
       console.log("");
       try {
-        await dispatch(cwd, result.argv);
+        // Many commands call process.exit on validation/success paths — trap them
+        // so the hub can show “press enter” and remount instead of dying.
+        await runWithSoftExit(() => dispatch(cwd, result.argv));
       } catch (err) {
-        if (!(err instanceof PromptCancelledError)) {
+        if (err instanceof SoftExitError) {
+          // Command already printed its output / error; continue to waitEnter.
+        } else if (!(err instanceof PromptCancelledError)) {
           console.error("gflows:", err instanceof Error ? err.message : String(err));
         }
       }
@@ -78,15 +84,18 @@ function runHubSession(cwd: string): Promise<HubSessionResult> {
 
 /**
  * Raw stdin “press enter” (no Clack / no Ink).
- * Ink unrefs stdin on unmount — we must ref it again or the process exits
- * before the user can return to the hub.
+ * Leaves stdin armed for the next Ink remount (does not pause/unref).
  */
 function waitEnterRaw(label: string): Promise<void> {
   return new Promise((resolve) => {
     const stdin = process.stdin;
     process.stdout.write(`${label}\n`);
     if (typeof stdin.setRawMode === "function") {
-      stdin.setRawMode(true);
+      try {
+        stdin.setRawMode(true);
+      } catch {
+        // ignore
+      }
     }
     stdin.resume();
     stdin.ref();
@@ -99,20 +108,17 @@ function waitEnterRaw(label: string): Promise<void> {
       }
     }
 
-    const cleanup = () => {
+    const finish = () => {
       stdin.off("data", onData);
-      if (typeof stdin.setRawMode === "function") {
-        stdin.setRawMode(false);
-      }
-      stdin.pause();
-      stdin.unref();
+      // Critical: leave stdin ready for Ink remount (old code paused+unref'd → hub died).
+      prepareStdinAfterInk();
+      resolve();
     };
 
     const onData = (chunk: string | Buffer) => {
       const s = typeof chunk === "string" ? chunk : chunk.toString("utf8");
       if (s.includes("\r") || s.includes("\n") || s.includes("\x03")) {
-        cleanup();
-        resolve();
+        finish();
       }
     };
     stdin.on("data", onData);

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",