gsd-pi 2.77.0-dev.eaa4973bc → 2.78.0-dev.aeeb2ca00

package/src/resources/extensions/gsd/tests/skill-activation.test.ts

@@ -4,7 +4,13 @@ import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { loadSkills } from "@gsd/pi-coding-agent";
-import { buildSkillActivationBlock } from "../auto-prompts.js";
+import {
+  buildPlanMilestonePrompt,
+  buildResearchMilestonePrompt,
+  buildSkillActivationBlock,
+} from "../auto-prompts.js";
+import { warnIfManifestHasMissingSkills } from "../skill-manifest.js";
+import { _resetLogs, drainLogs, setStderrLoggingEnabled } from "../workflow-logger.js";
 import type { GSDPreferences } from "../preferences.js";
 
 function makeTempBase(): string {
@@ -25,6 +31,11 @@ function loadOnlyTestSkills(base: string): void {
   loadSkills({ cwd: base, includeDefaults: false, skillPaths: [join(base, "skills")] });
 }
 
+function writeProjectPreferences(base: string, preferences: string): void {
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  writeFileSync(join(base, ".gsd", "PREFERENCES.md"), `---\n${preferences}---\n`);
+}
+
 function buildBlock(
   base: string,
   params: Partial<Parameters<typeof buildSkillActivationBlock>[0]> = {},
@@ -231,3 +242,111 @@ test("buildSkillActivationBlock allows valid skill names and rejects invalid one
     cleanup(base);
   }
 });
