gsd-pi 2.28.0 → 2.29.0-dev.2ccf3fb

package/src/resources/extensions/gsd/tests/network-error-fallback.test.ts

@@ -1,104 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-
-// Instead of trying to mock out the entire `index.ts` extension initialization which touches
-// the disk and parses files, we test the logic via the standard test methods, or we can
-// just test that `resolveModelWithFallbacksForUnit` returns the correct format since
-// the fallback rotation logic itself was verified manually.
-
-import { getNextFallbackModel, isTransientNetworkError } from "../preferences.ts";
-
-test("getNextFallbackModel selects next fallback if current is a fallback", () => {
-    const modelConfig = { primary: "model-a", fallbacks: ["model-b", "model-c"] };
-    const currentModelId = "model-b";
-
-    const nextModelId = getNextFallbackModel(currentModelId, modelConfig);
-
-    assert.equal(nextModelId, "model-c", "should select next model after current fallback");
-});
-
-test("getNextFallbackModel returns undefined if fallbacks exhausted", () => {
-    const modelConfig = { primary: "model-a", fallbacks: ["model-b", "model-c"] };
-    const currentModelId = "model-c";
-
-    const nextModelId = getNextFallbackModel(currentModelId, modelConfig);
-
-    assert.equal(nextModelId, undefined, "should return undefined when exhausted");
-});
-
-test("getNextFallbackModel finds current model when formatted with provider", () => {
-    const modelConfig = { primary: "p/model-a", fallbacks: ["p/model-b"] };
-    const currentModelId = "model-a"; // context model doesn't always have provider in ID
-
-    const nextModelId = getNextFallbackModel(currentModelId, modelConfig);
-
-    assert.equal(nextModelId, "p/model-b", "should select next model after current with provider format");
-});
-
-test("getNextFallbackModel returns primary if current model is not in the list", () => {
-    const modelConfig = { primary: "model-a", fallbacks: ["model-b", "model-c"] };
-    const currentModelId = "model-x"; // completely different model manually selected
-
-    const nextModelId = getNextFallbackModel(currentModelId, modelConfig);
-
-    assert.equal(nextModelId, "model-a", "should default to primary if current is unknown");
-});
-
-test("getNextFallbackModel returns primary if current model is undefined", () => {
-    const modelConfig = { primary: "model-a", fallbacks: ["model-b", "model-c"] };
-    const currentModelId = undefined;
-
-    const nextModelId = getNextFallbackModel(currentModelId, modelConfig);
-
-    assert.equal(nextModelId, "model-a", "should default to primary if current is undefined");
-});
-
-// ── isTransientNetworkError tests ────────────────────────────────────────────
-
-test("isTransientNetworkError detects ECONNRESET", () => {
-    assert.ok(isTransientNetworkError("fetch failed: ECONNRESET"));
-});
-
-test("isTransientNetworkError detects ETIMEDOUT", () => {
-    assert.ok(isTransientNetworkError("ETIMEDOUT: request timed out"));
-});
-
-test("isTransientNetworkError detects generic network error", () => {
-    assert.ok(isTransientNetworkError("network error"));
-});
-
-test("isTransientNetworkError detects socket hang up", () => {
-    assert.ok(isTransientNetworkError("socket hang up"));
-});
-
-test("isTransientNetworkError detects fetch failed", () => {
-    assert.ok(isTransientNetworkError("fetch failed"));
-});
-
-test("isTransientNetworkError detects connection reset", () => {
-    assert.ok(isTransientNetworkError("connection was reset by peer"));
-});
-
-test("isTransientNetworkError detects DNS errors", () => {
-    assert.ok(isTransientNetworkError("dns resolution failed"));
-});
-
-test("isTransientNetworkError rejects auth errors", () => {
-    assert.ok(!isTransientNetworkError("unauthorized: invalid API key"));
-});
-
-test("isTransientNetworkError rejects quota errors", () => {
-    assert.ok(!isTransientNetworkError("quota exceeded"));
-});
-
-test("isTransientNetworkError rejects billing errors", () => {
-    assert.ok(!isTransientNetworkError("billing issue: network payment required"));
-});
-
-test("isTransientNetworkError rejects empty string", () => {
-    assert.ok(!isTransientNetworkError(""));
-});
-
-test("isTransientNetworkError rejects non-network errors", () => {
-    assert.ok(!isTransientNetworkError("model not found"));
-});

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

