gsd-pi 2.68.0 → 2.68.1-dev.abc8f2b

package/src/resources/extensions/gsd/tests/tool-compatibility.test.ts

@@ -0,0 +1,199 @@
+// GSD-2 — Tool Compatibility + Model Router Tool Filtering Tests (ADR-005 Phases 2-3)
+import { describe, test, beforeEach } from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  registerToolCompatibility,
+  getToolCompatibility,
+  getAllToolCompatibility,
+  registerMcpToolCompatibility,
+  resetToolCompatibilityRegistry,
+} from "@gsd/pi-coding-agent";
+
+import {
+  isToolCompatibleWithProvider,
+  filterToolsForProvider,
+  adjustToolSet,
+} from "../model-router.js";
+
+import {
+  getProviderCapabilities,
+} from "@gsd/pi-ai";
+
+// ─── Tool Compatibility Registry ────────────────────────────────────────────
+
+describe("tool compatibility registry", () => {
+  beforeEach(() => {
+    resetToolCompatibilityRegistry();
+  });
+
+  test("built-in tools are pre-registered", () => {
+    const builtins = ["bash", "read", "write", "edit", "grep", "find", "ls", "lsp"];
+    for (const name of builtins) {
+      const compat = getToolCompatibility(name);
+      assert.ok(compat !== undefined, `${name} should be pre-registered`);
+    }
+  });
+
+  test("unknown tool returns undefined", () => {
+    assert.equal(getToolCompatibility("nonexistent_tool_xyz"), undefined);
+  });
+
+  test("registerToolCompatibility stores and retrieves metadata", () => {
+    registerToolCompatibility("screenshot_tool", {
+      producesImages: true,
+      minCapabilityTier: "standard",
+    });
+    const compat = getToolCompatibility("screenshot_tool");
+    assert.ok(compat);
+    assert.equal(compat.producesImages, true);
+    assert.equal(compat.minCapabilityTier, "standard");
+  });
+
+  test("registerMcpToolCompatibility sets default schema features", () => {
+    registerMcpToolCompatibility("mcp__test__tool");
+    const compat = getToolCompatibility("mcp__test__tool");
+    assert.ok(compat);
+    assert.ok(compat.schemaFeatures?.includes("patternProperties"));
+  });
+
+  test("registerMcpToolCompatibility allows overrides", () => {
+    registerMcpToolCompatibility("mcp__test__override", { producesImages: true });
+    const compat = getToolCompatibility("mcp__test__override");
+    assert.ok(compat);
+    assert.equal(compat.producesImages, true);
+    assert.ok(compat.schemaFeatures?.includes("patternProperties"));
+  });
+
+  test("getAllToolCompatibility returns all entries", () => {
+    const all = getAllToolCompatibility();
+    assert.ok(all.size >= 10); // at least built-in tools
+    assert.ok(all.has("bash"));
+    assert.ok(all.has("read"));
+  });
+
+  test("resetToolCompatibilityRegistry clears custom entries but keeps builtins", () => {
+    registerToolCompatibility("custom_tool", { producesImages: true });
+    assert.ok(getToolCompatibility("custom_tool"));
+    resetToolCompatibilityRegistry();
+    assert.equal(getToolCompatibility("custom_tool"), undefined);
+    assert.ok(getToolCompatibility("bash")); // built-in preserved
+  });
+});
+
+// ─── isToolCompatibleWithProvider ───────────────────────────────────────────
+
+describe("isToolCompatibleWithProvider", () => {
+  beforeEach(() => {
+    resetToolCompatibilityRegistry();
+  });
+
+  test("tool without compatibility metadata is always compatible", () => {
+    const caps = getProviderCapabilities("anthropic-messages");
+    assert.equal(isToolCompatibleWithProvider("unknown_tool", caps), true);
+  });
+
+  test("built-in tools are compatible with all providers", () => {
+    const providers = ["anthropic-messages", "openai-responses", "google-generative-ai", "mistral-conversations"];
+    const tools = ["bash", "read", "write", "edit"];
+    for (const api of providers) {
+      const caps = getProviderCapabilities(api);
+      for (const tool of tools) {
+        assert.equal(
+          isToolCompatibleWithProvider(tool, caps),
+          true,
+          `${tool} should be compatible with ${api}`,
+        );
+      }
+    }
+  });
+
+  test("image-producing tool filtered for providers without image support", () => {
+    registerToolCompatibility("screenshot", { producesImages: true });
+    const openaiCaps = getProviderCapabilities("openai-responses");
+    assert.equal(isToolCompatibleWithProvider("screenshot", openaiCaps), false);
+
+    const anthropicCaps = getProviderCapabilities("anthropic-messages");
+    assert.equal(isToolCompatibleWithProvider("screenshot", anthropicCaps), true);
+  });
+
+  test("tool with unsupported schema features filtered for Google", () => {
+    registerToolCompatibility("complex_schema_tool", {
+      schemaFeatures: ["patternProperties"],
+    });
+    const googleCaps = getProviderCapabilities("google-generative-ai");
+    assert.equal(isToolCompatibleWithProvider("complex_schema_tool", googleCaps), false);
+
+    const anthropicCaps = getProviderCapabilities("anthropic-messages");
+    assert.equal(isToolCompatibleWithProvider("complex_schema_tool", anthropicCaps), true);
+  });
+});
+
+// ─── filterToolsForProvider ─────────────────────────────────────────────────
+
+describe("filterToolsForProvider", () => {
+  beforeEach(() => {
+    resetToolCompatibilityRegistry();
+  });
+
+  test("all built-in tools pass for any provider", () => {
+    const toolNames = ["bash", "read", "write", "edit", "grep", "find", "ls"];
+    const { compatible, filtered } = filterToolsForProvider(toolNames, "mistral-conversations");
+    assert.deepEqual(compatible, toolNames);
+    assert.deepEqual(filtered, []);
+  });
+
+  test("image tool filtered for OpenAI Responses", () => {
+    registerToolCompatibility("browser_screenshot", { producesImages: true });
+    const toolNames = ["bash", "read", "browser_screenshot"];
+    const { compatible, filtered } = filterToolsForProvider(toolNames, "openai-responses");
+    assert.deepEqual(compatible, ["bash", "read"]);
+    assert.deepEqual(filtered, ["browser_screenshot"]);
+  });
+
+  test("MCP tool with patternProperties filtered for Google", () => {
+    registerMcpToolCompatibility("mcp__repowise__search");
+    const toolNames = ["bash", "read", "mcp__repowise__search"];
+    const { compatible, filtered } = filterToolsForProvider(toolNames, "google-generative-ai");
+    assert.deepEqual(compatible, ["bash", "read"]);
+    assert.deepEqual(filtered, ["mcp__repowise__search"]);
+  });
+
+  test("unknown provider passes all tools (permissive default)", () => {
+    registerToolCompatibility("image_tool", { producesImages: true });
+    registerMcpToolCompatibility("mcp_tool");
+    const toolNames = ["bash", "image_tool", "mcp_tool"];
+    const { compatible, filtered } = filterToolsForProvider(toolNames, "unknown-provider-xyz");
+    assert.deepEqual(compatible, toolNames);
+    assert.deepEqual(filtered, []);
+  });
+});
+
+// ─── adjustToolSet ──────────────────────────────────────────────────────────
+
+describe("adjustToolSet", () => {
+  beforeEach(() => {
+    resetToolCompatibilityRegistry();
+  });
+
+  test("returns all tools for Anthropic (most permissive)", () => {
+    registerToolCompatibility("screenshot", { producesImages: true });
+    const toolNames = ["bash", "read", "screenshot"];
+    const { toolNames: result, removedTools } = adjustToolSet(toolNames, "anthropic-messages");
+    assert.deepEqual(result, toolNames);
+    assert.deepEqual(removedTools, []);
+  });
+
+  test("removes incompatible tools and reports them", () => {
+    registerToolCompatibility("screenshot", { producesImages: true });
+    registerMcpToolCompatibility("mcp_complex");
+    const toolNames = ["bash", "read", "screenshot", "mcp_complex"];
+    const { toolNames: result, removedTools } = adjustToolSet(toolNames, "google-generative-ai");
+    // Google supports images but not patternProperties
+    assert.ok(result.includes("bash"));
+    assert.ok(result.includes("read"));
+    assert.ok(result.includes("screenshot")); // Google supports images
+    assert.ok(!result.includes("mcp_complex")); // patternProperties not supported
+    assert.deepEqual(removedTools, ["mcp_complex"]);
+  });
+});

