automata-cli 0.1.0-007-git-publish-release.45 → 0.1.0-008-test-command.62

package/README.md

@@ -14,12 +14,90 @@ npm install -g automata-cli
 automata --help
 ```
 
-## Commands
+---
 
-| Command group | Description | Docs |
-|---|---|---|
-| `automata config` | Configure the tool | [docs/config.md](docs/config.md) |
-| `automata git` | Git workflow helpers (requires `gh` CLI) | [docs/git.md](docs/git.md) |
+## `automata config`
+
+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 the remote type non-interactively (useful in scripts or CI).
+
+```bash
+automata config set type gh      # GitHub (requires gh CLI)
+automata config set type azdo    # Azure DevOps
+```
+
+---
+
+## `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`).
+
+---
+
+## `automata implement-next`
+
+Find the next open GitHub issue matching the configured filter, claim it, and invoke Claude Code to implement it.
+
+```bash
+automata implement-next                # find, claim, and implement
+automata implement-next --query-only   # print the issue and exit
+automata implement-next --yolo         # skip Claude permission prompts
+automata implement-next --json         # JSON output
+automata implement-next --no-claude    # claim without launching Claude
+```
+
+See [docs/implement-next.md](docs/implement-next.md) for full details.
+
+---
 
 ## Development
 

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command4 } from "commander";
+import { Command as Command5 } from "commander";
 
 // src/version.ts
 import { readFileSync } from "fs";
@@ -876,9 +876,6 @@ var gitCommand = new Command2("git").description("Git workflow commands (some re
 
 // 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";
@@ -903,10 +900,6 @@ function listIssues(technique, value) {
     "list",
     "--state",
     "open",
-    "--sort",
-    "created",
-    "--order",
-    "asc",
     "--limit",
     "1",
     "--json",
@@ -941,7 +934,11 @@ function postComment(issueNumber, body) {
   }
 }
 
-// src/commands/getReady.ts
+// src/claude/claudeService.ts
+import { spawn, spawnSync as spawnSync4 } from "child_process";
+import { createInterface } from "readline";
+import { existsSync } from "fs";
+import { delimiter, join as join2 } from "path";
 function resolveCommand(name) {
   const pathDirs = (process.env["PATH"] ?? "").split(delimiter);
   for (const dir of pathDirs) {
@@ -950,33 +947,140 @@ function resolveCommand(name) {
   }
   return name;
 }
-function invokeClaudeCode(issue, systemPrompt) {
-  const prompt = systemPrompt ? `${systemPrompt}
-
-${issue.body}` : issue.body;
+function invokeClaudeCode(prompt, options = {}) {
+  if (options.verbose) {
+    return invokeClaudeCodeVerbose(prompt, options.yolo ?? false, options.model);
+  }
+  invokeClaudeCodeSync(prompt, options.yolo ?? false, options.model);
+}
+function invokeClaudeCodeSync(prompt, yolo, model) {
   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);
+  const args = [];
+  if (yolo) args.push("--dangerously-skip-permissions");
+  if (model) args.push("--model", model);
+  args.push("-p", prompt);
+  const result = spawnSync4(claudeBin, args, { encoding: "utf8", stdio: "inherit" });
+  handleSpawnError(result.error);
+  handleExitCode(result.status);
+}
+function invokeClaudeCodeVerbose(prompt, yolo, model) {
+  return new Promise((resolve2) => {
+    const claudeBin = resolveCommand("claude");
+    const args = [];
+    if (yolo) args.push("--dangerously-skip-permissions");
+    if (model) args.push("--model", model);
+    args.push("--verbose", "--output-format", "stream-json", "-p", prompt);
+    const child = spawn(claudeBin, args, { stdio: ["inherit", "pipe", "inherit"] });
+    const rl = createInterface({ input: child.stdout });
+    let turnCount = 0;
+    child.on("error", (err) => {
+      handleSpawnError(err);
+    });
+    rl.on("line", (line) => {
+      try {
+        const event = JSON.parse(line);
+        formatEvent(event, turnCount);
+        if (event["type"] === "assistant") turnCount++;
+      } catch {
+      }
+    });
+    child.on("close", (code) => {
+      handleExitCode(code);
+      resolve2();
+    });
+  });
+}
+function formatEvent(event, turnCount) {
+  const type = event["type"];
+  if (type === "assistant") {
+    const message = event["message"];
+    const content = message?.["content"];
+    if (!content) return;
+    for (const block of content) {
+      if (block["type"] === "tool_use") {
+        const toolName = block["name"];
+        const input = block["input"];
+        const summary = summarizeTool(toolName, input);
+        process.stderr.write(`  [step ${turnCount + 1}] ${summary}
+`);
+      } else if (block["type"] === "text") {
+        const text = block["text"] ?? "";
+        if (text.length > 0) {
+          const preview = text.length > 120 ? text.slice(0, 120) + "..." : text;
+          const firstLine = preview.split("\n")[0];
+          process.stderr.write(`  [step ${turnCount + 1}] ${firstLine}
+`);
+        }
+      }
     }
-    process.stderr.write(`Error: ${err.message}
+  } else if (type === "result") {
+    const result = event["result"];
+    const cost = event["cost_usd"];
+    const duration = event["duration_ms"];
+    const turns = event["num_turns"];
+    process.stderr.write("\n--- Result ---\n");
+    if (cost !== void 0 || duration !== void 0 || turns !== void 0) {
+      const parts = [];
+      if (turns !== void 0) parts.push(`${turns} turns`);
+      if (duration !== void 0) parts.push(`${(duration / 1e3).toFixed(1)}s`);
+      if (cost !== void 0) parts.push(`$${cost.toFixed(4)}`);
+      process.stderr.write(`  [info] ${parts.join(" | ")}
 `);
+    }
+    if (result) {
+      process.stdout.write(result + "\n");
+    }
+  }
+}
+function summarizeTool(name, input) {
+  if (!input) return `tool: ${name}`;
+  switch (name) {
+    case "Read":
+      return `reading ${input["file_path"] ?? "file"}`;
+    case "Write":
+      return `writing ${input["file_path"] ?? "file"}`;
+    case "Edit":
+      return `editing ${input["file_path"] ?? "file"}`;
+    case "Bash":
+      return `running: ${truncate(String(input["command"] ?? ""), 80)}`;
+    case "Glob":
+      return `searching files: ${input["pattern"] ?? ""}`;
+    case "Grep":
+      return `searching content: ${truncate(String(input["pattern"] ?? ""), 60)}`;
+    case "Agent":
+      return `spawning agent: ${input["description"] ?? name}`;
+    default:
+      return `tool: ${name}`;
+  }
+}
+function truncate(str, max) {
+  return str.length > max ? str.slice(0, max) + "..." : str;
+}
+function handleSpawnError(error) {
+  if (!error) return;
+  const err = error;
+  if (err.code === "ENOENT") {
+    process.stderr.write("Error: `claude` CLI is not installed or not on PATH.\n");
     process.exit(1);
   }
-  if (result.status !== 0) {
-    process.stderr.write(`Error: Claude Code exited with code ${result.status ?? "unknown"}.
+  process.stderr.write(`Error: ${err.message}
 `);
-    process.exit(result.status ?? 1);
+  process.exit(1);
+}
+function handleExitCode(status) {
+  if (status !== null && status !== 0) {
+    process.stderr.write(`Error: Claude Code exited with code ${status}.
+`);
+    process.exit(status);
   }
 }
-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) => {
+
+// src/commands/getReady.ts
+var implementNextCommand = new Command3("implement-next").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").option("--query-only", "Print issue content and exit without claiming or invoking Claude").option("--yolo", "Launch Claude Code with --dangerously-skip-permissions").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"
+      "Error: implement-next 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);
   }
@@ -1014,6 +1118,9 @@ URL:    ${issue.url}
 ${issue.body}
 `);
   }
+  if (options.queryOnly) {
+    process.exit(0);
+  }
   try {
     postComment(issue.number, "working");
   } catch (err) {
@@ -1022,16 +1129,39 @@ ${issue.body}
     process.exit(1);
   }
   if (options.claude !== false) {
-    invokeClaudeCode(issue, config.claudeSystemPrompt);
+    const prompt = config.claudeSystemPrompt ? `${config.claudeSystemPrompt}
+
+${issue.body}` : issue.body;
+    invokeClaudeCode(prompt, { yolo: options.yolo });
+  }
+});
+
+// src/commands/test.ts
+import { Command as Command4 } from "commander";
+var MODEL_IDS = {
+  opus: "claude-opus-4-6",
+  sonnet: "claude-sonnet-4-6",
+  haiku: "claude-haiku-4-5-20251001"
+};
+var testClaudeCmd = new Command4("claude").description("Test Claude Code invocation with a user-supplied prompt").requiredOption("--prompt <string>", "Prompt to send to Claude Code").option("--yolo", "Launch Claude Code with --dangerously-skip-permissions").option("--verbose", "Show step-by-step progress summary and final result").option("--opus", "Use claude-opus-4-6").option("--sonnet", "Use claude-sonnet-4-6").option("--haiku", "Use claude-haiku-4-5-20251001").action(async (options) => {
+  const selected = ["opus", "sonnet", "haiku"].filter((m) => options[m]);
+  if (selected.length > 1) {
+    process.stderr.write(`Error: --${selected[0]} and --${selected[1]} are mutually exclusive.
+`);
+    process.exit(1);
   }
+  const model = selected.length === 1 ? MODEL_IDS[selected[0]] : void 0;
+  await invokeClaudeCode(options.prompt, { yolo: options.yolo, verbose: options.verbose, model });
 });
+var testCommand = new Command4("test").description("Test commands for verifying automata integrations").addCommand(testClaudeCmd);
 
 // src/index.ts
-var program = new Command4();
+var program = new Command5();
 program.name("automata").description("Automata CLI tool").version(version, "-v, --version");
 program.addCommand(configCommand);
 program.addCommand(gitCommand);
-program.addCommand(getReadyCommand);
+program.addCommand(implementNextCommand);
+program.addCommand(testCommand);
 program.showHelpAfterError();
 program.parse();
 if (process.argv.length <= 2) {

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "automata-cli",
-  "version": "0.1.0-007-git-publish-release.45",
+  "version": "0.1.0-008-test-command.62",
   "description": "Automata CLI tool",
   "type": "module",
   "bin": {
     "automata": "./dist/index.js"
   },
   "files": [
-    "dist"
+    "dist",
+    "README.md"
   ],
   "scripts": {
     "build": "tsup",