gsd-pi 2.32.0-dev.f3d5d53 → 2.33.0-dev.69bff0f

package/dist/resources/extensions/gsd/tests/roadmap-parse-regression.test.ts

@@ -0,0 +1,358 @@
+/**
+ * roadmap-parse-regression.test.ts — Regression tests for roadmap parsing.
+ *
+ * Exercises parseRoadmapSlices() and the prose fallback parser against
+ * every known LLM-generated roadmap variant that has caused production bugs.
+ *
+ * Regression coverage for:
+ *   #807   Prose slice headers not parsed → "No slice eligible" block
+ *   #1248  Prose header regex only matched H2 with colon separator
+ *   #1243  Same root cause as #1248
+ *
+ * Also covers dependency expansion (range syntax) and edge cases.
+ */
+
+import { parseRoadmapSlices, expandDependencies } from '../roadmap-slices.ts';
+import { createTestContext } from './test-helpers.ts';
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+async function main(): Promise<void> {
+
+  // ═══════════════════════════════════════════════════════════════════════
+  // A. Standard machine-readable format (should always work)
+  // ═══════════════════════════════════════════════════════════════════════
+
+  console.log('\n=== A. Standard checkbox format ===');
+
+  {
+    const content = [
+      '# M001: Test Project',
+      '',
+      '## Slices',
+      '',
+      '- [ ] **S01: First Slice** `risk:low` `depends:[]`',
+      '- [ ] **S02: Second Slice** `risk:medium` `depends:[S01]`',
+      '- [x] **S03: Third Slice** `risk:high` `depends:[S01,S02]`',
+      '',
+      '## Boundary Map',
+      '',
+    ].join('\n');
+
+    const slices = parseRoadmapSlices(content);
+    assertEq(slices.length, 3, 'standard format: 3 slices');
+    assertEq(slices[0].id, 'S01', 'S01 id');
+    assertEq(slices[0].title, 'First Slice', 'S01 title');
+    assertEq(slices[0].done, false, 'S01 not done');
+    assertEq(slices[0].risk, 'low', 'S01 risk');
+    assertEq(slices[0].depends.length, 0, 'S01 no deps');
+
+    assertEq(slices[1].id, 'S02', 'S02 id');
+    assertEq(slices[1].depends.length, 1, 'S02 has 1 dep');
+    assertEq(slices[1].depends[0], 'S01', 'S02 depends on S01');
+
+    assertEq(slices[2].id, 'S03', 'S03 id');
+    assertEq(slices[2].done, true, 'S03 is done');
+    assertEq(slices[2].risk, 'high', 'S03 risk');
+    assertEq(slices[2].depends.length, 2, 'S03 has 2 deps');
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════
+  // B. Prose fallback: H2 with colon (the only format the old regex matched)
+  // ═══════════════════════════════════════════════════════════════════════
+
+  console.log('\n=== B. Prose fallback: H2 with colon ===');
+
+  {
+    const content = [
+      '# M001: Test',
+      '',
+      '## S01: Setup Foundation',
+      '',
+      'Do the setup work.',
+      '',
+      '## S02: Core Features',
+      '',
+      'Build the features.',
+      '',
+    ].join('\n');
+
+    const slices = parseRoadmapSlices(content);
+    assertEq(slices.length, 2, 'prose H2 colon: 2 slices');
+    assertEq(slices[0].id, 'S01', 'S01 id');
+    assertEq(slices[0].title, 'Setup Foundation', 'S01 title');
+    assertEq(slices[1].id, 'S02', 'S02 id');
+    assertEq(slices[1].title, 'Core Features', 'S02 title');
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════
+  // C. Regression #1248: H3 headers (the old regex only matched ##)
+  // ═══════════════════════════════════════════════════════════════════════
+
+  console.log('\n=== C. #1248: H3 headers ===');
+
+  {
+    const content = [
+      '# M001: Test',
+      '',
+      '### S01: Setup Foundation',
+      '',
+      'Do the setup work.',
+      '',
+      '### S02: Core Features',
+      '',
+      'Build the features.',
+      '',
+    ].join('\n');
+
+    const slices = parseRoadmapSlices(content);
+    assertEq(slices.length, 2, '#1248 H3: 2 slices parsed');
+    assertEq(slices[0].id, 'S01', 'S01 from H3');
+    assertEq(slices[1].id, 'S02', 'S02 from H3');
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════
+  // D. Regression #1248: H4 headers
+  // ═══════════════════════════════════════════════════════════════════════
+
+  console.log('\n=== D. #1248: H4 headers ===');
+
+  {
+    const content = [
+      '# M001: Test',
+      '',
+      '#### S01: Setup Foundation',
+      '',
+      '#### S02: Core Features',
+      '',
+    ].join('\n');
+
+    const slices = parseRoadmapSlices(content);
+    assertEq(slices.length, 2, '#1248 H4: 2 slices parsed');
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════
+  // E. Regression #1248: H1 header (unusual but LLMs produce it)
+  // ═══════════════════════════════════════════════════════════════════════
+
+  console.log('\n=== E. #1248: H1 headers ===');
+
+  {
+    const content = [
+      '# S01: Setup Foundation',
+      '',
+      'Setup stuff.',
+      '',
+      '# S02: Core Features',
+      '',
+      'Build stuff.',
+      '',
+    ].join('\n');
+
+    const slices = parseRoadmapSlices(content);
+    assertEq(slices.length, 2, '#1248 H1: 2 slices parsed');
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════
+  // F. Regression #1248: Bold-wrapped IDs
+  // ═══════════════════════════════════════════════════════════════════════
+
+  console.log('\n=== F. #1248: Bold-wrapped ===');
+
+  {
+    const content1 = '## **S01: Setup Foundation**\n\nDo stuff.\n\n## **S02: Features**\n\nMore stuff.\n';
+    const slices1 = parseRoadmapSlices(content1);
+    assertEq(slices1.length, 2, 'bold-wrapped: 2 slices');
+    assertEq(slices1[0].title, 'Setup Foundation', 'bold-wrapped: title extracted without bold');
+
+    const content2 = '## **S01**: Setup Foundation\n\n## **S02**: Features\n';
+    const slices2 = parseRoadmapSlices(content2);
+    assertEq(slices2.length, 2, 'bold ID only: 2 slices');
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════
+  // G. Regression #1248: Dot separator
+  // ═══════════════════════════════════════════════════════════════════════
+
+  console.log('\n=== G. #1248: Dot separator ===');
+
+  {
+    const content = '## S01. Setup Foundation\n\n## S02. Core Features\n';
+    const slices = parseRoadmapSlices(content);
+    assertEq(slices.length, 2, 'dot separator: 2 slices');
+    assertEq(slices[0].title, 'Setup Foundation', 'dot separator: title');
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════
+  // H. Regression #1248: Em dash separator
+  // ═══════════════════════════════════════════════════════════════════════
+
+  console.log('\n=== H. #1248: Em/en dash separators ===');
+
+  {
+    const content = '## S01 — Setup Foundation\n\n## S02 – Core Features\n';
+    const slices = parseRoadmapSlices(content);
+    assertEq(slices.length, 2, 'em/en dash: 2 slices');
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════
+  // I. Regression #1248: Space-only separator (no punctuation)
+  // ═══════════════════════════════════════════════════════════════════════
+
+  console.log('\n=== I. #1248: Space-only separator ===');
+
+  {
+    const content = '## S01 Setup Foundation\n\n## S02 Core Features\n';
+    const slices = parseRoadmapSlices(content);
+    assertEq(slices.length, 2, 'space-only: 2 slices');
+    assertEq(slices[0].title, 'Setup Foundation', 'space-only: title');
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════
+  // J. Regression #1248: Non-zero-padded IDs
+  // ═══════════════════════════════════════════════════════════════════════
+
+  console.log('\n=== J. #1248: Non-zero-padded IDs ===');
+
+  {
+    const content = '## S1: Setup\n\n## S2: Features\n';
+    const slices = parseRoadmapSlices(content);
+    assertEq(slices.length, 2, 'non-padded: 2 slices');
+    assertEq(slices[0].id, 'S1', 'non-padded: S1');
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════
+  // K. Regression #1248: "Slice" prefix
+  // ═══════════════════════════════════════════════════════════════════════
+
+  console.log('\n=== K. #1248: "Slice" prefix ===');
+
+  {
+    const content = '## Slice S01: Setup Foundation\n\n## Slice S02: Core Features\n';
+    const slices = parseRoadmapSlices(content);
+    assertEq(slices.length, 2, 'Slice prefix: 2 slices');
+    assertEq(slices[0].id, 'S01', 'Slice prefix: S01');
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════
+  // L. Prose with "Depends on:" line
+  // ═══════════════════════════════════════════════════════════════════════
+
+  console.log('\n=== L. Prose with Depends on: ===');
+
+  {
+    const content = [
+      '## S01: Foundation',
+      '',
+      'Build the base.',
+      '',
+      '## S02: Features',
+      '',
+      '**Depends on:** S01',
+      '',
+      'Build features.',
+    ].join('\n');
+
+    const slices = parseRoadmapSlices(content);
+    assertEq(slices.length, 2, 'prose deps: 2 slices');
+    assertEq(slices[1].depends.length, 1, 'S02 has 1 dep');
+    assertEq(slices[1].depends[0], 'S01', 'S02 depends on S01');
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════
+  // M. Empty / edge cases
+  // ═══════════════════════════════════════════════════════════════════════
+
+  console.log('\n=== M. Edge cases ===');
+
+  {
+    assertEq(parseRoadmapSlices('').length, 0, 'empty content → 0 slices');
+    assertEq(parseRoadmapSlices('# Just a title\n\nSome text.').length, 0, 'no slices at all → 0');
+
+    // Mixed format: ## Slices section with one checkbox + prose below
+    const mixed = [
+      '## Slices',
+      '',
+      '- [ ] **S01: Foundation** `risk:low` `depends:[]`',
+      '',
+      '## S02: Features',
+      '',
+      'Prose content.',
+    ].join('\n');
+    const mixedSlices = parseRoadmapSlices(mixed);
+    // The ## Slices section takes priority — prose headers outside it aren't picked up
+    assertEq(mixedSlices.length, 1, 'mixed: only 1 slice from ## Slices section');
+    assertEq(mixedSlices[0].id, 'S01', 'mixed: S01 from checkbox');
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════
+  // N. Dependency range expansion
+  // ═══════════════════════════════════════════════════════════════════════
+
+  console.log('\n=== N. Dependency range expansion ===');
+
+  {
+    assertEq(
+      expandDependencies(['S01-S04']),
+      ['S01', 'S02', 'S03', 'S04'],
+      'S01-S04 → 4 individual deps',
+    );
+
+    assertEq(
+      expandDependencies(['S01..S03']),
+      ['S01', 'S02', 'S03'],
+      'S01..S03 → 3 individual deps',
+    );
+
+    assertEq(
+      expandDependencies(['S01']),
+      ['S01'],
+      'single dep passes through',
+    );
+
+    assertEq(
+      expandDependencies(['S01', 'S03-S05']),
+      ['S01', 'S03', 'S04', 'S05'],
+      'mixed single + range',
+    );
+
+    assertEq(
+      expandDependencies(['']),
+      [],
+      'empty string filtered out',
+    );
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════
+  // O. No-separator colon-less: "S01:Title" (no space after colon)
+  // ═══════════════════════════════════════════════════════════════════════
+
+  console.log('\n=== O. No space after colon ===');
+
+  {
+    const content = '## S01:Foundation\n\n## S02:Features\n';
+    const slices = parseRoadmapSlices(content);
+    // The regex uses [:\s.—–-]* which allows colon with no space
+    assertEq(slices.length, 2, 'no-space-colon: 2 slices');
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════
+  // P. Three-digit padded IDs
+  // ═══════════════════════════════════════════════════════════════════════
+
+  console.log('\n=== P. Three-digit padded IDs ===');
+
+  {
+    const content = '## S001: Foundation\n\n## S002: Features\n';
+    const slices = parseRoadmapSlices(content);
+    assertEq(slices.length, 2, 'three-digit: 2 slices');
+    assertEq(slices[0].id, 'S001', 'three-digit: S001');
+  }
+
+  report();
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

package/dist/resources/extensions/gsd/tests/session-lock-regression.test.ts

@@ -0,0 +1,216 @@
+/**
+ * session-lock-regression.test.ts — Regression tests for session lock lifecycle.
+ *
+ * Regression coverage for:
+ *   #1257  False-positive "Session lock lost" during auto-mode
+ *   #1245  Stranded .gsd.lock/ directory preventing new sessions
+ *   #1251  Same root cause as #1245
+ *
+ * Tests the acquire → validate → release lifecycle and edge cases
+ * without requiring concurrent processes.
+ */
+
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import {
+  acquireSessionLock,
+  validateSessionLock,
+  releaseSessionLock,
+  readSessionLockData,
+  updateSessionLock,
+  isSessionLockHeld,
+} from '../session-lock.ts';
+import { gsdRoot } from '../paths.ts';
+import { createTestContext } from './test-helpers.ts';
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+async function main(): Promise<void> {
+
+  // ─── 1. Basic acquire/release lifecycle ───────────────────────────────
+  console.log('\n=== 1. acquire → validate → release lifecycle ===');
+  {
+    const base = mkdtempSync(join(tmpdir(), 'gsd-session-lock-'));
+    mkdirSync(join(base, '.gsd'), { recursive: true });
+
+    try {
+      const result = acquireSessionLock(base);
+      assertTrue(result.acquired, 'lock acquired successfully');
+
+      const valid = validateSessionLock(base);
+      assertTrue(valid, 'lock validates after acquisition');
+
+      assertTrue(isSessionLockHeld(base), 'isSessionLockHeld returns true');
+
+      releaseSessionLock(base);
+
+      // After release, the lock file should be cleaned up
+      const lockFile = join(gsdRoot(base), 'auto.lock');
+      assertTrue(!existsSync(lockFile), 'lock file removed after release');
+
+      // The .gsd.lock/ directory should be cleaned up
+      const lockDir = gsdRoot(base) + '.lock';
+      assertTrue(!existsSync(lockDir), '.gsd.lock/ directory removed after release (#1245)');
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
+  }
+
+  // ─── 2. Double release is safe ────────────────────────────────────────
+  console.log('\n=== 2. double release does not throw ===');
+  {
+    const base = mkdtempSync(join(tmpdir(), 'gsd-session-lock-'));
+    mkdirSync(join(base, '.gsd'), { recursive: true });
+
+    try {
+      acquireSessionLock(base);
+      releaseSessionLock(base);
+      // Second release should not throw
+      let threw = false;
+      try {
+        releaseSessionLock(base);
+      } catch {
+        threw = true;
+      }
+      assertTrue(!threw, 'double release does not throw');
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
+  }
+
+  // ─── 3. updateSessionLock preserves lock data ─────────────────────────
+  console.log('\n=== 3. updateSessionLock writes metadata ===');
+  {
+    const base = mkdtempSync(join(tmpdir(), 'gsd-session-lock-'));
+    mkdirSync(join(base, '.gsd'), { recursive: true });
+
+    try {
+      acquireSessionLock(base);
+
+      updateSessionLock(base, 'execute-task', 'M001/S01/T01', 5, '/tmp/session.json');
+
+      const data = readSessionLockData(base);
+      assertTrue(data !== null, 'lock data readable after update');
+      if (data) {
+        assertEq(data.pid, process.pid, 'lock data has correct PID');
+        assertEq(data.unitType, 'execute-task', 'lock data has correct unit type');
+        assertEq(data.unitId, 'M001/S01/T01', 'lock data has correct unit ID');
+        assertEq(data.completedUnits, 5, 'lock data has correct completed count');
+        assertEq(data.sessionFile, '/tmp/session.json', 'lock data has session file');
+      }
+
+      releaseSessionLock(base);
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
+  }
+
+  // ─── 4. Stale lock from dead PID → re-acquirable (#1245) ─────────────
+  console.log('\n=== 4. stale lock from dead PID → re-acquirable ===');
+  {
+    const base = mkdtempSync(join(tmpdir(), 'gsd-session-lock-'));
+    mkdirSync(join(base, '.gsd'), { recursive: true });
+
+    try {
+      // Write a lock file with a definitely-dead PID
+      const lockFile = join(gsdRoot(base), 'auto.lock');
+      const staleLock = {
+        pid: 99999999, // extremely unlikely to be alive
+        startedAt: new Date(Date.now() - 3600000).toISOString(),
+        unitType: 'execute-task',
+        unitId: 'M001/S01/T01',
+        unitStartedAt: new Date(Date.now() - 3600000).toISOString(),
+        completedUnits: 3,
+      };
+      writeFileSync(lockFile, JSON.stringify(staleLock, null, 2));
+
+      // Should be able to acquire despite the stale lock
+      const result = acquireSessionLock(base);
+      assertTrue(result.acquired, '#1245: stale lock from dead PID → re-acquirable');
+
+      releaseSessionLock(base);
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
+  }
+
+  // ─── 5. readSessionLockData with no lock → null ───────────────────────
+  console.log('\n=== 5. readSessionLockData with no lock → null ===');
+  {
+    const base = mkdtempSync(join(tmpdir(), 'gsd-session-lock-'));
+    mkdirSync(join(base, '.gsd'), { recursive: true });
+
+    try {
+      const data = readSessionLockData(base);
+      assertEq(data, null, 'no lock file → null');
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
+  }
+
+  // ─── 6. validateSessionLock after own acquisition → true ──────────────
+  console.log('\n=== 6. validateSessionLock after own acquisition → true ===');
+  {
+    const base = mkdtempSync(join(tmpdir(), 'gsd-session-lock-'));
+    mkdirSync(join(base, '.gsd'), { recursive: true });
+
+    try {
+      acquireSessionLock(base);
+
+      // Multiple validations should all return true (regression for #1257)
+      for (let i = 0; i < 5; i++) {
+        const valid = validateSessionLock(base);
+        assertTrue(valid, `#1257: validation ${i + 1} returns true for own lock`);
+      }
+
+      releaseSessionLock(base);
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
+  }
+
+  // ─── 7. readSessionLockData with corrupt JSON → null ──────────────────
+  console.log('\n=== 7. corrupt lock file → null ===');
+  {
+    const base = mkdtempSync(join(tmpdir(), 'gsd-session-lock-'));
+    mkdirSync(join(base, '.gsd'), { recursive: true });
+
+    try {
+      const lockFile = join(gsdRoot(base), 'auto.lock');
+      writeFileSync(lockFile, 'NOT VALID JSON {{{');
+
+      const data = readSessionLockData(base);
+      assertEq(data, null, 'corrupt JSON → null');
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
+  }
+
+  // ─── 8. Acquire after release is possible ─────────────────────────────
+  console.log('\n=== 8. acquire after release → re-acquirable ===');
+  {
+    const base = mkdtempSync(join(tmpdir(), 'gsd-session-lock-'));
+    mkdirSync(join(base, '.gsd'), { recursive: true });
+
+    try {
+      const r1 = acquireSessionLock(base);
+      assertTrue(r1.acquired, 'first acquisition');
+      releaseSessionLock(base);
+
+      const r2 = acquireSessionLock(base);
+      assertTrue(r2.acquired, 're-acquisition after release');
+      releaseSessionLock(base);
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
+  }
+
+  report();
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});