automata-cli 0.2.0-develop.7 → 0.2.1

package/README.md

@@ -1,6 +1,6 @@
 # automata-cli
 
-A command-line interface tool.
+A command-line interface tool for automating Git and project workflows.
 
 ## Installation
 
@@ -8,32 +8,80 @@ A command-line interface tool.
 npm install -g automata-cli
 ```
 
-## Usage
+## Quick start
 
 ```bash
 automata --help
 ```
 
-## Commands
+---
 
-### `automata config`
+## `automata config`
 
-Launch the interactive configuration wizard. Use arrow keys to select the remote environment type and press Enter to save.
+Launch the interactive configuration wizard to select the remote environment type.
 
 ```bash
 automata config
 ```
 
+Configuration is saved to `.automata/config.json` in the current directory.
+
 ### `automata config set type <value>`
 
-Set a configuration value non-interactively (useful in scripts or CI).
+Set the remote type non-interactively (useful in scripts or CI).
 
 ```bash
-automata config set type gh      # GitHub
+automata config set type gh      # GitHub (requires gh CLI)
 automata config set type azdo    # Azure DevOps
 ```
 
-Configuration is saved to `.automata/config.json` in the current directory.
+---
+
+## `automata git`
+
+Git workflow helpers. Most commands require the [`gh` CLI](https://cli.github.com/) installed and authenticated. `publish-release` only requires `git`.
+
+### `automata git get-pr-info`
+
+Show the pull request for the current branch, including CI check results.
+
+```bash
+automata git get-pr-info           # human-readable output
+automata git get-pr-info --json    # full PR object as JSON
+```
+
+### `automata git get-pr-comments`
+
+List open (unresolved) review thread comments on the current branch's PR.
+
+```bash
+automata git get-pr-comments           # human-readable output
+automata git get-pr-comments --json    # JSON array output
+```
+
+### `automata git finish-feature`
+
+Clean up a merged feature branch: checkout `develop`, pull latest, delete the local branch.
+
+```bash
+automata git finish-feature
+```
+
+Checks that the PR exists and is merged, the working tree is clean, and the remote tracking branch is gone before making any changes.
+
+### `automata git publish-release`
+
+Execute the full GitFlow release sequence and push to `origin`. Only requires `git`.
+
+```bash
+automata git publish-release            # auto-detect version from master tag
+automata git publish-release 2.0.0      # explicit version
+automata git publish-release --dry-run  # preview without executing
+```
+
+When no version is given, the latest semver tag on `master` is detected and the minor segment is incremented (e.g. `1.2.0 → 1.3.0`).
+
+---
 
 ## Development
 
@@ -53,7 +101,7 @@ npm install
 ### Scripts
 
 | Command | Description |
-| --- | --- |
+|---|---|
 | `npm run build` | Build the CLI with tsup |
 | `npm test` | Build and run tests with vitest |
 | `npm run lint` | Lint source files with ESLint |

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command2 } from "commander";
+import { Command as Command4 } from "commander";
 
 // src/version.ts
 import { readFileSync } from "fs";
@@ -44,43 +44,151 @@ function writeConfig(config) {
 
 // src/config/ConfigWizard.tsx
 import { jsx, jsxs } from "react/jsx-runtime";
-var OPTIONS = [
+var REMOTE_OPTIONS = [
   { label: "GitHub", value: "gh" },
   { label: "Azure DevOps", value: "azdo" }
 ];
+var TECHNIQUE_OPTIONS = [
+  { label: "By Label", value: "label" },
+  { label: "By Assignee", value: "assignee" },
+  { label: "By Title Contains", value: "title-contains" }
+];
 function ConfigWizard() {
   const existing = readConfig();
-  const initialIndex = OPTIONS.findIndex((o) => o.value === existing.remoteType);
-  const [selectedIndex, setSelectedIndex] = useState(initialIndex >= 0 ? initialIndex : 0);
+  const initialRemoteIndex = REMOTE_OPTIONS.findIndex((o) => o.value === existing.remoteType);
+  const initialTechIndex = TECHNIQUE_OPTIONS.findIndex((o) => o.value === existing.issueDiscoveryTechnique);
+  const [screen, setScreen] = useState("remote");
+  const [selectedRemoteIndex, setSelectedRemoteIndex] = useState(initialRemoteIndex >= 0 ? initialRemoteIndex : 0);
+  const [selectedTechIndex, setSelectedTechIndex] = useState(initialTechIndex >= 0 ? initialTechIndex : 0);
+  const [discoveryValue, setDiscoveryValue] = useState(existing.issueDiscoveryValue ?? "");
+  const [systemPrompt, setSystemPrompt] = useState(existing.claudeSystemPrompt ?? "");
+  const [pendingRemote, setPendingRemote] = useState(existing.remoteType ?? "gh");
+  const [pendingTechnique, setPendingTechnique] = useState(
+    existing.issueDiscoveryTechnique ?? "label"
+  );
   const { exit } = useApp();
   useInput((input, key) => {
-    if (key.upArrow) {
-      setSelectedIndex((i) => i > 0 ? i - 1 : OPTIONS.length - 1);
-    } else if (key.downArrow) {
-      setSelectedIndex((i) => i < OPTIONS.length - 1 ? i + 1 : 0);
-    } else if (key.return) {
-      const chosen = OPTIONS[selectedIndex];
-      writeConfig({ ...existing, remoteType: chosen.value });
-      exit();
-    } else if (key.escape || key.ctrl && input === "c") {
-      exit();
+    if (screen === "remote") {
+      if (key.upArrow) {
+        setSelectedRemoteIndex((i) => i > 0 ? i - 1 : REMOTE_OPTIONS.length - 1);
+      } else if (key.downArrow) {
+        setSelectedRemoteIndex((i) => i < REMOTE_OPTIONS.length - 1 ? i + 1 : 0);
+      } else if (key.return) {
+        const chosen = REMOTE_OPTIONS[selectedRemoteIndex];
+        setPendingRemote(chosen.value);
+        if (chosen.value === "gh") {
+          setScreen("technique");
+        } else {
+          writeConfig({ ...existing, remoteType: chosen.value });
+          exit();
+        }
+      } else if (key.escape || key.ctrl && input === "c") {
+        exit();
+      }
+    } else if (screen === "technique") {
+      if (key.upArrow) {
+        setSelectedTechIndex((i) => i > 0 ? i - 1 : TECHNIQUE_OPTIONS.length - 1);
+      } else if (key.downArrow) {
+        setSelectedTechIndex((i) => i < TECHNIQUE_OPTIONS.length - 1 ? i + 1 : 0);
+      } else if (key.return) {
+        const chosen = TECHNIQUE_OPTIONS[selectedTechIndex];
+        setPendingTechnique(chosen.value);
+        setScreen("value");
+      } else if (key.escape || key.ctrl && input === "c") {
+        exit();
+      }
+    } else if (screen === "value") {
+      if (key.return) {
+        setScreen("system-prompt");
+      } else if (key.backspace || key.delete) {
+        setDiscoveryValue((v) => v.slice(0, -1));
+      } else if (key.escape || key.ctrl && input === "c") {
+        exit();
+      } else if (input && !key.ctrl && !key.meta) {
+        setDiscoveryValue((v) => v + input);
+      }
+    } else if (screen === "system-prompt") {
+      if (key.return) {
+        writeConfig({
+          ...existing,
+          remoteType: pendingRemote,
+          issueDiscoveryTechnique: pendingTechnique,
+          issueDiscoveryValue: discoveryValue || void 0,
+          claudeSystemPrompt: systemPrompt || void 0
+        });
+        exit();
+      } else if (key.backspace || key.delete) {
+        setSystemPrompt((v) => v.slice(0, -1));
+      } else if (key.escape || key.ctrl && input === "c") {
+        exit();
+      } else if (input && !key.ctrl && !key.meta) {
+        setSystemPrompt((v) => v + input);
+      }
     }
   });
+  if (screen === "remote") {
+    return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginY: 1, children: [
+      /* @__PURE__ */ jsx(Text, { bold: true, children: "Configure Automata" }),
+      /* @__PURE__ */ jsx(Text, { children: " " }),
+      /* @__PURE__ */ jsx(Text, { children: "Remote environment type:" }),
+      REMOTE_OPTIONS.map((option, index) => /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsxs(Text, { color: index === selectedRemoteIndex ? "cyan" : void 0, children: [
+        index === selectedRemoteIndex ? "\u276F " : "  ",
+        option.label
+      ] }) }, option.value)),
+      /* @__PURE__ */ jsx(Text, { children: " " }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2191/\u2193 to move \xB7 Enter to confirm \xB7 Ctrl+C to cancel" })
+    ] });
+  }
+  if (screen === "technique") {
+    return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginY: 1, children: [
+      /* @__PURE__ */ jsx(Text, { bold: true, children: "Configure Issue Discovery Technique" }),
+      /* @__PURE__ */ jsx(Text, { children: " " }),
+      /* @__PURE__ */ jsx(Text, { children: "How to find the next issue to work on:" }),
+      TECHNIQUE_OPTIONS.map((option, index) => /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsxs(Text, { color: index === selectedTechIndex ? "cyan" : void 0, children: [
+        index === selectedTechIndex ? "\u276F " : "  ",
+        option.label
+      ] }) }, option.value)),
+      /* @__PURE__ */ jsx(Text, { children: " " }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2191/\u2193 to move \xB7 Enter to confirm \xB7 Ctrl+C to cancel" })
+    ] });
+  }
+  if (screen === "value") {
+    const techLabel = TECHNIQUE_OPTIONS.find((t) => t.value === pendingTechnique)?.label ?? pendingTechnique;
+    return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginY: 1, children: [
+      /* @__PURE__ */ jsx(Text, { bold: true, children: "Configure Issue Discovery Value" }),
+      /* @__PURE__ */ jsx(Text, { children: " " }),
+      /* @__PURE__ */ jsxs(Text, { children: [
+        techLabel,
+        " value:",
+        " ",
+        /* @__PURE__ */ jsxs(Text, { color: "cyan", children: [
+          discoveryValue,
+          /* @__PURE__ */ jsx(Text, { children: "_" })
+        ] })
+      ] }),
+      /* @__PURE__ */ jsx(Text, { children: " " }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "Type value \xB7 Enter to confirm \xB7 Ctrl+C to cancel" })
+    ] });
+  }
   return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginY: 1, children: [
-    /* @__PURE__ */ jsx(Text, { bold: true, children: "Configure Automata" }),
+    /* @__PURE__ */ jsx(Text, { bold: true, children: "Configure Claude System Prompt" }),
     /* @__PURE__ */ jsx(Text, { children: " " }),
-    /* @__PURE__ */ jsx(Text, { children: "Remote environment type:" }),
-    OPTIONS.map((option, index) => /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsxs(Text, { color: index === selectedIndex ? "cyan" : void 0, children: [
-      index === selectedIndex ? "\u276F " : "  ",
-      option.label
-    ] }) }, option.value)),
+    /* @__PURE__ */ jsxs(Text, { children: [
+      "System prompt (optional):",
+      " ",
+      /* @__PURE__ */ jsxs(Text, { color: "cyan", children: [
+        systemPrompt,
+        /* @__PURE__ */ jsx(Text, { children: "_" })
+      ] })
+    ] }),
     /* @__PURE__ */ jsx(Text, { children: " " }),
-    /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2191/\u2193 to move \xB7 Enter to confirm \xB7 Ctrl+C to cancel" })
+    /* @__PURE__ */ jsx(Text, { dimColor: true, children: "Type prompt \xB7 Enter to save and exit \xB7 Ctrl+C to cancel" })
   ] });
 }
 
 // src/commands/config.ts
 var VALID_TYPES = ["gh", "azdo"];
+var VALID_TECHNIQUES = ["label", "assignee", "title-contains"];
 var configSetType = new Command("type").description("Set the remote environment type").argument("<value>", "Remote type: gh (GitHub) or azdo (Azure DevOps)").action((value) => {
   if (!VALID_TYPES.includes(value)) {
     process.stderr.write(`Error: invalid type "${value}". Must be one of: ${VALID_TYPES.join(", ")}
