gsd-pi 2.78.0 → 2.78.1-dev.8a893322c

package/src/resources/extensions/gsd/tests/budget-prediction.test.ts

@@ -1,220 +1,147 @@
 /**
- * Budget Prediction — unit tests for M004/S04.
+ * budget-prediction.test.ts — unit tests for budget prediction math
+ * (`getAverageCostPerUnitType`, `predictRemainingCost`) exported from
+ * `metrics.ts`.
  *
- * Tests prediction math, auto-downgrade logic, and dashboard integration.
- * Uses extracted pure functions (avoiding module import chain) and
- * source-level structural checks for dashboard/auto.ts integration.
+ * The previous version (PR #582, `972dd05f4`) re-implemented both
+ * functions inline, citing a `paths.js → @gsd/pi-coding-agent` import
+ * chain as the reason. That chain concern is no longer valid — the
+ * real exports import cleanly from `metrics.ts`. All 10 math tests
+ * were then exercising the test's own copy of the functions, not the
+ * product code. #4840 documented the false-coverage case.
+ *
+ * This rewrite imports the real functions, deletes the inline copies,
+ * drops the 3 source-grep tests (`metricsSrc.includes(...)`) and the
+ * 2 dashboard `includes` tests (dashboard integration should be a
+ * behaviour test against the dashboard builder, not a grep), and
+ * deletes the synthesized `downgrade:` test that exercised a local
+ * closure instead of product code. See #4784 / #4840.
  */
 
