gsd-pi 2.33.0-dev.bafba33 → 2.33.1-dev.235d83a

package/dist/resources/extensions/gsd/tests/stale-worktree-cwd.test.ts

@@ -1,142 +0,0 @@
-/**
- * stale-worktree-cwd.test.ts — Tests for #608 fix.
- *
- * Verifies that when process.cwd() is inside a stale .gsd/worktrees/ path,
- * startAuto escapes back to the project root before proceeding.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, rmSync, existsSync, realpathSync, writeFileSync } from "node:fs";
-import { join, sep } from "node:path";
-import { tmpdir } from "node:os";
-import { execSync } from "node:child_process";
-
-import {
-  createAutoWorktree,
-  teardownAutoWorktree,
-  mergeMilestoneToMain,
-} from "../auto-worktree.ts";
-
-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(), "stale-wt-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");
-  // Mirror production: .gsd/worktrees/ is gitignored so autoCommitDirtyState
-  // doesn't pick up the worktrees directory as dirty state (#1127 fix).
-  writeFileSync(join(dir, ".gitignore"), ".gsd/worktrees/\n");
-  run("git add .", dir);
-  run("git commit -m init", dir);
-  run("git branch -M main", dir);
-  return dir;
-}
-
-// ─── escapeStaleWorktree is called by startAuto, test the detection logic ────
-
-test("detects stale worktree path and extracts project root", () => {
-  // Simulate the path pattern: /project/.gsd/worktrees/M004/...
-  const projectRoot = "/Users/test/myproject";
-  const stalePath = `${projectRoot}${sep}.gsd${sep}worktrees${sep}M004`;
-
-  const marker = `${sep}.gsd${sep}worktrees${sep}`;
-  const idx = stalePath.indexOf(marker);
-
-  assert.ok(idx !== -1, "marker found in stale path");
-  assert.equal(stalePath.slice(0, idx), projectRoot, "project root extracted correctly");
-});
-
-test("does not trigger on normal project path", () => {
-  const normalPath = "/Users/test/myproject";
-  const marker = `${sep}.gsd${sep}worktrees${sep}`;
-  const idx = normalPath.indexOf(marker);
-
-  assert.equal(idx, -1, "marker not found in normal path");
-});
-
-// ─── Integration: mergeMilestoneToMain restores cwd ─────────────────────────
-
-test("mergeMilestoneToMain restores cwd to project root", () => {
-  const savedCwd = process.cwd();
-  let tempDir = "";
-
-  try {
-    tempDir = createTempRepo();
-
-    // Create milestone planning artifacts
-    const msDir = join(tempDir, ".gsd", "milestones", "M050");
-    mkdirSync(msDir, { recursive: true });
-    writeFileSync(join(msDir, "CONTEXT.md"), "# M050 Context\n");
-    const roadmap = [
-      "# M050: Test Milestone",
-      "**Vision**: testing",
-      "## Success Criteria",
-      "- It works",
-      "## Slices",
-      "- [x] S01 — First slice",
-    ].join("\n");
-    writeFileSync(join(msDir, "ROADMAP.md"), roadmap);
-    run("git add .", tempDir);
-    run("git commit -m \"add milestone\"", tempDir);
-
-    // Create auto-worktree (enters the worktree dir)
-    const wtPath = createAutoWorktree(tempDir, "M050");
-    assert.equal(process.cwd(), wtPath, "cwd is in worktree after create");
-
-    // Add a change in the worktree
-    writeFileSync(join(wtPath, "feature.txt"), "new feature\n");
-    run("git add .", wtPath);
-    run("git commit -m \"feat: add feature\"", wtPath);
-
-    // Merge back — should restore cwd to tempDir
-    mergeMilestoneToMain(tempDir, "M050", roadmap);
-
-    assert.equal(process.cwd(), tempDir, "cwd restored to project root after merge");
-    assert.ok(!existsSync(wtPath), "worktree directory removed after merge");
-  } finally {
-    process.chdir(savedCwd);
-    if (tempDir && existsSync(tempDir)) {
-      rmSync(tempDir, { recursive: true, force: true });
-    }
-  }
-});
-
-// ─── Integration: stale worktree directory is detectable ────────────────────
-
-test("process.cwd() inside removed worktree is recoverable", () => {
-  const savedCwd = process.cwd();
-  let tempDir = "";
-
-  try {
-    tempDir = createTempRepo();
-
-    // Create a .gsd/worktrees/M099 directory to simulate stale state
-    const staleWtDir = join(tempDir, ".gsd", "worktrees", "M099");
-    mkdirSync(staleWtDir, { recursive: true });
-
-    // Enter the stale directory
-    process.chdir(staleWtDir);
-    const cwdBefore = process.cwd();
-    assert.ok(cwdBefore.includes(`${sep}.gsd${sep}worktrees${sep}`), "cwd is inside worktree dir");
-
-    // Simulate escapeStaleWorktree logic
-    const marker = `${sep}.gsd${sep}worktrees${sep}`;
-    const idx = cwdBefore.indexOf(marker);
-    assert.ok(idx !== -1, "marker found");
-
-    const projectRoot = cwdBefore.slice(0, idx);
-    process.chdir(projectRoot);
-
-    assert.equal(process.cwd(), tempDir, "successfully escaped to project root");
-  } finally {
-    process.chdir(savedCwd);
-    if (tempDir && existsSync(tempDir)) {
-      rmSync(tempDir, { recursive: true, force: true });
-    }
-  }
-});

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

@@ -1,156 +0,0 @@
-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 { spawn, type ChildProcess } 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 { /* */ }
-}
-
-function waitForChildExit(child: ChildProcess, timeoutMs = 5000): Promise<number | null> {
-  return new Promise((resolve) => {
-    if (child.exitCode !== null) {
-      resolve(child.exitCode);
-      return;
-    }
-
-    const timeout = setTimeout(() => {
-      child.off("exit", onExit);
-      resolve(child.exitCode);
-    }, timeoutMs);
-
-    const onExit = (code: number | null) => {
-      clearTimeout(timeout);
-      resolve(code);
-    };
-
-    child.once("exit", onExit);
-  });
-}
-
-// ─── 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 prints "ready" then sleeps, acting as a fake auto-mode session
-  const child = spawn(
-    process.execPath,
-    ["-e", "process.on('SIGTERM', () => process.exit(0)); process.stdout.write('ready'); setTimeout(() => process.exit(1), 30000);"],
-    { stdio: ["ignore", "pipe", "ignore"], detached: false },
-  );
-
-  if (!child.pid) {
-    throw new Error("failed to spawn child process for stopAutoRemote test");
-  }
-
-  try {
-    // Wait for child to signal readiness via stdout
-    await new Promise<void>((resolve) => {
-      child.stdout!.once("data", () => resolve());
-      setTimeout(resolve, 2000); // fallback timeout
-    });
-
-    // 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 exitPromise = waitForChildExit(child);
-    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 exitPromise;
-    // 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);
-  }
-});

