gsd-pi 2.33.1-dev.235d83a → 2.33.1-dev.29a8268

package/dist/resources/extensions/gsd/tests/validate-directory.test.ts

@@ -0,0 +1,222 @@
+/**
+ * Unit tests for GSD Directory Validation — safeguards against dangerous directories.
+ *
+ * Exercises validateDirectory() and assertSafeDirectory() with:
+ * - Blocked system paths (/, /usr, /etc, $HOME, C:\Windows)
+ * - Temp directory root
+ * - Normal project directories (should pass)
+ * - Directories with many entries (warning heuristic)
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir, homedir, platform } from "node:os";
+import { validateDirectory, assertSafeDirectory } from "../validate-directory.ts";
+
+const isWindows = platform() === "win32";
+
+function makeTempDir(prefix: string): string {
+  const dir = join(
+    tmpdir(),
+    `gsd-validate-test-${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+  );
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+// ─── Blocked system paths (Unix) ─────────────────────────────────────────────────
+
+test("validateDirectory: root filesystem is blocked", { skip: isWindows ? "Unix-only test" : undefined }, () => {
+  const result = validateDirectory("/");
+  assert.equal(result.safe, false);
+  assert.equal(result.severity, "blocked");
+  assert.ok(result.reason?.includes("system directory"));
+});
+
+test("validateDirectory: /usr is blocked", { skip: isWindows ? "Unix-only test" : undefined }, () => {
+  const result = validateDirectory("/usr");
+  assert.equal(result.safe, false);
+  assert.equal(result.severity, "blocked");
+});
+
+test("validateDirectory: /etc is blocked", { skip: isWindows ? "Unix-only test" : undefined }, () => {
+  const result = validateDirectory("/etc");
+  assert.equal(result.safe, false);
+  assert.equal(result.severity, "blocked");
+});
+
+test("validateDirectory: /var is blocked", { skip: isWindows ? "Unix-only test" : undefined }, () => {
+  const result = validateDirectory("/var");
+  assert.equal(result.safe, false);
+  assert.equal(result.severity, "blocked");
+});
+
+test("validateDirectory: /usr/local/bin is blocked", { skip: isWindows ? "Unix-only test" : undefined }, () => {
+  const result = validateDirectory("/usr/local/bin");
+  assert.equal(result.safe, false);
+  assert.equal(result.severity, "blocked");
+});
+
+// ─── Blocked system paths (Windows) ──────────────────────────────────────────────
+
+test("validateDirectory: C:\\ is blocked", { skip: !isWindows ? "Windows-only test" : undefined }, () => {
+  const result = validateDirectory("C:\\");
+  assert.equal(result.safe, false);
+  assert.equal(result.severity, "blocked");
+  assert.ok(result.reason?.includes("system directory"));
+});
+
+test("validateDirectory: C:\\Windows is blocked", { skip: !isWindows ? "Windows-only test" : undefined }, () => {
+  const result = validateDirectory("C:\\Windows");
+  assert.equal(result.safe, false);
+  assert.equal(result.severity, "blocked");
+});
+
+// ─── Home directory (cross-platform) ─────────────────────────────────────────────
+
+test("validateDirectory: home directory itself is blocked", () => {
+  const result = validateDirectory(homedir());
+  assert.equal(result.safe, false);
+  assert.equal(result.severity, "blocked");
+  assert.ok(result.reason?.includes("home directory"));
+});
+
+test("validateDirectory: home directory with trailing slash is blocked", () => {
+  const sep = isWindows ? "\\" : "/";
+  const result = validateDirectory(homedir() + sep);
+  assert.equal(result.safe, false);
+  assert.equal(result.severity, "blocked");
+});
+
+test("validateDirectory: subdirectory of home is NOT blocked", () => {
+  const dir = makeTempDir("home-subdir");
+  try {
+    const result = validateDirectory(dir);
+    assert.equal(result.severity, "ok");
+    assert.equal(result.safe, true);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+// ─── Temp directory root ─────────────────────────────────────────────────────────
+
+test("validateDirectory: temp directory root is blocked", () => {
+  const result = validateDirectory(tmpdir());
+  assert.equal(result.safe, false);
+  assert.equal(result.severity, "blocked");
+  assert.ok(result.reason?.includes("temp directory"));
+});
+
+// ─── Normal project directories ──────────────────────────────────────────────────
+
+test("validateDirectory: normal project directory is safe", () => {
+  const dir = makeTempDir("normal-project");
+  try {
+    writeFileSync(join(dir, "package.json"), "{}");
+    mkdirSync(join(dir, "src"));
+    const result = validateDirectory(dir);
+    assert.equal(result.safe, true);
+    assert.equal(result.severity, "ok");
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("validateDirectory: empty directory is safe", () => {
+  const dir = makeTempDir("empty");
+  try {
+    const result = validateDirectory(dir);
+    assert.equal(result.safe, true);
+    assert.equal(result.severity, "ok");
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+// ─── High entry count heuristic ──────────────────────────────────────────────────
+
+test("validateDirectory: directory with >200 entries triggers warning", () => {
+  const dir = makeTempDir("many-entries");
+  try {
+    for (let i = 0; i < 210; i++) {
+      writeFileSync(join(dir, `file-${i.toString().padStart(4, "0")}.txt`), "");
+    }
+    const result = validateDirectory(dir);
+    assert.equal(result.safe, false);
+    assert.equal(result.severity, "warning");
+    assert.ok(result.reason?.includes("210 entries"));
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("validateDirectory: directory with exactly 200 entries is safe", () => {
+  const dir = makeTempDir("boundary-entries");
+  try {
+    for (let i = 0; i < 200; i++) {
+      writeFileSync(join(dir, `file-${i.toString().padStart(4, "0")}.txt`), "");
+    }
+    const result = validateDirectory(dir);
+    assert.equal(result.safe, true);
+    assert.equal(result.severity, "ok");
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+// ─── assertSafeDirectory ─────────────────────────────────────────────────────────
+
+test("assertSafeDirectory: throws for blocked directories", { skip: isWindows ? "Unix-only test" : undefined }, () => {
+  assert.throws(
+    () => assertSafeDirectory("/"),
+    (err: Error) => err.message.includes("system directory"),
+  );
+});
+
+test("assertSafeDirectory: throws for home directory", () => {
+  assert.throws(
+    () => assertSafeDirectory(homedir()),
+    (err: Error) => err.message.includes("home directory"),
+  );
+});
+
+test("assertSafeDirectory: returns result for warnings (does not throw)", () => {
+  const dir = makeTempDir("assert-warning");
+  try {
+    for (let i = 0; i < 210; i++) {
+      writeFileSync(join(dir, `file-${i.toString().padStart(4, "0")}.txt`), "");
+    }
+    const result = assertSafeDirectory(dir);
+    assert.equal(result.severity, "warning");
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("assertSafeDirectory: returns ok for safe directories", () => {
+  const dir = makeTempDir("assert-safe");
+  try {
+    const result = assertSafeDirectory(dir);
+    assert.equal(result.severity, "ok");
+    assert.equal(result.safe, true);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+// ─── Trailing slash normalization ────────────────────────────────────────────────
+
+test("validateDirectory: handles paths with trailing slashes", { skip: isWindows ? "Unix-only test" : undefined }, () => {
+  const result = validateDirectory("/usr/");
+  assert.equal(result.safe, false);
+  assert.equal(result.severity, "blocked");
+});
+
+test("validateDirectory: handles paths with multiple trailing slashes", { skip: isWindows ? "Unix-only test" : undefined }, () => {
+  const result = validateDirectory("/etc///");
+  assert.equal(result.safe, false);
+  assert.equal(result.severity, "blocked");
+});

package/dist/resources/extensions/gsd/tests/validate-milestone.test.ts

@@ -0,0 +1,375 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, writeFileSync, existsSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { randomUUID } from "node:crypto";
+
+import { deriveState, isValidationTerminal } from "../state.ts";
+import { resolveExpectedArtifactPath, verifyExpectedArtifact, diagnoseExpectedArtifact, buildLoopRemediationSteps } from "../auto-recovery.ts";
+import { resolveDispatch, type DispatchContext } from "../auto-dispatch.ts";
+import type { GSDState } from "../types.ts";
+import { clearPathCache } from "../paths.ts";
+import { clearParseCache } from "../files.ts";
+
+// ─── Helpers ──────────────────────────────────────────────────────────────
+
+function makeTmpBase(): string {
+  const base = join(tmpdir(), `gsd-val-test-${randomUUID()}`);
+  mkdirSync(join(base, ".gsd", "milestones"), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  clearPathCache();
+  clearParseCache();
+  try { rmSync(base, { recursive: true, force: true }); } catch { /* */ }
+}
+
+function writeRoadmap(base: string, mid: string, content: string): void {
+  const dir = join(base, ".gsd", "milestones", mid);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, `${mid}-ROADMAP.md`), content);
+}
+
+function writeMilestoneSummary(base: string, mid: string, content: string): void {
+  const dir = join(base, ".gsd", "milestones", mid);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, `${mid}-SUMMARY.md`), content);
+}
+
+function writeValidation(base: string, mid: string, content: string): void {
+  const dir = join(base, ".gsd", "milestones", mid);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, `${mid}-VALIDATION.md`), content);
+}
+
+function writeSlicePlan(base: string, mid: string, sid: string, content: string): void {
+  const dir = join(base, ".gsd", "milestones", mid, "slices", sid);
+  mkdirSync(join(dir, "tasks"), { recursive: true });
+  writeFileSync(join(dir, `${sid}-PLAN.md`), content);
+}
+
+function writeSliceSummary(base: string, mid: string, sid: string, content: string): void {
+  const dir = join(base, ".gsd", "milestones", mid, "slices", sid);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, `${sid}-SUMMARY.md`), content);
+}
+
+const ALL_DONE_ROADMAP = `# M001: Test Milestone
+
+## Vision
+Test
+
+## Success Criteria
+- It works
+
+## Slices
+
+- [x] **S01: First slice** \`risk:low\` \`depends:[]\`
+  > After this: it works
+
+## Boundary Map
+
+| From | To | Produces | Consumes |
+|------|-----|----------|----------|
+| S01  | terminal | output | nothing |
+`;
+
+const CONTEXT_FILE = `---
+id: M001
+title: Test Milestone
+---
+
+# Context
+Test context.
+`;
+
+// ─── isValidationTerminal ─────────────────────────────────────────────────
+
+test("isValidationTerminal returns true for verdict: pass", () => {
+  const content = "---\nverdict: pass\nremediation_round: 0\n---\n\n# Validation";
+  assert.equal(isValidationTerminal(content), true);
+});
+
+test("isValidationTerminal returns true for verdict: needs-attention", () => {
+  const content = "---\nverdict: needs-attention\nremediation_round: 0\n---\n\n# Validation";
+  assert.equal(isValidationTerminal(content), true);
+});
+
+test("isValidationTerminal returns true for verdict: needs-remediation (#832)", () => {
+  // needs-remediation is treated as terminal to prevent infinite loops
+  // when no remediation slices exist in the roadmap.
+  const content = "---\nverdict: needs-remediation\nremediation_round: 0\n---\n\n# Validation";
+  assert.equal(isValidationTerminal(content), true);
+});
+
+test("isValidationTerminal returns false for missing frontmatter", () => {
+  const content = "# Validation\nNo frontmatter here.";
+  assert.equal(isValidationTerminal(content), false);
+});
+
+test("isValidationTerminal returns false for missing verdict field", () => {
+  const content = "---\nremediation_round: 0\n---\n\n# Validation";
+  assert.equal(isValidationTerminal(content), false);
+});
+
+// ─── deriveState: validating-milestone ────────────────────────────────────
+
+test("deriveState returns validating-milestone when all slices done and no VALIDATION file", async () => {
+  const base = makeTmpBase();
+  try {
+    writeRoadmap(base, "M001", ALL_DONE_ROADMAP);
+    // Write CONTEXT so milestone has a title
+    const dir = join(base, ".gsd", "milestones", "M001");
+    writeFileSync(join(dir, "M001-CONTEXT.md"), CONTEXT_FILE);
+
+    const state = await deriveState(base);
+    assert.equal(state.phase, "validating-milestone");
+    assert.equal(state.activeMilestone?.id, "M001");
+    assert.equal(state.activeSlice, null);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("deriveState returns completing-milestone when VALIDATION exists with terminal verdict", async () => {
+  const base = makeTmpBase();
+  try {
+    writeRoadmap(base, "M001", ALL_DONE_ROADMAP);
+    writeValidation(base, "M001", "---\nverdict: pass\nremediation_round: 0\n---\n\n# Validation\nAll good.");
+
+    const state = await deriveState(base);
+    assert.equal(state.phase, "completing-milestone");
+    assert.equal(state.activeMilestone?.id, "M001");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("deriveState treats needs-remediation as terminal — does not re-enter validating-milestone (#832)", async () => {
+  const base = makeTmpBase();
+  try {
+    writeRoadmap(base, "M001", ALL_DONE_ROADMAP);
+    writeValidation(base, "M001", "---\nverdict: needs-remediation\nremediation_round: 0\n---\n\n# Validation\nNeeds fixes.");
+
+    const state = await deriveState(base);
+    // needs-remediation is now terminal — milestone needs a SUMMARY to be fully complete
+    // Without SUMMARY, it enters completing-milestone (not validating-milestone)
+    assert.notEqual(state.phase, "validating-milestone");
+    assert.equal(state.activeMilestone?.id, "M001");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("deriveState returns complete when both VALIDATION and SUMMARY exist", async () => {
+  const base = makeTmpBase();
+  try {
+    writeRoadmap(base, "M001", ALL_DONE_ROADMAP);
+    writeValidation(base, "M001", "---\nverdict: pass\nremediation_round: 0\n---\n\n# Validation\nPassed.");
+    writeMilestoneSummary(base, "M001", "# Summary\nDone.");
+
+    const state = await deriveState(base);
+    assert.equal(state.phase, "complete");
+  } finally {
+    cleanup(base);
+  }
+});
+
+// ─── Dispatch rule ────────────────────────────────────────────────────────
+
+test("dispatch rule matches validating-milestone phase", async () => {
+  const state: GSDState = {
+    activeMilestone: { id: "M001", title: "Test" },
+    activeSlice: null,
+    activeTask: null,
+    phase: "validating-milestone",
+    recentDecisions: [],
+    blockers: [],
+    nextAction: "Validate milestone M001.",
+    registry: [{ id: "M001", title: "Test", status: "active" }],
+    progress: { milestones: { done: 0, total: 1 } },
+  };
+
+  const base = makeTmpBase();
+  try {
+    // Set up minimal milestone structure for the prompt builder
+    writeRoadmap(base, "M001", ALL_DONE_ROADMAP);
+
+    const ctx: DispatchContext = {
+      basePath: base,
+      mid: "M001",
+      midTitle: "Test",
+      state,
+      prefs: undefined,
+    };
+    const result = await resolveDispatch(ctx);
+    assert.equal(result.action, "dispatch");
+    if (result.action === "dispatch") {
+      assert.equal(result.unitType, "validate-milestone");
+      assert.equal(result.unitId, "M001");
+    }
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("dispatch rule skips when skip_milestone_validation preference is set", async () => {
+  const state: GSDState = {
+    activeMilestone: { id: "M001", title: "Test" },
+    activeSlice: null,
+    activeTask: null,
+    phase: "validating-milestone",
+    recentDecisions: [],
+    blockers: [],
+    nextAction: "Validate milestone M001.",
+    registry: [{ id: "M001", title: "Test", status: "active" }],
+    progress: { milestones: { done: 0, total: 1 } },
+  };
+
+  const base = makeTmpBase();
+  try {
+    writeRoadmap(base, "M001", ALL_DONE_ROADMAP);
+
+    const ctx: DispatchContext = {
+      basePath: base,
+      mid: "M001",
+      midTitle: "Test",
+      state,
+      prefs: { phases: { skip_milestone_validation: true } },
+    };
+    const result = await resolveDispatch(ctx);
+    assert.equal(result.action, "skip");
+
+    // Verify the VALIDATION file was written
+    const validationPath = join(base, ".gsd", "milestones", "M001", "M001-VALIDATION.md");
+    assert.ok(existsSync(validationPath), "VALIDATION file should be written on skip");
+  } finally {
+    cleanup(base);
+  }
+});
+
+// ─── Artifact resolution & verification ───────────────────────────────────
+
+test("resolveExpectedArtifactPath returns VALIDATION path for validate-milestone", () => {
+  const base = makeTmpBase();
+  try {
+    mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+    const result = resolveExpectedArtifactPath("validate-milestone", "M001", base);
+    assert.ok(result);
+    assert.ok(result!.includes("VALIDATION"));
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("verifyExpectedArtifact passes when VALIDATION.md exists", () => {
+  const base = makeTmpBase();
+  try {
+    writeValidation(base, "M001", "---\nverdict: pass\n---\n# Val");
+    clearPathCache();
+    clearParseCache();
+    const result = verifyExpectedArtifact("validate-milestone", "M001", base);
+    assert.equal(result, true);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("verifyExpectedArtifact fails when VALIDATION.md is missing", () => {
+  const base = makeTmpBase();
+  try {
+    mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+    clearPathCache();
+    clearParseCache();
+    const result = verifyExpectedArtifact("validate-milestone", "M001", base);
+    assert.equal(result, false);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("verifyExpectedArtifact rejects VALIDATION with missing frontmatter", () => {
+  const base = makeTmpBase();
+  try {
+    // A VALIDATION file without frontmatter should be treated as incomplete —
+    // matching what deriveState expects. Without this, the artifact check passes
+    // but deriveState still returns validating-milestone, causing the hard skip loop.
+    writeValidation(base, "M001", "# Validation\nNo frontmatter here.");
+    clearPathCache();
+    clearParseCache();
+    const result = verifyExpectedArtifact("validate-milestone", "M001", base);
+    assert.equal(result, false, "VALIDATION without frontmatter should fail verification");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("verifyExpectedArtifact rejects VALIDATION with missing verdict field", () => {
+  const base = makeTmpBase();
+  try {
+    writeValidation(base, "M001", "---\nremediation_round: 0\n---\n\n# Validation");
+    clearPathCache();
+    clearParseCache();
+    const result = verifyExpectedArtifact("validate-milestone", "M001", base);
+    assert.equal(result, false, "VALIDATION without verdict field should fail verification");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("verifyExpectedArtifact rejects VALIDATION with unrecognized verdict", () => {
+  const base = makeTmpBase();
+  try {
+    writeValidation(base, "M001", "---\nverdict: unknown-value\nremediation_round: 0\n---\n\n# Validation");
+    clearPathCache();
+    clearParseCache();
+    const result = verifyExpectedArtifact("validate-milestone", "M001", base);
+    assert.equal(result, false, "VALIDATION with unrecognized verdict should fail verification");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("verifyExpectedArtifact passes VALIDATION with needs-attention verdict", () => {
+  const base = makeTmpBase();
+  try {
+    writeValidation(base, "M001", "---\nverdict: needs-attention\nremediation_round: 0\n---\n\n# Validation\nNeeds attention.");
+    clearPathCache();
+    clearParseCache();
+    const result = verifyExpectedArtifact("validate-milestone", "M001", base);
+    assert.equal(result, true, "VALIDATION with needs-attention verdict should pass verification");
+  } finally {
+    cleanup(base);
+  }
+});
+
+// ─── diagnoseExpectedArtifact ─────────────────────────────────────────────
+
+test("diagnoseExpectedArtifact returns validation path for validate-milestone", () => {
+  const base = makeTmpBase();
+  try {
+    const result = diagnoseExpectedArtifact("validate-milestone", "M001", base);
+    assert.ok(result);
+    assert.ok(result!.includes("VALIDATION"));
+    assert.ok(result!.includes("milestone validation report"));
+  } finally {
+    cleanup(base);
+  }
+});
+
+// ─── buildLoopRemediationSteps ────────────────────────────────────────────
+
+test("buildLoopRemediationSteps returns steps for validate-milestone", () => {
+  const base = makeTmpBase();
+  try {
+    const result = buildLoopRemediationSteps("validate-milestone", "M001", base);
+    assert.ok(result);
+    assert.ok(result!.includes("VALIDATION"));
+    assert.ok(result!.includes("verdict: pass"));
+    assert.ok(result!.includes("gsd doctor"));
+  } finally {
+    cleanup(base);
+  }
+});