gsd-pi 2.76.0-dev.4100bd590 → 2.76.0-dev.4c866b677

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

@@ -9,6 +9,7 @@ import {
   isDbAvailable,
   wasDbOpenAttempted,
   getDbProvider,
+  getDbStatus,
   insertDecision,
   getDecisionById,
   insertRequirement,
@@ -561,6 +562,92 @@ describe('gsd-db', () => {
     });
   });
 
+  // ─── getDbStatus ───────────────────────────────────────────────────────────
+
+  describe('getDbStatus', () => {
+    test('getDbStatus: initial state before any open', () => {
+      closeDatabase();
+      const status = getDbStatus();
+      assert.strictEqual(status.available, false, 'available false before open');
+      assert.strictEqual(status.attempted, false, 'attempted false before open');
+      assert.strictEqual(status.lastError, null, 'lastError null before open');
+      assert.strictEqual(status.lastPhase, null, 'lastPhase null before open');
+    });
+
+    test('getDbStatus: available after successful open', () => {
+      openDatabase(':memory:');
+      const status = getDbStatus();
+      assert.strictEqual(status.available, true, 'available true after open');
+      assert.strictEqual(status.attempted, true, 'attempted true after open');
+      assert.ok(status.provider !== null, 'provider set after open');
+      assert.strictEqual(status.lastError, null, 'lastError null on success');
+      assert.strictEqual(status.lastPhase, null, 'lastPhase null on success');
+      closeDatabase();
+    });
+
+    test('getDbStatus: resets lastError/lastPhase after closeDatabase', () => {
+      // Simulate a failed open to set error state
+      const corruptPath = path.join(os.tmpdir(), `gsd-corrupt-${Date.now()}.db`);
+      fs.writeFileSync(corruptPath, Buffer.from('not a sqlite file at all!!!!!'));
+      try {
+        openDatabase(corruptPath);
+      } catch {
+        // expected
+      }
+      assert.ok(getDbStatus().lastError !== null, 'lastError set after failed open');
+
+      // closeDatabase should clear it even though no DB was opened
+      closeDatabase();
+      const status = getDbStatus();
+      assert.strictEqual(status.lastError, null, 'lastError cleared by closeDatabase');
+      assert.strictEqual(status.lastPhase, null, 'lastPhase cleared by closeDatabase');
+      assert.strictEqual(status.attempted, false, 'attempted reset by closeDatabase');
+      fs.unlinkSync(corruptPath);
+    });
+
+    test('getDbStatus: captures open-phase error on corrupt file', () => {
+      closeDatabase();
+      const corruptPath = path.join(os.tmpdir(), `gsd-corrupt-${Date.now()}.db`);
+      fs.writeFileSync(corruptPath, Buffer.from('not a sqlite file at all!!!!!'));
+      try {
+        openDatabase(corruptPath);
+      } catch {
+        // expected — both providers should reject a non-SQLite file
+      }
+      const status = getDbStatus();
+      if (!status.available) {
+        // open failed (expected in most environments)
+        assert.strictEqual(status.attempted, true, 'attempted true after failed open');
+        // provider may reject at raw-open level ("open") or at SQL init level ("initSchema")
+        assert.ok(
+          status.lastPhase === 'open' || status.lastPhase === 'initSchema',
+          `lastPhase should be "open" or "initSchema", got: ${status.lastPhase}`,
+        );
+        assert.ok(status.lastError instanceof Error, 'lastError is an Error');
+      }
+      // If somehow it succeeded (unlikely with garbage content), that's also fine
+      closeDatabase();
+      try { fs.unlinkSync(corruptPath); } catch { /* best effort */ }
+    });
+
+    test('getDbStatus: error state resets on next successful open', () => {
+      closeDatabase();
+      const corruptPath = path.join(os.tmpdir(), `gsd-corrupt-${Date.now()}.db`);
+      fs.writeFileSync(corruptPath, Buffer.from('not a sqlite file at all!!!!!'));
+      try { openDatabase(corruptPath); } catch { /* expected */ }
+      assert.ok(!getDbStatus().available, 'DB unavailable after corrupt open');
+
+      // Now open a valid in-memory DB — error state should clear
+      openDatabase(':memory:');
+      const status = getDbStatus();
+      assert.strictEqual(status.available, true, 'available after valid open');
+      assert.strictEqual(status.lastError, null, 'lastError cleared on successful open');
+      assert.strictEqual(status.lastPhase, null, 'lastPhase cleared on successful open');
+      closeDatabase();
+      try { fs.unlinkSync(corruptPath); } catch { /* best effort */ }
+    });
+  });
+
   // ─── Final Report ──────────────────────────────────────────────────────────
 
 });

