@polymorphism-tech/morph-spec 9.8.0 → 10.0.0

package/src/lib/worktree/agent-reaper.js

@@ -1,247 +0,0 @@
-import { execFileSync } from 'node:child_process';
-import {
-  closeSync, existsSync, fstatSync, mkdirSync, openSync, readFileSync, readSync, statSync, unlinkSync, writeFileSync,
-} from 'node:fs';
-import { basename, join, resolve } from 'node:path';
-import {
-  cwdIsInsideWorktree, isGitRepo, parseWorktreeList, resolvePrimaryRoot, runWorktreeRemove,
-  sessionAnchoredInWorktree,
-} from '../../commands/project/worktree.js';
-import { containerDirs, isUnder } from '../../../framework/hooks/shared/worktree-root.js';
-import { withoutLeftoverIgnore } from '../../../framework/hooks/shared/graph-freshness.js';
-import { resolveGitCommonDir } from '../../../framework/hooks/shared/git-paths.js';
-import { pidAlive } from '../../../framework/hooks/shared/process-alive.js';
-import { readProjectConfig } from '../../../framework/hooks/shared/heavy-config.js';
-
-export const DEFAULT_GRACE_MINUTES = 30;
-
-const AGENT_DIR = /^agent-([0-9a-f]+)$/;
-const AGENT_BRANCH = /^morph-task\/agent-([0-9a-f]+)$/;
-const AGENT_REF = /^refs\/heads\/morph-task\/agent-[0-9a-f]+$/;
-const TAIL_BYTES = 64 * 1024;
-const LOCK_MAX_AGE_MS = 15 * 60_000;
-const SAMPLE = 5;
-
-const norm = (p) => resolve(p).replace(/\\/g, '/');
-const gitOut = (cwd, args, input) => execFileSync('git', args, {
-  cwd, stdio: ['pipe', 'pipe', 'pipe'], encoding: 'utf8', input,
-});
-const sample = (list) => `${list.slice(0, SAMPLE).join(', ')}${list.length > SAMPLE ? `, +${list.length - SAMPLE}` : ''}`;
-
-export function resolveGraceMinutes(root, override) {
-  const valid = (v) => typeof v === 'number' && Number.isFinite(v) && v >= 0;
-  if (valid(override)) return override;
-  const configured = readProjectConfig(root)?.worktree?.reap?.graceMinutes;
-  return valid(configured) ? configured : DEFAULT_GRACE_MINUTES;
-}
-
-/**
- * Commits reachable from `tip` and from no other branch, remote or tag; agent branches are left out
- * of the comparison, and `--all` is not used (the agent's own HEAD would protect it). `null` = unmeasured.
- */
-export function exclusiveCommitCount(root, tip) {
-  if (!tip) return null;
-  try {
-    const refs = gitOut(root, ['for-each-ref', '--format=%(refname)', 'refs/heads', 'refs/remotes', 'refs/tags'])
-      .split(/\r?\n/).filter((r) => r && !AGENT_REF.test(r));
-    const input = `${[tip, ...refs.map((r) => `^${r}`)].join('\n')}\n`;
-    const count = Number.parseInt(gitOut(root, ['rev-list', '--count', '--stdin'], input).trim(), 10);
-    return Number.isInteger(count) ? count : null;
-  } catch {
-    return null;
-  }
-}
-
-function tailOfEvents(file) {
-  const fd = openSync(file, 'r');
-  try {
-    const { size, mtimeMs } = fstatSync(fd);
-    const len = Math.min(size, TAIL_BYTES);
-    const buf = Buffer.alloc(len);
-    readSync(fd, buf, 0, len, size - len);
-    const lines = buf.toString('utf8').split(/\r?\n/).filter((l) => l.trim());
-    if (size > len) lines.shift();
-    return { last: lines.at(-1) ?? null, mtimeMs };
-  } finally {
-    closeSync(fd);
-  }
-}
-
-/** `stopped` only when the tree's last event is this agent's own `AgentUsage`. */
-export function readAgentStop(worktreePath, hex) {
-  const file = join(worktreePath, '.morph', 'logs', 'events.jsonl');
-  if (!existsSync(file)) return { status: 'unknown', detail: 'sem .morph/logs/events.jsonl na árvore' };
-  let tail;
-  try { tail = tailOfEvents(file); } catch { return { status: 'unknown', detail: 'events.jsonl ilegível' }; }
-  let event = null;
-  try { event = tail.last ? JSON.parse(tail.last) : null; } catch { event = null; }
-  if (!event || typeof event !== 'object') return { status: 'unknown', detail: 'último evento ilegível' };
-  if (event.event !== 'AgentUsage') return { status: 'active', detail: `último evento: ${event.event ?? '?'}` };
-  if (String(event.agentId ?? '').toLowerCase() !== hex) return { status: 'unknown', detail: 'AgentUsage de outro agente' };
-  return { status: 'stopped', mtimeMs: tail.mtimeMs };
-}
-
-function dirtOf(worktreePath) {
-  try {
-    const lines = gitOut(worktreePath, ['status', '--porcelain', '--untracked-files=all']).split(/\r?\n/).filter((l) => l.trim());
-    return withoutLeftoverIgnore(worktreePath, lines).map((l) => (l.startsWith('??') ? `untracked ${l.slice(3)}` : l.slice(3)));
-  } catch {
-    return null;
-  }
-}
-
-function agentBranches(root) {
-  try {
-    return gitOut(root, ['for-each-ref', '--format=%(refname:short) %(objectname)', 'refs/heads/morph-task/'])
-      .split(/\r?\n/).filter(Boolean)
-      .map((line) => { const [name, sha] = line.split(' '); return { name, sha, hex: AGENT_BRANCH.exec(name)?.[1] }; })
-      .filter((b) => b.hex);
-  } catch {
-    return [];
-  }
-}
-
-function branchTouchedMs(root, branch) {
-  const common = resolveGitCommonDir(root);
-  if (!common) return null;
-  try { return statSync(join(common, 'logs', 'refs', 'heads', ...branch.split('/'))).mtimeMs; } catch { return null; }
-}
-
-function agentWorktrees(root) {
-  const rootNorm = norm(root);
-  const containers = containerDirs(root);
-  return parseWorktreeList(root).flatMap((e) => {
-    const path = norm(e.path);
-    const hex = AGENT_DIR.exec(basename(path))?.[1];
-    if (!hex || path === rootNorm) return [];
-    if (!isUnder(containers, path)) return [];
-    const branch = e.branch ? e.branch.replace(/^refs\/heads\//, '') : null;
-    if (branch && branch !== `morph-task/agent-${hex}`) return [];
-    return [{ path, hex, branch, tip: e.head, locked: e.locked }];
-  });
-}
-
-function judgeWorktree(item, ctx) {
-  const keep = (state, reason, detail) => ({ ...item, state, reason, detail });
-  if (!existsSync(item.path)) return keep('preserved', 'directory-missing', 'o diretório sumiu; `morph-spec doctor --worktrees --prune` limpa o registro');
-  if (cwdIsInsideWorktree(ctx.cwd, item.path) || sessionAnchoredInWorktree(item.path, ctx.env)) return keep('active', 'anchored');
-  if (item.locked) return keep('preserved', 'locked', '`git worktree unlock` libera, se o lock já não vale');
-
-  const stop = readAgentStop(item.path, item.hex);
-  if (stop.status === 'active') return keep('active', 'agent-active', stop.detail);
-  if (stop.status !== 'stopped') return keep('preserved', 'no-usage-event', stop.detail);
-  const idleMin = (ctx.now - stop.mtimeMs) / 60_000;
-  if (idleMin < ctx.graceMinutes) return keep('pending', 'within-grace', `parou há ${Math.floor(idleMin)} min (graça de ${ctx.graceMinutes} min)`);
-
-  const dirt = dirtOf(item.path);
-  if (dirt === null) return keep('preserved', 'unknown', 'git status falhou');
-  if (dirt.length) return keep('preserved', 'dirty', sample(dirt));
-
-  const exclusive = exclusiveCommitCount(ctx.root, item.tip);
-  if (exclusive === null) return keep('preserved', 'unknown', 'não foi possível contar os commits exclusivos');
-  if (exclusive > 0) return keep('preserved', 'exclusive-commits', `${exclusive} commit(s) só nesta branch`);
-  return keep('reapable', 'stopped-clean');
-}
-
-function judgeOrphanBranch(branch, ctx) {
-  const item = { path: null, hex: branch.hex, branch: branch.name, tip: branch.sha };
-  const keep = (state, reason, detail) => ({ ...item, state, reason, detail });
-  const exclusive = exclusiveCommitCount(ctx.root, branch.sha);
-  if (exclusive === null) return keep('preserved', 'unknown', 'não foi possível contar os commits exclusivos');
-  if (exclusive > 0) return keep('preserved', 'exclusive-commits', `${exclusive} commit(s) só nesta branch`);
-  const touched = branchTouchedMs(ctx.root, branch.name);
-  if (touched === null) return keep('preserved', 'unknown', 'sem reflog para medir a idade da branch');
-  const idleMin = (ctx.now - touched) / 60_000;
-  if (idleMin < ctx.graceMinutes) return keep('pending', 'within-grace', `branch tocada há ${Math.floor(idleMin)} min (graça de ${ctx.graceMinutes} min)`);
-  return keep('reapable', 'orphan-branch');
-}
-
-/** Read-only: every agent tree and orphan agent branch with its verdict. */
-export function planAgentReap(root, { cwd = root, now = Date.now(), graceMinutes, env = process.env } = {}) {
-  const ctx = { root, cwd, now, env, graceMinutes: resolveGraceMinutes(root, graceMinutes) };
-  const trees = agentWorktrees(root);
-  const withTree = new Set(trees.map((t) => t.branch).filter(Boolean));
-  const orphans = agentBranches(root).filter((b) => !withTree.has(b.name));
-  const items = [...trees.map((t) => judgeWorktree(t, ctx)), ...orphans.map((b) => judgeOrphanBranch(b, ctx))];
-  return { graceMinutes: ctx.graceMinutes, items };
-}
-
-function acquireReapLock(root, now) {
-  const common = resolveGitCommonDir(root);
-  if (!common) return null;
-  const dir = join(common, 'morph-spec');
-  const file = join(dir, 'agent-reap.lock');
-  try { mkdirSync(dir, { recursive: true }); } catch { return null; }
-  for (let attempt = 0; attempt < 2; attempt += 1) {
-    try {
-      writeFileSync(file, JSON.stringify({ pid: process.pid, since: now }), { flag: 'wx' });
-      return () => { try { unlinkSync(file); } catch { /* already gone */ } };
-    } catch (err) {
-      if (err.code !== 'EEXIST') return null;
-    }
-    let holder = null;
-    try { holder = JSON.parse(readFileSync(file, 'utf8')); } catch { holder = null; }
-    const stale = !holder || !pidAlive(holder.pid) || now - Number(holder.since) > LOCK_MAX_AGE_MS;
-    if (!stale) return null;
-    try { unlinkSync(file); } catch { return null; }
-  }
-  return null;
-}
-
-function deleteAgentBranch(root, branch, sha) {
-  if (exclusiveCommitCount(root, sha) !== 0) return false;
-  try { gitOut(root, ['branch', '-D', branch]); return true; } catch { return false; }
-}
-
-const brief = ({ path, branch, hex }) => ({ path, branch, hex });
-const why = ({ path, branch, hex, reason, detail }) => ({ path, branch, hex, reason, ...(detail ? { detail } : {}) });
-
-/**
- * Removes the worktrees and branches of stopped, clean agents that hold no commit only they have;
- * everything else is listed with the reason and left alone.
- */
-export async function reapAgentWorktrees(cwd = process.cwd(), {
-  dryRun = false, graceMinutes, now = Date.now, env = process.env, remove = runWorktreeRemove,
-} = {}) {
-  if (!isGitRepo(cwd)) return { ok: false, error: 'not-a-git-repo', dryRun };
-  const root = resolvePrimaryRoot(cwd);
-  const summarize = (plan, extra = {}) => {
-    const of = (state) => plan.items.filter((i) => i.state === state);
-    return {
-      ok: true, dryRun, graceMinutes: plan.graceMinutes,
-      reaped: [], branchesDeleted: [],
-      ...(dryRun ? { wouldReap: of('reapable').map(brief) } : {}),
-      preserved: [...of('preserved'), ...of('pending')].map(why),
-      active: of('active').length,
-      ...extra,
-    };
-  };
-
-  if (dryRun) return summarize(planAgentReap(root, { cwd, now: now(), graceMinutes, env }));
-
-  const release = acquireReapLock(root, now());
-  if (!release) return { ...summarize({ graceMinutes: resolveGraceMinutes(root, graceMinutes), items: [] }), busy: true };
-  try {
-    const plan = planAgentReap(root, { cwd, now: now(), graceMinutes, env });
-    const out = summarize(plan);
-    for (const item of plan.items.filter((i) => i.state === 'reapable')) {
-      if (item.path) {
-        const { out: removal } = await remove(null, { target: item.path, ifClean: true, relinkOnFailure: true, cwd: root });
-        if (!removal.removed) {
-          out.preserved.push(why({ ...item, reason: 'remove-failed', detail: removal.hint || removal.error }));
-          continue;
-        }
-        out.reaped.push({ ...brief(item), ...(removal.ignoredBackup ? { backup: removal.ignoredBackup } : {}) });
-        if (item.branch && deleteAgentBranch(root, item.branch, item.tip)) out.branchesDeleted.push(item.branch);
-      } else if (deleteAgentBranch(root, item.branch, item.tip)) {
-        out.branchesDeleted.push(item.branch);
-        out.reaped.push(brief(item));
-      } else {
-        out.preserved.push(why({ ...item, reason: 'unknown', detail: 'a branch mudou antes de ser apagada' }));
-      }
-    }
-    return out;
-  } finally {
-    release();
-  }
-}