gsd-pi 2.28.0 → 2.29.0-dev.2ccf3fb

package/dist/resources/extensions/gsd/tests/token-optimization-prefs.test.ts

@@ -0,0 +1,164 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+
+// Test the type definitions exist and are correct
+describe("token-optimization: types", () => {
+  it("CompressionStrategy accepts valid values", async () => {
+    const { } = await import("../types.js");
+    // Type-level test — if this compiles, the types exist
+    const truncate: import("../types.js").CompressionStrategy = "truncate";
+    const compress: import("../types.js").CompressionStrategy = "compress";
+    assert.equal(truncate, "truncate");
+    assert.equal(compress, "compress");
+  });
+
+  it("ContextSelectionMode accepts valid values", async () => {
+    const full: import("../types.js").ContextSelectionMode = "full";
+    const smart: import("../types.js").ContextSelectionMode = "smart";
+    assert.equal(full, "full");
+    assert.equal(smart, "smart");
+  });
+});
+
+// Test cache hit rate computation
+describe("token-optimization: cache hit rate", () => {
+  it("computeCacheHitRate returns correct percentage", async () => {
+    const { computeCacheHitRate } = await import("../prompt-cache-optimizer.js");
+    assert.equal(computeCacheHitRate({ cacheRead: 900, cacheWrite: 100, input: 100 }), 90);
+    assert.equal(computeCacheHitRate({ cacheRead: 0, cacheWrite: 0, input: 100 }), 0);
+    assert.equal(computeCacheHitRate({ cacheRead: 0, cacheWrite: 0, input: 0 }), 0);
+    assert.equal(computeCacheHitRate({ cacheRead: 500, cacheWrite: 0, input: 500 }), 50);
+  });
+});
+
+// Test structured data savings
+describe("token-optimization: structured data savings", () => {
+  it("compact decisions format is shorter than markdown table", async () => {
+    const { formatDecisionsCompact, measureSavings } = await import("../structured-data-formatter.js");
+    const decisions = [
+      { id: "D001", when_context: "M001/S01", scope: "architecture", decision: "Use SQLite for storage", choice: "WAL mode", rationale: "Built-in, no external deps", revisable: "yes" },
+      { id: "D002", when_context: "M001/S02", scope: "testing", decision: "Unit test all parsers", choice: "node:test", rationale: "Fast, zero-dependency", revisable: "no" },
+    ];
+    const compact = formatDecisionsCompact(decisions);
+    // A realistic markdown table equivalent
+    const markdown = [
+      "| # | When | Scope | Decision | Choice | Rationale | Revisable? |",
+      "|---|------|-------|----------|--------|-----------|------------|",
+      "| D001 | M001/S01 | architecture | Use SQLite for storage | WAL mode | Built-in, no external deps | yes |",
+      "| D002 | M001/S02 | testing | Unit test all parsers | node:test | Fast, zero-dependency | no |",
+    ].join("\n");
+    const savings = measureSavings(compact, markdown);
+    assert.ok(savings > 10, `Expected >10% savings, got ${savings}%`);
+  });
+
+  it("compact requirements format drops low-value fields", async () => {
+    const { formatRequirementsCompact } = await import("../structured-data-formatter.js");
+    const requirements = [{
+      id: "R001", class: "functional", status: "active",
+      description: "API response time < 200ms",
+      why: "User experience", primary_owner: "S01",
+      validation: "Load test P99 < 200ms",
+    }];
+    const compact = formatRequirementsCompact(requirements);
+    assert.ok(!compact.includes("source"), "Should not include source field");
+    assert.ok(!compact.includes("supporting_slices"), "Should not include supporting_slices");
+    assert.ok(compact.includes("R001"), "Should include requirement ID");
+  });
+});
+
+// Test compression levels
+describe("token-optimization: prompt compression", () => {
+  it("light compression removes extra whitespace", async () => {
+    const { compressPrompt } = await import("../prompt-compressor.js");
+    const input = "Line 1\n\n\n\n\nLine 2\n\n\n\nLine 3";
+    const result = compressPrompt(input, { level: "light" });
+    assert.ok(result.savingsPercent > 0, "Should have positive savings");
+    assert.ok(!result.content.includes("\n\n\n"), "Should collapse multiple blank lines");
+  });
+
+  it("moderate compression abbreviates verbose phrases", async () => {
+    const { compressPrompt } = await import("../prompt-compressor.js");
+    const input = "In order to achieve this, it is important to note that the following steps are required.";
+    const result = compressPrompt(input, { level: "moderate" });
+    assert.ok(result.compressedChars < result.originalChars, "Should be shorter");
+  });
+
+  it("code blocks are preserved during compression", async () => {
+    const { compressPrompt } = await import("../prompt-compressor.js");
+    const input = "In order to do this:\n\n```typescript\nconst x = 1;\n```\n\nIn order to verify:";
+    const result = compressPrompt(input, { level: "aggressive" });
+    assert.ok(result.content.includes("const x = 1;"), "Code block should be preserved");
+  });
+});
+
+// Test summary distillation
+describe("token-optimization: summary distillation", () => {
+  it("distills summaries preserving key fields", async () => {
+    const { distillSummaries } = await import("../summary-distiller.js");
+    const summary = `---
+id: S01
+provides:
+  - Core types
+key_files:
+  - src/types.ts
+key_decisions:
+  - D001
+---
+
+# S01: Core Types
+
+Built the foundation type system.
+
+## What Happened
+
+Long prose about implementation details that should be dropped...
+`;
+    const result = distillSummaries([summary], 5000);
+    assert.ok(result.savingsPercent > 0, "Should have savings");
+    assert.ok(result.content.includes("Core types"), "Should preserve provides");
+    assert.ok(result.content.includes("src/types.ts"), "Should preserve key_files");
+  });
+});
+
+// Test semantic chunker
+describe("token-optimization: semantic chunking", () => {
+  it("chunks TypeScript code at function boundaries", async () => {
+    const { splitIntoChunks } = await import("../semantic-chunker.js");
+    const code = `export function alpha() {
+  return 1;
+}
+
+export function beta() {
+  return 2;
+}
+
+export function gamma() {
+  return 3;
+}`;
+    const chunks = splitIntoChunks(code);
+    assert.ok(chunks.length >= 2, `Expected >=2 chunks, got ${chunks.length}`);
+  });
+
+  it("scores chunks by relevance to query", async () => {
+    const { chunkByRelevance } = await import("../semantic-chunker.js");
+    const code = `export function createUser(name: string) {
+  return { name, id: generateId() };
+}
+
+export function deleteDatabase() {
+  dropAllTables();
+  clearCache();
+}
+
+export function updateUser(id: string, name: string) {
+  const user = findUser(id);
+  user.name = name;
+  return user;
+}`;
+    const result = chunkByRelevance(code, "user creation and management", { maxChunks: 2 });
+    // The user-related chunks should score higher
+    const content = result.chunks.map(c => c.content).join("\n");
+    assert.ok(content.includes("createUser") || content.includes("updateUser"),
+      "Should include user-related chunks");
+  });
+});

