gsd-pi 2.28.0 → 2.29.0-dev.2ccf3fb

package/src/resources/extensions/gsd/auto-worktree-sync.ts

@@ -10,9 +10,12 @@
  * Also contains resource staleness detection and stale worktree escape.
  */
 
-import { existsSync, mkdirSync, readFileSync, writeFileSync, cpSync, unlinkSync, readdirSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, cpSync, unlinkSync, readdirSync } from "node:fs";
+import { loadJsonFileOrNull } from "./json-persistence.js";
 import { join, sep as pathSep } from "node:path";
 import { homedir } from "node:os";
+import { safeCopy, safeCopyRecursive } from "./safe-fs.js";
+import { atomicWriteSync } from "./atomic-write.js";
 
 // ─── Project Root → Worktree Sync ─────────────────────────────────────────
 
@@ -32,14 +35,13 @@ export function syncProjectRootToWorktree(projectRoot: string, worktreePath: str
 
   // Copy milestone directory from project root to worktree if the project root
   // has newer artifacts (e.g. slices that don't exist in the worktree yet)
-  try {
-    const srcMilestone = join(prGsd, "milestones", milestoneId);
-    const dstMilestone = join(wtGsd, "milestones", milestoneId);
-    if (existsSync(srcMilestone)) {
-      mkdirSync(dstMilestone, { recursive: true });
-      cpSync(srcMilestone, dstMilestone, { recursive: true, force: false });
-    }
-  } catch { /* non-fatal */ }
+  safeCopyRecursive(join(prGsd, "milestones", milestoneId), join(wtGsd, "milestones", milestoneId))
+
+  // Copy living documents from project root to worktree so agents have the
+  // latest decisions, requirements, project state, and knowledge.
+  for (const doc of ["DECISIONS.md", "REQUIREMENTS.md", "PROJECT.md", "KNOWLEDGE.md"]) {
+    safeCopy(join(prGsd, doc), join(wtGsd, doc), { force: true });
+  }
 
   // Delete worktree gsd.db so it rebuilds from the freshly synced files.
   // Stale DB rows are the root cause of the infinite skip loop (#853).
@@ -67,22 +69,11 @@ export function syncStateToProjectRoot(worktreePath: string, projectRoot: string
   const prGsd = join(projectRoot, ".gsd");
 
   // 1. STATE.md — the quick-glance status used by initial deriveState()
-  try {
-    const src = join(wtGsd, "STATE.md");
-    const dst = join(prGsd, "STATE.md");
-    if (existsSync(src)) cpSync(src, dst, { force: true });
-  } catch { /* non-fatal */ }
+  safeCopy(join(wtGsd, "STATE.md"), join(prGsd, "STATE.md"), { force: true })
 
   // 2. Milestone directory — ROADMAP, slice PLANs, task summaries
   // Copy the entire milestone .gsd subtree so deriveState reads current checkboxes
-  try {
-    const srcMilestone = join(wtGsd, "milestones", milestoneId);
-    const dstMilestone = join(prGsd, "milestones", milestoneId);
-    if (existsSync(srcMilestone)) {
-      mkdirSync(dstMilestone, { recursive: true });
-      cpSync(srcMilestone, dstMilestone, { recursive: true, force: true });
-    }
-  } catch { /* non-fatal */ }
+  safeCopyRecursive(join(wtGsd, "milestones", milestoneId), join(prGsd, "milestones", milestoneId), { force: true })
 
   // 3. Merge completed-units.json (set-union of both locations)
   // Prevents already-completed units from being re-dispatched after crash/restart.
@@ -96,7 +87,7 @@ export function syncStateToProjectRoot(worktreePath: string, projectRoot: string
         try { dstKeys = JSON.parse(readFileSync(dstKeysFile, "utf8")); } catch { /* ignore corrupt dst */ }
       }
       const merged = [...new Set([...dstKeys, ...srcKeys])];
-      writeFileSync(dstKeysFile, JSON.stringify(merged, null, 2));
+      atomicWriteSync(dstKeysFile, JSON.stringify(merged, null, 2));
     } catch { /* non-fatal */ }
   }
 
