gflows 0.1.18 → 1.0.1

package/src/commands/config.ts

@@ -0,0 +1,123 @@
+/**
+ * Config get/set for .gflows.json.
+ * @module commands/config
+ */
+
+import { readConfigFile, resolveConfig, writeConfigFile } from "../config.js";
+import { EXIT_USER } from "../constants.js";
+import { resolveRepoRoot } from "../git.js";
+import { hint, success } from "../out.js";
+import type { BranchType, GflowsConfigFile, ParsedArgs } from "../types.js";
+
+const PREFIX_TYPES: BranchType[] = ["feature", "bugfix", "chore", "release", "hotfix", "spike"];
+
+/**
+ * get/set gflows configuration.
+ */
+export async function run(args: ParsedArgs): Promise<void> {
+  const repoRoot = await resolveRepoRoot(args.cwd);
+  const isTTY = Boolean(process.stdin.isTTY);
+
+  let action = args.configAction;
+  let key = args.configKey;
+  let value = args.configValue;
+
+  if (!action && isTTY) {
+    const { inputPrompt, selectPrompt } = await import("../prompts.js");
+    action = await selectPrompt<"get" | "set">({
+      message: "Config action",
+      options: [
+        { label: "get", value: "get" },
+        { label: "set", value: "set" },
+      ],
+    });
+    key = await inputPrompt({ message: "Key (main|dev|remote|prefixes.<type>)" });
+    if (action === "set") {
+      value = await inputPrompt({ message: "Value" });
+    }
+  }
+
+  if (!action || (action !== "get" && action !== "set")) {
+    console.error(
+      "gflows config: use `gflows config get <key>` or `gflows config set <key> <value>`.",
+    );
+    process.exit(EXIT_USER);
+  }
+  if (!key) {
+    console.error("gflows config: missing key.");
+    process.exit(EXIT_USER);
+  }
+
+  const resolved = resolveConfig(
+    repoRoot,
+    { main: args.main, dev: args.dev, remote: args.remote },
+    { verbose: args.verbose },
+  );
+
+  if (action === "get") {
+    const out = getValue(resolved, key);
+    if (out === undefined) {
+      console.error(`gflows config: unknown key '${key}'.`);
+      process.exit(EXIT_USER);
+    }
+    if (args.json) {
+      console.log(JSON.stringify({ [key]: out }, null, 2));
+    } else {
+      console.log(String(out));
+    }
+    return;
+  }
+
+  if (value === undefined || value === "") {
+    console.error("gflows config set: missing value.");
+    process.exit(EXIT_USER);
+  }
+
+  const current = readConfigFile(repoRoot).config ?? {};
+  const next = setValue(current, key, value);
+  if (!args.dryRun) {
+    writeConfigFile(repoRoot, next);
+  }
+  if (!args.quiet) {
+    success(`gflows: set ${key} = ${value}`);
+  }
+  hint("Stored in .gflows.json");
+}
+
+function getValue(resolved: ReturnType<typeof resolveConfig>, key: string): string | undefined {
+  if (key === "main") return resolved.main;
+  if (key === "dev") return resolved.dev;
+  if (key === "remote") return resolved.remote;
+  if (key.startsWith("prefixes.")) {
+    const t = key.slice("prefixes.".length) as BranchType;
+    if (PREFIX_TYPES.includes(t)) return resolved.prefixes[t];
+  }
+  return undefined;
+}
+
+function setValue(current: GflowsConfigFile, key: string, value: string): GflowsConfigFile {
+  const next: GflowsConfigFile = { ...current, prefixes: { ...current.prefixes } };
+  if (key === "main") {
+    next.main = value;
+    return next;
+  }
+  if (key === "dev") {
+    next.dev = value;
+    return next;
+  }
+  if (key === "remote") {
+    next.remote = value;
+    return next;
+  }
+  if (key.startsWith("prefixes.")) {
+    const t = key.slice("prefixes.".length) as BranchType;
+    if (!PREFIX_TYPES.includes(t)) {
+      console.error(`gflows config: unknown prefix type '${t}'.`);
+      process.exit(EXIT_USER);
+    }
+    next.prefixes = { ...next.prefixes, [t]: value };
+    return next;
+  }
+  console.error(`gflows config: unknown key '${key}'.`);
+  process.exit(EXIT_USER);
+}

package/src/commands/continue.ts

@@ -0,0 +1,40 @@
+/**
+ * Continue a suspended gflows multi-step operation after resolving conflicts.
+ * @module commands/continue
+ */
+
+import { EXIT_USER } from "../constants.js";
+import { resolveRepoRoot } from "../git.js";
+import { hint } from "../out.js";
+import { readActiveRun } from "../run-state.js";
+import type { ParsedArgs } from "../types.js";
+import { executeFinishSteps } from "./finish.js";
+
+/**
+ * Resumes the active suspended run (finish, sync, …).
+ */
+export async function run(args: ParsedArgs): Promise<void> {
+  const repoRoot = await resolveRepoRoot(args.cwd);
+  const state = readActiveRun(repoRoot);
+  if (!state || (state.status !== "suspended" && state.status !== "running")) {
+    console.error("gflows continue: no suspended operation to continue.");
+    hint("If you hit a merge conflict during finish/sync, resolve it, then retry continue.");
+    process.exit(EXIT_USER);
+  }
+
+  const opts = { dryRun: args.dryRun, verbose: args.verbose, quiet: args.quiet };
+
+  if (state.command === "finish") {
+    await executeFinishSteps(repoRoot, state, opts);
+    return;
+  }
+
+  if (state.command === "sync") {
+    const { executeSyncSteps } = await import("./sync.js");
+    await executeSyncSteps(repoRoot, state, opts);
+    return;
+  }
+
+  console.error(`gflows continue: unknown suspended command '${state.command}'.`);
+  process.exit(EXIT_USER);
+}

