gsd-pi 2.41.0-dev.0acbce9 → 2.41.0-dev.5a170d0

package/src/resources/extensions/gsd/tests/auto-worktree-milestone-merge.test.ts

@@ -569,6 +569,208 @@ async function main(): Promise<void> {
       assertTrue(existsSync(join(repo, "landed.ts")), "landed.ts present on main");
     }
 
+    // ─── Test 14: Stale branch ref — worktree HEAD ahead of branch (#1846) ─
+    console.log("\n=== stale branch ref — fast-forward before squash merge (#1846) ===");
+    {
+      const repo = freshRepo();
+      const wtPath = createAutoWorktree(repo, "M140");
+
+      // Add a first slice normally — this advances both the branch ref and HEAD
+      addSliceToMilestone(repo, wtPath, "M140", "S01", "Initial work", [
+        { file: "initial.ts", content: "export const initial = true;\n", message: "add initial" },
+      ]);
+
+      // Now simulate the bug: detach HEAD in the worktree, then make commits
+      // that advance HEAD but leave the milestone/M140 branch ref behind.
+      const branchRefBefore = run("git rev-parse milestone/M140", wtPath);
+      run("git checkout --detach HEAD", wtPath);
+
+      // Add multiple commits on the detached HEAD (simulates agent work)
+      writeFileSync(join(wtPath, "feature-a.ts"), "export const featureA = true;\n");
+      run("git add .", wtPath);
+      run('git commit -m "add feature-a"', wtPath);
+
+      writeFileSync(join(wtPath, "feature-b.ts"), "export const featureB = true;\n");
+      run("git add .", wtPath);
+      run('git commit -m "add feature-b"', wtPath);
+
+      writeFileSync(join(wtPath, "feature-c.ts"), "export const featureC = true;\n");
+      run("git add .", wtPath);
+      run('git commit -m "add feature-c"', wtPath);
+
+      // Verify: branch ref is stale, HEAD is ahead
+      const branchRefAfter = run("git rev-parse milestone/M140", wtPath);
+      const worktreeHead = run("git rev-parse HEAD", wtPath);
+      assertEq(branchRefBefore, branchRefAfter, "branch ref unchanged (stale)");
+      assertTrue(worktreeHead !== branchRefAfter, "worktree HEAD ahead of branch ref");
+
+      const roadmap = makeRoadmap("M140", "Stale ref milestone", [
+        { id: "S01", title: "Initial work" },
+      ]);
+
+      // The fix should fast-forward the branch ref to worktree HEAD before
+      // squash-merging, so ALL commits are captured.
+      let threw = false;
+      let errMsg = "";
+      try {
+        const result = mergeMilestoneToMain(repo, "M140", roadmap);
+        assertTrue(result.commitMessage.includes("feat(M140)"), "merge commit created");
+      } catch (err) {
+        threw = true;
+        errMsg = err instanceof Error ? err.message : String(err);
+      }
+      assertTrue(!threw, `should not throw with stale branch ref (got: ${errMsg})`);
+
+      // ALL files from detached HEAD commits must be on main — not just
+      // the ones from the stale branch ref
+      assertTrue(existsSync(join(repo, "initial.ts")), "initial.ts on main");
+      assertTrue(existsSync(join(repo, "feature-a.ts")), "feature-a.ts on main (#1846)");
+      assertTrue(existsSync(join(repo, "feature-b.ts")), "feature-b.ts on main (#1846)");
+      assertTrue(existsSync(join(repo, "feature-c.ts")), "feature-c.ts on main (#1846)");
+    }
+
+    // ─── Test 15: Diverged worktree HEAD — throws instead of losing data (#1846) ─
+    console.log("\n=== diverged worktree HEAD — throws on divergence (#1846) ===");
+    {
+      const repo = freshRepo();
+      const wtPath = createAutoWorktree(repo, "M150");
+
+      addSliceToMilestone(repo, wtPath, "M150", "S01", "Base work", [
+        { file: "base.ts", content: "export const base = true;\n", message: "add base" },
+      ]);
+
+      run("git checkout --detach HEAD", wtPath);
+      writeFileSync(join(wtPath, "detached-work.ts"), "export const detached = true;\n");
+      run("git add .", wtPath);
+      run('git commit -m "detached work"', wtPath);
+
+      run("git checkout milestone/M150", repo);
+      writeFileSync(join(repo, "diverged-work.ts"), "export const diverged = true;\n");
+      run("git add .", repo);
+      run('git commit -m "diverged work on branch"', repo);
+      run("git checkout main", repo);
+
+      process.chdir(wtPath);
+
+      const roadmap = makeRoadmap("M150", "Diverged milestone", [
+        { id: "S01", title: "Base work" },
+      ]);
+
+      let threw = false;
+      let errMsg = "";
+      try {
+        mergeMilestoneToMain(repo, "M150", roadmap);
+      } catch (err) {
+        threw = true;
+        errMsg = err instanceof Error ? err.message : String(err);
+      }
+      assertTrue(threw, "throws when worktree HEAD diverged from branch ref (#1846)");
+      assertTrue(errMsg.includes("diverged"), "error message mentions divergence (#1846)");
+
+      const branches = run("git branch", repo);
+      assertTrue(branches.includes("milestone/M150"), "milestone branch preserved on divergence (#1846)");
+    }
+
+    // ─── Test 16: #1853 Bug 1 — SQUASH_MSG cleaned up after squash-merge ──
+    console.log("\n=== #1853 bug 1: SQUASH_MSG cleaned up after successful squash-merge ===");
+    {
+      const repo = freshRepo();
+      const wtPath = createAutoWorktree(repo, "M160");
+
+      addSliceToMilestone(repo, wtPath, "M160", "S01", "SQUASH_MSG cleanup test", [
+        { file: "squash-cleanup.ts", content: "export const cleanup = true;\n", message: "add squash-cleanup" },
+      ]);
+
+      const roadmap = makeRoadmap("M160", "SQUASH_MSG cleanup", [
+        { id: "S01", title: "SQUASH_MSG cleanup test" },
+      ]);
+
+      const squashMsgPath = join(repo, ".git", "SQUASH_MSG");
+      writeFileSync(squashMsgPath, "leftover squash message\n");
+      assertTrue(existsSync(squashMsgPath), "SQUASH_MSG planted before merge");
+
+      const result = mergeMilestoneToMain(repo, "M160", roadmap);
+      assertTrue(result.commitMessage.includes("feat(M160)"), "merge commit created");
+
+      assertTrue(
+        !existsSync(squashMsgPath),
+        "#1853: SQUASH_MSG must not persist after successful squash-merge",
+      );
+    }
+
+    // ─── Test 17: #1853 Bug 2 — uncommitted worktree code survives teardown ──
+    console.log("\n=== #1853 bug 2: uncommitted worktree changes committed before teardown ===");
+    {
+      const repo = freshRepo();
+      const wtPath = createAutoWorktree(repo, "M170");
+
+      addSliceToMilestone(repo, wtPath, "M170", "S01", "Teardown safety test", [
+        { file: "safe-file.ts", content: "export const safe = true;\n", message: "add safe file" },
+      ]);
+
+      writeFileSync(join(wtPath, "uncommitted-agent-code.ts"), "export const lost = true;\n");
+
+      const roadmap = makeRoadmap("M170", "Teardown safety", [
+        { id: "S01", title: "Teardown safety test" },
+      ]);
+
+      const result = mergeMilestoneToMain(repo, "M170", roadmap);
+      assertTrue(result.commitMessage.includes("feat(M170)"), "merge commit created");
+
+      assertTrue(
+        existsSync(join(repo, "uncommitted-agent-code.ts")),
+        "#1853: uncommitted worktree code must survive teardown",
+      );
+    }
+
+    // ─── Test 18: #1906 — codeFilesChanged false when only .gsd/ metadata merged ──
+    console.log("\n=== #1906: codeFilesChanged=false when only .gsd/ metadata merged ===");
+    {
+      const repo = freshRepo();
+      const wtPath = createAutoWorktree(repo, "M180");
+
+      // Only add .gsd/ metadata files — no actual code
+      mkdirSync(join(wtPath, ".gsd", "milestones", "M180"), { recursive: true });
+      writeFileSync(
+        join(wtPath, ".gsd", "milestones", "M180", "SUMMARY.md"),
+        "# M180 Summary\n\nThis milestone was planned but not implemented.\n",
+      );
+      run("git add .", wtPath);
+      run('git commit -m "chore: add milestone summary"', wtPath);
+
+      const roadmap = makeRoadmap("M180", "Metadata-only milestone", []);
+
+      const result = mergeMilestoneToMain(repo, "M180", roadmap);
+      assertEq(
+        result.codeFilesChanged,
+        false,
+        "#1906: codeFilesChanged must be false when only .gsd/ files were merged",
+      );
+    }
+
+    // ─── Test 19: #1906 — codeFilesChanged true when real code is merged ──
+    console.log("\n=== #1906: codeFilesChanged=true when real code is merged ===");
+    {
+      const repo = freshRepo();
+      const wtPath = createAutoWorktree(repo, "M190");
+
+      addSliceToMilestone(repo, wtPath, "M190", "S01", "Real code", [
+        { file: "real-code.ts", content: "export const real = true;\n", message: "add real code" },
+      ]);
+
+      const roadmap = makeRoadmap("M190", "Code milestone", [
+        { id: "S01", title: "Real code" },
+      ]);
+
+      const result = mergeMilestoneToMain(repo, "M190", roadmap);
+      assertEq(
+        result.codeFilesChanged,
+        true,
+        "#1906: codeFilesChanged must be true when real code files were merged",
+      );
+      assertTrue(existsSync(join(repo, "real-code.ts")), "real-code.ts merged to main");
+    }
+
   } finally {
     process.chdir(savedCwd);
     for (const d of tempDirs) {

package/src/resources/extensions/gsd/tests/bundled-workflow-defs.test.ts

@@ -0,0 +1,180 @@
+/**
+ * Bundled workflow definition validation tests.
+ *
+ * Verifies that every example YAML in src/resources/skills/create-workflow/templates/
+ * passes validateDefinition() from definition-loader.ts with { valid: true, errors: [] }.
+ *
+ * Also validates scaffold template and structural properties of each example
+ * (step counts, feature usage) to guard against accidental regressions.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parse } from "yaml";
+
+import { validateDefinition } from "../definition-loader.ts";
+
+// ─── Path resolution ─────────────────────────────────────────────────────
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+// Navigate from tests/ → extensions/gsd/ → extensions/ → resources/ → skills/create-workflow/templates/
+const templatesDir = join(
+  __dirname,
+  "..",
+  "..",
+  "..",
+  "skills",
+  "create-workflow",
+  "templates",
+);
+
+function loadYaml(filename: string): unknown {
+  const raw = readFileSync(join(templatesDir, filename), "utf-8");
+  return parse(raw);
+}
+
+// ─── Scaffold template ──────────────────────────────────────────────────
+
+test("scaffold template (workflow-definition.yaml) passes validation", () => {
+  const parsed = loadYaml("workflow-definition.yaml");
+  const result = validateDefinition(parsed);
+  assert.equal(result.valid, true, `Scaffold invalid: ${result.errors.join("; ")}`);
+  assert.equal(result.errors.length, 0);
+});
+
+// ─── blog-post-pipeline.yaml ────────────────────────────────────────────
+
+test("blog-post-pipeline.yaml passes validation", () => {
+  const parsed = loadYaml("blog-post-pipeline.yaml");
+  const result = validateDefinition(parsed);
+  assert.equal(result.valid, true, `Invalid: ${result.errors.join("; ")}`);
+  assert.equal(result.errors.length, 0);
+});
+
+test("blog-post-pipeline.yaml: 3 steps, context_from, params, content-heuristic", () => {
+  const parsed = loadYaml("blog-post-pipeline.yaml") as Record<string, unknown>;
+  const steps = parsed.steps as Array<Record<string, unknown>>;
+
+  // 3 steps
+  assert.equal(steps.length, 3, "Expected 3 steps");
+
+  // params defined
+  assert.ok(parsed.params, "Expected params to be defined");
+  const params = parsed.params as Record<string, string>;
+  assert.ok("topic" in params, "Expected 'topic' param");
+  assert.ok("audience" in params, "Expected 'audience' param");
+
+  // At least one step uses context_from
+  const hasContextFrom = steps.some(
+    (s) => Array.isArray(s.context_from) && s.context_from.length > 0,
+  );
+  assert.ok(hasContextFrom, "Expected at least one step with context_from");
+
+  // All steps use content-heuristic verify
+  for (const step of steps) {
+    const verify = step.verify as Record<string, unknown> | undefined;
+    assert.ok(verify, `Step "${step.id}" missing verify`);
+    assert.equal(verify.policy, "content-heuristic", `Step "${step.id}" should use content-heuristic`);
+  }
+});
+
+// ─── code-audit.yaml ────────────────────────────────────────────────────
+
+test("code-audit.yaml passes validation", () => {
+  const parsed = loadYaml("code-audit.yaml");
+  const result = validateDefinition(parsed);
+  assert.equal(result.valid, true, `Invalid: ${result.errors.join("; ")}`);
+  assert.equal(result.errors.length, 0);
+});
+
+test("code-audit.yaml: iterate with capture group and shell-command verify", () => {
+  const parsed = loadYaml("code-audit.yaml") as Record<string, unknown>;
+  const steps = parsed.steps as Array<Record<string, unknown>>;
+
+  // Find step with iterate
+  const iterateStep = steps.find((s) => s.iterate != null);
+  assert.ok(iterateStep, "Expected a step with iterate config");
+
+  const iterate = iterateStep.iterate as Record<string, unknown>;
+  assert.equal(typeof iterate.source, "string", "iterate.source must be a string");
+  assert.equal(typeof iterate.pattern, "string", "iterate.pattern must be a string");
+
+  // Pattern has a capture group
+  const pattern = iterate.pattern as string;
+  assert.ok(/\((?!\?)/.test(pattern), "iterate.pattern must contain a capture group");
+
+  // Pattern is valid regex
+  assert.doesNotThrow(() => new RegExp(pattern), "iterate.pattern must be valid regex");
+
+  // Has shell-command verify
+  const verify = iterateStep.verify as Record<string, unknown>;
+  assert.equal(verify.policy, "shell-command");
+  assert.equal(typeof verify.command, "string");
+});
+
+// ─── release-checklist.yaml ─────────────────────────────────────────────
+
+test("release-checklist.yaml passes validation", () => {
+  const parsed = loadYaml("release-checklist.yaml");
+  const result = validateDefinition(parsed);
+  assert.equal(result.valid, true, `Invalid: ${result.errors.join("; ")}`);
+  assert.equal(result.errors.length, 0);
+});
+
+test("release-checklist.yaml: diamond dependencies and human-review", () => {
+  const parsed = loadYaml("release-checklist.yaml") as Record<string, unknown>;
+  const steps = parsed.steps as Array<Record<string, unknown>>;
+
+  // 4 steps
+  assert.equal(steps.length, 4, "Expected 4 steps");
+
+  // Diamond pattern: two steps depend on the same parent
+  const changelog = steps.find((s) => s.id === "changelog");
+  const versionBump = steps.find((s) => s.id === "version-bump");
+  const testSuite = steps.find((s) => s.id === "test-suite");
+  const publish = steps.find((s) => s.id === "publish");
+
+  assert.ok(changelog, "Expected 'changelog' step");
+  assert.ok(versionBump, "Expected 'version-bump' step");
+  assert.ok(testSuite, "Expected 'test-suite' step");
+  assert.ok(publish, "Expected 'publish' step");
+
+  // Both version-bump and test-suite depend on changelog
+  const vbReqs = versionBump.requires as string[];
+  const tsReqs = testSuite.requires as string[];
+  assert.ok(vbReqs.includes("changelog"), "version-bump should require changelog");
+  assert.ok(tsReqs.includes("changelog"), "test-suite should require changelog");
+
+  // publish depends on both (diamond join)
+  const pubReqs = publish.requires as string[];
+  assert.ok(pubReqs.includes("version-bump"), "publish should require version-bump");
+  assert.ok(pubReqs.includes("test-suite"), "publish should require test-suite");
+
+  // publish uses human-review
+  const verify = publish.verify as Record<string, unknown>;
+  assert.equal(verify.policy, "human-review");
+});
+
+// ─── Cross-cutting: no path traversal in produces ───────────────────────
+
+test("no produces path contains '..'", () => {
+  const files = [
+    "blog-post-pipeline.yaml",
+    "code-audit.yaml",
+    "release-checklist.yaml",
+  ];
+
+  for (const file of files) {
+    const parsed = loadYaml(file) as Record<string, unknown>;
+    const steps = parsed.steps as Array<Record<string, unknown>>;
+    for (const step of steps) {
+      const produces = (step.produces as string[]) ?? [];
+      for (const p of produces) {
+        assert.ok(!p.includes(".."), `${file} step "${step.id}" produces path contains '..': ${p}`);
+      }
+    }
+  }
+});

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

@@ -119,12 +119,23 @@ test("captures: loadPendingCaptures filters resolved entries", () => {
     const id1 = appendCapture(tmp, "pending one");
     appendCapture(tmp, "pending two");
 
-    // Resolve the first one
     markCaptureResolved(tmp, id1, "note", "acknowledged", "just a note");
 
     const pending = loadPendingCaptures(tmp);
     assert.strictEqual(pending.length, 1, "should have 1 pending");
     assert.strictEqual(pending[0].text, "pending two");
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+test("captures: loadAllCaptures preserves resolved entries", () => {
+  const tmp = makeTempDir("cap-all-resolved");
+  try {
+    const id1 = appendCapture(tmp, "pending one");
+    appendCapture(tmp, "pending two");
+
+    markCaptureResolved(tmp, id1, "note", "acknowledged", "just a note");
 
     const all = loadAllCaptures(tmp);
     assert.strictEqual(all.length, 2, "all should still have 2");