gsd-pi 2.43.0 → 2.44.0-dev.0b97ffd

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/schema-v9-sequence.test.ts

@@ -0,0 +1,176 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+  getMilestoneSlices,
+  getSliceTasks,
+  getActiveSliceFromDb,
+  getActiveTaskFromDb,
+} from '../gsd-db.ts';
+
+function makeTmp(): string {
+  return mkdtempSync(join(tmpdir(), 'gsd-v9-'));
+}
+
+function cleanup(base: string): void {
+  try { closeDatabase(); } catch { /* noop */ }
+  try { rmSync(base, { recursive: true, force: true }); } catch { /* noop */ }
+}
+
+test('schema v9: migration adds sequence column to slices and tasks', () => {
+  const base = makeTmp();
+  const dbPath = join(base, 'gsd.db');
+  openDatabase(dbPath);
+  try {
+    insertMilestone({ id: 'M001', title: 'Test', status: 'active' });
+    // If sequence column doesn't exist, these would throw
+    insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Slice 1', sequence: 5 });
+    insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', title: 'Task 1', sequence: 3 });
+
+    const slices = getMilestoneSlices('M001');
+    assert.equal(slices.length, 1);
+    assert.equal(slices[0]!.sequence, 5);
+
+    const tasks = getSliceTasks('M001', 'S01');
+    assert.equal(tasks.length, 1);
+    assert.equal(tasks[0]!.sequence, 3);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('schema v9: getMilestoneSlices returns slices ordered by sequence then id', () => {
+  const base = makeTmp();
+  openDatabase(join(base, 'gsd.db'));
+  try {
+    insertMilestone({ id: 'M001', title: 'Test', status: 'active' });
+
+    // Insert in reverse lexicographic order with sequence overriding id order
+    insertSlice({ id: 'S03', milestoneId: 'M001', title: 'Third by id, first by seq', sequence: 1 });
+    insertSlice({ id: 'S01', milestoneId: 'M001', title: 'First by id, third by seq', sequence: 3 });
+    insertSlice({ id: 'S02', milestoneId: 'M001', title: 'Second by id, second by seq', sequence: 2 });
+
+    const slices = getMilestoneSlices('M001');
+    assert.equal(slices.length, 3);
+    assert.equal(slices[0]!.id, 'S03', 'sequence=1 should be first');
+    assert.equal(slices[1]!.id, 'S02', 'sequence=2 should be second');
+    assert.equal(slices[2]!.id, 'S01', 'sequence=3 should be third');
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('schema v9: getSliceTasks returns tasks ordered by sequence then id', () => {
+  const base = makeTmp();
+  openDatabase(join(base, 'gsd.db'));
+  try {
+    insertMilestone({ id: 'M001', title: 'Test', status: 'active' });
+    insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Slice' });
+
+    // Insert tasks with sequence overriding id order
+    insertTask({ id: 'T03', sliceId: 'S01', milestoneId: 'M001', title: 'Third by id', sequence: 1 });
+    insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', title: 'First by id', sequence: 3 });
+    insertTask({ id: 'T02', sliceId: 'S01', milestoneId: 'M001', title: 'Second by id', sequence: 2 });
+
+    const tasks = getSliceTasks('M001', 'S01');
+    assert.equal(tasks.length, 3);
+    assert.equal(tasks[0]!.id, 'T03', 'sequence=1 should be first');
+    assert.equal(tasks[1]!.id, 'T02', 'sequence=2 should be second');
+    assert.equal(tasks[2]!.id, 'T01', 'sequence=3 should be third');
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('schema v9: default sequence (0) falls back to id-based ordering', () => {
+  const base = makeTmp();
+  openDatabase(join(base, 'gsd.db'));
+  try {
+    insertMilestone({ id: 'M001', title: 'Test', status: 'active' });
+
+    // All slices with default sequence=0 should sort by id
+    insertSlice({ id: 'S03', milestoneId: 'M001', title: 'Third' });
+    insertSlice({ id: 'S01', milestoneId: 'M001', title: 'First' });
+    insertSlice({ id: 'S02', milestoneId: 'M001', title: 'Second' });
+
+    const slices = getMilestoneSlices('M001');
+    assert.equal(slices[0]!.id, 'S01', 'default seq=0: should sort by id');
+    assert.equal(slices[1]!.id, 'S02');
+    assert.equal(slices[2]!.id, 'S03');
+
+    // Same for tasks
+    insertSlice({ id: 'S04', milestoneId: 'M001', title: 'Container' });
+    insertTask({ id: 'T02', sliceId: 'S04', milestoneId: 'M001', title: 'B' });
+    insertTask({ id: 'T01', sliceId: 'S04', milestoneId: 'M001', title: 'A' });
+    insertTask({ id: 'T03', sliceId: 'S04', milestoneId: 'M001', title: 'C' });
+
+    const tasks = getSliceTasks('M001', 'S04');
+    assert.equal(tasks[0]!.id, 'T01');
+    assert.equal(tasks[1]!.id, 'T02');
+    assert.equal(tasks[2]!.id, 'T03');
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('schema v9: getActiveSliceFromDb respects sequence ordering', () => {
+  const base = makeTmp();
+  openDatabase(join(base, 'gsd.db'));
+  try {
+    insertMilestone({ id: 'M001', title: 'Test', status: 'active' });
+
+    // S02 has lower sequence so should be active first despite higher id than S01
+    insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Higher seq', status: 'pending', sequence: 5 });
+    insertSlice({ id: 'S02', milestoneId: 'M001', title: 'Lower seq', status: 'pending', sequence: 2 });
+
+    const active = getActiveSliceFromDb('M001');
+    assert.ok(active);
+    assert.equal(active!.id, 'S02', 'lower sequence should be active first');
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('schema v9: getActiveTaskFromDb respects sequence ordering', () => {
+  const base = makeTmp();
+  openDatabase(join(base, 'gsd.db'));
+  try {
+    insertMilestone({ id: 'M001', title: 'Test', status: 'active' });
+    insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Slice' });
+
+    insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', title: 'Higher seq', status: 'pending', sequence: 10 });
+    insertTask({ id: 'T02', sliceId: 'S01', milestoneId: 'M001', title: 'Lower seq', status: 'pending', sequence: 1 });
+
+    const active = getActiveTaskFromDb('M001', 'S01');
+    assert.ok(active);
+    assert.equal(active!.id, 'T02', 'lower sequence should be active first');
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('schema v9: sequence field defaults to 0 when not provided', () => {
+  const base = makeTmp();
+  openDatabase(join(base, 'gsd.db'));
+  try {
+    insertMilestone({ id: 'M001', title: 'Test', status: 'active' });
+    insertSlice({ id: 'S01', milestoneId: 'M001', title: 'No seq' });
+    insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', title: 'No seq' });
+
+    const slices = getMilestoneSlices('M001');
+    assert.equal(slices[0]!.sequence, 0, 'slice sequence defaults to 0');
+
+    const tasks = getSliceTasks('M001', 'S01');
+    assert.equal(tasks[0]!.sequence, 0, 'task sequence defaults to 0');
+  } finally {
+    cleanup(base);
+  }
+});