gsd-pi 2.44.0-dev.848dd4c → 2.44.0

package/src/resources/extensions/gsd/tests/must-have-parser.test.ts

@@ -1,12 +1,13 @@
 import { parseTaskPlanMustHaves } from '../files.ts';
-import { describe, test, beforeEach, afterEach } from 'node:test';
-import assert from 'node:assert/strict';
+import { createTestContext } from './test-helpers.ts';
 
+const { assertEq, assertTrue, report } = createTestContext();
 // ═══════════════════════════════════════════════════════════════════════════
 // (a) Standard unchecked format: - [ ] text
 // ═══════════════════════════════════════════════════════════════════════════
 
-test('parseTaskPlanMustHaves: standard unchecked', () => {
+console.log('\n=== parseTaskPlanMustHaves: standard unchecked ===');
+{
   const content = `# T01: Test Task
 
 ## Must-Haves
@@ -15,53 +16,56 @@ test('parseTaskPlanMustHaves: standard unchecked', () => {
 - [ ] Second must-have item
 `;
   const result = parseTaskPlanMustHaves(content);
-  assert.deepStrictEqual(result.length, 2, 'should return 2 items');
-  assert.deepStrictEqual(result[0].text, 'First must-have item', 'first item text');
-  assert.deepStrictEqual(result[0].checked, false, 'first item unchecked');
-  assert.deepStrictEqual(result[1].text, 'Second must-have item', 'second item text');
-  assert.deepStrictEqual(result[1].checked, false, 'second item unchecked');
-});
+  assertEq(result.length, 2, 'should return 2 items');
+  assertEq(result[0].text, 'First must-have item', 'first item text');
+  assertEq(result[0].checked, false, 'first item unchecked');
+  assertEq(result[1].text, 'Second must-have item', 'second item text');
+  assertEq(result[1].checked, false, 'second item unchecked');
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // (b) Checked variants: - [x] and - [X]
 // ═══════════════════════════════════════════════════════════════════════════
 
-test('parseTaskPlanMustHaves: checked [x] and [X]', () => {
+console.log('\n=== parseTaskPlanMustHaves: checked [x] and [X] ===');
+{
   const content = `## Must-Haves
 
 - [x] Lowercase checked item
 - [X] Uppercase checked item
 `;
   const result = parseTaskPlanMustHaves(content);
-  assert.deepStrictEqual(result.length, 2, 'should return 2 items');
-  assert.deepStrictEqual(result[0].checked, true, 'lowercase x is checked');
-  assert.deepStrictEqual(result[0].text, 'Lowercase checked item', 'lowercase x text');
-  assert.deepStrictEqual(result[1].checked, true, 'uppercase X is checked');
-  assert.deepStrictEqual(result[1].text, 'Uppercase checked item', 'uppercase X text');
-});
+  assertEq(result.length, 2, 'should return 2 items');
+  assertEq(result[0].checked, true, 'lowercase x is checked');
+  assertEq(result[0].text, 'Lowercase checked item', 'lowercase x text');
+  assertEq(result[1].checked, true, 'uppercase X is checked');
+  assertEq(result[1].text, 'Uppercase checked item', 'uppercase X text');
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // (c) No-checkbox bullets: - text
 // ═══════════════════════════════════════════════════════════════════════════
 
-test('parseTaskPlanMustHaves: no-checkbox bullets', () => {
+console.log('\n=== parseTaskPlanMustHaves: no-checkbox bullets ===');
+{
   const content = `## Must-Haves
 
 - Plain bullet item
 - Another plain item
 `;
   const result = parseTaskPlanMustHaves(content);
-  assert.deepStrictEqual(result.length, 2, 'should return 2 items');
-  assert.deepStrictEqual(result[0].text, 'Plain bullet item', 'plain bullet text');
-  assert.deepStrictEqual(result[0].checked, false, 'plain bullet defaults to unchecked');
-  assert.deepStrictEqual(result[1].text, 'Another plain item', 'second plain bullet text');
-});
+  assertEq(result.length, 2, 'should return 2 items');
+  assertEq(result[0].text, 'Plain bullet item', 'plain bullet text');
+  assertEq(result[0].checked, false, 'plain bullet defaults to unchecked');
+  assertEq(result[1].text, 'Another plain item', 'second plain bullet text');
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // (d) Indented variants
 // ═══════════════════════════════════════════════════════════════════════════
 
-test('parseTaskPlanMustHaves: indented variants', () => {
+console.log('\n=== parseTaskPlanMustHaves: indented variants ===');
+{
   const content = `## Must-Haves
 
   - [ ] Indented unchecked item
@@ -69,20 +73,21 @@ test('parseTaskPlanMustHaves: indented variants', () => {
   - Plain indented item
 `;
   const result = parseTaskPlanMustHaves(content);
-  assert.deepStrictEqual(result.length, 3, 'should return 3 items');
-  assert.deepStrictEqual(result[0].text, 'Indented unchecked item', 'indented unchecked text');
-  assert.deepStrictEqual(result[0].checked, false, 'indented unchecked state');
-  assert.deepStrictEqual(result[1].text, 'Indented checked item', 'indented checked text');
-  assert.deepStrictEqual(result[1].checked, true, 'indented checked state');
-  assert.deepStrictEqual(result[2].text, 'Plain indented item', 'indented plain text');
-  assert.deepStrictEqual(result[2].checked, false, 'indented plain state');
-});
+  assertEq(result.length, 3, 'should return 3 items');
+  assertEq(result[0].text, 'Indented unchecked item', 'indented unchecked text');
+  assertEq(result[0].checked, false, 'indented unchecked state');
+  assertEq(result[1].text, 'Indented checked item', 'indented checked text');
+  assertEq(result[1].checked, true, 'indented checked state');
+  assertEq(result[2].text, 'Plain indented item', 'indented plain text');
+  assertEq(result[2].checked, false, 'indented plain state');
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // (e) Mixed checkbox states in one section
 // ═══════════════════════════════════════════════════════════════════════════
 
-test('parseTaskPlanMustHaves: mixed states', () => {
+console.log('\n=== parseTaskPlanMustHaves: mixed states ===');
+{
   const content = `## Must-Haves
 
 - [ ] Unchecked one
@@ -92,19 +97,20 @@ test('parseTaskPlanMustHaves: mixed states', () => {
 - [ ] Another unchecked
 `;
   const result = parseTaskPlanMustHaves(content);
-  assert.deepStrictEqual(result.length, 5, 'should return 5 items');
-  assert.deepStrictEqual(result[0].checked, false, 'first is unchecked');
-  assert.deepStrictEqual(result[1].checked, true, 'second is checked');
-  assert.deepStrictEqual(result[2].checked, true, 'third is checked (uppercase)');
-  assert.deepStrictEqual(result[3].checked, false, 'fourth (plain) is unchecked');
-  assert.deepStrictEqual(result[4].checked, false, 'fifth is unchecked');
-});
+  assertEq(result.length, 5, 'should return 5 items');
+  assertEq(result[0].checked, false, 'first is unchecked');
+  assertEq(result[1].checked, true, 'second is checked');
+  assertEq(result[2].checked, true, 'third is checked (uppercase)');
+  assertEq(result[3].checked, false, 'fourth (plain) is unchecked');
+  assertEq(result[4].checked, false, 'fifth is unchecked');
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // (f) Missing Must-Haves section → empty array
 // ═══════════════════════════════════════════════════════════════════════════
 
-test('parseTaskPlanMustHaves: missing section', () => {
+console.log('\n=== parseTaskPlanMustHaves: missing section ===');
+{
   const content = `# T01: Some Task
 
 ## Description
@@ -116,15 +122,16 @@ Some description here.
 - Run tests
 `;
   const result = parseTaskPlanMustHaves(content);
-  assert.deepStrictEqual(result.length, 0, 'returns empty array when section missing');
-  assert.ok(Array.isArray(result), 'result is an array');
-});
+  assertEq(result.length, 0, 'returns empty array when section missing');
+  assertTrue(Array.isArray(result), 'result is an array');
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // (g) Empty Must-Haves section → empty array
 // ═══════════════════════════════════════════════════════════════════════════
 
-test('parseTaskPlanMustHaves: empty section', () => {
+console.log('\n=== parseTaskPlanMustHaves: empty section ===');
+{
   const content = `## Must-Haves
 
 ## Verification
@@ -132,14 +139,15 @@ test('parseTaskPlanMustHaves: empty section', () => {
 - Run tests
 `;
   const result = parseTaskPlanMustHaves(content);
-  assert.deepStrictEqual(result.length, 0, 'returns empty array when section is empty');
-});
+  assertEq(result.length, 0, 'returns empty array when section is empty');
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // (h) Content with YAML frontmatter
 // ═══════════════════════════════════════════════════════════════════════════
 
-test('parseTaskPlanMustHaves: YAML frontmatter', () => {
+console.log('\n=== parseTaskPlanMustHaves: YAML frontmatter ===');
+{
   const content = `---
 estimated_steps: 5
 estimated_files: 3
@@ -153,16 +161,16 @@ estimated_files: 3
 - [x] Checked must-have after frontmatter
 `;
   const result = parseTaskPlanMustHaves(content);
-  assert.deepStrictEqual(result.length, 2, 'frontmatter does not pollute results');
-  assert.deepStrictEqual(result[0].text, 'Real must-have after frontmatter', 'first item text correct');
-  assert.deepStrictEqual(result[0].checked, false, 'first item unchecked');
-  assert.deepStrictEqual(result[1].text, 'Checked must-have after frontmatter', 'second item text correct');
-  assert.deepStrictEqual(result[1].checked, true, 'second item checked');
-});
+  assertEq(result.length, 2, 'frontmatter does not pollute results');
+  assertEq(result[0].text, 'Real must-have after frontmatter', 'first item text correct');
+  assertEq(result[0].checked, false, 'first item unchecked');
+  assertEq(result[1].text, 'Checked must-have after frontmatter', 'second item text correct');
+  assertEq(result[1].checked, true, 'second item checked');
+}
 
 // Verify frontmatter content is not misinterpreted as must-haves
-
-test('parseTaskPlanMustHaves: frontmatter-only content', () => {
+console.log('\n=== parseTaskPlanMustHaves: frontmatter-only content ===');
+{
   const content = `---
 estimated_steps: 5
 estimated_files: 3
@@ -175,14 +183,15 @@ estimated_files: 3
 No must-haves section here.
 `;
   const result = parseTaskPlanMustHaves(content);
-  assert.deepStrictEqual(result.length, 0, 'frontmatter-only content returns empty array');
-});
+  assertEq(result.length, 0, 'frontmatter-only content returns empty array');
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // (i) Real task plan format (based on S01/T01-PLAN.md structure)
 // ═══════════════════════════════════════════════════════════════════════════
 
-test('parseTaskPlanMustHaves: real task plan format', () => {
+console.log('\n=== parseTaskPlanMustHaves: real task plan format ===');
+{
   const content = `---
 estimated_steps: 5
 estimated_files: 3
@@ -230,37 +239,40 @@ Add the \`completing-milestone\` phase to the GSD state machine.
 - \`agent/extensions/gsd/types.ts\` — Phase union includes \`'completing-milestone'\`
 `;
   const result = parseTaskPlanMustHaves(content);
-  assert.deepStrictEqual(result.length, 5, 'real plan has 5 must-haves');
-  assert.ok(result[0].text.includes('`Phase` type includes'), 'first must-have text matches');
-  assert.ok(result[1].text.includes('`deriveState` returns'), 'second must-have text matches');
-  assert.deepStrictEqual(result[0].checked, false, 'all real must-haves are unchecked');
-  assert.deepStrictEqual(result[4].checked, false, 'last real must-have is unchecked');
-  assert.ok(result[4].text.includes('multi-milestone'), 'last must-have references multi-milestone');
-});
+  assertEq(result.length, 5, 'real plan has 5 must-haves');
+  assertTrue(result[0].text.includes('`Phase` type includes'), 'first must-have text matches');
+  assertTrue(result[1].text.includes('`deriveState` returns'), 'second must-have text matches');
+  assertEq(result[0].checked, false, 'all real must-haves are unchecked');
+  assertEq(result[4].checked, false, 'last real must-have is unchecked');
+  assertTrue(result[4].text.includes('multi-milestone'), 'last must-have references multi-milestone');
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Edge cases
 // ═══════════════════════════════════════════════════════════════════════════
 
-test('parseTaskPlanMustHaves: empty string', () => {
+console.log('\n=== parseTaskPlanMustHaves: empty string ===');
+{
   const result = parseTaskPlanMustHaves('');
-  assert.deepStrictEqual(result.length, 0, 'empty string returns empty array');
-});
+  assertEq(result.length, 0, 'empty string returns empty array');
+}
 
-test('parseTaskPlanMustHaves: must-haves with inline code and backticks', () => {
+console.log('\n=== parseTaskPlanMustHaves: must-haves with inline code and backticks ===');
+{
   const content = `## Must-Haves
 
 - [ ] \`functionName\` is exported from \`module.ts\`
 - [x] Returns \`Array<{ text: string }>\` with correct extraction
 `;
   const result = parseTaskPlanMustHaves(content);
-  assert.deepStrictEqual(result.length, 2, 'handles backtick content');
-  assert.ok(result[0].text.includes('`functionName`'), 'preserves backticks in text');
-  assert.deepStrictEqual(result[0].checked, false, 'backtick item unchecked');
-  assert.deepStrictEqual(result[1].checked, true, 'backtick item checked');
-});
-
-test('parseTaskPlanMustHaves: asterisk bullets', () => {
+  assertEq(result.length, 2, 'handles backtick content');
+  assertTrue(result[0].text.includes('`functionName`'), 'preserves backticks in text');
+  assertEq(result[0].checked, false, 'backtick item unchecked');
+  assertEq(result[1].checked, true, 'backtick item checked');
+}
+
+console.log('\n=== parseTaskPlanMustHaves: asterisk bullets ===');
+{
   const content = `## Must-Haves
 
 * [ ] Asterisk unchecked
@@ -268,11 +280,12 @@ test('parseTaskPlanMustHaves: asterisk bullets', () => {
 * Plain asterisk
 `;
   const result = parseTaskPlanMustHaves(content);
-  assert.deepStrictEqual(result.length, 3, 'handles asterisk bullets');
-  assert.deepStrictEqual(result[0].checked, false, 'asterisk unchecked');
-  assert.deepStrictEqual(result[1].checked, true, 'asterisk checked');
-  assert.deepStrictEqual(result[2].checked, false, 'plain asterisk unchecked');
-});
+  assertEq(result.length, 3, 'handles asterisk bullets');
+  assertEq(result[0].checked, false, 'asterisk unchecked');
+  assertEq(result[1].checked, true, 'asterisk checked');
+  assertEq(result[2].checked, false, 'plain asterisk unchecked');
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 
+report();

package/src/resources/extensions/gsd/tests/none-mode-gates.test.ts

@@ -19,8 +19,9 @@ import { shouldUseWorktreeIsolation } from "../auto.ts";
 import { getIsolationMode } from "../preferences.ts";
 import { getActiveAutoWorktreeContext } from "../auto-worktree.ts";
 import { invalidateAllCaches } from "../cache.ts";
-import { describe, test, beforeEach, afterEach } from 'node:test';
-import assert from 'node:assert/strict';
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertEq, assertTrue, report } = createTestContext();
 
 // --- Preferences helpers (same pattern as doctor-git.test.ts K001) ---
 
@@ -37,77 +38,77 @@ function removeRunnerPreferences(): void {
 
 // --- Tests ---
 
-test('shouldUseWorktreeIsolation returns false for none', () => {
+// Test 1: shouldUseWorktreeIsolation returns false for none
+console.log("Test 1: shouldUseWorktreeIsolation returns false for none");
 try {
   writeRunnerPreferences("none");
   invalidateAllCaches();
-  assert.deepStrictEqual(shouldUseWorktreeIsolation(), false, "shouldUseWorktreeIsolation() with none prefs");
+  assertEq(shouldUseWorktreeIsolation(), false, "shouldUseWorktreeIsolation() with none prefs");
 } finally {
   removeRunnerPreferences();
   invalidateAllCaches();
 }
-});
 
-test('shouldUseWorktreeIsolation returns false for branch', () => {
+// Test 2: shouldUseWorktreeIsolation returns false for branch
+console.log("Test 2: shouldUseWorktreeIsolation returns false for branch");
 try {
   writeRunnerPreferences("branch");
   invalidateAllCaches();
-  assert.deepStrictEqual(shouldUseWorktreeIsolation(), false, "shouldUseWorktreeIsolation() with branch prefs");
+  assertEq(shouldUseWorktreeIsolation(), false, "shouldUseWorktreeIsolation() with branch prefs");
 } finally {
   removeRunnerPreferences();
   invalidateAllCaches();
 }
-});
 
-test('shouldUseWorktreeIsolation returns true for worktree', () => {
+// Test 3: shouldUseWorktreeIsolation returns true for worktree
+console.log("Test 3: shouldUseWorktreeIsolation returns true for worktree");
 try {
   writeRunnerPreferences("worktree");
   invalidateAllCaches();
-  assert.deepStrictEqual(shouldUseWorktreeIsolation(), true, "shouldUseWorktreeIsolation() with worktree prefs");
+  assertEq(shouldUseWorktreeIsolation(), true, "shouldUseWorktreeIsolation() with worktree prefs");
 } finally {
   removeRunnerPreferences();
   invalidateAllCaches();
 }
-});
 
 // Test 4: shouldUseWorktreeIsolation returns true for no prefs (default)
 // Skip if global prefs exist — they override the default and this test
 // cannot control ~/.gsd/preferences.md.
-
-test('shouldUseWorktreeIsolation returns true for no prefs (default)', () => {
-  const globalPrefsExist = existsSync(join(homedir(), ".gsd", "preferences.md"))
-    || existsSync(join(homedir(), ".gsd", "PREFERENCES.md"));
-  if (!globalPrefsExist) {
-    try {
-      removeRunnerPreferences(); // ensure no prefs file
-      invalidateAllCaches();
-      assert.deepStrictEqual(shouldUseWorktreeIsolation(), true, "shouldUseWorktreeIsolation() with no prefs (default worktree)");
-    } finally {
-      invalidateAllCaches();
-    }
-  } else {
+const globalPrefsExist = existsSync(join(homedir(), ".gsd", "preferences.md"))
+  || existsSync(join(homedir(), ".gsd", "PREFERENCES.md"));
+if (!globalPrefsExist) {
+  console.log("Test 4: shouldUseWorktreeIsolation returns true for no prefs (default)");
+  try {
+    removeRunnerPreferences(); // ensure no prefs file
+    invalidateAllCaches();
+    assertEq(shouldUseWorktreeIsolation(), true, "shouldUseWorktreeIsolation() with no prefs (default worktree)");
+  } finally {
+    invalidateAllCaches();
   }
-});
+} else {
+  console.log("Test 4: SKIPPED — global prefs file exists, cannot test bare default");
+}
 
-test('getIsolationMode returns "none" with none prefs', () => {
+// Test 5: getIsolationMode returns "none" with none prefs
+console.log("Test 5: getIsolationMode returns 'none' with none prefs");
 try {
   writeRunnerPreferences("none");
   invalidateAllCaches();
-  assert.deepStrictEqual(getIsolationMode(), "none", "getIsolationMode() with none prefs");
+  assertEq(getIsolationMode(), "none", "getIsolationMode() with none prefs");
 } finally {
   removeRunnerPreferences();
   invalidateAllCaches();
 }
-});
 
-test('getActiveAutoWorktreeContext returns null at baseline', () => {
-assert.deepStrictEqual(getActiveAutoWorktreeContext(), null, "getActiveAutoWorktreeContext() returns null without enterAutoWorktree()");
-});
+// Test 6: getActiveAutoWorktreeContext returns null at baseline
+console.log("Test 6: getActiveAutoWorktreeContext returns null at baseline");
+assertEq(getActiveAutoWorktreeContext(), null, "getActiveAutoWorktreeContext() returns null without enterAutoWorktree()");
 
 // Test 7: System prompt worktree block absent without active worktree
-
-test('Test 7: System prompt worktree block absent without active worktree', () => {
+console.log("Test 7: System prompt worktree block absent without active worktree");
+{
   const ctx = getActiveAutoWorktreeContext();
-  assert.ok(ctx === null, "getActiveAutoWorktreeContext() null confirms system prompt worktree block will not be injected");
-});
+  assertTrue(ctx === null, "getActiveAutoWorktreeContext() null confirms system prompt worktree block will not be injected");
+}
 
+report();