@tuan_son.dinh/gsd 2.6.3 → 2.7.0

package/src/resources/extensions/gsd/tests/doctor-fixlevel.test.ts

@@ -0,0 +1,170 @@
+/**
+ * Tests that doctor's fixLevel option correctly separates task-level
+ * bookkeeping from completion state transitions.
+ *
+ * fixLevel:"task" — fixes task checkboxes, does NOT create slice summary
+ *   stubs, UAT stubs, or mark slices done in the roadmap.
+ * fixLevel:"all" (default) — fixes everything including completion transitions.
+ */
+
+import { mkdirSync, writeFileSync, rmSync, readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import test from "node:test";
+import assert from "node:assert/strict";
+import { runGSDDoctor } from "../doctor.ts";
+
+function makeTmp(name: string): string {
+  const dir = join(tmpdir(), `doctor-fixlevel-${name}-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+/**
+ * Build a minimal .gsd structure: milestone with one slice, one task
+ * marked done with a summary — but no slice summary and roadmap unchecked.
+ * This is exactly the state after the last task completes.
+ */
+function buildScaffold(base: string) {
+  const gsd = join(base, ".gsd");
+  const m = join(gsd, "milestones", "M001");
+  const s = join(m, "slices", "S01", "tasks");
+  mkdirSync(s, { recursive: true });
+
+  writeFileSync(join(m, "M001-ROADMAP.md"), `# M001: Test
+
+## Slices
+
+- [ ] **S01: Test Slice** \`risk:low\` \`depends:[]\`
+  > Demo text
+`);
+
+  writeFileSync(join(m, "slices", "S01", "S01-PLAN.md"), `# S01: Test Slice
+
+**Goal:** test
+
+## Tasks
+
+- [x] **T01: Do stuff** \`est:5m\`
+`);
+
+  writeFileSync(join(s, "T01-SUMMARY.md"), `---
+id: T01
+parent: S01
+milestone: M001
+duration: 5m
+verification_result: passed
+completed_at: 2026-01-01
+---
+
+# T01: Do stuff
+
+Done.
+`);
+}
+
+test("fixLevel:task — detects completion issues but does NOT create summary stub or mark roadmap", async () => {
+  const tmp = makeTmp("task-level");
+  try {
+    buildScaffold(tmp);
+
+    const report = await runGSDDoctor(tmp, { fix: true, fixLevel: "task" });
+
+    // Should detect the issues
+    const codes = report.issues.map(i => i.code);
+    assert.ok(codes.includes("all_tasks_done_missing_slice_summary"), "should detect missing summary");
+    assert.ok(codes.includes("all_tasks_done_roadmap_not_checked"), "should detect unchecked roadmap");
+
+    // Should NOT have fixed them
+    const sliceSummaryPath = join(tmp, ".gsd", "milestones", "M001", "slices", "S01", "S01-SUMMARY.md");
+    assert.ok(!existsSync(sliceSummaryPath), "should NOT have created summary stub");
+
+    const roadmapContent = readFileSync(join(tmp, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), "utf8");
+    assert.ok(roadmapContent.includes("- [ ] **S01"), "roadmap should still show S01 as unchecked");
+
+    // Fixes applied should NOT include completion artifacts
+    for (const f of report.fixesApplied) {
+      assert.ok(!f.includes("SUMMARY"), `should not have fixed summary: ${f}`);
+      assert.ok(!f.includes("roadmap"), `should not have fixed roadmap: ${f}`);
+    }
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+test("fixLevel:all (default) — detects AND fixes completion issues", async () => {
+  const tmp = makeTmp("all-level");
+  try {
+    buildScaffold(tmp);
+
+    const report = await runGSDDoctor(tmp, { fix: true });
+
+    // Should detect the issues
+    const codes = report.issues.map(i => i.code);
+    assert.ok(codes.includes("all_tasks_done_missing_slice_summary"), "should detect missing summary");
+    assert.ok(codes.includes("all_tasks_done_roadmap_not_checked"), "should detect unchecked roadmap");
+
+    // SHOULD have fixed them
+    const sliceSummaryPath = join(tmp, ".gsd", "milestones", "M001", "slices", "S01", "S01-SUMMARY.md");
+    assert.ok(existsSync(sliceSummaryPath), "should have created summary stub");
+
+    const roadmapContent = readFileSync(join(tmp, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), "utf8");
+    assert.ok(roadmapContent.includes("- [x] **S01"), "roadmap should show S01 as checked");
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+test("fixLevel:task — still fixes task-level bookkeeping (checkbox marking)", async () => {
+  const tmp = makeTmp("task-checkbox");
+  try {
+    const gsd = join(tmp, ".gsd");
+    const m = join(gsd, "milestones", "M001");
+    const s = join(m, "slices", "S01", "tasks");
+    mkdirSync(s, { recursive: true });
+
+    writeFileSync(join(m, "M001-ROADMAP.md"), `# M001: Test
+
+## Slices
+
+- [ ] **S01: Test Slice** \`risk:low\` \`depends:[]\`
+  > Demo text
+`);
+
+    // Task NOT checked in plan but has a summary — doctor should mark it done
+    writeFileSync(join(m, "slices", "S01", "S01-PLAN.md"), `# S01: Test Slice
+
+**Goal:** test
+
+## Tasks
+
+- [ ] **T01: Do stuff** \`est:5m\`
+`);
+
+    writeFileSync(join(s, "T01-SUMMARY.md"), `---
+id: T01
+parent: S01
+milestone: M001
+duration: 5m
+verification_result: passed
+completed_at: 2026-01-01
+---
+
+# T01: Do stuff
+
+Done.
+`);
+
+    const report = await runGSDDoctor(tmp, { fix: true, fixLevel: "task" });
+
+    // Should have fixed the task checkbox
+    const planContent = readFileSync(join(m, "slices", "S01", "S01-PLAN.md"), "utf8");
+    assert.ok(planContent.includes("- [x] **T01"), "should have marked T01 done in plan");
+
+    // Should NOT have touched slice-level completion
+    const sliceSummaryPath = join(tmp, ".gsd", "milestones", "M001", "slices", "S01", "S01-SUMMARY.md");
+    assert.ok(!existsSync(sliceSummaryPath), "should NOT have created summary stub");
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/git-service.test.ts

@@ -453,6 +453,49 @@ async function main(): Promise<void> {
     rmSync(repo, { recursive: true, force: true });
   }
 
+  // ─── GitServiceImpl: autoCommit with extraExclusions ───────────────────
+
+  console.log("\n=== GitServiceImpl: autoCommit with extraExclusions ===");
+
+  {
+    const repo = initTempRepo();
+    const svc = new GitServiceImpl(repo);
+
+    // Create both a .gsd/ planning file and a regular source file
+    createFile(repo, ".gsd/milestones/M001/M001-ROADMAP.md", "- [x] S01");
+    createFile(repo, "src/feature.ts", "export const y = 2;");
+
+    // Auto-commit with .gsd/ excluded (simulates pre-switch)
+    const msg = svc.autoCommit("pre-switch", "main", [".gsd/"]);
+    assertEq(msg, "chore(main): auto-commit after pre-switch", "pre-switch autoCommit with .gsd/ exclusion commits");
+
+    // Verify .gsd/ file was NOT committed
+    const show = run("git show --stat HEAD", repo);
+    assert(!show.includes("ROADMAP"), ".gsd/ files excluded from pre-switch auto-commit");
+    assert(show.includes("feature.ts"), "non-.gsd/ files included in pre-switch auto-commit");
+
+    rmSync(repo, { recursive: true, force: true });
+  }
+
+  // ─── GitServiceImpl: autoCommit extraExclusions — only .gsd/ dirty ────
+
+  console.log("\n=== GitServiceImpl: autoCommit extraExclusions — only .gsd/ dirty ===");
+
+  {
+    const repo = initTempRepo();
+    const svc = new GitServiceImpl(repo);
+
+    // Create only .gsd/ planning files
+    createFile(repo, ".gsd/milestones/M001/M001-ROADMAP.md", "- [x] S01");
+    createFile(repo, ".gsd/STATE.md", "state content");
+
+    // Auto-commit with .gsd/ excluded — nothing else to commit
+    const result = svc.autoCommit("pre-switch", "main", [".gsd/"]);
+    assertEq(result, null, "autoCommit returns null when only .gsd/ files are dirty and excluded");
+
+    rmSync(repo, { recursive: true, force: true });
+  }
+
   // ─── GitServiceImpl: commit returns null when nothing staged ───────────
 
   console.log("\n=== GitServiceImpl: commit empty ===");

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 });
+  }
+});