gflows 0.1.18 → 1.0.0

package/src/tui/flows.tsx

@@ -0,0 +1,140 @@
+/**
+ * Multi-step Ink wizards for hub actions (start / finish / sync).
+ * @module tui/flows
+ */
+
+import type React from "react";
+import { useState } from "react";
+import type { BranchType } from "../types.js";
+import { InkConfirm, InkSelect, InkText, WizardFrame } from "./prompts.js";
+
+const BRANCH_TYPES: BranchType[] = ["feature", "bugfix", "chore", "release", "hotfix", "spike"];
+
+/**
+ * Collects argv for `gflows start …` entirely inside Ink.
+ */
+export function StartFlow({
+  onDone,
+  onCancel,
+}: {
+  onDone: (argv: string[]) => void;
+  onCancel: () => void;
+}): React.ReactElement {
+  const [step, setStep] = useState<"type" | "name" | "push" | "fromMain">("type");
+  const [type, setType] = useState<BranchType>("feature");
+  const [name, setName] = useState("");
+  const [push, setPush] = useState(false);
+
+  if (step === "type") {
+    return (
+      <WizardFrame title="Start new work">
+        <InkSelect
+          message="Branch type"
+          options={BRANCH_TYPES.map((t) => ({ value: t, label: t }))}
+          onCancel={onCancel}
+          onSubmit={(t) => {
+            setType(t);
+            setStep("name");
+          }}
+        />
+      </WizardFrame>
+    );
+  }
+
+  if (step === "name") {
+    return (
+      <WizardFrame title={`Start · ${type}`}>
+        <InkText
+          message={type === "release" || type === "hotfix" ? "Version (vX.Y.Z)" : "Branch name"}
+          placeholder={type === "release" || type === "hotfix" ? "v1.0.0" : "my-thing"}
+          onCancel={onCancel}
+          onSubmit={(n) => {
+            setName(n);
+            setStep("push");
+          }}
+        />
+      </WizardFrame>
+    );
+  }
+
+  if (step === "push") {
+    return (
+      <WizardFrame title={`Start · ${type}/${name}`}>
+        <InkConfirm
+          message="Push after create?"
+          initialValue={false}
+          onCancel={onCancel}
+          onSubmit={(p) => {
+            setPush(p);
+            if (type === "bugfix") setStep("fromMain");
+            else onDone(["start", type, name, p ? "-p" : "-P"]);
+          }}
+        />
+      </WizardFrame>
+    );
+  }
+
+  // fromMain
+  return (
+    <WizardFrame title={`Start · bugfix/${name}`}>
+      <InkConfirm
+        message="Base from main (production fix)?"
+        initialValue={false}
+        onCancel={onCancel}
+        onSubmit={(fromMain) => {
+          const argv = ["start", type, name, push ? "-p" : "-P"];
+          if (fromMain) argv.push("-o", "main");
+          onDone(argv);
+        }}
+      />
+    </WizardFrame>
+  );
+}
+
+/**
+ * Collects argv for `gflows finish …` entirely inside Ink.
+ */
+export function FinishFlow({
+  onDone,
+  onCancel,
+}: {
+  onDone: (argv: string[]) => void;
+  onCancel: () => void;
+}): React.ReactElement {
+  return (
+    <WizardFrame title="Finish / merge branch">
+      <InkConfirm
+        message="Push after finish?"
+        initialValue={false}
+        onCancel={onCancel}
+        onSubmit={(push) => {
+          onDone(["finish", "-y", push ? "-p" : "-P"]);
+        }}
+      />
+    </WizardFrame>
+  );
+}
+
+/**
+ * Collects argv for `gflows sync …` entirely inside Ink.
+ */
+export function SyncFlow({
+  onDone,
+  onCancel,
+}: {
+  onDone: (argv: string[]) => void;
+  onCancel: () => void;
+}): React.ReactElement {
+  return (
+    <WizardFrame title="Sync with base">
+      <InkConfirm
+        message="Rebase onto base (instead of merge)?"
+        initialValue={false}
+        onCancel={onCancel}
+        onSubmit={(rebase) => {
+          onDone(["sync", ...(rebase ? ["--rebase"] : []), "--force"]);
+        }}
+      />
+    </WizardFrame>
+  );
+}