@@ -1,120 +0,0 @@
-// GSD Git Preferences Tests — validates git.isolation and git.merge_to_main handling
-
-import { createTestContext } from "./test-helpers.ts";
-import { validatePreferences, getIsolationMode } from "../preferences.ts";
-
-const { assertEq, assertTrue, report } = createTestContext();
-
-async function main(): Promise<void> {
-  console.log("\n=== git.isolation ===");
-
-  // Valid values are accepted without warnings
-  {
-    const { preferences, warnings, errors } = validatePreferences({ git: { isolation: "worktree" } });
-    assertEq(errors.length, 0, "isolation: worktree — no errors");
-    assertEq(warnings.length, 0, "isolation: worktree — no warnings");
-    assertEq(preferences.git?.isolation, "worktree", "isolation: worktree — value preserved");
-  }
-  {
-    const { preferences, warnings, errors } = validatePreferences({ git: { isolation: "branch" } });
-    assertEq(errors.length, 0, "isolation: branch — no errors");
-    assertEq(warnings.length, 0, "isolation: branch — no warnings");
-    assertEq(preferences.git?.isolation, "branch", "isolation: branch — value preserved");
-  }
-  {
-    const { preferences, warnings, errors } = validatePreferences({ git: { isolation: "none" } });
-    assertEq(errors.length, 0, "isolation: none — no errors");
-    assertEq(warnings.length, 0, "isolation: none — no warnings");
-    assertEq(preferences.git?.isolation, "none", "isolation: none — value preserved");
-  }
-
-  // Invalid values produce errors
-  {
-    const { errors } = validatePreferences({ git: { isolation: "invalid" as any } });
-    assertTrue(errors.length > 0, "isolation: invalid — produces error");
-    assertTrue(errors[0].includes("worktree, branch, none"), "isolation: invalid — error mentions valid values");
-  }
-
-  // Undefined passes through without warning
-  {
-    const { preferences, warnings } = validatePreferences({ git: { auto_push: true } });
-    assertEq(warnings.length, 0, "isolation: undefined — no warnings");
-    assertEq(preferences.git?.isolation, undefined, "isolation: undefined — not set");
-  }
-
-  console.log("\n=== git.merge_to_main deprecated ===");
-
-  // Any value produces a deprecation warning
-  {
-    const { warnings } = validatePreferences({ git: { merge_to_main: "milestone" } as any });
-    assertTrue(warnings.length > 0, "merge_to_main: milestone — produces deprecation warning");
-    assertTrue(warnings[0].includes("deprecated"), "merge_to_main: milestone — warning mentions deprecated");
-  }
-  {
-    const { warnings } = validatePreferences({ git: { merge_to_main: "slice" } as any });
-    assertTrue(warnings.length > 0, "merge_to_main: slice — produces deprecation warning");
-    assertTrue(warnings[0].includes("deprecated"), "merge_to_main: slice — warning mentions deprecated");
-  }
-
-  // Undefined passes through without warning
-  {
-    const { preferences, warnings } = validatePreferences({ git: { auto_push: true } });
-    assertEq(warnings.length, 0, "merge_to_main: undefined — no warnings");
-    assertEq((preferences.git as any)?.merge_to_main, undefined, "merge_to_main: undefined — not set");
-  }
-
-  console.log("\n=== isolation + deprecated merge_to_main together ===");
-  {
-    const { warnings, errors } = validatePreferences({
-      git: { isolation: "branch", merge_to_main: "slice" } as any,
-    });
-    assertEq(errors.length, 0, "branch isolation + deprecated merge_to_main — no errors");
-    assertEq(warnings.length, 1, "branch isolation + deprecated merge_to_main — 1 warning (merge_to_main only)");
-    assertTrue(warnings[0].includes("merge_to_main"), "warning mentions merge_to_main");
-  }
-
-  console.log("\n=== git.commit_docs ===");
-
-  // Valid boolean values accepted
-  {
-    const { preferences, errors } = validatePreferences({ git: { commit_docs: false } });
-    assertEq(errors.length, 0, "commit_docs: false — no errors");
-    assertEq(preferences.git?.commit_docs, false, "commit_docs: false — value preserved");
-  }
-  {
-    const { preferences, errors } = validatePreferences({ git: { commit_docs: true } });
-    assertEq(errors.length, 0, "commit_docs: true — no errors");
-    assertEq(preferences.git?.commit_docs, true, "commit_docs: true — value preserved");
-  }
-
-  // Invalid type produces error
-  {
-    const { errors } = validatePreferences({ git: { commit_docs: "no" as any } });
-    assertTrue(errors.length > 0, "commit_docs: string — produces error");
-    assertTrue(errors[0].includes("commit_docs"), "commit_docs: string — error mentions commit_docs");
-  }
-
-  // Undefined passes through without issue
-  {
-    const { preferences, errors } = validatePreferences({ git: { auto_push: true } });
-    assertEq(errors.length, 0, "commit_docs: undefined — no errors");
-    assertEq(preferences.git?.commit_docs, undefined, "commit_docs: undefined — not set");
-  }
-
-  console.log("\n=== getIsolationMode() ===");
-
-  // Returns "none" when set to "none"
-  // Note: getIsolationMode() reads from disk via loadEffectiveGSDPreferences,
-  // so we test it indirectly by verifying the function is exported and callable.
-  // The validation tests above prove the preference value is stored correctly.
-  // Direct mode tests require mocking the filesystem, so we test the function's
-  // default return value (no preferences file in test context).
-  {
-    const mode = getIsolationMode();
-    assertEq(mode, "worktree", "getIsolationMode: returns worktree as default when no prefs file");
-  }
-
-  report();
-}
-
-main();

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