package/dist/resources/extensions/gsd/tests/token-profile.test.ts

@@ -18,9 +18,16 @@ import { fileURLToPath } from "node:url";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
 // ─── Source files for structural checks ───────────────────────────────────
+// After decomposition, code lives across multiple modules. Concatenate them
+// so structural string-matching works regardless of which file holds the code.
 
 const dispatchSrc = readFileSync(join(__dirname, "..", "auto-dispatch.ts"), "utf-8");
-const preferencesSrc = readFileSync(join(__dirname, "..", "preferences.ts"), "utf-8");
+const preferencesSrc = [
+  readFileSync(join(__dirname, "..", "preferences.ts"), "utf-8"),
+  readFileSync(join(__dirname, "..", "preferences-types.ts"), "utf-8"),
+  readFileSync(join(__dirname, "..", "preferences-models.ts"), "utf-8"),
+  readFileSync(join(__dirname, "..", "preferences-validation.ts"), "utf-8"),
+].join("\n");
 const typesSrc = readFileSync(join(__dirname, "..", "types.ts"), "utf-8");
 
 // ═══════════════════════════════════════════════════════════════════════════

package/dist/resources/extensions/gsd/tests/triage-dispatch.test.ts

@@ -2,8 +2,9 @@
  * Triage dispatch ordering contract tests.
  *
  * These tests verify structural invariants of the triage integration
- * by inspecting the actual source code of auto.ts and post-unit-hooks.ts.
- * Full behavioral testing requires the @gsd/pi-coding-agent runtime.
+ * by inspecting the actual source code of auto-post-unit.ts, auto.ts,
+ * and post-unit-hooks.ts. Full behavioral testing requires the
+ * @gsd/pi-coding-agent runtime.
  */
 
 import test from "node:test";
@@ -13,18 +14,23 @@ import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const autoPath = join(__dirname, "..", "auto.ts");
 const hooksPath = join(__dirname, "..", "post-unit-hooks.ts");
 const autoPromptsPath = join(__dirname, "..", "auto-prompts.ts");
 