package/src/resources/extensions/gsd/tests/write-gate.test.ts

@@ -230,16 +230,13 @@ import {
 // ─── Scenario 19: isGateQuestionId recognizes all gate patterns ──
 
 test('write-gate: isGateQuestionId recognizes all gate patterns', () => {
-  assert.strictEqual(isGateQuestionId('layer1_scope_gate'), true);
-  assert.strictEqual(isGateQuestionId('layer2_architecture_gate'), true);
-  assert.strictEqual(isGateQuestionId('layer3_error_gate'), true);
-  assert.strictEqual(isGateQuestionId('layer4_quality_gate'), true);
   assert.strictEqual(isGateQuestionId('depth_verification'), true);
   assert.strictEqual(isGateQuestionId('depth_verification_M002'), true);
-  assert.strictEqual(isGateQuestionId('my_layer1_scope_gate_question'), true);
+  assert.strictEqual(isGateQuestionId('depth_verification_confirm'), true);
   // Non-gate question IDs
   assert.strictEqual(isGateQuestionId('project_intent'), false);
   assert.strictEqual(isGateQuestionId('feature_priority'), false);
+  assert.strictEqual(isGateQuestionId('layer1_scope_gate'), false);
   assert.strictEqual(isGateQuestionId(''), false);
 });
 
@@ -249,14 +246,14 @@ test('write-gate: pending gate lifecycle (set, get, clear)', () => {
   clearDiscussionFlowState();
   assert.strictEqual(getPendingGate(), null, 'starts null');
 
-  setPendingGate('layer1_scope_gate');
-  assert.strictEqual(getPendingGate(), 'layer1_scope_gate', 'set correctly');
+  setPendingGate('depth_verification');
+  assert.strictEqual(getPendingGate(), 'depth_verification', 'set correctly');
 
   clearPendingGate();
   assert.strictEqual(getPendingGate(), null, 'cleared correctly');
 
   // clearDiscussionFlowState also clears pending gate
-  setPendingGate('layer2_architecture_gate');
+  setPendingGate('depth_verification_M002');
   clearDiscussionFlowState();
   assert.strictEqual(getPendingGate(), null, 'clearDiscussionFlowState clears pending gate');
 });
@@ -265,12 +262,12 @@ test('write-gate: pending gate lifecycle (set, get, clear)', () => {
 
 test('write-gate: shouldBlockPendingGate blocks write/edit during pending gate', () => {
   clearDiscussionFlowState();
-  setPendingGate('layer1_scope_gate');
+  setPendingGate('depth_verification');
 
   // write should be blocked during discussion
   const writeResult = shouldBlockPendingGate('write', 'M001', false);
   assert.strictEqual(writeResult.block, true, 'write should be blocked');
-  assert.ok(writeResult.reason!.includes('layer1_scope_gate'), 'reason mentions the gate');
+  assert.ok(writeResult.reason!.includes('depth_verification'), 'reason mentions the gate');
 
   // edit should be blocked
   const editResult = shouldBlockPendingGate('edit', 'M001', false);
@@ -287,7 +284,7 @@ test('write-gate: shouldBlockPendingGate blocks write/edit during pending gate',
 
 test('write-gate: shouldBlockPendingGate allows read-only and ask_user_questions during pending gate', () => {
   clearDiscussionFlowState();
-  setPendingGate('layer1_scope_gate');
+  setPendingGate('depth_verification');
 
   // ask_user_questions is always safe (model needs to re-ask)
   assert.strictEqual(shouldBlockPendingGate('ask_user_questions', 'M001').block, false);
@@ -304,7 +301,7 @@ test('write-gate: shouldBlockPendingGate allows read-only and ask_user_questions
 
 test('write-gate: shouldBlockPendingGate blocks outside discussion when a gate is pending', () => {
   clearDiscussionFlowState();
-  setPendingGate('layer1_scope_gate');
+  setPendingGate('depth_verification');
 
   // No milestoneId and no queue phase — still block because the gate is pending
   const result = shouldBlockPendingGate('write', null, false);
@@ -330,7 +327,7 @@ test('write-gate: shouldBlockPendingGate blocks in queue mode when gate is pendi
 
 test('write-gate: shouldBlockPendingGateBash allows read-only commands during pending gate', () => {
   clearDiscussionFlowState();
-  setPendingGate('layer2_architecture_gate');
+  setPendingGate('depth_verification');
 
   assert.strictEqual(shouldBlockPendingGateBash('cat file.txt', 'M001').block, false);
   assert.strictEqual(shouldBlockPendingGateBash('git log --oneline', 'M001').block, false);
@@ -344,11 +341,11 @@ test('write-gate: shouldBlockPendingGateBash allows read-only commands during pe
 
 test('write-gate: shouldBlockPendingGateBash blocks mutating commands during pending gate', () => {
   clearDiscussionFlowState();
-  setPendingGate('layer2_architecture_gate');
+  setPendingGate('depth_verification');
 
   const result = shouldBlockPendingGateBash('npm run build', 'M001');
   assert.strictEqual(result.block, true, 'mutating bash should be blocked');
-  assert.ok(result.reason!.includes('layer2_architecture_gate'));
+  assert.ok(result.reason!.includes('depth_verification'));
 
   clearDiscussionFlowState();
 });
@@ -365,7 +362,7 @@ test('write-gate: no pending gate means no blocking', () => {
 // ─── Scenario 28: resetWriteGateState clears pending gate ──
 
 test('write-gate: resetWriteGateState clears pending gate', () => {
-  setPendingGate('layer3_error_gate');
+  setPendingGate('depth_verification');
   resetWriteGateState();
   assert.strictEqual(getPendingGate(), null);
 });

package/dist/resources/extensions/gsd/prompt-validation.js

@@ -1,67 +0,0 @@
-/**
- * GSD Prompt Validation — Validates enhanced context output before writing.
- *
- * Implements R109 validation requirement: CONTEXT.md must have required sections
- * before being written to disk.
- */
-/**
- * Validate that enhanced context content has all required sections.
- *
- * Required sections per R109:
- * - Scope section (## Scope, ## Milestone Scope, or ## Why This Milestone)
- * - Architectural Decisions section (## Architectural Decisions)
- * - Acceptance Criteria section (## Acceptance Criteria or ## Final Integrated Acceptance)
- *
- * Additionally validates that the Architectural Decisions section contains
- * at least one decision entry (### heading or **Decision marker).
- *
- * @param content - The enhanced context markdown content
- * @returns ValidationResult with valid flag and list of missing sections
- */
-export function validateEnhancedContext(content) {
-    const missing = [];
-    // Required section 1: Scope (multiple acceptable header variants)
-    const hasScopeSection = /^## Scope\b/m.test(content) ||
-        /^## Milestone Scope\b/m.test(content) ||
-        /^## Why This Milestone\b/m.test(content);
-    if (!hasScopeSection) {
-        missing.push("Milestone Scope or Why This Milestone");
-    }
-    // Required section 2: Architectural Decisions
-    const hasArchitecturalDecisions = /^## Architectural Decisions\b/m.test(content);
-    if (!hasArchitecturalDecisions) {
-        missing.push("Architectural Decisions");
-    }
-    // Required section 3: Acceptance Criteria (multiple acceptable header variants)
-    const hasAcceptanceCriteria = /^## Acceptance Criteria\b/m.test(content) ||
-        /^## Final Integrated Acceptance\b/m.test(content);
-    if (!hasAcceptanceCriteria) {
-        missing.push("Acceptance Criteria");
-    }
-    // Additional validation: Architectural Decisions must have at least one entry
-    if (hasArchitecturalDecisions) {
-        // Extract the section content between ## Architectural Decisions and the next ## heading.
-        // Uses indexOf-based extraction instead of regex with \z (which is invalid in JavaScript
-        // regex — it's PCRE/Ruby syntax and JS treats it as literal 'z').
-        const sectionStart = content.indexOf("## Architectural Decisions");
-        if (sectionStart === -1) {
-            missing.push("Architectural Decisions");
-        }
-        else {
-            const afterHeading = content.slice(sectionStart + "## Architectural Decisions".length);
-            const nextSection = afterHeading.search(/^## /m);
-            const sectionContent = nextSection === -1 ? afterHeading : afterHeading.slice(0, nextSection);
-            // Check for actual decision entries:
-            // - ### heading (subsection per decision)
-            // - **Decision marker (inline decision format)
-            const hasDecisionEntry = /^### /m.test(sectionContent) || /^\*\*Decision/m.test(sectionContent);
-            if (!hasDecisionEntry) {
-                missing.push("At least one architectural decision entry");
-            }
-        }
-    }
-    return {
-        valid: missing.length === 0,
-        missing,
-    };
-}