mandrel 1.57.0

package/.agents/scripts/lib/orchestration/git-cleanup/phases/fast-forward.js

@@ -0,0 +1,123 @@
+/**
+ * fast-forward.js — fast-forward-main phase of git-cleanup (Story #2466).
+ *
+ * Owns `planFastForward(ctx)` and `executeFastForward(ctx)`. Extracted
+ * verbatim from `git-cleanup.js`.
+ *
+ * @module lib/orchestration/git-cleanup/phases/fast-forward
+ */
+
+import { Logger } from '../../../Logger.js';
+import {
+  canFastForward,
+  checkoutBranch,
+  currentBranch,
+  fetchRef,
+  isWorkingTreeClean,
+  mergeFastForward,
+} from './git-probes.js';
+
+const TAG = '[git-cleanup]';
+
+/**
+ * Pure-ish: plan the fast-forward-main phase. Inspects the working tree
+ * and the local-vs-remote ref relationship to decide whether a fast-
+ * forward is even possible.
+ */
+export function planFastForward(ctx) {
+  const {
+    cwd,
+    baseBranch,
+    remoteName = 'origin',
+    isCleanFn = isWorkingTreeClean,
+    currentBranchFn = currentBranch,
+    fetchFn = fetchRef,
+    canFastForwardFn = canFastForward,
+  } = ctx;
+  if (!isCleanFn(cwd)) return { runnable: false, reason: 'dirty-tree' };
+  const fetchRes = fetchFn(cwd, remoteName, baseBranch);
+  if (!fetchRes.ok) {
+    return { runnable: false, reason: 'fetch-failed', stderr: fetchRes.stderr };
+  }
+  const cur = currentBranchFn(cwd);
+  const ff = canFastForwardFn(cwd, baseBranch, remoteName);
+  if (!ff.ok) {
+    return {
+      runnable: false,
+      reason: ff.reason ?? 'not-fast-forward',
+      currentBranch: cur,
+    };
+  }
+  if (ff.behind === 0) {
+    return {
+      runnable: false,
+      reason: 'already-up-to-date',
+      behind: 0,
+      currentBranch: cur,
+    };
+  }
+  return { runnable: true, behind: ff.behind, currentBranch: cur };
+}
+
+function maybeCheckout({ plan, baseBranch, cwd, checkoutFn, logger }) {
+  if (!plan.currentBranch || plan.currentBranch === baseBranch) {
+    return { ok: true };
+  }
+  const co = checkoutFn(cwd, baseBranch);
+  if (!co.ok) {
+    logger.warn?.(`${TAG} ❌ checkout ${baseBranch} failed: ${co.stderr}`);
+    return {
+      ok: false,
+      applied: false,
+      skipped: false,
+      reason: 'checkout-failed',
+      stderr: co.stderr,
+    };
+  }
+  return { ok: true };
+}
+
+/** Execute the fast-forward-main phase. */
+export function executeFastForward(ctx) {
+  const {
+    cwd,
+    baseBranch,
+    remoteName = 'origin',
+    plan,
+    checkoutFn = checkoutBranch,
+    mergeFn = mergeFastForward,
+    logger = Logger,
+  } = ctx;
+  if (!plan.runnable) {
+    logger.info?.(
+      `${TAG} ⏭️  fast-forward ${baseBranch} skipped: ${plan.reason ?? 'unknown'}`,
+    );
+    return {
+      ok: true,
+      applied: false,
+      skipped: true,
+      reason: plan.reason,
+      behind: plan.behind,
+    };
+  }
+  const co = maybeCheckout({ plan, baseBranch, cwd, checkoutFn, logger });
+  if (!co.ok) return co;
+  const ref = `${remoteName}/${baseBranch}`;
+  const mergeRes = mergeFn(cwd, ref);
+  if (!mergeRes.ok) {
+    logger.warn?.(
+      `${TAG} ❌ merge --ff-only ${ref} failed: ${mergeRes.stderr}`,
+    );
+    return {
+      ok: false,
+      applied: false,
+      skipped: false,
+      reason: 'merge-failed',
+      stderr: mergeRes.stderr,
+    };
+  }
+  logger.info?.(
+    `${TAG} ✅ fast-forwarded ${baseBranch} by ${plan.behind} commit(s)`,
+  );
+  return { ok: true, applied: true, skipped: false, behind: plan.behind };
+}

package/.agents/scripts/lib/orchestration/git-cleanup/phases/filters.js

@@ -0,0 +1,57 @@
+/**
+ * filters.js — pure branch-filter helpers for git-cleanup (Story #2466).
+ *
+ * Exports `buildGlobFilter`, `computeProtectedSet`, and
+ * `computeProtectedReason` — extracted verbatim from `git-cleanup.js`
+ * so the named-export contract stays byte-identical.
+ *
+ * @module lib/orchestration/git-cleanup/phases/filters
+ */
+
+import picomatch from 'picomatch';
+
+/**
+ * Pure: build a `(branch) => boolean` filter from include/exclude globs.
+ */
+export function buildGlobFilter({ include = [], exclude = [] } = {}) {
+  const includeMatch = include.length > 0 ? picomatch(include) : () => true;
+  const excludeMatch = exclude.length > 0 ? picomatch(exclude) : () => false;
+  return (branch) => includeMatch(branch) && !excludeMatch(branch);
+}
+
+/**
+ * Pure: compute the protected-branch skip set.
+ */
+export function computeProtectedSet({ baseBranch, currentBranch, configured }) {
+  const set = new Set();
+  if (baseBranch) set.add(baseBranch);
+  if (currentBranch) set.add(currentBranch);
+  for (const name of configured ?? []) {
+    if (name) set.add(name);
+  }
+  return set;
+}
+
+/**
+ * Pure: classify why a branch is protected. Returns `null` when the
+ * branch is NOT protected, otherwise one of:
+ *
+ *   - `'protected'`    — base branch or in `branch.protectedBranches`.
+ *   - `'current-head'` — current HEAD (and not also base / configured).
+ *
+ * The `'current-head'` reason is split out so `renderDryRun` can emit a
+ * remediation hint distinct from the generic `'protected'` line.
+ */
+export function computeProtectedReason({
+  baseBranch,
+  currentBranch,
+  configured,
+  branch,
+}) {
+  if (!branch) return null;
+  if (baseBranch && branch === baseBranch) return 'protected';
+  if (Array.isArray(configured) && configured.includes(branch))
+    return 'protected';
+  if (currentBranch && branch === currentBranch) return 'current-head';
+  return null;
+}

