gsd-pi 2.5.1 → 2.6.0

package/src/resources/extensions/gsd/tests/manifest-status.test.ts

@@ -0,0 +1,283 @@
+/**
+ * Tests for getManifestStatus() — the S01→S02 boundary contract.
+ *
+ * Verifies that manifest entries are correctly categorized into
+ * pending, collected, skipped, and existing arrays based on
+ * manifest status and environment presence.
+ *
+ * Uses temp directories with real .gsd/milestones/M001/ structure.
+ */
+
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdirSync, writeFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { getManifestStatus } from '../files.ts';
+
+function makeTempDir(prefix: string): string {
+  const dir = join(tmpdir(), `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+/** Create the .gsd/milestones/M001/ directory structure and write a secrets manifest. */
+function writeManifest(base: string, content: string): void {
+  const mDir = join(base, '.gsd', 'milestones', 'M001');
+  mkdirSync(mDir, { recursive: true });
+  writeFileSync(join(mDir, 'M001-SECRETS.md'), content);
+}
+
+// ─── Mixed statuses ──────────────────────────────────────────────────────────
+
+test('getManifestStatus: mixed statuses — categorizes entries correctly', async () => {
+  const tmp = makeTempDir('manifest-mixed');
+  const savedVal = process.env.GSD_TEST_EXISTING_KEY_001;
+  try {
+    process.env.GSD_TEST_EXISTING_KEY_001 = 'some-value';
+
+    writeManifest(tmp, `# Secrets Manifest
+
+**Milestone:** M001
+**Generated:** 2025-06-20T10:00:00Z
+
+### PENDING_KEY
+
+**Service:** SomeService
+**Status:** pending
+**Destination:** dotenv
+
+1. Get the key
+
+### COLLECTED_KEY
+
+**Service:** AnotherService
+**Status:** collected
+**Destination:** dotenv
+
+1. Already collected
+
+### SKIPPED_KEY
+
+**Service:** OptionalService
+**Status:** skipped
+**Destination:** dotenv
+
+1. Not needed
+
+### GSD_TEST_EXISTING_KEY_001
+
+**Service:** EnvService
+**Status:** pending
+**Destination:** dotenv
+
+1. Already in env
+`);
+
+    const result = await getManifestStatus(tmp, 'M001');
+    assert.notStrictEqual(result, null, 'should not be null');
+    assert.deepStrictEqual(result!.pending, ['PENDING_KEY']);
+    assert.deepStrictEqual(result!.collected, ['COLLECTED_KEY']);
+    assert.deepStrictEqual(result!.skipped, ['SKIPPED_KEY']);
+    assert.deepStrictEqual(result!.existing, ['GSD_TEST_EXISTING_KEY_001']);
+  } finally {
+    delete process.env.GSD_TEST_EXISTING_KEY_001;
+    if (savedVal !== undefined) process.env.GSD_TEST_EXISTING_KEY_001 = savedVal;
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+// ─── All pending ─────────────────────────────────────────────────────────────
+
+test('getManifestStatus: all pending — 3 pending entries, none in env', async () => {
+  const tmp = makeTempDir('manifest-pending');
+  try {
+    // Ensure none of these are in process.env
+    delete process.env.PEND_A;
+    delete process.env.PEND_B;
+    delete process.env.PEND_C;
+
+    writeManifest(tmp, `# Secrets Manifest
+
+**Milestone:** M001
+**Generated:** 2025-06-20T10:00:00Z
+
+### PEND_A
+
+**Service:** A
+**Status:** pending
+**Destination:** dotenv
+
+1. Step one
+
+### PEND_B
+
+**Service:** B
+**Status:** pending
+**Destination:** dotenv
+
+1. Step one
+
+### PEND_C
+
+**Service:** C
+**Status:** pending
+**Destination:** dotenv
+
+1. Step one
+`);
+
+    const result = await getManifestStatus(tmp, 'M001');
+    assert.notStrictEqual(result, null);
+    assert.deepStrictEqual(result!.pending, ['PEND_A', 'PEND_B', 'PEND_C']);
+    assert.deepStrictEqual(result!.collected, []);
+    assert.deepStrictEqual(result!.skipped, []);
+    assert.deepStrictEqual(result!.existing, []);
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+// ─── All collected ───────────────────────────────────────────────────────────
+
+test('getManifestStatus: all collected — 2 collected entries, none in env', async () => {
+  const tmp = makeTempDir('manifest-collected');
+  try {
+    delete process.env.COLL_X;
+    delete process.env.COLL_Y;
+
+    writeManifest(tmp, `# Secrets Manifest
+
+**Milestone:** M001
+**Generated:** 2025-06-20T10:00:00Z
+
+### COLL_X
+
+**Service:** X
+**Status:** collected
+**Destination:** dotenv
+
+1. Done
+
+### COLL_Y
+
+**Service:** Y
+**Status:** collected
+**Destination:** dotenv
+
+1. Done
+`);
+
+    const result = await getManifestStatus(tmp, 'M001');
+    assert.notStrictEqual(result, null);
+    assert.deepStrictEqual(result!.pending, []);
+    assert.deepStrictEqual(result!.collected, ['COLL_X', 'COLL_Y']);
+    assert.deepStrictEqual(result!.skipped, []);
+    assert.deepStrictEqual(result!.existing, []);
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+// ─── Key in env overrides manifest status ────────────────────────────────────
+
+test('getManifestStatus: key in env overrides manifest status — collected key in env goes to existing', async () => {
+  const tmp = makeTempDir('manifest-override');
+  const savedVal = process.env.GSD_TEST_OVERRIDE_KEY;
+  try {
+    process.env.GSD_TEST_OVERRIDE_KEY = 'already-here';
+
+    writeManifest(tmp, `# Secrets Manifest
+
+**Milestone:** M001
+**Generated:** 2025-06-20T10:00:00Z
+
+### GSD_TEST_OVERRIDE_KEY
+
+**Service:** Override
+**Status:** collected
+**Destination:** dotenv
+
+1. Was collected but now in env
+`);
+
+    const result = await getManifestStatus(tmp, 'M001');
+    assert.notStrictEqual(result, null);
+    assert.deepStrictEqual(result!.pending, []);
+    assert.deepStrictEqual(result!.collected, []);
+    assert.deepStrictEqual(result!.skipped, []);
+    assert.deepStrictEqual(result!.existing, ['GSD_TEST_OVERRIDE_KEY']);
+  } finally {
+    delete process.env.GSD_TEST_OVERRIDE_KEY;
+    if (savedVal !== undefined) process.env.GSD_TEST_OVERRIDE_KEY = savedVal;
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+// ─── Missing manifest ────────────────────────────────────────────────────────
+
+test('getManifestStatus: missing manifest — returns null', async () => {
+  const tmp = makeTempDir('manifest-missing');
+  try {
+    // No .gsd directory at all
+    const result = await getManifestStatus(tmp, 'M001');
+    assert.strictEqual(result, null);
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+// ─── Empty manifest (no entries) ─────────────────────────────────────────────
+
+test('getManifestStatus: empty manifest — exists but no H3 sections', async () => {
+  const tmp = makeTempDir('manifest-empty');
+  try {
+    writeManifest(tmp, `# Secrets Manifest
+
+**Milestone:** M001
+**Generated:** 2025-06-20T10:00:00Z
+`);
+
+    const result = await getManifestStatus(tmp, 'M001');
+    assert.notStrictEqual(result, null);
+    assert.deepStrictEqual(result!.pending, []);
+    assert.deepStrictEqual(result!.collected, []);
+    assert.deepStrictEqual(result!.skipped, []);
+    assert.deepStrictEqual(result!.existing, []);
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+// ─── Env via .env file (not just process.env) ────────────────────────────────
+
+test('getManifestStatus: key in .env file counts as existing', async () => {
+  const tmp = makeTempDir('manifest-dotenv');
+  try {
+    delete process.env.DOTENV_ONLY_KEY;
+
+    writeManifest(tmp, `# Secrets Manifest
+
+**Milestone:** M001
+**Generated:** 2025-06-20T10:00:00Z
+
+### DOTENV_ONLY_KEY
+
+**Service:** DotenvService
+**Status:** pending
+**Destination:** dotenv
+
+1. Get key
+`);
+
+    // Write a .env file at the project root with the key
+    writeFileSync(join(tmp, '.env'), 'DOTENV_ONLY_KEY=from-dotenv-file\n');
+
+    const result = await getManifestStatus(tmp, 'M001');
+    assert.notStrictEqual(result, null);
+    assert.deepStrictEqual(result!.existing, ['DOTENV_ONLY_KEY']);
+    assert.deepStrictEqual(result!.pending, []);
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/parsers.test.ts

@@ -1488,6 +1488,196 @@ console.log('\n=== parseSecretsManifest + formatSecretsManifest: round-trip ==='
   }
 }
 
+// ═══════════════════════════════════════════════════════════════════════════
+// LLM-style round-trip tests — realistic manifest variations
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== LLM round-trip: extra whitespace ===');
+{
+  // LLMs often produce inconsistent indentation and trailing spaces
+  const messy = `# Secrets Manifest
+
+**Milestone:**   M010  
+**Generated:**   2025-07-01T12:00:00Z  
+
+###   OPENAI_API_KEY  
+
+**Service:**   OpenAI  
+**Dashboard:**   https://platform.openai.com/api-keys  
+**Format hint:**   starts with sk-  
+**Status:**   pending  
+**Destination:**   dotenv  
+
+1.   Go to the API keys page  
+2.   Create a new key  
+
+###   REDIS_URL  
+
+**Service:**   Upstash  
+**Status:**   collected  
+**Destination:**   vercel  
+
+1.   Open console  
+`;
+
+  const parsed1 = parseSecretsManifest(messy);
+  const formatted = formatSecretsManifest(parsed1);
+  const parsed2 = parseSecretsManifest(formatted);
+
+  assertEq(parsed2.milestone, parsed1.milestone, 'whitespace round-trip milestone');
+  assertEq(parsed2.generatedAt, parsed1.generatedAt, 'whitespace round-trip generatedAt');
+  assertEq(parsed2.entries.length, parsed1.entries.length, 'whitespace round-trip entry count');
+  assertEq(parsed2.entries.length, 2, 'whitespace: two entries parsed');
+
+  for (let i = 0; i < parsed1.entries.length; i++) {
+    const e1 = parsed1.entries[i];
+    const e2 = parsed2.entries[i];
+    assertEq(e2.key, e1.key, `whitespace round-trip entry ${i} key`);
+    assertEq(e2.service, e1.service, `whitespace round-trip entry ${i} service`);
+    assertEq(e2.dashboardUrl, e1.dashboardUrl, `whitespace round-trip entry ${i} dashboardUrl`);
+    assertEq(e2.formatHint, e1.formatHint, `whitespace round-trip entry ${i} formatHint`);
+    assertEq(e2.status, e1.status, `whitespace round-trip entry ${i} status`);
+    assertEq(e2.destination, e1.destination, `whitespace round-trip entry ${i} destination`);
+    assertEq(e2.guidance.length, e1.guidance.length, `whitespace round-trip entry ${i} guidance length`);
+    for (let j = 0; j < e1.guidance.length; j++) {
+      assertEq(e2.guidance[j], e1.guidance[j], `whitespace round-trip entry ${i} guidance[${j}]`);
+    }
+  }
+
+  // Verify the parser correctly stripped trailing whitespace
+  assertEq(parsed1.milestone, 'M010', 'whitespace: milestone trimmed');
+  assertEq(parsed1.entries[0].key, 'OPENAI_API_KEY', 'whitespace: key trimmed');
+  assertEq(parsed1.entries[0].service, 'OpenAI', 'whitespace: service trimmed');
+}
+
+console.log('\n=== LLM round-trip: missing optional fields ===');
+{
+  // LLMs may omit Dashboard and Format hint lines entirely
+  const minimal = `# Secrets Manifest
+
+**Milestone:** M011
+**Generated:** 2025-07-02T08:00:00Z
+
+### DATABASE_URL
+
+**Service:** Neon
+**Status:** pending
+**Destination:** dotenv
+
+1. Create a Neon project
+2. Copy connection string
+
+### WEBHOOK_SECRET
+
+**Service:** Stripe
+**Status:** collected
+**Destination:** dotenv
+
+1. Go to webhooks
+`;
+
+  const parsed1 = parseSecretsManifest(minimal);
+
+  // Verify missing optional fields get defaults
+  assertEq(parsed1.entries[0].dashboardUrl, '', 'missing-optional: no dashboard → empty string');
+  assertEq(parsed1.entries[0].formatHint, '', 'missing-optional: no format hint → empty string');
+  assertEq(parsed1.entries[1].dashboardUrl, '', 'missing-optional: entry 2 no dashboard → empty string');
+  assertEq(parsed1.entries[1].formatHint, '', 'missing-optional: entry 2 no format hint → empty string');
+
+  // Round-trip: formatter omits empty optional fields, re-parse preserves defaults
+  const formatted = formatSecretsManifest(parsed1);
+  const parsed2 = parseSecretsManifest(formatted);
+
+  assertEq(parsed2.entries.length, parsed1.entries.length, 'missing-optional round-trip entry count');
+
+  for (let i = 0; i < parsed1.entries.length; i++) {
+    const e1 = parsed1.entries[i];
+    const e2 = parsed2.entries[i];
+    assertEq(e2.key, e1.key, `missing-optional round-trip entry ${i} key`);
+    assertEq(e2.service, e1.service, `missing-optional round-trip entry ${i} service`);
+    assertEq(e2.dashboardUrl, e1.dashboardUrl, `missing-optional round-trip entry ${i} dashboardUrl`);
+    assertEq(e2.formatHint, e1.formatHint, `missing-optional round-trip entry ${i} formatHint`);
+    assertEq(e2.status, e1.status, `missing-optional round-trip entry ${i} status`);
+    assertEq(e2.destination, e1.destination, `missing-optional round-trip entry ${i} destination`);
+    assertEq(e2.guidance.length, e1.guidance.length, `missing-optional round-trip entry ${i} guidance length`);
+  }
+}
+
+console.log('\n=== LLM round-trip: extra blank lines ===');
+{
+  // LLMs sometimes insert excessive blank lines between sections
+  const blanky = `# Secrets Manifest
+
+
+**Milestone:** M012
+**Generated:** 2025-07-03T14:00:00Z
+
+
+
+### API_KEY_ONE
+
+
+**Service:** ServiceOne
+**Dashboard:** https://one.example.com
+
+
+**Format hint:** key_...
+**Status:** pending
+**Destination:** dotenv
+
+
+
+1. Go to settings
+
+
+2. Generate key
+
+
+
+### API_KEY_TWO
+
+
+
+**Service:** ServiceTwo
+**Status:** skipped
+**Destination:** dotenv
+
+
+1. Not needed
+`;
+
+  const parsed1 = parseSecretsManifest(blanky);
+
+  assertEq(parsed1.entries.length, 2, 'blank-lines: two entries parsed');
+  assertEq(parsed1.milestone, 'M012', 'blank-lines: milestone parsed');
+  assertEq(parsed1.entries[0].key, 'API_KEY_ONE', 'blank-lines: first key');
+  assertEq(parsed1.entries[0].guidance.length, 2, 'blank-lines: first entry guidance count');
+  assertEq(parsed1.entries[1].key, 'API_KEY_TWO', 'blank-lines: second key');
+  assertEq(parsed1.entries[1].status, 'skipped', 'blank-lines: second entry status');
+
+  // Round-trip produces clean output
+  const formatted = formatSecretsManifest(parsed1);
+  const parsed2 = parseSecretsManifest(formatted);
+
+  assertEq(parsed2.entries.length, parsed1.entries.length, 'blank-lines round-trip entry count');
+
+  for (let i = 0; i < parsed1.entries.length; i++) {
+    const e1 = parsed1.entries[i];
+    const e2 = parsed2.entries[i];
+    assertEq(e2.key, e1.key, `blank-lines round-trip entry ${i} key`);
+    assertEq(e2.service, e1.service, `blank-lines round-trip entry ${i} service`);
+    assertEq(e2.dashboardUrl, e1.dashboardUrl, `blank-lines round-trip entry ${i} dashboardUrl`);
+    assertEq(e2.formatHint, e1.formatHint, `blank-lines round-trip entry ${i} formatHint`);
+    assertEq(e2.status, e1.status, `blank-lines round-trip entry ${i} status`);
+    assertEq(e2.destination, e1.destination, `blank-lines round-trip entry ${i} destination`);
+    assertEq(e2.guidance.length, e1.guidance.length, `blank-lines round-trip entry ${i} guidance length`);
+  }
+
+  // Verify the formatted output is cleaner (fewer consecutive blank lines)
+  const consecutiveBlanks = formatted.match(/\n{4,}/g);
+  assert(consecutiveBlanks === null, 'blank-lines: formatted output has no 4+ consecutive newlines');
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // Results
 // ═══════════════════════════════════════════════════════════════════════════

package/src/resources/extensions/gsd/types.ts

@@ -136,6 +136,13 @@ export interface SecretsManifest {
   entries: SecretsManifestEntry[];
 }
 
+export interface ManifestStatus {
+  pending: string[];    // manifest status = pending AND not in env
+  collected: string[];  // manifest status = collected AND not in env
+  skipped: string[];    // manifest status = skipped
+  existing: string[];   // key present in .env or process.env (regardless of manifest status)
+}
+
 // ─── GSD State (Derived Dashboard) ────────────────────────────────────────
 
 export interface ActiveRef {