-const autoSrc = readFileSync(autoPath, "utf-8");
+// After decomposition, triage/dispatch logic lives in auto-post-unit.ts
+const postUnitSrc = readFileSync(join(__dirname, "..", "auto-post-unit.ts"), "utf-8");
+// auto.ts retains top-level orchestration and imports
+const autoSrc = [
+  readFileSync(join(__dirname, "..", "auto.ts"), "utf-8"),
+  postUnitSrc,
+  readFileSync(join(__dirname, "..", "auto-start.ts"), "utf-8"),
+].join("\n");
 const hooksSrc = readFileSync(hooksPath, "utf-8");
 const autoPromptsSrc = (() => { try { return readFileSync(autoPromptsPath, "utf-8"); } catch { return autoSrc; } })();
 
 // ─── Hook exclusion ──────────────────────────────────────────────────────────
 
 test("dispatch: triage-captures excluded from post-unit hook triggering", () => {
-  // post-unit-hooks.ts must return null for triage-captures unit type
   assert.ok(
     hooksSrc.includes('"triage-captures"'),
     "post-unit-hooks.ts should reference triage-captures",
@@ -38,32 +44,30 @@ test("dispatch: triage-captures excluded from post-unit hook triggering", () =>
 // ─── Triage check placement ──────────────────────────────────────────────────
 
 test("dispatch: triage check appears after hook section and before stepMode check", () => {
-  const hookRetryIndex = autoSrc.indexOf("isRetryPending()");
-  // Find the triage check in handleAgentEnd (not in getAutoDashboardData)
-  const triageCheckIndex = autoSrc.indexOf("Triage check: dispatch triage unit");
-  const stepModeIndex = autoSrc.indexOf("In step mode, pause and show a wizard");
+  const triageCheckIndex = postUnitSrc.indexOf("// ── Triage check");
+  const quickTaskIndex = postUnitSrc.indexOf("// ── Quick-task dispatch");
+  const stepModeIndex = postUnitSrc.indexOf("if (s.stepMode)");
 
-  assert.ok(hookRetryIndex > 0, "hook retry check should exist");
   assert.ok(triageCheckIndex > 0, "triage check block should exist");
+  assert.ok(quickTaskIndex > 0, "quick-task dispatch block should exist");
   assert.ok(stepModeIndex > 0, "step mode check should exist");
 
   assert.ok(
-    triageCheckIndex > hookRetryIndex,
-    "triage check should come after hook retry check",
+    triageCheckIndex < quickTaskIndex,
+    "triage check should come before quick-task dispatch",
   );
   assert.ok(
-    triageCheckIndex < stepModeIndex,
-    "triage check should come before stepMode check",
+    quickTaskIndex < stepModeIndex,
+    "quick-task dispatch should come before stepMode check",
   );
 });
 
 // ─── Guard conditions ────────────────────────────────────────────────────────
 
 test("dispatch: triage check guards against step mode", () => {
-  // The triage block should check !stepMode
-  const triageBlock = autoSrc.slice(
-    autoSrc.indexOf("Triage check: dispatch triage unit"),
-    autoSrc.indexOf("In step mode, pause and show a wizard"),
+  const triageBlock = postUnitSrc.slice(
+    postUnitSrc.indexOf("// ── Triage check"),
+    postUnitSrc.indexOf("// ── Quick-task dispatch"),
   );
   assert.ok(
     triageBlock.includes("!s.stepMode"),
@@ -72,9 +76,9 @@ test("dispatch: triage check guards against step mode", () => {
 });
 
 test("dispatch: triage check guards against hook unit types", () => {
-  const triageBlock = autoSrc.slice(
-    autoSrc.indexOf("Triage check: dispatch triage unit"),
-    autoSrc.indexOf("In step mode, pause and show a wizard"),
+  const triageBlock = postUnitSrc.slice(
+    postUnitSrc.indexOf("// ── Triage check"),
+    postUnitSrc.indexOf("// ── Quick-task dispatch"),
   );
   assert.ok(
     triageBlock.includes('!s.currentUnit.type.startsWith("hook/")'),
@@ -83,9 +87,9 @@ test("dispatch: triage check guards against hook unit types", () => {
 });
 
 test("dispatch: triage check guards against triage-on-triage", () => {
-  const triageBlock = autoSrc.slice(
-    autoSrc.indexOf("Triage check: dispatch triage unit"),
-    autoSrc.indexOf("In step mode, pause and show a wizard"),
+  const triageBlock = postUnitSrc.slice(
+    postUnitSrc.indexOf("// ── Triage check"),
+    postUnitSrc.indexOf("// ── Quick-task dispatch"),
   );
   assert.ok(
     triageBlock.includes('s.currentUnit.type !== "triage-captures"'),
@@ -94,9 +98,9 @@ test("dispatch: triage check guards against triage-on-triage", () => {
 });
 
 test("dispatch: triage check guards against quick-task triggering triage", () => {
-  const triageBlock = autoSrc.slice(
-    autoSrc.indexOf("Triage check: dispatch triage unit"),
-    autoSrc.indexOf("In step mode, pause and show a wizard"),
+  const triageBlock = postUnitSrc.slice(
+    postUnitSrc.indexOf("// ── Triage check"),
+    postUnitSrc.indexOf("// ── Quick-task dispatch"),
   );
   assert.ok(
     triageBlock.includes('s.currentUnit.type !== "quick-task"'),
@@ -104,22 +108,25 @@ test("dispatch: triage check guards against quick-task triggering triage", () =>
   );
 });
 
-test("dispatch: triage dispatch uses early-return pattern", () => {
-  const triageBlock = autoSrc.slice(
-    autoSrc.indexOf("Triage check: dispatch triage unit"),
-    autoSrc.indexOf("In step mode, pause and show a wizard"),
+test("dispatch: triage dispatch uses return-value pattern", () => {
+  const triageBlock = postUnitSrc.slice(
+    postUnitSrc.indexOf("// ── Triage check"),
+    postUnitSrc.indexOf("// ── Quick-task dispatch"),
   );
   assert.ok(
-    triageBlock.includes("return; // handleAgentEnd will fire again"),
-    "triage dispatch should return after sending message",
+    triageBlock.includes('return "dispatched"'),
+    "triage dispatch should return 'dispatched' after sending message",
   );
 });
 
 test("dispatch: triage imports hasPendingCaptures and loadPendingCaptures", () => {
   assert.ok(
-    autoSrc.includes('hasPendingCaptures, loadPendingCaptures, countPendingCaptures') &&
+    autoSrc.includes("hasPendingCaptures") && autoSrc.includes("loadPendingCaptures"),
+    "should import capture functions",
+  );
+  assert.ok(
     autoSrc.includes('from "./captures.js"'),
-    "auto.ts should import capture functions including countPendingCaptures",
+    "should import from captures module",
   );
 });
 
@@ -226,49 +233,45 @@ test("dashboard: overlay labels triage-captures and quick-task unit types", () =
 // ─── Post-triage resolution execution ─────────────────────────────────────────
 
 test("dispatch: post-triage resolution executor fires after triage-captures unit", () => {
-  const triageCompletionBlock = autoSrc.slice(
-    autoSrc.indexOf("Post-triage: execute actionable resolutions"),
-    autoSrc.indexOf("Path A fix: verify artifact"),
+  const postTriageBlock = postUnitSrc.slice(
+    postUnitSrc.indexOf("Post-triage: execute actionable resolutions"),
   );
   assert.ok(
-    triageCompletionBlock.includes('s.currentUnit.type === "triage-captures"'),
+    postTriageBlock.includes('s.currentUnit.type === "triage-captures"'),
     "should check for triage-captures unit completion",
   );
   assert.ok(
-    triageCompletionBlock.includes("executeTriageResolutions"),
+    postTriageBlock.includes("executeTriageResolutions"),
     "should call executeTriageResolutions",
   );
 });
 
 test("dispatch: post-triage executor handles inject results", () => {
-  const triageCompletionBlock = autoSrc.slice(
-    autoSrc.indexOf("Post-triage: execute actionable resolutions"),
-    autoSrc.indexOf("Path A fix: verify artifact"),
+  const postTriageBlock = postUnitSrc.slice(
+    postUnitSrc.indexOf("Post-triage: execute actionable resolutions"),
   );
   assert.ok(
-    triageCompletionBlock.includes("triageResult.injected"),
+    postTriageBlock.includes("triageResult.injected"),
     "should check injected count",
   );
 });
 
 test("dispatch: post-triage executor handles replan results", () => {
-  const triageCompletionBlock = autoSrc.slice(
-    autoSrc.indexOf("Post-triage: execute actionable resolutions"),
-    autoSrc.indexOf("Path A fix: verify artifact"),
+  const postTriageBlock = postUnitSrc.slice(
+    postUnitSrc.indexOf("Post-triage: execute actionable resolutions"),
   );
   assert.ok(
-    triageCompletionBlock.includes("triageResult.replanned"),
+    postTriageBlock.includes("triageResult.replanned"),
     "should check replanned count",
   );
 });
 
 test("dispatch: post-triage executor queues quick-tasks", () => {
-  const triageCompletionBlock = autoSrc.slice(
-    autoSrc.indexOf("Post-triage: execute actionable resolutions"),
-    autoSrc.indexOf("Path A fix: verify artifact"),
+  const postTriageBlock = postUnitSrc.slice(
+    postUnitSrc.indexOf("Post-triage: execute actionable resolutions"),
   );
   assert.ok(
-    triageCompletionBlock.includes("s.pendingQuickTasks"),
+    postTriageBlock.includes("s.pendingQuickTasks"),
     "should push quick-tasks to s.pendingQuickTasks queue",
   );
 });
@@ -276,25 +279,19 @@ test("dispatch: post-triage executor queues quick-tasks", () => {
 // ─── Quick-task dispatch ──────────────────────────────────────────────────────
 
 test("dispatch: quick-task dispatch block exists after triage check", () => {
-  const quickTaskBlock = autoSrc.indexOf("Quick-task dispatch: execute queued quick-tasks");
-  const triageBlock = autoSrc.indexOf("Triage check: dispatch triage unit");
-  const stepModeBlock = autoSrc.indexOf("In step mode, pause and show a wizard");
+  const quickTaskBlock = postUnitSrc.indexOf("// ── Quick-task dispatch");
+  const triageBlock = postUnitSrc.indexOf("// ── Triage check");
 
   assert.ok(quickTaskBlock > 0, "quick-task dispatch block should exist");
   assert.ok(
     quickTaskBlock > triageBlock,
     "quick-task dispatch should come after triage check",
   );
-  assert.ok(
-    quickTaskBlock < stepModeBlock,
-    "quick-task dispatch should come before step mode check",
-  );
 });
 
 test("dispatch: quick-task dispatch uses buildQuickTaskPrompt", () => {
-  const quickTaskSection = autoSrc.slice(
-    autoSrc.indexOf("Quick-task dispatch: execute queued quick-tasks"),
-    autoSrc.indexOf("In step mode, pause and show a wizard"),
+  const quickTaskSection = postUnitSrc.slice(
+    postUnitSrc.indexOf("// ── Quick-task dispatch"),
   );
   assert.ok(
     quickTaskSection.includes("buildQuickTaskPrompt"),
@@ -303,9 +300,8 @@ test("dispatch: quick-task dispatch uses buildQuickTaskPrompt", () => {
 });
 
 test("dispatch: quick-task dispatch marks capture as executed", () => {
-  const quickTaskSection = autoSrc.slice(
-    autoSrc.indexOf("Quick-task dispatch: execute queued quick-tasks"),
-    autoSrc.indexOf("In step mode, pause and show a wizard"),
+  const quickTaskSection = postUnitSrc.slice(
+    postUnitSrc.indexOf("// ── Quick-task dispatch"),
   );
   assert.ok(
     quickTaskSection.includes("markCaptureExecuted"),
@@ -313,14 +309,14 @@ test("dispatch: quick-task dispatch marks capture as executed", () => {
   );
 });
 
-test("dispatch: quick-task dispatch uses early-return pattern", () => {
-  const quickTaskSection = autoSrc.slice(
-    autoSrc.indexOf("Quick-task dispatch: execute queued quick-tasks"),
-    autoSrc.indexOf("In step mode, pause and show a wizard"),
+test("dispatch: quick-task dispatch uses return-value pattern", () => {
+  const quickTaskSection = postUnitSrc.slice(
+    postUnitSrc.indexOf("// ── Quick-task dispatch"),
+    postUnitSrc.indexOf("if (s.stepMode)"),
   );
   assert.ok(
-    quickTaskSection.includes("return; // handleAgentEnd will fire again when quick-task session completes"),
-    "quick-task dispatch should return after sending message",
+    quickTaskSection.includes('return "dispatched"'),
+    "quick-task dispatch should return 'dispatched' after sending message",
   );
 });
 
@@ -338,7 +334,7 @@ test("dispatch: quick-task excluded from post-unit hook triggering", () => {
 test("dispatch: pendingQuickTasks queue is reset on auto-mode start/stop", () => {
   const resetMatches = autoSrc.match(/s\.pendingQuickTasks = \[\]/g);
   assert.ok(
-    resetMatches && resetMatches.length >= 3,
-    "s.pendingQuickTasks should be reset in at least 3 places (start, stop, manual hook)",
+    resetMatches && resetMatches.length >= 2,
+    "s.pendingQuickTasks should be reset in start and stop paths",
   );
 });