package/src/commands/delete.ts

@@ -91,13 +91,13 @@ export async function run(args: ParsedArgs): Promise<void> {
     process.exit(EXIT_USER);
   }
 
-  const { checkbox } = await import("@inquirer/prompts");
-  const chosen = await checkbox({
+  const { multiSelectPrompt } = await import("../prompts.js");
+  const chosen = await multiSelectPrompt({
     message: "Delete branch(es)",
-    choices: workflowBranches.map((b) => ({ name: b, value: b })),
+    options: workflowBranches.map((b) => ({ label: b, value: b })),
   });
 
-  if (!Array.isArray(chosen) || chosen.length === 0) {
+  if (chosen.length === 0) {
     if (!quiet) {
       console.error("No branches selected.");
     }

package/src/commands/doctor.ts

@@ -0,0 +1,143 @@
+/**
+ * Doctor: check whether the repo is ready for gflows workflows.
+ * @module commands/doctor
+ */
+
+import { readConfigFile, resolveConfig } from "../config.js";
+import {
+  getCurrentBranch,
+  isClean,
+  isDetachedHead,
+  isRebaseOrMergeInProgress,
+  resolveRepoRoot,
+  revParse,
+  runGit,
+} from "../git.js";
+import { hint, success } from "../out.js";
+import { readActiveRun } from "../run-state.js";
+import type { ParsedArgs } from "../types.js";
+
+interface Check {
+  ok: boolean;
+  name: string;
+  detail: string;
+}
+
+/**
+ * Runs health checks and prints a report (or JSON).
+ */
+export async function run(args: ParsedArgs): Promise<void> {
+  let repoRoot: string;
+  try {
+    repoRoot = await resolveRepoRoot(args.cwd);
+  } catch (err) {
+    if (args.json) {
+      console.log(JSON.stringify({ ok: false, error: String(err) }, null, 2));
+      process.exit(2);
+    }
+    throw err;
+  }
+
+  const config = resolveConfig(
+    repoRoot,
+    { main: args.main, dev: args.dev, remote: args.remote },
+    { verbose: args.verbose },
+  );
+  const cfgRead = readConfigFile(repoRoot);
+  const checks: Check[] = [];
+
+  checks.push({
+    ok: true,
+    name: "git-repo",
+    detail: repoRoot,
+  });
+
+  const mainOk = await revParse(repoRoot, config.main, [], { verbose: false }).then(
+    () => true,
+    () => false,
+  );
+  checks.push({
+    ok: mainOk,
+    name: "main-branch",
+    detail: mainOk ? `found '${config.main}'` : `missing '${config.main}' — create it first`,
+  });
+
+  const devOk = await revParse(repoRoot, config.dev, [], { verbose: false }).then(
+    () => true,
+    () => false,
+  );
+  checks.push({
+    ok: devOk,
+    name: "dev-branch",
+    detail: devOk ? `found '${config.dev}'` : `missing '${config.dev}' — run gflows init`,
+  });
+
+  const remoteList = await runGit(["remote"], { cwd: repoRoot });
+  const hasRemote = remoteList.stdout
+    .split("\n")
+    .map((s) => s.trim())
+    .includes(config.remote);
+  checks.push({
+    ok: hasRemote,
+    name: "remote",
+    detail: hasRemote
+      ? `remote '${config.remote}' configured`
+      : `remote '${config.remote}' missing (push will fail)`,
+  });
+
+  checks.push({
+    ok: !cfgRead.invalid,
+    name: "config",
+    detail: cfgRead.invalid
+      ? "config file invalid — using defaults"
+      : cfgRead.config
+        ? "config loaded"
+        : "using defaults (no .gflows.json)",
+  });
+
+  const detached = await isDetachedHead(repoRoot);
+  checks.push({
+    ok: !detached,
+    name: "head",
+    detail: detached ? "detached HEAD" : `on ${(await getCurrentBranch(repoRoot)) ?? "?"}`,
+  });
+
+  const inProgress = isRebaseOrMergeInProgress(repoRoot);
+  const active = readActiveRun(repoRoot);
+  checks.push({
+    ok: !inProgress && !active,
+    name: "run-state",
+    detail: active
+      ? `suspended '${active.command}' — gflows continue | abort | undo`
+      : inProgress
+        ? "git merge/rebase in progress — gflows continue or abort"
+        : "clean",
+  });
+
+  const clean = await isClean(repoRoot);
+  checks.push({
+    ok: true,
+    name: "working-tree",
+    detail: clean ? "clean" : "dirty (uncommitted changes)",
+  });
+
+  const ok = checks.every((c) => c.ok);
+
+  if (args.json) {
+    console.log(JSON.stringify({ ok, config, checks }, null, 2));
+    if (!ok) process.exit(2);
+    return;
+  }
+
+  for (const c of checks) {
+    const mark = c.ok ? "✓" : "✗";
+    console.log(`${mark} ${c.name}: ${c.detail}`);
+  }
+  if (ok) {
+    if (!args.quiet) success("gflows doctor: all critical checks passed.");
+  } else {
+    console.error("gflows doctor: some checks failed.");
+    hint("Fix the ✗ items, then retry. Run gflows init if dev is missing.");
+    process.exit(2);
+  }
+}