gflows 0.1.18 → 1.0.1

package/src/tui/HubShell.tsx

@@ -0,0 +1,193 @@
+/**
+ * Persistent Ink hub shell: home map + in-app wizards (no Clack drop-out for prompts).
+ * @module tui/HubShell
+ */
+
+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 { HubHome } from "./HubHome.js";
+import { WizardFrame } from "./prompts.js";
+import { SLASH_COMMANDS } from "./slash.js";
+
+const ACCENT = "#E88C4A";
+const MUTED = "#8A8A8A";
+const FG = "#E6E6E6";
+
+/** Outcome of one hub session (Ink unmounts after this). */
+export type HubSessionResult = { kind: "quit" } | { kind: "run"; argv: string[] };
+
+type Screen =
+  | { id: "home"; flash?: string }
+  | { id: "start" }
+  | { id: "finish" }
+  | { id: "sync" }
+  | { id: "list" }
+  | { id: "notice"; message: string };
+
+const DISPATCH_COMMANDS = new Set(
+  SLASH_COMMANDS.map((c) => c.name).filter(
+    (name) => !["start", "finish", "sync", "list", "viz", "quit", "exit", "q"].includes(name),
+  ),
+);
+
+/**
+ * Props for the hub shell.
+ */
+export interface HubShellProps {
+  cwd: string;
+  onDone: (result: HubSessionResult) => void;
+}
+
+/**
+ * Fullscreen hub with embedded wizards.
+ */
+export function HubShell({ cwd, onDone }: HubShellProps): React.ReactElement {
+  const { exit } = useApp();
+  const [screen, setScreen] = useState<Screen>({ id: "home" });
+
+  const finish = (result: HubSessionResult) => {
+    onDone(result);
+    exit();
+  };
+
+  const cancelWizard = () => setScreen({ id: "home" });
+  const runArgv = (argv: string[]) => finish({ kind: "run", argv });
+
+  const handleSlash = (raw: string) => {
+    const parts = raw.slice(1).trim().split(/\s+/);
+    const cmd = (parts[0] ?? "").toLowerCase();
+    const rest = parts.slice(1);
+
+    if (!cmd || cmd === "quit" || cmd === "exit" || cmd === "q") {
+      finish({ kind: "quit" });
+      return;
+    }
+
+    if (cmd === "start") {
+      if (rest.length >= 2) {
+        const type = rest[0] ?? "feature";
+        const name = rest[1] ?? "";
+        runArgv(["start", type, name, "-P", ...rest.slice(2)]);
+        return;
+      }
+      setScreen({ id: "start" });
+      return;
+    }
+    if (cmd === "finish") {
+      if (rest.length > 0) {
+        runArgv(["finish", "-y", "-P", ...rest]);
+        return;
+      }
+      setScreen({ id: "finish" });
+      return;
+    }
+    if (cmd === "sync") {
+      if (rest.length > 0) {
+        runArgv(["sync", "--force", ...rest]);
+        return;
+      }
+      setScreen({ id: "sync" });
+      return;
+    }
+    if (cmd === "list") {
+      setScreen({ id: "list" });
+      return;
+    }
+    if (cmd === "viz") {
+      setScreen({ id: "home", flash: "Branch map is shown on this screen." });
+      return;
+    }
+
+    if (!DISPATCH_COMMANDS.has(cmd)) {
+      setScreen({
+        id: "notice",
+        message: `Unknown /${cmd} — type / for command hints.`,
+      });
+      return;
+    }
+
+    runArgv([cmd, ...rest]);
+  };
+
+  const handleHome = (action: string) => {
+    if (action === "quit") {
+      finish({ kind: "quit" });
+      return;
+    }
+    if (action === "start") {
+      setScreen({ id: "start" });
+      return;
+    }
+    if (action === "finish") {
+      setScreen({ id: "finish" });
+      return;
+    }
+    if (action === "sync") {
+      setScreen({ id: "sync" });
+      return;
+    }
+    if (action === "list") {
+      setScreen({ id: "list" });
+      return;
+    }
+    runArgv([action]);
+  };
+
+  if (screen.id === "start") {
+    return <StartFlow onCancel={cancelWizard} onDone={runArgv} />;
+  }
+  if (screen.id === "finish") {
+    return <FinishFlow onCancel={cancelWizard} onDone={runArgv} />;
+  }
+  if (screen.id === "sync") {
+    return <SyncFlow onCancel={cancelWizard} onDone={runArgv} />;
+  }
+  if (screen.id === "list") {
+    return <ListFlow cwd={cwd} onDone={cancelWizard} />;
+  }
+  if (screen.id === "notice") {
+    return (
+      <PressEnter
+        title="Notice"
+        message={screen.message}
+        onDone={() => setScreen({ id: "home" })}
+      />
+    );
+  }
+
+  return (
+    <HubHome
+      cwd={cwd}
+      flash={screen.flash}
+      onAction={handleHome}
+      onSlash={handleSlash}
+      onQuit={() => finish({ kind: "quit" })}
+    />
+  );
+}
+
+function PressEnter({
+  title,
+  message,
+  onDone,
+}: {
+  title: string;
+  message: string;
+  onDone: () => void;
+}): React.ReactElement {
+  useInput((_ch, key) => {
+    if (key.return || key.escape) onDone();
+  });
+
+  return (
+    <WizardFrame title={title}>
+      <Text color={FG}>{message}</Text>
+      <Box marginTop={1}>
+        <Text color={MUTED}>Press enter to continue</Text>
+        <Text color={ACCENT}> █</Text>
+      </Box>
+    </WizardFrame>
+  );
+}