package/dist/resources/extensions/gsd/tests/structured-data-formatter.test.ts

@@ -1,365 +0,0 @@
-/**
- * Unit tests for structured-data-formatter.ts — compact notation for prompt injection.
- */
-
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-
-import {
-  formatDecisionCompact,
-  formatDecisionsCompact,
-  formatRequirementCompact,
-  formatRequirementsCompact,
-  formatTaskPlanCompact,
-  measureSavings,
-} from "../structured-data-formatter.js";
-
-// ---------------------------------------------------------------------------
-// Fixtures
-// ---------------------------------------------------------------------------
-
-const sampleDecision = {
-  id: "D001",
-  when_context: "M001/S01",
-  scope: "architecture",
-  decision: "Use SQLite for storage",
-  choice: "WAL mode, single-writer",
-  rationale: "Built-in, no external deps",
-  revisable: "yes",
-};
-
-const sampleDecision2 = {
-  id: "D002",
-  when_context: "M001/S02",
-  scope: "testing",
-  decision: "Unit test all parsers",
-  choice: "node:test framework",
-  rationale: "Fast, zero-dependency",
-  revisable: "no",
-};
-
-const sampleRequirement = {
-  id: "R001",
-  class: "functional",
-  status: "active",
-  description: "Response latency < 200ms for API endpoints",
-  why: "Critical for user experience",
-  primary_owner: "S01",
-  validation: "Load test confirms P99 < 200ms",
-};
-
-const sampleRequirement2 = {
-  id: "R002",
-  class: "non-functional",
-  status: "active",
-  description: "Data consistency across writes",
-  why: "Prevents data loss",
-  primary_owner: "S02",
-  validation: "Integration test suite",
-};
-
-const sampleTaskDone = {
-  id: "T01",
-  title: "Database schema",
-  description: "Create tables for decisions and requirements",
-  done: true,
-  estimate: "30m",
-  files: ["src/db.ts", "src/schema.ts"],
-};
-
-const sampleTaskPending = {
-  id: "T02",
-  title: "API endpoints",
-  description: "REST endpoints for CRUD operations",
-  done: false,
-  estimate: "1h",
-  files: ["src/api.ts"],
-  verify: "npm test",
-};
-
-// ---------------------------------------------------------------------------
-// formatDecisionCompact
-// ---------------------------------------------------------------------------
-
-describe("structured-data-formatter: formatDecisionCompact", () => {
-  it("produces pipe-separated single-line output", () => {
-    const result = formatDecisionCompact(sampleDecision);
-    assert.equal(
-      result,
-      "D001 | M001/S01 | architecture | Use SQLite for storage | WAL mode, single-writer | Built-in, no external deps | yes",
-    );
-  });
-
-  it("includes all fields in the correct order", () => {
-    const result = formatDecisionCompact(sampleDecision);
-    const parts = result.split(" | ");
-    assert.equal(parts.length, 7);
-    assert.equal(parts[0], "D001");
-    assert.equal(parts[6], "yes");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// formatDecisionsCompact
-// ---------------------------------------------------------------------------
-
-describe("structured-data-formatter: formatDecisionsCompact", () => {
-  it("includes Fields header line", () => {
-    const result = formatDecisionsCompact([sampleDecision]);
-    assert.ok(result.startsWith("# Decisions (compact)"));
-    assert.ok(result.includes("Fields: id | when | scope | decision | choice | rationale | revisable"));
-  });
-
-  it("formats multiple decisions on separate lines", () => {
-    const result = formatDecisionsCompact([sampleDecision, sampleDecision2]);
-    const lines = result.split("\n");
-    // header, fields, blank, D001, D002
-    assert.equal(lines.length, 5);
-    assert.ok(lines[3].startsWith("D001"));
-    assert.ok(lines[4].startsWith("D002"));
-  });
-
-  it("returns (none) for empty array", () => {
-    const result = formatDecisionsCompact([]);
-    assert.ok(result.includes("(none)"));
-  });
-
-  it("formats single-item array with header", () => {
-    const result = formatDecisionsCompact([sampleDecision]);
-    assert.ok(result.includes("# Decisions (compact)"));
-    assert.ok(result.includes("D001"));
-    // Only one data line after the blank separator
-    const dataLines = result.split("\n\n")[1].split("\n");
-    assert.equal(dataLines.length, 1);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// formatRequirementCompact
-// ---------------------------------------------------------------------------
-
-describe("structured-data-formatter: formatRequirementCompact", () => {
-  it("produces multi-line compact format", () => {
-    const result = formatRequirementCompact(sampleRequirement);
-    const lines = result.split("\n");
-    assert.equal(lines.length, 4);
-  });
-
-  it("first line has id, class, status, owner", () => {
-    const result = formatRequirementCompact(sampleRequirement);
-    const first = result.split("\n")[0];
-    assert.equal(first, "R001 [functional] (active) owner:S01");
-  });
-
-  it("description is indented on second line", () => {
-    const result = formatRequirementCompact(sampleRequirement);
-    const second = result.split("\n")[1];
-    assert.equal(second, "  Response latency < 200ms for API endpoints");
-  });
-
-  it("includes why and validate lines", () => {
-    const result = formatRequirementCompact(sampleRequirement);
-    assert.ok(result.includes("  why: Critical for user experience"));
-    assert.ok(result.includes("  validate: Load test confirms P99 < 200ms"));
-  });
-});
-
-// ---------------------------------------------------------------------------
-// formatRequirementsCompact
-// ---------------------------------------------------------------------------
-
-describe("structured-data-formatter: formatRequirementsCompact", () => {
-  it("includes header", () => {
-    const result = formatRequirementsCompact([sampleRequirement]);
-    assert.ok(result.startsWith("# Requirements (compact)"));
-  });
-
-  it("separates multiple requirements with blank lines", () => {
-    const result = formatRequirementsCompact([sampleRequirement, sampleRequirement2]);
-    const blocks = result.split("\n\n");
-    // header block, R001 block, R002 block
-    assert.equal(blocks.length, 3);
-  });
-
-  it("returns (none) for empty array", () => {
-    const result = formatRequirementsCompact([]);
-    assert.ok(result.includes("(none)"));
-  });
-
-  it("formats single-item array", () => {
-    const result = formatRequirementsCompact([sampleRequirement]);
-    assert.ok(result.includes("R001"));
-    assert.ok(!result.includes("R002"));
-  });
-});
-
-// ---------------------------------------------------------------------------
-// formatTaskPlanCompact
-// ---------------------------------------------------------------------------
-
-describe("structured-data-formatter: formatTaskPlanCompact", () => {
-  it("uses [x] for done tasks and [ ] for pending", () => {
-    const result = formatTaskPlanCompact([sampleTaskDone, sampleTaskPending]);
-    assert.ok(result.includes("T01 [x] Database schema (30m)"));
-    assert.ok(result.includes("T02 [ ] API endpoints (1h)"));
-  });
-
-  it("includes files list when present", () => {
-    const result = formatTaskPlanCompact([sampleTaskDone]);
-    assert.ok(result.includes("  files: src/db.ts, src/schema.ts"));
-  });
-
-  it("includes verify when present", () => {
-    const result = formatTaskPlanCompact([sampleTaskPending]);
-    assert.ok(result.includes("  verify: npm test"));
-  });
-
-  it("omits files line when not provided", () => {
-    const noFiles = { ...sampleTaskDone, files: undefined };
-    const result = formatTaskPlanCompact([noFiles]);
-    assert.ok(!result.includes("files:"));
-  });
-
-  it("omits verify line when not provided", () => {
-    const noVerify = { ...sampleTaskDone, verify: undefined };
-    const result = formatTaskPlanCompact([noVerify]);
-    assert.ok(!result.includes("verify:"));
-  });
-
-  it("description is indented", () => {
-    const result = formatTaskPlanCompact([sampleTaskDone]);
-    assert.ok(result.includes("  Create tables for decisions and requirements"));
-  });
-
-  it("returns (none) for empty array", () => {
-    const result = formatTaskPlanCompact([]);
-    assert.ok(result.includes("(none)"));
-  });
-
-  it("formats single-item array with header", () => {
-    const result = formatTaskPlanCompact([sampleTaskDone]);
-    assert.ok(result.startsWith("# Tasks (compact)"));
-    // Only one task block
-    const blocks = result.split("\n\n");
-    assert.equal(blocks.length, 2);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// measureSavings
-// ---------------------------------------------------------------------------
-
-describe("structured-data-formatter: measureSavings", () => {
-  it("returns positive savings when compact is shorter", () => {
-    const compact = "short";
-    const markdown = "this is a much longer markdown version";
-    const savings = measureSavings(compact, markdown);
-    assert.ok(savings > 0, `expected positive savings, got ${savings}`);
-  });
-
-  it("returns 0 for empty markdown", () => {
-    assert.equal(measureSavings("anything", ""), 0);
-  });
-
-  it("returns negative when compact is longer", () => {
-    const compact = "this is somehow longer than the original";
-    const markdown = "tiny";
-    const savings = measureSavings(compact, markdown);
-    assert.ok(savings < 0, `expected negative savings, got ${savings}`);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Realistic token savings measurement
-// ---------------------------------------------------------------------------
-
-describe("structured-data-formatter: realistic savings", () => {
-  it("decisions compact format saves 30%+ vs markdown table", () => {
-    const decisions = [sampleDecision, sampleDecision2];
-
-    // Simulate a typical markdown table
-    const markdownTable = [
-      "| ID   | When       | Scope        | Decision                | Choice                 | Rationale                | Revisable |",
-      "|------|------------|--------------|-------------------------|------------------------|--------------------------|-----------|",
-      "| D001 | M001/S01   | architecture | Use SQLite for storage  | WAL mode, single-writer | Built-in, no external deps | yes       |",
-      "| D002 | M001/S02   | testing      | Unit test all parsers   | node:test framework    | Fast, zero-dependency    | no        |",
-    ].join("\n");
-
-    const compactOutput = formatDecisionsCompact(decisions);
-    const savings = measureSavings(compactOutput, markdownTable);
-    assert.ok(
-      savings >= 30,
-      `expected >=30% savings, got ${savings.toFixed(1)}%`,
-    );
-  });
-
-  it("requirements compact format saves 30%+ vs markdown sections", () => {
-    const requirements = [sampleRequirement, sampleRequirement2];
-
-    // Simulate verbose markdown format with all fields
-    const markdownSections = [
-      "## R001",
-      "",
-      "- **Class:** functional",
-      "- **Status:** active",
-      "- **Description:** Response latency < 200ms for API endpoints",
-      "- **Why:** Critical for user experience",
-      "- **Source:** architecture review",
-      "- **Primary Owner:** S01",
-      "- **Supporting Slices:** S02, S03",
-      "- **Validation:** Load test confirms P99 < 200ms",
-      "- **Notes:** Monitor in production",
-      "",
-      "## R002",
-      "",
-      "- **Class:** non-functional",
-      "- **Status:** active",
-      "- **Description:** Data consistency across writes",
-      "- **Why:** Prevents data loss",
-      "- **Source:** data team review",
-      "- **Primary Owner:** S02",
-      "- **Supporting Slices:** S01",
-      "- **Validation:** Integration test suite",
-      "- **Notes:** Requires WAL mode",
-    ].join("\n");
-
-    const compactOutput = formatRequirementsCompact(requirements);
-    const savings = measureSavings(compactOutput, markdownSections);
-    assert.ok(
-      savings >= 30,
-      `expected >=30% savings, got ${savings.toFixed(1)}%`,
-    );
-  });
-
-  it("task plan compact format saves 30%+ vs markdown sections", () => {
-    const tasks = [sampleTaskDone, sampleTaskPending];
-
-    // Simulate verbose markdown task format
-    const markdownTasks = [
-      "## T01 - Database schema",
-      "",
-      "- **Status:** Done",
-      "- **Estimate:** 30m",
-      "- **Description:** Create tables for decisions and requirements",
-      "- **Files:**",
-      "  - src/db.ts",
-      "  - src/schema.ts",
-      "",
-      "## T02 - API endpoints",
-      "",
-      "- **Status:** Pending",
-      "- **Estimate:** 1h",
-      "- **Description:** REST endpoints for CRUD operations",
-      "- **Files:**",
-      "  - src/api.ts",
-      "- **Verify:** npm test",
-    ].join("\n");
-
-    const compactOutput = formatTaskPlanCompact(tasks);
-    const savings = measureSavings(compactOutput, markdownTasks);
-    assert.ok(
-      savings >= 30,
-      `expected >=30% savings, got ${savings.toFixed(1)}%`,
-    );
-  });
-});