@@ -92,16 +200,838 @@ var configSetType = new Command("type").description("Set the remote environment
   process.stdout.write(`Remote type set to: ${value}
 `);
 });
-var configSet = new Command("set").description("Set a configuration value").addCommand(configSetType);
+var configSetIssueDiscoveryTechnique = new Command("issue-discovery-technique").description("Set the issue discovery technique (GitHub mode only)").argument("<value>", `Technique: ${VALID_TECHNIQUES.join(", ")}`).action((value) => {
+  if (!VALID_TECHNIQUES.includes(value)) {
+    process.stderr.write(`Error: invalid technique "${value}". Must be one of: ${VALID_TECHNIQUES.join(", ")}
+`);
+    process.exit(1);
+  }
+  const current = readConfig();
+  writeConfig({ ...current, issueDiscoveryTechnique: value });
+  process.stdout.write(`Issue discovery technique set to: ${value}
+`);
+});
+var configSetIssueDiscoveryValue = new Command("issue-discovery-value").description("Set the value for the issue discovery technique (label name, username, or search string)").argument("<value>", "The filter value").action((value) => {
+  const current = readConfig();
+  writeConfig({ ...current, issueDiscoveryValue: value });
+  process.stdout.write(`Issue discovery value set to: ${value}
+`);
+});
+var configSetClaudeSystemPrompt = new Command("claude-system-prompt").description("Set the system prompt used when invoking Claude Code").argument("<value>", "System prompt text").action((value) => {
+  const current = readConfig();
+  writeConfig({ ...current, claudeSystemPrompt: value });
+  process.stdout.write(`Claude system prompt set.
+`);
+});
+var configSet = new Command("set").description("Set a configuration value").addCommand(configSetType).addCommand(configSetIssueDiscoveryTechnique).addCommand(configSetIssueDiscoveryValue).addCommand(configSetClaudeSystemPrompt);
 var configCommand = new Command("config").description("Configure automata settings").addCommand(configSet).action(async () => {
   const { waitUntilExit } = render(React2.createElement(ConfigWizard));
   await waitUntilExit();
 });
 
