gflows 1.0.2 → 1.0.4

package/CHANGELOG.md

@@ -7,6 +7,23 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.0.4] - 2026-07-25
+
+### Fixed
+
+- Hub switch flow typecheck when HEAD is detached (`current` may be null)
+
+## [1.0.3] - 2026-07-25
+
+### Fixed
+
+- Hub interactive actions no longer freeze/exit after Ink unmount (`stdin.ref` before dispatch; Clack cancel no longer `process.exit`s the hub)
+- `/switch`, `/init`, `/bump` wizards run inside Ink (same as start/list)
+
+### Changed
+
+- Local `bun run g` script invokes `src/cli.ts` so the hub gets a real TTY
+
 ## [1.0.2] - 2026-07-25
 
 ### Changed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gflows",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "author": "Ali AlNaghmoush (https://github.com/alialnaghmoush)",
   "repository": {
     "type": "git",
@@ -39,7 +39,8 @@
     "gflows": "bun run src/cli.ts",
     "publish:all": "bun run scripts/publish.ts",
     "publish:npm": "bun run scripts/publish.ts -- --npm-only",
-    "publish:jsr": "bun run scripts/publish.ts -- --jsr-only"
+    "publish:jsr": "bun run scripts/publish.ts -- --jsr-only",
+    "g": "bun run src/cli.ts"
   },
   "type": "module",
   "dependencies": {

package/src/cli.ts

@@ -9,6 +9,7 @@
 import { EXIT_GIT, EXIT_OK, EXIT_USER } from "./constants.js";
 import { exitCodeForError, printError } from "./errors.js";
 import { parse } from "./parse.js";
+import { PromptCancelledError } from "./prompts.js";
 import type { ParsedArgs } from "./types.js";
 
 /** Last parsed args, set at start of run(); used by catch/rejection to respect -v for stack trace. */
@@ -27,7 +28,10 @@ async function run(): Promise<void> {
       await runHub(process.cwd());
       return;
     }
-    console.error("gflows: missing command. Use 'gflows help' for usage.");
+    console.error(
+      "gflows: no interactive TTY. Run `gflows` directly (or `alias g=gflows`), not via a bun/npm script that swallows stdin.",
+    );
+    console.error("Or pass a command: gflows help");
     process.exit(EXIT_USER);
   }
 
