gsd-pi 2.16.0 → 2.17.0

package/dist/resources/extensions/gsd/tests/context-compression.test.ts

@@ -0,0 +1,180 @@
+/**
+ * Context Compression — unit tests for M004/S02.
+ *
+ * Verifies that prompt builders respect inlineLevel parameter by
+ * inspecting the auto-prompts.ts source for level-aware gating.
+ * Cannot call builders directly due to @gsd/pi-coding-agent import
+ * resolution — uses source-level structural verification instead.
+ */
+
+import 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 promptsSrc = readFileSync(join(__dirname, "..", "auto-prompts.ts"), "utf-8");
+
+// ═══════════════════════════════════════════════════════════════════════════
+// inlineLevel Parameter Presence
+// ═══════════════════════════════════════════════════════════════════════════
+
+const BUILDERS_WITH_LEVEL = [
+  "buildPlanMilestonePrompt",
+  "buildPlanSlicePrompt",
+  "buildExecuteTaskPrompt",
+  "buildCompleteSlicePrompt",
+  "buildCompleteMilestonePrompt",
+  "buildReassessRoadmapPrompt",
+];
+
+for (const builder of BUILDERS_WITH_LEVEL) {
+  test(`compression: ${builder} accepts inlineLevel parameter`, () => {
+    // Find the function signature
+    const sigRegex = new RegExp(`export async function ${builder}\\([^)]*level\\?: InlineLevel`);
+    assert.ok(
+      sigRegex.test(promptsSrc),
+      `${builder} should have level?: InlineLevel parameter`,
+    );
+  });
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Default Level Resolution
+// ═══════════════════════════════════════════════════════════════════════════
+
+test("compression: builders default to resolveInlineLevel() when no level passed", () => {
+  const defaultPattern = /const inlineLevel = level \?\? resolveInlineLevel\(\)/g;
+  const matches = promptsSrc.match(defaultPattern);
+  assert.ok(matches, "should have resolveInlineLevel() fallback");
+  assert.ok(
+    matches.length >= BUILDERS_WITH_LEVEL.length,
+    `should have ${BUILDERS_WITH_LEVEL.length} fallback instances, found ${matches?.length}`,
+  );
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Minimal Level — Template Reduction
+// ═══════════════════════════════════════════════════════════════════════════
+
+test("compression: buildExecuteTaskPrompt minimal drops decisions template", () => {
+  // In the execute-task builder, minimal should only inline task-summary, not decisions
+  assert.ok(
+    promptsSrc.includes('inlineLevel === "minimal"') &&
+    promptsSrc.includes('inlineTemplate("task-summary"'),
+    "execute-task should conditionally include decisions template based on level",
+  );
+});
+
+test("compression: buildExecuteTaskPrompt minimal truncates prior summaries", () => {
+  assert.ok(
+    promptsSrc.includes('inlineLevel === "minimal" && priorSummaries.length > 1'),
+    "execute-task should limit prior summaries for minimal level",
+  );
+});
+
+test("compression: buildPlanMilestonePrompt minimal drops project/requirements/decisions files", () => {
+  // The plan-milestone builder should gate root file inlining on inlineLevel
+  assert.ok(
+    promptsSrc.includes('inlineLevel !== "minimal"') &&
+    promptsSrc.includes('inlineGsdRootFile(base, "project.md"'),
+    "plan-milestone should conditionally include project.md based on level",
+  );
+});
+
+test("compression: buildPlanMilestonePrompt minimal drops extra templates", () => {
+  // Full inlines 5 templates, minimal should inline fewer
+  assert.ok(
+    promptsSrc.includes('if (inlineLevel === "full")') &&
+    promptsSrc.includes('inlineTemplate("secrets-manifest"'),
+    "plan-milestone should only include secrets-manifest template at full level",
+  );
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Complete-Slice Level Gating
+// ═══════════════════════════════════════════════════════════════════════════
+
+test("compression: buildCompleteSlicePrompt minimal drops requirements", () => {
+  // Find the complete-slice section and verify requirements gating
+  const completeSliceIdx = promptsSrc.indexOf("buildCompleteSlicePrompt");
+  const nextBuilder = promptsSrc.indexOf("buildCompleteMilestonePrompt");
+  const completeSliceBlock = promptsSrc.slice(completeSliceIdx, nextBuilder);
+  assert.ok(
+    completeSliceBlock.includes('inlineLevel !== "minimal"'),
+    "complete-slice should gate requirements inlining on level",
+  );
+});
+
+test("compression: buildCompleteSlicePrompt minimal drops UAT template", () => {
+  const completeSliceIdx = promptsSrc.indexOf("buildCompleteSlicePrompt");
+  const nextBuilder = promptsSrc.indexOf("buildCompleteMilestonePrompt");
+  const completeSliceBlock = promptsSrc.slice(completeSliceIdx, nextBuilder);
+  assert.ok(
+    completeSliceBlock.includes('inlineLevel !== "minimal"') &&
+    completeSliceBlock.includes('inlineTemplate("uat"'),
+    "complete-slice should conditionally include UAT template based on level",
+  );
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Complete-Milestone Level Gating
+// ═══════════════════════════════════════════════════════════════════════════
+
+test("compression: buildCompleteMilestonePrompt minimal drops root GSD files", () => {
+  const completeMilestoneIdx = promptsSrc.indexOf("buildCompleteMilestonePrompt");
+  const nextBuilder = promptsSrc.indexOf("buildReplanSlicePrompt");
+  const block = promptsSrc.slice(completeMilestoneIdx, nextBuilder);
+  assert.ok(
+    block.includes('inlineLevel !== "minimal"') &&
+    block.includes('inlineGsdRootFile(base, "requirements.md"'),
+    "complete-milestone should gate root file inlining on level",
+  );
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Reassess-Roadmap Level Gating
+// ═══════════════════════════════════════════════════════════════════════════
+
+test("compression: buildReassessRoadmapPrompt minimal drops project/requirements/decisions", () => {
+  const reassessIdx = promptsSrc.indexOf("buildReassessRoadmapPrompt");
+  const block = promptsSrc.slice(reassessIdx, reassessIdx + 1500);
+  assert.ok(
+    block.includes('inlineLevel !== "minimal"'),
+    "reassess-roadmap should gate file inlining on level",
+  );
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Full Level — No Regression
+// ═══════════════════════════════════════════════════════════════════════════
+
+test("compression: full level preserves all templates and files (no regression)", () => {
+  // Verify the key template names are still present in the source
+  const expectedTemplates = [
+    "roadmap", "decisions", "plan", "task-plan", "secrets-manifest",
+    "task-summary", "slice-summary", "uat", "milestone-summary",
+  ];
+  for (const tpl of expectedTemplates) {
+    assert.ok(
+      promptsSrc.includes(`inlineTemplate("${tpl}"`),
+      `template "${tpl}" should still be present in auto-prompts.ts`,
+    );
+  }
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Import Verification
+// ═══════════════════════════════════════════════════════════════════════════
+
+test("compression: auto-prompts.ts imports resolveInlineLevel and InlineLevel", () => {
+  assert.ok(
+    promptsSrc.includes("resolveInlineLevel"),
+    "should import resolveInlineLevel from preferences",
+  );
+  assert.ok(
+    promptsSrc.includes("InlineLevel"),
+    "should import InlineLevel type from types",
+  );
+});

package/dist/resources/extensions/gsd/tests/git-service.test.ts

@@ -1020,6 +1020,138 @@ async function main(): Promise<void> {
     rmSync(repo, { recursive: true, force: true });
   }
 
+  // ─── commit_docs: false — smartStage excludes .gsd/ ──────────────────
+
+  console.log("\n=== commit_docs: false — smartStage excludes .gsd/ ===");
+
+  {
+    const repo = mkdtempSync(join(tmpdir(), "gsd-commit-docs-"));
+    run("git init -b main", repo);
+    run("git config user.email test@test.com", repo);
+    run("git config user.name Test", repo);
+    writeFileSync(join(repo, "README.md"), "init");
+    run("git add -A && git commit -m init", repo);
+
+    // Create .gsd/ planning files + a normal source file
+    mkdirSync(join(repo, ".gsd", "milestones", "M001"), { recursive: true });
+    writeFileSync(join(repo, ".gsd", "milestones", "M001", "ROADMAP.md"), "# Roadmap");
+    writeFileSync(join(repo, ".gsd", "preferences.md"), "---\nversion: 1\n---");
+    writeFileSync(join(repo, "src.ts"), "const x = 1;");
+
+    // With commit_docs: false, smartStage should exclude .gsd/
+    const svc = new GitServiceImpl(repo, { commit_docs: false });
+    const msg = svc.commit({ message: "test commit" });
+    assertTrue(msg !== null, "commit_docs=false: commit succeeds with non-.gsd files");
+
+    // .gsd/ files should NOT be in the commit
+    const committed = run("git show --name-only HEAD", repo);
+    assertTrue(!committed.includes(".gsd/"), "commit_docs=false: .gsd/ files not in commit");
+    assertTrue(committed.includes("src.ts"), "commit_docs=false: source files ARE in commit");
+
+    rmSync(repo, { recursive: true, force: true });
+  }
+
+  // ─── commit_docs: true (default) — smartStage includes .gsd/ ────────
+
+  console.log("\n=== commit_docs: true — smartStage includes .gsd/ ===");
+
+  {
+    const repo = mkdtempSync(join(tmpdir(), "gsd-commit-docs-default-"));
+    run("git init -b main", repo);
+    run("git config user.email test@test.com", repo);
+    run("git config user.name Test", repo);
+    writeFileSync(join(repo, "README.md"), "init");
+    run("git add -A && git commit -m init", repo);
+
+    mkdirSync(join(repo, ".gsd", "milestones", "M001"), { recursive: true });
+    writeFileSync(join(repo, ".gsd", "milestones", "M001", "ROADMAP.md"), "# Roadmap");
+    writeFileSync(join(repo, "src.ts"), "const x = 1;");
+
+    // Default behavior (commit_docs not set) — .gsd/ files ARE committed
+    const svc = new GitServiceImpl(repo);
+    const msg = svc.commit({ message: "test commit" });
+    assertTrue(msg !== null, "commit_docs=default: commit succeeds");
+
+    const committed = run("git show --name-only HEAD", repo);
+    assertTrue(committed.includes(".gsd/"), "commit_docs=default: .gsd/ files ARE in commit");
+    assertTrue(committed.includes("src.ts"), "commit_docs=default: source files in commit");
+
+    rmSync(repo, { recursive: true, force: true });
+  }
+
+  // ─── writeIntegrationBranch: commitDocs false skips commit ──────────
+
+  console.log("\n=== writeIntegrationBranch: commitDocs false skips commit ===");
+
+  {
+    const repo = initBranchTestRepo();
+    const commitsBefore = run("git rev-list --count HEAD", repo);
+
+    writeIntegrationBranch(repo, "M001", "f-123-new-thing", { commitDocs: false });
+
+    // File should still be written to disk
+    assertEq(readIntegrationBranch(repo, "M001"), "f-123-new-thing",
+      "commitDocs=false: metadata file exists on disk");
+
+    // But no new commit should have been created
+    const commitsAfter = run("git rev-list --count HEAD", repo);
+    assertEq(commitsBefore, commitsAfter,
+      "commitDocs=false: no git commit created for integration branch");
+
+    rmSync(repo, { recursive: true, force: true });
+  }
+
+  // ─── ensureGitignore: commit_docs false adds blanket .gsd/ ──────────
+
+  console.log("\n=== ensureGitignore: commit_docs false ===");
+
+  {
+    const { ensureGitignore } = await import("../gitignore.ts");
+    const repo = mkdtempSync(join(tmpdir(), "gsd-gitignore-commit-docs-"));
+
+    // When commit_docs is false, should add blanket .gsd/ to gitignore
+    const modified = ensureGitignore(repo, { commitDocs: false });
+    assertTrue(modified, "commit_docs=false: gitignore was modified");
+
+    const { readFileSync } = await import("node:fs");
+    const content = readFileSync(join(repo, ".gitignore"), "utf-8");
+    assertTrue(content.includes(".gsd/"), "commit_docs=false: .gitignore contains blanket .gsd/");
+    assertTrue(content.includes("commit_docs: false"), "commit_docs=false: .gitignore contains explanatory comment");
+
+    // Should NOT contain individual runtime patterns (those are subsumed by blanket .gsd/)
+    // But it's OK if it does — the blanket .gsd/ covers everything
+
+    // Idempotent — calling again doesn't add duplicates
+    const modified2 = ensureGitignore(repo, { commitDocs: false });
+    assertTrue(!modified2, "commit_docs=false: second call is idempotent");
+
+    rmSync(repo, { recursive: true, force: true });
+  }
+
+  // ─── ensureGitignore: commit_docs true removes blanket .gsd/ ────────
+
+  console.log("\n=== ensureGitignore: commit_docs true self-heals ===");
+
+  {
+    const { ensureGitignore } = await import("../gitignore.ts");
+    const repo = mkdtempSync(join(tmpdir(), "gsd-gitignore-selfheal-"));
+
+    // Start with a gitignore that has a blanket .gsd/ (e.g., user switched setting)
+    writeFileSync(join(repo, ".gitignore"), ".gsd/\n");
+
+    const modified = ensureGitignore(repo, { commitDocs: true });
+    assertTrue(modified, "commit_docs=true: gitignore was modified");
+
+    const { readFileSync } = await import("node:fs");
+    const content = readFileSync(join(repo, ".gitignore"), "utf-8");
+    // Blanket .gsd/ should be removed
+    const lines = content.split("\n").map(l => l.trim()).filter(l => l && !l.startsWith("#"));
+    assertTrue(!lines.includes(".gsd/"), "commit_docs=true: blanket .gsd/ was removed");
+    assertTrue(!lines.includes(".gsd"), "commit_docs=true: blanket .gsd was removed");
+
+    rmSync(repo, { recursive: true, force: true });
+  }
+
   report();
 }
 

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

@@ -68,6 +68,34 @@ async function main(): Promise<void> {
     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");
+  }
+
   report();
 }
 

package/dist/resources/extensions/gsd/tests/routing-history.test.ts

@@ -0,0 +1,87 @@
+/**
+ * Routing History — structural tests for adaptive learning module.
+ *
+ * Verifies routing-history.ts exports and structure from #579.
+ * Uses source-level checks to avoid @gsd/pi-coding-agent import chain.
+ */
+
+import 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 historySrc = readFileSync(join(__dirname, "..", "routing-history.ts"), "utf-8");
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Module Exports
+// ═══════════════════════════════════════════════════════════════════════════
+
+test("routing-history: exports initRoutingHistory", () => {
+  assert.ok(historySrc.includes("export function initRoutingHistory"), "should export initRoutingHistory");
+});
+
+test("routing-history: exports recordOutcome", () => {
+  assert.ok(historySrc.includes("export function recordOutcome"), "should export recordOutcome");
+});
+
+test("routing-history: exports recordFeedback", () => {
+  assert.ok(historySrc.includes("export function recordFeedback"), "should export recordFeedback");
+});
+
+test("routing-history: exports getAdaptiveTierAdjustment", () => {
+  assert.ok(historySrc.includes("export function getAdaptiveTierAdjustment"), "should export getAdaptiveTierAdjustment");
+});
+
+test("routing-history: exports resetRoutingHistory", () => {
+  assert.ok(historySrc.includes("export function resetRoutingHistory"), "should export resetRoutingHistory");
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Design Constants
+// ═══════════════════════════════════════════════════════════════════════════
+
+test("routing-history: uses rolling window of 50 entries", () => {
+  assert.ok(historySrc.includes("ROLLING_WINDOW = 50"), "should use 50-entry rolling window");
+});
+
+test("routing-history: failure threshold is 20%", () => {
+  assert.ok(historySrc.includes("FAILURE_THRESHOLD = 0.20"), "should use 20% failure threshold");
+});
+
+test("routing-history: feedback weight is 2x", () => {
+  assert.ok(historySrc.includes("FEEDBACK_WEIGHT = 2"), "feedback should count 2x");
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Type Structure
+// ═══════════════════════════════════════════════════════════════════════════
+
+test("routing-history: imports ComplexityTier from types.ts", () => {
+  assert.ok(
+    historySrc.includes('from "./types.js"') && historySrc.includes("ComplexityTier"),
+    "should import ComplexityTier from types.ts",
+  );
+});
+
+test("routing-history: defines RoutingHistoryData interface", () => {
+  assert.ok(historySrc.includes("interface RoutingHistoryData"), "should define RoutingHistoryData");
+});
+
+test("routing-history: defines FeedbackEntry interface", () => {
+  assert.ok(historySrc.includes("interface FeedbackEntry"), "should define FeedbackEntry");
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Persistence
+// ═══════════════════════════════════════════════════════════════════════════
+
+test("routing-history: persists to routing-history.json", () => {
+  assert.ok(historySrc.includes("routing-history.json"), "should persist to routing-history.json");
+});
+
+test("routing-history: has save and load functions", () => {
+  assert.ok(historySrc.includes("saveHistory") || historySrc.includes("function save"), "should have save");
+  assert.ok(historySrc.includes("loadHistory") || historySrc.includes("function load"), "should have load");
+});

package/dist/resources/extensions/gsd/tests/stop-auto-remote.test.ts

@@ -0,0 +1,130 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { randomUUID } from "node:crypto";
+import { fork } from "node:child_process";
+
+import { writeFileSync } from "node:fs";
+import {
+  writeLock,
+  readCrashLock,
+  clearLock,
+  isLockProcessAlive,
+} from "../crash-recovery.ts";
+import { stopAutoRemote } from "../auto.ts";
+
+function makeTmpBase(): string {
+  const base = join(tmpdir(), `gsd-test-${randomUUID()}`);
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  try { rmSync(base, { recursive: true, force: true }); } catch { /* */ }
+}
+
+// ─── stopAutoRemote ──────────────────────────────────────────────────────
+
+test("stopAutoRemote returns found:false when no lock file exists", () => {
+  const base = makeTmpBase();
+  try {
+    const result = stopAutoRemote(base);
+    assert.equal(result.found, false);
+    assert.equal(result.pid, undefined);
+    assert.equal(result.error, undefined);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("stopAutoRemote cleans up stale lock (dead PID) and returns found:false", () => {
+  const base = makeTmpBase();
+  try {
+    // Write a lock with a PID that doesn't exist
+    writeLock(base, "execute-task", "M001/S01/T01", 3);
+    // Overwrite PID to a dead one
+    const lock = readCrashLock(base)!;
+    const staleData = { ...lock, pid: 999999999 };
+    writeFileSync(join(base, ".gsd", "auto.lock"), JSON.stringify(staleData, null, 2), "utf-8");
+
+    const result = stopAutoRemote(base);
+    assert.equal(result.found, false, "stale lock should not be found as running");
+
+    // Lock should be cleaned up
+    assert.equal(readCrashLock(base), null, "stale lock should be removed");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("stopAutoRemote sends SIGTERM to a live process and returns found:true", async () => {
+  const base = makeTmpBase();
+
+  // Spawn a child process that sleeps, acting as a fake auto-mode session
+  const child = fork(
+    "-e",
+    ["process.on('SIGTERM', () => process.exit(0)); setTimeout(() => process.exit(1), 30000);"],
+    { stdio: "ignore", detached: false },
+  );
+
+  try {
+    // Wait for child to be ready
+    await new Promise((resolve) => setTimeout(resolve, 200));
+
+    // Write lock with child's PID
+    const lockData = {
+      pid: child.pid,
+      startedAt: new Date().toISOString(),
+      unitType: "execute-task",
+      unitId: "M001/S01/T01",
+      unitStartedAt: new Date().toISOString(),
+      completedUnits: 0,
+    };
+    writeFileSync(join(base, ".gsd", "auto.lock"), JSON.stringify(lockData, null, 2), "utf-8");
+
+    const result = stopAutoRemote(base);
+    assert.equal(result.found, true, "should find running auto-mode");
+    assert.equal(result.pid, child.pid, "should return the PID");
+
+    // Wait for child to exit (it should receive SIGTERM)
+    const exitCode = await new Promise<number | null>((resolve) => {
+      child.on("exit", (code) => resolve(code));
+      setTimeout(() => resolve(null), 5000);
+    });
+    // On Windows, SIGTERM is not interceptable — the process exits with code 1
+    // rather than running the handler. Accept either clean exit (0) or forced (1).
+    assert.ok(exitCode !== null, "child should have exited after SIGTERM");
+    if (process.platform !== "win32") {
+      assert.equal(exitCode, 0, "child should have exited cleanly via SIGTERM");
+    }
+  } finally {
+    try { child.kill("SIGKILL"); } catch { /* already dead */ }
+    cleanup(base);
+  }
+});
+
+// ─── Lock path: original project root vs worktree ────────────────────────
+
+test("lock file should be discoverable at project root, not worktree path", () => {
+  const projectRoot = makeTmpBase();
+  const worktreePath = join(projectRoot, ".gsd", "worktrees", "M001");
+  mkdirSync(join(worktreePath, ".gsd"), { recursive: true });
+
+  try {
+    // Simulate: auto-mode writes lock to project root (the fix)
+    writeLock(projectRoot, "execute-task", "M001/S01/T01", 0);
+
+    // Second terminal checks project root — should find the lock
+    const lock = readCrashLock(projectRoot);
+    assert.ok(lock, "lock should be found at project root");
+    assert.equal(lock!.unitType, "execute-task");
+
+    // Worktree path should NOT have a lock
+    const worktreeLock = readCrashLock(worktreePath);
+    assert.equal(worktreeLock, null, "lock should NOT exist at worktree path");
+  } finally {
+    cleanup(projectRoot);
+  }
+});