+
+// ─── Per-unit-type skill manifest (RFC #4779) ─────────────────────────────────
+
+test("buildSkillActivationBlock: explicit always_use_skills bypass the unit-type manifest", () => {
+  const base = makeTempBase();
+  try {
+    // write-docs is in the research-milestone manifest; swiftui is not.
+    // Both are in always_use_skills — a user-explicit source — so BOTH
+    // should activate regardless of the manifest. User intent wins over
+    // unit-type defaults. See RFC #4779 and skill-manifest.ts rationale.
+    writeSkill(base, "write-docs", "Use when writing docs or RFCs.");
+    writeSkill(base, "swiftui", "Use for SwiftUI views.");
+    loadOnlyTestSkills(base);
+
+    const result = buildBlock(base, { unitType: "research-milestone" }, {
+      always_use_skills: ["write-docs", "swiftui"],
+    });
+
+    assert.match(result, /Call Skill\(\{ skill: 'write-docs' \}\)/);
+    assert.match(result, /Call Skill\(\{ skill: 'swiftui' \}\)/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("buildSkillActivationBlock falls through to all skills for unknown unit type", () => {
+  const base = makeTempBase();
+  try {
+    writeSkill(base, "swiftui", "Use for SwiftUI views.");
+    loadOnlyTestSkills(base);
+
+    const result = buildBlock(base, { unitType: "unknown-unit-type" }, {
+      always_use_skills: ["swiftui"],
+    });
+
+    // Unknown unit type = wildcard fallback (pre-manifest behavior).
+    assert.match(result, /Call Skill\(\{ skill: 'swiftui' \}\)/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("buildSkillActivationBlock without unitType preserves pre-manifest behavior", () => {
+  const base = makeTempBase();
+  try {
+    writeSkill(base, "swiftui", "Use for SwiftUI views.");
+    loadOnlyTestSkills(base);
+
+    // No unitType param — filter should no-op.
+    const result = buildBlock(base, {}, {
+      always_use_skills: ["swiftui"],
+    });
+
+    assert.match(result, /Call Skill\(\{ skill: 'swiftui' \}\)/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("milestone prompt builders propagate always_use_skills through buildSkillActivationBlock", async () => {
+  const base = makeTempBase();
+  try {
+    // Both skills are in always_use_skills — explicit user intent bypasses
+    // the unit-type manifest, so both activate in both milestone flows.
+    writeSkill(base, "write-docs", "Use when writing docs or RFCs.");
+    writeSkill(base, "swiftui", "Use for SwiftUI views.");
+    writeProjectPreferences(base, "always_use_skills:\n  - write-docs\n  - swiftui\n");
+    loadOnlyTestSkills(base);
+
+    const researchPrompt = await buildResearchMilestonePrompt("M001", "Test", base);
+    assert.match(researchPrompt, /Call Skill\(\{ skill: 'write-docs' \}\)/);
+    assert.match(researchPrompt, /Call Skill\(\{ skill: 'swiftui' \}\)/);
+
+    const planPrompt = await buildPlanMilestonePrompt("M001", "Test", base);
+    assert.match(planPrompt, /Call Skill\(\{ skill: 'write-docs' \}\)/);
+    assert.match(planPrompt, /Call Skill\(\{ skill: 'swiftui' \}\)/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("skill manifest strict warnings require GSD_SKILL_MANIFEST_STRICT=1", (t) => {
+  const previousStrict = process.env.GSD_SKILL_MANIFEST_STRICT;
+  const previousStderr = setStderrLoggingEnabled(false);
+  t.after(() => {
+    if (previousStrict === undefined) {
+      delete process.env.GSD_SKILL_MANIFEST_STRICT;
+    } else {
+      process.env.GSD_SKILL_MANIFEST_STRICT = previousStrict;
+    }
+    setStderrLoggingEnabled(previousStderr);
+    _resetLogs();
+  });
+
+  process.env.GSD_SKILL_MANIFEST_STRICT = "0";
+  _resetLogs();
+  warnIfManifestHasMissingSkills("research-milestone", new Set());
+  assert.equal(drainLogs().length, 0, "strict=0 must preserve silent behavior");
+
+  process.env.GSD_SKILL_MANIFEST_STRICT = "1";
+  _resetLogs();
+  warnIfManifestHasMissingSkills("research-milestone", new Set());
+  const logs = drainLogs();
+  assert.ok(
+    logs.some(log => log.message.includes("skill-manifest: references uninstalled skill")),
+    "strict=1 should warn about missing manifest entries",
+  );
+});

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

@@ -0,0 +1,112 @@
+// GSD2 + skill-manifest.test — unit coverage for the skill manifest resolver
+//
+// Focused tests for `resolveSkillManifest` and `filterSkillsByManifest`.
+// Covers the wildcard semantics, the newly seeded unit-type entries
+// (complete-milestone, validate-milestone, reassess-roadmap, research-slice,
+// plan-slice, refine-slice, replan-slice, run-uat), and the deliberate
+// wildcard fallback for the execute-task hot path (RFC #4779).
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  resolveSkillManifest,
+  filterSkillsByManifest,
+} from "../skill-manifest.js";
+
+const NEWLY_WIRED_UNIT_TYPES = [
+  "complete-milestone",
+  "validate-milestone",
+  "reassess-roadmap",
+  "research-slice",
+  "plan-slice",
+  "refine-slice",
+  "replan-slice",
+  "run-uat",
+] as const;
+
+test("resolveSkillManifest returns null for undefined unit type (wildcard)", () => {
+  assert.equal(resolveSkillManifest(undefined), null);
+});
+
+test("resolveSkillManifest returns null for unknown unit types (wildcard fallback)", () => {
+  assert.equal(resolveSkillManifest("nonexistent-unit-type"), null);
+});
+
+test("resolveSkillManifest returns null for execute-task (intentional wildcard)", () => {
+  // execute-task is the implementation hot path; allowlisting it requires
+  // per-task skill hints from task-plan frontmatter. Documented in
+  // skill-manifest.ts — regression guard.
+  assert.equal(resolveSkillManifest("execute-task"), null);
+});
+
+for (const unitType of NEWLY_WIRED_UNIT_TYPES) {
+  test(`resolveSkillManifest returns a non-empty allowlist for '${unitType}'`, () => {
+    const allowlist = resolveSkillManifest(unitType);
+    assert.ok(allowlist !== null, `${unitType} should resolve to an allowlist, not wildcard`);
+    assert.ok(allowlist.length > 0, `${unitType} allowlist should not be empty`);
+    // Every entry must be lowercase (normalized).
+    for (const name of allowlist) {
+      assert.equal(name, name.toLowerCase(), `${unitType} entry '${name}' should be lowercase`);
+    }
+  });
+}
+
+test("resolveSkillManifest: slice-level manifests include decompose-into-slices", () => {
+  // Planning-shaped slice flows all benefit from the decomposition skill.
+  // Sanity-check a representative entry from each.
+  for (const unitType of ["research-slice", "plan-slice", "refine-slice", "replan-slice"] as const) {
+    const allowlist = resolveSkillManifest(unitType);
+    assert.ok(
+      allowlist?.includes("decompose-into-slices"),
+      `${unitType} should list decompose-into-slices`,
+    );
+  }
+});
+
+test("resolveSkillManifest: validation / completion flows include verify-before-complete", () => {
+  for (const unitType of ["complete-milestone", "validate-milestone", "run-uat"] as const) {
+    const allowlist = resolveSkillManifest(unitType);
+    assert.ok(
+      allowlist?.includes("verify-before-complete"),
+      `${unitType} should list verify-before-complete`,
+    );
+  }
+});
+
+test("filterSkillsByManifest: pass-through when unit type is unknown", () => {
+  const skills = [{ name: "swiftui" }, { name: "solidity-security" }];
+  const result = filterSkillsByManifest(skills, "nonexistent-unit-type");
+  assert.deepEqual(result, skills);
+});
+
+test("filterSkillsByManifest: pass-through when unitType is undefined", () => {
+  const skills = [{ name: "swiftui" }];
+  const result = filterSkillsByManifest(skills, undefined);
+  assert.deepEqual(result, skills);
+});
+
+test("filterSkillsByManifest: restricts to allowlisted names for known unit type", () => {
+  // research-slice allowlists include decompose-into-slices but not swiftui.
+  const skills = [
+    { name: "decompose-into-slices" },
+    { name: "swiftui" },
+    { name: "write-docs" },
+  ];
+  const result = filterSkillsByManifest(skills, "research-slice");
+  const names = result.map(s => s.name);
+  assert.ok(names.includes("decompose-into-slices"));
+  assert.ok(names.includes("write-docs"));
+  assert.ok(!names.includes("swiftui"));
+});
+
+test("filterSkillsByManifest: matching is case-insensitive via normalize", () => {
+  const skills = [
+    { name: "Write-Docs" }, // different case from manifest entry
+    { name: "SWIFTUI" },
+  ];
+  const result = filterSkillsByManifest(skills, "research-milestone");
+  const names = result.map(s => s.name);
+  assert.ok(names.includes("Write-Docs"));
+  assert.ok(!names.includes("SWIFTUI"));
+});

package/src/resources/extensions/gsd/tests/slice-cadence.test.ts

@@ -0,0 +1,242 @@
+/**
+ * Tests for slice-cadence collapse — #4765.
+ *
+ * Covers mergeSliceToMain (squash + advance), resquashMilestoneOnMain,
+ * and the preference accessors.
+ */
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, realpathSync, readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execFileSync } from "node:child_process";
+
+import {
+  mergeSliceToMain,
+  resquashMilestoneOnMain,
+  getCollapseCadence,
+  getMilestoneResquash,
+} from "../slice-cadence.ts";
+import { MergeConflictError } from "../git-service.ts";
+import { summarizeWorktreeTelemetry } from "../worktree-telemetry.ts";
+
+function git(args: string[], cwd: string): string {
+  return execFileSync("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
+}
+
+/** Create a temp git repo with an initial commit on main. */
+function createRepo(): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "slice-cad-test-")));
+  git(["init"], dir);
+  git(["config", "user.email", "test@test.com"], dir);
+  git(["config", "user.name", "Test"], dir);
+  writeFileSync(join(dir, "README.md"), "# test\n");
+  git(["add", "."], dir);
+  git(["commit", "-m", "init"], dir);
+  git(["branch", "-M", "main"], dir);
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  return dir;
+}
+
+function enterMilestoneBranch(dir: string, milestoneId: string): void {
+  git(["checkout", "-b", `milestone/${milestoneId}`], dir);
+}
+
+function commitFile(dir: string, file: string, content: string, msg: string): string {
+  writeFileSync(join(dir, file), content);
+  git(["add", "."], dir);
+  git(["commit", "-m", msg], dir);
+  return git(["rev-parse", "HEAD"], dir);
+}
+
+describe("getCollapseCadence / getMilestoneResquash", () => {
+  test("defaults to milestone cadence", () => {
+    assert.equal(getCollapseCadence(undefined), "milestone");
+    assert.equal(getCollapseCadence(null), "milestone");
+    assert.equal(getCollapseCadence({}), "milestone");
+    assert.equal(getCollapseCadence({ git: {} }), "milestone");
+  });
+  test("reads slice cadence when set", () => {
+    assert.equal(getCollapseCadence({ git: { collapse_cadence: "slice" } }), "slice");
+  });
+  test("milestone_resquash defaults to true when not set", () => {
+    assert.equal(getMilestoneResquash(undefined), true);
+    assert.equal(getMilestoneResquash({ git: {} }), true);
+    assert.equal(getMilestoneResquash({ git: { milestone_resquash: true } }), true);
+  });
+  test("milestone_resquash can be disabled explicitly", () => {
+    assert.equal(getMilestoneResquash({ git: { milestone_resquash: false } }), false);
+  });
+});
+
+describe("mergeSliceToMain", () => {
+  let dir: string;
+  let originalCwd: string;
+
+  beforeEach(() => {
+    dir = createRepo();
+    originalCwd = process.cwd();
+  });
+
+  afterEach(() => {
+    try { process.chdir(originalCwd); } catch { /* */ }
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  test("squashes one slice's commits onto main and advances the milestone branch", () => {
+    enterMilestoneBranch(dir, "M001");
+    commitFile(dir, "feature.txt", "slice 1 work\n", "feat: S01 work");
+
+    process.chdir(dir);
+    const result = mergeSliceToMain(dir, "M001", "S01");
+
+    assert.equal(result.skipped, false);
+    assert.ok(result.commitSha, "expected a commit SHA");
+    assert.equal(result.milestoneBranch, "milestone/M001");
+    assert.equal(result.mainBranch, "main");
+
+    const mainLog = git(["log", "main", "--oneline"], dir);
+    assert.ok(mainLog.includes("S01 of M001 (slice-cadence)"), `main log: ${mainLog}`);
+    assert.equal(readFileSync(join(dir, "feature.txt"), "utf-8"), "slice 1 work\n");
+
+    const mainSha = git(["rev-parse", "main"], dir);
+    const milestoneSha = git(["rev-parse", "milestone/M001"], dir);
+    assert.equal(milestoneSha, mainSha, "milestone branch must be advanced to main");
+
+    const summary = summarizeWorktreeTelemetry(dir);
+    assert.equal(summary.slicesMerged, 1);
+    assert.equal(summary.sliceMergeConflicts, 0);
+  });
+
+  test("handles sequential slice merges cleanly", () => {
+    enterMilestoneBranch(dir, "M001");
+    commitFile(dir, "a.txt", "slice 1\n", "feat: S01");
+
+    process.chdir(dir);
+    mergeSliceToMain(dir, "M001", "S01");
+
+    git(["checkout", "milestone/M001"], dir);
+    commitFile(dir, "b.txt", "slice 2\n", "feat: S02");
+
+    const result = mergeSliceToMain(dir, "M001", "S02");
+    assert.equal(result.skipped, false);
+
+    const mainLog = git(["log", "main", "--oneline"], dir);
+    assert.ok(mainLog.includes("S01 of M001"));
+    assert.ok(mainLog.includes("S02 of M001"));
+
+    assert.equal(readFileSync(join(dir, "a.txt"), "utf-8"), "slice 1\n");
+    assert.equal(readFileSync(join(dir, "b.txt"), "utf-8"), "slice 2\n");
+
+    const summary = summarizeWorktreeTelemetry(dir);
+    assert.equal(summary.slicesMerged, 2);
+  });
+
+  test("returns skipped when milestone branch has no commits ahead of main", () => {
+    enterMilestoneBranch(dir, "M001");
+
+    process.chdir(dir);
+    const result = mergeSliceToMain(dir, "M001", "S01");
+
+    assert.equal(result.skipped, true);
+    assert.equal(result.skippedReason, "no-commits-ahead");
+    assert.equal(result.commitSha, null);
+  });
+
+  test("throws MergeConflictError on a real conflict and leaves no merge artifacts", () => {
+    writeFileSync(join(dir, "shared.txt"), "main version\n");
+    git(["add", "."], dir);
+    git(["commit", "-m", "main-seed"], dir);
+
+    enterMilestoneBranch(dir, "M001");
+    commitFile(dir, "shared.txt", "slice version\n", "feat: S01 conflicting");
+
+    git(["checkout", "main"], dir);
+    commitFile(dir, "shared.txt", "main evolved\n", "main evolved");
+    git(["checkout", "milestone/M001"], dir);
+
+    process.chdir(dir);
+    assert.throws(
+      () => mergeSliceToMain(dir, "M001", "S01"),
+      (err: unknown) => err instanceof MergeConflictError,
+    );
+
+    const gitDir = join(dir, ".git");
+    for (const f of ["SQUASH_MSG", "MERGE_MSG", "MERGE_HEAD"]) {
+      assert.ok(!existsSync(join(gitDir, f)), `${f} should be cleaned up`);
+    }
+
+    const summary = summarizeWorktreeTelemetry(dir);
+    assert.equal(summary.sliceMergeConflicts, 1);
+  });
+
+  test("restores cwd even when merge fails (dirty working tree)", () => {
+    enterMilestoneBranch(dir, "M001");
+    commitFile(dir, "feature.txt", "slice 1\n", "feat: S01");
+    // Introduce an untracked file AFTER the slice commit so it's still
+    // present when mergeSliceToMain runs its status check.
+    writeFileSync(join(dir, "dirty.txt"), "uncommitted\n");
+
+    process.chdir(dir);
+    const cwdBefore = process.cwd();
+    assert.throws(() => mergeSliceToMain(dir, "M001", "S01"));
+    assert.equal(process.cwd(), cwdBefore, "cwd must be restored on failure");
+  });
+});
+
+describe("resquashMilestoneOnMain", () => {
+  let dir: string;
+  let originalCwd: string;
+
+  beforeEach(() => {
+    dir = createRepo();
+    originalCwd = process.cwd();
+  });
+
+  afterEach(() => {
+    try { process.chdir(originalCwd); } catch { /* */ }
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  test("collapses N slice commits on main into one milestone commit", () => {
+    const startSha = git(["rev-parse", "main"], dir);
+
+    enterMilestoneBranch(dir, "M001");
+    commitFile(dir, "a.txt", "slice 1\n", "feat: S01");
+    process.chdir(dir);
+    mergeSliceToMain(dir, "M001", "S01");
+
+    git(["checkout", "milestone/M001"], dir);
+    commitFile(dir, "b.txt", "slice 2\n", "feat: S02");
+    mergeSliceToMain(dir, "M001", "S02");
+
+    const beforeCount = parseInt(git(["rev-list", "--count", `${startSha}..main`], dir), 10);
+    assert.equal(beforeCount, 2);
+
+    const result = resquashMilestoneOnMain(dir, "M001", startSha);
+    assert.equal(result.resquashed, true);
+    assert.ok(result.newSha);
+
+    git(["checkout", "main"], dir);
+    const afterCount = parseInt(git(["rev-list", "--count", `${startSha}..main`], dir), 10);
+    assert.equal(afterCount, 1, "slice commits collapsed into one milestone commit");
+
+    const msg = git(["log", "-1", "--format=%s", "main"], dir);
+    assert.ok(msg.includes("M001") && msg.includes("2 slices"), `commit message should describe the resquash; got: ${msg}`);
+
+    assert.equal(readFileSync(join(dir, "a.txt"), "utf-8"), "slice 1\n");
+    assert.equal(readFileSync(join(dir, "b.txt"), "utf-8"), "slice 2\n");
+
+    const summary = summarizeWorktreeTelemetry(dir);
+    assert.equal(summary.milestoneResquashes, 1);
+  });
+
+  test("no-op when startSha equals HEAD", () => {
+    const startSha = git(["rev-parse", "main"], dir);
+    process.chdir(dir);
+    const result = resquashMilestoneOnMain(dir, "M001", startSha);
+    assert.equal(result.resquashed, false);
+    assert.equal(result.newSha, null);
+  });
+});

package/src/resources/extensions/gsd/tests/slice-context-injection.test.ts

@@ -11,6 +11,7 @@ import assert from "node:assert/strict";
 import { readFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
+import { extractSourceRegion } from "./test-helpers.ts";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const autoPromptsPath = join(__dirname, "..", "auto-prompts.ts");
@@ -32,7 +33,7 @@ describe("slice CONTEXT.md injection into prompt builders (#3452)", () => {
       assert.ok(fnStart !== -1, `${builder} should exist in auto-prompts.ts`);
 
       // Get a reasonable chunk after the function start
-      const chunk = source.slice(fnStart, fnStart + 3000);
+      const chunk = extractSourceRegion(source, `export async function ${builder}`);
 
       // ADR-011: buildPlanSlicePrompt / buildRefineSlicePrompt now delegate to
       // a shared helper (renderSlicePrompt) that performs the slice CONTEXT
@@ -42,7 +43,7 @@ describe("slice CONTEXT.md injection into prompt builders (#3452)", () => {
         ? (() => {
             const helperStart = source.indexOf("async function renderSlicePrompt");
             assert.ok(helperStart !== -1, "renderSlicePrompt helper must exist");
-            return source.slice(helperStart, helperStart + 3000);
+            return extractSourceRegion(source, "async function renderSlicePrompt");
           })()
         : chunk;