gsd-pi 2.44.0-dev.848dd4c → 2.44.0

package/src/resources/extensions/gsd/tests/queue-order.test.ts

@@ -1,5 +1,3 @@
-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';
@@ -11,6 +9,10 @@ import {
   pruneQueueOrder,
   validateQueueOrder,
 } from '../queue-order.ts';
+import { createTestContext } from './test-helpers.ts';
+
+const { assertEq, assertTrue, report } = createTestContext();
+
 // ─── Fixture Helpers ───────────────────────────────────────────────────────
 
 function createFixtureBase(): string {
@@ -27,166 +29,176 @@ function cleanup(base: string): void {
 // sortByQueueOrder
 // ═══════════════════════════════════════════════════════════════════════════
 
+console.log('\n=== sortByQueueOrder ===');
 
-describe('queue-order', () => {
-test('sortByQueueOrder', () => {
 // Null order → default milestoneIdSort
+{
   const result = sortByQueueOrder(['M003', 'M001', 'M002'], null);
-  assert.deepStrictEqual(result, ['M001', 'M002', 'M003'], 'null order falls back to numeric sort');
-});
+  assertEq(result, ['M001', 'M002', 'M003'], 'null order falls back to numeric sort');
+}
 
 // Custom order → exact sequence
-test('test block at line 39', () => {
+{
   const result = sortByQueueOrder(['M001', 'M002', 'M003'], ['M003', 'M001', 'M002']);
-  assert.deepStrictEqual(result, ['M003', 'M001', 'M002'], 'custom order produces exact sequence');
-});
+  assertEq(result, ['M003', 'M001', 'M002'], 'custom order produces exact sequence');
+}
 
 // Custom order with new IDs → appended at end in numeric order
-test('test block at line 45', () => {
+{
   const result = sortByQueueOrder(['M001', 'M002', 'M003', 'M004'], ['M003', 'M001']);
-  assert.deepStrictEqual(result, ['M003', 'M001', 'M002', 'M004'], 'new IDs appended in numeric order');
-});
+  assertEq(result, ['M003', 'M001', 'M002', 'M004'], 'new IDs appended in numeric order');
+}
 
 // Custom order with deleted IDs → silently skipped
-test('test block at line 51', () => {
+{
   const result = sortByQueueOrder(['M001', 'M003'], ['M003', 'M002', 'M001']);
-  assert.deepStrictEqual(result, ['M003', 'M001'], 'deleted IDs in order are skipped');
-});
+  assertEq(result, ['M003', 'M001'], 'deleted IDs in order are skipped');
+}
 
 // Empty custom order → all IDs in numeric order
-test('test block at line 57', () => {
+{
   const result = sortByQueueOrder(['M002', 'M001'], []);
-  assert.deepStrictEqual(result, ['M001', 'M002'], 'empty custom order falls back to numeric sort');
-});
+  assertEq(result, ['M001', 'M002'], 'empty custom order falls back to numeric sort');
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // loadQueueOrder / saveQueueOrder
 // ═══════════════════════════════════════════════════════════════════════════
-test('loadQueueOrder / saveQueueOrder', () => {
+
+console.log('\n=== loadQueueOrder / saveQueueOrder ===');
+
 // Load returns null when file doesn't exist
+{
   const base = createFixtureBase();
-  assert.deepStrictEqual(loadQueueOrder(base), null, 'returns null when file missing');
+  assertEq(loadQueueOrder(base), null, 'returns null when file missing');
   cleanup(base);
-});
+}
 
 // Save then load round-trip
-test('test block at line 76', () => {
+{
   const base = createFixtureBase();
   saveQueueOrder(base, ['M003', 'M001', 'M002']);
   const loaded = loadQueueOrder(base);
-  assert.deepStrictEqual(loaded, ['M003', 'M001', 'M002'], 'round-trip preserves order');
+  assertEq(loaded, ['M003', 'M001', 'M002'], 'round-trip preserves order');
 
   // Verify file contains updatedAt
   const raw = JSON.parse(readFileSync(join(base, '.gsd', 'QUEUE-ORDER.json'), 'utf-8'));
-  assert.ok(typeof raw.updatedAt === 'string' && raw.updatedAt.length > 0, 'file contains updatedAt');
+  assertTrue(typeof raw.updatedAt === 'string' && raw.updatedAt.length > 0, 'file contains updatedAt');
 
   cleanup(base);
-});
+}
 
 // Load returns null on corrupt JSON
-test('test block at line 90', () => {
+{
   const base = createFixtureBase();
   writeFileSync(join(base, '.gsd', 'QUEUE-ORDER.json'), 'not json');
-  assert.deepStrictEqual(loadQueueOrder(base), null, 'returns null on corrupt JSON');
+  assertEq(loadQueueOrder(base), null, 'returns null on corrupt JSON');
   cleanup(base);
-});
+}
 
 // Load returns null when order field is not an array
-test('test block at line 98', () => {
+{
   const base = createFixtureBase();
   writeFileSync(join(base, '.gsd', 'QUEUE-ORDER.json'), '{"order": "invalid"}');
-  assert.deepStrictEqual(loadQueueOrder(base), null, 'returns null when order is not array');
+  assertEq(loadQueueOrder(base), null, 'returns null when order is not array');
   cleanup(base);
-});
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // pruneQueueOrder
 // ═══════════════════════════════════════════════════════════════════════════
-test('pruneQueueOrder', () => {
+
+console.log('\n=== pruneQueueOrder ===');
+
 // Prune removes invalid IDs
+{
   const base = createFixtureBase();
   saveQueueOrder(base, ['M001', 'M002', 'M003']);
   pruneQueueOrder(base, ['M001', 'M003']);
-  assert.deepStrictEqual(loadQueueOrder(base), ['M001', 'M003'], 'prune removes invalid IDs');
+  assertEq(loadQueueOrder(base), ['M001', 'M003'], 'prune removes invalid IDs');
   cleanup(base);
-});
+}
 
 // Prune no-ops when file doesn't exist
-test('test block at line 121', () => {
+{
   const base = createFixtureBase();
   pruneQueueOrder(base, ['M001']); // should not throw
-  assert.ok(!existsSync(join(base, '.gsd', 'QUEUE-ORDER.json')), 'prune does not create file');
+  assertTrue(!existsSync(join(base, '.gsd', 'QUEUE-ORDER.json')), 'prune does not create file');
   cleanup(base);
-});
+}
 
 // Prune no-ops when all IDs are valid
-test('test block at line 129', () => {
+{
   const base = createFixtureBase();
   saveQueueOrder(base, ['M001', 'M002']);
   pruneQueueOrder(base, ['M001', 'M002', 'M003']);
-  assert.deepStrictEqual(loadQueueOrder(base), ['M001', 'M002'], 'prune is no-op when all valid');
+  assertEq(loadQueueOrder(base), ['M001', 'M002'], 'prune is no-op when all valid');
   cleanup(base);
-});
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // validateQueueOrder
 // ═══════════════════════════════════════════════════════════════════════════
-test('validateQueueOrder', () => {
+
+console.log('\n=== validateQueueOrder ===');
+
 // Valid order with no dependencies
+{
   const depsMap = new Map<string, string[]>();
   const result = validateQueueOrder(['M001', 'M002'], depsMap, new Set());
-  assert.ok(result.valid, 'valid when no dependencies');
-  assert.deepStrictEqual(result.violations.length, 0, 'no violations');
-  assert.deepStrictEqual(result.redundant.length, 0, 'no redundancies');
-});
+  assertTrue(result.valid, 'valid when no dependencies');
+  assertEq(result.violations.length, 0, 'no violations');
+  assertEq(result.redundant.length, 0, 'no redundancies');
+}
 
 // Dependency violation: M002 before M001, but M002 depends on M001
-test('test block at line 153', () => {
+{
   const depsMap = new Map<string, string[]>([['M002', ['M001']]]);
   const result = validateQueueOrder(['M002', 'M001'], depsMap, new Set());
-  assert.ok(!result.valid, 'invalid when dep violated');
-  assert.deepStrictEqual(result.violations.length, 1, 'one violation');
-  assert.deepStrictEqual(result.violations[0].type, 'would_block', 'violation type is would_block');
-  assert.deepStrictEqual(result.violations[0].milestone, 'M002', 'violation milestone is M002');
-  assert.deepStrictEqual(result.violations[0].dependsOn, 'M001', 'violation dep is M001');
-});
+  assertTrue(!result.valid, 'invalid when dep violated');
+  assertEq(result.violations.length, 1, 'one violation');
+  assertEq(result.violations[0].type, 'would_block', 'violation type is would_block');
+  assertEq(result.violations[0].milestone, 'M002', 'violation milestone is M002');
+  assertEq(result.violations[0].dependsOn, 'M001', 'violation dep is M001');
+}
 
 // Redundant dependency: M002 depends on M001, M001 comes first in order
-test('test block at line 164', () => {
+{
   const depsMap = new Map<string, string[]>([['M002', ['M001']]]);
   const result = validateQueueOrder(['M001', 'M002'], depsMap, new Set());
-  assert.ok(result.valid, 'valid when dep satisfied by position');
-  assert.deepStrictEqual(result.redundant.length, 1, 'one redundancy');
-  assert.deepStrictEqual(result.redundant[0].milestone, 'M002', 'redundant milestone is M002');
-});
+  assertTrue(result.valid, 'valid when dep satisfied by position');
+  assertEq(result.redundant.length, 1, 'one redundancy');
+  assertEq(result.redundant[0].milestone, 'M002', 'redundant milestone is M002');
+}
 
 // Completed dep is always satisfied
-test('test block at line 173', () => {
+{
   const depsMap = new Map<string, string[]>([['M002', ['M001']]]);
   const result = validateQueueOrder(['M002'], depsMap, new Set(['M001']));
-  assert.ok(result.valid, 'valid when dep is already completed');
-  assert.deepStrictEqual(result.violations.length, 0, 'no violations for completed dep');
-});
+  assertTrue(result.valid, 'valid when dep is already completed');
+  assertEq(result.violations.length, 0, 'no violations for completed dep');
+}
 
 // Missing dependency
-test('test block at line 181', () => {
+{
   const depsMap = new Map<string, string[]>([['M002', ['M099']]]);
   const result = validateQueueOrder(['M001', 'M002'], depsMap, new Set());
-  assert.ok(!result.valid, 'invalid when dep does not exist');
-  assert.deepStrictEqual(result.violations[0].type, 'missing_dep', 'violation type is missing_dep');
-});
+  assertTrue(!result.valid, 'invalid when dep does not exist');
+  assertEq(result.violations[0].type, 'missing_dep', 'violation type is missing_dep');
+}
 
 // Circular dependency
-test('test block at line 189', () => {
+{
   const depsMap = new Map<string, string[]>([
     ['M001', ['M002']],
     ['M002', ['M001']],
   ]);
   const result = validateQueueOrder(['M001', 'M002'], depsMap, new Set());
-  assert.ok(!result.valid, 'invalid on circular dependency');
+  assertTrue(!result.valid, 'invalid on circular dependency');
   const circularViolation = result.violations.find(v => v.type === 'circular');
-  assert.ok(!!circularViolation, 'circular violation detected');
-});
+  assertTrue(!!circularViolation, 'circular violation detected');
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
-});
+
+report();

package/src/resources/extensions/gsd/tests/queue-reorder-e2e.test.ts

@@ -11,8 +11,6 @@
  * 4. A fresh deriveState() call (simulating new session) also works
  */
 
-import { describe, test } from 'node:test';
-import assert from 'node:assert/strict';
 import { mkdtempSync, mkdirSync, rmSync, writeFileSync, readFileSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
@@ -21,6 +19,10 @@ import { deriveState, invalidateStateCache } from '../state.ts';
 import { findMilestoneIds } from '../guided-flow.ts';
 import { saveQueueOrder, loadQueueOrder } from '../queue-order.ts';
 import { parseContextDependsOn } from '../files.ts';
+import { createTestContext } from './test-helpers.ts';
+
+const { assertEq, assertTrue, report } = createTestContext();
+
 // ─── Fixture Helpers ───────────────────────────────────────────────────────
 
 function createFixtureBase(): string {
@@ -68,9 +70,8 @@ function readContextFile(base: string, mid: string): string {
 // Test: Queue order changes milestone activation
 // ═══════════════════════════════════════════════════════════════════════════
 
-
-describe('queue-reorder-e2e', () => {
-test('E2E: queue-order changes active milestone', async () => {
+console.log('\n=== E2E: queue-order changes active milestone ===');
+{
   const base = createFixtureBase();
   try {
     // Setup: M007 complete, M008 and M009 pending (no context, no roadmap)
@@ -83,7 +84,7 @@ test('E2E: queue-order changes active milestone', async () => {
     // Without custom order: M008 comes first (numeric sort)
     invalidateStateCache();
     const stateBefore = await deriveState(base);
-    assert.deepStrictEqual(stateBefore.activeMilestone?.id, 'M008', 'before reorder: M008 is active');
+    assertEq(stateBefore.activeMilestone?.id, 'M008', 'before reorder: M008 is active');
 
     // Save custom order: M009 before M008
     saveQueueOrder(base, ['M009', 'M008']);
@@ -91,23 +92,25 @@ test('E2E: queue-order changes active milestone', async () => {
     // With custom order: M009 should be active
     invalidateStateCache();
     const stateAfter = await deriveState(base);
-    assert.deepStrictEqual(stateAfter.activeMilestone?.id, 'M009', 'after reorder: M009 is active');
+    assertEq(stateAfter.activeMilestone?.id, 'M009', 'after reorder: M009 is active');
 
     // findMilestoneIds respects the order
     const ids = findMilestoneIds(base);
     const m008Idx = ids.indexOf('M008');
     const m009Idx = ids.indexOf('M009');
-    assert.ok(m009Idx < m008Idx, 'findMilestoneIds: M009 comes before M008');
+    assertTrue(m009Idx < m008Idx, 'findMilestoneIds: M009 comes before M008');
 
   } finally {
     cleanup(base);
   }
-});
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Test: Reorder + depends_on removal = correct state
 // ═══════════════════════════════════════════════════════════════════════════
-test('E2E: reorder with depends_on removal', async () => {
+
+console.log('\n=== E2E: reorder with depends_on removal ===');
+{
   const base = createFixtureBase();
   try {
     // Setup: M007 complete, M008 depends_on M009, M009 no deps
@@ -118,7 +121,7 @@ test('E2E: reorder with depends_on removal', async () => {
     // Before: M008 depends on M009, so deriveState skips M008, M009 is active
     invalidateStateCache();
     const stateBefore = await deriveState(base);
-    assert.deepStrictEqual(stateBefore.activeMilestone?.id, 'M009', 'before: M009 active (M008 dep-blocked)');
+    assertEq(stateBefore.activeMilestone?.id, 'M009', 'before: M009 active (M008 dep-blocked)');
 
     // Simulate reorder confirm: save order M009→M008, remove depends_on from M008
     saveQueueOrder(base, ['M009', 'M008']);
@@ -131,27 +134,29 @@ test('E2E: reorder with depends_on removal', async () => {
     // Verify: depends_on is gone
     const updatedContent = readContextFile(base, 'M008');
     const deps = parseContextDependsOn(updatedContent);
-    assert.deepStrictEqual(deps.length, 0, 'depends_on removed from M008-CONTEXT.md');
+    assertEq(deps.length, 0, 'depends_on removed from M008-CONTEXT.md');
 
     // Verify: deriveState still picks M009 (it's first in queue order)
     invalidateStateCache();
     const stateAfter = await deriveState(base);
-    assert.deepStrictEqual(stateAfter.activeMilestone?.id, 'M009', 'after: M009 still active (first in queue)');
+    assertEq(stateAfter.activeMilestone?.id, 'M009', 'after: M009 still active (first in queue)');
 
     // Verify: M008 is now pending (not dep-blocked)
     const m008Entry = stateAfter.registry.find(m => m.id === 'M008');
-    assert.deepStrictEqual(m008Entry?.status, 'pending', 'M008 is pending (not dep-blocked)');
-    assert.ok(!m008Entry?.dependsOn || m008Entry.dependsOn.length === 0, 'M008 has no dependsOn');
+    assertEq(m008Entry?.status, 'pending', 'M008 is pending (not dep-blocked)');
+    assertTrue(!m008Entry?.dependsOn || m008Entry.dependsOn.length === 0, 'M008 has no dependsOn');
 
   } finally {
     cleanup(base);
   }
-});
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Test: Fresh deriveState (simulating new session) respects queue order
 // ═══════════════════════════════════════════════════════════════════════════
-test('E2E: fresh session respects queue order', async () => {
+
+console.log('\n=== E2E: fresh session respects queue order ===');
+{
   const base = createFixtureBase();
   try {
     writeCompleteMilestone(base, 'M007');
@@ -166,21 +171,23 @@ test('E2E: fresh session respects queue order', async () => {
 
     // Derive state — should read QUEUE-ORDER.json from disk
     const state = await deriveState(base);
-    assert.deepStrictEqual(state.activeMilestone?.id, 'M009', 'fresh session: M009 is active');
+    assertEq(state.activeMilestone?.id, 'M009', 'fresh session: M009 is active');
 
     // Verify queue order persisted
     const order = loadQueueOrder(base);
-    assert.deepStrictEqual(order, ['M009', 'M008'], 'QUEUE-ORDER.json persisted correctly');
+    assertEq(order, ['M009', 'M008'], 'QUEUE-ORDER.json persisted correctly');
 
   } finally {
     cleanup(base);
   }
-});
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Test: Queue order with newly added milestones
 // ═══════════════════════════════════════════════════════════════════════════
-test('E2E: new milestones appended to queue', async () => {
+
+console.log('\n=== E2E: new milestones appended to queue ===');
+{
   const base = createFixtureBase();
   try {
     writeCompleteMilestone(base, 'M007');
@@ -200,22 +207,24 @@ test('E2E: new milestones appended to queue', async () => {
     const m009Idx = ids.indexOf('M009');
     const m008Idx = ids.indexOf('M008');
     const m010Idx = ids.indexOf('M010');
-    assert.ok(m009Idx < m008Idx, 'M009 before M008');
-    assert.ok(m008Idx < m010Idx, 'M008 before M010 (new milestone appended)');
+    assertTrue(m009Idx < m008Idx, 'M009 before M008');
+    assertTrue(m008Idx < m010Idx, 'M008 before M010 (new milestone appended)');
 
     // M009 is still active (first non-complete in queue order)
     const state = await deriveState(base);
-    assert.deepStrictEqual(state.activeMilestone?.id, 'M009', 'M009 still active after M010 added');
+    assertEq(state.activeMilestone?.id, 'M009', 'M009 still active after M010 added');
 
   } finally {
     cleanup(base);
   }
-});
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Test: No queue order file = default numeric sort (backward compat)
 // ═══════════════════════════════════════════════════════════════════════════
-test('E2E: backward compat without QUEUE-ORDER.json', async () => {
+
+console.log('\n=== E2E: backward compat without QUEUE-ORDER.json ===');
+{
   const base = createFixtureBase();
   try {
     writeCompleteMilestone(base, 'M007');
@@ -225,20 +234,22 @@ test('E2E: backward compat without QUEUE-ORDER.json', async () => {
     // No QUEUE-ORDER.json — default numeric sort
     invalidateStateCache();
     const state = await deriveState(base);
-    assert.deepStrictEqual(state.activeMilestone?.id, 'M008', 'no queue order: M008 active (numeric)');
+    assertEq(state.activeMilestone?.id, 'M008', 'no queue order: M008 active (numeric)');
 
     const ids = findMilestoneIds(base);
-    assert.ok(ids.indexOf('M008') < ids.indexOf('M009'), 'default sort: M008 before M009');
+    assertTrue(ids.indexOf('M008') < ids.indexOf('M009'), 'default sort: M008 before M009');
 
   } finally {
     cleanup(base);
   }
-});
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Test: non-milestone directories are filtered out (#1494)
 // ═══════════════════════════════════════════════════════════════════════════
-test('E2E: non-milestone directories filtered from findMilestoneIds (#1494)', () => {
+
+console.log('\n=== E2E: non-milestone directories filtered from findMilestoneIds (#1494) ===');
+{
   const base = createFixtureBase();
   try {
     writeContext(base, 'M001', '', 'First');
@@ -249,20 +260,22 @@ test('E2E: non-milestone directories filtered from findMilestoneIds (#1494)', ()
 
     invalidateStateCache();
     const ids = findMilestoneIds(base);
-    assert.deepStrictEqual(ids.length, 2, 'only M001 and M002 returned');
-    assert.ok(!ids.includes('slices'), 'slices directory excluded');
-    assert.ok(!ids.includes('temp-backup'), 'temp-backup directory excluded');
-    assert.ok(ids.includes('M001'), 'M001 included');
-    assert.ok(ids.includes('M002'), 'M002 included');
+    assertEq(ids.length, 2, 'only M001 and M002 returned');
+    assertTrue(!ids.includes('slices'), 'slices directory excluded');
+    assertTrue(!ids.includes('temp-backup'), 'temp-backup directory excluded');
+    assertTrue(ids.includes('M001'), 'M001 included');
+    assertTrue(ids.includes('M002'), 'M002 included');
   } finally {
     cleanup(base);
   }
-});
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Test: depends_on inline array format removal
 // ═══════════════════════════════════════════════════════════════════════════
-test('E2E: depends_on inline format preserved after partial removal', () => {
+
+console.log('\n=== E2E: depends_on inline format preserved after partial removal ===');
+{
   const base = createFixtureBase();
   try {
     writeCompleteMilestone(base, 'M007');
@@ -274,7 +287,7 @@ test('E2E: depends_on inline format preserved after partial removal', () => {
     // Verify both deps are parsed
     const contentBefore = readContextFile(base, 'M008');
     const depsBefore = parseContextDependsOn(contentBefore);
-    assert.deepStrictEqual(depsBefore.length, 2, 'M008 has 2 deps before');
+    assertEq(depsBefore.length, 2, 'M008 has 2 deps before');
 
     // Simulate removing only M009 dep (keep M010)
     const content = readContextFile(base, 'M008');
@@ -284,12 +297,12 @@ test('E2E: depends_on inline format preserved after partial removal', () => {
     // Verify only M010 remains
     const contentAfter = readContextFile(base, 'M008');
     const depsAfter = parseContextDependsOn(contentAfter);
-    assert.deepStrictEqual(depsAfter.length, 1, 'M008 has 1 dep after removal');
-    assert.deepStrictEqual(depsAfter[0], 'M010', 'remaining dep is M010');
+    assertEq(depsAfter.length, 1, 'M008 has 1 dep after removal');
+    assertEq(depsAfter[0], 'M010', 'remaining dep is M010');
 
   } finally {
     cleanup(base);
   }
-});
+}
 
-});
+report();