gsd-pi 2.44.0 → 2.45.0-dev.1afbdaa

package/src/resources/extensions/gsd/tests/run-uat.test.ts

@@ -1,14 +1,5 @@
-// Tests for extractUatType — the core UAT classification primitive — plus
-// prompt template loading and dispatch precondition assertions (via
-// resolveSliceFile / extractUatType on real fixture files).
-//
-// Sections:
-//   (a)–(j)  extractUatType classification (17 assertions from T01)
-//   (k)      run-uat prompt template loading and content integrity (8 assertions)
-//   (l)      dispatch precondition assertions via resolveSliceFile (4 assertions)
-//   (m)      non-artifact UAT skip: human-experience UATs are not dispatched (1 assertion)
-//   (n)      stale replay guard: existing UAT-RESULT never re-dispatches (1 assertion)
-
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
 import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { tmpdir } from 'node:os';
@@ -17,11 +8,6 @@ import { fileURLToPath } from 'node:url';
 import { extractUatType } from '../files.ts';
 import { resolveSliceFile } from '../paths.ts';
 import { checkNeedsRunUat } from '../auto-prompts.ts';
-import { createTestContext } from './test-helpers.ts';
-
-// ─── Worktree-aware prompt loader ──────────────────────────────────────────
-// Resolves prompts relative to this test file so the worktree copy is used
-// instead of the main checkout copy (matches complete-milestone.test.ts pattern).
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const worktreePromptsDir = join(__dirname, '..', 'prompts');
@@ -39,10 +25,6 @@ function loadPromptFromWorktree(name: string, vars: Record<string, string> = {})
   return content.trim();
 }
 