@@ -104,14 +95,15 @@ export function syncStateToProjectRoot(worktreePath: string, projectRoot: string
   // Without this, a crash during a unit leaves the runtime record only in the
   // worktree. If the next session resolves basePath before worktree re-entry,
   // selfHeal can't find or clear the stale record (#769).
-  try {
-    const srcRuntime = join(wtGsd, "runtime", "units");
-    const dstRuntime = join(prGsd, "runtime", "units");
-    if (existsSync(srcRuntime)) {
-      mkdirSync(dstRuntime, { recursive: true });
-      cpSync(srcRuntime, dstRuntime, { recursive: true, force: true });
-    }
-  } catch { /* non-fatal */ }
+  safeCopyRecursive(join(wtGsd, "runtime", "units"), join(prGsd, "runtime", "units"), { force: true })
+
+  // 5. Living documents — decisions, requirements, project description, knowledge.
+  // Agents update these during slice execution. Without syncing, a new session
+  // reads stale copies from the project root, losing architectural decisions,
+  // requirement status updates, and accumulated knowledge (#1168).
+  for (const doc of ["DECISIONS.md", "REQUIREMENTS.md", "PROJECT.md", "KNOWLEDGE.md"]) {
+    safeCopy(join(wtGsd, doc), join(prGsd, doc), { force: true });
+  }
 }
 
 // ─── Resource Staleness ───────────────────────────────────────────────────
@@ -121,15 +113,15 @@ export function syncStateToProjectRoot(worktreePath: string, projectRoot: string
  * Uses gsdVersion instead of syncedAt so that launching a second session
  * doesn't falsely trigger staleness (#804).
  */
+function isManifestWithVersion(data: unknown): data is { gsdVersion: string } {
+  return data !== null && typeof data === "object" && "gsdVersion" in data! && typeof (data as Record<string, unknown>).gsdVersion === "string";
+}
+
 export function readResourceVersion(): string | null {
   const agentDir = process.env.GSD_CODING_AGENT_DIR || join(homedir(), ".gsd", "agent");
   const manifestPath = join(agentDir, "managed-resources.json");
-  try {
-    const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
-    return typeof manifest?.gsdVersion === "string" ? manifest.gsdVersion : null;
-  } catch {
-    return null;
-  }
+  const manifest = loadJsonFileOrNull(manifestPath, isManifestWithVersion);
+  return manifest?.gsdVersion ?? null;
 }
 
 /**

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

@@ -6,16 +6,19 @@
  * manages create, enter, detect, and teardown for auto-mode worktrees.
  */
 
-import { existsSync, cpSync, readFileSync, writeFileSync, readdirSync, mkdirSync, realpathSync, utimesSync, unlinkSync } from "node:fs";
-import { isAbsolute, join, resolve } from "node:path";
+import { existsSync, cpSync, readFileSync, readdirSync, mkdirSync, realpathSync, unlinkSync, statSync } from "node:fs";
+import { isAbsolute, join, sep } from "node:path";
+import { GSDError, GSD_IO_ERROR, GSD_GIT_ERROR } from "./errors.js";
 import { copyWorktreeDb, reconcileWorktreeDb, isDbAvailable } from "./gsd-db.js";
+import { atomicWriteSync } from "./atomic-write.js";
 import { execSync, execFileSync } from "node:child_process";
+import { safeCopy, safeCopyRecursive } from "./safe-fs.js";
 import {
   createWorktree,
   removeWorktree,
   worktreePath,
 } from "./worktree-manager.js";
-import { detectWorktreeName } from "./worktree.js";
+import { detectWorktreeName, resolveGitHeadPath, nudgeGitBranchCache } from "./worktree.js";
 import {
   MergeConflictError,
   readIntegrationBranch,
@@ -42,41 +45,6 @@ import {
 /** Original project root before chdir into auto-worktree. */
 let originalBase: string | null = null;
 
-// ─── Git Helpers (local, mirrors worktree-command.ts pattern) ──────────────
-
-function resolveGitHeadPath(dir: string): string | null {
-  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.
- */
-function nudgeGitBranchCache(previousCwd: string): void {
-  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
-    }
-  }
-}
-
 // ─── Worktree Post-Create Hook (#597) ────────────────────────────────────────
 
 /**
@@ -216,7 +184,7 @@ function reconcilePlanCheckboxes(projectRoot: string, wtPath: string, milestoneI
 
     if (changed) {
       try {
-        writeFileSync(dstFile, updated, "utf-8");
+        atomicWriteSync(dstFile, updated, "utf-8");
       } catch { /* non-fatal */ }
     }
   }
@@ -234,7 +202,7 @@ function reconcilePlanCheckboxes(projectRoot: string, wtPath: string, milestoneI
       const merged = [...new Set([...dst, ...src])];
       if (merged.length > dst.length) {
         mkdirSync(join(wtPath, ".gsd"), { recursive: true });
-        writeFileSync(dstKeys, JSON.stringify(merged), "utf-8");
+        atomicWriteSync(dstKeys, JSON.stringify(merged), "utf-8");
       }
     } catch { /* non-fatal */ }
   }