package/src/tui/hub.ts

@@ -0,0 +1,89 @@
+/**
+ * Ink hub runner — wizards stay in Ink; only git dispatch drops to the main screen.
+ * @module tui/hub
+ */
+
+import { render } from "ink";
+import React from "react";
+import { dispatch } from "../dispatch.js";
+import { type HubSessionResult, HubShell } from "./HubShell.js";
+
+/**
+ * Whether stdin/stdout can host the Ink hub.
+ */
+export function canUseTui(): boolean {
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+
+/**
+ * Runs the Ink fullscreen hub until quit.
+ * @returns true if the TUI ran, false if caller should use the legacy menu.
+ */
+export async function runTuiHub(cwd: string): Promise<boolean> {
+  if (!canUseTui()) return false;
+
+  for (;;) {
+    const result = await runHubSession(cwd);
+    if (result.kind === "quit") break;
+
+    if (result.kind === "run") {
+      console.log("");
+      try {
+        await dispatch(cwd, result.argv);
+      } catch (err) {
+        console.error("gflows:", err instanceof Error ? err.message : String(err));
+      }
+      console.log("");
+      await waitEnterRaw("Press enter to return to hub…");
+    }
+  }
+
+  return true;
+}
+
+function runHubSession(cwd: string): Promise<HubSessionResult> {
+  return new Promise((resolve) => {
+    let settled = false;
+    const done = (result: HubSessionResult) => {
+      if (settled) return;
+      settled = true;
+      resolve(result);
+    };
+    const instance = render(
+      React.createElement(HubShell, {
+        cwd,
+        onDone: (result) => {
+          done(result);
+          instance.unmount();
+        },
+      }),
+    );
+    void instance.waitUntilExit().then(() => {
+      done({ kind: "quit" });
+    });
+  });
+}
+
+/**
+ * Raw stdin “press enter” (no Clack / no Ink).
+ */
+function waitEnterRaw(label: string): Promise<void> {
+  return new Promise((resolve) => {
+    process.stdout.write(`${label}\n`);
+    if (typeof process.stdin.setRawMode === "function") {
+      process.stdin.setRawMode(true);
+    }
+    process.stdin.resume();
+    const onData = (chunk: string | Buffer) => {
+      const s = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+      if (s === "\r" || s === "\n" || s === "\x03") {
+        process.stdin.off("data", onData);
+        if (typeof process.stdin.setRawMode === "function") {
+          process.stdin.setRawMode(false);
+        }
+        resolve();
+      }
+    };
+    process.stdin.on("data", onData);
+  });
+}

package/src/tui/prompts.tsx

@@ -0,0 +1,207 @@
+/**
+ * Ink-native prompts used inside the hub (no Clack drop-out).
+ * @module tui/prompts
+ */
+
+import { Box, Text, useInput } from "ink";
+import type React from "react";
+import { useState } from "react";
+
+const ACCENT = "#E88C4A";
+const MUTED = "#8A8A8A";
+const FG = "#E6E6E6";
+
+/** Option for {@link InkSelect}. */
+export interface InkSelectOption<T extends string> {
+  value: T;
+  label: string;
+  hint?: string;
+}
+
+/**
+ * Arrow-key select list.
+ */
+export function InkSelect<T extends string>({
+  message,
+  options,
+  initialIndex = 0,
+  onSubmit,
+  onCancel,
+}: {
+  message: string;
+  options: InkSelectOption<T>[];
+  initialIndex?: number;
+  onSubmit: (value: T) => void;
+  onCancel?: () => void;
+}): React.ReactElement {
+  const [selected, setSelected] = useState(
+    Math.min(Math.max(0, initialIndex), Math.max(0, options.length - 1)),
+  );
+
+  useInput((ch, key) => {
+    if (key.escape || (key.ctrl && ch === "c")) {
+      onCancel?.();
+      return;
+    }
+    if (key.upArrow) {
+      setSelected((i) => Math.max(0, i - 1));
+      return;
+    }
+    if (key.downArrow) {
+      setSelected((i) => Math.min(options.length - 1, i + 1));
+      return;
+    }
+    if (key.return) {
+      const opt = options[selected];
+      if (opt) onSubmit(opt.value);
+    }
+  });
+
+  return (
+    <Box flexDirection="column">
+      <Text bold color={FG}>
+        {message}
+      </Text>
+      {options.map((opt, i) => {
+        const active = i === selected;
+        return (
+          <Text key={opt.value} color={active ? FG : MUTED} bold={active}>
+            {active ? <Text color={ACCENT}>❯ </Text> : "  "}
+            {opt.label}
+            {opt.hint ? <Text color={MUTED}>{`  ${opt.hint}`}</Text> : null}
+          </Text>
+        );
+      })}
+      <Text color={MUTED}>↑↓ · enter · esc cancel</Text>
+    </Box>
+  );
+}
+
+/**
+ * Yes/no confirm (←/→ or y/n).
+ */
+export function InkConfirm({
+  message,
+  initialValue = true,
+  onSubmit,
+  onCancel,
+}: {
+  message: string;
+  initialValue?: boolean;
+  onSubmit: (value: boolean) => void;
+  onCancel?: () => void;
+}): React.ReactElement {
+  const [value, setValue] = useState(initialValue);
+
+  useInput((ch, key) => {
+    if (key.escape || (key.ctrl && ch === "c")) {
+      onCancel?.();
+      return;
+    }
+    if (key.leftArrow || key.rightArrow || ch === " ") {
+      setValue((v) => !v);
+      return;
+    }
+    if (ch === "y" || ch === "Y") {
+      onSubmit(true);
+      return;
+    }
+    if (ch === "n" || ch === "N") {
+      onSubmit(false);
+      return;
+    }
+    if (key.return) onSubmit(value);
+  });
+
+  return (
+    <Box flexDirection="column">
+      <Text bold color={FG}>
+        {message}
+      </Text>
+      <Text>
+        <Text color={value ? ACCENT : MUTED} bold={value}>
+          {value ? "●" : "○"} Yes
+        </Text>
+        {"   "}
+        <Text color={!value ? ACCENT : MUTED} bold={!value}>
+          {!value ? "●" : "○"} No
+        </Text>
+      </Text>
+      <Text color={MUTED}>←→ / y n · enter · esc cancel</Text>
+    </Box>
+  );
+}
+
+/**
+ * Single-line text input.
+ */
+export function InkText({
+  message,
+  placeholder,
+  initialValue = "",
+  onSubmit,
+  onCancel,
+}: {
+  message: string;
+  placeholder?: string;
+  initialValue?: string;
+  onSubmit: (value: string) => void;
+  onCancel?: () => void;
+}): React.ReactElement {
+  const [value, setValue] = useState(initialValue);
+
+  useInput((ch, key) => {
+    if (key.escape || (key.ctrl && ch === "c")) {
+      onCancel?.();
+      return;
+    }
+    if (key.return) {
+      const out = value.trim() || (placeholder ?? "");
+      if (out) onSubmit(out);
+      return;
+    }
+    if (key.backspace || key.delete) {
+      setValue((s) => [...s].slice(0, -1).join(""));
+      return;
+    }
+    if (ch && !key.ctrl && !key.meta && ch >= " ") {
+      setValue((s) => s + ch);
+    }
+  });
+
+  return (
+    <Box flexDirection="column">
+      <Text bold color={FG}>
+        {message}
+      </Text>
+      <Text>
+        <Text color={ACCENT}>❯ </Text>
+        {value || <Text color={MUTED}>{placeholder ?? ""}</Text>}
+        <Text color={ACCENT}>█</Text>
+      </Text>
+      <Text color={MUTED}>type · enter · esc cancel</Text>
+    </Box>
+  );
+}
+
+/**
+ * Framed wizard chrome around a prompt step.
+ */
+export function WizardFrame({
+  title,
+  children,
+}: {
+  title: string;
+  children: React.ReactNode;
+}): React.ReactElement {
+  return (
+    <Box flexDirection="column" borderStyle="round" borderColor={ACCENT} paddingX={1} paddingY={0}>
+      <Text bold color={ACCENT}>
+        {title}
+      </Text>
+      <Box marginTop={1} flexDirection="column">
+        {children}
+      </Box>
+    </Box>
+  );
+}

package/src/types.ts

@@ -34,7 +34,42 @@ export type Command =
   | "completion"
   | "status"
   | "help"
-  | "version";
+  | "version"
+  | "sync"
+  | "pr"
+  | "doctor"
+  | "config"
+  | "schema"
+  | "continue"
+  | "undo"
+  | "abort"
+  | "mcp"
+  | "viz";
+
+/** All CLI commands in display order. */
+export const ALL_COMMANDS: Command[] = [
+  "init",
+  "start",
+  "finish",
+  "switch",
+  "delete",
+  "list",
+  "bump",
+  "sync",
+  "pr",
+  "viz",
+  "doctor",
+  "config",
+  "schema",
+  "continue",
+  "undo",
+  "abort",
+  "completion",
+  "status",
+  "help",
+  "version",
+  "mcp",
+];
 
 /** Branch prefix overrides per type (e.g. "feature" -> "feature/"). */
 export interface BranchPrefixes {
@@ -75,6 +110,9 @@ export type BumpDirection = "up" | "down";
 /** Bump type (semver segment). */
 export type BumpType = "patch" | "minor" | "major";
 
+/** Config subcommand for `gflows config`. */
+export type ConfigAction = "get" | "set";
+
 /** Parsed CLI arguments after resolving command, type, name, and flags. */
 export interface ParsedArgs {
   command: Command;
@@ -92,6 +130,12 @@ export interface ParsedArgs {
   bumpDirection?: BumpDirection;
   /** Bump type (patch | minor | major). */
   bumpType?: BumpType;
+  /** Config get/set action. */
+  configAction?: ConfigAction;
+  /** Config key (main, dev, remote, or prefixes.<type>). */
+  configKey?: string;
+  /** Config value for set. */
+  configValue?: string;
   // Common flags
   push: boolean;
   noPush: boolean;
@@ -107,7 +151,9 @@ export interface ParsedArgs {
   quiet: boolean;
   force: boolean;
   path: string | undefined;
-  // start
+  /** Raw --from / -o value (base branch override). */
+  from: string | undefined;
+  /** True when --from points at main (configured or literal). */
   fromMain: boolean;
   // finish
   noFf: boolean;
@@ -117,8 +163,21 @@ export interface ParsedArgs {
   noTag: boolean;
   tagMessage: string | undefined;
   message: string | undefined;
-  // list
+  squash: boolean;
+  preview: boolean;
+  bumpOnFinish: boolean;
+  // list / status
   includeRemote: boolean;
+  json: boolean;
+  // sync
+  rebase: boolean;
   // switch: explicit mode when uncommitted (overrides prompt)
   switchMode?: "restore" | "clean" | "cancel" | "move" | "destroy";
+  /**
+   * Optional package.json script name to wire to `gflows` during init
+   * (e.g. `"g"` → `bun run g -- start feature x`). Undefined = ask (TTY) or skip.
+   */
+  scriptAlias: string | undefined;
+  /** When true, never add a package.json script alias during init. */
+  noScriptAlias: boolean;
 }

package/src/ui.ts

@@ -0,0 +1,132 @@
+/**
+ * Modern terminal chrome shared by viz and the interactive hub.
+ * Lightweight ANSI panels (Claude Code / Codex–style), no TUI framework.
+ * @module ui
+ */
+
+const RESET = "\x1b[0m";
+const BOLD = "\x1b[1m";
+const DIM = "\x1b[2m";
+const CYAN = "\x1b[36m";
+const GREEN = "\x1b[32m";
+const YELLOW = "\x1b[33m";
+const MAGENTA = "\x1b[35m";
+const BLUE = "\x1b[34m";
+
+/**
+ * Whether stdout can use ANSI color.
+ */
+export function colorEnabled(): boolean {
+  if (process.env.NO_COLOR) return false;
+  return typeof process.stdout.isTTY === "boolean" && process.stdout.isTTY;
+}
+
+/**
+ * Wraps text in an ANSI code when color is enabled.
+ */
+export function paint(code: string, text: string): string {
+  return colorEnabled() ? `${code}${text}${RESET}` : text;
+}
+
+/** Shared ANSI codes for callers that compose styles. */
+export const ansi = {
+  reset: RESET,
+  bold: BOLD,
+  dim: DIM,
+  cyan: CYAN,
+  green: GREEN,
+  yellow: YELLOW,
+  magenta: MAGENTA,
+  blue: BLUE,
+} as const;
+
+const ESC = "\u001b";
+const ANSI_RE = new RegExp(`${ESC}\\[[0-9;]*m`, "g");
+const ANSI_PREFIX_RE = new RegExp(`^${ESC}\\[[0-9;]*m`);
+
+/**
+ * Visible length of a string ignoring ANSI escape sequences.
+ */
+export function visibleLength(text: string): number {
+  return text.replace(ANSI_RE, "").length;
+}
+
+/**
+ * Pads or soft-truncates a line to a target visible width.
+ */
+export function padVisible(text: string, width: number): string {
+  const len = visibleLength(text);
+  if (len === width) return text;
+  if (len < width) return text + " ".repeat(width - len);
+  let out = "";
+  let vis = 0;
+  let i = 0;
+  while (i < text.length && vis < width - 1) {
+    if (text[i] === ESC) {
+      const m = text.slice(i).match(ANSI_PREFIX_RE);
+      if (m) {
+        out += m[0];
+        i += m[0].length;
+        continue;
+      }
+    }
+    out += text[i];
+    vis++;
+    i++;
+  }
+  return `${out}…`;
+}
+
+/**
+ * Renders a rounded status panel (title bar + body rows).
+ */
+export function renderPanel(title: string, body: string[], width = 56): string[] {
+  const inner = Math.max(24, width - 2);
+  const labeled = `─ ${title} `;
+  const fill = Math.max(0, inner - visibleLength(labeled));
+  const top = paint(CYAN + BOLD, `╭${labeled}${"─".repeat(fill)}╮`);
+  const bottom = paint(DIM, `╰${"─".repeat(inner)}╯`);
+  const rows = body.map((line) => {
+    const content = padVisible(` ${line}`, inner);
+    return `${paint(DIM, "│")}${content}${paint(DIM, "│")}`;
+  });
+  return [top, ...rows, bottom];
+}
+
+/**
+ * Section header.
+ */
+export function section(title: string): string {
+  return paint(BOLD, title);
+}
+
+/**
+ * Dim horizontal rule.
+ */
+export function rule(width = 56): string {
+  return paint(DIM, "─".repeat(width));
+}
+
+/**
+ * Accent arrow for recommended next step.
+ */
+export function recommendLine(label: string): string {
+  return `${paint(GREEN + BOLD, "→")} ${paint(BOLD, label)}`;
+}
+
+/**
+ * Chip / badge text.
+ */
+export function chip(text: string, tone: "ok" | "warn" | "info" | "muted" = "muted"): string {
+  const code = tone === "ok" ? GREEN : tone === "warn" ? YELLOW : tone === "info" ? CYAN : DIM;
+  return paint(code, `[${text}]`);
+}
+
+/**
+ * Keyboard hint footer.
+ */
+export function keyHints(pairs: Array<[string, string]>): string {
+  return pairs
+    .map(([key, label]) => `${paint(BOLD, key)} ${paint(DIM, label)}`)
+    .join(paint(DIM, "  ·  "));
+}

package/src/version.ts

@@ -0,0 +1,24 @@
+/**
+ * Package version helper for CLI chrome and schema.
+ * @module version
+ */
+
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+/**
+ * Reads the installed/package version from package.json.
+ */
+export function getVersion(): string {
+  try {
+    const pkgPath = join(__dirname, "..", "package.json");
+    const raw = readFileSync(pkgPath, "utf-8");
+    const pkg = JSON.parse(raw) as { version?: string };
+    return pkg.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}