@opengsd/gsd-pi 1.3.0-dev.eed73bea → 1.4.0-dev.5fc22c6f

package/dist/resources/extensions/gsd/worktree-manager.js

@@ -17,12 +17,12 @@
  *   3. merge()   — LLM-guided reconciliation of .gsd/ artifacts back to main
  *   4. remove()  — git worktree remove + branch cleanup
  */
-import { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, realpathSync, rmSync, statSync } from "node:fs";
+import { cpSync, existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, realpathSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { execFileSync } from "node:child_process";
 import { join, resolve, sep } from "node:path";
 import { GSDError, GSD_PARSE_ERROR, GSD_STALE_STATE, GSD_LOCK_HELD, GSD_GIT_ERROR, GSD_MERGE_CONFLICT } from "./errors.js";
 import { logWarning } from "./workflow-logger.js";
-import { nativeBranchList, nativeBranchDelete, nativeBranchExists, nativeBranchForceReset, nativeCommit, nativeDetectMainBranch, nativeDiffContent, nativeDiffNameStatus, nativeDiffNumstat, nativeGetCurrentBranch, nativeIsAncestor, nativeLogOneline, nativeMergeSquash, nativeWorktreeAdd, nativeWorktreeList, nativeWorktreePrune, nativeWorktreeRemove, } from "./native-git-bridge.js";
+import { nativeBranchList, nativeBranchDelete, nativeBranchExists, nativeBranchForceReset, nativeCommit, nativeDetectMainBranch, nativeDiffContent, nativeDiffNameStatus, nativeDiffNumstat, nativeGetCurrentBranch, nativeIsAncestor, nativeLogOneline, nativeMergeAbort, nativeMergeSquash, nativeWorktreeAdd, nativeWorktreeList, nativeWorktreePrune, nativeWorktreeRemove, } from "./native-git-bridge.js";
 import { emitCanonicalRootRedirect } from "./worktree-telemetry.js";
 import { isGsdWorktreePath, normalizeWorktreePathForCompare, resolveWorktreeProjectRoot, } from "./worktree-root.js";
 import { MILESTONE_ID_RE } from "./milestone-ids.js";
@@ -37,6 +37,36 @@ function deleteBranchIfPresent(basePath, branch, warningPrefix) {
         logWarning("worktree", `${warningPrefix}: ${e.message}`);
     }
 }
+function cleanupFailedSquashMergeState(basePath) {
+    try {
+        nativeMergeAbort(basePath);
+    }
+    catch (e) {
+        // Squash conflicts may not create MERGE_HEAD; this is expected.
+        logWarning("worktree", `merge abort skipped: ${e.message}`);
+    }
+    try {
+        execFileSync("git", ["reset", "--merge"], {
+            cwd: basePath,
+            stdio: ["ignore", "pipe", "pipe"],
+            encoding: "utf-8",
+        });
+    }
+    catch (e) {
+        logWarning("worktree", `failed squash merge reset failed: ${e.message}`);
+    }
+    const gitDir = resolveGitDir(basePath);
+    for (const marker of ["SQUASH_MSG", "MERGE_MSG", "MERGE_MODE", "MERGE_HEAD", "AUTO_MERGE"]) {
+        try {
+            const markerPath = join(gitDir, marker);
+            if (existsSync(markerPath))
+                unlinkSync(markerPath);
+        }
+        catch (e) {
+            logWarning("worktree", `failed squash merge marker cleanup failed (${marker}): ${e.message}`);
+        }
+    }
+}
 // ─── Path Helpers ──────────────────────────────────────────────────────────
 function normalizePathForComparison(path) {
     const normalized = path
@@ -133,6 +163,76 @@ function isRegisteredGitWorktreeAtPath(basePath, wtPath) {
         return false;
     }
 }
