automata-cli 0.6.0-develop.273 → 0.6.0-develop.282

package/dist/index.js

@@ -778,6 +778,47 @@ function deleteLocalBranch(branch) {
     throw new Error(`Failed to delete branch ${branch}: ${result.stderr.trim()}`);
   }
 }
+function listLocalBranches() {
+  const { stdout, status } = run2("git", ["for-each-ref", "--format=%(refname:short)", "refs/heads"]);
+  if (status !== 0) return [];
+  return stdout.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+}
+function listRemoteBranches() {
+  const { stdout, status } = run2("git", ["ls-remote", "--heads", "origin"]);
+  if (status !== 0) return null;
+  const names = [];
+  for (const line of stdout.split("\n")) {
+    const match = /^[0-9a-f]+\s+refs\/heads\/(.+)$/.exec(line.trim());
+    if (match) names.push(match[1]);
+  }
+  return names;
+}
+function createBranchAtHead(branch) {
+  return gitCommand(["checkout", "-b", branch]);
+}
+function stageAllExcept(excludePaths) {
+  const args = ["add", "-A"];
+  if (excludePaths.length > 0) {
+    args.push("--", ".", ...excludePaths.map((path) => `:(exclude)${path}`));
+  }
+  return gitCommand(args);
+}
+function commitStaged(message) {
+  return gitCommand(["commit", "-m", message]);
+}
+function pushSetUpstream(branch) {
+  return gitCommand(["push", "-u", "origin", branch]);
+}
+function countCommitsNotIn(baseBranch, branch) {
+  const { stdout, status } = run2("git", ["rev-list", "--count", `${baseBranch}..${branch}`]);
+  if (status !== 0) return null;
+  const trimmed2 = stdout.trim();
+  if (!/^\d+$/.test(trimmed2)) return null;
+  return Number(trimmed2);
+}
+function forceDeleteLocalBranch(branch) {
+  return gitCommand(["branch", "-D", branch]);
+}
 var REVIEW_THREADS_QUERY = `
 query($owner:String!,$repo:String!,$prNumber:Int!){
   repository(owner:$owner,name:$repo){
@@ -2765,6 +2806,68 @@ function deleteMarker(marker) {
     throw new Error(stderr.trim() || `Failed to delete comment ${marker.commentId}.`);
   }
 }
+function toHeadState(state) {
+  return state === "OPEN" || state === "MERGED" ? state : "CLOSED";
+}
+function listPullRequestsForHead(branch) {
+  const raw = ghJson(
+    ["pr", "list", "--head", branch, "--state", "all", "--json", "number,state,url,updatedAt"],
+    `list pull requests for branch ${branch}`
+  );
+  return raw.map((pr) => ({
+    number: pr.number,
+    url: pr.url,
+    state: toHeadState(pr.state),
+    updatedAt: pr.updatedAt
+  })).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+}
+var MISSING_LABEL_PATTERNS = [
+  // gh's own message: `could not add label: 'rescue' not found`.
+  /could not add label/i,
+  // The GraphQL error it wraps, seen directly on some gh versions.
+  /could not resolve to a label/i,
+  /\blabels?\b[^\n]*\b(?:not found|does not exist)\b/i
+];
+function isMissingLabelError(stderr) {
+  return MISSING_LABEL_PATTERNS.some((pattern) => pattern.test(stderr));
+}
+function createDraftPullRequest(input) {
+  const base = [
+    "pr",
+    "create",
+    "--draft",
+    "--head",
+    input.head,
+    "--base",
+    input.base,
+    "--title",
+    input.title,
+    "--body",
+    input.body
+  ];
+  if (input.label !== void 0 && input.label.length > 0) {
+    const labelled = run4("gh", [...base, "--label", input.label]);
+    if (labelled.status === 0) return parseCreatedPrUrl(labelled.stdout, input.head);
+    if (!isMissingLabelError(labelled.stderr)) {
+      throw new Error(
+        labelled.stderr.trim() || `Failed to open a draft pull request for ${input.head}.`
+      );
+    }
+  }
+  const { stdout, stderr, status } = run4("gh", base);
+  if (status !== 0) {
+    throw new Error(stderr.trim() || `Failed to open a draft pull request for ${input.head}.`);
+  }
+  return parseCreatedPrUrl(stdout, input.head);
+}
+function parseCreatedPrUrl(stdout, head) {
+  const url = stdout.trim().split("\n").pop()?.trim() ?? "";
+  const match = /\/pull\/(\d+)\s*$/.exec(url);
+  if (!match) {
+    throw new Error(`Opened a pull request for ${head} but could not read its number from: ${url}`);
+  }
+  return { number: Number(match[1]), url };
+}
 
 // src/github/workDetection.ts
 function isAssignedToAgent(assignees, agentUser) {
@@ -3402,6 +3505,283 @@ function preparePrBranch(headRefName) {
   return { ok: true, branch: headRefName };
 }
 
+// src/git/repoHygiene.ts
+var RESCUE_PR_LABEL = "rescue";
+var RESCUE_BRANCH_PREFIX = "rescue/";
+function utcStamp(now) {
+  return now.toISOString().replace(/[-:]/g, "").replace(/\.\d+Z$/, "Z");
+}
+function flattenBranchName(branch) {
+  return branch.replaceAll("/", "-");
+}
+function detectRescueTarget(baseBranch, now) {
+  const current = getCurrentBranch();
+  const detached = current === "HEAD" || current.length === 0;
+  if (!detached && current !== baseBranch) {
+    return { branch: current, createdBranch: false, source: current };
+  }
+  const source = detached ? "detached HEAD" : baseBranch;
+  const label = detached ? "detached" : flattenBranchName(baseBranch);
+  return {
+    branch: `${RESCUE_BRANCH_PREFIX}${label}-${utcStamp(now)}`,
+    createdBranch: true,
+    source
+  };
+}
+function rescueBody(source) {
+  return `Opened by \`automata do-work\`'s repository-hygiene pre-flight because this branch carried work that existed only in the local checkout.
+
+Source: \`${source}\`.
+
+It is a draft and references no issue: nothing here is claimed to be finished, it is here so it cannot be lost. Review it, fold it into the right pull request, or close it.`;
+}
+function findOpenPr(branch) {
+  const prs = listPullRequestsForHead(branch);
+  return prs.find((pr) => pr.state === "OPEN") ?? null;
+}
+function rescueUncommittedChanges(options, now) {
+  if (!hasUncommittedChanges([RUN_LOCK_RELATIVE_PATH])) {
+    options.log("  rescue    nothing to do; the working tree is clean\n");
+    return { kind: "clean" };
+  }
+  const target = detectRescueTarget(options.baseBranch, now);
+  if (options.dryRun) {
+    options.log(
+      target.createdBranch ? `  rescue    would create ${target.branch} off ${target.source}, commit the uncommitted changes, push it and open a draft PR
+` : `  rescue    would commit the uncommitted changes onto ${target.branch}, push it and open a draft PR if it has none open
+`
+    );
+    return { kind: "would-rescue", branch: target.branch, createdBranch: target.createdBranch };
+  }
+  if (target.createdBranch) {
+    const created = createBranchAtHead(target.branch);
+    if (!created.ok) {
+      options.log(`  rescue    FAILED to create ${target.branch}: ${created.stderr}
+`);
+      return { kind: "failed", step: "branch", detail: created.stderr };
+    }
+  }
+  const staged = stageAllExcept([RUN_LOCK_RELATIVE_PATH]);
+  if (!staged.ok) {
+    options.log(`  rescue    FAILED to stage the changes: ${staged.stderr}
+`);
+    return { kind: "failed", step: "stage", detail: staged.stderr };
+  }
+  const committed = commitStaged(`chore(automata): rescue uncommitted work from ${target.source}`);
+  if (!committed.ok) {
+    options.log(`  rescue    FAILED to commit: ${committed.stderr}
+`);
+    return { kind: "failed", step: "commit", detail: committed.stderr };
+  }
+  const pushed = pushSetUpstream(target.branch);
+  if (!pushed.ok) {
+    options.log(`  rescue    FAILED to push ${target.branch}: ${pushed.stderr}
+`);
+    return { kind: "failed", step: "push", detail: pushed.stderr };
+  }
+  let existing;
+  try {
+    existing = findOpenPr(target.branch);
+  } catch (err) {
+    options.log(
+      `  rescue    committed and pushed ${target.branch}, but could not check for an open PR: ${err.message}
+`
+    );
+    return { kind: "failed", step: "pr", detail: err.message };
+  }
+  if (existing !== null) {
+    options.log(
+      `  rescue    committed and pushed ${target.branch}; PR #${String(existing.number)} is already open
+`
+    );
+    return {
+      kind: "rescued",
+      branch: target.branch,
+      createdBranch: target.createdBranch,
+      pr: existing.number,
+      prUrl: existing.url,
+      prCreated: false
+    };
+  }
+  try {
+    const pr = createDraftPullRequest({
+      head: target.branch,
+      base: options.baseBranch,
+      title: `rescue: uncommitted work from ${target.source}`,
+      body: rescueBody(target.source),
+      label: RESCUE_PR_LABEL
+    });
+    options.log(
+      `  rescue    committed and pushed ${target.branch}; opened draft PR #${String(pr.number)}
+`
+    );
+    return {
+      kind: "rescued",
+      branch: target.branch,
+      createdBranch: target.createdBranch,
+      pr: pr.number,
+      prUrl: pr.url,
+      prCreated: true
+    };
+  } catch (err) {
+    options.log(
+      `  rescue    committed and pushed ${target.branch}, but could not open a draft PR: ${err.message}
+`
+    );
+    return { kind: "failed", step: "pr", detail: err.message };
+  }
+}
+function prepareBase(options) {
+  if (options.dryRun) {
+    options.log(`  base      would check out ${options.baseBranch} and pull --ff-only
+`);
+    return { ok: true };
+  }
+  const checkout = checkoutBranch(options.baseBranch);
+  if (!checkout.ok) {
+    options.log(`  base      FAILED to check out ${options.baseBranch}: ${checkout.stderr}
+`);
+    return { ok: false, step: "checkout", detail: checkout.stderr };
+  }
+  const pull = pullFastForwardOnly();
+  if (!pull.ok) {
+    options.log(`  base      FAILED to pull ${options.baseBranch}: ${pull.stderr}
+`);
+    return { ok: false, step: "pull", detail: pull.stderr };
+  }
+  options.log(`  base      ${options.baseBranch} checked out and up to date
+`);
+  return { ok: true };
+}
+function collectCandidates(options) {
+  const remote = listRemoteBranches();
+  if (remote === null) return null;
+  const remoteNames = new Set(remote);
+  const current = getCurrentBranch();
+  const untouchable = /* @__PURE__ */ new Set([options.baseBranch, current, ...options.protectedBranches]);
+  return listLocalBranches().filter(
+    (branch) => !untouchable.has(branch) && !remoteNames.has(branch)
+  );
+}
+function deleteOrReport(branch, options, why) {
+  if (options.dryRun) {
+    options.log(`  prune     would delete ${branch} (no remote, ${why})
+`);
+    return { kind: "would-delete", branch };
+  }
+  const deleted = forceDeleteLocalBranch(branch);
+  if (!deleted.ok) {
+    options.log(`  prune     kept ${branch}: delete failed \u2014 ${deleted.stderr}
+`);
+    return { kind: "kept", branch, reason: "delete-failed", detail: deleted.stderr };
+  }
+  options.log(`  prune     deleted ${branch} (${why})
+`);
+  return { kind: "deleted", branch };
+}
+function pruneCandidate(branch, options) {
+  let prs;
+  try {
+    prs = listPullRequestsForHead(branch);
+  } catch (err) {
+    const detail = err.message;
+    options.log(`  prune     kept ${branch}: could not read its pull requests \u2014 ${detail}
+`);
+    return { kind: "kept", branch, reason: "lookup-failed", detail };
+  }
+  const openPr = prs.find((pr) => pr.state === "OPEN") ?? null;
+  if (openPr !== null) {
+    options.log(`  prune     kept ${branch}: PR #${String(openPr.number)} is open
+`);
+    return {
+      kind: "kept",
+      branch,
+      reason: "open-pr",
+      detail: `PR #${String(openPr.number)} is open`
+    };
+  }
+  const merged = prs.find((pr) => pr.state === "MERGED") ?? null;
+  if (merged !== null) {
+    return deleteOrReport(branch, options, `PR #${String(merged.number)} was merged`);
+  }
+  const closed = prs.find((pr) => pr.state === "CLOSED") ?? null;
+  if (closed !== null) {
+    return deleteOrReport(branch, options, `PR #${String(closed.number)} was closed unmerged`);
+  }
+  const unmerged = countCommitsNotIn(options.baseBranch, branch);
+  if (unmerged === null) {
+    const detail = `could not count commits outside ${options.baseBranch}`;
+    options.log(`  prune     kept ${branch}: ${detail}
+`);
+    return { kind: "kept", branch, reason: "lookup-failed", detail };
+  }
+  if (unmerged === 0) {
+    return deleteOrReport(branch, options, `nothing outside ${options.baseBranch}`);
+  }
+  if (options.dryRun) {
+    options.log(
+      `  prune     would push ${branch} and open a draft PR (${String(unmerged)} commit(s) outside ${options.baseBranch}), keeping the branch
+`
+    );
+    return { kind: "would-rescue", branch, unmergedCommits: unmerged };
+  }
+  const pushed = pushSetUpstream(branch);
+  if (!pushed.ok) {
+    options.log(
+      `  prune     kept ${branch}: has ${String(unmerged)} commit(s) outside ${options.baseBranch} and could not be pushed \u2014 ${pushed.stderr}
+`
+    );
+    return { kind: "kept", branch, reason: "push-failed", detail: pushed.stderr };
+  }
+  try {
+    const pr = createDraftPullRequest({
+      head: branch,
+      base: options.baseBranch,
+      title: `rescue: unmerged commits on ${branch}`,
+      body: rescueBody(branch),
+      label: RESCUE_PR_LABEL
+    });
+    options.log(
+      `  prune     rescued ${branch}: pushed and opened draft PR #${String(pr.number)}
+`
+    );
+    return { kind: "rescued", branch, pr: pr.number, prUrl: pr.url };
+  } catch (err) {
+    options.log(
+      `  prune     rescued ${branch}: pushed, but could not open a draft PR \u2014 ${err.message}
+`
+    );
+    return { kind: "rescued", branch, pr: null, prUrl: null };
+  }
+}
+function prune(options) {
+  const candidates = collectCandidates(options);
+  if (candidates === null) {
+    options.log(
+      "  prune     skipped: could not list origin's branches, so no branch can be shown to have no remote\n"
+    );
+    return { outcomes: [], remoteUnreadable: true };
+  }
+  if (candidates.length === 0) {
+    options.log("  prune     nothing to do; every local branch exists on origin\n");
+    return { outcomes: [], remoteUnreadable: false };
+  }
+  return {
+    outcomes: candidates.map((branch) => pruneCandidate(branch, options)),
+    remoteUnreadable: false
+  };
+}
+function runRepoHygiene(options, now = /* @__PURE__ */ new Date()) {
+  options.log(options.dryRun ? "\nPre-flight (dry run):\n" : "\nPre-flight:\n");
+  const rescue = rescueUncommittedChanges(options, now);
+  const base = prepareBase(options);
+  const { outcomes, remoteUnreadable } = prune(options);
+  const degraded = rescue.kind === "failed" || !base.ok || remoteUnreadable || outcomes.some(
+    (outcome) => outcome.kind === "kept" && outcome.reason !== "open-pr" || outcome.kind === "rescued" && outcome.pr === null
+  );
+  return { rescue, base, prunes: outcomes, degraded };
+}
+
 // src/commands/doWork.ts
 var inFlightMarker = null;
 function out(message) {
@@ -4148,6 +4528,12 @@ function explainInterruptedMarker() {
   }
 }
 async function runTick(settings, options) {
+  const hygiene = runRepoHygiene({
+    baseBranch: settings.baseBranch,
+    protectedBranches: settings.protectedBranches,
+    dryRun: options.dryRun === true,
+    log: progress
+  });
   const issues = discoverIssues(settings);
   const linkMap = getOpenPrLinkMap();
   const decisions = issues.map(
@@ -4166,7 +4552,7 @@ ${describePlan(decisions)}`;
     out(planText);
   }
   if (options.dryRun) {
-    reportDryRun(items, decisions, settings, options);
+    reportDryRun(items, decisions, settings, options, hygiene);
     return 0;
   }
   const reports = [];
@@ -4206,17 +4592,24 @@ ${describePlan(decisions)}`;
       detail: `run cap of ${String(settings.maxRuns)} reached`
     });
   }