@@ -301,7 +269,8 @@ export function createAutoWorktree(basePath: string, milestoneId: string): strin
   } catch (err) {
     // If chdir fails, the worktree was created but we couldn't enter it.
     // Don't store originalBase -- caller can retry or clean up.
-    throw new Error(
+    throw new GSDError(
+      GSD_IO_ERROR,
       `Auto-worktree created at ${info.path} but chdir failed: ${err instanceof Error ? err.message : String(err)}`,
     );
   }
@@ -323,21 +292,11 @@ function copyPlanningArtifacts(srcBase: string, wtPath: string): void {
   if (!existsSync(srcGsd)) return;
 
   // Copy milestones/ directory (planning files, roadmaps, plans, research)
-  const srcMilestones = join(srcGsd, "milestones");
-  if (existsSync(srcMilestones)) {
-    try {
-      cpSync(srcMilestones, join(dstGsd, "milestones"), { recursive: true, force: true });
-    } catch { /* non-fatal */ }
-  }
+  safeCopyRecursive(join(srcGsd, "milestones"), join(dstGsd, "milestones"), { force: true });
 
   // Copy top-level planning files
   for (const file of ["DECISIONS.md", "REQUIREMENTS.md", "PROJECT.md", "QUEUE.md", "STATE.md", "KNOWLEDGE.md", "OVERRIDES.md"]) {
-    const src = join(srcGsd, file);
-    if (existsSync(src)) {
-      try {
-        cpSync(src, join(dstGsd, file), { force: true });
-      } catch { /* non-fatal */ }
-    }
+    safeCopy(join(srcGsd, file), join(dstGsd, file), { force: true });
   }
 
   // Copy gsd.db if present in source
@@ -367,7 +326,8 @@ export function teardownAutoWorktree(
     process.chdir(originalBasePath);
     originalBase = null;
   } catch (err) {
-    throw new Error(
+    throw new GSDError(
+      GSD_IO_ERROR,
       `Failed to chdir back to ${originalBasePath} during teardown: ${err instanceof Error ? err.message : String(err)}`,
     );
   }
@@ -381,13 +341,36 @@ export function teardownAutoWorktree(
  * Checks both module state and git branch prefix.
  */
 export function isInAutoWorktree(basePath: string): boolean {
-  if (!originalBase) return false;
   const cwd = process.cwd();
-  const resolvedBase = existsSync(basePath) ? realpathSync(basePath) : basePath;
-  const wtDir = join(resolvedBase, ".gsd", "worktrees");
-  if (!cwd.startsWith(wtDir)) return false;
-  const branch = nativeGetCurrentBranch(cwd);
-  return branch.startsWith("milestone/");
+
+  // Primary check: use originalBase if available (fast path)
+  if (originalBase) {
+    const resolvedBase = existsSync(basePath) ? realpathSync(basePath) : basePath;
+    const wtDir = join(resolvedBase, ".gsd", "worktrees");
+    if (!cwd.startsWith(wtDir)) return false;
+    const branch = nativeGetCurrentBranch(cwd);
+    return branch.startsWith("milestone/");
+  }
+
+  // Fallback: infer worktree status structurally when originalBase is null
+  // (happens after session restart where module-level state is lost, #1120).
+  // Check if cwd is inside a .gsd/worktrees/ directory and has a .git file
+  // (worktree marker) pointing to the main repo.
+  const worktreeMarker = join(cwd, ".git");
+  if (!existsSync(worktreeMarker)) return false;
+  try {
+    const stat = statSync(worktreeMarker);
+    if (stat.isDirectory()) return false; // Main repo has .git dir, not file
+    // Worktrees have a .git file with "gitdir: ..." pointing to the main repo
+    const gitContent = readFileSync(worktreeMarker, "utf-8").trim();
+    if (!gitContent.startsWith("gitdir:")) return false;
+    // Verify cwd path contains .gsd/worktrees/
+    if (!cwd.includes(`${sep}.gsd${sep}worktrees${sep}`) && !cwd.includes("/.gsd/worktrees/")) return false;
+    const branch = nativeGetCurrentBranch(cwd);
+    return branch.startsWith("milestone/");
+  } catch {
+    return false;
+  }
 }
 
 /**
@@ -425,22 +408,22 @@ export function getAutoWorktreePath(basePath: string, milestoneId: string): stri
 export function enterAutoWorktree(basePath: string, milestoneId: string): string {
   const p = worktreePath(basePath, milestoneId);
   if (!existsSync(p)) {
-    throw new Error(`Auto-worktree for ${milestoneId} does not exist at ${p}`);
+    throw new GSDError(GSD_IO_ERROR, `Auto-worktree for ${milestoneId} does not exist at ${p}`);
   }
 
   // Validate this is a real git worktree, not a stray directory (#695)
   const gitPath = join(p, ".git");
   if (!existsSync(gitPath)) {
-    throw new Error(`Auto-worktree path ${p} exists but is not a git worktree (no .git)`);
+    throw new GSDError(GSD_GIT_ERROR, `Auto-worktree path ${p} exists but is not a git worktree (no .git)`);
   }
   try {
     const content = readFileSync(gitPath, "utf8").trim();
     if (!content.startsWith("gitdir: ")) {
-      throw new Error(`Auto-worktree path ${p} has a .git but it is not a worktree gitdir pointer`);
+      throw new GSDError(GSD_GIT_ERROR, `Auto-worktree path ${p} has a .git but it is not a worktree gitdir pointer`);
     }
   } catch (err) {
     if (err instanceof Error && err.message.includes("worktree")) throw err;
-    throw new Error(`Auto-worktree path ${p} exists but .git is unreadable`);
+    throw new GSDError(GSD_IO_ERROR, `Auto-worktree path ${p} exists but .git is unreadable`);
   }
 
   const previousCwd = process.cwd();
@@ -449,7 +432,8 @@ export function enterAutoWorktree(basePath: string, milestoneId: string): string
     process.chdir(p);
     originalBase = basePath;
   } catch (err) {
-    throw new Error(
+    throw new GSDError(
+      GSD_IO_ERROR,
       `Failed to enter auto-worktree at ${p}: ${err instanceof Error ? err.message : String(err)}`,
     );
   }
@@ -527,7 +511,7 @@ export function mergeMilestoneToMain(
   originalBasePath_: string,
   milestoneId: string,
   roadmapContent: string,
-): { commitMessage: string; pushed: boolean } {
+): { commitMessage: string; pushed: boolean; prCreated: boolean } {
   const worktreeCwd = process.cwd();
   const milestoneBranch = autoWorktreeBranch(milestoneId);
 
@@ -551,6 +535,11 @@ export function mergeMilestoneToMain(
   const previousCwd = process.cwd();
   process.chdir(originalBasePath_);
 
+  // 3a. Auto-commit any dirty state in the project root that syncStateToProjectRoot
+  // wrote during execution. Without this, the squash merge can fail with
+  // "Your local changes to the following files would be overwritten by merge" (#1127).
+  autoCommitDirtyState(originalBasePath_);
+
   // 4. Resolve integration branch — prefer milestone metadata, fall back to preferences / "main"
   const prefs = loadEffectiveGSDPreferences()?.preferences?.git ?? {};
   const integrationBranch = readIntegrationBranch(originalBasePath_, milestoneId);
@@ -642,6 +631,33 @@ export function mergeMilestoneToMain(
     }
   }
 
+  // 9b. Auto-create PR if enabled (requires push_branches + push succeeded)
+  let prCreated = false;
+  if (prefs.auto_pr === true && pushed) {
+    const remote = prefs.remote ?? "origin";
+    const prTarget = prefs.pr_target_branch ?? mainBranch;
+    try {
+      // Push the milestone branch to remote first
+      execSync(`git push ${remote} ${milestoneBranch}`, {
+        cwd: originalBasePath_,
+        stdio: ["ignore", "pipe", "pipe"],
+        encoding: "utf-8",
+      });
+      // Create PR via gh CLI
+      execSync(
+        `gh pr create --base "${prTarget}" --head "${milestoneBranch}" --title "Milestone ${milestoneId} complete" --body "Auto-created by GSD on milestone completion."`,
+        {
+          cwd: originalBasePath_,
+          stdio: ["ignore", "pipe", "pipe"],
+          encoding: "utf-8",
+        },
+      );
+      prCreated = true;
+    } catch {
+      // PR creation failure is non-fatal — gh may not be installed or authenticated
+    }
+  }
+
   // 10. Remove worktree directory first (must happen before branch deletion)
   try {
     removeWorktree(originalBasePath_, milestoneId, { branch: null as unknown as string, deleteBranch: false });
@@ -660,5 +676,5 @@ export function mergeMilestoneToMain(
   originalBase = null;
   nudgeGitBranchCache(previousCwd);
 
-  return { commitMessage, pushed };
+  return { commitMessage, pushed, prCreated };
 }