gsd-pi 2.19.0 → 2.20.0

package/src/resources/extensions/gsd/tests/model-isolation.test.ts

@@ -0,0 +1,99 @@
+/**
+ * Tests for model config isolation between concurrent instances (#650).
+ */
+
+import { describe, it, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, writeFileSync, rmSync, existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+// ─── Test helpers ─────────────────────────────────────────────────────────────
+
+function makeTmpDir(suffix: string): string {
+  const dir = join(tmpdir(), `gsd-test-650-${suffix}-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+// ─── Settings Manager Model Scoping ───────────────────────────────────────────
+
+describe("model config isolation (#650)", () => {
+  let tmpGlobal: string;
+  let tmpProjectA: string;
+  let tmpProjectB: string;
+
+  beforeEach(() => {
+    tmpGlobal = makeTmpDir("global");
+    tmpProjectA = makeTmpDir("project-a");
+    tmpProjectB = makeTmpDir("project-b");
+    // Create .pi directories for project settings
+    mkdirSync(join(tmpProjectA, ".pi"), { recursive: true });
+    mkdirSync(join(tmpProjectB, ".pi"), { recursive: true });
+  });
+
+  afterEach(() => {
+    try { rmSync(tmpGlobal, { recursive: true, force: true }); } catch {}
+    try { rmSync(tmpProjectA, { recursive: true, force: true }); } catch {}
+    try { rmSync(tmpProjectB, { recursive: true, force: true }); } catch {}
+  });
+
+  it("project settings file isolates model from global", async () => {
+    // Write project settings for project A
+    const projectSettingsPath = join(tmpProjectA, ".pi", "settings.json");
+    writeFileSync(projectSettingsPath, JSON.stringify({
+      defaultProvider: "anthropic",
+      defaultModel: "claude-opus-4-6",
+    }));
+
+    // Write global settings with a different model
+    const globalSettingsPath = join(tmpGlobal, "settings.json");
+    writeFileSync(globalSettingsPath, JSON.stringify({
+      defaultProvider: "openai",
+      defaultModel: "gpt-5.4",
+    }));
+
+    // Verify project settings exist and have independent data
+    const projectData = JSON.parse(readFileSync(projectSettingsPath, "utf-8"));
+    const globalData = JSON.parse(readFileSync(globalSettingsPath, "utf-8"));
+
+    assert.equal(projectData.defaultModel, "claude-opus-4-6");
+    assert.equal(globalData.defaultModel, "gpt-5.4");
+    assert.notEqual(projectData.defaultModel, globalData.defaultModel,
+      "Project and global should have different models");
+  });
+
+  it("two projects have independent model configs", () => {
+    const settingsA = join(tmpProjectA, ".pi", "settings.json");
+    const settingsB = join(tmpProjectB, ".pi", "settings.json");
+
+    writeFileSync(settingsA, JSON.stringify({
+      defaultProvider: "anthropic",
+      defaultModel: "claude-opus-4-6",
+    }));
+    writeFileSync(settingsB, JSON.stringify({
+      defaultProvider: "openai-codex",
+      defaultModel: "gpt-5.4",
+    }));
+
+    const dataA = JSON.parse(readFileSync(settingsA, "utf-8"));
+    const dataB = JSON.parse(readFileSync(settingsB, "utf-8"));
+
+    assert.equal(dataA.defaultModel, "claude-opus-4-6");
+    assert.equal(dataB.defaultModel, "gpt-5.4");
+    assert.notEqual(dataA.defaultProvider, dataB.defaultProvider);
+  });
+
+  it("autoModeStartModel concept prevents model drift", () => {
+    // Simulate the auto-mode start model capture pattern
+    const autoModeStartModel = { provider: "anthropic", id: "claude-opus-4-6" };
+
+    // Simulate another instance writing to global settings
+    const globalSettings = { defaultProvider: "openai-codex", defaultModel: "gpt-5.4" };
+
+    // The captured model should be used, not the global settings
+    assert.notEqual(autoModeStartModel.id, globalSettings.defaultModel);
+    assert.equal(autoModeStartModel.id, "claude-opus-4-6",
+      "Captured model should be preserved regardless of global settings changes");
+  });
+});

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

@@ -1661,4 +1661,44 @@ console.log('\n=== LLM round-trip: extra blank lines ===');
   assertTrue(consecutiveBlanks === null, 'blank-lines: formatted output has no 4+ consecutive newlines');
 }
 
+// ═══════════════════════════════════════════════════════════════════════════
+// parseRoadmap: boundary map with embedded code fences (#468)
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== parseRoadmap: boundary map with code fences (#468) ===');
+{
+  const content = `# M001: Test
+
+**Vision:** Test
+
+## Slices
+
+- [ ] **S01: Core** \`risk:low\` \`depends:[]\`
+- [ ] **S02: API** \`risk:low\` \`depends:[S01]\`
+
+## Boundary Map
+
+### S01 → S02
+
+Produces:
+  types.ts — all types
+  \`\`\`
+  const x = 1;
+  \`\`\`
+
+Consumes: nothing
+`;
+
+  // This test ensures the boundary map parser does not hang or
+  // catastrophically backtrack when content contains code fences.
+  const start = Date.now();
+  const r = parseRoadmap(content);
+  const elapsed = Date.now() - start;
+
+  assertTrue(elapsed < 1000, `boundary map with code fences parsed in ${elapsed}ms (should be < 1s)`);
+  assertEq(r.slices.length, 2, 'code-fence roadmap: slice count');
+  // Boundary map should still parse (may not capture perfectly with code fences, but must not hang)
+  assertTrue(r.boundaryMap.length >= 0, 'code-fence roadmap: boundary map parsed without hanging');
+}
+
 report();

package/src/resources/extensions/gsd/tests/post-unit-hooks.test.ts

@@ -1,5 +1,4 @@
 // GSD Extension — Hook Engine Tests (Post-Unit, Pre-Dispatch, State Persistence)
-// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
 
 import { mkdtempSync, mkdirSync, rmSync, writeFileSync, existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
@@ -18,6 +17,7 @@ import {
   clearPersistedHookState,
   getHookStatus,
   formatHookStatus,
+  triggerHookManually,
 } from "../post-unit-hooks.ts";
 
 const { assertEq, assertTrue, assertMatch, report } = createTestContext();
@@ -294,4 +294,44 @@ console.log("\n=== Hook status: no hooks ===");
   assertMatch(formatted, /No hooks configured/, "status message says no hooks");
 }
 
+// ═══════════════════════════════════════════════════════════════════════════
+// Phase 4: Manual Hook Trigger Tests
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log("\n=== triggerHookManually: hook not found ===");
+
+{
+  resetHookState();
+  const base = createFixtureBase();
+  try {
+    const result = triggerHookManually("nonexistent-hook", "execute-task", "M001/S01/T01", base);
+    assertEq(result, null, "returns null when hook not found");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+}
+
+console.log("\n=== triggerHookManually: with configured hook ===");
+
+{
+  resetHookState();
+  const base = createFixtureBase();
+  try {
+    // This test will work when preferences are configured
+    // For now, just verify the function exists and handles missing hooks
+    const result = triggerHookManually("code-review", "execute-task", "M001/S01/T01", base);
+    // Result depends on whether code-review hook is configured in preferences
+    // The function should either return null or a valid HookDispatchResult
+    assertTrue(result === null || typeof result === "object", "returns null or object");
+    if (result) {
+      assertEq(result.hookName, "code-review", "hook name in result");
+      assertEq(result.unitType, "hook/code-review", "unit type is hook-prefixed");
+      assertEq(result.unitId, "M001/S01/T01", "unit ID preserved");
+      assertTrue(typeof result.prompt === "string", "prompt is a string");
+    }
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+}
+
 report();

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

@@ -1,5 +1,4 @@
 // GSD Git Preferences Tests — validates git.isolation and git.merge_to_main handling
-// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
 
 import { createTestContext } from "./test-helpers.ts";
 import { validatePreferences } from "../preferences.ts";

package/src/resources/extensions/gsd/tests/preferences-hooks.test.ts

@@ -1,5 +1,4 @@
 // GSD Extension — Hook Preferences Parsing Tests (Post-Unit + Pre-Dispatch)
-// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
 
 import { createTestContext } from "./test-helpers.ts";
 import type { PreDispatchHookConfig } from "../types.ts";

package/src/resources/extensions/gsd/tests/preferences-mode.test.ts

@@ -0,0 +1,110 @@
+// GSD Workflow Mode Tests — validates mode defaults, overrides, and validation
+
+import { createTestContext } from "./test-helpers.ts";
+import { validatePreferences, applyModeDefaults } from "../preferences.ts";
+import type { GSDPreferences } from "../preferences.ts";
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+async function main(): Promise<void> {
+  console.log("\n=== mode: solo defaults ===");
+
+  {
+    const prefs: GSDPreferences = { mode: "solo" };
+    const result = applyModeDefaults("solo", prefs);
+    assertEq(result.git?.auto_push, true, "solo — auto_push defaults to true");
+    assertEq(result.git?.push_branches, false, "solo — push_branches defaults to false");
+    assertEq(result.git?.pre_merge_check, false, "solo — pre_merge_check defaults to false");
+    assertEq(result.git?.merge_strategy, "squash", "solo — merge_strategy defaults to squash");
+    assertEq(result.git?.isolation, "worktree", "solo — isolation defaults to worktree");
+    assertEq(result.git?.commit_docs, true, "solo — commit_docs defaults to true");
+    assertEq(result.unique_milestone_ids, false, "solo — unique_milestone_ids defaults to false");
+  }
+
+  console.log("\n=== mode: team defaults ===");
+
+  {
+    const prefs: GSDPreferences = { mode: "team" };
+    const result = applyModeDefaults("team", prefs);
+    assertEq(result.git?.auto_push, false, "team — auto_push defaults to false");
+    assertEq(result.git?.push_branches, true, "team — push_branches defaults to true");
+    assertEq(result.git?.pre_merge_check, true, "team — pre_merge_check defaults to true");
+    assertEq(result.git?.merge_strategy, "squash", "team — merge_strategy defaults to squash");
+    assertEq(result.git?.isolation, "worktree", "team — isolation defaults to worktree");
+    assertEq(result.git?.commit_docs, true, "team — commit_docs defaults to true");
+    assertEq(result.unique_milestone_ids, true, "team — unique_milestone_ids defaults to true");
+  }
+
+  console.log("\n=== explicit override wins over mode default ===");
+
+  {
+    const prefs: GSDPreferences = {
+      mode: "solo",
+      git: { auto_push: false },
+    };
+    const result = applyModeDefaults("solo", prefs);
+    assertEq(result.git?.auto_push, false, "solo + explicit auto_push=false — override wins");
+    assertEq(result.git?.push_branches, false, "solo + override — other defaults still apply");
+    assertEq(result.git?.merge_strategy, "squash", "solo + override — merge_strategy still defaults");
+  }
+
+  console.log("\n=== no mode set — no defaults injected ===");
+
+  {
+    const prefs: GSDPreferences = { git: { auto_push: true } };
+    const { preferences } = validatePreferences(prefs);
+    assertEq(preferences.mode, undefined, "no mode — mode is undefined");
+    assertEq(preferences.git?.push_branches, undefined, "no mode — push_branches not injected");
+    assertEq(preferences.unique_milestone_ids, undefined, "no mode — unique_milestone_ids not injected");
+  }
+
+  console.log("\n=== invalid mode value → validation error ===");
+
+  {
+    const { errors } = validatePreferences({ mode: "invalid" as any });
+    assertTrue(errors.length > 0, "invalid mode — produces error");
+    assertTrue(errors[0].includes("solo, team"), "invalid mode — error mentions valid values");
+  }
+
+  console.log("\n=== valid mode values pass validation ===");
+
+  {
+    const { errors: soloErrors, preferences: soloPrefs } = validatePreferences({ mode: "solo" });
+    assertEq(soloErrors.length, 0, "mode: solo — no errors");
+    assertEq(soloPrefs.mode, "solo", "mode: solo — value preserved");
+  }
+  {
+    const { errors: teamErrors, preferences: teamPrefs } = validatePreferences({ mode: "team" });
+    assertEq(teamErrors.length, 0, "mode: team — no errors");
+    assertEq(teamPrefs.mode, "team", "mode: team — value preserved");
+  }
+
+  console.log("\n=== deep merge: mode + explicit git.remote ===");
+
+  {
+    const prefs: GSDPreferences = {
+      mode: "team",
+      git: { remote: "upstream" },
+    };
+    const result = applyModeDefaults("team", prefs);
+    assertEq(result.git?.remote, "upstream", "team + git.remote — custom remote preserved");
+    assertEq(result.git?.auto_push, false, "team + git.remote — team auto_push default applied");
+    assertEq(result.git?.push_branches, true, "team + git.remote — team push_branches default applied");
+  }
+
+  console.log("\n=== mode + unique_milestone_ids explicit override ===");
+
+  {
+    const prefs: GSDPreferences = {
+      mode: "team",
+      unique_milestone_ids: false,
+    };
+    const result = applyModeDefaults("team", prefs);
+    assertEq(result.unique_milestone_ids, false, "team + explicit unique_milestone_ids=false — override wins");
+    assertEq(result.git?.push_branches, true, "team + override — other team defaults still apply");
+  }
+
+  report();
+}
+
+main();

package/src/resources/extensions/gsd/tests/preferences-models.test.ts

@@ -1,5 +1,4 @@
 // GSD Extension — Model Preferences Parsing Tests
-// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
 
 import test from "node:test";
 import assert from "node:assert/strict";