-
-const { assertEq, assertTrue, report } = createTestContext();
-// ─── Fixture helpers ───────────────────────────────────────────────────────
-
 function createFixtureBase(): string {
   const base = mkdtempSync(join(tmpdir(), 'gsd-run-uat-test-'));
   mkdirSync(join(base, '.gsd', 'milestones'), { recursive: true });
@@ -69,154 +51,129 @@ function makeUatContent(mode: string): string {
   return `# UAT File\n\n## UAT Type\n\n- UAT mode: ${mode}\n- Some other bullet: value\n`;
 }
 
-// ═══════════════════════════════════════════════════════════════════════════
-// Tests
-// ═══════════════════════════════════════════════════════════════════════════
-
-async function main(): Promise<void> {
-
-  // ─── (a) artifact-driven ──────────────────────────────────────────────────
-  console.log('\n── (a) artifact-driven');
-
-  assertEq(
+describe('run-uat', () => {
+test('(a) artifact-driven', () => {
+  assert.deepStrictEqual(
     extractUatType(makeUatContent('artifact-driven')),
     'artifact-driven',
     'plain artifact-driven → artifact-driven',
   );
-
-  assertEq(
+  assert.deepStrictEqual(
     extractUatType('## UAT Type\n\n- UAT mode: artifact-driven\n'),
     'artifact-driven',
     'minimal content, artifact-driven',
   );
+});
 
-  // ─── (b) live-runtime ─────────────────────────────────────────────────────
-  console.log('\n── (b) live-runtime');
-
-  assertEq(
+test('(b) live-runtime', () => {
+  assert.deepStrictEqual(
     extractUatType(makeUatContent('live-runtime')),
     'live-runtime',
     'plain live-runtime → live-runtime',
   );
+});
 
-  // ─── (c) human-experience ─────────────────────────────────────────────────
-  console.log('\n── (c) human-experience');
-
-  assertEq(
+test('(c) human-experience', () => {
+  assert.deepStrictEqual(
     extractUatType(makeUatContent('human-experience')),
     'human-experience',
     'plain human-experience → human-experience',
   );
+});
 
-  // ─── (d) mixed standalone ─────────────────────────────────────────────────
-  console.log('\n── (d) mixed standalone');
-
-  assertEq(
+test('(d) mixed standalone', () => {
+  assert.deepStrictEqual(
     extractUatType(makeUatContent('mixed')),
     'mixed',
     'plain mixed → mixed',
   );
+});
 
-  // ─── (e) mixed with parenthetical ─────────────────────────────────────────
-  console.log('\n── (e) mixed parenthetical');
-
-  assertEq(
+test('(e) mixed parenthetical', () => {
+  assert.deepStrictEqual(
     extractUatType(makeUatContent('mixed (artifact-driven + live-runtime)')),
     'mixed',
     'mixed (artifact-driven + live-runtime) → mixed (leading keyword only)',
   );
-
-  assertEq(
+  assert.deepStrictEqual(
     extractUatType(makeUatContent('mixed (some other description)')),
     'mixed',
     'mixed with arbitrary parenthetical → mixed',
   );
+});
 
-  // ─── (f) missing ## UAT Type section ──────────────────────────────────────
-  console.log('\n── (f) missing UAT Type section');
-
-  assertEq(
+test('(f) missing UAT Type section', () => {
+  assert.deepStrictEqual(
     extractUatType('# UAT File\n\n## Overview\n\nSome content.\n'),
     undefined,
     'no ## UAT Type section → undefined',
   );
-
-  assertEq(
+  assert.deepStrictEqual(
     extractUatType(''),
     undefined,
     'empty content → undefined',
   );
+});
 
-  // ─── (g) ## UAT Type present but no UAT mode: bullet ─────────────────────
-  console.log('\n── (g) UAT Type section present, no UAT mode: bullet');
-
-  assertEq(
+test('(g) UAT Type section present, no UAT mode: bullet', () => {
+  assert.deepStrictEqual(
     extractUatType('## UAT Type\n\n- Some other bullet: value\n- Another bullet\n'),
     undefined,
     'section present but no UAT mode: bullet → undefined',
   );
-
-  assertEq(
+  assert.deepStrictEqual(
     extractUatType('## UAT Type\n\n'),
     undefined,
     'section present but empty → undefined',
   );
+});
 
-  // ─── (h) unknown keyword ──────────────────────────────────────────────────
-  console.log('\n── (h) unknown keyword');
-
-  assertEq(
+test('(h) unknown keyword', () => {
+  assert.deepStrictEqual(
     extractUatType(makeUatContent('automated')),
     undefined,
     'unknown keyword automated → undefined',
   );
-
-  assertEq(
+  assert.deepStrictEqual(
     extractUatType(makeUatContent('fully-automated')),
     undefined,
     'unknown keyword fully-automated → undefined',
   );
+});
 
-  // ─── (i) extra whitespace around value ────────────────────────────────────
-  console.log('\n── (i) extra whitespace');
-
-  assertEq(
+test('(i) extra whitespace', () => {
+  assert.deepStrictEqual(
     extractUatType('## UAT Type\n\n- UAT mode:   artifact-driven   \n'),
     'artifact-driven',
     'leading/trailing whitespace around value → still classified correctly',
   );
-
-  assertEq(
+  assert.deepStrictEqual(
     extractUatType('## UAT Type\n\n- UAT mode:  mixed (artifact-driven + live-runtime)  \n'),
     'mixed',
     'whitespace around mixed parenthetical → mixed',
   );
+});
 
-  // ─── (j) case sensitivity ─────────────────────────────────────────────────
-  console.log('\n── (j) case sensitivity');
-
-  assertEq(
+test('(j) case sensitivity', () => {
+  assert.deepStrictEqual(
     extractUatType(makeUatContent('Artifact-Driven')),
     'artifact-driven',
     'Artifact-Driven (title case) → artifact-driven (function lowercases before matching)',
   );
-
-  assertEq(
+  assert.deepStrictEqual(
     extractUatType(makeUatContent('MIXED')),
     'mixed',
     'MIXED (upper case) → mixed (function lowercases before matching)',
   );
+});
 
-  // ─── (k) prompt template loading and content integrity ────────────────────
-  console.log('\n── (k) run-uat prompt template');
-
+test('(k) run-uat prompt template', () => {
   const milestoneId = 'M001';
   const sliceId = 'S01';
   const uatPath = '.gsd/milestones/M001/slices/S01/S01-UAT.md';
   const uatResultPath = '.gsd/milestones/M001/slices/S01/S01-UAT-RESULT.md';
   const uatType = 'live-runtime';
   const inlinedContext = '<!-- no context -->';
-
   let promptResult: string | undefined;
   let promptThrew = false;
   try {
@@ -232,71 +189,66 @@ async function main(): Promise<void> {
   } catch {
     promptThrew = true;
   }
-
-  assertTrue(!promptThrew, 'loadPromptFromWorktree("run-uat", vars) does not throw');
-  assertTrue(
+  assert.ok(!promptThrew, 'loadPromptFromWorktree("run-uat", vars) does not throw');
+  assert.ok(
     typeof promptResult === 'string' && promptResult.length > 0,
     'run-uat prompt result is a non-empty string',
   );
-  assertTrue(
+  assert.ok(
     promptResult?.includes(milestoneId) ?? false,
     `prompt contains milestoneId value "${milestoneId}" after substitution`,
   );
-  assertTrue(
+  assert.ok(
     promptResult?.includes(sliceId) ?? false,
     `prompt contains sliceId value "${sliceId}" after substitution`,
   );
-  assertTrue(
+  assert.ok(
     promptResult?.includes(uatResultPath) ?? false,
     `prompt contains uatResultPath value after substitution`,
   );
-  assertTrue(
+  assert.ok(
     promptResult?.includes(`Detected UAT mode:** \`${uatType}\``) ?? false,
     `prompt contains detected dynamic uatType value "${uatType}" after substitution`,
   );
-  assertTrue(
+  assert.ok(
     promptResult?.includes(`uatType: ${uatType}`) ?? false,
     `prompt contains dynamic uatType frontmatter value "${uatType}" after substitution`,
   );
-  assertTrue(
+  assert.ok(
     !/\{\{[^}]+\}\}/.test(promptResult ?? ''),
     'no unreplaced {{...}} tokens remain after variable substitution',
   );
-  assertTrue(
+  assert.ok(
     /browser|runtime|execute|run/i.test(promptResult ?? ''),
     'prompt contains runtime execution language (browser/runtime/execute/run)',
   );
-  assertTrue(
+  assert.ok(
     !/surfaced for human review/i.test(promptResult ?? ''),
     'prompt does not contain "surfaced for human review" (non-artifact UATs are skipped, not dispatched)',
   );
+});
 
-  // ─── (l) dispatch precondition assertions via resolveSliceFile ────────────
-  console.log('\n── (l) dispatch preconditions via resolveSliceFile');
-
-  // State A: UAT file exists, UAT-RESULT file does NOT — triggers dispatch
-  {
+test('(l) dispatch preconditions via resolveSliceFile', () => {
     const base = createFixtureBase();
     const uatContent = makeUatContent('artifact-driven');
     try {
       writeSliceFile(base, 'M001', 'S01', 'UAT', uatContent);
 
       const uatFilePath = resolveSliceFile(base, 'M001', 'S01', 'UAT');
-      assertTrue(
+      assert.ok(
         uatFilePath !== null,
         'resolveSliceFile(..., "UAT") returns non-null when UAT file exists (dispatch trigger state)',
       );
 
       const uatResultFilePath = resolveSliceFile(base, 'M001', 'S01', 'UAT-RESULT');
-      assertEq(
+      assert.deepStrictEqual(
         uatResultFilePath,
         null,
         'resolveSliceFile(..., "UAT-RESULT") returns null when result file missing (dispatch trigger state)',
       );
 
-      // End-to-end: file content → parse → classify
       const rawContent = readFileSync(uatFilePath!, 'utf-8');
-      assertEq(
+      assert.deepStrictEqual(
         extractUatType(rawContent),
         'artifact-driven',
         'extractUatType on fixture UAT file returns expected type (end-to-end data flow)',
@@ -304,29 +256,25 @@ async function main(): Promise<void> {
     } finally {
       cleanup(base);
     }
-  }
+});
 
-  // State B: UAT-RESULT file exists — dispatch is skipped (idempotent)
-  {
+test('test block at line 307', () => {
     const base = createFixtureBase();
     try {
       writeSliceFile(base, 'M001', 'S01', 'UAT', makeUatContent('artifact-driven'));
       writeSliceFile(base, 'M001', 'S01', 'UAT-RESULT', '# UAT Result\n\nverdict: PASS\n');
 
       const uatResultFilePath = resolveSliceFile(base, 'M001', 'S01', 'UAT-RESULT');
-      assertTrue(
+      assert.ok(
         uatResultFilePath !== null,
         'resolveSliceFile(..., "UAT-RESULT") returns non-null when result file exists (idempotent skip state)',
       );
     } finally {
       cleanup(base);
     }
-  }
-
-  // ─── (m) non-artifact UATs are skipped (not dispatched) ─────────────────
-  console.log('\n── (m) non-artifact UAT skip');
+});
 
-  {
+test('(m) non-artifact UAT skip', async () => {
     const base = createFixtureBase();
     try {
       const roadmapDir = join(base, '.gsd', 'milestones', 'M001');
@@ -346,7 +294,6 @@ async function main(): Promise<void> {
         ].join('\n'),
       );
 
-      // human-experience UAT still dispatches, but auto-mode later pauses for manual review
       writeSliceFile(base, 'M001', 'S01', 'UAT', makeUatContent('human-experience'));
 
       const state = {
@@ -361,7 +308,7 @@ async function main(): Promise<void> {
       } as const;
 
       const result = await checkNeedsRunUat(base, 'M001', state as any, { uat_dispatch: true } as any);
-      assertEq(
+      assert.deepStrictEqual(
         result,
         { sliceId: 'S01', uatType: 'human-experience' },
         'human-experience UAT dispatches so auto-mode can pause for manual review',
@@ -369,12 +316,9 @@ async function main(): Promise<void> {
     } finally {
       cleanup(base);
     }
-  }
-
-  // ─── (n) existing UAT-RESULT never re-dispatches ──────────────────────
-  console.log('\n── (n) stale replay guard');
+});
 
-  {
+test('(n) stale replay guard', async () => {
     const base = createFixtureBase();
     try {
       const roadmapDir = join(base, '.gsd', 'milestones', 'M001');
@@ -409,7 +353,7 @@ async function main(): Promise<void> {
       } as const;
 
       const result = await checkNeedsRunUat(base, 'M001', state as any, { uat_dispatch: true } as any);
-      assertEq(
+      assert.deepStrictEqual(
         result,
         null,
         'existing UAT-RESULT with FAIL verdict does not re-dispatch; verdict gate owns blocking',
@@ -417,12 +361,6 @@ async function main(): Promise<void> {
     } finally {
       cleanup(base);
     }
-  }
-
-  report();
-}
+});
 
-main().catch((error) => {
-  console.error(error);
-  process.exit(1);
 });

package/src/resources/extensions/gsd/tests/session-lock-multipath.test.ts

@@ -20,11 +20,11 @@ import {
   _getRegisteredLockDirs,
 } from '../session-lock.ts';
 import { gsdRoot } from '../paths.ts';
-import { createTestContext } from './test-helpers.ts';
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
 
-const { assertEq, assertTrue, report } = createTestContext();
 
-async function main(): Promise<void> {
+describe('session-lock-multipath', async () => {
 
   // ─── 1. Lock dir registry tracks gsdDir on acquisition ──────────────────
   console.log('\n=== 1. Lock dir registry tracks gsdDir on acquisition ===');
@@ -34,17 +34,17 @@ async function main(): Promise<void> {
 
     try {
       const result = acquireSessionLock(base);
-      assertTrue(result.acquired, 'lock acquired');
+      assert.ok(result.acquired, 'lock acquired');
 
       const registered = _getRegisteredLockDirs();
       const gsdDir = gsdRoot(base);
-      assertTrue(registered.includes(gsdDir), 'gsdDir is registered in lock dir registry');
+      assert.ok(registered.includes(gsdDir), 'gsdDir is registered in lock dir registry');
 
       releaseSessionLock(base);
 
       // After release, registry should be cleared
       const afterRelease = _getRegisteredLockDirs();
-      assertEq(afterRelease.length, 0, 'lock dir registry cleared after release');
+      assert.deepStrictEqual(afterRelease.length, 0, 'lock dir registry cleared after release');
     } finally {
       rmSync(base, { recursive: true, force: true });
     }
@@ -62,7 +62,7 @@ async function main(): Promise<void> {
 
     try {
       const result = acquireSessionLock(base);
-      assertTrue(result.acquired, 'lock acquired');
+      assert.ok(result.acquired, 'lock acquired');
 
       // Manually plant a stale lock file at the secondary path to simulate
       // multi-path lock accumulation
@@ -72,8 +72,8 @@ async function main(): Promise<void> {
       mkdirSync(secondaryLockDir, { recursive: true });
 
       // Verify they exist before release
-      assertTrue(existsSync(secondaryLockFile), 'secondary lock file exists before release');
-      assertTrue(existsSync(secondaryLockDir), 'secondary lock dir exists before release');
+      assert.ok(existsSync(secondaryLockFile), 'secondary lock file exists before release');
+      assert.ok(existsSync(secondaryLockDir), 'secondary lock dir exists before release');
 
       // Manually add the secondary dir to the registry (simulating ensureExitHandler call)
       // We do this by acquiring knowledge of internals — the registry is populated
@@ -83,10 +83,10 @@ async function main(): Promise<void> {
 
       // Primary lock artifacts should be cleaned
       const primaryLockFile = join(gsdRoot(base), 'auto.lock');
-      assertTrue(!existsSync(primaryLockFile), 'primary auto.lock removed after release');
+      assert.ok(!existsSync(primaryLockFile), 'primary auto.lock removed after release');
 
       const primaryLockDir = gsdRoot(base) + '.lock';
-      assertTrue(!existsSync(primaryLockDir), 'primary .gsd.lock/ removed after release');
+      assert.ok(!existsSync(primaryLockDir), 'primary .gsd.lock/ removed after release');
     } finally {
       rmSync(base, { recursive: true, force: true });
     }
@@ -106,7 +106,7 @@ async function main(): Promise<void> {
       const gsdDir = gsdRoot(base);
       // Should only appear once (Set deduplication)
       const count = registered.filter(d => d === gsdDir).length;
-      assertEq(count, 1, 'gsdDir registered exactly once after re-entrant acquisition');
+      assert.deepStrictEqual(count, 1, 'gsdDir registered exactly once after re-entrant acquisition');
 
       releaseSessionLock(base);
     } finally {
@@ -124,17 +124,17 @@ async function main(): Promise<void> {
 
     try {
       const r1 = acquireSessionLock(base1);
-      assertTrue(r1.acquired, 'first base lock acquired');
+      assert.ok(r1.acquired, 'first base lock acquired');
 
       // Release first to acquire second (module state is single-lock)
       releaseSessionLock(base1);
 
       const r2 = acquireSessionLock(base2);
-      assertTrue(r2.acquired, 'second base lock acquired');
+      assert.ok(r2.acquired, 'second base lock acquired');
 
       const registered = _getRegisteredLockDirs();
       const gsd2 = gsdRoot(base2);
-      assertTrue(registered.includes(gsd2), 'second gsdDir is registered');
+      assert.ok(registered.includes(gsd2), 'second gsdDir is registered');
 
       releaseSessionLock(base2);
     } finally {
@@ -156,18 +156,11 @@ async function main(): Promise<void> {
       // Verify everything is clean
       const lockFile = join(gsdRoot(base), 'auto.lock');
       const lockDir = gsdRoot(base) + '.lock';
-      assertTrue(!existsSync(lockFile), 'auto.lock cleaned');
-      assertTrue(!existsSync(lockDir), '.gsd.lock/ cleaned');
-      assertEq(_getRegisteredLockDirs().length, 0, 'registry empty');
+      assert.ok(!existsSync(lockFile), 'auto.lock cleaned');
+      assert.ok(!existsSync(lockDir), '.gsd.lock/ cleaned');
+      assert.deepStrictEqual(_getRegisteredLockDirs().length, 0, 'registry empty');
     } finally {
       rmSync(base, { recursive: true, force: true });
     }
   }
-
-  report();
-}
-
-main().catch((error) => {
-  console.error(error);
-  process.exit(1);
 });