gsd-pi 2.11.0 → 2.13.0

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

@@ -0,0 +1,234 @@
+/**
+ * git-self-heal.test.ts — Integration tests for git self-healing utilities.
+ *
+ * Uses real temporary git repos with deliberately broken state.
+ * No mocks — exercises actual git operations.
+ */
+
+import { execSync } from "node:child_process";
+import { existsSync, mkdtempSync, writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { rmSync } from "node:fs";
+import assert from "node:assert/strict";
+import {
+  abortAndReset,
+  withMergeHeal,
+  recoverCheckout,
+  formatGitError,
+  MergeConflictError,
+} from "../git-self-heal.js";
+
+// ─── Helpers ─────────────────────────────────────────────────────────
+
+function makeTempRepo(): string {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-self-heal-"));
+  execSync("git init", { cwd: dir, stdio: "pipe" });
+  execSync("git config user.email 'test@test.com'", { cwd: dir, stdio: "pipe" });
+  execSync("git config user.name 'Test'", { cwd: dir, stdio: "pipe" });
+  writeFileSync(join(dir, "README.md"), "# init\n");
+  execSync("git add -A && git commit -m 'init'", { cwd: dir, stdio: "pipe" });
+  return dir;
+}
+
+function cleanup(dir: string) {
+  try {
+    rmSync(dir, { recursive: true, force: true });
+  } catch {
+    // ignore
+  }
+}
+
+// ─── abortAndReset ───────────────────────────────────────────────────
+
+console.log("── abortAndReset ──");
+
+// Test: leftover MERGE_HEAD
+{
+  const dir = makeTempRepo();
+  try {
+    // Create a conflicting branch
+    execSync("git checkout -b feature", { cwd: dir, stdio: "pipe" });
+    writeFileSync(join(dir, "file.txt"), "feature content\n");
+    execSync("git add -A && git commit -m 'feature'", { cwd: dir, stdio: "pipe" });
+    execSync("git checkout master 2>/dev/null || git checkout main", { cwd: dir, stdio: "pipe" });
+    writeFileSync(join(dir, "file.txt"), "main content\n");
+    execSync("git add -A && git commit -m 'main change'", { cwd: dir, stdio: "pipe" });
+
+    // Create a merge conflict → MERGE_HEAD will exist
+    try {
+      execSync("git merge feature", { cwd: dir, stdio: "pipe" });
+    } catch {
+      // expected conflict
+    }
+
+    assert.ok(existsSync(join(dir, ".git", "MERGE_HEAD")), "MERGE_HEAD should exist before abort");
+
+    const result = abortAndReset(dir);
+    assert.ok(result.cleaned.some((s) => s.includes("aborted merge")), "should report aborted merge");
+    assert.ok(!existsSync(join(dir, ".git", "MERGE_HEAD")), "MERGE_HEAD should be gone after abort");
+
+    console.log("  ✓ cleans up leftover MERGE_HEAD");
+  } finally {
+    cleanup(dir);
+  }
+}
+
+// Test: leftover SQUASH_MSG (no MERGE_HEAD)
+{
+  const dir = makeTempRepo();
+  try {
+    // Manually create a SQUASH_MSG to simulate leftover state
+    writeFileSync(join(dir, ".git", "SQUASH_MSG"), "leftover squash message\n");
+
+    const result = abortAndReset(dir);
+    assert.ok(result.cleaned.some((s) => s.includes("SQUASH_MSG")), "should report SQUASH_MSG removal");
+    assert.ok(!existsSync(join(dir, ".git", "SQUASH_MSG")), "SQUASH_MSG should be gone");
+
+    console.log("  ✓ cleans up leftover SQUASH_MSG");
+  } finally {
+    cleanup(dir);
+  }
+}
+
+// Test: clean state (no-op)
+{
+  const dir = makeTempRepo();
+  try {
+    const result = abortAndReset(dir);
+    assert.deepStrictEqual(result.cleaned, [], "clean repo should produce empty cleaned array");
+
+    console.log("  ✓ no-op on clean state");
+  } finally {
+    cleanup(dir);
+  }
+}
+
+// ─── withMergeHeal ───────────────────────────────────────────────────
+
+console.log("── withMergeHeal ──");
+
+// Test: transient failure succeeds on retry
+{
+  const dir = makeTempRepo();
+  try {
+    let callCount = 0;
+    const result = withMergeHeal(dir, () => {
+      callCount++;
+      if (callCount === 1) throw new Error("transient git error");
+      return "success";
+    });
+
+    assert.strictEqual(result, "success", "should return mergeFn result on retry");
+    assert.strictEqual(callCount, 2, "should have called mergeFn twice");
+
+    console.log("  ✓ transient failure succeeds on retry");
+  } finally {
+    cleanup(dir);
+  }
+}
+
+// Test: real conflict escalates immediately (no retry)
+{
+  const dir = makeTempRepo();
+  try {
+    // Set up a real merge conflict
+    execSync("git checkout -b conflict-branch", { cwd: dir, stdio: "pipe" });
+    writeFileSync(join(dir, "conflict.txt"), "branch A\n");
+    execSync("git add -A && git commit -m 'branch A'", { cwd: dir, stdio: "pipe" });
+    execSync("git checkout master 2>/dev/null || git checkout main", { cwd: dir, stdio: "pipe" });
+    writeFileSync(join(dir, "conflict.txt"), "branch B\n");
+    execSync("git add -A && git commit -m 'branch B'", { cwd: dir, stdio: "pipe" });
+
+    let callCount = 0;
+    try {
+      withMergeHeal(dir, () => {
+        callCount++;
+        // Actually perform the conflicting merge
+        execSync("git merge conflict-branch", { cwd: dir, stdio: "pipe" });
+      });
+      assert.fail("should have thrown MergeConflictError");
+    } catch (err) {
+      assert.ok(err instanceof MergeConflictError, `should throw MergeConflictError, got ${(err as Error).constructor.name}`);
+      assert.strictEqual(callCount, 1, "should NOT retry on real conflict");
+    }
+
+    console.log("  ✓ real conflict escalates immediately without retry");
+  } finally {
+    cleanup(dir);
+  }
+}
+
+// ─── recoverCheckout ─────────────────────────────────────────────────
+
+console.log("── recoverCheckout ──");
+
+// Test: dirty index recovery
+{
+  const dir = makeTempRepo();
+  try {
+    // Create a branch to checkout to
+    execSync("git checkout -b target-branch", { cwd: dir, stdio: "pipe" });
+    execSync("git checkout master 2>/dev/null || git checkout main", { cwd: dir, stdio: "pipe" });
+
+    // Dirty the index
+    writeFileSync(join(dir, "README.md"), "dirty changes\n");
+    execSync("git add README.md", { cwd: dir, stdio: "pipe" });
+
+    // Normal checkout would complain about dirty index
+    recoverCheckout(dir, "target-branch");
+
+    const branch = execSync("git branch --show-current", { cwd: dir, encoding: "utf-8" }).trim();
+    assert.strictEqual(branch, "target-branch", "should be on target branch after recovery");
+
+    console.log("  ✓ recovers checkout with dirty index");
+  } finally {
+    cleanup(dir);
+  }
+}
+
+// Test: non-existent branch throws with context
+{
+  const dir = makeTempRepo();
+  try {
+    try {
+      recoverCheckout(dir, "nonexistent-branch");
+      assert.fail("should have thrown");
+    } catch (err) {
+      assert.ok((err as Error).message.includes("recoverCheckout failed"), "should include context in error");
+      assert.ok((err as Error).message.includes("nonexistent-branch"), "should mention branch name");
+    }
+
+    console.log("  ✓ throws with context for non-existent branch");
+  } finally {
+    cleanup(dir);
+  }
+}
+
+// ─── formatGitError ──────────────────────────────────────────────────
+
+console.log("── formatGitError ──");
+
+{
+  const cases: Array<{ input: string; shouldContain: string; label: string }> = [
+    { input: "CONFLICT (content): Merge conflict in file.ts", shouldContain: "/gsd doctor", label: "merge conflict" },
+    { input: "error: pathspec 'foo' did not match any file(s)", shouldContain: "/gsd doctor", label: "checkout failure" },
+    { input: "HEAD detached at abc123", shouldContain: "/gsd doctor", label: "detached HEAD" },
+    { input: "Unable to create '/path/.git/index.lock': File exists", shouldContain: "/gsd doctor", label: "lock file" },
+    { input: "fatal: not a git repository", shouldContain: "/gsd doctor", label: "not a repo" },
+    { input: "some unknown error", shouldContain: "/gsd doctor", label: "unknown error" },
+  ];
+
+  for (const { input, shouldContain, label } of cases) {
+    const result = formatGitError(input);
+    assert.ok(result.includes(shouldContain), `${label}: should suggest /gsd doctor`);
+    console.log(`  ✓ ${label} → suggests /gsd doctor`);
+  }
+
+  // Test with Error object
+  const result = formatGitError(new Error("CONFLICT in merge"));
+  assert.ok(result.includes("/gsd doctor"), "should handle Error objects");
+  console.log("  ✓ handles Error objects");
+}
+
+console.log("\n✅ All git-self-heal tests passed");

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

@@ -0,0 +1,107 @@
+/**
+ * isolation-resolver.test.ts -- Tests for shouldUseWorktreeIsolation resolver.
+ *
+ * Tests three resolution paths:
+ *  1. Explicit git.isolation preference overrides everything
+ *  2. Legacy detection: existing gsd/*\/* branches = branch mode
+ *  3. Default: new project = worktree mode
+ */
+
+import { mkdtempSync, writeFileSync, rmSync, realpathSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execSync } from "node:child_process";
+
+import { shouldUseWorktreeIsolation } from "../auto-worktree.ts";
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertEq, report } = createTestContext();
+
+function run(command: string, cwd: string): string {
+  return execSync(command, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
+}
+
+function createTempRepo(): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "iso-resolver-test-")));
+  run("git init", dir);
+  run("git config user.email test@test.com", dir);
+  run("git config user.name Test", dir);
+  writeFileSync(join(dir, "README.md"), "# test\n");
+  run("git add .", dir);
+  run("git commit -m init", dir);
+  run("git branch -M main", dir);
+  return dir;
+}
+
+async function main(): Promise<void> {
+  const savedCwd = process.cwd();
+
+  console.log("\n=== shouldUseWorktreeIsolation ===");
+
+  // Test 1: New project with no gsd branches → defaults to worktree (true)
+  {
+    const dir = createTempRepo();
+    try {
+      const result = shouldUseWorktreeIsolation(dir);
+      assertEq(result, true, "new project defaults to worktree isolation");
+    } finally {
+      process.chdir(savedCwd);
+      rmSync(dir, { recursive: true, force: true });
+    }
+  }
+
+  // Test 2: Legacy project with gsd/*/* branches → returns false (branch mode)
+  {
+    const dir = createTempRepo();
+    try {
+      // Create a legacy gsd/*/* branch
+      run("git checkout -b gsd/M001/S01", dir);
+      writeFileSync(join(dir, "slice.md"), "# S01\n");
+      run("git add .", dir);
+      run("git commit -m 'slice work'", dir);
+      run("git checkout main", dir);
+
+      const result = shouldUseWorktreeIsolation(dir);
+      assertEq(result, false, "legacy project with gsd branches → branch mode");
+    } finally {
+      process.chdir(savedCwd);
+      rmSync(dir, { recursive: true, force: true });
+    }
+  }
+
+  // Test 3: Explicit preference override -- isolation: "worktree"
+  {
+    const dir = createTempRepo();
+    try {
+      // Create legacy branches that would normally trigger branch mode
+      run("git checkout -b gsd/M001/S01", dir);
+      writeFileSync(join(dir, "slice.md"), "# S01\n");
+      run("git add .", dir);
+      run("git commit -m 'slice work'", dir);
+      run("git checkout main", dir);
+
+      const result = shouldUseWorktreeIsolation(dir, { isolation: "worktree" });
+      assertEq(result, true, "explicit isolation: worktree overrides legacy detection");
+    } finally {
+      process.chdir(savedCwd);
+      rmSync(dir, { recursive: true, force: true });
+    }
+  }
+
+  // Test 4: Explicit preference override -- isolation: "branch"
+  {
+    const dir = createTempRepo();
+    try {
+      // No legacy branches -- would normally default to worktree
+      const result = shouldUseWorktreeIsolation(dir, { isolation: "branch" });
+      assertEq(result, false, "explicit isolation: branch overrides default");
+    } finally {
+      process.chdir(savedCwd);
+      rmSync(dir, { recursive: true, force: true });
+    }
+  }
+
+  report();
+}
+
+main();

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