@@ -1,226 +0,0 @@
-// GSD Extension — Hook Preferences Parsing Tests (Post-Unit + Pre-Dispatch)
-
-import { createTestContext } from "./test-helpers.ts";
-import type { PreDispatchHookConfig } from "../types.ts";
-
-const { assertEq, assertTrue, report } = createTestContext();
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Phase 1: Post-Unit Hook Config Tests
-// ═══════════════════════════════════════════════════════════════════════════
-
-console.log("\n=== Post-unit hook config validation ===");
-
-{
-  const validHook = {
-    name: "test-hook",
-    after: ["execute-task"],
-    prompt: "Test prompt",
-    max_cycles: 2,
-    model: "claude-sonnet-4-6",
-    artifact: "TEST-RESULT.md",
-    retry_on: "TEST-ISSUES.md",
-    enabled: true,
-  };
-
-  assertEq(validHook.name, "test-hook", "valid hook has name");
-  assertEq(validHook.after.length, 1, "valid hook has one after entry");
-  assertEq(validHook.after[0], "execute-task", "valid hook triggers after execute-task");
-  assertTrue(validHook.max_cycles! <= 10, "max_cycles within limit");
-  assertTrue(validHook.max_cycles! >= 1, "max_cycles above minimum");
-}
-
-console.log("\n=== max_cycles clamping ===");
-
-{
-  const clampedHigh = Math.max(1, Math.min(10, Math.round(15)));
-  assertEq(clampedHigh, 10, "max_cycles above 10 clamped to 10");
-
-  const clampedLow = Math.max(1, Math.min(10, Math.round(0)));
-  assertEq(clampedLow, 1, "max_cycles below 1 clamped to 1");
-
-  const clampedNeg = Math.max(1, Math.min(10, Math.round(-5)));
-  assertEq(clampedNeg, 1, "negative max_cycles clamped to 1");
-
-  const normal = Math.max(1, Math.min(10, Math.round(3)));
-  assertEq(normal, 3, "normal max_cycles passes through");
-}
-
-console.log("\n=== Post-unit hook merging ===");
-
-{
-  const baseHooks = [
-    { name: "review", after: ["execute-task"], prompt: "base prompt" },
-    { name: "lint", after: ["plan-slice"], prompt: "lint code" },
-  ];
-
-  const overrideHooks = [
-    { name: "review", after: ["execute-task", "complete-slice"], prompt: "override prompt" },
-    { name: "security", after: ["execute-task"], prompt: "security check" },
-  ];
-
-  const merged = [...baseHooks];
-  for (const hook of overrideHooks) {
-    const idx = merged.findIndex(h => h.name === hook.name);
-    if (idx >= 0) {
-      merged[idx] = hook;
-    } else {
-      merged.push(hook);
-    }
-  }
-
-  assertEq(merged.length, 3, "merged has 3 hooks");
-  assertEq(merged[0].prompt, "override prompt", "review hook was overridden");
-  assertEq(merged[0].after.length, 2, "overridden review has 2 after entries");
-  assertEq(merged[1].name, "lint", "lint kept from base");
-  assertEq(merged[2].name, "security", "security added from override");
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Phase 2: Pre-Dispatch Hook Config Tests
-// ═══════════════════════════════════════════════════════════════════════════
-
-console.log("\n=== Pre-dispatch hook config shape ===");
-
-{
-  const modifyHook = {
-    name: "inject-context",
-    before: ["execute-task"],
-    action: "modify" as const,
-    prepend: "Remember to follow coding conventions.",
-    append: "Run tests after making changes.",
-    enabled: true,
-  };
-
-  assertEq(modifyHook.name, "inject-context", "modify hook has name");
-  assertEq(modifyHook.action, "modify", "action is modify");
-  assertTrue(!!modifyHook.prepend, "has prepend text");
-  assertTrue(!!modifyHook.append, "has append text");
-}
-
-{
-  const skipHook = {
-    name: "skip-research",
-    before: ["research-slice"],
-    action: "skip" as const,
-    skip_if: "RESEARCH-DONE.md",
-    enabled: true,
-  };
-
-  assertEq(skipHook.action, "skip", "action is skip");
-  assertEq(skipHook.skip_if, "RESEARCH-DONE.md", "has skip condition");
-}
-
-{
-  const replaceHook = {
-    name: "custom-planning",
-    before: ["plan-slice"],
-    action: "replace" as const,
-    prompt: "Use custom planning approach for {sliceId}",
-    unit_type: "custom-plan",
-    model: "claude-opus-4-6",
-    enabled: true,
-  };
-
-  assertEq(replaceHook.action, "replace", "action is replace");
-  assertTrue(!!replaceHook.prompt, "replace hook has prompt");
-  assertEq(replaceHook.unit_type, "custom-plan", "has unit_type override");
-}
-
-console.log("\n=== Pre-dispatch action validation ===");
-
-{
-  const validActions = new Set(["modify", "skip", "replace"]);
-  assertTrue(validActions.has("modify"), "modify is valid");
-  assertTrue(validActions.has("skip"), "skip is valid");
-  assertTrue(validActions.has("replace"), "replace is valid");
-  assertTrue(!validActions.has("delete"), "delete is not valid");
-  assertTrue(!validActions.has(""), "empty string is not valid");
-}
-
-console.log("\n=== Pre-dispatch hook merging ===");
-
-{
-  const baseHooks: PreDispatchHookConfig[] = [
-    { name: "inject", before: ["execute-task"], action: "modify", prepend: "base" },
-  ];
-
-  const overrideHooks: PreDispatchHookConfig[] = [
-    { name: "inject", before: ["execute-task"], action: "modify", prepend: "override" },
-    { name: "gate", before: ["plan-slice"], action: "skip" },
-  ];
-
-  const merged: PreDispatchHookConfig[] = [...baseHooks];
-  for (const hook of overrideHooks) {
-    const idx = merged.findIndex(h => h.name === hook.name);
-    if (idx >= 0) {
-      merged[idx] = hook;
-    } else {
-      merged.push(hook);
-    }
-  }
-
-  assertEq(merged.length, 2, "merged has 2 pre-dispatch hooks");
-  assertEq(merged[0].prepend, "override", "inject hook overridden");
-  assertEq(merged[1].name, "gate", "gate hook added");
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Known unit types validation
-// ═══════════════════════════════════════════════════════════════════════════
-
-console.log("\n=== Known unit types ===");
-
-{
-  const knownUnitTypes = new Set([
-    "research-milestone", "plan-milestone", "research-slice", "plan-slice",
-    "execute-task", "complete-slice", "replan-slice", "reassess-roadmap",
-    "run-uat", "fix-merge", "complete-milestone",
-  ]);
-
-  assertTrue(knownUnitTypes.has("execute-task"), "execute-task is known");
-  assertTrue(knownUnitTypes.has("complete-slice"), "complete-slice is known");
-  assertTrue(knownUnitTypes.has("plan-slice"), "plan-slice is known");
-  assertTrue(!knownUnitTypes.has("hook/review"), "hook types are not in known set");
-  assertTrue(!knownUnitTypes.has("invalid-type"), "invalid types are not in known set");
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Preferences YAML format verification
-// ═══════════════════════════════════════════════════════════════════════════
-
-console.log("\n=== Preferences YAML format ===");
-
-{
-  const prefsContent = [
-    "---",
-    "version: 1",
-    "post_unit_hooks:",
-    "  - name: code-review",
-    "    after:",
-    "      - execute-task",
-    "    prompt: Review the changes",
-    "    max_cycles: 3",
-    "    artifact: REVIEW-PASS.md",
-    "    retry_on: REVIEW-ISSUES.md",
-    "pre_dispatch_hooks:",
-    "  - name: inject-conventions",
-    "    before:",
-    "      - execute-task",
-    "    action: modify",
-    "    append: Follow project coding conventions",
-    "  - name: custom-research",
-    "    before:",
-    "      - research-slice",
-    "    action: replace",
-    "    prompt: Custom research prompt",
-    "---",
-  ].join("\n");
-
-  assertTrue(prefsContent.includes("post_unit_hooks:"), "has post_unit_hooks key");
-  assertTrue(prefsContent.includes("pre_dispatch_hooks:"), "has pre_dispatch_hooks key");
-  assertTrue(prefsContent.includes("action: modify"), "has modify action");
-  assertTrue(prefsContent.includes("action: replace"), "has replace action");
-}
-
-report();

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

@@ -1,110 +0,0 @@
-// 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();