package/.agents/scripts/lib/orchestration/git-cleanup/phases/git-probes-ff.js

@@ -0,0 +1,114 @@
+/**
+ * git-probes-ff.js — fast-forward / worktree / prune subprocess wrappers
+ * for git-cleanup (Story #2466).
+ *
+ * Split out of `git-probes.js` so each phase file stays under Story
+ * #2466's 200-LOC ceiling. Owns the wrappers the fast-forward-main,
+ * prune-remotes, and worktree-reap paths call.
+ *
+ * @module lib/orchestration/git-cleanup/phases/git-probes-ff
+ */
+
+import { gitSpawn } from '../../../git-utils.js';
+
+/**
+ * Windows file-lock-class failure signatures. Mirrors the regex in
+ * `worktree/lifecycle/reap.js` — a `git worktree remove` that fails with
+ * one of these is an OS-level lock on the worktree directory (open
+ * `node_modules` handles, AV/indexer, test/coverage artifacts), not a
+ * git-state problem. Lock-class removal failures degrade to a deferred
+ * `pending-cleanup` handoff instead of aborting the candidate's ref reap.
+ */
+const WORKTREE_LOCK_RE =
+  /(permission denied|access is denied|directory not empty|resource busy|device or resource busy|sharing violation|used by another process|EACCES|EBUSY|ENOTEMPTY)/i;
+
+/**
+ * Classify a worktree-removal stderr as Windows-lock-class or not.
+ *
+ * @param {string} stderr
+ * @returns {boolean} `true` when the failure looks like an OS file lock.
+ */
+export function isWorktreeLockFailure(stderr) {
+  return WORKTREE_LOCK_RE.test(stderr ?? '');
+}
+
+/* node:coverage ignore next */
+export function isWorkingTreeClean(cwd) {
+  const res = gitSpawn(cwd, 'status', '--porcelain');
+  if (res.status !== 0) return false;
+  return res.stdout.trim() === '';
+}
+
+/* node:coverage ignore next */
+export function fetchRef(cwd, remoteName, ref) {
+  const res = gitSpawn(cwd, 'fetch', '--quiet', remoteName, ref);
+  if (res.status !== 0) return { ok: false, stderr: res.stderr };
+  return { ok: true };
+}
+
+/* node:coverage ignore next */
+export function canFastForward(cwd, baseBranch, remoteName) {
+  const ref = `${remoteName}/${baseBranch}`;
+  const ahead = gitSpawn(
+    cwd,
+    'rev-list',
+    '--left-right',
+    '--count',
+    `${baseBranch}...${ref}`,
+  );
+  if (ahead.status !== 0) {
+    return { ok: false, behind: 0, reason: 'rev-list-failed' };
+  }
+  const parts = ahead.stdout.trim().split(/\s+/);
+  const localAhead = Number(parts[0]) || 0;
+  const remoteAhead = Number(parts[1]) || 0;
+  if (localAhead > 0) {
+    return { ok: false, behind: remoteAhead, reason: 'not-fast-forward' };
+  }
+  return { ok: true, behind: remoteAhead };
+}
+
+/* node:coverage ignore next */
+export function checkoutBranch(cwd, branch) {
+  const res = gitSpawn(cwd, 'checkout', branch);
+  if (res.status !== 0) return { ok: false, stderr: res.stderr };
+  return { ok: true };
+}
+
+/* node:coverage ignore next */
+export function mergeFastForward(cwd, ref) {
+  const res = gitSpawn(cwd, 'merge', '--ff-only', ref);
+  if (res.status !== 0) return { ok: false, stderr: res.stderr };
+  return { ok: true };
+}
+
+/* node:coverage ignore next */
+export function removeWorktree(worktreePath, cwd) {
+  const plain = gitSpawn(cwd, 'worktree', 'remove', worktreePath);
+  if (plain.status === 0) return { ok: true, dirty: false };
+  const forced = gitSpawn(cwd, 'worktree', 'remove', '--force', worktreePath);
+  if (forced.status === 0) {
+    return { ok: true, dirty: true, stderr: plain.stderr };
+  }
+  const stderr = forced.stderr || plain.stderr;
+  return {
+    ok: false,
+    dirty: true,
+    lockClass: isWorktreeLockFailure(stderr),
+    stderr,
+  };
+}
+
+/* node:coverage ignore next */
+export function pruneRemoteTracking(cwd, remoteName, parsePruneFn) {
+  const res = gitSpawn(cwd, 'fetch', '--prune', '--quiet', remoteName);
+  if (res.status !== 0) return { ok: false, pruned: [], stderr: res.stderr };
+  return { ok: true, pruned: parsePruneFn(res.stderr, remoteName) };
+}
+
+/* node:coverage ignore next */
+export function dropStash(ref, cwd) {
+  const res = gitSpawn(cwd, 'stash', 'drop', ref);
+  if (res.status !== 0) return { ok: false, stderr: res.stderr };
+  return { ok: true };
+}