gsd-pi 2.29.0-dev.49d972f → 2.29.0-dev.4c155ee

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

@@ -1,199 +0,0 @@
-/**
- * Worktree ↔ project root state synchronization for auto-mode.
- *
- * When auto-mode runs inside a worktree, dispatch-critical state files
- * (.gsd/ metadata) diverge between the worktree (where work happens)
- * and the project root (where startAutoMode reads initial state on restart).
- * Without syncing, restarting auto-mode reads stale state from the project
- * root and re-dispatches already-completed units.
- *
- * Also contains resource staleness detection and stale worktree escape.
- */
-
-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 ─────────────────────────────────────────
-
-/**
- * Sync milestone artifacts from project root INTO worktree before deriveState.
- * Covers the case where the LLM wrote artifacts to the main repo filesystem
- * (e.g. via absolute paths) but the worktree has stale data. Also deletes
- * gsd.db in the worktree so it rebuilds from fresh disk state (#853).
- * Non-fatal — sync failure should never block dispatch.
- */
-export function syncProjectRootToWorktree(projectRoot: string, worktreePath: string, milestoneId: string | null): void {
-  if (!worktreePath || !projectRoot || worktreePath === projectRoot) return;
-  if (!milestoneId) return;
-
-  const prGsd = join(projectRoot, ".gsd");
-  const wtGsd = join(worktreePath, ".gsd");
-
-  // 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)
-  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).
-  try {
-    const wtDb = join(wtGsd, "gsd.db");
-    if (existsSync(wtDb)) {
-      unlinkSync(wtDb);
-    }
-  } catch { /* non-fatal */ }
-}
-
-// ─── Worktree → Project Root Sync ─────────────────────────────────────────
-
-/**
- * Sync dispatch-critical .gsd/ state files from worktree to project root.
- * Only runs when inside an auto-worktree (worktreePath differs from projectRoot).
- * Copies: STATE.md + active milestone directory (roadmap, slice plans, task summaries).
- * Non-fatal — sync failure should never block dispatch.
- */
-export function syncStateToProjectRoot(worktreePath: string, projectRoot: string, milestoneId: string | null): void {
-  if (!worktreePath || !projectRoot || worktreePath === projectRoot) return;
-  if (!milestoneId) return;
-
-  const wtGsd = join(worktreePath, ".gsd");
-  const prGsd = join(projectRoot, ".gsd");
-
-  // 1. STATE.md — the quick-glance status used by initial deriveState()
-  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
-  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.
-  const srcKeysFile = join(wtGsd, "completed-units.json");
-  const dstKeysFile = join(prGsd, "completed-units.json");
-  if (existsSync(srcKeysFile)) {
-    try {
-      const srcKeys: string[] = JSON.parse(readFileSync(srcKeysFile, "utf8"));
-      let dstKeys: string[] = [];
-      if (existsSync(dstKeysFile)) {
-        try { dstKeys = JSON.parse(readFileSync(dstKeysFile, "utf8")); } catch { /* ignore corrupt dst */ }
-      }
-      const merged = [...new Set([...dstKeys, ...srcKeys])];
-      atomicWriteSync(dstKeysFile, JSON.stringify(merged, null, 2));
-    } catch { /* non-fatal */ }
-  }
-
-  // 4. Runtime records — unit dispatch state used by selfHealRuntimeRecords().
-  // 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).
-  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 ───────────────────────────────────────────────────
-
-/**
- * Read the resource version (semver) from the managed-resources manifest.
- * 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");
-  const manifest = loadJsonFileOrNull(manifestPath, isManifestWithVersion);
-  return manifest?.gsdVersion ?? null;
-}
-
-/**
- * Check if managed resources have been updated since session start.
- * Returns a warning message if stale, null otherwise.
- */
-export function checkResourcesStale(versionOnStart: string | null): string | null {
-  if (versionOnStart === null) return null;
-  const current = readResourceVersion();
-  if (current === null) return null;
-  if (current !== versionOnStart) {
-    return "GSD resources were updated since this session started. Restart gsd to load the new code.";
-  }
-  return null;
-}
-
-// ─── Stale Worktree Escape ────────────────────────────────────────────────
-
-/**
- * Detect and escape a stale worktree cwd (#608).
- *
- * After milestone completion + merge, the worktree directory is removed but
- * the process cwd may still point inside `.gsd/worktrees/<MID>/`.
- * When a new session starts, `process.cwd()` is passed as `base` to startAuto
- * and all subsequent writes land in the wrong directory. This function detects
- * that scenario and chdir back to the project root.
- *
- * Returns the corrected base path.
- */
-export function escapeStaleWorktree(base: string): string {
-  const marker = `${pathSep}.gsd${pathSep}worktrees${pathSep}`;
-  const idx = base.indexOf(marker);
-  if (idx === -1) return base;
-
-  // base is inside .gsd/worktrees/<something> — extract the project root
-  const projectRoot = base.slice(0, idx);
-  try {
-    process.chdir(projectRoot);
-  } catch {
-    // If chdir fails, return the original — caller will handle errors downstream
-    return base;
-  }
-  return projectRoot;
-}
-
-/**
- * Clean stale runtime unit files for completed milestones.
- *
- * After restart, stale runtime/units/*.json from prior milestones can
- * cause deriveState to resume the wrong milestone (#887). Removes files
- * for milestones that have a SUMMARY (fully complete).
- */
-export function cleanStaleRuntimeUnits(
-  gsdRootPath: string,
-  hasMilestoneSummary: (mid: string) => boolean,
-): number {
-  const runtimeUnitsDir = join(gsdRootPath, "runtime", "units");
-  if (!existsSync(runtimeUnitsDir)) return 0;
-
-  let cleaned = 0;
-  try {
-    for (const file of readdirSync(runtimeUnitsDir)) {
-      if (!file.endsWith(".json")) continue;
-      const midMatch = file.match(/(M\d+(?:-[a-z0-9]{6})?)/);
-      if (!midMatch) continue;
-      if (hasMilestoneSummary(midMatch[1])) {
-        try {
-          unlinkSync(join(runtimeUnitsDir, file));
-          cleaned++;
-        } catch { /* non-fatal */ }
-      }
-    }
-  } catch { /* non-fatal */ }
-  return cleaned;
-}

package/src/resources/extensions/gsd/tests/worktree-db-integration.test.ts

@@ -1,205 +0,0 @@
-/**
- * worktree-db-integration.test.ts
- *
- * Integration tests for the worktree DB copy and reconcile hooks.
- * Uses real temp git repos and real SQLite databases.
- *
- * Test cases:
- *   1. Copy: createAutoWorktree seeds .gsd/gsd.db into the worktree when main has one
- *   2. Copy-skip: createAutoWorktree silently skips when main has no gsd.db
- *   3. Reconcile: reconcileWorktreeDb merges worktree rows into main DB
- *   4. Reconcile-skip: reconcileWorktreeDb is non-fatal when both paths are nonexistent
- *   5. Failure path: reconcileWorktreeDb emits to stderr on open failure (observable)
- */
-
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, realpathSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { execSync } from "node:child_process";
-
-import { createAutoWorktree } from "../auto-worktree.ts";
-import { worktreePath } from "../worktree-manager.ts";
-import {
-  copyWorktreeDb,
-  reconcileWorktreeDb,
-  openDatabase,
-  closeDatabase,
-  upsertDecision,
-  getActiveDecisions,
-  isDbAvailable,
-} from "../gsd-db.ts";
-
-import { createTestContext } from "./test-helpers.ts";
-
-const { assertEq, assertTrue, report } = createTestContext();
-
-function run(command: string, cwd: string): string {
-  return execSync(command, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
-}
-
-function createTempRepo(): string {
-  const dir = realpathSync(mkdtempSync(join(tmpdir(), "wt-db-int-test-")));
-  run("git init", dir);
-  run("git config user.email test@test.com", dir);
-  run("git config user.name Test", dir);
-  writeFileSync(join(dir, "README.md"), "# test\n");
-  run("git add .", dir);
-  run("git commit -m init", dir);
-  run("git branch -M main", dir);
-  return dir;
-}
-
-async function main(): Promise<void> {
-  const savedCwd = process.cwd();
-  const tempDirs: string[] = [];
-
-  function makeTempDir(): string {
-    const dir = realpathSync(mkdtempSync(join(tmpdir(), "wt-db-int-")));
-    tempDirs.push(dir);
-    return dir;
-  }
-
-  try {
-
-    // ─── Test 1: copy on worktree creation ───────────────────────────
-    console.log("\n=== Test 1: copy on worktree creation ===");
-    {
-      const tempDir = createTempRepo();
-      tempDirs.push(tempDir);
-
-      // Seed a gsd.db in the main repo
-      const gsdDir = join(tempDir, ".gsd");
-      mkdirSync(gsdDir, { recursive: true });
-      const mainDbPath = join(gsdDir, "gsd.db");
-      openDatabase(mainDbPath);
-      closeDatabase();
-
-      // Commit so createAutoWorktree can copy planning artifacts
-      run("git add .", tempDir);
-      run('git commit -m "add gsd dir"', tempDir);
-
-      // createAutoWorktree should copy the DB into the worktree
-      const wtPath = createAutoWorktree(tempDir, "M004");
-
-      const worktreeDbPath = join(worktreePath(tempDir, "M004"), ".gsd", "gsd.db");
-      assertTrue(
-        existsSync(worktreeDbPath),
-        "gsd.db exists in worktree .gsd after createAutoWorktree",
-      );
-
-      // Restore cwd for next test
-      process.chdir(savedCwd);
-    }
-
-    // ─── Test 2: copy skip when no source DB ─────────────────────────
-    console.log("\n=== Test 2: copy skip when no source DB ===");
-    {
-      const tempDir = createTempRepo();
-      tempDirs.push(tempDir);
-
-      // No gsd.db — just a bare repo
-      let threw = false;
-      let wtPath: string | null = null;
-      try {
-        wtPath = createAutoWorktree(tempDir, "M004");
-      } catch (err) {
-        threw = true;
-        console.error("  Unexpected throw:", err);
-      }
-
-      assertTrue(!threw, "createAutoWorktree does not throw when no source DB");
-
-      const worktreeDbPath = join(worktreePath(tempDir, "M004"), ".gsd", "gsd.db");
-      assertTrue(
-        !existsSync(worktreeDbPath),
-        "gsd.db is absent in worktree when source had none",
-      );
-
-      process.chdir(savedCwd);
-    }
-
-    // ─── Test 3: reconcile inserts worktree rows into main ───────────
-    console.log("\n=== Test 3: reconcile merges worktree rows into main ===");
-    {
-      const mainDbPath = join(makeTempDir(), "main.db");
-      const worktreeDbPath = join(makeTempDir(), "wt.db");
-
-      // Seed main DB (empty schema)
-      openDatabase(mainDbPath);
-      closeDatabase();
-
-      // Seed worktree DB with one decision
-      openDatabase(worktreeDbPath);
-      upsertDecision({
-        id: "D-WT-001",
-        when_context: "integration test",
-        scope: "test",
-        decision: "use reconcile",
-        choice: "reconcile on merge",
-        rationale: "test coverage",
-        revisable: "no",
-        superseded_by: null,
-      });
-      closeDatabase();
-
-      // Reconcile worktree → main
-      const result = reconcileWorktreeDb(mainDbPath, worktreeDbPath);
-      assertTrue(result.decisions >= 1, "reconcile reports at least 1 decision merged");
-
-      // Open main DB and verify the row is present
-      openDatabase(mainDbPath);
-      const decisions = getActiveDecisions();
-      closeDatabase();
-
-      const found = decisions.some((d) => d.id === "D-WT-001");
-      assertTrue(found, "worktree decision D-WT-001 present in main DB after reconcile");
-    }
-
-    // ─── Test 4: reconcile non-fatal when both paths nonexistent ─────
-    console.log("\n=== Test 4: reconcile non-fatal on nonexistent paths ===");
-    {
-      let threw = false;
-      try {
-        reconcileWorktreeDb("/nonexistent/path/gsd.db", "/also/nonexistent/gsd.db");
-      } catch {
-        threw = true;
-      }
-      assertTrue(!threw, "reconcileWorktreeDb does not throw when worktree DB is absent");
-    }
-
-    // ─── Test 5: failure path observable via stderr (diagnostic) ─────
-    // reconcileWorktreeDb emits to stderr on reconciliation failures.
-    // We can't easily intercept stderr in this test harness, but we verify
-    // that the function returns the zero-result shape (not undefined/throws)
-    // when the worktree DB is missing — confirming the failure path is non-fatal
-    // and returns a structured result.
-    console.log("\n=== Test 5: reconcile returns zero-shape when worktree DB absent ===");
-    {
-      const mainDbPath = join(makeTempDir(), "main2.db");
-      openDatabase(mainDbPath);
-      closeDatabase();
-
-      const result = reconcileWorktreeDb(mainDbPath, "/definitely/does/not/exist.db");
-      assertEq(result.decisions, 0, "decisions is 0 when worktree DB absent");
-      assertEq(result.requirements, 0, "requirements is 0 when worktree DB absent");
-      assertEq(result.artifacts, 0, "artifacts is 0 when worktree DB absent");
-      assertEq(result.conflicts.length, 0, "conflicts is empty when worktree DB absent");
-    }
-
-  } finally {
-    // Always restore cwd
-    process.chdir(savedCwd);
-    // Ensure DB is closed
-    if (isDbAvailable()) closeDatabase();
-    // Remove all temp dirs
-    for (const dir of tempDirs) {
-      if (existsSync(dir)) {
-        rmSync(dir, { recursive: true, force: true });
-      }
-    }
-  }
-
-  report();
-}
-
-main();