@polymorphism-tech/morph-spec 8.27.0 → 8.29.0

package/src/lib/worktree/worktree-audit.js

@@ -22,13 +22,14 @@
  */
 
 import { execFileSync } from 'child_process';
-import { existsSync, readdirSync, statSync } from 'fs';
+import { existsSync, readdirSync, readFileSync, statSync } from 'fs';
 import { join, resolve } from 'path';
 import {
   isGitRepo,
   resolvePrimaryRoot,
   parseWorktreeList,
   WORKTREE_DIR_NAMES,
+  clearDanglingWorktreeRegistration,
 } from '../../commands/project/worktree.js';
 
 const norm = (p) => resolve(p).replace(/\\/g, '/');
@@ -65,6 +66,36 @@ function featureCommittedOnBranch(root, feature) {
   }
 }
 
+/**
+ * Every feature's `worktree` registration in the primary root — the OTHER
+ * direction from `knownFeatures`/`dirsOnDisk`: not "does git/disk know about
+ * this worktree", but "does the ROOT's feature.json still point somewhere
+ * real". `create --worktree` writes this pointer once at birth
+ * (`{path, branch, createdAt}`) and nothing updates it afterwards except
+ * `finish`'s own teardown — so a directory removed any other way (by hand,
+ * `git worktree prune` run directly, a failed teardown that still cleared the
+ * field, an unrelated script) leaves it dangling with nothing to notice.
+ *
+ * @param {string} root
+ * @returns {Array<{ feature: string, path: string, branch: string|null }>}
+ */
+function featureRegistrations(root) {
+  const out = [];
+  try {
+    const dir = join(root, '.morph', 'features');
+    if (!existsSync(dir)) return out;
+    for (const feature of readdirSync(dir)) {
+      const fjPath = join(dir, feature, 'feature.json');
+      if (!existsSync(fjPath)) continue;
+      try {
+        const fj = JSON.parse(readFileSync(fjPath, 'utf8'));
+        if (fj?.worktree?.path) out.push({ feature, path: fj.worktree.path, branch: fj.worktree.branch || null });
+      } catch { /* corrupt feature.json — nothing to register */ }
+    }
+  } catch { /* fail-open */ }
+  return out;
+}
+
 /** Directories physically present under either worktree root. */
 function dirsOnDisk(root) {
   const found = [];
@@ -87,14 +118,25 @@ function dirsOnDisk(root) {
  * Reconcile git's registry, the disk and morph's features.
  *
  * Issue types:
- *   • registered-missing — git has a worktree whose directory is gone
- *   • non-morph-branch   — a registered worktree under worktrees/ on a branch
- *                          that is not `morph/*`, so `fleet` cannot see it
- *   • unregistered-dir   — a directory under worktrees/ git never registered
- *   • no-feature         — a `morph/{f}` worktree for a feature morph does not know
+ *   • registered-missing        — git has a worktree whose directory is gone
+ *   • non-morph-branch          — a registered worktree under worktrees/ on a
+ *                                 branch that is not `morph/*`, so `fleet`
+ *                                 cannot see it
+ *   • unregistered-dir          — a directory under worktrees/ git never
+ *                                 registered
+ *   • no-feature                — a `morph/{f}` worktree for a feature morph
+ *                                 does not know
+ *   • dangling-registration     — a feature's ROOT feature.json still points
+ *                                 at a `worktree.path` that no longer exists
+ *                                 (the symmetric OTHER direction from
+ *                                 `no-feature`: the worktree is gone, but the
+ *                                 root's pointer to it survived)
+ *   • unregistered-registration — a feature's `worktree.path` names a
+ *                                 directory that exists but git's own
+ *                                 registry does not know as a worktree
  *
  * @param {string} [cwd]
- * @returns {Array<{ type: string, detail: string, path?: string, fix: string }>}
+ * @returns {Array<{ type: string, detail: string, path?: string, feature?: string, fix: string }>}
  */
 export function auditWorktrees(cwd = process.cwd()) {
   if (!isGitRepo(cwd)) return [];
@@ -161,25 +203,69 @@ export function auditWorktrees(cwd = process.cwd()) {
     });
   }
 
+  // The other direction: does the ROOT's own bookkeeping still point at a
+  // live worktree? `git worktree list`/disk only see what's PHYSICALLY
+  // there; a registration surviving past its worktree's removal is invisible
+  // to every check above.
+  for (const reg of featureRegistrations(root)) {
+    const path = norm(reg.path);
+    if (!existsSync(reg.path)) {
+      issues.push({
+        type: 'dangling-registration',
+        feature: reg.feature,
+        path,
+        detail: `"${reg.feature}" registra worktree.path=${path} na raiz, mas o diretório não existe`,
+        fix: `morph-spec doctor --worktrees --prune`,
+      });
+    } else if (!registeredPaths.has(path)) {
+      issues.push({
+        type: 'unregistered-registration',
+        feature: reg.feature,
+        path,
+        detail: `"${reg.feature}" registra worktree.path=${path}, mas o git não o conhece como worktree — a próxima \`worktree setup\` recusará com exit 3`,
+        fix: `inspecione o diretório; se não serve mais, apague-o e rode morph-spec doctor --worktrees --prune`,
+      });
+    }
+  }
+
   return issues;
 }
 
 /**
- * Drop git's admin records for worktrees whose directory is already gone.
+ * Drop git's admin records for worktrees whose directory is already gone, AND
+ * clear any feature's `worktree` registration that names one of those same
+ * gone directories.
  *
- * The ONLY prune offered, on purpose: it cannot destroy anything, because
- * everything it touches is already absent from disk. Removing a directory that
- * still exists is exactly the operation that needs a human looking at it.
+ * Both halves are the ONLY prune offered, on purpose: neither can destroy
+ * anything, because everything they touch is already absent from disk.
+ * Removing a directory that still exists is exactly the operation that needs
+ * a human looking at it.
+ *
+ * `clearDanglingWorktreeRegistration` re-checks the dangling predicate itself
+ * (path unset, or still exists → no-op) rather than trusting a pre-computed
+ * list, so this stays correct even called against a stale audit snapshot.
  *
  * @param {string} [cwd]
- * @returns {{ pruned: boolean, error?: string }}
+ * @returns {Promise<{ pruned: boolean, error?: string, clearedRegistrations: Array<{feature: string, cleared: boolean}> }>}
  */
-export function pruneWorktrees(cwd = process.cwd()) {
-  if (!isGitRepo(cwd)) return { pruned: false, error: 'not-a-git-repo' };
+export async function pruneWorktrees(cwd = process.cwd()) {
+  if (!isGitRepo(cwd)) return { pruned: false, error: 'not-a-git-repo', clearedRegistrations: [] };
+  const root = resolvePrimaryRoot(cwd);
+
+  let pruned = false;
+  let error;
   try {
-    execFileSync('git', ['worktree', 'prune'], { cwd: resolvePrimaryRoot(cwd), stdio: 'pipe' });
-    return { pruned: true };
+    execFileSync('git', ['worktree', 'prune'], { cwd: root, stdio: 'pipe' });
+    pruned = true;
   } catch (err) {
-    return { pruned: false, error: (err.message || 'unknown').slice(0, 200) };
+    error = (err.message || 'unknown').slice(0, 200);
   }
+
+  const clearedRegistrations = [];
+  for (const reg of featureRegistrations(root)) {
+    const { cleared } = await clearDanglingWorktreeRegistration(root, reg.feature);
+    if (cleared) clearedRegistrations.push({ feature: reg.feature, cleared: true });
+  }
+
+  return { pruned, ...(error ? { error } : {}), clearedRegistrations };
 }