gsd-pi 2.33.1 → 2.34.0-dev.bbb5216

package/src/resources/extensions/gsd/worktree-command.ts

@@ -34,7 +34,6 @@ import type { FileLineStat } from "./worktree-manager.js";
 import { existsSync, realpathSync, readdirSync, rmSync, unlinkSync } from "node:fs";
 import { nativeMergeAbort } from "./native-git-bridge.js";
 import { join, sep } from "node:path";
-import { getErrorMessage } from "./error-utils.js";
 
 /**
  * Tracks the original project root so we can switch back.
@@ -51,7 +50,7 @@ export function getWorktreeOriginalCwd(): string | null {
 export function getActiveWorktreeName(): string | null {
   if (!originalCwd) return null;
   const cwd = process.cwd();
-  const wtDir = join(gsdRoot(originalCwd), "worktrees");
+  const wtDir = join(originalCwd, ".gsd", "worktrees");
   if (!cwd.startsWith(wtDir)) return null;
   const rel = cwd.slice(wtDir.length + 1);
   const name = rel.split("/")[0] ?? rel.split("\\")[0];
@@ -229,6 +228,15 @@ async function worktreeHandler(
   }
 }
 
+export async function handleWorktreeCommand(
+  args: string,
+  ctx: ExtensionCommandContext,
+  pi: ExtensionAPI,
+  alias: string,
+): Promise<void> {
+  await worktreeHandler(args, ctx, pi, alias);
+}
+
 export function registerWorktreeCommand(pi: ExtensionAPI): void {
   // Restore worktree state after /reload.
   // The module-level originalCwd resets to null when extensions are re-loaded,
@@ -247,7 +255,7 @@ export function registerWorktreeCommand(pi: ExtensionAPI): void {
     getArgumentCompletions: worktreeCompletions,
 
     async handler(args: string, ctx: ExtensionCommandContext) {
-      await worktreeHandler(args, ctx, pi, "worktree");
+      await handleWorktreeCommand(args, ctx, pi, "worktree");
     },
   });
 
@@ -256,7 +264,7 @@ export function registerWorktreeCommand(pi: ExtensionAPI): void {
     description: "Alias for /worktree",
     getArgumentCompletions: worktreeCompletions,
     async handler(args: string, ctx: ExtensionCommandContext) {
-      await worktreeHandler(args, ctx, pi, "wt");
+      await handleWorktreeCommand(args, ctx, pi, "wt");
     },
   });
 }
@@ -371,7 +379,7 @@ async function handleCreate(
       "info",
     );
   } catch (error) {
-    const msg = getErrorMessage(error);
+    const msg = error instanceof Error ? error.message : String(error);
     ctx.ui.notify(`Failed to create worktree: ${msg}`, "error");
   }
 }
@@ -419,7 +427,7 @@ async function handleSwitch(
       "info",
     );
   } catch (error) {
-    const msg = getErrorMessage(error);
+    const msg = error instanceof Error ? error.message : String(error);
     ctx.ui.notify(`Failed to switch to worktree: ${msg}`, "error");
   }
 }
@@ -529,7 +537,7 @@ async function handleList(
 
     ctx.ui.notify(lines.join("\n"), "info");
   } catch (error) {
-    const msg = getErrorMessage(error);
+    const msg = error instanceof Error ? error.message : String(error);
     ctx.ui.notify(`Failed to list worktrees: ${msg}`, "error");
   }
 }
@@ -634,6 +642,16 @@ async function handleMerge(
     const commitType = inferCommitType(name);
     const commitMessage = `${commitType}(${name}): merge worktree ${name}`;
 
+    // Reconcile worktree DB into main DB before squash merge
+    const wtDbPath = join(worktreePath(basePath, name), ".gsd", "gsd.db");
+    const mainDbPath = join(basePath, ".gsd", "gsd.db");
+    if (existsSync(wtDbPath) && existsSync(mainDbPath)) {
+      try {
+        const { reconcileWorktreeDb } = await import("./gsd-db.js");
+        reconcileWorktreeDb(mainDbPath, wtDbPath);
+      } catch { /* non-fatal */ }
+    }
+
     try {
       mergeWorktreeToMain(basePath, name, commitMessage);
       ctx.ui.notify(
@@ -647,7 +665,7 @@ async function handleMerge(
       );
       return;
     } catch (mergeErr) {
-      const mergeMsg = getErrorMessage(mergeErr);
+      const mergeMsg = mergeErr instanceof Error ? mergeErr.message : String(mergeErr);
       const isConflict = /conflict/i.test(mergeMsg);
 
       if (isConflict) {
@@ -704,7 +722,7 @@ async function handleMerge(
       "info",
     );
   } catch (error) {
-    const msg = getErrorMessage(error);
+    const msg = error instanceof Error ? error.message : String(error);
     ctx.ui.notify(`Failed to start merge: ${msg}`, "error");
   }
 }
@@ -747,7 +765,7 @@ async function handleRemove(
 
     ctx.ui.notify(`${CLR.ok("✓")} Worktree ${CLR.name(name)} removed ${CLR.muted("(branch deleted)")}.`, "info");
   } catch (error) {
-    const msg = getErrorMessage(error);
+    const msg = error instanceof Error ? error.message : String(error);
     ctx.ui.notify(`Failed to remove worktree: ${msg}`, "error");
   }
 }
