automata-cli 0.8.0-develop.346 → 0.8.0-develop.353

package/README.md

@@ -74,12 +74,12 @@ Checks that the PR exists and is merged, the working tree is clean, and the remo
 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            # auto-detect version from the trunk 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`).
+When no version is given, the trunk branch is resolved from `origin` (`main`, `master` or whatever the remote calls it), tags are fetched, and the latest semver tag on `origin/<trunk>` is detected and the minor segment incremented (e.g. `1.2.0 → 1.3.0`). See [docs/git.md](docs/git.md#automata-git-publish-release).
 
 ---
 

package/dist/{ConfigWizard-D6NYL2E6.js → ConfigWizard-GULICHML.js}

@@ -36,7 +36,7 @@ var EXECUTOR_OPTIONS = [
   { label: "Claude Code", value: "claude" },
   { label: "Codex", value: "codex" }
 ];
-var MAIN_MENU_OPTIONS = ["Remote / Mode", "Implement-Next", "Prompts", "Issue Watch", "Do Work"];
+var MAIN_MENU_OPTIONS = ["Remote / Mode", "Implement-Next", "Prompts", "Issue Watch", "Do Work", "Git"];
 var PROMPTS_MENU_OPTIONS = [
   "Sonar",
   "Fix-Comments",
@@ -173,6 +173,7 @@ function ConfigWizard() {
   const [doWorkPrOrphanPrompt, setDoWorkPrOrphanPrompt] = useState(
     existing.doWork?.prompts?.prOrphan ?? DEFAULT_DO_WORK_PR_ORPHAN_PROMPT
   );
+  const [gitTrunkBranch, setGitTrunkBranch] = useState(existing.git?.trunkBranch ?? "");
   const [pendingRemote, setPendingRemote] = useState(existing.remoteType ?? "gh");
   const [pendingTechnique, setPendingTechnique] = useState(
     existing.issueDiscoveryTechnique ?? "label"
@@ -379,6 +380,16 @@ function ConfigWizard() {
         setScreen("prompts-menu");
       },
       onBack: () => setScreen("prompts-menu")
+    },
+    "git-trunk-branch": {
+      setValue: setGitTrunkBranch,
+      onSubmit: () => {
+        const branch = gitTrunkBranch.trim();
+        const current = readRawConfig();
+        writeConfig({ ...current, git: { ...current.git, trunkBranch: branch || void 0 } });
+        exit();
+      },
+      onBack: () => setScreen("main")
     }
   };
   const menus = {
@@ -392,6 +403,7 @@ function ConfigWizard() {
         else if (chosen === "Implement-Next") setScreen("technique");
         else if (chosen === "Issue Watch") setScreen("allowed-users");
         else if (chosen === "Do Work") setScreen("do-work-base-branch");
+        else if (chosen === "Git") setScreen("git-trunk-branch");
         else setScreen("prompts-menu");
       }
     },
@@ -550,6 +562,12 @@ function ConfigWizard() {
       label: "Instructions for a pull request with no linked issue:",
       value: doWorkPrOrphanPrompt,
       hint: `Type prompt \xB7 Enter to save \xB7 ${BACK}`
+    },
+    "git-trunk-branch": {
+      title: "Git \u2014 Trunk Branch",
+      label: "Branch publish-release releases to (blank = detect it from the remote):",
+      value: gitTrunkBranch,
+      hint: `Type branch \xB7 Enter to save \xB7 ${BACK}`
     }
   };
   const menuViews = {

package/dist/index.js

@@ -214,12 +214,23 @@ var configSetDoWorkPrompt = new Command("do-work-prompt").description("Set the t
   process.stdout.write(`do-work ${turnKind} prompt set.
 `);
 });
-var configSet = new Command("set").description("Set a configuration value").addCommand(configSetType).addCommand(configSetIssueDiscoveryTechnique).addCommand(configSetIssueDiscoveryValue).addCommand(configSetClaudeSystemPrompt).addCommand(configSetAllowedUsers).addCommand(configSetAgentUser).addCommand(configSetDoWorkBaseBranch).addCommand(configSetDoWorkProtectedBranches).addCommand(configSetDoWorkExecutor).addCommand(configSetDoWorkModel).addCommand(configSetDoWorkEffort).addCommand(configSetDoWorkMaxRuns).addCommand(configSetDoWorkLockStaleMinutes).addCommand(configSetDoWorkPrompt);
+var configSetGitTrunkBranch = new Command("git-trunk-branch").description("Pin the branch `publish-release` releases to, instead of detecting it").argument("<value>", "Branch name (unset = detect it from the remote)").action((value) => {
+  const branch = value.trim();
+  if (branch.length === 0) {
+    process.stderr.write("Error: git-trunk-branch requires a non-empty branch name.\n");
+    process.exit(1);
+  }
+  const current = readRawConfig();
+  writeConfig({ ...current, git: { ...current.git, trunkBranch: branch } });
+  process.stdout.write(`git trunk branch set to: ${branch}
+`);
+});
+var configSet = new Command("set").description("Set a configuration value").addCommand(configSetType).addCommand(configSetIssueDiscoveryTechnique).addCommand(configSetIssueDiscoveryValue).addCommand(configSetClaudeSystemPrompt).addCommand(configSetAllowedUsers).addCommand(configSetAgentUser).addCommand(configSetDoWorkBaseBranch).addCommand(configSetDoWorkProtectedBranches).addCommand(configSetDoWorkExecutor).addCommand(configSetDoWorkModel).addCommand(configSetDoWorkEffort).addCommand(configSetDoWorkMaxRuns).addCommand(configSetDoWorkLockStaleMinutes).addCommand(configSetDoWorkPrompt).addCommand(configSetGitTrunkBranch);
 var configCommand = new Command("config").description("Configure automata settings").addCommand(configSet).action(async () => {
   const [{ render }, React, { ConfigWizard }] = await Promise.all([
     import("ink"),
     import("react"),
-    import("./ConfigWizard-D6NYL2E6.js")
+    import("./ConfigWizard-GULICHML.js")
   ]);
   const { waitUntilExit } = render(React.createElement(ConfigWizard));
   await waitUntilExit();
@@ -280,6 +291,44 @@ function getPrInfo() {
   };
 }
 
+// src/git/trunkDetection.ts
+var TRUNK_CANDIDATES = ["main", "master"];
+var TRUNK_BRANCH_CONFIG_KEY = "git.trunkBranch";
+var ORIGIN_HEAD_PREFIX = "refs/remotes/origin/";
+var SYMREF_PREFIX = "ref: refs/heads/";
+function parseOriginHeadRef(stdout) {
+  const ref = stdout.trim();
+  if (!ref.startsWith(ORIGIN_HEAD_PREFIX)) return null;
+  const branch = ref.slice(ORIGIN_HEAD_PREFIX.length);
+  return branch.length > 0 ? branch : null;
+}
+function parseLsRemoteSymref(stdout) {
+  for (const line of stdout.split("\n")) {
+    const trimmed2 = line.trim();
+    if (!trimmed2.startsWith(SYMREF_PREFIX)) continue;
+    const branch = trimmed2.slice(SYMREF_PREFIX.length).split(/\s+/)[0];
+    if (branch.length > 0) return branch;
+  }
+  return null;
+}
+function describeTrunkSource(source, branch) {
+  switch (source) {
+    case "config":
+      return `configured as ${TRUNK_BRANCH_CONFIG_KEY}`;
+    case "origin-head":
+      return "from origin/HEAD";
+    case "ls-remote":
+      return "from the remote's advertised HEAD";
+    case "probe":
+      return `probed as origin/${branch}`;
+  }
+}
+function unresolvedTrunkMessage(attempted) {
+  return `Could not determine the trunk branch of 'origin'.
+Tried: ${attempted.join(", ")}.
+Set it explicitly with: automata config set git-trunk-branch <branch>`;
+}
+
 // src/git/gitService.ts
 function run2(cmd, args) {
   const result = spawnSync2(cmd, args, { encoding: "utf8" });
@@ -963,7 +1012,63 @@ function resolveCurrentBranchComments() {
   return { ok: true, branch, comments: raw };
 }
 var SEMVER_RE = /^v?(\d+)\.(\d+)\.(\d+)$/;
-function getLatestTagOnMaster() {
+function remoteBranchExists(branch) {
+  return !isUpstreamGone(branch);
+}
+function resolveTrunkBranch() {
+  const configured = readRawConfig().git?.trunkBranch?.trim();
+  if (configured) {
+    return { ok: true, branch: configured, source: "config" };
+  }
+  const attempted = [];
+  attempted.push("origin/HEAD");
+  const head = run2("git", ["symbolic-ref", "--quiet", "refs/remotes/origin/HEAD"]);
+  if (head.status === 0) {
+    const branch = parseOriginHeadRef(head.stdout);
+    if (branch !== null) return { ok: true, branch, source: "origin-head" };
+  }
+  attempted.push("git ls-remote --symref origin HEAD");
+  const symref = run2("git", ["ls-remote", "--symref", "origin", "HEAD"]);
+  if (symref.status === 0) {
+    const branch = parseLsRemoteSymref(symref.stdout);
+    if (branch !== null) return { ok: true, branch, source: "ls-remote" };
+  }
+  for (const candidate of TRUNK_CANDIDATES) {
+    attempted.push(`origin/${candidate}`);
+    if (remoteBranchExists(candidate)) {
+      return { ok: true, branch: candidate, source: "probe" };
+    }
+  }
+  return { ok: false, attempted };
+}
+function fetchTrunkAndTags(trunk) {
+  const { status, stderr } = run2("git", [
+    "fetch",
+    "--tags",
+    "origin",
+    `+refs/heads/${trunk}:refs/remotes/origin/${trunk}`
+  ]);
+  if (status !== 0) {
+    return { ok: false, message: stderr.trim() || `git fetch --tags origin ${trunk} failed.` };
+  }
+  return { ok: true };
+}
+function localBranchExists(branch) {
+  const { status } = run2("git", ["rev-parse", "--verify", "--quiet", `refs/heads/${branch}`]);
+  return status === 0;
+}
+function trunkBehindCount(trunk) {
+  if (!localBranchExists(trunk)) return 0;
+  const { stdout, status } = run2("git", [
+    "rev-list",
+    "--count",
+    `refs/heads/${trunk}..refs/remotes/origin/${trunk}`
+  ]);
+  if (status !== 0) return 0;
+  const count = Number.parseInt(stdout.trim(), 10);
+  return Number.isNaN(count) ? 0 : count;
+}
+function getLatestTagOnTrunk(ref) {
   const { stdout, status } = run2("git", [
     "describe",
     "--tags",
@@ -972,7 +1077,7 @@ function getLatestTagOnMaster() {
     "[0-9]*.[0-9]*.[0-9]*",
     "--match",
     "v[0-9]*.[0-9]*.[0-9]*",
-    "master"
+    ref
   ]);
   if (status !== 0) return null;
   const tag = stdout.trim();
@@ -993,17 +1098,45 @@ ${stderr.trim()}`);
   }
   return stdout.trim().length > 0;
 }
-function publishRelease(version2, dryRun) {
+function checkReleasePreconditions() {
+  let branch;
+  try {
+    branch = getCurrentBranch();
+  } catch (err) {
+    return { ok: false, message: err.message };
+  }
+  if (branch !== "develop") {
+    return {
+      ok: false,
+      message: `publish-release must be run from the 'develop' branch (currently on '${branch}').`
+    };
+  }
+  if (hasUncommittedChanges()) {
+    return {
+      ok: false,
+      message: "You have uncommitted changes. Commit or stash them before publishing a release."
+    };
+  }
+  return { ok: true };
+}
+function publishRelease(version2, dryRun, trunk) {
   const releaseBranch = `release/${version2}`;
+  const checkoutTrunk = localBranchExists(trunk) ? { args: ["checkout", trunk], desc: `git checkout ${trunk}` } : {
+    args: ["checkout", "-b", trunk, `origin/${trunk}`],
+    desc: `git checkout -b ${trunk} origin/${trunk}`
+  };
   const steps = [
     { args: ["checkout", "-b", releaseBranch], desc: `git checkout -b ${releaseBranch}` },
-    { args: ["checkout", "master"], desc: `git checkout master` },
+    checkoutTrunk,
     { 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}` }
+    {
+      args: ["push", "origin", "develop", trunk, version2],
+      desc: `git push origin develop ${trunk} ${version2}`
+    }
   ];
   for (const step of steps) {
     if (dryRun) {
@@ -1019,6 +1152,29 @@ ${stderr.trim()}`);
   }
 }
 
+// src/git/releaseVersion.ts
+var SEMVER_ARG_RE = /^\d+\.\d+\.\d+$/;
+function resolveReleaseVersion(requested, trunkRef, latestTag) {
+  if (requested !== void 0) {
+    if (!SEMVER_ARG_RE.test(requested)) {
+      return {
+        ok: false,
+        message: `Version '${requested}' is not valid semver. Use X.Y.Z format (e.g. 1.2.0).`
+      };
+    }
+    return { ok: true, version: requested, notice: null };
+  }
+  const latest = latestTag();
+  if (latest === null) {
+    return {
+      ok: false,
+      message: `No semver tag found on ${trunkRef}. Pass a version explicitly: automata git publish-release <X.Y.Z>`
+    };
+  }
+  const version2 = bumpMinorVersion(latest);
+  return { ok: true, version: version2, notice: `Auto-detected version: ${latest} \u2192 ${version2}` };
+}
+
 // src/commands/git.ts
 var FAIL_CONCLUSIONS = /* @__PURE__ */ new Set(["FAILURE", "TIMED_OUT", "ACTION_REQUIRED", "CANCELLED"]);
 var SKIP_CONCLUSIONS = /* @__PURE__ */ new Set(["SKIPPED", "NEUTRAL"]);
@@ -1383,59 +1539,58 @@ var finishFeatureCmd = new Command2("finish-feature").description("Clean up a me
     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(
+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 the trunk 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>
+  2. git checkout <trunk> && 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>
+  6. git push origin develop <trunk> <version>
+
+<trunk> is resolved from origin \u2014 git.trunkBranch in .automata/config.json if
+set, else origin/HEAD, the remote's advertised HEAD, or a probe of main/master.
+Tags are fetched from origin first, in --dry-run too, so the version a dry run
+prints is the one a real run would use.
 
-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).`
+When [version] is omitted the latest semver tag on origin/<trunk> 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}
+  const preconditions = checkReleasePreconditions();
+  if (!preconditions.ok) {
+    process.stderr.write(`Error: ${preconditions.message}
 `);
     process.exit(1);
   }
-  if (branch !== "develop") {
-    process.stderr.write(
-      `Error: publish-release must be run from the 'develop' branch (currently on '${branch}').
-`
-    );
+  const trunk = resolveTrunkBranch();
+  if (!trunk.ok) {
+    process.stderr.write(`Error: ${unresolvedTrunkMessage(trunk.attempted)}
+`);
     process.exit(1);
   }
-  if (hasUncommittedChanges()) {
-    process.stderr.write("Error: You have uncommitted changes. Commit or stash them before publishing a release.\n");
+  const trunkBranch = trunk.branch;
+  const trunkRef = `origin/${trunkBranch}`;
+  process.stdout.write(`Trunk branch: ${trunkBranch} (${describeTrunkSource(trunk.source, trunkBranch)})
+`);
+  const fetched = fetchTrunkAndTags(trunkBranch);
+  if (!fetched.ok) {
+    process.stderr.write(`Error: Failed to fetch ${trunkBranch} and tags from origin.
+${fetched.message}
+`);
     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).
+  const versionResult = resolveReleaseVersion(version2, trunkRef, () => getLatestTagOnTrunk(trunkRef));
+  if (!versionResult.ok) {
+    process.stderr.write(`Error: ${versionResult.message}
 `);
-      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}
+    process.exit(1);
+  }
+  const resolvedVersion = versionResult.version;
+  if (versionResult.notice !== null) {
+    process.stdout.write(`${versionResult.notice}
 `);
   }
   if (tagExists(resolvedVersion)) {
@@ -1443,6 +1598,14 @@ minor segment is incremented (e.g. 1.2.0 \u2192 1.3.0).`
 `);
     process.exit(1);
   }
+  const behind = trunkBehindCount(trunkBranch);
+  if (behind > 0) {
+    process.stderr.write(
+      `Error: Local branch '${trunkBranch}' is ${String(behind)} commit(s) behind ${trunkRef}. Update it (git checkout ${trunkBranch} && git merge --ff-only ${trunkRef}) or delete it, then re-run.
+`
+    );
+    process.exit(1);
+  }
   if (dryRun) {
     process.stdout.write(`Dry-run: release ${resolvedVersion}
 `);
@@ -1451,7 +1614,7 @@ minor segment is incremented (e.g. 1.2.0 \u2192 1.3.0).`
 `);
   }
   try {
-    publishRelease(resolvedVersion, dryRun);
+    publishRelease(resolvedVersion, dryRun, trunkBranch);
   } catch (err) {
     process.stderr.write(`Error: ${err.message}
 `);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "automata-cli",
-  "version": "0.8.0-develop.346",
+  "version": "0.8.0-develop.353",
   "description": "Automata CLI tool",
   "type": "module",
   "engines": {