-import test from "node:test";
+import { describe, 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";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const metricsSrc = readFileSync(join(__dirname, "..", "metrics.ts"), "utf-8");
-const dashboardSrc = readFileSync(join(__dirname, "..", "auto-dashboard.ts"), "utf-8");
-
-// ─── Extract pure functions from metrics.ts source ────────────────────────
-// Can't import directly due to paths.js → @gsd/pi-coding-agent import chain.
-// Extract and evaluate the pure math functions.
-
-interface MockUnitMetrics {
-  type: string;
-  cost: number;
-}
-
-// Re-implement the functions under test (verified against source below)
-function getAverageCostPerUnitType(units: MockUnitMetrics[]): Map<string, number> {
-  const sums = new Map<string, { total: number; count: number }>();
-  for (const u of units) {
-    const entry = sums.get(u.type) ?? { total: 0, count: 0 };
-    entry.total += u.cost;
-    entry.count += 1;
-    sums.set(u.type, entry);
-  }
-  const avgs = new Map<string, number>();
-  for (const [type, { total, count }] of sums) {
-    avgs.set(type, total / count);
-  }
-  return avgs;
-}
 
-function predictRemainingCost(
-  avgCosts: Map<string, number>,
-  remainingUnits: string[],
-  fallbackAvg?: number,
-): number {
-  const allAvgs = [...avgCosts.values()];
-  const overallAvg = fallbackAvg ?? (allAvgs.length > 0 ? allAvgs.reduce((a, b) => a + b, 0) / allAvgs.length : 0);
-  let total = 0;
-  for (const unitType of remainingUnits) {
-    total += avgCosts.get(unitType) ?? overallAvg;
-  }
-  return total;
+import {
+  getAverageCostPerUnitType,
+  predictRemainingCost,
+} from "../metrics.ts";
+import type { UnitMetrics } from "../metrics.ts";
+
+// ─── Fixture helper ───────────────────────────────────────────────────────
+// UnitMetrics has several required fields; this builder lets each test
+// specify only the fields that matter for the cost math.
+
+function makeUnit(partial: Partial<UnitMetrics> & { type: string; cost: number }): UnitMetrics {
+  return {
+    id: "M001/S01/T01",
+    model: "test-model",
+    startedAt: 0,
+    finishedAt: 0,
+    tokens: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+    toolCalls: 0,
+    assistantMessages: 0,
+    userMessages: 0,
+    ...partial,
+  };
 }
 
-// ═══════════════════════════════════════════════════════════════════════════
-// Source Verification — confirm our re-implementation matches
-// ═══════════════════════════════════════════════════════════════════════════
-
-test("source: metrics.ts exports getAverageCostPerUnitType", () => {
-  assert.ok(metricsSrc.includes("export function getAverageCostPerUnitType"), "should be exported");
-});
-
-test("source: metrics.ts exports predictRemainingCost", () => {
-  assert.ok(metricsSrc.includes("export function predictRemainingCost"), "should be exported");
-});
-
-test("source: getAverageCostPerUnitType uses Map<string, number>", () => {
-  assert.ok(
-    metricsSrc.includes("Map<string, number>") && metricsSrc.includes("getAverageCostPerUnitType"),
-    "should return Map<string, number>",
-  );
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Average Cost Per Unit Type
-// ═══════════════════════════════════════════════════════════════════════════
-
-test("avgCost: returns correct averages per unit type", () => {
-  const units: MockUnitMetrics[] = [
-    { type: "execute-task", cost: 0.10 },
-    { type: "execute-task", cost: 0.20 },
-    { type: "plan-slice", cost: 0.05 },
-    { type: "plan-slice", cost: 0.15 },
-    { type: "complete-slice", cost: 0.08 },
-  ];
-  const avgs = getAverageCostPerUnitType(units);
-  assert.ok(Math.abs(avgs.get("execute-task")! - 0.15) < 0.001, "execute-task avg should be 0.15");
-  assert.ok(Math.abs(avgs.get("plan-slice")! - 0.10) < 0.001, "plan-slice avg should be 0.10");
-  assert.ok(Math.abs(avgs.get("complete-slice")! - 0.08) < 0.001, "complete-slice avg should be 0.08");
-});
-
-test("avgCost: returns empty map for empty input", () => {
-  const avgs = getAverageCostPerUnitType([]);
-  assert.equal(avgs.size, 0);
-});
-
-test("avgCost: single unit per type returns exact cost", () => {
-  const avgs = getAverageCostPerUnitType([{ type: "execute-task", cost: 0.42 }]);
-  assert.ok(Math.abs(avgs.get("execute-task")! - 0.42) < 0.001);
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Predict Remaining Cost
-// ═══════════════════════════════════════════════════════════════════════════
-
-test("predict: calculates remaining cost from averages", () => {
-  const avgs = new Map([
-    ["execute-task", 0.15],
-    ["plan-slice", 0.10],
-    ["complete-slice", 0.08],
-  ]);
-  const remaining = ["execute-task", "execute-task", "complete-slice"];
-  const cost = predictRemainingCost(avgs, remaining);
-  assert.ok(Math.abs(cost - 0.38) < 0.001);
-});
-
-test("predict: uses overall average for unknown unit types", () => {
-  const avgs = new Map([
-    ["execute-task", 0.10],
-    ["plan-slice", 0.20],
-  ]);
-  const remaining = ["execute-task", "unknown-type"];
-  const cost = predictRemainingCost(avgs, remaining);
-  // unknown: (0.10 + 0.20) / 2 = 0.15 → total 0.10 + 0.15 = 0.25
-  assert.ok(Math.abs(cost - 0.25) < 0.001);
-});
-
-test("predict: returns 0 for empty remaining", () => {
-  const avgs = new Map([["execute-task", 0.15]]);
-  assert.equal(predictRemainingCost(avgs, []), 0);
-});
-
-test("predict: handles no averages with fallback", () => {
-  const avgs = new Map<string, number>();
-  const cost = predictRemainingCost(avgs, ["execute-task", "plan-slice"], 0.10);
-  assert.ok(Math.abs(cost - 0.20) < 0.001);
-});
-
-test("predict: handles no averages and no fallback", () => {
-  const avgs = new Map<string, number>();
-  const cost = predictRemainingCost(avgs, ["execute-task"]);
-  assert.equal(cost, 0);
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Dashboard Integration
-// ═══════════════════════════════════════════════════════════════════════════
-
-test("dashboard: AutoDashboardData includes projectedRemainingCost field", () => {
-  assert.ok(
-    dashboardSrc.includes("projectedRemainingCost"),
-    "AutoDashboardData should have projectedRemainingCost field",
-  );
-});
-
-test("dashboard: AutoDashboardData includes profileDowngraded field", () => {
-  assert.ok(
-    dashboardSrc.includes("profileDowngraded"),
-    "AutoDashboardData should have profileDowngraded field",
-  );
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Budget Prediction — End-to-End Math
-// ═══════════════════════════════════════════════════════════════════════════
-
-test("e2e: budget ceiling exceeded triggers downgrade prediction", () => {
-  const units: MockUnitMetrics[] = [
-    { type: "execute-task", cost: 0.50 },
-    { type: "execute-task", cost: 0.60 },
-    { type: "plan-slice", cost: 0.30 },
-    { type: "complete-slice", cost: 0.20 },
-  ];
-  const totalSpent = units.reduce((sum, u) => sum + u.cost, 0); // 1.60
-  const avgs = getAverageCostPerUnitType(units);
-  const remaining = ["execute-task", "execute-task", "execute-task"];
-  const predictedRemaining = predictRemainingCost(avgs, remaining);
-  const predictedTotal = totalSpent + predictedRemaining;
-  const budgetCeiling = 2.50;
-  assert.ok(predictedTotal > budgetCeiling, "should predict budget exhaustion");
-});
-
-test("e2e: budget ceiling not exceeded does not trigger", () => {
-  const units: MockUnitMetrics[] = [
-    { type: "execute-task", cost: 0.10 },
-    { type: "plan-slice", cost: 0.05 },
-  ];
-  const totalSpent = units.reduce((sum, u) => sum + u.cost, 0); // 0.15
-  const avgs = getAverageCostPerUnitType(units);
-  const remaining = ["execute-task", "complete-slice"];
-  const predictedRemaining = predictRemainingCost(avgs, remaining);
-  const predictedTotal = totalSpent + predictedRemaining;
-  const budgetCeiling = 5.00;
-  assert.ok(predictedTotal <= budgetCeiling, "should not predict budget exhaustion");
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Downgrade Logic
-// ═══════════════════════════════════════════════════════════════════════════
-
-test("downgrade: one-way per D048 — downgrade should not be reversible", () => {
-  // Simulate: first prediction triggers downgrade, second doesn't reverse it
-  let downgraded = false;
-
-  function checkDowngrade(predictedTotal: number, ceiling: number) {
-    if (!downgraded && predictedTotal > ceiling) {
-      downgraded = true;
-    }
-    // Never reverse — per D048
-  }
-
-  checkDowngrade(3.00, 2.50); // triggers
-  assert.ok(downgraded, "should downgrade when prediction exceeds ceiling");
-
-  checkDowngrade(1.50, 2.50); // doesn't reverse
-  assert.ok(downgraded, "should stay downgraded (one-way per D048)");
+describe("getAverageCostPerUnitType (metrics.ts)", () => {
+  test("returns correct averages per unit type", () => {
+    const units = [
+      makeUnit({ type: "execute-task", cost: 0.1 }),
+      makeUnit({ type: "execute-task", cost: 0.2 }),
+      makeUnit({ type: "plan-slice", cost: 0.05 }),
+      makeUnit({ type: "plan-slice", cost: 0.15 }),
+      makeUnit({ type: "complete-slice", cost: 0.08 }),
+    ];
+    const avgs = getAverageCostPerUnitType(units);
+    assert.ok(Math.abs(avgs.get("execute-task")! - 0.15) < 0.001, "execute-task avg");
+    assert.ok(Math.abs(avgs.get("plan-slice")! - 0.10) < 0.001, "plan-slice avg");
+    assert.ok(Math.abs(avgs.get("complete-slice")! - 0.08) < 0.001, "complete-slice avg");
+  });
+
+  test("returns empty map for empty input", () => {
+    assert.equal(getAverageCostPerUnitType([]).size, 0);
+  });
+
+  test("single unit per type returns exact cost", () => {
+    const avgs = getAverageCostPerUnitType([makeUnit({ type: "execute-task", cost: 0.42 })]);
+    assert.ok(Math.abs(avgs.get("execute-task")! - 0.42) < 0.001);
+  });
+});
+
+describe("predictRemainingCost (metrics.ts)", () => {
+  test("calculates remaining cost from known averages", () => {
+    const avgs = new Map([
+      ["execute-task", 0.15],
+      ["plan-slice", 0.10],
+      ["complete-slice", 0.08],
+    ]);
+    const remaining = ["execute-task", "execute-task", "complete-slice"];
+    const cost = predictRemainingCost(avgs, remaining);
+    // 2 × 0.15 + 0.08 = 0.38
+    assert.ok(Math.abs(cost - 0.38) < 0.001);
+  });
+
+  test("uses overall average for unknown unit types", () => {
+    const avgs = new Map([
+      ["execute-task", 0.10],
+      ["plan-slice", 0.20],
+    ]);
+    const remaining = ["execute-task", "unknown-type"];
+    // unknown: (0.10 + 0.20) / 2 = 0.15 → total 0.10 + 0.15 = 0.25
+    assert.ok(Math.abs(predictRemainingCost(avgs, remaining) - 0.25) < 0.001);
+  });
+
+  test("returns 0 for empty remaining list", () => {
+    const avgs = new Map([["execute-task", 0.15]]);
+    assert.equal(predictRemainingCost(avgs, []), 0);
+  });
+
+  test("uses fallback when no averages are known", () => {
+    const cost = predictRemainingCost(new Map(), ["execute-task", "plan-slice"], 0.10);
+    assert.ok(Math.abs(cost - 0.20) < 0.001);
+  });
+
+  test("returns 0 when no averages and no fallback", () => {
+    assert.equal(predictRemainingCost(new Map(), ["execute-task"]), 0);
+  });
+});
+
+describe("end-to-end budget prediction (composes the real functions)", () => {
+  test("budget ceiling exceeded is detectable from real averages + projection", () => {
+    const units = [
+      makeUnit({ type: "execute-task", cost: 0.5 }),
+      makeUnit({ type: "execute-task", cost: 0.6 }),
+      makeUnit({ type: "plan-slice", cost: 0.3 }),
+      makeUnit({ type: "complete-slice", cost: 0.2 }),
+    ];
+    const totalSpent = units.reduce((sum, u) => sum + u.cost, 0); // 1.60
+    const avgs = getAverageCostPerUnitType(units);
+    const predicted = predictRemainingCost(avgs, [
+      "execute-task",
+      "execute-task",
+      "execute-task",
+    ]);
+    // avg execute-task = 0.55, predicted remaining = 3 × 0.55 = 1.65
+    // total = 1.60 + 1.65 = 3.25 > 2.50 ceiling
+    assert.ok(
+      totalSpent + predicted > 2.5,
+      "spent + predicted should exceed test ceiling",
+    );
+  });
+
+  test("budget ceiling not exceeded when averages stay low", () => {
+    const units = [
+      makeUnit({ type: "execute-task", cost: 0.1 }),
+      makeUnit({ type: "plan-slice", cost: 0.05 }),
+    ];
+    const totalSpent = units.reduce((sum, u) => sum + u.cost, 0); // 0.15
+    const avgs = getAverageCostPerUnitType(units);
+    const predicted = predictRemainingCost(avgs, ["execute-task", "complete-slice"]);
+    assert.ok(
+      totalSpent + predicted <= 5.0,
+      "spent + predicted should stay under test ceiling",
+    );
+  });
 });

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

@@ -2,12 +2,56 @@
 //
 // Guards the skill-trigger table in system-context.ts against accidental
 // regression. Every entry must have a non-empty trigger + skill, and the
-// skills added in PR #4505 must remain present.
+// skills added in PR #4505 and PR #5060 must remain present.
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
 
 import { BUNDLED_SKILL_TRIGGERS } from '../bootstrap/system-context.ts';
 
+const PR_4505_BUNDLED_SKILLS = [
+  'review',
+  'test',
+  'lint',
+  'make-interfaces-feel-better',
+  'accessibility',
+  'grill-me',
+  'design-an-interface',
+  'tdd',
+  'write-milestone-brief',
+  'decompose-into-slices',
+  'spike-wrap-up',
+  'verify-before-complete',
+  'create-mcp-server',
+  'write-docs',
+  'forensics',
+  'handoff',
+  'security-review',
+  'api-design',
+  'dependency-upgrade',
+  'observability',
+] as const;
+
+const PR_5060_BUNDLED_SKILLS = [
+  'react-best-practices',
+  'core-web-vitals',
+  'github-workflows',
+  'web-quality-audit',
+  'agent-browser',
+  'web-design-guidelines',
+  'userinterface-wiki',
+  'create-skill',
+  'create-gsd-extension',
+  'create-workflow',
+  'code-optimizer',
+] as const;
+
+function assertBundledSkillsRegistered(label: string, expectedSkills: readonly string[]): void {
+  const registered = new Set(BUNDLED_SKILL_TRIGGERS.map(e => e.skill));
+  for (const skill of expectedSkills) {
+    assert.ok(registered.has(skill), `${label}: expected bundled skill "${skill}" to be registered`);
+  }
+}
+
 test('BUNDLED_SKILL_TRIGGERS: every entry has a non-empty trigger and skill', () => {
   assert.ok(BUNDLED_SKILL_TRIGGERS.length > 0, 'table should not be empty');
   for (const { trigger, skill } of BUNDLED_SKILL_TRIGGERS) {
@@ -17,32 +61,11 @@ test('BUNDLED_SKILL_TRIGGERS: every entry has a non-empty trigger and skill', ()
 });
 
 test('BUNDLED_SKILL_TRIGGERS: PR #4505 bundled skills are present', () => {
-  const expected = [
-    'review',
-    'test',
-    'lint',
-    'make-interfaces-feel-better',
-    'accessibility',
-    'grill-me',
-    'design-an-interface',
-    'tdd',
-    'write-milestone-brief',
-    'decompose-into-slices',
-    'spike-wrap-up',
-    'verify-before-complete',
-    'create-mcp-server',
-    'write-docs',
-    'forensics',
-    'handoff',
-    'security-review',
-    'api-design',
-    'dependency-upgrade',
-    'observability',
-  ];
-  const registered = new Set(BUNDLED_SKILL_TRIGGERS.map(e => e.skill));
-  for (const skill of expected) {
-    assert.ok(registered.has(skill), `expected bundled skill "${skill}" to be registered`);
-  }
+  assertBundledSkillsRegistered('PR #4505', PR_4505_BUNDLED_SKILLS);
+});
+
+test('BUNDLED_SKILL_TRIGGERS: PR #5060 previously-unexposed skills are present', () => {
+  assertBundledSkillsRegistered('PR #5060', PR_5060_BUNDLED_SKILLS);
 });
 
 test('BUNDLED_SKILL_TRIGGERS: skill ids are unique', () => {

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

@@ -0,0 +1,58 @@
+// GSD2 — Regression test for Issue #4946 isVersionGreater (commands-extensions.ts)
+//
+// Covers the inline npm-version comparator that replaced the `semver` import in
+// commands-extensions.ts. The original import broke `tsc -p tsconfig.json` whenever
+// `@types/semver` failed to install — the file is type-checked transitively despite
+// being under the `src/resources` exclude. The replacement keeps the same comparison
+// semantics for the realistic input space (npm extension version strings) without
+// pulling in the full semver type surface.
+
+import test, { describe } from "node:test";
+import assert from "node:assert/strict";
+import { isVersionGreater } from "../commands-extensions.ts";
+
+describe("isVersionGreater — npm extension version comparison (#4946)", () => {
+	test("strictly greater patch beats lesser patch", () => {
+		assert.equal(isVersionGreater("1.2.4", "1.2.3"), true);
+		assert.equal(isVersionGreater("1.2.3", "1.2.4"), false);
+	});
+
+	test("equal versions are not strictly greater", () => {
+		assert.equal(isVersionGreater("1.2.3", "1.2.3"), false);
+	});
+
+	test("numeric (not lexicographic) component comparison", () => {
+		// Lexicographic compare would say "1.10.0" < "1.9.0".
+		assert.equal(isVersionGreater("1.10.0", "1.9.0"), true);
+		assert.equal(isVersionGreater("1.9.0", "1.10.0"), false);
+	});
+
+	test("major bump beats minor and patch differences", () => {
+		assert.equal(isVersionGreater("2.0.0", "1.99.99"), true);
+		assert.equal(isVersionGreater("1.99.99", "2.0.0"), false);
+	});
+
+	test("missing trailing components default to zero", () => {
+		assert.equal(isVersionGreater("1.2", "1.1.9"), true);
+		assert.equal(isVersionGreater("1", "0.9.9"), true);
+		assert.equal(isVersionGreater("1.2", "1.2.0"), false);
+	});
+
+	test("release version beats prerelease at the same release number", () => {
+		assert.equal(isVersionGreater("1.0.0", "1.0.0-beta.1"), true);
+		assert.equal(isVersionGreater("1.0.0-beta.1", "1.0.0"), false);
+	});
+
+	test("prerelease ordering: beta.2 > beta.1, rc.1 > beta.9", () => {
+		assert.equal(isVersionGreater("1.0.0-beta.2", "1.0.0-beta.1"), true);
+		assert.equal(isVersionGreater("1.0.0-rc.1", "1.0.0-beta.9"), true);
+	});
+
+	test("non-numeric junk in components doesn't crash — coerces to 0", () => {
+		// Defensive: we don't throw on garbage input; we treat unparseable
+		// components as 0. This matches the behaviour the extension installer
+		// can rely on without surfacing an error to the user.
+		assert.equal(isVersionGreater("1.x.0", "1.0.0"), false);
+		assert.equal(isVersionGreater("abc", "0.0.1"), false);
+	});
+});

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

@@ -0,0 +1,48 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  formatCleanKeepReason,
+  type WorktreeStatus,
+} from "../commands-worktree.ts";
+
+function mkStatus(over: Partial<WorktreeStatus>): WorktreeStatus {
+  const name = over.name ?? "feat-x";
+  return {
+    name,
+    path: `/repo/.gsd/worktrees/${name}`,
+    branch: `gsd/${name}`,
+    exists: true,
+    filesChanged: 0,
+    linesAdded: 0,
+    linesRemoved: 0,
+    uncommitted: false,
+    commits: 0,
+    ...over,
+  };
+}
+
+test("clean keep reason shows uncommitted-only worktrees clearly", () => {
+  const reason = formatCleanKeepReason(mkStatus({ uncommitted: true }));
+  assert.equal(reason, "uncommitted changes");
+});
+
+test("clean keep reason includes uncommitted context with changed files", () => {
+  const reason = formatCleanKeepReason(mkStatus({ filesChanged: 2, uncommitted: true }));
+  assert.equal(reason, "2 changed files, uncommitted");
+});
+
+test("clean keep reason flags missing directory with prune hint", () => {
+  const reason = formatCleanKeepReason(mkStatus({ exists: false }));
+  assert.equal(reason, "directory missing — run 'git worktree prune' to unregister");
+});
+
+test("clean keep reason reports changed files without uncommitted suffix", () => {
+  const reason = formatCleanKeepReason(mkStatus({ filesChanged: 2, uncommitted: false }));
+  assert.equal(reason, "2 changed files");
+});
+
+test("clean keep reason uses singular form for a single changed file", () => {
+  const reason = formatCleanKeepReason(mkStatus({ filesChanged: 1, uncommitted: false }));
+  assert.equal(reason, "1 changed file");
+});