@@ -0,0 +1,297 @@
+// 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";
+import { tmpdir } from "node:os";
+import { createTestContext } from "./test-helpers.ts";
+import {
+  checkPostUnitHooks,
+  getActiveHook,
+  resetHookState,
+  isRetryPending,
+  consumeRetryTrigger,
+  resolveHookArtifactPath,
+  runPreDispatchHooks,
+  persistHookState,
+  restoreHookState,
+  clearPersistedHookState,
+  getHookStatus,
+  formatHookStatus,
+} from "../post-unit-hooks.ts";
+
+const { assertEq, assertTrue, assertMatch, report } = createTestContext();
+
+// ─── Fixture Helpers ───────────────────────────────────────────────────────
+
+function createFixtureBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-hook-test-"));
+  mkdirSync(join(base, ".gsd", "M001", "slices", "S01", "tasks"), { recursive: true });
+  return base;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Phase 1: Post-Unit Hook Tests
+// ═══════════════════════════════════════════════════════════════════════════
+
+// ─── resolveHookArtifactPath ───────────────────────────────────────────────
+
+console.log("\n=== resolveHookArtifactPath ===");
+
+{
+  const base = "/project";
+
+  // Task-level
+  const taskPath = resolveHookArtifactPath(base, "M001/S01/T01", "REVIEW-PASS.md");
+  assertEq(
+    taskPath,
+    join(base, ".gsd", "M001", "slices", "S01", "tasks", "T01-REVIEW-PASS.md"),
+    "task-level artifact path",
+  );
+
+  // Slice-level
+  const slicePath = resolveHookArtifactPath(base, "M001/S01", "REVIEW-PASS.md");
+  assertEq(
+    slicePath,
+    join(base, ".gsd", "M001", "slices", "S01", "REVIEW-PASS.md"),
+    "slice-level artifact path",
+  );
+
+  // Milestone-level
+  const milestonePath = resolveHookArtifactPath(base, "M001", "REVIEW-PASS.md");
+  assertEq(
+    milestonePath,
+    join(base, ".gsd", "M001", "REVIEW-PASS.md"),
+    "milestone-level artifact path",
+  );
+}
+
+// ─── resetHookState ────────────────────────────────────────────────────────
+
+console.log("\n=== resetHookState ===");
+
+{
+  resetHookState();
+  assertEq(getActiveHook(), null, "no active hook after reset");
+  assertTrue(!isRetryPending(), "no retry pending after reset");
+  assertEq(consumeRetryTrigger(), null, "no retry trigger after reset");
+}
+
+// ─── checkPostUnitHooks with no hooks configured ───────────────────────────
+
+console.log("\n=== No hooks configured ===");
+
+{
+  resetHookState();
+  const base = createFixtureBase();
+  try {
+    const result = checkPostUnitHooks("execute-task", "M001/S01/T01", base);
+    assertEq(result, null, "returns null when no hooks configured");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+}
+
+// ─── Hook units don't trigger hooks (no hook-on-hook) ──────────────────────
+
+console.log("\n=== Hook-on-hook prevention ===");
+
+{
+  resetHookState();
+  const base = createFixtureBase();
+  try {
+    const result = checkPostUnitHooks("hook/code-review", "M001/S01/T01", base);
+    assertEq(result, null, "hook units don't trigger other hooks");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+}
+
+// ─── consumeRetryTrigger clears state ──────────────────────────────────────
+
+console.log("\n=== consumeRetryTrigger clears state ===");
+
+{
+  resetHookState();
+  assertEq(consumeRetryTrigger(), null, "no trigger initially");
+  assertTrue(!isRetryPending(), "no retry initially");
+}
+
+// ─── Variable substitution in prompts ──────────────────────────────────────
+
+console.log("\n=== Variable substitution ===");
+
+{
+  const base = "/project";
+
+  // 3-part ID
+  const path3 = resolveHookArtifactPath(base, "M002/S03/T05", "result.md");
+  assertTrue(path3.includes("M002"), "3-part ID extracts milestoneId");
+  assertTrue(path3.includes("S03"), "3-part ID extracts sliceId");
+  assertTrue(path3.includes("T05"), "3-part ID extracts taskId");
+
+  // 2-part ID
+  const path2 = resolveHookArtifactPath(base, "M002/S03", "result.md");
+  assertTrue(path2.includes("M002"), "2-part ID extracts milestoneId");
+  assertTrue(path2.includes("S03"), "2-part ID extracts sliceId");
+
+  // 1-part ID
+  const path1 = resolveHookArtifactPath(base, "M002", "result.md");
+  assertTrue(path1.includes("M002"), "1-part ID extracts milestoneId");
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Phase 2: Pre-Dispatch Hook Tests
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log("\n=== Pre-dispatch: no hooks configured ===");
+
+{
+  const base = createFixtureBase();
+  try {
+    const result = runPreDispatchHooks("execute-task", "M001/S01/T01", "original prompt", base);
+    assertEq(result.action, "proceed", "proceeds when no hooks");
+    assertEq(result.prompt, "original prompt", "prompt unchanged");
+    assertEq(result.firedHooks.length, 0, "no hooks fired");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+}
+
+console.log("\n=== Pre-dispatch: hook units bypass ===");
+
+{
+  const base = createFixtureBase();
+  try {
+    const result = runPreDispatchHooks("hook/review", "M001/S01/T01", "hook prompt", base);
+    assertEq(result.action, "proceed", "hook units always proceed");
+    assertEq(result.prompt, "hook prompt", "hook prompt unchanged");
+    assertEq(result.firedHooks.length, 0, "no hooks fired for hook units");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Phase 3: State Persistence Tests
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log("\n=== State persistence: persist and restore ===");
+
+{
+  const base = createFixtureBase();
+  try {
+    resetHookState();
+
+    // Persist empty state
+    persistHookState(base);
+    const filePath = join(base, ".gsd", "hook-state.json");
+    assertTrue(existsSync(filePath), "hook-state.json created");
+
+    const content = JSON.parse(readFileSync(filePath, "utf-8"));
+    assertEq(typeof content.savedAt, "string", "savedAt is a string");
+    assertEq(Object.keys(content.cycleCounts).length, 0, "empty cycle counts");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+}
+
+console.log("\n=== State persistence: restore from disk ===");
+
+{
+  const base = createFixtureBase();
+  try {
+    resetHookState();
+
+    // Write a state file with some cycle counts
+    const stateFile = join(base, ".gsd", "hook-state.json");
+    writeFileSync(stateFile, JSON.stringify({
+      cycleCounts: {
+        "review/execute-task/M001/S01/T01": 2,
+        "simplify/execute-task/M001/S01/T02": 1,
+      },
+      savedAt: new Date().toISOString(),
+    }), "utf-8");
+
+    // Restore
+    restoreHookState(base);
+
+    // Verify by persisting and reading back
+    persistHookState(base);
+    const restored = JSON.parse(readFileSync(stateFile, "utf-8"));
+    assertEq(restored.cycleCounts["review/execute-task/M001/S01/T01"], 2, "cycle count restored for review");
+    assertEq(restored.cycleCounts["simplify/execute-task/M001/S01/T02"], 1, "cycle count restored for simplify");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+}
+
+console.log("\n=== State persistence: clear ===");
+
+{
+  const base = createFixtureBase();
+  try {
+    resetHookState();
+
+    // Write then clear
+    const stateFile = join(base, ".gsd", "hook-state.json");
+    writeFileSync(stateFile, JSON.stringify({
+      cycleCounts: { "review/execute-task/M001/S01/T01": 3 },
+      savedAt: new Date().toISOString(),
+    }), "utf-8");
+
+    clearPersistedHookState(base);
+
+    const cleared = JSON.parse(readFileSync(stateFile, "utf-8"));
+    assertEq(Object.keys(cleared.cycleCounts).length, 0, "cycle counts cleared");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+}
+
+console.log("\n=== State persistence: restore handles missing file ===");
+
+{
+  const base = createFixtureBase();
+  try {
+    resetHookState();
+    // Should not throw
+    restoreHookState(base);
+    assertEq(getActiveHook(), null, "no active hook after restore from missing file");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+}
+
+console.log("\n=== State persistence: restore handles corrupt file ===");
+
+{
+  const base = createFixtureBase();
+  try {
+    resetHookState();
+    writeFileSync(join(base, ".gsd", "hook-state.json"), "not json", "utf-8");
+    // Should not throw
+    restoreHookState(base);
+    assertEq(getActiveHook(), null, "no active hook after corrupt restore");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Phase 3: Hook Status Reporting Tests
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log("\n=== Hook status: no hooks ===");
+
+{
+  resetHookState();
+  const entries = getHookStatus();
+  // No preferences file = no hooks
+  assertEq(entries.length, 0, "no entries when no hooks configured");
+
+  const formatted = formatHookStatus();
+  assertMatch(formatted, /No hooks configured/, "status message says no hooks");
+}
+
+report();