lsd-pi 1.0.0 → 1.1.0

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

@@ -1,366 +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 | agent",
-    );
-  });
-
-  it("includes all fields in the correct order", () => {
-    const result = formatDecisionCompact(sampleDecision);
-    const parts = result.split(" | ");
-    assert.equal(parts.length, 8);
-    assert.equal(parts[0], "D001");
-    assert.equal(parts[6], "yes");
-    assert.equal(parts[7], "agent");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// 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 | made_by"));
-  });
-
-  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)}%`,
-    );
-  });
-});

package/src/resources/extensions/gsd/tests/stuck-detection-coverage.test.ts

@@ -1,174 +0,0 @@
-// GSD State Machine Regression Tests — Stuck Detection Coverage (#3161)
-
-import test from "node:test";
-import assert from "node:assert/strict";
-
-import { detectStuck } from "../auto/detect-stuck.ts";
-
-// ─── Baseline: window too small ──────────────────────────────────────────────
-
-test("returns null for empty window", () => {
-  assert.equal(detectStuck([]), null);
-});
-
-test("returns null for single entry", () => {
-  assert.equal(detectStuck([{ key: "A" }]), null);
-});
-
-test("returns null for two different entries without errors", () => {
-  assert.equal(detectStuck([{ key: "A" }, { key: "B" }]), null);
-});
-
-// ─── Rule 1: Same error repeated consecutively ───────────────────────────────
-
-test("Rule 1: same error twice consecutively triggers stuck", () => {
-  const result = detectStuck([
-    { key: "A", error: "ENOENT: no such file" },
-    { key: "A", error: "ENOENT: no such file" },
-  ]);
-  assert.notEqual(result, null);
-  assert.equal(result!.stuck, true);
-  assert.ok(result!.reason.includes("Same error"), `reason was: ${result!.reason}`);
-});
-
-test("Rule 1: different errors do not trigger stuck", () => {
-  // Only 2 entries with different errors — Rule 2 needs 3 entries, so null.
-  const result = detectStuck([
-    { key: "A", error: "err1" },
-    { key: "A", error: "err2" },
-  ]);
-  assert.equal(result, null);
-});
-
-test("Rule 1: only last two entries matter for error check", () => {
-  // First two share an error, but the last two have distinct errors — no trigger.
-  const result = detectStuck([
-    { key: "A", error: "same-error" },
-    { key: "A", error: "same-error" },
-    { key: "B", error: "different-error-1" },
-    { key: "C", error: "different-error-2" },
-  ]);
-  assert.equal(result, null);
-});
-
-// ─── Rule 2: Same unit key 3+ consecutive times ───────────────────────────────
-
-test("Rule 2: same unit key 3 consecutive times triggers stuck", () => {
-  const result = detectStuck([
-    { key: "A" },
-    { key: "A" },
-    { key: "A" },
-  ]);
-  assert.notEqual(result, null);
-  assert.equal(result!.stuck, true);
-  assert.ok(
-    result!.reason.includes("3 consecutive times"),
-    `reason was: ${result!.reason}`,
-  );
-});
-
-test("Rule 2: same key twice is not enough", () => {
-  assert.equal(detectStuck([{ key: "A" }, { key: "A" }]), null);
-});
-
-test("Rule 2: interrupted sequence does not trigger", () => {
-  // A, B, A — last three are not all the same key.
-  assert.equal(
-    detectStuck([{ key: "A" }, { key: "B" }, { key: "A" }]),
-    null,
-  );
-});
-
-// ─── Rule 3: Oscillation A→B→A→B ─────────────────────────────────────────────
-
-test("Rule 3: A-B-A-B oscillation triggers stuck", () => {
-  const result = detectStuck([
-    { key: "A" },
-    { key: "B" },
-    { key: "A" },
-    { key: "B" },
-  ]);
-  assert.notEqual(result, null);
-  assert.equal(result!.stuck, true);
-  assert.ok(
-    result!.reason.includes("Oscillation"),
-    `reason was: ${result!.reason}`,
-  );
-});
-
-test("Rule 3: A-B-A-C does not trigger oscillation", () => {
-  assert.equal(
-    detectStuck([{ key: "A" }, { key: "B" }, { key: "A" }, { key: "C" }]),
-    null,
-  );
-});
-
-test("Rule 3: A-A-A-A triggers Rule 2 not Rule 3", () => {
-  // Rule 2 fires first (last 3 are all the same key).
-  const result = detectStuck([
-    { key: "A" },
-    { key: "A" },
-    { key: "A" },
-    { key: "A" },
-  ]);
-  assert.notEqual(result, null);
-  assert.equal(result!.stuck, true);
-  assert.ok(
-    result!.reason.includes("3 consecutive times"),
-    `expected Rule 2 reason but got: ${result!.reason}`,
-  );
-  assert.ok(
-    !result!.reason.includes("Oscillation"),
-    `unexpectedly matched Rule 3: ${result!.reason}`,
-  );
-});
-
-// ─── Gap documentation: 3-unit cycle evades detection ────────────────────────
-
-test("Three-unit cycle A-B-C-A-B-C does NOT trigger stuck (documents gap L13)", () => {
-  // None of the three rules fires for a 3-unit repeating cycle.
-  // This test intentionally documents the coverage gap where such cycles
-  // slip through undetected (#3161).
-  const result = detectStuck([
-    { key: "A" },
-    { key: "B" },
-    { key: "C" },
-    { key: "A" },
-    { key: "B" },
-    { key: "C" },
-  ]);
-  assert.equal(result, null);
-});
-
-// ─── Window boundary: earlier patterns do not contaminate recent check ─────────
-
-test("window bounded: detection uses last N entries correctly", () => {
-  // The first three entries would trigger Rule 2, but the last entries are
-  // healthy — only the tail matters.
-  const result = detectStuck([
-    { key: "X" },
-    { key: "X" },
-    { key: "X" }, // would be stuck if this were the end
-    { key: "A" },
-    { key: "B" }, // last two: different keys, no error
-  ]);
-  assert.equal(result, null);
-});
-
-// ─── Rule priority: Rule 1 before Rule 2 ─────────────────────────────────────
-
-test("Rule 1 takes priority over Rule 2 when both match", () => {
-  // Last 3 entries share the same key (Rule 2 candidate) AND last 2 share
-  // the same error (Rule 1 candidate). Rule 1 is evaluated first.
-  const result = detectStuck([
-    { key: "A", error: "boom" },
-    { key: "A", error: "boom" },
-    { key: "A", error: "boom" },
-  ]);
-  assert.notEqual(result, null);
-  assert.equal(result!.stuck, true);
-  assert.ok(
-    result!.reason.includes("Same error"),
-    `expected Rule 1 reason but got: ${result!.reason}`,
-  );
-});

package/src/resources/extensions/gsd/tests/subagent-agent-discovery.test.ts

@@ -1,44 +0,0 @@
-import assert from "node:assert/strict";
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import test from "node:test";
-
-import { discoverAgents } from "../../subagent/agents.ts";
-
-function makeProjectRoot(t: test.TestContext): string {
-	const root = mkdtempSync(join(tmpdir(), "gsd-subagent-agents-"));
-	t.after(() => rmSync(root, { recursive: true, force: true }));
-	return root;
-}
-
-function writeAgent(root: string, configDirName: ".gsd" | ".pi", name = "ping"): string {
-	const agentsDir = join(root, configDirName, "agents");
-	mkdirSync(agentsDir, { recursive: true });
-	writeFileSync(
-		join(agentsDir, `${name}.md`),
-		`---\nname: ${name}\ndescription: ${name} agent\n---\nSay hello\n`,
-	);
-	return agentsDir;
-}
-
-test("discoverAgents finds project agents in .gsd/agents", (t) => {
-	const root = makeProjectRoot(t);
-	const agentsDir = writeAgent(root, ".gsd");
-
-	const discovery = discoverAgents(root, "project");
-
-	assert.equal(discovery.projectAgentsDir, agentsDir);
-	assert.deepEqual(discovery.agents.map((agent) => agent.name), ["ping"]);
-	assert.equal(discovery.agents[0]?.source, "project");
-});
-
-test("discoverAgents falls back to legacy .pi/agents when needed", (t) => {
-	const root = makeProjectRoot(t);
-	const agentsDir = writeAgent(root, ".pi");
-
-	const discovery = discoverAgents(root, "project");
-
-	assert.equal(discovery.projectAgentsDir, agentsDir);
-	assert.deepEqual(discovery.agents.map((agent) => agent.name), ["ping"]);
-});