gsd-pi 2.44.0 → 2.45.0-dev.e0ee972

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

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

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

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