gsd-pi 2.29.0-dev.953d788 → 2.29.0-dev.f08b4fe

package/dist/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();

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();