automata-cli 0.7.0 → 0.8.0-develop.346

package/dist/index.js

@@ -230,6 +230,7 @@ import { Command as Command2 } from "commander";
 
 // src/git/gitService.ts
 import { spawnSync as spawnSync2 } from "child_process";
+import { existsSync } from "fs";
 
 // src/config/azdoService.ts
 import { spawnSync } from "child_process";
@@ -752,7 +753,7 @@ function checkoutAndPull(targetBranch) {
   if (checkout.status !== 0) {
     throw new Error(`Failed to checkout ${targetBranch}: ${checkout.stderr.trim()}`);
   }
-  const pull = run2("git", ["pull"]);
+  const pull = run2("git", ["pull", "--ff-only"]);
   if (pull.status !== 0) {
     throw new Error(`Failed to pull ${targetBranch}: ${pull.stderr.trim()}`);
   }
@@ -785,6 +786,41 @@ function isAncestorCommit(maybeAncestor, descendant) {
 function resetHardTo(ref) {
   return gitCommand(["reset", "--hard", ref]);
 }
+var CHERRY_LINE = /^([+-]) ([0-9a-f]+)$/;
+function describeDivergence(upstream, head) {
+  const cherry = run2("git", ["cherry", upstream, head]);
+  if (cherry.status !== 0) return null;
+  const commits = [];
+  for (const line of cherry.stdout.split("\n")) {
+    const trimmed2 = line.trim();
+    if (trimmed2.length === 0) continue;
+    const match = CHERRY_LINE.exec(trimmed2);
+    if (match === null) return null;
+    commits.push({ sha: match[2], alreadyUpstream: match[1] === "-" });
+  }
+  const merges = run2("git", ["rev-list", "--count", "--merges", `${upstream}..${head}`]);
+  if (merges.status !== 0) return null;
+  const count = Number.parseInt(merges.stdout.trim(), 10);
+  if (!Number.isInteger(count)) return null;
+  return { commits, merges: count };
+}
+function rebaseOnto(ref) {
+  const { stdout, stderr, status } = run2("git", ["rebase", "--no-reapply-cherry-picks", ref]);
+  const detail = [stdout.trim(), stderr.trim()].filter((part) => part.length > 0).join("\n");
+  return { ok: status === 0, stderr: detail };
+}
+function abortRebase() {
+  return gitCommand(["rebase", "--abort"]);
+}
+var REBASE_STATE_PATHS = ["rebase-merge", "rebase-apply/rebasing"];
+function isRebaseInProgress() {
+  return REBASE_STATE_PATHS.some((name) => {
+    const { stdout, status } = run2("git", ["rev-parse", "--git-path", name]);
+    if (status !== 0) return false;
+    const path = stdout.trim();
+    return path.length > 0 && existsSync(path);
+  });
+}
 function fetchPrune() {
   const result = run2("git", ["fetch", "--prune"]);
   if (result.status !== 0) {
@@ -2035,7 +2071,7 @@ function parseCreatedPrUrl(stdout, head) {
 // src/claude/claudeService.ts
 import { spawn, spawnSync as spawnSync5 } from "child_process";
 import { createInterface } from "readline";
-import { existsSync } from "fs";
+import { existsSync as existsSync2 } from "fs";
 import { delimiter, join } from "path";
 
 // src/cli/spawnUtils.ts
@@ -2129,7 +2165,7 @@ function resolveCommand(name) {
   const pathDirs = (process.env["PATH"] ?? "").split(delimiter);
   for (const dir of pathDirs) {
     const candidate = join(dir, name);
-    if (existsSync(candidate)) return candidate;
+    if (existsSync2(candidate)) return candidate;
   }
   return name;
 }
@@ -3668,7 +3704,7 @@ function prepareBaseBranch(baseBranch) {
   if (!pull.ok) {
     return { ok: false, reason: "pull-failed", detail: pull.stderr };
   }
-  return { ok: true, branch: baseBranch };
+  return { ok: true, branch: baseBranch, strategy: "fast-forward" };
 }
 function resetToForcePushedRemote(headRefName, previousRemoteSha) {
   const localSha = revParse(`refs/heads/${headRefName}`);
@@ -3678,7 +3714,81 @@ function resetToForcePushedRemote(headRefName, previousRemoteSha) {
   if (!reset.ok) {
     return { ok: false, reason: "pull-failed", detail: reset.stderr };
   }
-  return { ok: true, branch: headRefName };
+  return { ok: true, branch: headRefName, strategy: "reset-to-remote" };
+}
+function rebaseOntoAlreadyAppliedRemote(headRefName) {
+  const upstream = `refs/remotes/origin/${headRefName}`;
+  const divergence = describeDivergence(upstream, `refs/heads/${headRefName}`);
+  if (divergence === null) return null;
+  if (divergence.merges > 0) return null;
+  if (divergence.commits.length === 0) return null;
+  if (divergence.commits.some((commit) => !commit.alreadyUpstream)) return null;
+  if (isRebaseInProgress()) {
+    return {
+      ok: false,
+      reason: "pull-failed",
+      detail: `a rebase is already in progress in this checkout and automata did not start it, so ${headRefName} was left untouched; finish it with \`git rebase --continue\` or drop it with \`git rebase --abort\``
+    };
+  }
+  const rebase = rebaseOnto(upstream);
+  if (!rebase.ok) {
+    if (!isRebaseInProgress()) {
+      return {
+        ok: false,
+        reason: "pull-failed",
+        detail: `${rebase.stderr} \u2014 the rebase never started, so ${headRefName} is untouched`
+      };
+    }
+    const aborted = abortRebase();
+    const restored = aborted.ok ? `the rebase was aborted, so ${headRefName} is back where it was` : `the rebase could NOT be aborted (${aborted.stderr}) \u2014 run \`git rebase --abort\` in the checkout`;
+    return {
+      ok: false,
+      reason: "rebase-conflict",
+      detail: `${rebase.stderr} \u2014 ${restored}`
+    };
+  }
+  const local = revParse(`refs/heads/${headRefName}`);
+  const remote = revParse(upstream);
+  if (local === null || remote === null || local !== remote) {
+    return {
+      ok: false,
+      reason: "pull-failed",
+      detail: `the rebase of ${headRefName} onto origin/${headRefName} reported success but did not land on the remote tip, so the branch is still out of sync; compare them with \`git log origin/${headRefName}..${headRefName}\``
+    };
+  }
+  return { ok: true, branch: headRefName, strategy: "rebase" };
+}
+function divergenceRefusal(headRefName, pullError) {
+  const divergence = describeDivergence(
+    `refs/remotes/origin/${headRefName}`,
+    `refs/heads/${headRefName}`
+  );
+  if (divergence === null) {
+    return {
+      ok: false,
+      reason: "pull-failed",
+      detail: `${pullError} \u2014 how the local ${headRefName} relates to origin/${headRefName} could not be established, so nothing was changed and ${headRefName} is untouched; inspect it with \`git log --oneline origin/${headRefName}...${headRefName}\` before deciding what to do`
+    };
+  }
+  const unpushedCount = divergence.commits.filter((c) => !c.alreadyUpstream).length + divergence.merges;
+  if (unpushedCount === 0) {
+    return {
+      ok: false,
+      reason: "pull-failed",
+      detail: `${pullError} \u2014 no commit of the local ${headRefName} is missing from origin/${headRefName}, so this is not a divergence; ${headRefName} is untouched and git's own error above is the cause to fix`
+    };
+  }
+  let unpushed;
+  if (unpushedCount === 1) {
+    unpushed = `1 of its commits is not on origin/${headRefName}`;
+  } else {
+    unpushed = `${String(unpushedCount)} of its commits are not on origin/${headRefName}`;
+  }
+  return {
+    ok: false,
+    reason: "pull-failed",
+    detail: `${pullError} \u2014 the local ${headRefName} has diverged from origin/${headRefName} and ${unpushed}, so it was not synchronized automatically; inspect them with \`git log origin/${headRefName}..${headRefName}\` and \`git reset --hard origin/${headRefName}\` yourself once they are safe to lose`
+  };
 }
 function preparePrBranch(headRefName) {
   if (hasUncommittedChanges([RUN_LOCK_RELATIVE_PATH])) return dirtyTree();
@@ -3687,25 +3797,28 @@ function preparePrBranch(headRefName) {
   if (!fetched.ok) {
     return { ok: false, reason: "checkout-failed", detail: fetched.stderr };
   }
+  const localExisted = revParse(`refs/heads/${headRefName}`) !== null;
   const checkout = checkoutBranch(headRefName);
   if (!checkout.ok) {
     const created = createTrackingBranch(headRefName);
     if (!created.ok) {
       return { ok: false, reason: "checkout-failed", detail: created.stderr };
     }
-    return { ok: true, branch: headRefName };
+    return { ok: true, branch: headRefName, strategy: "tracking-branch" };
   }
   const pull = pullFastForwardOnly(headRefName);
   if (!pull.ok) {
     const reset = resetToForcePushedRemote(headRefName, previousRemoteSha);
     if (reset !== null) return reset;
-    return {
-      ok: false,
-      reason: "pull-failed",
-      detail: `${pull.stderr} \u2014 the local ${headRefName} has commits origin/${headRefName} does not, so it was not reset automatically; inspect them and \`git reset --hard origin/${headRefName}\` yourself`
-    };
+    const rebased = rebaseOntoAlreadyAppliedRemote(headRefName);
+    if (rebased !== null) return rebased;
+    return divergenceRefusal(headRefName, pull.stderr);
   }
-  return { ok: true, branch: headRefName };
+  return {
+    ok: true,
+    branch: headRefName,
+    strategy: localExisted ? "fast-forward" : "tracking-branch"
+  };
 }
 
 // src/git/repoHygiene.ts
@@ -4073,6 +4186,18 @@ function repoField(repo) {
   const flat = oneLine(repo);
   return flat.length === 0 ? "-" : flat;
 }
+var QUIET_SYNC = /* @__PURE__ */ new Set(["fast-forward", "tracking-branch"]);
+function summarizeSync(items) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    if (item.sync === void 0) continue;
+    const key = oneLine(item.sync);
+    if (key.length === 0 || QUIET_SYNC.has(key)) continue;
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+  }
+  if (counts.size === 0) return null;
+  return [...counts].map(([strategy, count]) => `${strategy}:${String(count)}`).join(",");
+}
 function formatExecutionLine(tick) {
   const counts = {
     answered: 0,
@@ -4096,6 +4221,8 @@ function formatExecutionLine(tick) {
     `exit=${String(tick.exitCode)}`,
     `dur=${(tick.durationMs / 1e3).toFixed(1)}s`
   ];
+  const sync = summarizeSync(tick.items);
+  if (sync !== null) fields.push(`sync=${sync}`);
   if (tick.note !== void 0 && tick.note.length > 0) fields.push(`note=${tick.note}`);
   return fields.join(" ") + "\n";
 }
@@ -4112,13 +4239,18 @@ function describeItemExecution(item) {
   const effort = item.effort === void 0 ? "" : ` effort=${oneLine(item.effort)}`;
   return ` [${oneLine(item.executor)}${model}${effort}]`;
 }
+function describeItemSync(item) {
+  if (item.sync === void 0) return "";
+  const flat = oneLine(item.sync);
+  return flat.length === 0 ? "" : ` sync=${flat}`;
+}
 function formatWorkRecord(tick) {
   const ran = tick.items.filter((item) => item.ranExecutor);
   if (ran.length === 0) return null;
   const header = `=== ${tick.timestamp.toISOString()} ${repoField(tick.repo)} ===
 `;
   const lines = ran.map(
-    (item) => `${oneLine(item.subject)} ${item.turn === null ? "-" : oneLine(item.turn)} ${item.outcome}${describeItemExecution(item)} \u2014 ${briefDetail(item.detail)}
+    (item) => `${oneLine(item.subject)} ${item.turn === null ? "-" : oneLine(item.turn)} ${item.outcome}${describeItemExecution(item)}${describeItemSync(item)} \u2014 ${briefDetail(item.detail)}
 `
   );
   return header + lines.join("") + "\n";
@@ -4202,6 +4334,7 @@ function recordTick(tick, dir = operationLogDirectory()) {
 
 // src/commands/doWork.ts
 var inFlightMarker = null;
+var inFlightSync = null;
 function subjectLabel(issue, pr) {
   if (issue !== null) return `#${String(issue)}`;
   return pr === null ? "#?" : `PR #${String(pr)}`;
@@ -4840,6 +4973,7 @@ async function processItem(planned, settings, silent, preflightCauses) {
   progress(`
 ${itemLabel(planned)} ${planned.turn}: ${planned.reason}
 `);
+  inFlightSync = null;
   const refreshed = refreshItem(planned, settings);
   if (refreshed.kind === "skip") {
     progress(`  skipped: ${refreshed.detail}
@@ -4872,9 +5006,18 @@ ${itemLabel(planned)} ${planned.turn}: ${planned.reason}
     return {
       ...base,
       outcome: "skipped",
-      detail: `${prepared.reason}: ${prepared.detail}${why}`
+      detail: `${prepared.reason}: ${prepared.detail}${why}`,
+      sync: prepared.reason
     };
   }
+  base.sync = prepared.strategy;
+  inFlightSync = prepared.strategy;
+  if (prepared.strategy !== "fast-forward" && prepared.strategy !== "tracking-branch") {
+    progress(
+      `  ${prepared.branch} had diverged from origin; synchronized by ${prepared.strategy}.
+`
+    );
+  }
   claimIssue(item, settings);
   if (item.turn === "pr-work" && item.pr !== null && item.prNeedsAssignment) {
     claimPr(item.pr.number, settings.participants.agentUser);
@@ -5077,7 +5220,8 @@ function toTickLogItem(report) {
     ranExecutor: report.ranExecutor ?? false,
     executor: report.execution?.executor,
     model: report.execution?.model,
-    effort: report.execution?.effort
+    effort: report.execution?.effort,
+    sync: report.sync
   };
 }
 function logTick(reports, exitCode, startedAt, note) {
@@ -5183,7 +5327,8 @@ ${describePlan(decisions)}`;
         title: itemTitle(item),
         turn: item.turn,
         outcome: "failed",
-        detail: err.message
+        detail: err.message,
+        sync: inFlightSync ?? void 0
       };
     }
     if (report.ranExecutor === true) runsUsed++;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "automata-cli",
-  "version": "0.7.0",
+  "version": "0.8.0-develop.346",
   "description": "Automata CLI tool",
   "type": "module",
   "engines": {
@@ -37,14 +37,14 @@
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
-    "@types/node": "^25.5.0",
+    "@types/node": "^26.6.1",
     "@types/react": "^19.3.0",
     "eslint": "^10.10.0",
     "ink-testing-library": "^4.0.0",
-    "prettier": "^3.9.6",
+    "prettier": "^3.9.7",
     "tsup": "^8.5.1",
     "typescript": "^5.9.3",
     "typescript-eslint": "^8.70.0",
-    "vitest": "^5.0.0"
+    "vitest": "^5.0.1"
   }
 }