gsd-pi 2.29.0-dev.2ccf3fb → 2.29.0-dev.4c155ee

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

@@ -1,442 +0,0 @@
-import { createTestContext } from './test-helpers.ts';
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import * as os from 'node:os';
-import {
-  openDatabase,
-  closeDatabase,
-  isDbAvailable,
-  insertDecision,
-  insertRequirement,
-  insertArtifact,
-  getDecisionById,
-  getRequirementById,
-  _getAdapter,
-  copyWorktreeDb,
-  reconcileWorktreeDb,
-} from '../gsd-db.ts';
-
-const { assertEq, assertTrue, report } = createTestContext();
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Helpers
-// ═══════════════════════════════════════════════════════════════════════════
-
-function tempDir(): string {
-  return fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-wt-test-'));
-}
-
-function cleanup(...dirs: string[]): void {
-  closeDatabase();
-  for (const dir of dirs) {
-    try {
-      fs.rmSync(dir, { recursive: true, force: true });
-    } catch {
-      // best effort
-    }
-  }
-}
-
-function seedMainDb(dbPath: string): void {
-  openDatabase(dbPath);
-  insertDecision({
-    id: 'D001',
-    when_context: '2025-01-01',
-    scope: 'M001/S01',
-    decision: 'Use SQLite',
-    choice: 'node:sqlite',
-    rationale: 'Built-in',
-    revisable: 'yes',
-    superseded_by: null,
-  });
-  insertRequirement({
-    id: 'R001',
-    class: 'functional',
-    status: 'active',
-    description: 'Must store decisions',
-    why: 'Core feature',
-    source: 'design',
-    primary_owner: 'S01',
-    supporting_slices: '',
-    validation: 'test',
-    notes: '',
-    full_content: 'Full requirement text',
-    superseded_by: null,
-  });
-  insertArtifact({
-    path: 'docs/arch.md',
-    artifact_type: 'plan',
-    milestone_id: 'M001',
-    slice_id: null,
-    task_id: null,
-    full_content: 'Architecture document',
-  });
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// copyWorktreeDb tests
-// ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n=== worktree-db: copyWorktreeDb ===');
-
-// Test: copies DB file and data is queryable
-{
-  const srcDir = tempDir();
-  const destDir = tempDir();
-  const srcDb = path.join(srcDir, 'gsd.db');
-  const destDb = path.join(destDir, 'nested', 'gsd.db');
-
-  seedMainDb(srcDb);
-  closeDatabase();
-
-  const result = copyWorktreeDb(srcDb, destDb);
-  assertTrue(result === true, 'copyWorktreeDb returns true on success');
-  assertTrue(fs.existsSync(destDb), 'dest DB file exists after copy');
-
-  // Open the copy and verify data is queryable
-  openDatabase(destDb);
-  const d = getDecisionById('D001');
-  assertTrue(d !== null, 'decision queryable in copied DB');
-  assertEq(d?.choice, 'node:sqlite', 'decision data preserved in copy');
-
-  const r = getRequirementById('R001');
-  assertTrue(r !== null, 'requirement queryable in copied DB');
-  assertEq(r?.description, 'Must store decisions', 'requirement data preserved in copy');
-
-  cleanup(srcDir, destDir);
-}
-
-// Test: skips -wal and -shm files
-{
-  const srcDir = tempDir();
-  const destDir = tempDir();
-  const srcDb = path.join(srcDir, 'gsd.db');
-  const destDb = path.join(destDir, 'gsd.db');
-
-  seedMainDb(srcDb);
-  closeDatabase();
-
-  // Create fake WAL/SHM files
-  fs.writeFileSync(srcDb + '-wal', 'fake wal data');
-  fs.writeFileSync(srcDb + '-shm', 'fake shm data');
-
-  copyWorktreeDb(srcDb, destDb);
-
-  assertTrue(fs.existsSync(destDb), 'DB file copied');
-  assertTrue(!fs.existsSync(destDb + '-wal'), 'WAL file NOT copied');
-  assertTrue(!fs.existsSync(destDb + '-shm'), 'SHM file NOT copied');
-
-  cleanup(srcDir, destDir);
-}
-
-// Test: returns false when source doesn't exist (no throw)
-{
-  const destDir = tempDir();
-  const result = copyWorktreeDb('/nonexistent/path/gsd.db', path.join(destDir, 'gsd.db'));
-  assertEq(result, false, 'returns false for missing source');
-  cleanup(destDir);
-}
-
-// Test: creates dest directory if needed
-{
-  const srcDir = tempDir();
-  const destDir = tempDir();
-  const srcDb = path.join(srcDir, 'gsd.db');
-  const deepDest = path.join(destDir, 'a', 'b', 'c', 'gsd.db');
-
-  seedMainDb(srcDb);
-  closeDatabase();
-
-  const result = copyWorktreeDb(srcDb, deepDest);
-  assertTrue(result === true, 'copyWorktreeDb succeeds with nested dest');
-  assertTrue(fs.existsSync(deepDest), 'DB file created at deeply nested path');
-
-  cleanup(srcDir, destDir);
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// reconcileWorktreeDb tests
-// ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n=== worktree-db: reconcileWorktreeDb ===');
-
-// Test: merges new decisions from worktree into main
-{
-  const mainDir = tempDir();
-  const wtDir = tempDir();
-  const mainDb = path.join(mainDir, 'gsd.db');
-  const wtDb = path.join(wtDir, 'gsd.db');
-
-  // Seed main with D001
-  seedMainDb(mainDb);
-  closeDatabase();
-
-  // Copy to worktree, add D002 in worktree
-  copyWorktreeDb(mainDb, wtDb);
-  openDatabase(wtDb);
-  insertDecision({
-    id: 'D002',
-    when_context: '2025-02-01',
-    scope: 'M001/S02',
-    decision: 'Use WAL mode',
-    choice: 'WAL',
-    rationale: 'Performance',
-    revisable: 'yes',
-    superseded_by: null,
-  });
-  closeDatabase();
-
-  // Re-open main and reconcile
-  openDatabase(mainDb);
-  const result = reconcileWorktreeDb(mainDb, wtDb);
-
-  assertTrue(result.decisions > 0, 'decisions merged count > 0');
-  const d2 = getDecisionById('D002');
-  assertTrue(d2 !== null, 'D002 from worktree now in main');
-  assertEq(d2?.choice, 'WAL', 'D002 data correct after merge');
-
-  cleanup(mainDir, wtDir);
-}
-
-// Test: merges new requirements from worktree into main
-{
-  const mainDir = tempDir();
-  const wtDir = tempDir();
-  const mainDb = path.join(mainDir, 'gsd.db');
-  const wtDb = path.join(wtDir, 'gsd.db');
-
-  seedMainDb(mainDb);
-  closeDatabase();
-  copyWorktreeDb(mainDb, wtDb);
-
-  openDatabase(wtDb);
-  insertRequirement({
-    id: 'R002',
-    class: 'non-functional',
-    status: 'active',
-    description: 'Must be fast',
-    why: 'UX',
-    source: 'design',
-    primary_owner: 'S02',
-    supporting_slices: '',
-    validation: 'benchmark',
-    notes: '',
-    full_content: 'Performance requirement',
-    superseded_by: null,
-  });
-  closeDatabase();
-
-  openDatabase(mainDb);
-  const result = reconcileWorktreeDb(mainDb, wtDb);
-
-  assertTrue(result.requirements > 0, 'requirements merged count > 0');
-  const r2 = getRequirementById('R002');
-  assertTrue(r2 !== null, 'R002 from worktree now in main');
-  assertEq(r2?.description, 'Must be fast', 'R002 data correct after merge');
-
-  cleanup(mainDir, wtDir);
-}
-
-// Test: merges new artifacts from worktree into main
-{
-  const mainDir = tempDir();
-  const wtDir = tempDir();
-  const mainDb = path.join(mainDir, 'gsd.db');
-  const wtDb = path.join(wtDir, 'gsd.db');
-
-  seedMainDb(mainDb);
-  closeDatabase();
-  copyWorktreeDb(mainDb, wtDb);
-
-  openDatabase(wtDb);
-  insertArtifact({
-    path: 'docs/api.md',
-    artifact_type: 'reference',
-    milestone_id: 'M001',
-    slice_id: 'S01',
-    task_id: 'T01',
-    full_content: 'API documentation',
-  });
-  closeDatabase();
-
-  openDatabase(mainDb);
-  const result = reconcileWorktreeDb(mainDb, wtDb);
-
-  assertTrue(result.artifacts > 0, 'artifacts merged count > 0');
-  const adapter = _getAdapter()!;
-  const row = adapter.prepare('SELECT * FROM artifacts WHERE path = ?').get('docs/api.md');
-  assertTrue(row !== null, 'artifact from worktree now in main');
-  assertEq(row?.['artifact_type'], 'reference', 'artifact data correct after merge');
-
-  cleanup(mainDir, wtDir);
-}
-
-// Test: detects conflicts (same PK, different content in both DBs)
-{
-  const mainDir = tempDir();
-  const wtDir = tempDir();
-  const mainDb = path.join(mainDir, 'gsd.db');
-  const wtDb = path.join(wtDir, 'gsd.db');
-
-  // Seed main with D001
-  seedMainDb(mainDb);
-  closeDatabase();
-  copyWorktreeDb(mainDb, wtDb);
-
-  // Modify D001 in main
-  openDatabase(mainDb);
-  const mainAdapter = _getAdapter()!;
-  mainAdapter.prepare(
-    `UPDATE decisions SET choice = 'better-sqlite3' WHERE id = 'D001'`,
-  ).run();
-  closeDatabase();
-
-  // Modify D001 in worktree differently
-  openDatabase(wtDb);
-  const wtAdapter = _getAdapter()!;
-  wtAdapter.prepare(
-    `UPDATE decisions SET choice = 'sql.js' WHERE id = 'D001'`,
-  ).run();
-  closeDatabase();
-
-  // Reconcile
-  openDatabase(mainDb);
-  const result = reconcileWorktreeDb(mainDb, wtDb);
-
-  assertTrue(result.conflicts.length > 0, 'conflicts detected');
-  assertTrue(
-    result.conflicts.some(c => c.includes('D001')),
-    'conflict mentions D001',
-  );
-
-  // Worktree-wins: D001 should now have worktree's value
-  const d1 = getDecisionById('D001');
-  assertEq(d1?.choice, 'sql.js', 'worktree wins on conflict (INSERT OR REPLACE)');
-
-  cleanup(mainDir, wtDir);
-}
-
-// Test: handles missing worktree DB gracefully
-{
-  const mainDir = tempDir();
-  const mainDb = path.join(mainDir, 'gsd.db');
-
-  seedMainDb(mainDb);
-
-  const result = reconcileWorktreeDb(mainDb, '/nonexistent/worktree.db');
-  assertEq(result.decisions, 0, 'no decisions merged for missing worktree DB');
-  assertEq(result.requirements, 0, 'no requirements merged for missing worktree DB');
-  assertEq(result.artifacts, 0, 'no artifacts merged for missing worktree DB');
-  assertEq(result.conflicts.length, 0, 'no conflicts for missing worktree DB');
-
-  cleanup(mainDir);
-}
-
-// Test: path with spaces works
-{
-  const baseDir = tempDir();
-  const mainDir = path.join(baseDir, 'main dir');
-  const wtDir = path.join(baseDir, 'worktree dir');
-  fs.mkdirSync(mainDir, { recursive: true });
-  fs.mkdirSync(wtDir, { recursive: true });
-
-  const mainDb = path.join(mainDir, 'gsd.db');
-  const wtDb = path.join(wtDir, 'gsd.db');
-
-  seedMainDb(mainDb);
-  closeDatabase();
-  copyWorktreeDb(mainDb, wtDb);
-
-  // Add a decision in worktree
-  openDatabase(wtDb);
-  insertDecision({
-    id: 'D003',
-    when_context: '2025-03-01',
-    scope: 'M001/S03',
-    decision: 'Path spaces test',
-    choice: 'yes',
-    rationale: 'Robustness',
-    revisable: 'no',
-    superseded_by: null,
-  });
-  closeDatabase();
-
-  openDatabase(mainDb);
-  const result = reconcileWorktreeDb(mainDb, wtDb);
-  assertTrue(result.decisions > 0, 'reconciliation works with spaces in path');
-  const d3 = getDecisionById('D003');
-  assertTrue(d3 !== null, 'D003 merged from worktree with spaces in path');
-
-  cleanup(baseDir);
-}
-
-// Test: main DB is usable after reconciliation (DETACH cleanup verified)
-{
-  const mainDir = tempDir();
-  const wtDir = tempDir();
-  const mainDb = path.join(mainDir, 'gsd.db');
-  const wtDb = path.join(wtDir, 'gsd.db');
-
-  seedMainDb(mainDb);
-  closeDatabase();
-  copyWorktreeDb(mainDb, wtDb);
-
-  openDatabase(mainDb);
-  reconcileWorktreeDb(mainDb, wtDb);
-
-  // Verify main DB is still fully usable after DETACH
-  assertTrue(isDbAvailable(), 'DB still available after reconciliation');
-
-  insertDecision({
-    id: 'D099',
-    when_context: '2025-12-01',
-    scope: 'test',
-    decision: 'Post-reconcile insert',
-    choice: 'works',
-    rationale: 'Verify DETACH cleanup',
-    revisable: 'no',
-    superseded_by: null,
-  });
-
-  const d99 = getDecisionById('D099');
-  assertTrue(d99 !== null, 'can insert and query after reconciliation');
-  assertEq(d99?.choice, 'works', 'post-reconcile data correct');
-
-  // Verify no "wt" database still attached
-  const adapter = _getAdapter()!;
-  let wtAccessible = false;
-  try {
-    adapter.prepare('SELECT count(*) FROM wt.decisions').get();
-    wtAccessible = true;
-  } catch {
-    // Expected — wt should be detached
-  }
-  assertTrue(!wtAccessible, 'wt database is detached after reconciliation');
-
-  cleanup(mainDir, wtDir);
-}
-
-// Test: reconcile with empty worktree DB (no new rows, no conflicts)
-{
-  const mainDir = tempDir();
-  const wtDir = tempDir();
-  const mainDb = path.join(mainDir, 'gsd.db');
-  const wtDb = path.join(wtDir, 'gsd.db');
-
-  seedMainDb(mainDb);
-  closeDatabase();
-  copyWorktreeDb(mainDb, wtDb);
-
-  // Don't modify the worktree DB at all — reconcile the identical copy
-  openDatabase(mainDb);
-  const result = reconcileWorktreeDb(mainDb, wtDb);
-
-  // Should still report counts for the existing rows (INSERT OR REPLACE touches them)
-  assertTrue(result.conflicts.length === 0, 'no conflicts when DBs are identical');
-  assertTrue(isDbAvailable(), 'DB usable after no-change reconciliation');
-
-  cleanup(mainDir, wtDir);
-}
-
-// ─── Final Report ──────────────────────────────────────────────────────────
-report();

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;
-}