+function inspectUncommittedWorktreeState(wtPath) {
+    try {
+        const status = execFileSync("git", ["status", "--porcelain=v1", "--untracked-files=all"], { cwd: wtPath, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trimEnd();
+        return { dirty: status.length > 0, status };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        logWarning("worktree", `dirty worktree inspection failed for ${wtPath}: ${message}`);
+        // Fail closed: unknown state must quarantine rather than force-remove.
+        return { dirty: true, status: `git status failed: ${message}` };
+    }
+}
+function timestampForPath() {
+    return new Date().toISOString().replace(/[:.]/g, "-");
+}
+function uniqueQuarantinePath(basePath, name) {
+    const root = join(basePath, ".gsd", "quarantine", "worktrees");
+    const baseName = `${name}-${timestampForPath()}`;
+    let candidate = join(root, baseName);
+    let suffix = 2;
+    while (existsSync(candidate)) {
+        candidate = join(root, `${baseName}-${suffix}`);
+        suffix++;
+    }
+    return candidate;
+}
+function quarantineDirtyWorktree(basePath, name, branch, wtPath, status) {
+    const quarantinePath = uniqueQuarantinePath(basePath, name);
+    mkdirSync(join(basePath, ".gsd", "quarantine", "worktrees"), { recursive: true });
+    let moved = false;
+    try {
+        renameSync(wtPath, quarantinePath);
+        moved = true;
+    }
+    catch (renameErr) {
+        logWarning("worktree", `dirty worktree rename quarantine failed for ${name}: ${renameErr instanceof Error ? renameErr.message : String(renameErr)}; trying copy snapshot`);
+        try {
+            cpSync(wtPath, quarantinePath, { recursive: true, force: false, errorOnExist: true });
+        }
+        catch (copyErr) {
+            logWarning("reconcile", `Dirty worktree quarantine failed; preserving original worktree ${wtPath}: ${copyErr instanceof Error ? copyErr.message : String(copyErr)}`, { worktree: name, path: wtPath });
+            return null;
+        }
+    }
+    try {
+        const gitFile = join(quarantinePath, ".git");
+        if (existsSync(gitFile) && lstatSync(gitFile).isFile()) {
+            unlinkSync(gitFile);
+        }
+    }
+    catch (err) {
+        logWarning("worktree", `failed to remove quarantined worktree git pointer: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    try {
+        writeFileSync(join(quarantinePath, ".gsd-quarantine.json"), JSON.stringify({
+            kind: "dirty-worktree",
+            worktree: name,
+            branch,
+            originalPath: wtPath,
+            moved,
+            quarantinedAt: new Date().toISOString(),
+            status,
+        }, null, 2) + "\n", "utf-8");
+    }
+    catch (err) {
+        logWarning("worktree", `failed to write worktree quarantine metadata: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    logWarning("reconcile", `Quarantined dirty worktree ${name} at ${quarantinePath} before removal. Branch ${branch} was preserved.`, { worktree: name, path: quarantinePath, branch });
+    return quarantinePath;
+}
 /** True when `wtPath` has a git worktree checkout marker (`.git` file with gitdir pointer). */
 export function isLiveGitWorktreeCheckout(wtPath) {
     const gitPath = join(wtPath, ".git");
@@ -580,6 +680,7 @@ export function removeWorktree(basePath, name, opts = {}) {
     let wtPath = worktreePath(basePath, name);
     const branch = opts.branch ?? worktreeBranchName(name);
     const { deleteBranch = true, force = true } = opts;
+    let deleteBranchAfterRemoval = deleteBranch;
     // Resolve the ACTUAL worktree path from git's worktree list.
     // The computed path may differ when .gsd/ is (or was) a symlink to an
     // external state directory — git resolves symlinks at worktree creation
@@ -634,10 +735,10 @@ export function removeWorktree(basePath, name, opts = {}) {
     }
     if (!existsSync(wtPath)) {
         nativeWorktreePrune(basePath);
-        if (deleteBranch) {
+        if (deleteBranchAfterRemoval) {
             deleteBranchIfPresent(basePath, branch, "nativeBranchDelete failed");
         }
-        return;
+        return true;
     }
     // Submodule safety (#2337): detect submodules with uncommitted changes
     // before force-removing the worktree. Force removal destroys all uncommitted
@@ -691,6 +792,27 @@ export function removeWorktree(basePath, name, opts = {}) {
             }
         }
     }
+    // Dirty-worktree quarantine (#2365): once submodule (#2337) and nested-.git
+    // (#2616) rescue have run — they commit/clean the tree first — quarantine any
+    // uncommitted state that remains instead of force-deleting it. Gate on a live
+    // git checkout so a stale local directory left behind by state-sync (which
+    // has no `.git` file and is not a registered worktree) is removed normally
+    // rather than quarantined; otherwise its branch would never be deleted and
+    // the worktree would never be unregistered (#1852).
+    if (force && resolvedPathSafe && isLiveGitWorktreeCheckout(resolvedWtPath)) {
+        const dirtyState = inspectUncommittedWorktreeState(resolvedWtPath);
+        if (dirtyState.dirty) {
+            const quarantinePath = quarantineDirtyWorktree(basePath, name, branch, resolvedWtPath, dirtyState.status);
+            if (!quarantinePath) {
+                return false;
+            }
+            deleteBranchAfterRemoval = false;
+            if (!existsSync(resolvedWtPath)) {
+                nativeWorktreePrune(basePath);
+                return true;
+            }
+        }
+    }
     // Remove worktree — only use force/rmSync when the path is safely contained
     if (resolvedPathSafe) {
         // Remove worktree: try non-force first when submodules have changes,
@@ -748,9 +870,10 @@ export function removeWorktree(basePath, name, opts = {}) {
     }
     // Prune stale entries so git knows the worktree is gone
     nativeWorktreePrune(basePath);
-    if (deleteBranch) {
+    if (deleteBranchAfterRemoval) {
         deleteBranchIfPresent(basePath, branch, "final branch delete failed");
     }
+    return true;
 }
 /**
  * Paths to skip in all worktree diffs (internal/runtime artifacts).
@@ -903,6 +1026,18 @@ export function mergeWorktreeToMain(basePath, name, commitMessage, branchOverrid
     }
     const result = nativeMergeSquash(basePath, branch);
     if (!result.success) {
+        const dirtyWorkingTree = result.conflicts.includes("__dirty_working_tree__");
+        if (!dirtyWorkingTree) {
+            cleanupFailedSquashMergeState(basePath);
+        }
+        if (!dirtyWorkingTree && branch.startsWith("milestone/")) {
+            try {
+                removeWorktree(basePath, name, { branch, deleteBranch: true, force: true });
+            }
+            catch (e) {
+                logWarning("worktree", `failed milestone branch cleanup after squash merge failure: ${e.message}`);
+            }
+        }
         throw new GSDError(GSD_MERGE_CONFLICT, `Merge conflicts detected in: ${result.conflicts.join(", ")}`);
     }
     nativeCommit(basePath, commitMessage);