automata-cli 0.2.0-develop.1 → 0.2.0-develop.12

package/README.md

@@ -14,6 +14,65 @@ npm install -g automata-cli
 automata --help
 ```
 
+## Commands
+
+### `automata config`
+
+Launch the interactive configuration wizard. Use arrow keys to select the remote environment type and press Enter to save.
+
+```bash
+automata config
+```
+
+### `automata config set type <value>`
+
+Set a configuration value non-interactively (useful in scripts or CI).
+
+```bash
+automata config set type gh      # GitHub
+automata config set type azdo    # Azure DevOps
+```
+
+Configuration is saved to `.automata/config.json` in the current directory.
+
+### `automata git get-pr-info`
+
+Show the pull request associated with the current branch (requires [`gh` CLI](https://cli.github.com/) installed and authenticated).
+
+```bash
+automata git get-pr-info           # human-readable output
+automata git get-pr-info --json    # JSON output
+```
+
+Example output:
+
+```
+PR:    #42
+Title: Fix authentication bug
+State: MERGED
+URL:   https://github.com/org/repo/pull/42
+```
+
+If no PR exists for the current branch, a friendly message is printed and the command exits with code 0.
+
+### `automata git finish-feature`
+
+Clean up a merged feature branch in one step: checkout `develop`, pull the latest, and delete the local branch.
+
+```bash
+automata git finish-feature
+```
+
+The command validates all preconditions before making any changes:
+
+- Must **not** be on the `develop` branch
+- Working tree must be clean (no uncommitted changes)
+- A pull request for the branch must exist
+- The PR must be in `merged` state (not open or closed-without-merge)
+- The remote tracking branch must no longer exist (`origin/<branch>` is gone)
+
+If any precondition fails, the command prints a descriptive error to stderr and exits with a non-zero code.
+
 ## Development
 
 ### Prerequisites

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command } from "commander";
+import { Command as Command3 } from "commander";
 
 // src/version.ts
 import { readFileSync } from "fs";
@@ -11,9 +11,260 @@ var __dirname = dirname(fileURLToPath(import.meta.url));
 var packageJson = JSON.parse(readFileSync(resolve(__dirname, "../package.json"), "utf8"));
 var version = packageJson.version;
 
+// src/commands/config.ts
+import { Command } from "commander";
+import { render } from "ink";
+import React2 from "react";
+
+// src/config/ConfigWizard.tsx
+import { useState } from "react";
+import { Box, Text, useInput, useApp } from "ink";
+
+// src/config/configStore.ts
+import { readFileSync as readFileSync2, writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+var CONFIG_DIR = ".automata";
+var CONFIG_FILE = "config.json";
+function configPath() {
+  return join(process.cwd(), CONFIG_DIR, CONFIG_FILE);
+}
+function readConfig() {
+  try {
+    const raw = readFileSync2(configPath(), "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+function writeConfig(config) {
+  const dir = join(process.cwd(), CONFIG_DIR);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(configPath(), JSON.stringify(config, null, 2) + "\n", "utf8");
+}
+
+// src/config/ConfigWizard.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var OPTIONS = [
+  { label: "GitHub", value: "gh" },
+  { label: "Azure DevOps", value: "azdo" }
+];
+function ConfigWizard() {
+  const existing = readConfig();
+  const initialIndex = OPTIONS.findIndex((o) => o.value === existing.remoteType);
+  const [selectedIndex, setSelectedIndex] = useState(initialIndex >= 0 ? initialIndex : 0);
+  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();
+    }
+  });
+  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:" }),
+    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__ */ jsx(Text, { children: " " }),
+    /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2191/\u2193 to move \xB7 Enter to confirm \xB7 Ctrl+C to cancel" })
+  ] });
+}
+
+// src/commands/config.ts
+var VALID_TYPES = ["gh", "azdo"];
+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(", ")}
+`);
+    process.exit(1);
+  }
+  const current = readConfig();
+  writeConfig({ ...current, remoteType: value });
+  process.stdout.write(`Remote type set to: ${value}
+`);
+});
+var configSet = new Command("set").description("Set a configuration value").addCommand(configSetType);
+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 } from "child_process";
+function run(cmd, args) {
+  const result = spawnSync(cmd, args, { encoding: "utf8" });
+  return {
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? "",
+    status: result.status ?? 1
+  };
+}
+function getCurrentBranch() {
+  const { stdout, status } = run("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 getPrInfo(branch) {
+  const { stdout, stderr, status } = run("gh", [
+    "pr",
+    "view",
+    branch,
+    "--json",
+    "number,title,state,url"
+  ]);
+  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?");
+  }
+  return JSON.parse(stdout);
+}
+function isUpstreamGone(branch) {
+  const { status } = run("git", ["ls-remote", "--exit-code", "--heads", "origin", branch]);
+  return status !== 0;
+}
+function hasUncommittedChanges() {
+  const { stdout } = run("git", ["status", "--porcelain"]);
+  return stdout.trim().length > 0;
+}
+function checkoutAndPull(targetBranch) {
+  const checkout = run("git", ["checkout", targetBranch]);
+  if (checkout.status !== 0) {
+    throw new Error(`Failed to checkout ${targetBranch}: ${checkout.stderr.trim()}`);
+  }
+  const pull = run("git", ["pull"]);
+  if (pull.status !== 0) {
+    throw new Error(`Failed to pull ${targetBranch}: ${pull.stderr.trim()}`);
+  }
+}
+function deleteLocalBranch(branch) {
+  const result = run("git", ["branch", "-d", branch]);
+  if (result.status !== 0) {
+    throw new Error(`Failed to delete branch ${branch}: ${result.stderr.trim()}`);
+  }
+}
+
+// src/commands/git.ts
+var getPrInfoCmd = new Command2("get-pr-info").description("Show pull request info for the current branch").option("--json", "Output as JSON").action((options) => {
+  let branch;
+  try {
+    branch = getCurrentBranch();
+  } catch (err) {
+    process.stderr.write(`Error: ${err.message}
+`);
+    process.exit(1);
+  }
+  let pr;
+  try {
+    pr = getPrInfo(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}
+`);
+  }
+});
+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 = getPrInfo(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(`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 gitCommand = new Command2("git").description("Git workflow commands (requires gh CLI)").addCommand(getPrInfoCmd).addCommand(finishFeatureCmd);
+
 // src/index.ts
-var program = new Command();
+var program = new Command3();
 program.name("automata").description("Automata CLI tool").version(version, "-v, --version");
+program.addCommand(configCommand);
+program.addCommand(gitCommand);
 program.showHelpAfterError();
 program.parse();
 if (process.argv.length <= 2) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "automata-cli",
-  "version": "0.2.0-develop.1",
+  "version": "0.2.0-develop.12",
   "description": "Automata CLI tool",
   "type": "module",
   "bin": {
@@ -23,11 +23,14 @@
   },
   "license": "MIT",
   "dependencies": {
-    "commander": "^14.0.3"
+    "commander": "^14.0.3",
+    "ink": "^6.8.0",
+    "react": "^19.2.4"
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
     "@types/node": "^25.5.0",
+    "@types/react": "^19.2.14",
     "eslint": "^10.1.0",
     "prettier": "^3.8.1",
     "tsup": "^8.5.1",