@@ -801,7 +819,7 @@ async function handleRemoveAll(
     if (failed.length > 0) lines.push(`${CLR.warn("✗")} Failed: ${failed.map(n => CLR.name(n)).join(", ")}`);
     ctx.ui.notify(lines.join("\n"), failed.length > 0 ? "warning" : "info");
   } catch (error) {
-    const msg = getErrorMessage(error);
+    const msg = error instanceof Error ? error.message : String(error);
     ctx.ui.notify(`Failed to remove worktrees: ${msg}`, "error");
   }
 }

package/src/resources/extensions/gsd/worktree-manager.ts

@@ -17,7 +17,6 @@
 
 import { existsSync, mkdirSync, readFileSync, realpathSync } from "node:fs";
 import { join, resolve, sep } from "node:path";
-import { gsdRoot } from "./paths.js";
 import { GSDError, GSD_PARSE_ERROR, GSD_STALE_STATE, GSD_LOCK_HELD, GSD_GIT_ERROR, GSD_MERGE_CONFLICT } from "./errors.js";
 import {
   nativeBranchDelete,
@@ -101,7 +100,7 @@ export function resolveGitDir(basePath: string): string {
 }
 
 export function worktreesDir(basePath: string): string {
-  return join(gsdRoot(basePath), "worktrees");
+  return join(basePath, ".gsd", "worktrees");
 }
 
 export function worktreePath(basePath: string, name: string): string {
@@ -194,7 +193,7 @@ export function listWorktrees(basePath: string): WorktreeInfo[] {
   const seenRoots = new Set<string>();
   const worktreeRoots = baseVariants
     .map(baseVariant => {
-      const path = join(gsdRoot(baseVariant), "worktrees");
+      const path = join(baseVariant, ".gsd", "worktrees");
       return {
         normalized: normalizePathForComparison(path),
       };

package/src/resources/extensions/gsd/worktree-resolver.ts

@@ -0,0 +1,485 @@
+/**
+ * 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 type { AutoSession } from "./auto/session.js";
+import { debugLog } from "./debug-logger.js";
+
+// ─── Dependency Interface ──────────────────────────────────────────────────
+
+export interface WorktreeResolverDeps {
+  isInAutoWorktree: (basePath: string) => boolean;
+  shouldUseWorktreeIsolation: () => boolean;
+  getIsolationMode: () => "worktree" | "branch" | "none";
+  mergeMilestoneToMain: (
+    basePath: string,
+    milestoneId: string,
+    roadmapContent: string,
+  ) => { pushed: boolean };
+  syncWorktreeStateBack: (
+    mainBasePath: string,
+    worktreePath: string,
+    milestoneId: string,
+  ) => { synced: string[] };
+  teardownAutoWorktree: (
+    basePath: string,
+    milestoneId: string,
+    opts?: { preserveBranch?: boolean },
+  ) => void;
+  createAutoWorktree: (basePath: string, milestoneId: string) => string;
+  enterAutoWorktree: (basePath: string, milestoneId: string) => string;
+  getAutoWorktreePath: (basePath: string, milestoneId: string) => string | null;
+  autoCommitCurrentBranch: (
+    basePath: string,
+    reason: string,
+    milestoneId: string,
+  ) => void;
+  getCurrentBranch: (basePath: string) => string;
+  autoWorktreeBranch: (milestoneId: string) => string;
+  resolveMilestoneFile: (
+    basePath: string,
+    milestoneId: string,
+    fileType: string,
+  ) => string | null;
+  readFileSync: (path: string, encoding: string) => string;
+  GitServiceImpl: new (basePath: string, gitConfig: unknown) => unknown;
+  loadEffectiveGSDPreferences: () =>
+    | { preferences?: { git?: Record<string, unknown> } }
+    | undefined;
+  invalidateAllCaches: () => void;
+  captureIntegrationBranch: (
+    basePath: string,
+    mid: string,
+    opts?: { commitDocs?: boolean },
+  ) => void;
+}
+
+// ─── Notify Context ────────────────────────────────────────────────────────
+
+export interface NotifyCtx {
+  notify: (
+    msg: string,
+    level?: "info" | "warning" | "error" | "success",
+  ) => void;
+}
+
+// ─── WorktreeResolver ──────────────────────────────────────────────────────
+
+export class WorktreeResolver {
+  private readonly s: AutoSession;
+  private readonly deps: WorktreeResolverDeps;
+
+  constructor(session: AutoSession, deps: WorktreeResolverDeps) {
+    this.s = session;
+    this.deps = deps;
+  }
+
+  // ── Getters ────────────────────────────────────────────────────────────
+
+  /** Current working path — may be worktree or project root. */
+  get workPath(): string {
+    return this.s.basePath;
+  }
+
+  /** Original project root — always the non-worktree path. */
+  get projectRoot(): string {
+    return this.s.originalBasePath || this.s.basePath;
+  }
+
+  /** Path for auto.lock file — same as the old lockBase(). */
+  get lockPath(): string {
+    return this.s.originalBasePath || this.s.basePath;
+  }
+
+  // ── Private Helpers ────────────────────────────────────────────────────
+
+  private rebuildGitService(): void {
+    const gitConfig =
+      this.deps.loadEffectiveGSDPreferences()?.preferences?.git ?? {};
+    this.s.gitService = new this.deps.GitServiceImpl(
+      this.s.basePath,
+      gitConfig,
+    ) as AutoSession["gitService"];
+  }
+
+  /** Restore basePath to originalBasePath and rebuild GitService. */
+  private restoreToProjectRoot(): void {
+    if (!this.s.originalBasePath) return;
+    this.s.basePath = this.s.originalBasePath;
+    this.rebuildGitService();
+    this.deps.invalidateAllCaches();
+  }
+
+  // ── Validation ──────────────────────────────────────────────────────────
+
+  /** Validate milestoneId to prevent path traversal. */
+  private validateMilestoneId(milestoneId: string): void {
+    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: string, ctx: NotifyCtx): void {
+    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: string;
+
+      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: string,
+    ctx: NotifyCtx,
+    opts?: { preserveBranch?: boolean },
+  ): void {
+    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: string, ctx: NotifyCtx): void {
+    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. */
+  private _mergeWorktreeMode(milestoneId: string, ctx: NotifyCtx): void {
+    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. */
+  private _mergeBranchMode(milestoneId: string, ctx: NotifyCtx): void {
+    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: string,
+    nextMilestoneId: string,
+    ctx: NotifyCtx,
+  ): void {
+    debugLog("WorktreeResolver", {
+      action: "mergeAndEnterNext",
+      currentMilestoneId,
+      nextMilestoneId,
+    });
+    this.mergeAndExit(currentMilestoneId, ctx);
+    this.enterMilestone(nextMilestoneId, ctx);
+  }
+}