package/src/tui/flows.tsx

@@ -0,0 +1,229 @@
+/**
+ * Multi-step Ink wizards for hub actions (start / finish / sync / list).
+ * @module tui/flows
+ */
+
+import { Box, Text, useInput } from "ink";
+import type React from "react";
+import { useEffect, useState } from "react";
+import type { BranchType } from "../types.js";
+import { collectVizSnapshot, type VizSnapshot } from "../viz.js";
+import { InkConfirm, InkSelect, InkText, WizardFrame } from "./prompts.js";
+
+const MUTED = "#8A8A8A";
+const FG = "#E6E6E6";
+const GREEN = "#78C88C";
+const ACCENT = "#E88C4A";
+
+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>
+  );
+}
+
+/**
+ * Styled branch list inside the hub (no drop-out to plain stdout).
+ */
+export function ListFlow({ cwd, onDone }: { cwd: string; onDone: () => void }): React.ReactElement {
+  const [lines, setLines] = useState<string[] | null>(null);
+  const [error, setError] = useState<string | null>(null);
+
+  useEffect(() => {
+    let cancelled = false;
+    void (async () => {
+      try {
+        const snap = await collectVizSnapshot(cwd);
+        if (!cancelled) setLines(formatListLines(snap));
+      } catch (err) {
+        if (!cancelled) {
+          setError(err instanceof Error ? err.message : String(err));
+          setLines([]);
+        }
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [cwd]);
+
+  useInput((_ch, key) => {
+    if (key.return || key.escape || (key.ctrl && _ch === "c")) onDone();
+  });
+
+  return (
+    <WizardFrame title="Branches">
+      {lines === null ? (
+        <Text color={MUTED}>Loading…</Text>
+      ) : error ? (
+        <Text color={FG}>{error}</Text>
+      ) : (
+        <Box flexDirection="column">
+          {lines.map((line) => {
+            const current = line.includes("●");
+            return (
+              <Text key={line} color={current ? GREEN : FG} bold={current}>
+                {line}
+              </Text>
+            );
+          })}
+        </Box>
+      )}
+      <Box marginTop={1}>
+        <Text color={MUTED}>enter / esc return to hub</Text>
+        <Text color={ACCENT}> █</Text>
+      </Box>
+    </WizardFrame>
+  );
+}
+
+/**
+ * Formats a viz snapshot into hub list rows.
+ */
+function formatListLines(snap: VizSnapshot): string[] {
+  const lines: string[] = [];
+  if (snap.suspended) lines.push(`⚠ suspended: ${snap.suspended}`);
+  for (const row of snap.rows) {
+    if (row.type !== "main" && row.type !== "dev") continue;
+    const mark = row.current ? "●" : "○";
+    lines.push(`${mark} ${row.name}  [${row.type}]`);
+  }
+  const workflow = snap.rows.filter((r) => r.type !== "main" && r.type !== "dev");
+  if (workflow.length === 0) {
+    lines.push("  (no workflow branches)");
+  } else {
+    for (let i = 0; i < workflow.length; i++) {
+      const row = workflow[i];
+      if (!row) continue;
+      const elbow = i === workflow.length - 1 ? "└─" : "├─";
+      const mark = row.current ? "●" : "○";
+      const ab = row.ahead === 0 && row.behind === 0 ? "synced" : `+${row.ahead}/-${row.behind}`;
+      lines.push(`${elbow} ${mark} ${row.name}  (${row.type}) ${ab}`);
+    }
+  }
+  return lines;
+}

package/src/tui/hub.ts

@@ -0,0 +1,114 @@
+/**
+ * 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();
+        },
+      }),
+      {
+        // Keep hub off the primary scrollback so command output isn't stranded
+        // under a full-height cleared frame when we drop out for dispatch.
+        alternateScreen: true,
+        exitOnCtrlC: false,
+      },
+    );
+    void instance.waitUntilExit().then(() => {
+      done({ kind: "quit" });
+    });
+  });
+}
+
+/**
+ * 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.
+ */
+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);
+    }
+    stdin.resume();
+    stdin.ref();
+
+    // Drop buffered Enter from the hub key that launched this command.
+    if (typeof stdin.read === "function") {
+      for (;;) {
+        const pending = stdin.read();
+        if (pending === null) break;
+      }
+    }
+
+    const cleanup = () => {
+      stdin.off("data", onData);
+      if (typeof stdin.setRawMode === "function") {
+        stdin.setRawMode(false);
+      }
+      stdin.pause();
+      stdin.unref();
+    };
+
+    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();
+      }
+    };
+    stdin.on("data", onData);
+  });
+}