gsd-pi 2.73.1 → 2.74.0-dev.0306a2e

package/src/resources/extensions/gsd/tests/commands-extract-learnings.test.ts

@@ -0,0 +1,340 @@
+import { describe, it, beforeEach, afterEach } 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 { randomUUID } from "node:crypto";
+
+import {
+  parseExtractLearningsArgs,
+  buildLearningsOutputPath,
+  resolvePhaseArtifacts,
+  buildExtractLearningsPrompt,
+  buildFrontmatter,
+  extractProjectName,
+} from "../commands-extract-learnings.js";
+
+// ─── parseExtractLearningsArgs ────────────────────────────────────────────────
+
+describe("parseExtractLearningsArgs", () => {
+  it("parses a milestone ID", () => {
+    const result = parseExtractLearningsArgs("M001");
+    assert.deepEqual(result, { milestoneId: "M001" });
+  });
+
+  it("returns null milestoneId for empty string", () => {
+    const result = parseExtractLearningsArgs("");
+    assert.deepEqual(result, { milestoneId: null });
+  });
+
+  it("returns null milestoneId for whitespace-only string", () => {
+    const result = parseExtractLearningsArgs("  ");
+    assert.deepEqual(result, { milestoneId: null });
+  });
+
+  it("trims whitespace from milestone ID", () => {
+    const result = parseExtractLearningsArgs("  M002  ");
+    assert.deepEqual(result, { milestoneId: "M002" });
+  });
+});
+
+// ─── buildLearningsOutputPath ─────────────────────────────────────────────────
+
+describe("buildLearningsOutputPath", () => {
+  it("builds the correct output path", () => {
+    const result = buildLearningsOutputPath("/base/.gsd/milestones/M001", "M001");
+    assert.equal(result, "/base/.gsd/milestones/M001/M001-LEARNINGS.md");
+  });
+
+  it("builds path for different milestone ID", () => {
+    const result = buildLearningsOutputPath("/project/.gsd/milestones/M005", "M005");
+    assert.equal(result, "/project/.gsd/milestones/M005/M005-LEARNINGS.md");
+  });
+});
+
+// ─── resolvePhaseArtifacts ────────────────────────────────────────────────────
+
+describe("resolvePhaseArtifacts", () => {
+  let tmpBase: string;
+
+  beforeEach(() => {
+    tmpBase = join(tmpdir(), `gsd-learnings-test-${randomUUID()}`);
+    mkdirSync(tmpBase, { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(tmpBase, { recursive: true, force: true });
+  });
+
+  it("finds required PLAN and SUMMARY when both present", () => {
+    writeFileSync(join(tmpBase, "M001-PLAN.md"), "# M001 Plan content", "utf-8");
+    writeFileSync(join(tmpBase, "M001-SUMMARY.md"), "# M001 Summary content", "utf-8");
+
+    const result = resolvePhaseArtifacts(tmpBase, "M001");
+    assert.equal(result.plan, join(tmpBase, "M001-PLAN.md"));
+    assert.equal(result.summary, join(tmpBase, "M001-SUMMARY.md"));
+    assert.deepEqual(result.missingRequired, []);
+  });
+
+  it("reports missing PLAN as missingRequired", () => {
+    writeFileSync(join(tmpBase, "M001-SUMMARY.md"), "# Summary", "utf-8");
+
+    const result = resolvePhaseArtifacts(tmpBase, "M001");
+    assert.ok(result.missingRequired.includes("M001-PLAN.md"));
+    assert.equal(result.plan, null);
+  });
+
+  it("reports missing SUMMARY as missingRequired", () => {
+    writeFileSync(join(tmpBase, "M001-PLAN.md"), "# Plan", "utf-8");
+
+    const result = resolvePhaseArtifacts(tmpBase, "M001");
+    assert.ok(result.missingRequired.includes("M001-SUMMARY.md"));
+    assert.equal(result.summary, null);
+  });
+
+  it("reports both required files missing when neither present", () => {
+    const result = resolvePhaseArtifacts(tmpBase, "M001");
+    assert.equal(result.missingRequired.length, 2);
+    assert.ok(result.missingRequired.includes("M001-PLAN.md"));
+    assert.ok(result.missingRequired.includes("M001-SUMMARY.md"));
+  });
+
+  it("finds optional VERIFICATION when present", () => {
+    writeFileSync(join(tmpBase, "M001-PLAN.md"), "# Plan", "utf-8");
+    writeFileSync(join(tmpBase, "M001-SUMMARY.md"), "# Summary", "utf-8");
+    writeFileSync(join(tmpBase, "M001-VERIFICATION.md"), "# Verification", "utf-8");
+
+    const result = resolvePhaseArtifacts(tmpBase, "M001");
+    assert.equal(result.verification, join(tmpBase, "M001-VERIFICATION.md"));
+  });
+
+  it("returns null for optional VERIFICATION when absent", () => {
+    writeFileSync(join(tmpBase, "M001-PLAN.md"), "# Plan", "utf-8");
+    writeFileSync(join(tmpBase, "M001-SUMMARY.md"), "# Summary", "utf-8");
+
+    const result = resolvePhaseArtifacts(tmpBase, "M001");
+    assert.equal(result.verification, null);
+  });
+
+  it("finds optional UAT when present", () => {
+    writeFileSync(join(tmpBase, "M001-PLAN.md"), "# Plan", "utf-8");
+    writeFileSync(join(tmpBase, "M001-SUMMARY.md"), "# Summary", "utf-8");
+    writeFileSync(join(tmpBase, "M001-UAT.md"), "# UAT", "utf-8");
+
+    const result = resolvePhaseArtifacts(tmpBase, "M001");
+    assert.equal(result.uat, join(tmpBase, "M001-UAT.md"));
+  });
+
+  it("returns null for optional UAT when absent, no error", () => {
+    writeFileSync(join(tmpBase, "M001-PLAN.md"), "# Plan", "utf-8");
+    writeFileSync(join(tmpBase, "M001-SUMMARY.md"), "# Summary", "utf-8");
+
+    const result = resolvePhaseArtifacts(tmpBase, "M001");
+    assert.equal(result.uat, null);
+    assert.deepEqual(result.missingRequired, []);
+  });
+});
+
+// ─── buildExtractLearningsPrompt ──────────────────────────────────────────────
+
+describe("buildExtractLearningsPrompt", () => {
+  it("includes milestoneId and outputPath", () => {
+    const result = buildExtractLearningsPrompt({
+      milestoneId: "M001",
+      milestoneName: "Test Milestone",
+      outputPath: "/project/.gsd/milestones/M001/M001-LEARNINGS.md",
+      relativeOutputPath: ".gsd/milestones/M001/M001-LEARNINGS.md",
+      planContent: "# Plan content",
+      summaryContent: "# Summary content",
+      verificationContent: null,
+      uatContent: null,
+      missingArtifacts: [],
+      projectName: "MyProject",
+    });
+
+    assert.ok(result.includes("M001"));
+    assert.ok(result.includes("/project/.gsd/milestones/M001/M001-LEARNINGS.md"));
+  });
+
+  it("includes all 4 learning categories", () => {
+    const result = buildExtractLearningsPrompt({
+      milestoneId: "M001",
+      milestoneName: "Test Milestone",
+      outputPath: "/out/M001-LEARNINGS.md",
+      relativeOutputPath: ".gsd/milestones/M001/M001-LEARNINGS.md",
+      planContent: "# Plan",
+      summaryContent: "# Summary",
+      verificationContent: null,
+      uatContent: null,
+      missingArtifacts: [],
+      projectName: "MyProject",
+    });
+
+    assert.ok(result.includes("Decisions"));
+    assert.ok(result.includes("Lessons"));
+    assert.ok(result.includes("Patterns"));
+    assert.ok(result.includes("Surprises"));
+  });
+
+  it("includes plan and summary content", () => {
+    const result = buildExtractLearningsPrompt({
+      milestoneId: "M001",
+      milestoneName: "Test Milestone",
+      outputPath: "/out/M001-LEARNINGS.md",
+      relativeOutputPath: ".gsd/milestones/M001/M001-LEARNINGS.md",
+      planContent: "PLAN_CONTENT_UNIQUE_123",
+      summaryContent: "SUMMARY_CONTENT_UNIQUE_456",
+      verificationContent: null,
+      uatContent: null,
+      missingArtifacts: [],
+      projectName: "MyProject",
+    });
+
+    assert.ok(result.includes("PLAN_CONTENT_UNIQUE_123"));
+    assert.ok(result.includes("SUMMARY_CONTENT_UNIQUE_456"));
+  });
+
+  it("includes optional artifacts when present", () => {
+    const result = buildExtractLearningsPrompt({
+      milestoneId: "M001",
+      milestoneName: "Test Milestone",
+      outputPath: "/out/M001-LEARNINGS.md",
+      relativeOutputPath: ".gsd/milestones/M001/M001-LEARNINGS.md",
+      planContent: "# Plan",
+      summaryContent: "# Summary",
+      verificationContent: "VERIFICATION_UNIQUE_789",
+      uatContent: "UAT_UNIQUE_012",
+      missingArtifacts: [],
+      projectName: "MyProject",
+    });
+
+    assert.ok(result.includes("VERIFICATION_UNIQUE_789"));
+    assert.ok(result.includes("UAT_UNIQUE_012"));
+  });
+
+  it("lists missing artifacts when present", () => {
+    const result = buildExtractLearningsPrompt({
+      milestoneId: "M001",
+      milestoneName: "Test Milestone",
+      outputPath: "/out/M001-LEARNINGS.md",
+      relativeOutputPath: ".gsd/milestones/M001/M001-LEARNINGS.md",
+      planContent: "# Plan",
+      summaryContent: "# Summary",
+      verificationContent: null,
+      uatContent: null,
+      missingArtifacts: ["M001-VERIFICATION.md"],
+      projectName: "MyProject",
+    });
+
+    assert.ok(result.includes("M001-VERIFICATION.md"));
+  });
+});
+
+// ─── buildFrontmatter ─────────────────────────────────────────────────────────
+
+describe("buildFrontmatter", () => {
+  it("starts with --- and ends with ---", () => {
+    const result = buildFrontmatter({
+      milestoneId: "M001",
+      milestoneName: "Test Milestone",
+      projectName: "MyProject",
+      generatedAt: "2026-04-15T10:00:00Z",
+      counts: { decisions: 0, lessons: 0, patterns: 0, surprises: 0 },
+      missingArtifacts: [],
+    });
+
+    assert.ok(result.startsWith("---\n"));
+    assert.ok(result.endsWith("---"));
+  });
+
+  it("includes required fields", () => {
+    const result = buildFrontmatter({
+      milestoneId: "M001",
+      milestoneName: "Test Milestone",
+      projectName: "MyProject",
+      generatedAt: "2026-04-15T10:00:00Z",
+      counts: { decisions: 3, lessons: 2, patterns: 1, surprises: 0 },
+      missingArtifacts: [],
+    });
+
+    assert.ok(result.includes("phase:"));
+    assert.ok(result.includes("phase_name:"));
+    assert.ok(result.includes("project:"));
+    assert.ok(result.includes("generated:"));
+    assert.ok(result.includes("counts:"));
+    assert.ok(result.includes("missing_artifacts:"));
+  });
+
+  it("includes milestoneId as phase value", () => {
+    const result = buildFrontmatter({
+      milestoneId: "M001",
+      milestoneName: "Auth System",
+      projectName: "MyApp",
+      generatedAt: "2026-04-15T10:00:00Z",
+      counts: { decisions: 0, lessons: 0, patterns: 0, surprises: 0 },
+      missingArtifacts: [],
+    });
+
+    assert.ok(result.includes("M001"));
+    assert.ok(result.includes("Auth System"));
+    assert.ok(result.includes("MyApp"));
+    assert.ok(result.includes("2026-04-15T10:00:00Z"));
+  });
+
+  it("includes missing artifacts list", () => {
+    const result = buildFrontmatter({
+      milestoneId: "M001",
+      milestoneName: "Test",
+      projectName: "Proj",
+      generatedAt: "2026-04-15T10:00:00Z",
+      counts: { decisions: 0, lessons: 0, patterns: 0, surprises: 0 },
+      missingArtifacts: ["M001-VERIFICATION.md", "M001-UAT.md"],
+    });
+
+    assert.ok(result.includes("M001-VERIFICATION.md"));
+    assert.ok(result.includes("M001-UAT.md"));
+  });
+});
+
+// ─── extractProjectName ───────────────────────────────────────────────────────
+
+describe("extractProjectName", () => {
+  let tmpBase: string;
+
+  beforeEach(() => {
+    tmpBase = join(tmpdir(), `gsd-projname-test-${randomUUID()}`);
+    mkdirSync(join(tmpBase, ".gsd"), { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(tmpBase, { recursive: true, force: true });
+  });
+
+  it("reads name from PROJECT.md frontmatter", () => {
+    writeFileSync(
+      join(tmpBase, ".gsd", "PROJECT.md"),
+      "---\nname: My Cool Project\nversion: 1\n---\n# Project\n",
+      "utf-8",
+    );
+
+    const result = extractProjectName(tmpBase);
+    assert.equal(result, "My Cool Project");
+  });
+
+  it("falls back to directory name when PROJECT.md absent", () => {
+    const result = extractProjectName(tmpBase);
+    // Should return the last path segment of tmpBase
+    assert.equal(result, tmpBase.split("/").at(-1));
+  });
+
+  it("falls back to directory name when PROJECT.md has no name field", () => {
+    writeFileSync(
+      join(tmpBase, ".gsd", "PROJECT.md"),
+      "---\nversion: 1\n---\n# Project\n",
+      "utf-8",
+    );
+
+    const result = extractProjectName(tmpBase);
+    assert.equal(result, tmpBase.split("/").at(-1));
+  });
+});

package/src/resources/extensions/gsd/tests/commands-pr-branch.test.ts

@@ -0,0 +1,68 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+// Test the filtering logic used by /gsd pr-branch.
+// Full integration requires git operations, so we test the path filtering.
+
+test("pr-branch: identifies .gsd/ paths", () => {
+  const files = [
+    ".gsd/milestones/M001/ROADMAP.md",
+    ".gsd/metrics.json",
+    "src/main.ts",
+    "package.json",
+    ".planning/PLAN.md",
+    "PLAN.md",
+  ];
+
+  const codeFiles = files.filter(
+    (f) => !f.startsWith(".gsd/") && !f.startsWith(".planning/") && f !== "PLAN.md",
+  );
+
+  assert.deepEqual(codeFiles, ["src/main.ts", "package.json"]);
+});
+
+test("pr-branch: all .gsd/ files returns empty", () => {
+  const files = [
+    ".gsd/milestones/M001/ROADMAP.md",
+    ".gsd/metrics.json",
+    ".gsd/BACKLOG.md",
+  ];
+
+  const codeFiles = files.filter(
+    (f) => !f.startsWith(".gsd/") && !f.startsWith(".planning/") && f !== "PLAN.md",
+  );
+
+  assert.equal(codeFiles.length, 0);
+});
+
+test("pr-branch: mixed commits with code changes", () => {
+  const files = [
+    ".gsd/milestones/M001/ROADMAP.md",
+    "src/auth.ts",
+    "src/auth.test.ts",
+  ];
+
+  const hasCodeChanges = files.some(
+    (f) => !f.startsWith(".gsd/") && !f.startsWith(".planning/") && f !== "PLAN.md",
+  );
+
+  assert.ok(hasCodeChanges);
+});
+
+test("pr-branch: --dry-run flag", () => {
+  assert.ok("--dry-run".includes("--dry-run"));
+  assert.ok(!"--name my-branch".includes("--dry-run"));
+});
+
+test("pr-branch: --name flag parsing", () => {
+  const args = "--name my-clean-pr";
+  const nameMatch = args.match(/--name\s+(\S+)/);
+  assert.ok(nameMatch);
+  assert.equal(nameMatch[1], "my-clean-pr");
+});
+
+test("pr-branch: default branch name", () => {
+  const currentBranch = "feat/add-auth";
+  const prBranch = `pr/${currentBranch}`;
+  assert.equal(prBranch, "pr/feat/add-auth");
+});

package/src/resources/extensions/gsd/tests/commands-session-report.test.ts

@@ -0,0 +1,82 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+// Test the formatting logic used by session-report.
+// The actual handler requires runtime context (metrics module), so we
+// test the core formatting and aggregation patterns.
+
+test("session-report: format cost correctly", () => {
+  // Simple cost formatting test
+  const formatCost = (cost: number): string => {
+    if (cost < 0.01) return "<$0.01";
+    return `$${cost.toFixed(2)}`;
+  };
+
+  assert.equal(formatCost(0), "<$0.01");
+  assert.equal(formatCost(0.005), "<$0.01");
+  assert.equal(formatCost(1.5), "$1.50");
+  assert.equal(formatCost(10.999), "$11.00");
+});
+
+test("session-report: format token count", () => {
+  const formatTokenCount = (count: number): string => {
+    if (count >= 1_000_000) return `${(count / 1_000_000).toFixed(1)}M`;
+    if (count >= 1_000) return `${(count / 1_000).toFixed(1)}K`;
+    return String(count);
+  };
+
+  assert.equal(formatTokenCount(500), "500");
+  assert.equal(formatTokenCount(1500), "1.5K");
+  assert.equal(formatTokenCount(1_200_000), "1.2M");
+});
+
+test("session-report: aggregate by model", () => {
+  interface UnitMetric {
+    model: string;
+    cost: number;
+  }
+
+  const units: UnitMetric[] = [
+    { model: "opus", cost: 1.0 },
+    { model: "opus", cost: 0.8 },
+    { model: "sonnet", cost: 0.3 },
+    { model: "sonnet", cost: 0.5 },
+    { model: "sonnet", cost: 0.2 },
+  ];
+
+  const byModel = new Map<string, { count: number; cost: number }>();
+  for (const u of units) {
+    const existing = byModel.get(u.model) ?? { count: 0, cost: 0 };
+    existing.count++;
+    existing.cost += u.cost;
+    byModel.set(u.model, existing);
+  }
+
+  const opus = byModel.get("opus")!;
+  assert.equal(opus.count, 2);
+  assert.ok(Math.abs(opus.cost - 1.8) < 0.01);
+
+  const sonnet = byModel.get("sonnet")!;
+  assert.equal(sonnet.count, 3);
+  assert.ok(Math.abs(sonnet.cost - 1.0) < 0.01);
+});
+
+test("session-report: --json flag detection", () => {
+  const args1 = "--json";
+  const args2 = "--save --json";
+  const args3 = "something else";
+
+  assert.ok(args1.includes("--json"));
+  assert.ok(args2.includes("--json"));
+  assert.ok(!args3.includes("--json"));
+});
+
+test("session-report: --save flag detection", () => {
+  const args1 = "--save";
+  const args2 = "--save --json";
+  const args3 = "";
+
+  assert.ok(args1.includes("--save"));
+  assert.ok(args2.includes("--save"));
+  assert.ok(!args3.includes("--save"));
+});

package/src/resources/extensions/gsd/tests/commands-ship.test.ts

@@ -0,0 +1,71 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+// Test the PR content generation logic used by /gsd ship.
+// Full integration requires gh CLI + git, so we test the text generation.
+
+test("ship: generates TL;DR format", () => {
+  // Simulate generatePRContent output structure
+  const milestoneId = "M001";
+  const milestoneTitle = "User authentication system";
+
+  const title = `feat: ${milestoneTitle}`;
+  assert.equal(title, "feat: User authentication system");
+  assert.ok(title.length < 80); // PR title should be short
+});
+
+test("ship: --dry-run flag detection", () => {
+  const args1 = "--dry-run";
+  const args2 = "--draft --dry-run";
+  const args3 = "--draft";
+
+  assert.ok(args1.includes("--dry-run"));
+  assert.ok(args2.includes("--dry-run"));
+  assert.ok(!args3.includes("--dry-run"));
+});
+
+test("ship: --base flag parsing", () => {
+  const args = "--base develop --draft";
+  const baseMatch = args.match(/--base\s+(\S+)/);
+  assert.ok(baseMatch);
+  assert.equal(baseMatch[1], "develop");
+});
+
+test("ship: --base flag absent defaults", () => {
+  const args = "--draft";
+  const baseMatch = args.match(/--base\s+(\S+)/);
+  assert.equal(baseMatch, null);
+});
+
+test("ship: --force flag detection", () => {
+  const args1 = "--force";
+  const args2 = "";
+
+  assert.ok(args1.includes("--force"));
+  assert.ok(!args2.includes("--force"));
+});
+
+test("ship: change type checklist format", () => {
+  const checklist = [
+    "- [x] `feat` — New feature or capability",
+    "- [ ] `fix` — Bug fix",
+    "- [ ] `refactor` — Code restructuring",
+    "- [ ] `test` — Adding or updating tests",
+    "- [ ] `docs` — Documentation only",
+    "- [ ] `chore` — Build, CI, or tooling changes",
+  ];
+
+  // Verify format matches CONTRIBUTING.md expectations
+  for (const line of checklist) {
+    assert.match(line, /^- \[[ x]\] `\w+` — .+$/);
+  }
+});
+
+test("ship: PR body contains required sections", () => {
+  const requiredSections = ["## TL;DR", "## Change type"];
+  const body = "## TL;DR\n\n**What:** Ship M001\n\n## Change type\n\n- [x] `feat`";
+
+  for (const section of requiredSections) {
+    assert.ok(body.includes(section), `Missing section: ${section}`);
+  }
+});

package/src/resources/extensions/gsd/tests/commands-workflow-custom.test.ts

@@ -217,6 +217,20 @@ describe("workflow command handler", () => {
     );
   });
 
+  it("preserves quoted workflow run overrides (#4130)", async () => {
+    const { parseWorkflowRunArgs } = await import("../commands/handlers/workflow.ts");
+    assert.deepStrictEqual(
+      parseWorkflowRunArgs('demo-workflow target="multi word target" region=\'us east\''),
+      {
+        defName: "demo-workflow",
+        overrides: {
+          target: "multi word target",
+          region: "us east",
+        },
+      },
+    );
+  });
+
   it("'/gsd workflow run nonexistent' shows error for missing definition", async () => {
     const { handled, notifications } = await callHandler("workflow run nonexistent-def-12345");
     assert.ok(handled, "should be handled");