gsd-pi 2.43.0-next.8 → 2.44.0-dev.0b97ffd

package/src/resources/extensions/gsd/tests/quick-branch-lifecycle.test.ts

@@ -7,17 +7,16 @@
  * Relates to #1269, #1293.
  */
 
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
 import { mkdtempSync, mkdirSync, rmSync, writeFileSync, existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
 
-import { createTestContext } from './test-helpers.ts';
 import { captureIntegrationBranch, getCurrentBranch } from "../worktree.ts";
 import { readIntegrationBranch, QUICK_BRANCH_RE } from "../git-service.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();
 }
@@ -35,68 +34,59 @@ function createTestRepo(): string {
   return repo;
 }
 
-async function main(): Promise<void> {
-
   // ═══════════════════════════════════════════════════════════════════════
   // QUICK_BRANCH_RE
   // ═══════════════════════════════════════════════════════════════════════
 
-  console.log("\n=== QUICK_BRANCH_RE: matches quick-task branches ===");
 
-  assertTrue(QUICK_BRANCH_RE.test("gsd/quick/1-fix-typo"), "matches standard quick branch");
-  assertTrue(QUICK_BRANCH_RE.test("gsd/quick/42-some-long-slug-name"), "matches multi-digit quick branch");
-  assertTrue(!QUICK_BRANCH_RE.test("main"), "rejects main");
-  assertTrue(!QUICK_BRANCH_RE.test("gsd/M001/S01"), "rejects slice branch");
-  assertTrue(!QUICK_BRANCH_RE.test("gsd/quickly-something"), "rejects non-quick prefix");
-  assertTrue(!QUICK_BRANCH_RE.test("feature/gsd/quick/1"), "rejects nested prefix");
+describe('quick-branch-lifecycle', () => {
+test('QUICK_BRANCH_RE: matches quick-task branches', () => {
+  assert.ok(QUICK_BRANCH_RE.test("gsd/quick/1-fix-typo"), "matches standard quick branch");
+});
 
+  assert.ok(QUICK_BRANCH_RE.test("gsd/quick/42-some-long-slug-name"), "matches multi-digit quick branch");
+  assert.ok(!QUICK_BRANCH_RE.test("main"), "rejects main");
+  assert.ok(!QUICK_BRANCH_RE.test("gsd/M001/S01"), "rejects slice branch");
+  assert.ok(!QUICK_BRANCH_RE.test("gsd/quickly-something"), "rejects non-quick prefix");
+  assert.ok(!QUICK_BRANCH_RE.test("feature/gsd/quick/1"), "rejects nested prefix");
   // ═══════════════════════════════════════════════════════════════════════
   // captureIntegrationBranch: guard against quick-task branches
   // ═══════════════════════════════════════════════════════════════════════
-
-  console.log("\n=== captureIntegrationBranch: skips quick-task branches ===");
-
-  {
+test('captureIntegrationBranch: skips quick-task branches', () => {
     const repo = createTestRepo();
 
     // Create and checkout a quick-task branch
     run("git checkout -b gsd/quick/1-fix-typo", repo);
-    assertEq(getCurrentBranch(repo), "gsd/quick/1-fix-typo", "on quick branch");
+    assert.deepStrictEqual(getCurrentBranch(repo), "gsd/quick/1-fix-typo", "on quick branch");
 
     captureIntegrationBranch(repo, "M001");
 
-    assertEq(readIntegrationBranch(repo, "M001"), null,
+    assert.deepStrictEqual(readIntegrationBranch(repo, "M001"), null,
       "captureIntegrationBranch is a no-op on quick-task branches");
 
     rmSync(repo, { recursive: true, force: true });
-  }
+});
 
   // ─── Verify main is still recorded correctly ─────────────────────────
-
-  console.log("\n=== captureIntegrationBranch: records main correctly ===");
-
-  {
+test('captureIntegrationBranch: records main correctly', () => {
     const repo = createTestRepo();
 
     // Capture from main — should work normally
     captureIntegrationBranch(repo, "M001");
-    assertEq(readIntegrationBranch(repo, "M001"), "main",
+    assert.deepStrictEqual(readIntegrationBranch(repo, "M001"), "main",
       "main is recorded as integration branch");
 
     // Switch to quick branch — capture should be no-op (doesn't overwrite main)
     run("git checkout -b gsd/quick/1-fix-typo", repo);
     captureIntegrationBranch(repo, "M001");
-    assertEq(readIntegrationBranch(repo, "M001"), "main",
+    assert.deepStrictEqual(readIntegrationBranch(repo, "M001"), "main",
       "quick branch does not overwrite existing integration branch");
 
     rmSync(repo, { recursive: true, force: true });
-  }
+});
 
   // ─── Sequence: main → quick → back to main → capture ────────────────
-
-  console.log("\n=== captureIntegrationBranch: correct after quick branch round-trip ===");
-
-  {
+test('captureIntegrationBranch: correct after quick branch round-trip', () => {
     const repo = createTestRepo();
 
     // Simulate quick-task lifecycle: branch off, do work, return to main
@@ -111,19 +101,16 @@ async function main(): Promise<void> {
 
     // Now capture — should get main, not the deleted quick branch
     captureIntegrationBranch(repo, "M002");
-    assertEq(readIntegrationBranch(repo, "M002"), "main",
+    assert.deepStrictEqual(readIntegrationBranch(repo, "M002"), "main",
       "after quick round-trip, main is captured correctly");
 
     rmSync(repo, { recursive: true, force: true });
-  }
+});
 
   // ═══════════════════════════════════════════════════════════════════════
   // cleanupQuickBranch: in-memory path (same session)
   // ═══════════════════════════════════════════════════════════════════════
-
-  console.log("\n=== cleanupQuickBranch: merges back and cleans up (same session) ===");
-
-  {
+test('cleanupQuickBranch: merges back and cleans up (same session)', async () => {
     const repo = createTestRepo();
     const origCwd = process.cwd();
 
@@ -155,30 +142,27 @@ async function main(): Promise<void> {
     const { cleanupQuickBranch } = await import("../quick.ts");
     const result = cleanupQuickBranch();
 
-    assertTrue(result, "cleanupQuickBranch returns true");
-    assertEq(getCurrentBranch(repo), "main", "back on main after cleanup");
+    assert.ok(result, "cleanupQuickBranch returns true");
+    assert.deepStrictEqual(getCurrentBranch(repo), "main", "back on main after cleanup");
 
     // Verify merge happened — fix.txt should exist on main
-    assertTrue(existsSync(join(repo, "fix.txt")), "fix.txt merged to main");
+    assert.ok(existsSync(join(repo, "fix.txt")), "fix.txt merged to main");
 
     // Verify quick branch deleted
     const branches = run("git branch", repo);
-    assertTrue(!branches.includes("gsd/quick/1-fix-typo"), "quick branch deleted");
+    assert.ok(!branches.includes("gsd/quick/1-fix-typo"), "quick branch deleted");
 
     // Verify disk state cleaned up
-    assertTrue(!existsSync(join(runtimeDir, "quick-return.json")), "quick-return.json removed");
+    assert.ok(!existsSync(join(runtimeDir, "quick-return.json")), "quick-return.json removed");
 
     process.chdir(origCwd);
     rmSync(repo, { recursive: true, force: true });
-  }
+});
 
   // ═══════════════════════════════════════════════════════════════════════
   // cleanupQuickBranch: cross-session recovery from disk
   // ═══════════════════════════════════════════════════════════════════════
-
-  console.log("\n=== cleanupQuickBranch: recovers from disk state (cross-session) ===");
-
-  {
+test('cleanupQuickBranch: recovers from disk state (cross-session)', async () => {
     const repo = createTestRepo();
     const origCwd = process.cwd();
 
@@ -206,22 +190,19 @@ async function main(): Promise<void> {
     const { cleanupQuickBranch } = await import("../quick.ts");
     const result = cleanupQuickBranch();
 
-    assertTrue(result, "cross-session recovery returns true");
-    assertEq(getCurrentBranch(repo), "main", "back on main after cross-session recovery");
-    assertTrue(existsSync(join(repo, "docs.md")), "docs.md merged to main");
-    assertTrue(!existsSync(join(runtimeDir, "quick-return.json")), "disk state cleaned up");
+    assert.ok(result, "cross-session recovery returns true");
+    assert.deepStrictEqual(getCurrentBranch(repo), "main", "back on main after cross-session recovery");
+    assert.ok(existsSync(join(repo, "docs.md")), "docs.md merged to main");
+    assert.ok(!existsSync(join(runtimeDir, "quick-return.json")), "disk state cleaned up");
 
     process.chdir(origCwd);
     rmSync(repo, { recursive: true, force: true });
-  }
+});
 
   // ═══════════════════════════════════════════════════════════════════════
   // cleanupQuickBranch: no-op when no pending state
   // ═══════════════════════════════════════════════════════════════════════
-
-  console.log("\n=== cleanupQuickBranch: no-op without pending state ===");
-
-  {
+test('cleanupQuickBranch: no-op without pending state', async () => {
     const repo = createTestRepo();
     const origCwd = process.cwd();
     process.chdir(repo);
@@ -229,32 +210,29 @@ async function main(): Promise<void> {
     const { cleanupQuickBranch } = await import("../quick.ts");
     const result = cleanupQuickBranch();
 
-    assertTrue(!result, "returns false when no pending state");
-    assertEq(getCurrentBranch(repo), "main", "stays on main");
+    assert.ok(!result, "returns false when no pending state");
+    assert.deepStrictEqual(getCurrentBranch(repo), "main", "stays on main");
 
     process.chdir(origCwd);
     rmSync(repo, { recursive: true, force: true });
-  }
+});
 
   // ═══════════════════════════════════════════════════════════════════════
   // End-to-end: quick branch does NOT contaminate integration branch
   // ═══════════════════════════════════════════════════════════════════════
-
-  console.log("\n=== E2E: quick branch does not contaminate integration branch ===");
-
-  {
+test('E2E: quick branch does not contaminate integration branch', () => {
     const repo = createTestRepo();
 
     // 1. Record main as integration branch for M001
     captureIntegrationBranch(repo, "M001");
-    assertEq(readIntegrationBranch(repo, "M001"), "main", "M001 integration = main");
+    assert.deepStrictEqual(readIntegrationBranch(repo, "M001"), "main", "M001 integration = main");
 
     // 2. Start a quick task (branch off)
     run("git checkout -b gsd/quick/1-fix-typo", repo);
 
     // 3. Try to capture integration branch for M002 while on quick branch
     captureIntegrationBranch(repo, "M002");
-    assertEq(readIntegrationBranch(repo, "M002"), null,
+    assert.deepStrictEqual(readIntegrationBranch(repo, "M002"), null,
       "M002 integration NOT recorded from quick branch");
 
     // 4. Return to main (simulate cleanupQuickBranch)
@@ -262,20 +240,14 @@ async function main(): Promise<void> {
 
     // 5. Now capture M002 from main — should work
     captureIntegrationBranch(repo, "M002");
-    assertEq(readIntegrationBranch(repo, "M002"), "main",
+    assert.deepStrictEqual(readIntegrationBranch(repo, "M002"), "main",
       "M002 integration = main after returning from quick branch");
 
     // 6. Verify M001 still intact
-    assertEq(readIntegrationBranch(repo, "M001"), "main",
+    assert.deepStrictEqual(readIntegrationBranch(repo, "M001"), "main",
       "M001 integration unchanged");
 
     rmSync(repo, { recursive: true, force: true });
-  }
-
-  report();
-}
+});
 
-main().catch((error) => {
-  console.error(error);
-  process.exit(1);
 });

package/src/resources/extensions/gsd/tests/reassess-prompt.test.ts

@@ -1,15 +1,14 @@
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
 import { readFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
-import { createTestContext } from './test-helpers.ts';
-
 // loadPrompt reads from ~/.gsd/agent/extensions/gsd/prompts/ (main checkout).
 // In a worktree the file may not exist there yet, so we resolve prompts
 // relative to this test file's location (the worktree copy).
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const worktreePromptsDir = join(__dirname, "..", "prompts");
 
-const { assertTrue, report } = createTestContext();
 /**
  * Load a prompt template from the worktree prompts directory
  * and apply variable substitution (mirrors loadPrompt logic).
@@ -27,11 +26,10 @@ function loadPromptFromWorktree(name: string, vars: Record<string, string> = {})
 // Tests
 // ═══════════════════════════════════════════════════════════════════════════
 
-async function main(): Promise<void> {
-
   // ─── reassess-roadmap prompt loads and substitutes ─────────────────────
-  console.log("\n=== reassess-roadmap prompt loads and substitutes ===");
-  {
+
+describe('reassess-prompt', () => {
+test('reassess-roadmap prompt loads and substitutes', () => {
     const testVars = {
       workingDirectory: "/tmp/test-project",
       milestoneId: "M099",
@@ -51,27 +49,26 @@ async function main(): Promise<void> {
       console.error(`  ERROR: loadPrompt threw: ${err}`);
     }
 
-    assertTrue(!threw, "loadPrompt does not throw for reassess-roadmap");
-    assertTrue(typeof result === "string" && result.length > 0, "loadPrompt returns a non-empty string");
+    assert.ok(!threw, "loadPrompt does not throw for reassess-roadmap");
+    assert.ok(typeof result === "string" && result.length > 0, "loadPrompt returns a non-empty string");
 
     // Verify all test variables were substituted into the output
-    assertTrue(result.includes("M099"), "prompt contains milestoneId 'M099'");
-    assertTrue(result.includes("S03"), "prompt contains completedSliceId 'S03'");
-    assertTrue(result.includes(".gsd/milestones/M099/slices/S03/S03-ASSESSMENT.md"), "prompt contains assessmentPath");
-    assertTrue(result.includes(".gsd/milestones/M099/M099-ROADMAP.md"), "prompt contains roadmapPath");
-    assertTrue(result.includes("--- test inlined context block ---"), "prompt contains inlinedContext");
+    assert.ok(result.includes("M099"), "prompt contains milestoneId 'M099'");
+    assert.ok(result.includes("S03"), "prompt contains completedSliceId 'S03'");
+    assert.ok(result.includes(".gsd/milestones/M099/slices/S03/S03-ASSESSMENT.md"), "prompt contains assessmentPath");
+    assert.ok(result.includes(".gsd/milestones/M099/M099-ROADMAP.md"), "prompt contains roadmapPath");
+    assert.ok(result.includes("--- test inlined context block ---"), "prompt contains inlinedContext");
 
     // Verify no un-substituted variables remain
-    assertTrue(!result.includes("{{milestoneId}}"), "no un-substituted {{milestoneId}}");
-    assertTrue(!result.includes("{{completedSliceId}}"), "no un-substituted {{completedSliceId}}");
-    assertTrue(!result.includes("{{assessmentPath}}"), "no un-substituted {{assessmentPath}}");
-    assertTrue(!result.includes("{{roadmapPath}}"), "no un-substituted {{roadmapPath}}");
-    assertTrue(!result.includes("{{inlinedContext}}"), "no un-substituted {{inlinedContext}}");
-  }
+    assert.ok(!result.includes("{{milestoneId}}"), "no un-substituted {{milestoneId}}");
+    assert.ok(!result.includes("{{completedSliceId}}"), "no un-substituted {{completedSliceId}}");
+    assert.ok(!result.includes("{{assessmentPath}}"), "no un-substituted {{assessmentPath}}");
+    assert.ok(!result.includes("{{roadmapPath}}"), "no un-substituted {{roadmapPath}}");
+    assert.ok(!result.includes("{{inlinedContext}}"), "no un-substituted {{inlinedContext}}");
+});
 
   // ─── reassess-roadmap contains coverage-check instruction ─────────────
-  console.log("\n=== reassess-roadmap contains coverage-check instruction ===");
-  {
+test('reassess-roadmap contains coverage-check instruction', () => {
     const prompt = loadPromptFromWorktree("reassess-roadmap", {
       workingDirectory: "/tmp/test-project",
       milestoneId: "M001",
@@ -85,33 +82,32 @@ async function main(): Promise<void> {
     const lower = prompt.toLowerCase();
 
     // The prompt must mention "each success criterion" or "every success criterion"
-    assertTrue(
+    assert.ok(
       lower.includes("each success criterion") || lower.includes("every success criterion"),
       "prompt contains 'each success criterion' or 'every success criterion'"
     );
 
     // The prompt must mention "owning slice" or "remaining slice"
-    assertTrue(
+    assert.ok(
       lower.includes("owning slice") || lower.includes("remaining slice"),
       "prompt contains 'owning slice' or 'remaining slice'"
     );
 
     // The prompt must mention "no remaining owner" or "no owner" or "no slice"
-    assertTrue(
+    assert.ok(
       lower.includes("no remaining owner") || lower.includes("no owner") || lower.includes("no slice"),
       "prompt contains 'no remaining owner', 'no owner', or 'no slice'"
     );
 
     // The prompt must mention "blocking issue" or "blocking"
-    assertTrue(
+    assert.ok(
       lower.includes("blocking issue") || lower.includes("blocking"),
       "prompt contains 'blocking issue' or 'blocking'"
     );
-  }
+});
 
   // ─── coverage-check requires at-least-one semantics ───────────────────
-  console.log("\n=== coverage-check requires at-least-one semantics ===");
-  {
+test('coverage-check requires at-least-one semantics', () => {
     const prompt = loadPromptFromWorktree("reassess-roadmap", {
       workingDirectory: "/tmp/test-project",
       milestoneId: "M001",
@@ -124,22 +120,16 @@ async function main(): Promise<void> {
     const lower = prompt.toLowerCase();
 
     // The instruction must use "at least one" or equivalent inclusive language
-    assertTrue(
+    assert.ok(
       lower.includes("at least one") || lower.includes("at-least-one") || lower.includes("one or more"),
       "prompt uses 'at least one' or equivalent inclusive language for slice ownership"
     );
 
     // The instruction must NOT require "exactly one" — that would be too rigid
-    assertTrue(
+    assert.ok(
       !lower.includes("exactly one owner") && !lower.includes("exactly one slice"),
       "prompt does NOT use 'exactly one' for slice ownership (would be too rigid)"
     );
-  }
-
-  report();
-}
+});
 
-main().catch((error) => {
-  console.error(error);
-  process.exit(1);
 });