gsd-pi 2.80.0-dev.c5f2443b3 → 2.80.0-dev.d4fc28e6b

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

@@ -0,0 +1,428 @@
+// gsd-2 (GSD2) + db migration `:memory:` integration tests
+//
+// Covers the gap left by the FakeAdapter unit tests for the gsd-db split
+// (PR #5308): those assert SQL strings, not that DDL actually executes.
+// These tests open a real node:sqlite `:memory:` database, run the schema
+// helpers, and verify the resulting schema via PRAGMA introspection.
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { createRequire } from "node:module";
+
+import { createDbAdapter, type DbAdapter } from "../db-adapter.ts";
+import { createBaseSchemaObjects } from "../db-base-schema.ts";
+import { columnExists } from "../db-schema-metadata.ts";
+import {
+  applyMigrationV2Artifacts,
+  applyMigrationV3Memories,
+  applyMigrationV4DecisionMadeBy,
+  applyMigrationV5HierarchyTables,
+  applyMigrationV6SliceSummaries,
+  applyMigrationV7Dependencies,
+  applyMigrationV8PlanningFields,
+  applyMigrationV9Ordering,
+  applyMigrationV10ReplanTrigger,
+  applyMigrationV11TaskPlanning,
+  applyMigrationV12QualityGates,
+  applyMigrationV13HotPathIndexes,
+  applyMigrationV22QualityGateRepair,
+} from "../db-migration-steps.ts";
+
+const _require = createRequire(import.meta.url);
+
+interface ColumnInfo {
+  name: string;
+  type: string;
+  notnull: number;
+  dflt_value: unknown;
+  pk: number;
+}
+
+function openMemoryAdapter(): { adapter: DbAdapter; close: () => void } {
+  const sqlite = _require("node:sqlite") as { DatabaseSync: new (path: string) => unknown };
+  const raw = new sqlite.DatabaseSync(":memory:");
+  const adapter = createDbAdapter(raw);
+  return {
+    adapter,
+    close: () => adapter.close(),
+  };
+}
+
+function tableInfo(db: DbAdapter, table: string): ColumnInfo[] {
+  return db.prepare(`PRAGMA table_info(${table})`).all() as unknown as ColumnInfo[];
+}
+
+function columnNames(db: DbAdapter, table: string): string[] {
+  return tableInfo(db, table).map((c) => c.name);
+}
+
+function tableExists(db: DbAdapter, table: string): boolean {
+  return !!db
+    .prepare("SELECT 1 as present FROM sqlite_master WHERE type='table' AND name=?")
+    .get(table);
+}
+
+function indexExists(db: DbAdapter, name: string): boolean {
+  return !!db
+    .prepare("SELECT 1 as present FROM sqlite_master WHERE type='index' AND name=?")
+    .get(name);
+}
+
+function viewExists(db: DbAdapter, name: string): boolean {
+  return !!db
+    .prepare("SELECT 1 as present FROM sqlite_master WHERE type='view' AND name=?")
+    .get(name);
+}
+
+describe("db base schema bring-up against :memory: sqlite", () => {
+  test("createBaseSchemaObjects executes all DDL without throwing", () => {
+    const { adapter, close } = openMemoryAdapter();
+    try {
+      assert.doesNotThrow(() => {
+        createBaseSchemaObjects(adapter, {
+          tryCreateMemoriesFts: () => true,
+          ensureVerificationEvidenceDedupIndex: () => {},
+        });
+      });
+    } finally {
+      close();
+    }
+  });
+
+  test("base schema produces all expected tables, indexes, and views", () => {
+    const { adapter, close } = openMemoryAdapter();
+    try {
+      createBaseSchemaObjects(adapter, {
+        tryCreateMemoriesFts: () => true,
+        ensureVerificationEvidenceDedupIndex: () => {},
+      });
+
+      const expectedTables = [
+        "schema_version",
+        "decisions",
+        "requirements",
+        "artifacts",
+        "memories",
+        "memory_processed_units",
+        "memory_sources",
+        "memory_embeddings",
+        "memory_relations",
+        "milestones",
+        "slices",
+        "tasks",
+        "verification_evidence",
+        "replan_history",
+        "assessments",
+        "quality_gates",
+        "slice_dependencies",
+        "gate_runs",
+        "turn_git_transactions",
+        "audit_events",
+        "audit_turn_index",
+      ];
+      for (const t of expectedTables) {
+        assert.ok(tableExists(adapter, t), `expected table ${t} to exist`);
+      }
+
+      const expectedIndexes = [
+        "idx_memories_active",
+        "idx_replan_history_milestone",
+        "idx_tasks_active",
+        "idx_slices_active",
+        "idx_milestones_status",
+        "idx_quality_gates_pending",
+        "idx_verification_evidence_task",
+        "idx_slice_deps_target",
+        "idx_gate_runs_turn",
+        "idx_gate_runs_lookup",
+        "idx_turn_git_tx_turn",
+        "idx_audit_events_trace",
+        "idx_audit_events_turn",
+      ];
+      for (const i of expectedIndexes) {
+        assert.ok(indexExists(adapter, i), `expected index ${i}`);
+      }
+
+      for (const v of ["active_decisions", "active_requirements", "active_memories"]) {
+        assert.ok(viewExists(adapter, v), `expected view ${v}`);
+      }
+    } finally {
+      close();
+    }
+  });
+
+  test("base schema decisions table has the documented column shape", () => {
+    const { adapter, close } = openMemoryAdapter();
+    try {
+      createBaseSchemaObjects(adapter, {
+        tryCreateMemoriesFts: () => true,
+        ensureVerificationEvidenceDedupIndex: () => {},
+      });
+
+      const cols = tableInfo(adapter, "decisions");
+      const byName = new Map(cols.map((c) => [c.name, c]));
+
+      const seq = byName.get("seq");
+      assert.ok(seq, "decisions.seq column missing");
+      assert.equal(seq!.type, "INTEGER");
+      assert.equal(seq!.pk, 1, "seq should be primary key");
+
+      const id = byName.get("id");
+      assert.ok(id);
+      assert.equal(id!.type, "TEXT");
+      assert.equal(id!.notnull, 1);
+
+      const madeBy = byName.get("made_by");
+      assert.ok(madeBy, "decisions.made_by missing (V4 migration column)");
+      assert.equal(madeBy!.notnull, 1);
+
+      const source = byName.get("source");
+      assert.ok(source, "decisions.source missing (V16 migration column)");
+      assert.equal(source!.notnull, 1);
+    } finally {
+      close();
+    }
+  });
+
+  test("base schema tasks table promotes composite primary key correctly", () => {
+    const { adapter, close } = openMemoryAdapter();
+    try {
+      createBaseSchemaObjects(adapter, {
+        tryCreateMemoriesFts: () => true,
+        ensureVerificationEvidenceDedupIndex: () => {},
+      });
+
+      const cols = tableInfo(adapter, "tasks");
+      const pkCols = cols.filter((c) => c.pk > 0).sort((a, b) => a.pk - b.pk).map((c) => c.name);
+      assert.deepEqual(pkCols, ["milestone_id", "slice_id", "id"]);
+    } finally {
+      close();
+    }
+  });
+});
+
+describe("db migration steps end-to-end against :memory: sqlite", () => {
+  // Drive a fresh DB from V1 baseline up to V13 so each high-risk migration
+  // sees a realistic schema (not the FakeAdapter no-op surface).
+  function runUpToV13(adapter: DbAdapter): void {
+    adapter.exec(`
+      CREATE TABLE schema_version (
+        version INTEGER NOT NULL,
+        applied_at TEXT NOT NULL
+      )
+    `);
+    adapter.exec(`
+      CREATE TABLE decisions (
+        seq INTEGER PRIMARY KEY AUTOINCREMENT,
+        id TEXT NOT NULL UNIQUE,
+        when_context TEXT NOT NULL DEFAULT '',
+        scope TEXT NOT NULL DEFAULT '',
+        decision TEXT NOT NULL DEFAULT '',
+        choice TEXT NOT NULL DEFAULT '',
+        rationale TEXT NOT NULL DEFAULT '',
+        revisable TEXT NOT NULL DEFAULT '',
+        superseded_by TEXT DEFAULT NULL
+      )
+    `);
+    adapter.exec(`
+      CREATE TABLE requirements (
+        id TEXT PRIMARY KEY,
+        class TEXT NOT NULL DEFAULT '',
+        status TEXT NOT NULL DEFAULT '',
+        description TEXT NOT NULL DEFAULT '',
+        why TEXT NOT NULL DEFAULT '',
+        source TEXT NOT NULL DEFAULT '',
+        primary_owner TEXT NOT NULL DEFAULT '',
+        supporting_slices TEXT NOT NULL DEFAULT '',
+        validation TEXT NOT NULL DEFAULT '',
+        notes TEXT NOT NULL DEFAULT '',
+        full_content TEXT NOT NULL DEFAULT '',
+        superseded_by TEXT DEFAULT NULL
+      )
+    `);
+    adapter.exec("CREATE VIEW active_decisions AS SELECT * FROM decisions WHERE superseded_by IS NULL");
+    adapter.exec("CREATE VIEW active_requirements AS SELECT * FROM requirements WHERE superseded_by IS NULL");
+
+    applyMigrationV2Artifacts(adapter);
+    applyMigrationV3Memories(adapter);
+    applyMigrationV4DecisionMadeBy(adapter);
+    applyMigrationV5HierarchyTables(adapter);
+    applyMigrationV6SliceSummaries(adapter);
+    applyMigrationV7Dependencies(adapter);
+    applyMigrationV8PlanningFields(adapter);
+    applyMigrationV9Ordering(adapter);
+    applyMigrationV10ReplanTrigger(adapter);
+    applyMigrationV11TaskPlanning(adapter);
+    applyMigrationV12QualityGates(adapter);
+    applyMigrationV13HotPathIndexes(adapter, () => {});
+  }
+
+  test("V8 PlanningFields adds every promised ALTER column without throwing", () => {
+    const { adapter, close } = openMemoryAdapter();
+    try {
+      runUpToV13(adapter);
+
+      assert.ok(columnExists(adapter, "milestones", "vision"));
+      assert.ok(columnExists(adapter, "milestones", "verification_uat"));
+      assert.ok(columnExists(adapter, "milestones", "definition_of_done"));
+      assert.ok(columnExists(adapter, "milestones", "boundary_map_markdown"));
+
+      assert.ok(columnExists(adapter, "slices", "goal"));
+      assert.ok(columnExists(adapter, "slices", "proof_level"));
+      assert.ok(columnExists(adapter, "slices", "observability_impact"));
+
+      assert.ok(columnExists(adapter, "tasks", "estimate"));
+      assert.ok(columnExists(adapter, "tasks", "files"));
+      assert.ok(columnExists(adapter, "tasks", "expected_output"));
+
+      assert.ok(tableExists(adapter, "replan_history"));
+      assert.ok(tableExists(adapter, "assessments"));
+    } finally {
+      close();
+    }
+  });
+
+  test("V13 HotPathIndexes succeeds when prior migrations have run (ordering)", () => {
+    const { adapter, close } = openMemoryAdapter();
+    try {
+      runUpToV13(adapter);
+
+      for (const i of [
+        "idx_tasks_active",
+        "idx_slices_active",
+        "idx_milestones_status",
+        "idx_quality_gates_pending",
+        "idx_verification_evidence_task",
+      ]) {
+        assert.ok(indexExists(adapter, i), `expected index ${i} after V13`);
+      }
+    } finally {
+      close();
+    }
+  });
+
+  test("V13 HotPathIndexes throws if quality_gates table does not yet exist (ordering guard)", () => {
+    const { adapter, close } = openMemoryAdapter();
+    try {
+      adapter.exec("CREATE TABLE schema_version (version INTEGER NOT NULL, applied_at TEXT NOT NULL)");
+      assert.throws(
+        () => applyMigrationV13HotPathIndexes(adapter, () => {}),
+        /no such table/i,
+      );
+    } finally {
+      close();
+    }
+  });
+
+  test("V22 QualityGateRepair rebuilds quality_gates with task_id NOT NULL and preserves indexes", () => {
+    const { adapter, close } = openMemoryAdapter();
+    try {
+      runUpToV13(adapter);
+
+      adapter.exec("DROP INDEX IF EXISTS idx_quality_gates_pending");
+      adapter.exec("DROP TABLE quality_gates");
+      adapter.exec(`
+        CREATE TABLE quality_gates (
+          milestone_id TEXT NOT NULL,
+          slice_id TEXT NOT NULL,
+          gate_id TEXT NOT NULL,
+          task_id TEXT DEFAULT '',
+          status TEXT NOT NULL DEFAULT 'pending',
+          verdict TEXT NOT NULL DEFAULT '',
+          rationale TEXT NOT NULL DEFAULT '',
+          findings TEXT NOT NULL DEFAULT '',
+          evaluated_at TEXT DEFAULT NULL,
+          PRIMARY KEY (milestone_id, slice_id, gate_id, task_id),
+          FOREIGN KEY (milestone_id, slice_id) REFERENCES slices(milestone_id, id)
+        )
+      `);
+
+      const before = tableInfo(adapter, "quality_gates").find((c) => c.name === "task_id");
+      assert.ok(before);
+      assert.equal(before!.notnull, 0, "pre-repair fixture should have nullable task_id");
+
+      let copyCalled = 0;
+      applyMigrationV22QualityGateRepair(adapter, {
+        copyQualityGateRowsToRepairedTable: () => {
+          copyCalled += 1;
+        },
+      });
+
+      assert.equal(copyCalled, 1, "repair branch should invoke the row-copy hook exactly once");
+
+      const after = tableInfo(adapter, "quality_gates").find((c) => c.name === "task_id");
+      assert.ok(after);
+      assert.equal(after!.notnull, 1, "post-repair task_id must be NOT NULL");
+
+      assert.ok(columnExists(adapter, "quality_gates", "scope"));
+      assert.ok(columnExists(adapter, "assessments", "scope"));
+
+      assert.ok(indexExists(adapter, "idx_quality_gates_pending"));
+
+      assert.equal(tableExists(adapter, "quality_gates_new"), false);
+
+      assert.deepEqual(columnNames(adapter, "quality_gates"), [
+        "milestone_id",
+        "slice_id",
+        "gate_id",
+        "scope",
+        "task_id",
+        "status",
+        "verdict",
+        "rationale",
+        "findings",
+        "evaluated_at",
+      ]);
+    } finally {
+      close();
+    }
+  });
+
+  test("V22 is a no-op on already-repaired quality_gates", () => {
+    const { adapter, close } = openMemoryAdapter();
+    try {
+      runUpToV13(adapter);
+
+      let copyCalled = 0;
+      applyMigrationV22QualityGateRepair(adapter, {
+        copyQualityGateRowsToRepairedTable: () => {
+          copyCalled += 1;
+        },
+      });
+
+      assert.equal(copyCalled, 0, "no-op when task_id is already NOT NULL");
+      assert.ok(columnExists(adapter, "quality_gates", "scope"));
+    } finally {
+      close();
+    }
+  });
+});
+
+describe("db provider happy path against :memory: sqlite", () => {
+  test("createDbAdapter wraps node:sqlite and supports exec/prepare/close", () => {
+    const sqlite = _require("node:sqlite") as { DatabaseSync: new (path: string) => unknown };
+    const raw = new sqlite.DatabaseSync(":memory:");
+    const adapter = createDbAdapter(raw);
+
+    assert.doesNotThrow(() => adapter.exec("CREATE TABLE t (id INTEGER PRIMARY KEY, v TEXT)"));
+
+    const insert = adapter.prepare("INSERT INTO t (id, v) VALUES (?, ?)");
+    insert.run(1, "alpha");
+    insert.run(2, "beta");
+
+    const selectOne = adapter.prepare("SELECT v FROM t WHERE id = ?");
+    const row = selectOne.get(1);
+    assert.deepEqual(row, { v: "alpha" });
+
+    const selectAll = adapter.prepare("SELECT id, v FROM t ORDER BY id");
+    const rows = selectAll.all();
+    assert.equal(rows.length, 2);
+    assert.equal(rows[0]["v"], "alpha");
+    assert.equal(rows[1]["v"], "beta");
+
+    const selectAgain = adapter.prepare("SELECT v FROM t WHERE id = ?");
+    assert.deepEqual(selectAgain.get(2), { v: "beta" });
+
+    assert.doesNotThrow(() => adapter.close());
+  });
+});