-  const degraded = reports.some((report) => report.outcome !== "answered");
+  const degraded = hygiene.degraded || reports.some((report) => report.outcome !== "answered");
   const exitCode = degraded ? 2 : 0;
   if (options.json) {
     out(
       JSON.stringify(
-        { dryRun: false, plan: decisions.map(toPlanJson), items: reports.map(toItemJson), exitCode },
+        {
+          dryRun: false,
+          preflight: toHygieneJson(hygiene),
+          plan: decisions.map(toPlanJson),
+          items: reports.map(toItemJson),
+          exitCode
+        },
         null,
         2
       ) + "\n"
     );
   } else {
+    summarizeHygiene(hygiene);
     summarize(reports);
   }
   return exitCode;
@@ -4255,7 +4648,7 @@ function toRunJson(entry) {
     prompt: entry.run.prompt
   };
 }
-function reportDryRun(items, decisions, settings, options) {
+function reportDryRun(items, decisions, settings, options, hygiene) {
   const describable = settings.maxRuns > 0 ? items.slice(0, settings.maxRuns) : items;
   const planned = describable.map((item) => {
     const resolved = resolveItemExecution(item, settings);
@@ -4270,6 +4663,7 @@ function reportDryRun(items, decisions, settings, options) {
       JSON.stringify(
         {
           dryRun: true,
+          preflight: toHygieneJson(hygiene),
           plan: decisions.map(toPlanJson),
           runs: planned.map(toRunJson)
         },
@@ -4279,6 +4673,7 @@ function reportDryRun(items, decisions, settings, options) {
     );
     return;
   }
+  summarizeHygiene(hygiene);
   for (const entry of planned) {
     out(
       "\n" + (entry.kind === "refused" ? describeRefusedRun(entry.item, entry.refusal) : describePlannedRun(entry.item, settings, entry.run, entry.execution))
@@ -4290,7 +4685,60 @@ function reportDryRun(items, decisions, settings, options) {
 (${String(deferred)} further item(s) deferred by the run cap.)
 `);
   }
-  out("\nDry run: nothing was assigned, posted, checked out or executed.\n");
+  out(
+    "\nDry run: nothing was rescued, pruned, pulled, assigned, posted, checked out or executed.\n"
+  );
+}
+function summarizeHygiene(hygiene) {
+  out("\nPre-flight:\n");
+  out(`  rescue ${describeRescue(hygiene.rescue)}
+`);
+  out(
+    hygiene.base.ok ? "  base   ready\n" : `  base   ${hygiene.base.step} failed \u2014 ${hygiene.base.detail}
+`
+  );
+  if (hygiene.prunes.length === 0) {
+    out("  prune  no candidates\n");
+  } else {
+    for (const outcome of hygiene.prunes) {
+      out(`  prune  ${describePrune(outcome)}
+`);
+    }
+  }
+}
+function describeRescue(rescue) {
+  switch (rescue.kind) {
+    case "clean":
+      return "nothing to rescue";
+    case "rescued":
+      return rescue.prCreated ? `committed and pushed ${rescue.branch}, opened draft PR #${String(rescue.pr)}` : `committed and pushed ${rescue.branch}, PR #${String(rescue.pr)} already open`;
+    case "would-rescue":
+      return `would rescue onto ${rescue.branch}`;
+    case "failed":
+      return `${rescue.step} failed \u2014 ${rescue.detail}; the tree is still dirty and nothing was discarded`;
+  }
+}
+function describePrune(outcome) {
+  switch (outcome.kind) {
+    case "deleted":
+      return `deleted ${outcome.branch}`;
+    case "would-delete":
+      return `would delete ${outcome.branch}`;
+    case "kept":
+      return `kept ${outcome.branch} (${outcome.reason}: ${outcome.detail})`;
+    case "rescued":
+      return outcome.pr === null ? `rescued ${outcome.branch} (pushed; no PR opened)` : `rescued ${outcome.branch} (pushed, draft PR #${String(outcome.pr)})`;
+    case "would-rescue":
+      return `would rescue ${outcome.branch} (${String(outcome.unmergedCommits)} unmerged commit(s))`;
+  }
+}
+function toHygieneJson(hygiene) {
+  return {
+    rescue: hygiene.rescue,
+    base: hygiene.base,
+    prunes: hygiene.prunes,
+    degraded: hygiene.degraded
+  };
 }
 function toPlanJson(decision) {
   if (decision.kind === "skip") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "automata-cli",
-  "version": "0.6.0-develop.273",
+  "version": "0.6.0-develop.282",
   "description": "Automata CLI tool",
   "type": "module",
   "engines": {