+// src/commands/git.ts
+import { Command as Command2 } from "commander";
+
+// src/git/gitService.ts
+import { spawnSync as spawnSync2 } from "child_process";
+
+// src/config/azdoService.ts
+import { spawnSync } from "child_process";
+function run(cmd, args) {
+  const result = spawnSync(cmd, args, { encoding: "utf8" });
+  if (result.error) {
+    const err = result.error;
+    if (err.code === "ENOENT") {
+      throw new Error("`azdo` CLI is not installed or not on PATH.");
+    }
+    throw new Error(err.message);
+  }
+  return {
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? "",
+    status: result.status ?? 1
+  };
+}
+function mapStatus(azdoStatus) {
+  switch (azdoStatus) {
+    case "active":
+      return "OPEN";
+    case "completed":
+      return "MERGED";
+    case "abandoned":
+      return "CLOSED";
+    default:
+      return azdoStatus.toUpperCase();
+  }
+}
+function getPrInfo() {
+  const { stdout, stderr, status } = run("azdo", ["pr", "status", "--json"]);
+  if (status !== 0) {
+    throw new Error(stderr.trim() || "Failed to query Azure DevOps PR status. Is `azdo` installed and authenticated?");
+  }
+  const parsed = JSON.parse(stdout);
+  if (parsed.pullRequests.length === 0) {
+    return null;
+  }
+  const pr = parsed.pullRequests[0];
+  return {
+    number: pr.id,
+    title: pr.title,
+    state: mapStatus(pr.status),
+    url: pr.url,
+    checks: []
+  };
+}
+
+// src/git/gitService.ts
+function run2(cmd, args) {
+  const result = spawnSync2(cmd, args, { encoding: "utf8" });
+  return {
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? "",
+    status: result.status ?? 1
+  };
+}
+function getCurrentBranch() {
+  const { stdout, status } = run2("git", ["rev-parse", "--abbrev-ref", "HEAD"]);
+  if (status !== 0) {
+    throw new Error("Failed to determine current branch. Are you inside a git repository?");
+  }
+  return stdout.trim();
+}
+function parseOwnerRepo() {
+  const { stdout, status } = run2("git", ["remote", "get-url", "origin"]);
+  if (status !== 0) return null;
+  const url = stdout.trim();
+  const https = url.match(/github\.com\/([^/]+\/[^/]+?)(?:\.git)?$/);
+  if (https) return https[1];
+  const ssh = url.match(/github\.com:([^/]+\/[^/]+?)(?:\.git)?$/);
+  if (ssh) return ssh[1];
+  return null;
+}
+function extractLastMarkdownUrl(markdown) {
+  const matches = [...markdown.matchAll(/\]\((https?:\/\/[^)]+)\)/g)];
+  return matches.length > 0 ? matches[matches.length - 1][1] ?? null : null;
+}
+function fetchCheckRunOutputs(ownerRepo, sha) {
+  const { stdout, status } = run2("gh", [
+    "api",
+    `repos/${ownerRepo}/commits/${sha}/check-runs`,
+    "--jq",
+    ".check_runs[] | {name, html_url, details_url, output}"
+  ]);
+  const map = /* @__PURE__ */ new Map();
+  if (status !== 0) return map;
+  for (const line of stdout.trim().split("\n")) {
+    if (!line) continue;
+    try {
+      const item = JSON.parse(line);
+      const title = item.output?.title ?? "";
+      const summaryUrl = item.output?.summary ? extractLastMarkdownUrl(item.output.summary) : null;
+      const detailsUrl = summaryUrl ?? (item.details_url !== item.html_url ? item.details_url : "") ?? item.html_url;
+      map.set(item.name, { title, detailsUrl });
+    } catch {
+    }
+  }
+  return map;
+}
+function getPrInfoGh(branch) {
+  const { stdout, stderr, status } = run2("gh", [
+    "pr",
+    "view",
+    branch,
+    "--json",
+    "number,title,state,url,headRefOid,statusCheckRollup"
+  ]);
+  if (status !== 0) {
+    if (stderr.includes("no pull requests found") || stderr.includes("Could not resolve")) {
+      return null;
+    }
+    throw new Error(stderr.trim() || "Failed to query GitHub. Is `gh` installed and authenticated?");
+  }
+  const raw = JSON.parse(stdout);
+  const failedChecks = (raw.statusCheckRollup ?? []).filter(
+    (c) => c.conclusion !== null && ["FAILURE", "TIMED_OUT", "ACTION_REQUIRED", "CANCELLED"].includes(c.conclusion)
+  );
+  const ownerRepo = failedChecks.length > 0 ? parseOwnerRepo() : null;
+  const checkOutputs = ownerRepo ? fetchCheckRunOutputs(ownerRepo, raw.headRefOid) : /* @__PURE__ */ new Map();
+  const checks = (raw.statusCheckRollup ?? []).map((c) => {
+    const enriched = checkOutputs.get(c.name);
+    return {
+      name: c.name,
+      status: c.status,
+      conclusion: c.conclusion,
+      description: enriched?.title || c.description || "",
+      detailsUrl: enriched?.detailsUrl || c.detailsUrl || ""
+    };
+  });
+  return { number: raw.number, title: raw.title, state: raw.state, url: raw.url, checks };
+}
+function getPrInfo2(branch) {
+  const config = readConfig();
+  if (config.remoteType === "azdo") {
+    return getPrInfo();
+  }
+  return getPrInfoGh(branch);
+}
+function isUpstreamGone(branch) {
+  const { status } = run2("git", ["ls-remote", "--exit-code", "--heads", "origin", branch]);
+  return status !== 0;
+}
+function hasUncommittedChanges() {
+  const { stdout } = run2("git", ["status", "--porcelain"]);
+  return stdout.trim().length > 0;
+}
+function checkoutAndPull(targetBranch) {
+  const checkout = run2("git", ["checkout", targetBranch]);
+  if (checkout.status !== 0) {
+    throw new Error(`Failed to checkout ${targetBranch}: ${checkout.stderr.trim()}`);
+  }
+  const pull = run2("git", ["pull"]);
+  if (pull.status !== 0) {
+    throw new Error(`Failed to pull ${targetBranch}: ${pull.stderr.trim()}`);
+  }
+}
+function fetchPrune() {
+  const result = run2("git", ["fetch", "--prune"]);
+  if (result.status !== 0) {
+    throw new Error(`Failed to fetch --prune: ${result.stderr.trim()}`);
+  }
+}
+function deleteLocalBranch(branch) {
+  const result = run2("git", ["branch", "-D", branch]);
+  if (result.status !== 0) {
+    throw new Error(`Failed to delete branch ${branch}: ${result.stderr.trim()}`);
+  }
+}
+var REVIEW_THREADS_QUERY = `
+query($owner:String!,$repo:String!,$prNumber:Int!){
+  repository(owner:$owner,name:$repo){
+    pullRequest(number:$prNumber){
+      reviewThreads(first:100){
+        nodes{
+          isResolved
+          isOutdated
+          comments(first:1){
+            nodes{ author{login} body path line createdAt }
+          }
+        }
+      }
+    }
+  }
+}`.trim();
+function getPrCommentsGh(branch) {
+  const prView = run2("gh", ["pr", "view", branch, "--json", "number"]);
+  if (prView.status !== 0) {
+    if (prView.stderr.includes("no pull requests found") || prView.stderr.includes("Could not resolve")) {
+      return null;
+    }
+    throw new Error(prView.stderr.trim() || "Failed to query GitHub. Is `gh` installed and authenticated?");
+  }
+  const { number: prNumber } = JSON.parse(prView.stdout);
+  const ownerRepo = parseOwnerRepo();
+  if (!ownerRepo) {
+    throw new Error("Could not determine GitHub owner/repo from git remote. Is 'origin' set to a GitHub URL?");
+  }
+  const slashIdx = ownerRepo.indexOf("/");
+  const owner = ownerRepo.slice(0, slashIdx);
+  const repo = ownerRepo.slice(slashIdx + 1);
+  const gql = run2("gh", [
+    "api",
+    "graphql",
+    "-f",
+    `query=${REVIEW_THREADS_QUERY}`,
+    "-f",
+    `owner=${owner}`,
+    "-f",
+    `repo=${repo}`,
+    "-F",
+    `prNumber=${String(prNumber)}`
+  ]);
+  if (gql.status !== 0) {
+    throw new Error(gql.stderr.trim() || "Failed to query GitHub GraphQL API.");
+  }
+  const response = JSON.parse(gql.stdout);
+  const threads = response.data.repository.pullRequest.reviewThreads.nodes;
+  return threads.filter((t) => !t.isResolved && t.comments.nodes.length > 0).map((t) => {
+    const c = t.comments.nodes[0];
+    return {
+      author: c.author.login,
+      body: c.body,
+      path: c.path,
+      line: c.line ?? null,
+      createdAt: c.createdAt
+    };
+  });
+}
+function getPrComments(branch) {
+  const config = readConfig();
+  if (config.remoteType === "azdo") {
+    return "unsupported";
+  }
+  return getPrCommentsGh(branch);
+}
+var SEMVER_RE = /^v?(\d+)\.(\d+)\.(\d+)$/;
+function getLatestTagOnMaster() {
+  const { stdout, status } = run2("git", [
+    "describe",
+    "--tags",
+    "--abbrev=0",
+    "--match",
+    "[0-9]*.[0-9]*.[0-9]*",
+    "--match",
+    "v[0-9]*.[0-9]*.[0-9]*",
+    "master"
+  ]);
+  if (status !== 0) return null;
+  const tag = stdout.trim();
+  const m = SEMVER_RE.exec(tag);
+  if (!m) return null;
+  return `${m[1]}.${m[2]}.${m[3]}`;
+}
+function bumpMinorVersion(version2) {
+  const m = SEMVER_RE.exec(version2);
+  if (!m) throw new Error(`Invalid semver: ${version2}`);
+  return `${m[1]}.${String(Number(m[2]) + 1)}.0`;
+}
+function tagExists(version2) {
+  const { stdout, status, stderr } = run2("git", ["tag", "-l", version2]);
+  if (status !== 0) {
+    throw new Error(`Command failed: git tag -l ${version2}
+${stderr.trim()}`);
+  }
+  return stdout.trim().length > 0;
+}
+function publishRelease(version2, dryRun) {
+  const releaseBranch = `release/${version2}`;
+  const steps = [
+    { args: ["checkout", "-b", releaseBranch], desc: `git checkout -b ${releaseBranch}` },
+    { args: ["checkout", "master"], desc: `git checkout master` },
+    { args: ["merge", "--no-ff", releaseBranch], desc: `git merge --no-ff ${releaseBranch}` },
+    { args: ["tag", version2], desc: `git tag ${version2}` },
+    { args: ["checkout", "develop"], desc: `git checkout develop` },
+    { args: ["merge", "--no-ff", releaseBranch], desc: `git merge --no-ff ${releaseBranch}` },
+    { args: ["branch", "-d", releaseBranch], desc: `git branch -d ${releaseBranch}` },
+    { args: ["push", "origin", "develop", "master", version2], desc: `git push origin develop master ${version2}` }
+  ];
+  for (const step of steps) {
+    if (dryRun) {
+      process.stdout.write(`[dry-run] ${step.desc}
+`);
+      continue;
+    }
+    const { status, stderr } = run2("git", step.args);
+    if (status !== 0) {
+      throw new Error(`Command failed: ${step.desc}
+${stderr.trim()}`);
+    }
+  }
+}
+
+// src/commands/git.ts
+var FAIL_CONCLUSIONS = /* @__PURE__ */ new Set(["FAILURE", "TIMED_OUT", "ACTION_REQUIRED", "CANCELLED"]);
+var SKIP_CONCLUSIONS = /* @__PURE__ */ new Set(["SKIPPED", "NEUTRAL"]);
+function checkSymbol(check) {
+  if (check.status !== "COMPLETED") return "\u25CF";
+  if (check.conclusion === "SUCCESS") return "\u2713";
+  if (check.conclusion !== null && SKIP_CONCLUSIONS.has(check.conclusion)) return "\u25CB";
+  if (check.conclusion !== null && FAIL_CONCLUSIONS.has(check.conclusion)) return "\u2717";
+  return "\u25CF";
+}
+function formatCheckSummary(checks) {
+  const running = checks.some((c) => c.status !== "COMPLETED");
+  const failed = checks.filter((c) => c.conclusion !== null && FAIL_CONCLUSIONS.has(c.conclusion));
+  const errors = failed.length === 0 ? "none" : failed.map((c) => `${c.name}: ${c.description.trim() || c.detailsUrl || "no details available"}`).join("; ");
+  return `Checks Running: ${String(running)}
+Check Errors:   ${errors}
+`;
+}
+function formatChecks(checks) {
+  if (checks.length === 0) return "Checks: none\n";
+  const lines = ["Checks:"];
+  for (const check of checks) {
+    const sym = checkSymbol(check);
+    const pending = check.status !== "COMPLETED" ? " (pending)" : "";
+    lines.push(`  ${sym} ${check.name}${pending}`);
+    if (check.conclusion !== null && FAIL_CONCLUSIONS.has(check.conclusion)) {
+      const desc = check.description.trim();
+      const url = check.detailsUrl.trim();
+      if (desc) lines.push(`    Details: ${desc}`);
+      if (url) lines.push(`    URL:     ${url}`);
+      if (!desc && !url) lines.push(`    Details: (no details available)`);
+    }
+  }
+  return lines.join("\n") + "\n";
+}
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+function formatFailedChecks(failed) {
+  const lines = [];
+  for (const check of failed) {
+    lines.push(`  \u2717 ${check.name}`);
+    const desc = check.description.trim();
+    const url = check.detailsUrl.trim();
+    if (desc) lines.push(`    Details: ${desc}`);
+    if (url) lines.push(`    URL:     ${url}`);
+    if (!desc && !url) lines.push(`    Details: (no details available)`);
+  }
+  return lines.join("\n") + "\n";
+}
+var POLL_INTERVAL_MS = 1e4;
+var getPrInfoCmd = new Command2("get-pr-info").description("Show pull request info for the current branch").option("--json", "Output as JSON").option("--wait-finish-checks", "Poll until all checks complete, then report pass/fail (exit 1 on failure)").addHelpText(
+  "after",
+  `
+Check status symbols:
+  \u2713  Passed        (conclusion: SUCCESS)
+  \u2717  Failed        (conclusion: FAILURE / TIMED_OUT / ACTION_REQUIRED / CANCELLED)
+  \u25CF  Pending       (status: QUEUED or IN_PROGRESS)
+  \u25CB  Skipped       (conclusion: SKIPPED or NEUTRAL)
+
+Failure details are printed beneath each \u2717 check.
+See docs/git.md for full output reference.`
+).action(async (options) => {
+  let branch;
+  try {
+    branch = getCurrentBranch();
+  } catch (err) {
+    process.stderr.write(`Error: ${err.message}
+`);
+    process.exit(1);
+  }
+  if (options.waitFinishChecks) {
+    let pr2;
+    while (true) {
+      try {
+        pr2 = getPrInfo2(branch);
+      } catch (err) {
+        process.stderr.write(`Error: ${err.message}
+`);
+        process.exit(1);
+      }
+      if (pr2 === null) {
+        process.stderr.write(`Error: No pull request found for branch: ${branch}
+`);
+        process.exit(1);
+      }
+      const running = pr2.checks.filter((c) => c.status !== "COMPLETED");
+      if (running.length === 0) break;
+      process.stdout.write(`Waiting for ${running.length} check(s) to complete...
+`);
+      await sleep(POLL_INTERVAL_MS);
+    }
+    const failed = pr2.checks.filter((c) => c.conclusion !== null && FAIL_CONCLUSIONS.has(c.conclusion));
+    if (failed.length === 0) {
+      if (options.json) {
+        process.stdout.write(JSON.stringify({ result: "passed" }, null, 2) + "\n");
+      } else {
+        process.stdout.write(`All checks passed. \u2713
+`);
+      }
+      process.exit(0);
+    } else {
+      if (options.json) {
+        process.stdout.write(JSON.stringify({ result: "failed", failed }, null, 2) + "\n");
+      } else {
+        process.stdout.write(`${failed.length} check(s) failed:
+`);
+        process.stdout.write(formatFailedChecks(failed));
+      }
+      process.exit(1);
+    }
+    return;
+  }
+  let pr;
+  try {
+    pr = getPrInfo2(branch);
+  } catch (err) {
+    process.stderr.write(`Error: ${err.message}
+`);
+    process.exit(1);
+  }
+  if (pr === null) {
+    process.stdout.write(`No pull request found for branch: ${branch}
+`);
+    process.exit(0);
+  }
+  if (options.json) {
+    process.stdout.write(JSON.stringify(pr, null, 2) + "\n");
+  } else {
+    process.stdout.write(`PR:    #${pr.number}
+Title: ${pr.title}
+State: ${pr.state}
+URL:   ${pr.url}
+`);
+    process.stdout.write(formatCheckSummary(pr.checks));
+    process.stdout.write(formatChecks(pr.checks));
+  }
+});
+var ANSI_ESCAPE_RE = new RegExp("\x1B(?:[@-Z\\\\-_]|\\[[0-?]*[ -/]*[@-~])", "g");
+var CONTROL_CHARS_RE = new RegExp("[\0-\b\v\f-\x7F]", "g");
+function sanitizeText(text) {
+  return text.replace(ANSI_ESCAPE_RE, "").replace(CONTROL_CHARS_RE, "");
+}
+var getPrCommentsCmd = new Command2("get-pr-comments").description("List open (unresolved) review comments on the pull request for the current branch (GitHub only)").option("--json", "Output as JSON array").addHelpText(
+  "after",
+  `
+Only GitHub (remoteType: gh) is supported. Azure DevOps is not supported.
+See docs/azdo-gap.md for details.`
+).action((options) => {
+  let branch;
+  try {
+    branch = getCurrentBranch();
+  } catch (err) {
+    process.stderr.write(`Error: ${err.message}
+`);
+    process.exit(1);
+  }
+  let comments;
+  try {
+    comments = getPrComments(branch);
+  } catch (err) {
+    process.stderr.write(`Error: ${err.message}
+`);
+    process.exit(1);
+  }
+  if (comments === "unsupported") {
+    process.stderr.write(
+      `Error: get-pr-comments is not supported for Azure DevOps. See docs/azdo-gap.md for details.
+`
+    );
+    process.exit(1);
+  }
+  if (comments === null) {
+    process.stderr.write(`Error: No pull request found for branch: ${branch}
+`);
+    process.exit(1);
+  }
+  if (options.json) {
+    process.stdout.write(JSON.stringify(comments, null, 2) + "\n");
+    return;
+  }
+  if (comments.length === 0) {
+    process.stdout.write(`No open comments.
+`);
+    return;
+  }
+  const lines = [];
+  for (const c of comments) {
+    const loc = c.line !== null ? `${c.path}:${String(c.line)}` : `${c.path}:(file)`;
+    const safeBody = sanitizeText(c.body);
+    const safeAuthor = sanitizeText(c.author);
+    lines.push(`[${safeAuthor}] on ${loc}
+${safeBody}`);
+  }
+  process.stdout.write(lines.join("\n\n") + "\n");
+});
+var finishFeatureCmd = new Command2("finish-feature").description("Clean up a merged feature branch: checkout develop, pull, and delete local branch").action(() => {
+  let branch;
+  try {
+    branch = getCurrentBranch();
+  } catch (err) {
+    process.stderr.write(`Error: ${err.message}
+`);
+    process.exit(1);
+  }
+  if (branch === "develop") {
+    process.stderr.write("Error: finish-feature cannot be run from the develop branch.\n");
+    process.exit(1);
+  }
+  if (hasUncommittedChanges()) {
+    process.stderr.write(
+      "Error: You have uncommitted changes. Commit or stash them before running finish-feature.\n"
+    );
+    process.exit(1);
+  }
+  let pr;
+  try {
+    pr = getPrInfo2(branch);
+  } catch (err) {
+    process.stderr.write(`Error: ${err.message}
+`);
+    process.exit(1);
+  }
+  if (pr === null) {
+    process.stderr.write(`Error: No pull request found for branch: ${branch}
+`);
+    process.exit(1);
+  }
+  if (pr.state === "OPEN") {
+    process.stderr.write(`Error: Pull request #${pr.number} is still open. Merge it before finishing the feature.
+`);
+    process.exit(1);
+  }
+  if (pr.state === "CLOSED") {
+    process.stderr.write(
+      `Error: Pull request #${pr.number} was closed without merging. finish-feature only proceeds for merged PRs.
+`
+    );
+    process.exit(1);
+  }
+  if (!isUpstreamGone(branch)) {
+    process.stderr.write(
+      `Error: Remote tracking branch 'origin/${branch}' still exists. Push or delete it remotely before finishing.
+`
+    );
+    process.exit(1);
+  }
+  try {
+    process.stdout.write(`Fetching and pruning remote refs...
+`);
+    fetchPrune();
+    process.stdout.write(`Checking out develop and pulling latest...
+`);
+    checkoutAndPull("develop");
+    process.stdout.write(`Deleting local branch: ${branch}
+`);
+    deleteLocalBranch(branch);
+    process.stdout.write(`Done. Branch '${branch}' has been removed.
+`);
+  } catch (err) {
+    process.stderr.write(`Error: ${err.message}
+`);
+    process.exit(1);
+  }
+});
+var SEMVER_ARG_RE = /^\d+\.\d+\.\d+$/;
+var publishReleaseCmd = new Command2("publish-release").description("Execute the full GitFlow release sequence and push to origin").argument("[version]", "Release version in X.Y.Z format (auto-detected from master tag if omitted)").option("--dry-run", "Print git commands without executing them").addHelpText(
+  "after",
+  `
+Release sequence:
+  1. git checkout -b release/<version>
+  2. git checkout master && git merge --no-ff release/<version>
+  3. git tag <version>
+  4. git checkout develop && git merge --no-ff release/<version>
+  5. git branch -d release/<version>
+  6. git push origin develop master <version>
+
+When [version] is omitted the latest semver tag on master is detected and the
+minor segment is incremented (e.g. 1.2.0 \u2192 1.3.0).`
+).action((version2, options) => {
+  const dryRun = options.dryRun ?? false;
+  let branch;
+  try {
+    branch = getCurrentBranch();
+  } catch (err) {
+    process.stderr.write(`Error: ${err.message}
+`);
+    process.exit(1);
+  }
+  if (branch !== "develop") {
+    process.stderr.write(
+      `Error: publish-release must be run from the 'develop' branch (currently on '${branch}').
+`
+    );
+    process.exit(1);
+  }
+  if (hasUncommittedChanges()) {
+    process.stderr.write("Error: You have uncommitted changes. Commit or stash them before publishing a release.\n");
+    process.exit(1);
+  }
+  let resolvedVersion;
+  if (version2 !== void 0) {
+    if (!SEMVER_ARG_RE.test(version2)) {
+      process.stderr.write(`Error: Version '${version2}' is not valid semver. Use X.Y.Z format (e.g. 1.2.0).
+`);
+      process.exit(1);
+    }
+    resolvedVersion = version2;
+  } else {
+    const latest = getLatestTagOnMaster();
+    if (latest === null) {
+      process.stderr.write(
+        "Error: No semver tag found on master. Pass a version explicitly: automata git publish-release <X.Y.Z>\n"
+      );
+      process.exit(1);
+    }
+    resolvedVersion = bumpMinorVersion(latest);
+    process.stdout.write(`Auto-detected version: ${latest} \u2192 ${resolvedVersion}
+`);
+  }
+  if (tagExists(resolvedVersion)) {
+    process.stderr.write(`Error: Tag '${resolvedVersion}' already exists.
+`);
+    process.exit(1);
+  }
+  if (dryRun) {
+    process.stdout.write(`Dry-run: release ${resolvedVersion}
+`);
+  } else {
+    process.stdout.write(`Publishing release ${resolvedVersion}...
+`);
+  }
+  try {
+    publishRelease(resolvedVersion, dryRun);
+  } catch (err) {
+    process.stderr.write(`Error: ${err.message}
+`);
+    process.exit(1);
+  }
+  if (!dryRun) {
+    process.stdout.write(`Release ${resolvedVersion} published successfully.
+`);
+  }
+});
+var gitCommand = new Command2("git").description("Git workflow commands (some require gh CLI)").addCommand(getPrInfoCmd).addCommand(getPrCommentsCmd).addCommand(finishFeatureCmd).addCommand(publishReleaseCmd);
+
+// src/commands/getReady.ts
+import { Command as Command3 } from "commander";
+import { spawnSync as spawnSync4 } from "child_process";
+import { existsSync } from "fs";
+import { delimiter, join as join2 } from "path";
+
+// src/config/githubService.ts
+import { spawnSync as spawnSync3 } from "child_process";
+function run3(cmd, args) {
+  const result = spawnSync3(cmd, args, { encoding: "utf8" });
+  if (result.error) {
+    const err = result.error;
+    if (err.code === "ENOENT") {
+      throw new Error("`gh` CLI is not installed or not on PATH.");
+    }
+    throw new Error(err.message);
+  }
+  return {
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? "",
+    status: result.status ?? 1
+  };
+}
+function listIssues(technique, value) {
+  const baseArgs = [
+    "issue",
+    "list",
+    "--state",
+    "open",
+    "--sort",
+    "created",
+    "--order",
+    "asc",
+    "--limit",
+    "1",
+    "--json",
+    "number,title,body,url"
+  ];
+  let filterArgs;
+  switch (technique) {
+    case "label":
+      filterArgs = ["--label", value];
+      break;
+    case "assignee":
+      filterArgs = ["--assignee", value];
+      break;
+    case "title-contains":
+      filterArgs = ["--search", `${value} in:title`];
+      break;
+  }
+  const { stdout, stderr, status } = run3("gh", [...baseArgs, ...filterArgs]);
+  if (status !== 0) {
+    throw new Error(stderr.trim() || "Failed to query GitHub issues. Is `gh` installed and authenticated?");
+  }
+  const issues = JSON.parse(stdout);
+  if (issues.length === 0) {
+    return null;
+  }
+  return issues[0];
+}
+function postComment(issueNumber, body) {
+  const { stderr, status } = run3("gh", ["issue", "comment", String(issueNumber), "--body", body]);
+  if (status !== 0) {
+    throw new Error(stderr.trim() || `Failed to post comment on issue #${issueNumber}.`);
+  }
+}
+
+// src/commands/getReady.ts
+function resolveCommand(name) {
+  const pathDirs = (process.env["PATH"] ?? "").split(delimiter);
+  for (const dir of pathDirs) {
+    const candidate = join2(dir, name);
+    if (existsSync(candidate)) return candidate;
+  }
+  return name;
+}
+function invokeClaudeCode(issue, systemPrompt) {
+  const prompt = systemPrompt ? `${systemPrompt}
+
+${issue.body}` : issue.body;
+  const claudeBin = resolveCommand("claude");
+  const result = spawnSync4(claudeBin, ["-p", prompt], { encoding: "utf8", stdio: "inherit" });
+  if (result.error) {
+    const err = result.error;
+    if (err.code === "ENOENT") {
+      process.stderr.write("Error: `claude` CLI is not installed or not on PATH.\n");
+      process.exit(1);
+    }
+    process.stderr.write(`Error: ${err.message}
+`);
+    process.exit(1);
+  }
+  if (result.status !== 0) {
+    process.stderr.write(`Error: Claude Code exited with code ${result.status ?? "unknown"}.
+`);
+    process.exit(result.status ?? 1);
+  }
+}
+var getReadyCommand = new Command3("get-ready").description("Find the next open GitHub issue matching the configured filter, claim it, and invoke Claude Code").option("--json", "Output issue details as JSON").option("--no-claude", "Skip Claude Code invocation after claiming the issue").action((options) => {
+  const config = readConfig();
+  if (config.remoteType !== "gh") {
+    process.stderr.write(
+      "Error: get-ready is not supported in Azure DevOps mode. Work item discovery is not available in azdo-cli. See docs/azdo-gap.md for details.\n"
+    );
+    process.exit(1);
+  }
+  if (!config.issueDiscoveryTechnique) {
+    process.stderr.write(
+      "Error: No issue discovery technique configured. Run `automata config` to set one.\n"
+    );
+    process.exit(1);
+  }
+  if (!config.issueDiscoveryValue) {
+    process.stderr.write(
+      "Error: No issue discovery value configured. Run `automata config` to set one.\n"
+    );
+    process.exit(1);
+  }
+  let issue;
+  try {
+    issue = listIssues(config.issueDiscoveryTechnique, config.issueDiscoveryValue);
+  } catch (err) {
+    process.stderr.write(`Error: ${err.message}
+`);
+    process.exit(1);
+  }
+  if (issue === null) {
+    process.stdout.write("No issues found matching the configured filter.\n");
+    process.exit(0);
+  }
+  if (options.json) {
+    process.stdout.write(JSON.stringify({ number: issue.number, title: issue.title, body: issue.body, url: issue.url }, null, 2) + "\n");
+  } else {
+    process.stdout.write(`Issue:  #${issue.number}
+Title:  ${issue.title}
+URL:    ${issue.url}
+
+${issue.body}
+`);
+  }
+  try {
+    postComment(issue.number, "working");
+  } catch (err) {
+    process.stderr.write(`Error: ${err.message}
+`);
+    process.exit(1);
+  }
+  if (options.claude !== false) {
+    invokeClaudeCode(issue, config.claudeSystemPrompt);
+  }
+});
+
 // src/index.ts
-var program = new Command2();
+var program = new Command4();
 program.name("automata").description("Automata CLI tool").version(version, "-v, --version");
 program.addCommand(configCommand);
+program.addCommand(gitCommand);
+program.addCommand(getReadyCommand);
 program.showHelpAfterError();
 program.parse();
 if (process.argv.length <= 2) {

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "automata-cli",
-  "version": "0.2.0-develop.7",
+  "version": "0.2.1",
   "description": "Automata CLI tool",
   "type": "module",
   "bin": {
     "automata": "./dist/index.js"
   },
   "files": [
-    "dist"
+    "dist",
+    "README.md"
   ],
   "scripts": {
     "build": "tsup",