@@ -76,6 +80,10 @@ function main(): void {
     })
     .catch((err: unknown) => {
       if (exitCode !== null) return;
+      if (err instanceof PromptCancelledError) {
+        process.exit(EXIT_OK);
+        return;
+      }
       printError(err);
       const verbose = lastParsedArgs?.verbose ?? !!process.env.GFLOWS_VERBOSE;
       if (verbose && err instanceof Error && err.stack) {

package/src/prompts.ts

@@ -6,12 +6,26 @@
 import * as clack from "@clack/prompts";
 
 /**
- * Exits the process when the user cancels a prompt (Ctrl+C / Escape).
+ * Thrown when the user cancels a Clack prompt (Ctrl+C / Escape).
+ * Callers (CLI / hub) should treat this as a soft abort — do not kill the hub loop via process.exit.
+ */
+export class PromptCancelledError extends Error {
+  /**
+   * Creates a cancellation error.
+   */
+  constructor() {
+    super("Cancelled.");
+    this.name = "PromptCancelledError";
+  }
+}
+
+/**
+ * Converts Clack cancel symbols into {@link PromptCancelledError}.
  */
 function exitIfCancel<T>(value: T | symbol): asserts value is T {
   if (clack.isCancel(value)) {
     clack.cancel("Cancelled.");
-    process.exit(0);
+    throw new PromptCancelledError();
   }
 }
 

package/src/tui/HubShell.tsx

@@ -6,7 +6,15 @@
 import { Box, Text, useApp, useInput } from "ink";
 import type React from "react";
 import { useState } from "react";
-import { FinishFlow, ListFlow, StartFlow, SyncFlow } from "./flows.js";
+import {
+  BumpFlow,
+  FinishFlow,
+  InitFlow,
+  ListFlow,
+  StartFlow,
+  SwitchFlow,
+  SyncFlow,
+} from "./flows.js";
 import { HubHome } from "./HubHome.js";
 import { WizardFrame } from "./prompts.js";
 import { SLASH_COMMANDS } from "./slash.js";
@@ -25,6 +33,9 @@ type Screen =
   | { id: "finish" }
   | { id: "sync" }
   | { id: "list" }
+  | { id: "switch" }
+  | { id: "init" }
+  | { id: "bump" }
   | { id: "doctor" }
   | { id: "help" }
   | { id: "status" }
@@ -32,13 +43,10 @@ type Screen =
   | { id: "version" }
   | { id: "notice"; message: string };
 
-/** Commands that leave Ink for git / side effects. */
+/** Commands that leave Ink for git / side effects (no interactive Clack). */
 const DISPATCH_COMMANDS = new Set([
-  "init",
   "pr",
   "continue",
-  "switch",
-  "bump",
   "delete",
   "undo",
   "abort",
@@ -84,6 +92,15 @@ export function HubShell({ cwd, onDone }: HubShellProps): React.ReactElement {
       case "list":
         setScreen({ id: "list" });
         return true;
+      case "switch":
+        setScreen({ id: "switch" });
+        return true;
+      case "init":
+        setScreen({ id: "init" });
+        return true;
+      case "bump":
+        setScreen({ id: "bump" });
+        return true;
       case "doctor":
         setScreen({ id: "doctor" });
         return true;
@@ -147,6 +164,18 @@ export function HubShell({ cwd, onDone }: HubShellProps): React.ReactElement {
       runArgv(["config", ...rest]);
       return;
     }
+    if (cmd === "switch" && rest.length > 0) {
+      runArgv(["switch", ...rest]);
+      return;
+    }
+    if (cmd === "bump" && rest.length > 0) {
+      runArgv(["bump", ...rest]);
+      return;
+    }
+    if (cmd === "init" && rest.length > 0) {
+      runArgv(["init", ...rest]);
+      return;
+    }
 
     if (openInHub(cmd)) return;
 
@@ -190,6 +219,15 @@ export function HubShell({ cwd, onDone }: HubShellProps): React.ReactElement {
   if (screen.id === "list") {
     return <ListFlow cwd={cwd} onDone={cancelWizard} />;
   }
+  if (screen.id === "switch") {
+    return <SwitchFlow cwd={cwd} onCancel={cancelWizard} onDone={runArgv} />;
+  }
+  if (screen.id === "init") {
+    return <InitFlow onCancel={cancelWizard} onDone={runArgv} />;
+  }
+  if (screen.id === "bump") {
+    return <BumpFlow onCancel={cancelWizard} onDone={runArgv} />;
+  }
   if (screen.id === "doctor") {
     return <DoctorView cwd={cwd} onDone={cancelWizard} />;
   }

package/src/tui/flows.tsx

@@ -1,17 +1,24 @@
 /**
- * Multi-step Ink wizards for hub actions (start / finish / sync / list).
+ * Multi-step Ink wizards for hub actions (start / finish / sync / list / switch / …).
  * @module tui/flows
  */
 
+import { Text } from "ink";
 import type React from "react";
 import { useEffect, useState } from "react";
+import { resolveConfig } from "../config.js";
+import { branchList, getCurrentBranch, isClean, resolveRepoRoot } from "../git.js";
 import type { BranchType } from "../types.js";
 import { collectVizSnapshot, type VizSnapshot } from "../viz.js";
 import { type HubPanelLine, HubScrollPanel } from "./panels.js";
 import { InkConfirm, InkSelect, InkText, WizardFrame } from "./prompts.js";
 
+const MUTED = "#8A8A8A";
+
 const BRANCH_TYPES: BranchType[] = ["feature", "bugfix", "chore", "release", "hotfix", "spike"];
 
+type SwitchMode = "move" | "restore" | "clean" | "destroy" | "cancel";
+
 /**
  * Collects argv for `gflows start …` entirely inside Ink.
  */
@@ -141,6 +148,268 @@ export function SyncFlow({
   );
 }
 
+/**
+ * Switch-branch wizard entirely inside Ink (avoids dead Clack after Ink unmount).
+ */
+export function SwitchFlow({
+  cwd,
+  onDone,
+  onCancel,
+}: {
+  cwd: string;
+  onDone: (argv: string[]) => void;
+  onCancel: () => void;
+}): React.ReactElement {
+  const [step, setStep] = useState<"load" | "pick" | "dirty" | "error">("load");
+  const [choices, setChoices] = useState<{ value: string; label: string }[]>([]);
+  const [target, setTarget] = useState("");
+  const [error, setError] = useState<string | null>(null);
+  const [initialIndex, setInitialIndex] = useState(0);
+
+  useEffect(() => {
+    let cancelled = false;
+    void (async () => {
+      try {
+        const root = await resolveRepoRoot(cwd);
+        const config = resolveConfig(root, {}, {});
+        const allLocal = await branchList(root, { dryRun: false, verbose: false });
+        const workflow = BRANCH_TYPES.map((t) => config.prefixes[t])
+          .filter(Boolean)
+          .flatMap((prefix) => allLocal.filter((b) => b.startsWith(prefix)));
+        const mainAndDev = [config.main, config.dev].filter((b) => allLocal.includes(b));
+        const names = [...mainAndDev, ...[...new Set(workflow)].sort()];
+        const current = await getCurrentBranch(root, {});
+        if (cancelled) return;
+        if (names.length === 0) {
+          setError("No branches found.");
+          setStep("error");
+          return;
+        }
+        const opts = names.map((b) => ({
+          value: b,
+          label: current && b === current ? `${b} (current)` : b,
+        }));
+        setChoices(opts);
+        setInitialIndex(Math.max(0, current ? names.indexOf(current) : 0));
+        setStep("pick");
+      } catch (err) {
+        if (!cancelled) {
+          setError(err instanceof Error ? err.message : String(err));
+          setStep("error");
+        }
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [cwd]);
+
+  if (step === "load") {
+    return (
+      <WizardFrame title="Switch branch">
+        <Text color={MUTED}>Loading…</Text>
+      </WizardFrame>
+    );
+  }
+
+  if (step === "error") {
+    return (
+      <HubScrollPanel
+        title="Switch branch"
+        lines={[{ id: "e", text: error ?? "Unknown error", tone: "bad" }]}
+        onDone={onCancel}
+      />
+    );
+  }
+
+  if (step === "pick") {
+    return (
+      <WizardFrame title="Switch branch">
+        <InkSelect
+          message="Switch to branch"
+          options={choices}
+          initialIndex={initialIndex}
+          onCancel={onCancel}
+          onSubmit={(branch) => {
+            void (async () => {
+              setTarget(branch);
+              try {
+                const root = await resolveRepoRoot(cwd);
+                const clean = await isClean(root, {});
+                if (clean) {
+                  onDone(["switch", branch]);
+                  return;
+                }
+                setStep("dirty");
+              } catch (err) {
+                setError(err instanceof Error ? err.message : String(err));
+                setStep("error");
+              }
+            })();
+          }}
+        />
+      </WizardFrame>
+    );
+  }
+
+  // dirty
+  return (
+    <WizardFrame title={`Switch · ${target}`}>
+      <InkSelect<SwitchMode>
+        message="Working tree has uncommitted changes"
+        options={[
+          { value: "move", label: "Move", hint: "carry changes to target" },
+          { value: "restore", label: "Restore", hint: "stash here, restore target" },
+          { value: "clean", label: "Clean", hint: "discard changes" },
+          { value: "destroy", label: "Destroy", hint: "delete current branch" },
+          { value: "cancel", label: "Cancel", hint: "abort switch" },
+        ]}
+        onCancel={onCancel}
+        onSubmit={(mode) => {
+          if (mode === "cancel") {
+            onCancel();
+            return;
+          }
+          onDone(["switch", target, `--${mode}`]);
+        }}
+      />
+    </WizardFrame>
+  );
+}
+
+/**
+ * Init wizard inside Ink; dispatches with -y so CLI skips Clack prompts.
+ */
+export function InitFlow({
+  onDone,
+  onCancel,
+}: {
+  onDone: (argv: string[]) => void;
+  onCancel: () => void;
+}): React.ReactElement {
+  const [step, setStep] = useState<"main" | "dev" | "remote" | "alias">("main");
+  const [main, setMain] = useState("main");
+  const [dev, setDev] = useState("dev");
+  const [remote, setRemote] = useState("origin");
+
+  if (step === "main") {
+    return (
+      <WizardFrame title="Initialize repo">
+        <InkText
+          message="Main branch name"
+          placeholder="main"
+          initialValue="main"
+          onCancel={onCancel}
+          onSubmit={(v) => {
+            setMain(v || "main");
+            setStep("dev");
+          }}
+        />
+      </WizardFrame>
+    );
+  }
+  if (step === "dev") {
+    return (
+      <WizardFrame title="Initialize repo">
+        <InkText
+          message="Dev branch name"
+          placeholder="dev"
+          initialValue="dev"
+          onCancel={onCancel}
+          onSubmit={(v) => {
+            setDev(v || "dev");
+            setStep("remote");
+          }}
+        />
+      </WizardFrame>
+    );
+  }
+  if (step === "remote") {
+    return (
+      <WizardFrame title="Initialize repo">
+        <InkText
+          message="Remote name"
+          placeholder="origin"
+          initialValue="origin"
+          onCancel={onCancel}
+          onSubmit={(v) => {
+            setRemote(v || "origin");
+            setStep("alias");
+          }}
+        />
+      </WizardFrame>
+    );
+  }
+
+  return (
+    <WizardFrame title="Initialize repo">
+      <InkSelect
+        message="Add package.json script alias?"
+        options={[
+          { value: "g", label: 'script "g"', hint: "prefer: alias g=gflows in shell" },
+          { value: "gflows", label: 'script "gflows"' },
+          { value: "skip", label: "Skip", hint: "shell alias is best for hub TTY" },
+        ]}
+        onCancel={onCancel}
+        onSubmit={(alias) => {
+          const argv = ["init", "-y", "-P", "--main", main, "--dev", dev, "--remote", remote];
+          if (alias === "skip") argv.push("--no-script-alias");
+          else argv.push("--script-alias", alias);
+          onDone(argv);
+        }}
+      />
+    </WizardFrame>
+  );
+}
+
+/**
+ * Bump wizard inside Ink.
+ */
+export function BumpFlow({
+  onDone,
+  onCancel,
+}: {
+  onDone: (argv: string[]) => void;
+  onCancel: () => void;
+}): React.ReactElement {
+  const [step, setStep] = useState<"dir" | "type">("dir");
+  const [direction, setDirection] = useState<"up" | "down">("up");
+
+  if (step === "dir") {
+    return (
+      <WizardFrame title="Bump version">
+        <InkSelect<"up" | "down">
+          message="Direction"
+          options={[
+            { value: "up", label: "Up (bump)" },
+            { value: "down", label: "Down (rollback)" },
+          ]}
+          onCancel={onCancel}
+          onSubmit={(d) => {
+            setDirection(d);
+            setStep("type");
+          }}
+        />
+      </WizardFrame>
+    );
+  }
+
+  return (
+    <WizardFrame title={`Bump · ${direction}`}>
+      <InkSelect<"patch" | "minor" | "major">
+        message="Semver part"
+        options={[
+          { value: "patch", label: "patch" },
+          { value: "minor", label: "minor" },
+          { value: "major", label: "major" },
+        ]}
+        onCancel={onCancel}
+        onSubmit={(type) => onDone(["bump", direction, type])}
+      />
+    </WizardFrame>
+  );
+}
+
 /**
  * Styled branch list inside the hub (no drop-out to plain stdout).
  */

package/src/tui/hub.ts

@@ -6,7 +6,9 @@
 import { render } from "ink";
 import React from "react";
 import { dispatch } from "../dispatch.js";
+import { PromptCancelledError } from "../prompts.js";
 import { type HubSessionResult, HubShell } from "./HubShell.js";
+import { prepareStdinAfterInk } from "./stdin.js";
 
 /**
  * Whether stdin/stdout can host the Ink hub.
@@ -27,11 +29,15 @@ export async function runTuiHub(cwd: string): Promise<boolean> {
     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);
       } catch (err) {
-        console.error("gflows:", err instanceof Error ? err.message : String(err));
+        if (!(err instanceof PromptCancelledError)) {
+          console.error("gflows:", err instanceof Error ? err.message : String(err));
+        }
       }
       console.log("");
       await waitEnterRaw("Press enter to return to hub…");

package/src/tui/stdin.ts

@@ -0,0 +1,28 @@
+/**
+ * Stdin helpers for surviving Ink teardown before Clack / dispatch.
+ * @module tui/stdin
+ */
+
+/**
+ * Re-arm process.stdin after Ink unmounts (Ink calls `stdin.unref()`).
+ * Without this, interactive Clack prompts paint once then the process exits.
+ */
+export function prepareStdinAfterInk(): void {
+  const stdin = process.stdin;
+  if (typeof stdin.setRawMode === "function") {
+    try {
+      stdin.setRawMode(false);
+    } catch {
+      // ignore — may already be non-raw / closed
+    }
+  }
+  stdin.resume();
+  stdin.ref();
+
+  if (typeof stdin.read === "function") {
+    for (;;) {
+      const pending = stdin.read();
+      if (pending === null) break;
+    }
+  }
+}