gsd-pi 2.33.1 → 2.34.0-dev.6769913

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

@@ -0,0 +1,344 @@
+/**
+ * WorktreeResolver — encapsulates worktree path state and merge/exit lifecycle.
+ *
+ * Replaces scattered `s.basePath`/`s.originalBasePath` mutation and 3 duplicated
+ * merge-or-teardown blocks in auto-loop.ts with single method calls. All
+ * `s.basePath` mutations (except session.reset() and initial setup) happen
+ * through this class.
+ *
+ * Design: Option A — mutates AutoSession fields directly so existing `s.basePath`
+ * reads continue to work everywhere without wiring changes.
+ *
+ * Key invariant: `createAutoWorktree()` and `enterAutoWorktree()` call
+ * `process.chdir()` internally — this class MUST NOT double-chdir.
+ */
+import { debugLog } from "./debug-logger.js";
+// ─── WorktreeResolver ──────────────────────────────────────────────────────
+export class WorktreeResolver {
+    s;
+    deps;
+    constructor(session, deps) {
+        this.s = session;
+        this.deps = deps;
+    }
+    // ── Getters ────────────────────────────────────────────────────────────
+    /** Current working path — may be worktree or project root. */
+    get workPath() {
+        return this.s.basePath;
+    }
+    /** Original project root — always the non-worktree path. */
+    get projectRoot() {
+        return this.s.originalBasePath || this.s.basePath;
+    }
+    /** Path for auto.lock file — same as the old lockBase(). */
+    get lockPath() {
+        return this.s.originalBasePath || this.s.basePath;
+    }
+    // ── Private Helpers ────────────────────────────────────────────────────
+    rebuildGitService() {
+        const gitConfig = this.deps.loadEffectiveGSDPreferences()?.preferences?.git ?? {};
+        this.s.gitService = new this.deps.GitServiceImpl(this.s.basePath, gitConfig);
+    }
+    /** Restore basePath to originalBasePath and rebuild GitService. */
+    restoreToProjectRoot() {
+        if (!this.s.originalBasePath)
+            return;
+        this.s.basePath = this.s.originalBasePath;
+        this.rebuildGitService();
+        this.deps.invalidateAllCaches();
+    }
+    // ── Validation ──────────────────────────────────────────────────────────
+    /** Validate milestoneId to prevent path traversal. */
+    validateMilestoneId(milestoneId) {
+        if (/[\/\\]|\.\./.test(milestoneId)) {
+            throw new Error(`Invalid milestoneId: ${milestoneId} — contains path separators or traversal`);
+        }
+    }
+    // ── Enter Milestone ────────────────────────────────────────────────────
+    /**
+     * Enter or create a worktree for the given milestone.
+     *
+     * Only acts if `shouldUseWorktreeIsolation()` returns true.
+     * Delegates to `enterAutoWorktree` (existing) or `createAutoWorktree` (new).
+     * Those functions call `process.chdir()` internally — we do NOT double-chdir.
+     *
+     * Updates `s.basePath` and rebuilds GitService on success.
+     * On failure: notifies a warning and does NOT update `s.basePath`.
+     */
+    enterMilestone(milestoneId, ctx) {
+        this.validateMilestoneId(milestoneId);
+        if (!this.deps.shouldUseWorktreeIsolation()) {
+            debugLog("WorktreeResolver", {
+                action: "enterMilestone",
+                milestoneId,
+                skipped: true,
+                reason: "isolation-disabled",
+            });
+            return;
+        }
+        const basePath = this.s.originalBasePath || this.s.basePath;
+        debugLog("WorktreeResolver", {
+            action: "enterMilestone",
+            milestoneId,
+            basePath,
+        });
+        try {
+            const existingPath = this.deps.getAutoWorktreePath(basePath, milestoneId);
+            let wtPath;
+            if (existingPath) {
+                wtPath = this.deps.enterAutoWorktree(basePath, milestoneId);
+            }
+            else {
+                wtPath = this.deps.createAutoWorktree(basePath, milestoneId);
+            }
+            this.s.basePath = wtPath;
+            this.rebuildGitService();
+            debugLog("WorktreeResolver", {
+                action: "enterMilestone",
+                milestoneId,
+                result: "success",
+                wtPath,
+            });
+            ctx.notify(`Entered worktree for ${milestoneId} at ${wtPath}`, "info");
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            debugLog("WorktreeResolver", {
+                action: "enterMilestone",
+                milestoneId,
+                result: "error",
+                error: msg,
+            });
+            ctx.notify(`Auto-worktree creation for ${milestoneId} failed: ${msg}. Continuing in project root.`, "warning");
+            // Do NOT update s.basePath — stay in project root
+        }
+    }
+    // ── Exit Milestone ─────────────────────────────────────────────────────
+    /**
+     * Exit the current worktree: auto-commit, teardown, reset basePath.
+     *
+     * Only acts if currently in an auto-worktree (checked via `isInAutoWorktree`).
+     * Resets `s.basePath` to `s.originalBasePath` and rebuilds GitService.
+     */
+    exitMilestone(milestoneId, ctx, opts) {
+        this.validateMilestoneId(milestoneId);
+        if (!this.deps.isInAutoWorktree(this.s.basePath)) {
+            debugLog("WorktreeResolver", {
+                action: "exitMilestone",
+                milestoneId,
+                skipped: true,
+                reason: "not-in-worktree",
+            });
+            return;
+        }
+        debugLog("WorktreeResolver", {
+            action: "exitMilestone",
+            milestoneId,
+            basePath: this.s.basePath,
+        });
+        try {
+            this.deps.autoCommitCurrentBranch(this.s.basePath, "stop", milestoneId);
+        }
+        catch (err) {
+            debugLog("WorktreeResolver", {
+                action: "exitMilestone",
+                milestoneId,
+                phase: "auto-commit-failed",
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+        try {
+            this.deps.teardownAutoWorktree(this.s.originalBasePath, milestoneId, {
+                preserveBranch: opts?.preserveBranch ?? false,
+            });
+        }
+        catch (err) {
+            debugLog("WorktreeResolver", {
+                action: "exitMilestone",
+                milestoneId,
+                phase: "teardown-failed",
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+        this.restoreToProjectRoot();
+        debugLog("WorktreeResolver", {
+            action: "exitMilestone",
+            milestoneId,
+            result: "done",
+            basePath: this.s.basePath,
+        });
+        ctx.notify(`Exited worktree for ${milestoneId}`, "info");
+    }
+    // ── Merge and Exit ─────────────────────────────────────────────────────
+    /**
+     * Merge the completed milestone branch back to main and exit the worktree.
+     *
+     * Handles all three isolation modes:
+     * - **worktree**: Read roadmap, merge, teardown worktree, reset paths.
+     *   Falls back to bare teardown if no roadmap exists.
+     * - **branch**: Check if on milestone branch, merge if so (no chdir/teardown).
+     * - **none**: No-op.
+     *
+     * Error recovery: on merge failure, always restore `s.basePath` to
+     * `s.originalBasePath` and `process.chdir(s.originalBasePath)`.
+     */
+    mergeAndExit(milestoneId, ctx) {
+        this.validateMilestoneId(milestoneId);
+        const mode = this.deps.getIsolationMode();
+        debugLog("WorktreeResolver", {
+            action: "mergeAndExit",
+            milestoneId,
+            mode,
+            basePath: this.s.basePath,
+        });
+        if (mode === "none") {
+            debugLog("WorktreeResolver", {
+                action: "mergeAndExit",
+                milestoneId,
+                skipped: true,
+                reason: "mode-none",
+            });
+            return;
+        }
+        if (mode === "worktree" ||
+            (this.deps.isInAutoWorktree(this.s.basePath) && this.s.originalBasePath)) {
+            this._mergeWorktreeMode(milestoneId, ctx);
+        }
+        else if (mode === "branch") {
+            this._mergeBranchMode(milestoneId, ctx);
+        }
+    }
+    /** Worktree-mode merge: read roadmap, merge, teardown, reset paths. */
+    _mergeWorktreeMode(milestoneId, ctx) {
+        const originalBase = this.s.originalBasePath;
+        if (!originalBase) {
+            debugLog("WorktreeResolver", {
+                action: "mergeAndExit",
+                milestoneId,
+                mode: "worktree",
+                skipped: true,
+                reason: "missing-original-base",
+            });
+            return;
+        }
+        try {
+            const { synced } = this.deps.syncWorktreeStateBack(originalBase, this.s.basePath, milestoneId);
+            if (synced.length > 0) {
+                debugLog("WorktreeResolver", {
+                    action: "mergeAndExit",
+                    milestoneId,
+                    phase: "reverse-sync",
+                    synced: synced.length,
+                });
+            }
+            const roadmapPath = this.deps.resolveMilestoneFile(originalBase, milestoneId, "ROADMAP");
+            if (roadmapPath) {
+                const roadmapContent = this.deps.readFileSync(roadmapPath, "utf-8");
+                const mergeResult = this.deps.mergeMilestoneToMain(originalBase, milestoneId, roadmapContent);
+                ctx.notify(`Milestone ${milestoneId} merged to main.${mergeResult.pushed ? " Pushed to remote." : ""}`, "info");
+            }
+            else {
+                // No roadmap — fall back to bare teardown
+                this.deps.teardownAutoWorktree(originalBase, milestoneId);
+                ctx.notify(`Exited worktree for ${milestoneId} (no roadmap for merge).`, "info");
+            }
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            debugLog("WorktreeResolver", {
+                action: "mergeAndExit",
+                milestoneId,
+                result: "error",
+                error: msg,
+                fallback: "chdir-to-project-root",
+            });
+            ctx.notify(`Milestone merge failed: ${msg}`, "warning");
+            // Error recovery: always restore to project root
+            if (originalBase) {
+                try {
+                    process.chdir(originalBase);
+                }
+                catch {
+                    /* best-effort */
+                }
+            }
+        }
+        // Always restore basePath and rebuild — whether merge succeeded or failed
+        this.restoreToProjectRoot();
+        debugLog("WorktreeResolver", {
+            action: "mergeAndExit",
+            milestoneId,
+            result: "done",
+            basePath: this.s.basePath,
+        });
+    }
+    /** Branch-mode merge: check current branch, merge if on milestone branch. */
+    _mergeBranchMode(milestoneId, ctx) {
+        try {
+            const currentBranch = this.deps.getCurrentBranch(this.s.basePath);
+            const milestoneBranch = this.deps.autoWorktreeBranch(milestoneId);
+            if (currentBranch !== milestoneBranch) {
+                debugLog("WorktreeResolver", {
+                    action: "mergeAndExit",
+                    milestoneId,
+                    mode: "branch",
+                    skipped: true,
+                    reason: "not-on-milestone-branch",
+                    currentBranch,
+                    milestoneBranch,
+                });
+                return;
+            }
+            const roadmapPath = this.deps.resolveMilestoneFile(this.s.basePath, milestoneId, "ROADMAP");
+            if (!roadmapPath) {
+                debugLog("WorktreeResolver", {
+                    action: "mergeAndExit",
+                    milestoneId,
+                    mode: "branch",
+                    skipped: true,
+                    reason: "no-roadmap",
+                });
+                return;
+            }
+            const roadmapContent = this.deps.readFileSync(roadmapPath, "utf-8");
+            const mergeResult = this.deps.mergeMilestoneToMain(this.s.basePath, milestoneId, roadmapContent);
+            // Rebuild GitService after merge (branch HEAD changed)
+            this.rebuildGitService();
+            ctx.notify(`Milestone ${milestoneId} merged (branch mode).${mergeResult.pushed ? " Pushed to remote." : ""}`, "info");
+            debugLog("WorktreeResolver", {
+                action: "mergeAndExit",
+                milestoneId,
+                mode: "branch",
+                result: "success",
+            });
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            debugLog("WorktreeResolver", {
+                action: "mergeAndExit",
+                milestoneId,
+                mode: "branch",
+                result: "error",
+                error: msg,
+            });
+            ctx.notify(`Milestone merge failed (branch mode): ${msg}`, "warning");
+        }
+    }
+    // ── Merge and Enter Next ───────────────────────────────────────────────
+    /**
+     * Milestone transition: merge the current milestone, then enter the next one.
+     *
+     * This is the pattern used when the loop detects that the active milestone
+     * has changed (e.g., current completed, next one is now active). The caller
+     * is responsible for re-deriving state between the merge and the enter.
+     */
+    mergeAndEnterNext(currentMilestoneId, nextMilestoneId, ctx) {
+        debugLog("WorktreeResolver", {
+            action: "mergeAndEnterNext",
+            currentMilestoneId,
+            nextMilestoneId,
+        });
+        this.mergeAndExit(currentMilestoneId, ctx);
+        this.enterMilestone(nextMilestoneId, ctx);
+    }
+}

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

@@ -0,0 +1,199 @@
+/**
+ * GSD Worktree Utilities
+ *
+ * Pure utility functions for worktree name detection, legacy branch name
+ * parsing, and integration branch capture.
+ *
+ * Pure utility functions (detectWorktreeName, getSliceBranchName, parseSliceBranch,
+ * SLICE_BRANCH_RE) remain standalone for backwards compatibility.
+ *
+ * Branchless architecture: all work commits sequentially on the milestone branch.
+ * Pure utility functions (detectWorktreeName, getSliceBranchName, parseSliceBranch,
+ * SLICE_BRANCH_RE) remain for backwards compatibility with legacy branches.
+ */
+import { existsSync, readFileSync, utimesSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { GitServiceImpl, writeIntegrationBranch } from "./git-service.js";
+import { loadEffectiveGSDPreferences } from "./preferences.js";
+export { MergeConflictError } from "./git-service.js";
+// ─── Lazy GitServiceImpl Cache ─────────────────────────────────────────────
+let cachedService = null;
+let cachedBasePath = null;
+/**
+ * Get or create a GitServiceImpl for the given basePath.
+ * Resets the cache if basePath changes between calls.
+ * Lazy construction: only instantiated at call-time, never at module-evaluation.
+ */
+function getService(basePath) {
+    if (cachedService === null || cachedBasePath !== basePath) {
+        const loaded = loadEffectiveGSDPreferences();
+        const gitPrefs = loaded?.preferences?.git ?? {};
+        cachedService = new GitServiceImpl(basePath, gitPrefs);
+        cachedBasePath = basePath;
+    }
+    return cachedService;
+}
+/**
+ * Set the active milestone ID on the cached GitServiceImpl.
+ * This enables integration branch resolution in getMainBranch().
+ */
+export function setActiveMilestoneId(basePath, milestoneId) {
+    getService(basePath).setMilestoneId(milestoneId);
+}
+/**
+ * Record the current branch as the integration branch for a milestone.
+ * Called once when auto-mode starts — captures where slice branches should
+ * merge back to. No-op if the same branch is already recorded. Updates the
+ * record when the user starts from a different branch (#300). Always a no-op
+ * if on a GSD slice branch.
+ */
+export function captureIntegrationBranch(basePath, milestoneId, options) {
+    // In a worktree, the base branch is implicit (worktree/<name>).
+    // Writing it to META.json would leave stale metadata after merge back to main.
+    if (detectWorktreeName(basePath))
+        return;
+    const svc = getService(basePath);
+    const current = svc.getCurrentBranch();
+    writeIntegrationBranch(basePath, milestoneId, current, options);
+}
+// ─── Pure Utility Functions (unchanged) ────────────────────────────────────
+/**
+ * Detect the active worktree name from the current working directory.
+ * Returns null if not inside a GSD worktree (.gsd/worktrees/<name>/).
+ */
+export function detectWorktreeName(basePath) {
+    const normalizedPath = basePath.replaceAll("\\", "/");
+    const marker = "/.gsd/worktrees/";
+    const idx = normalizedPath.indexOf(marker);
+    if (idx === -1)
+        return null;
+    const afterMarker = normalizedPath.slice(idx + marker.length);
+    const name = afterMarker.split("/")[0];
+    return name || null;
+}
+/**
+ * Resolve the project root from a path that may be inside a worktree.
+ * If the path contains `/.gsd/worktrees/<name>/`, returns the portion
+ * before `/.gsd/`. Otherwise returns the input unchanged.
+ *
+ * Use this in commands that call `process.cwd()` to ensure they always
+ * operate against the real project root, not a worktree subdirectory.
+ */
+export function resolveProjectRoot(basePath) {
+    const normalizedPath = basePath.replaceAll("\\", "/");
+    const marker = "/.gsd/worktrees/";
+    const idx = normalizedPath.indexOf(marker);
+    if (idx === -1)
+        return basePath;
+    // Return the original path up to the .gsd/ marker (un-normalized)
+    // Account for potential OS-specific separators
+    const sep = basePath.includes("\\") ? "\\" : "/";
+    const markerOs = `${sep}.gsd${sep}worktrees${sep}`;
+    const idxOs = basePath.indexOf(markerOs);
+    if (idxOs !== -1)
+        return basePath.slice(0, idxOs);
+    return basePath.slice(0, idx);
+}
+/**
+ * Get the slice branch name, namespaced by worktree when inside one.
+ *
+ * In the main tree:     gsd/<milestoneId>/<sliceId>
+ * In a worktree:        gsd/<worktreeName>/<milestoneId>/<sliceId>
+ *
+ * This prevents branch conflicts when multiple worktrees work on the
+ * same milestone/slice IDs — git doesn't allow a branch to be checked
+ * out in more than one worktree simultaneously.
+ */
+export function getSliceBranchName(milestoneId, sliceId, worktreeName) {
+    if (worktreeName) {
+        return `gsd/${worktreeName}/${milestoneId}/${sliceId}`;
+    }
+    return `gsd/${milestoneId}/${sliceId}`;
+}
+/** Regex that matches both plain and worktree-namespaced slice branches. */
+export const SLICE_BRANCH_RE = /^gsd\/(?:([a-zA-Z0-9_-]+)\/)?(M\d+(?:-[a-z0-9]{6})?)\/(S\d+)$/;
+/**
+ * Parse a slice branch name into its components.
+ * Handles both `gsd/M001/S01` and `gsd/myworktree/M001/S01`.
+ */
+export function parseSliceBranch(branchName) {
+    const match = branchName.match(SLICE_BRANCH_RE);
+    if (!match)
+        return null;
+    return {
+        worktreeName: match[1] ?? null,
+        milestoneId: match[2],
+        sliceId: match[3],
+    };
+}
+// ─── Git-Mutation Functions (delegate to GitServiceImpl) ───────────────────
+/**
+ * Get the "main" branch for GSD slice operations.
+ *
+ * In the main working tree: returns main/master (the repo's default branch).
+ * In a worktree: returns worktree/<name> — the worktree's own base branch.
+ *
+ * This is critical because git doesn't allow a branch to be checked out
+ * in more than one worktree. Slice branches merge into the worktree's base
+ * branch, and the worktree branch later merges into the real main via
+ * /worktree merge.
+ */
+export function getMainBranch(basePath) {
+    return getService(basePath).getMainBranch();
+}
+export function getCurrentBranch(basePath) {
+    return getService(basePath).getCurrentBranch();
+}
+/**
+ * Auto-commit any dirty files in the current working tree.
+ *
+ * When `taskContext` is provided, generates a meaningful conventional commit
+ * message from the task summary (one-liner, inferred type, key files).
+ * Falls back to a generic `chore()` message for non-task commits.
+ *
+ * Returns the commit message used, or null if already clean.
+ */
+export function autoCommitCurrentBranch(basePath, unitType, unitId, taskContext) {
+    return getService(basePath).autoCommit(unitType, unitId, [], taskContext);
+}
+// ─── Git HEAD Resolution ────────────────────────────────────────────────────
+/**
+ * Resolve the git HEAD file path for a given directory.
+ * Handles both normal repos (.git is a directory) and worktrees (.git is a file
+ * containing a `gitdir:` pointer to the real gitdir).
+ */
+export function resolveGitHeadPath(dir) {
+    const gitPath = join(dir, ".git");
+    if (!existsSync(gitPath))
+        return null;
+    try {
+        const content = readFileSync(gitPath, "utf8").trim();
+        if (content.startsWith("gitdir: ")) {
+            const gitDir = resolve(dir, content.slice(8));
+            const headPath = join(gitDir, "HEAD");
+            return existsSync(headPath) ? headPath : null;
+        }
+        const headPath = join(dir, ".git", "HEAD");
+        return existsSync(headPath) ? headPath : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Nudge pi's FooterDataProvider to re-read the git branch after chdir.
+ * Touches HEAD in both old and new cwd to fire the fs watcher.
+ */
+export function nudgeGitBranchCache(previousCwd) {
+    const now = new Date();
+    for (const dir of [previousCwd, process.cwd()]) {
+        try {
+            const headPath = resolveGitHeadPath(dir);
+            if (headPath)
+                utimesSync(headPath, now, now);
+        }
+        catch {
+            // Best-effort
+        }
+    }
+}