package/src/resources/extensions/gsd/tests/db-schema-metadata.test.ts

@@ -106,10 +106,10 @@ describe("db-schema-metadata", () => {
   test("records schema version rows with timestamps", () => {
     const db = new FakeAdapter();
 
-    recordSchemaVersion(db, 25);
+    recordSchemaVersion(db, 26);
 
     assert.equal(db.runCalls.length, 1);
-    assert.equal((db.runCalls[0][0] as Record<string, unknown>)[":version"], 25);
+    assert.equal((db.runCalls[0][0] as Record<string, unknown>)[":version"], 26);
     assert.equal(typeof (db.runCalls[0][0] as Record<string, unknown>)[":applied_at"], "string");
   });
 });

package/src/resources/extensions/gsd/tests/detection.test.ts

@@ -11,12 +11,14 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 import { mkdirSync, writeFileSync, rmSync, existsSync } from "node:fs";
+import { execFileSync } from "node:child_process";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import {
   detectProjectState,
   detectV1Planning,
   detectProjectSignals,
+  classifyProject,
   scanProjectFiles,
 } from "../detection.ts";
 
@@ -37,6 +39,18 @@ function cleanup(dir: string): void {
   }
 }
 
+function git(dir: string, args: string[]): void {
+  execFileSync("git", args, { cwd: dir, stdio: "ignore" });
+}
+
+function makeGitRepo(prefix: string): string {
+  const dir = makeTempDir(prefix);
+  git(dir, ["init"]);
+  git(dir, ["config", "user.email", "test@example.com"]);
+  git(dir, ["config", "user.name", "Test User"]);
+  return dir;
+}
+
 // ─── detectProjectState ─────────────────────────────────────────────────────────
 
 test("detectProjectState: empty directory returns state=none", (t) => {
@@ -49,6 +63,132 @@ test("detectProjectState: empty directory returns state=none", (t) => {
   assert.equal(result.v2, undefined);
 });
 
+test("classifyProject: no git repo is invalid", (t) => {
+  const dir = makeTempDir("classify-invalid");
+  t.after(() => cleanup(dir));
+
+  const classification = classifyProject(dir);
+  assert.equal(classification.kind, "invalid-repo");
+});
+
+test("classifyProject: empty git repo is greenfield", (t) => {
+  const dir = makeGitRepo("classify-greenfield");
+  t.after(() => cleanup(dir));
+
+  const classification = classifyProject(dir);
+  assert.equal(classification.kind, "greenfield");
+});
+
+test("classifyProject: nested empty git repo does not inherit ancestor markers", (t) => {
+  const parent = makeGitRepo("classify-parent-marker");
+  t.after(() => cleanup(parent));
+
+  writeFileSync(join(parent, "package.json"), JSON.stringify({ name: "parent" }), "utf-8");
+  git(parent, ["add", "package.json"]);
+  git(parent, ["commit", "-m", "add parent marker"]);
+  const child = join(parent, "nested");
+  mkdirSync(child, { recursive: true });
+  git(child, ["init"]);
+  git(child, ["config", "user.email", "test@example.com"]);
+  git(child, ["config", "user.name", "Test User"]);
+
+  const classification = classifyProject(child);
+  assert.equal(classification.kind, "greenfield");
+});
+
+test("classifyProject: tracked static HTML is existing untyped content", (t) => {
+  const dir = makeGitRepo("classify-index");
+  t.after(() => cleanup(dir));
+
+  writeFileSync(join(dir, "index.html"), "<main></main>\n", "utf-8");
+  git(dir, ["add", "index.html"]);
+  git(dir, ["commit", "-m", "add static page"]);
+
+  const classification = classifyProject(dir);
+  assert.equal(classification.kind, "untyped-existing");
+  assert.deepEqual(classification.contentFiles, ["index.html"]);
+});
+
+test("classifyProject: README-only repo is existing untyped content", (t) => {
+  const dir = makeGitRepo("classify-readme");
+  t.after(() => cleanup(dir));
+
+  writeFileSync(join(dir, "README.md"), "# docs\n", "utf-8");
+  git(dir, ["add", "README.md"]);
+  git(dir, ["commit", "-m", "add docs"]);
+
+  const classification = classifyProject(dir);
+  assert.equal(classification.kind, "untyped-existing");
+});
+
+test("classifyProject: src-only content is untyped existing, not typed marker", (t) => {
+  const dir = makeGitRepo("classify-src-only");
+  t.after(() => cleanup(dir));
+
+  mkdirSync(join(dir, "src"), { recursive: true });
+  writeFileSync(join(dir, "src", "index.txt"), "content\n", "utf-8");
+  git(dir, ["add", "src/index.txt"]);
+  git(dir, ["commit", "-m", "add source content"]);
+
+  const classification = classifyProject(dir);
+  assert.equal(classification.kind, "untyped-existing");
+  assert.deepEqual(classification.contentFiles, ["src/index.txt"]);
+});
+
+test("classifyProject: nested untracked files count as project content", (t) => {
+  const dir = makeGitRepo("classify-untracked-nested");
+  t.after(() => cleanup(dir));
+
+  mkdirSync(join(dir, "docs"), { recursive: true });
+  writeFileSync(join(dir, "docs", "index.html"), "<main></main>\n", "utf-8");
+
+  const classification = classifyProject(dir);
+  assert.equal(classification.kind, "untyped-existing");
+  assert.deepEqual(classification.untrackedFiles, ["docs/index.html"]);
+});
+
+test("classifyProject: known markers produce typed existing project", (t) => {
+  const dir = makeGitRepo("classify-typed");
+  t.after(() => cleanup(dir));
+
+  writeFileSync(join(dir, "package.json"), JSON.stringify({ name: "typed" }), "utf-8");
+  git(dir, ["add", "package.json"]);
+  git(dir, ["commit", "-m", "add package"]);
+
+  const classification = classifyProject(dir);
+  assert.equal(classification.kind, "typed-existing");
+  assert.ok(classification.markers.includes("package.json"));
+});
+
+test("classifyProject: ignored build/cache-only files do not count as content", (t) => {
+  const dir = makeGitRepo("classify-ignored");
+  t.after(() => cleanup(dir));
+
+  writeFileSync(join(dir, ".gitignore"), "dist/\n.cache/\n", "utf-8");
+  git(dir, ["add", ".gitignore"]);
+  git(dir, ["commit", "-m", "ignore generated files"]);
+  mkdirSync(join(dir, "dist"), { recursive: true });
+  writeFileSync(join(dir, "dist", "bundle.js"), "generated\n", "utf-8");
+  mkdirSync(join(dir, ".cache"), { recursive: true });
+  writeFileSync(join(dir, ".cache", "x"), "cache\n", "utf-8");
+
+  const classification = classifyProject(dir);
+  assert.equal(classification.kind, "greenfield");
+});
+
+test("classifyProject: generated framework/cache dirs do not count as content", (t) => {
+  const dir = makeGitRepo("classify-generated-dirs");
+  t.after(() => cleanup(dir));
+
+  mkdirSync(join(dir, ".next", "server"), { recursive: true });
+  writeFileSync(join(dir, ".next", "server", "page.js"), "generated\n", "utf-8");
+  mkdirSync(join(dir, ".venv", "lib"), { recursive: true });
+  writeFileSync(join(dir, ".venv", "lib", "site.py"), "generated\n", "utf-8");
+
+  const classification = classifyProject(dir);
+  assert.equal(classification.kind, "greenfield");
+});
+
 test("detectProjectState: directory with .gsd/milestones/M001 returns v2-gsd", (t) => {
   const dir = makeTempDir("v2-gsd");
   t.after(() => cleanup(dir));