package/src/resources/extensions/gsd/tests/init-wizard.test.ts

@@ -178,6 +178,33 @@ test("init-wizard: multiple project files detected together", (t) => {
   }
 });
 
+// ─── Git init + initial commit regression (#4530) ───────────────────────────
+
+import { execFileSync } from "node:child_process";
+import { nativeInit, nativeAddAll, nativeCommit } from "../native-git-bridge.ts";
+
+test("init-wizard: nativeInit + nativeAddAll + nativeCommit produces a reachable HEAD (#4530)", (t) => {
+  // Regression: showProjectInit called nativeInit but never committed, leaving
+  // the branch unborn. git log and git worktree add both fail on zero-commit repos.
+  const dir = makeTempDir("git-init-commit");
+  t.after(() => { cleanup(dir); });
+
+  nativeInit(dir, "main");
+  execFileSync("git", ["config", "user.email", "test@test.com"], { cwd: dir });
+  execFileSync("git", ["config", "user.name", "Test"], { cwd: dir });
+  writeFileSync(join(dir, ".gitignore"), "*.log\n", "utf-8");
+
+  nativeAddAll(dir);
+  nativeCommit(dir, "chore: init project");
+
+  // git log must succeed (was: fatal: your current branch 'main' does not have any commits yet)
+  const subject = execFileSync("git", ["log", "-1", "--format=%s"], {
+    cwd: dir,
+    encoding: "utf-8",
+  }).trim();
+  assert.equal(subject, "chore: init project");
+});
+
 test("init-wizard: v1 with both .planning/ and .gsd/ prioritizes v2", (t) => {
   const dir = makeTempDir("both-v1-v2");
   try {

package/src/resources/extensions/gsd/tests/prompt-loader-extension-dir.test.ts

@@ -0,0 +1,49 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { join } from "node:path";
+
+import { resolveExtensionDirFromCandidates } from "../prompt-loader.ts";
+
+function makeExists(paths: Set<string>): (path: string) => boolean {
+  return (path: string) => paths.has(path);
+}
+
+test("resolveExtensionDirFromCandidates prefers user-local dir when both trees are valid", () => {
+  const moduleDir = "/npm/global/gsd";
+  const agentDir = "/home/user/.gsd/agent/extensions/gsd";
+  const paths = new Set<string>([
+    join(moduleDir, "prompts"),
+    join(moduleDir, "templates", "task-summary.md"),
+    join(agentDir, "prompts"),
+    join(agentDir, "templates", "task-summary.md"),
+  ]);
+
+  const resolved = resolveExtensionDirFromCandidates(moduleDir, agentDir, makeExists(paths));
+  assert.equal(resolved, agentDir);
+});
+
+test("resolveExtensionDirFromCandidates rejects module dir missing task-summary template", () => {
+  const moduleDir = "/npm/global/gsd";
+  const agentDir = "/home/user/.gsd/agent/extensions/gsd";
+  const paths = new Set<string>([
+    join(moduleDir, "prompts"),
+    // Missing module templates/task-summary.md on purpose.
+    join(agentDir, "prompts"),
+    join(agentDir, "templates", "task-summary.md"),
+  ]);
+
+  const resolved = resolveExtensionDirFromCandidates(moduleDir, agentDir, makeExists(paths));
+  assert.equal(resolved, agentDir);
+});
+
+test("resolveExtensionDirFromCandidates falls back to prompts-only dir when neither tree is fully valid", () => {
+  const moduleDir = "/npm/global/gsd";
+  const agentDir = "/home/user/.gsd/agent/extensions/gsd";
+  const paths = new Set<string>([
+    join(moduleDir, "prompts"),
+    // Neither side has templates/task-summary.md.
+  ]);
+
+  const resolved = resolveExtensionDirFromCandidates(moduleDir, agentDir, makeExists(paths));
+  assert.equal(resolved, moduleDir);
+});