fraim-framework 2.0.43 → 2.0.45

package/dist/tests/test-ai-coach-mcp-integration.js

@@ -0,0 +1,432 @@
+"use strict";
+/**
+ * Tests for AI Coach MCP integration
+ * Tests the seekCoachingOnNextStep MCP tool and server integration
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = require("node:test");
+const node_assert_1 = __importDefault(require("node:assert"));
+const shared_server_utils_js_1 = require("./shared-server-utils.js");
+(0, node_test_1.describe)('AI Coach MCP Integration', () => {
+    (0, node_test_1.before)(async () => {
+        // Wait for the test server to be ready
+        await (0, shared_server_utils_js_1.waitForServer)();
+    });
+    (0, node_test_1.describe)('MCP Tool Registration', () => {
+        (0, node_test_1.it)('should register seekCoachingOnNextStep tool', async () => {
+            const axios = require('axios');
+            // Test MCP tools/list endpoint
+            const response = await axios.post((0, shared_server_utils_js_1.getMcpEndpoint)(), {
+                jsonrpc: '2.0',
+                id: 1,
+                method: 'tools/list'
+            });
+            node_assert_1.default.strictEqual(response.status, 200);
+            node_assert_1.default.ok(response.data.result);
+            node_assert_1.default.ok(Array.isArray(response.data.result.tools));
+            // Find the seekCoachingOnNextStep tool
+            const coachingTool = response.data.result.tools.find((tool) => tool.name === 'seekCoachingOnNextStep');
+            node_assert_1.default.ok(coachingTool, 'seekCoachingOnNextStep tool should be registered');
+            node_assert_1.default.ok(coachingTool.description, 'Tool should have description');
+            node_assert_1.default.ok(coachingTool.inputSchema, 'Tool should have input schema');
+        });
+        (0, node_test_1.it)('should have correct tool schema for seekCoachingOnNextStep', async () => {
+            const axios = require('axios');
+            const response = await axios.post((0, shared_server_utils_js_1.getMcpEndpoint)(), {
+                jsonrpc: '2.0',
+                id: 1,
+                method: 'tools/list'
+            });
+            const coachingTool = response.data.result.tools.find((tool) => tool.name === 'seekCoachingOnNextStep');
+            const schema = coachingTool.inputSchema;
+            node_assert_1.default.ok(schema.properties, 'Tool schema should have properties');
+            // Check required properties
+            const requiredProps = ['workflowType', 'issueNumber', 'currentPhase', 'status'];
+            for (const prop of requiredProps) {
+                node_assert_1.default.ok(schema.properties[prop], `Tool schema should have ${prop} property`);
+            }
+            // Check optional properties
+            const optionalProps = ['evidence', 'findings'];
+            for (const prop of optionalProps) {
+                node_assert_1.default.ok(schema.properties[prop], `Tool schema should have ${prop} property`);
+            }
+            // Check that required properties are marked as required
+            node_assert_1.default.ok(schema.required, 'Tool schema should have required array');
+            for (const prop of requiredProps) {
+                node_assert_1.default.ok(schema.required.includes(prop), `${prop} should be required`);
+            }
+        });
+    });
+    (0, node_test_1.describe)('MCP Tool Execution', () => {
+        (0, node_test_1.it)('should execute seekCoachingOnNextStep for spec workflow starting phase', async () => {
+            const axios = require('axios');
+            const response = await axios.post((0, shared_server_utils_js_1.getMcpEndpoint)(), {
+                jsonrpc: '2.0',
+                id: 1,
+                method: 'tools/call',
+                params: {
+                    name: 'seekCoachingOnNextStep',
+                    arguments: {
+                        workflowType: 'spec',
+                        issueNumber: '123',
+                        currentPhase: 'spec-spec',
+                        status: 'starting',
+                        evidence: { issueType: 'feature' }
+                    }
+                }
+            });
+            node_assert_1.default.strictEqual(response.status, 200);
+            node_assert_1.default.ok(response.data.result);
+            node_assert_1.default.ok(response.data.result.content);
+            node_assert_1.default.ok(Array.isArray(response.data.result.content));
+            const content = response.data.result.content[0];
+            node_assert_1.default.strictEqual(content.type, 'text');
+            node_assert_1.default.ok(content.text.includes('Phase:'), 'Response should contain phase instructions');
+            node_assert_1.default.ok(content.text.includes('INTENT'), 'Response should contain INTENT section');
+        });
+        (0, node_test_1.it)('should execute seekCoachingOnNextStep for implement workflow starting phase', async () => {
+            const axios = require('axios');
+            const response = await axios.post((0, shared_server_utils_js_1.getMcpEndpoint)(), {
+                jsonrpc: '2.0',
+                id: 1,
+                method: 'tools/call',
+                params: {
+                    name: 'seekCoachingOnNextStep',
+                    arguments: {
+                        workflowType: 'implement',
+                        issueNumber: '456',
+                        currentPhase: 'implement-scoping',
+                        status: 'starting',
+                        evidence: { issueType: 'bug' }
+                    }
+                }
+            });
+            node_assert_1.default.strictEqual(response.status, 200);
+            node_assert_1.default.ok(response.data.result);
+            const content = response.data.result.content[0];
+            node_assert_1.default.ok(content.text.includes('Phase:'), 'Response should contain phase instructions');
+            node_assert_1.default.ok(content.text.includes('INTENT'), 'Response should contain INTENT section');
+        });
+        (0, node_test_1.it)('should execute seekCoachingOnNextStep for design workflow starting phase', async () => {
+            const axios = require('axios');
+            const response = await axios.post((0, shared_server_utils_js_1.getMcpEndpoint)(), {
+                jsonrpc: '2.0',
+                id: 1,
+                method: 'tools/call',
+                params: {
+                    name: 'seekCoachingOnNextStep',
+                    arguments: {
+                        workflowType: 'design',
+                        issueNumber: '789',
+                        currentPhase: 'design-design',
+                        status: 'starting',
+                        evidence: { issueType: 'feature' }
+                    }
+                }
+            });
+            node_assert_1.default.strictEqual(response.status, 200);
+            node_assert_1.default.ok(response.data.result);
+            const content = response.data.result.content[0];
+            node_assert_1.default.ok(content.text.includes('Phase:'), 'Response should contain phase instructions');
+            node_assert_1.default.ok(content.text.includes('INTENT'), 'Response should contain INTENT section');
+        });
+        (0, node_test_1.it)('should handle phase completion and provide next phase', async () => {
+            const axios = require('axios');
+            const response = await axios.post((0, shared_server_utils_js_1.getMcpEndpoint)(), {
+                jsonrpc: '2.0',
+                id: 1,
+                method: 'tools/call',
+                params: {
+                    name: 'seekCoachingOnNextStep',
+                    arguments: {
+                        workflowType: 'spec',
+                        issueNumber: '123',
+                        currentPhase: 'spec-spec',
+                        status: 'complete',
+                        evidence: {
+                            issueType: 'feature',
+                            specComplete: true,
+                            specDocument: 'docs/feature specs/123-test-feature.md'
+                        }
+                    }
+                }
+            });
+            node_assert_1.default.strictEqual(response.status, 200);
+            const content = response.data.result.content[0];
+            node_assert_1.default.ok(content.text.includes('Phase Complete!'), 'Should indicate phase completion');
+            node_assert_1.default.ok(content.text.includes('Next Phase: spec-completeness-review'), 'Should provide next phase');
+        });
+        (0, node_test_1.it)('should handle incomplete phase with help message', async () => {
+            const axios = require('axios');
+            const response = await axios.post((0, shared_server_utils_js_1.getMcpEndpoint)(), {
+                jsonrpc: '2.0',
+                id: 1,
+                method: 'tools/call',
+                params: {
+                    name: 'seekCoachingOnNextStep',
+                    arguments: {
+                        workflowType: 'implement',
+                        issueNumber: '456',
+                        currentPhase: 'implement-code',
+                        status: 'incomplete',
+                        evidence: { issueType: 'bug' },
+                        findings: {
+                            uncertainties: ['Tests are failing', 'Build errors']
+                        }
+                    }
+                }
+            });
+            node_assert_1.default.strictEqual(response.status, 200);
+            const content = response.data.result.content[0];
+            node_assert_1.default.ok(content.text.includes('🤝 AI Coach Assistance'), 'Should show assistance header');
+            node_assert_1.default.ok(content.text.includes('Tests are failing'), 'Should include uncertainties');
+            node_assert_1.default.ok(content.text.includes('Build errors'), 'Should include all uncertainties');
+        });
+        (0, node_test_1.it)('should handle finalize phase completion', async () => {
+            const axios = require('axios');
+            const response = await axios.post((0, shared_server_utils_js_1.getMcpEndpoint)(), {
+                jsonrpc: '2.0',
+                id: 1,
+                method: 'tools/call',
+                params: {
+                    name: 'seekCoachingOnNextStep',
+                    arguments: {
+                        workflowType: 'spec',
+                        issueNumber: '123',
+                        currentPhase: 'wait-for-pr-review',
+                        status: 'complete',
+                        evidence: {
+                            issueType: 'feature',
+                            prApproved: true,
+                            reviewComplete: true
+                        }
+                    }
+                }
+            });
+            node_assert_1.default.strictEqual(response.status, 200);
+            const content = response.data.result.content[0];
+            node_assert_1.default.ok(content.text.includes('Spec Complete!'), 'Should show workflow completion');
+            node_assert_1.default.ok(content.text.includes('Congratulations!'), 'Should include congratulations');
+        });
+    });
+    (0, node_test_1.describe)('MCP Error Handling', () => {
+        (0, node_test_1.it)('should return error for invalid workflow type', async () => {
+            const axios = require('axios');
+            const response = await axios.post((0, shared_server_utils_js_1.getMcpEndpoint)(), {
+                jsonrpc: '2.0',
+                id: 1,
+                method: 'tools/call',
+                params: {
+                    name: 'seekCoachingOnNextStep',
+                    arguments: {
+                        workflowType: 'invalid',
+                        issueNumber: '123',
+                        currentPhase: 'some-phase',
+                        status: 'starting'
+                    }
+                }
+            });
+            node_assert_1.default.strictEqual(response.status, 200);
+            node_assert_1.default.ok(response.data.error ||
+                (response.data.result && response.data.result.isError), 'Should return error for invalid workflow type');
+        });
+        (0, node_test_1.it)('should return error for invalid phase', async () => {
+            const axios = require('axios');
+            const response = await axios.post((0, shared_server_utils_js_1.getMcpEndpoint)(), {
+                jsonrpc: '2.0',
+                id: 1,
+                method: 'tools/call',
+                params: {
+                    name: 'seekCoachingOnNextStep',
+                    arguments: {
+                        workflowType: 'spec',
+                        issueNumber: '123',
+                        currentPhase: 'implement-scoping', // Wrong phase for spec workflow
+                        status: 'starting',
+                        evidence: { issueType: 'feature' }
+                    }
+                }
+            });
+            node_assert_1.default.strictEqual(response.status, 200);
+            node_assert_1.default.ok(response.data.error ||
+                (response.data.result && response.data.result.isError), 'Should return error for invalid phase');
+        });
+        (0, node_test_1.it)('should handle missing required parameters', async () => {
+            const axios = require('axios');
+            const response = await axios.post((0, shared_server_utils_js_1.getMcpEndpoint)(), {
+                jsonrpc: '2.0',
+                id: 1,
+                method: 'tools/call',
+                params: {
+                    name: 'seekCoachingOnNextStep',
+                    arguments: {
+                        workflowType: 'spec',
+                        // Missing issueNumber, currentPhase, status
+                    }
+                }
+            });
+            node_assert_1.default.strictEqual(response.status, 200);
+            node_assert_1.default.ok(response.data.error ||
+                (response.data.result && response.data.result.isError), 'Should return error for missing required parameters');
+        });
+    });
+    (0, node_test_1.describe)('MCP Response Format', () => {
+        (0, node_test_1.it)('should return properly formatted MCP response', async () => {
+            const axios = require('axios');
+            const response = await axios.post((0, shared_server_utils_js_1.getMcpEndpoint)(), {
+                jsonrpc: '2.0',
+                id: 1,
+                method: 'tools/call',
+                params: {
+                    name: 'seekCoachingOnNextStep',
+                    arguments: {
+                        workflowType: 'spec',
+                        issueNumber: '123',
+                        currentPhase: 'spec-spec',
+                        status: 'starting',
+                        evidence: { issueType: 'feature' }
+                    }
+                }
+            });
+            node_assert_1.default.strictEqual(response.status, 200);
+            node_assert_1.default.strictEqual(response.data.jsonrpc, '2.0');
+            node_assert_1.default.strictEqual(response.data.id, 1);
+            node_assert_1.default.ok(response.data.result);
+            const result = response.data.result;
+            node_assert_1.default.ok(result.content);
+            node_assert_1.default.ok(Array.isArray(result.content));
+            node_assert_1.default.strictEqual(result.content.length, 1);
+            const content = result.content[0];
+            node_assert_1.default.strictEqual(content.type, 'text');
+            node_assert_1.default.ok(typeof content.text === 'string');
+            node_assert_1.default.ok(content.text.length > 0);
+        });
+        (0, node_test_1.it)('should include metadata in response when appropriate', async () => {
+            const axios = require('axios');
+            const response = await axios.post((0, shared_server_utils_js_1.getMcpEndpoint)(), {
+                jsonrpc: '2.0',
+                id: 1,
+                method: 'tools/call',
+                params: {
+                    name: 'seekCoachingOnNextStep',
+                    arguments: {
+                        workflowType: 'spec',
+                        issueNumber: '123',
+                        currentPhase: 'spec-spec',
+                        status: 'complete',
+                        evidence: { issueType: 'feature', specComplete: true }
+                    }
+                }
+            });
+            node_assert_1.default.strictEqual(response.status, 200);
+            const content = response.data.result.content[0];
+            // Should include both completion message and next phase instructions
+            node_assert_1.default.ok(content.text.includes('Phase Complete!'), 'Should include completion message');
+            node_assert_1.default.ok(content.text.includes('Next Phase:'), 'Should include next phase info');
+            node_assert_1.default.ok(content.text.length > 1000, 'Should include substantial content');
+        });
+    });
+    (0, node_test_1.describe)('Workflow Integration Tests', () => {
+        (0, node_test_1.it)('should support complete spec workflow via MCP', async () => {
+            const axios = require('axios');
+            // Start spec phase
+            let response = await axios.post((0, shared_server_utils_js_1.getMcpEndpoint)(), {
+                jsonrpc: '2.0',
+                id: 1,
+                method: 'tools/call',
+                params: {
+                    name: 'seekCoachingOnNextStep',
+                    arguments: {
+                        workflowType: 'spec',
+                        issueNumber: '999',
+                        currentPhase: 'spec-spec',
+                        status: 'starting',
+                        evidence: { issueType: 'feature' }
+                    }
+                }
+            });
+            node_assert_1.default.strictEqual(response.status, 200);
+            let content = response.data.result.content[0];
+            node_assert_1.default.ok(content.text.includes('Phase: Spec-Spec'), 'Should start with spec phase');
+            // Complete spec phase
+            response = await axios.post((0, shared_server_utils_js_1.getMcpEndpoint)(), {
+                jsonrpc: '2.0',
+                id: 2,
+                method: 'tools/call',
+                params: {
+                    name: 'seekCoachingOnNextStep',
+                    arguments: {
+                        workflowType: 'spec',
+                        issueNumber: '999',
+                        currentPhase: 'spec-spec',
+                        status: 'complete',
+                        evidence: { issueType: 'feature', specComplete: true }
+                    }
+                }
+            });
+            node_assert_1.default.strictEqual(response.status, 200);
+            content = response.data.result.content[0];
+            node_assert_1.default.ok(content.text.includes('Next Phase: spec-completeness-review'), 'Should transition to review');
+            // Complete review phase
+            response = await axios.post((0, shared_server_utils_js_1.getMcpEndpoint)(), {
+                jsonrpc: '2.0',
+                id: 3,
+                method: 'tools/call',
+                params: {
+                    name: 'seekCoachingOnNextStep',
+                    arguments: {
+                        workflowType: 'spec',
+                        issueNumber: '999',
+                        currentPhase: 'spec-completeness-review',
+                        status: 'complete',
+                        evidence: { issueType: 'feature', reviewComplete: true }
+                    }
+                }
+            });
+            node_assert_1.default.strictEqual(response.status, 200);
+            content = response.data.result.content[0];
+            node_assert_1.default.ok(content.text.includes('Next Phase: submit-pr'), 'Should transition to submit-pr');
+            // Complete submit-pr
+            response = await axios.post((0, shared_server_utils_js_1.getMcpEndpoint)(), {
+                jsonrpc: '2.0',
+                id: 4,
+                method: 'tools/call',
+                params: {
+                    name: 'seekCoachingOnNextStep',
+                    arguments: {
+                        workflowType: 'spec',
+                        issueNumber: '999',
+                        currentPhase: 'submit-pr',
+                        status: 'complete',
+                        evidence: { issueType: 'feature', prSubmitted: true }
+                    }
+                }
+            });
+            node_assert_1.default.strictEqual(response.status, 200);
+            content = response.data.result.content[0];
+            node_assert_1.default.ok(content.text.includes('Next Phase: wait-for-pr-review'), 'Should transition to wait-for-pr-review');
+            // Complete wait-for-pr-review
+            response = await axios.post((0, shared_server_utils_js_1.getMcpEndpoint)(), {
+                jsonrpc: '2.0',
+                id: 5,
+                method: 'tools/call',
+                params: {
+                    name: 'seekCoachingOnNextStep',
+                    arguments: {
+                        workflowType: 'spec',
+                        issueNumber: '999',
+                        currentPhase: 'wait-for-pr-review',
+                        status: 'complete',
+                        evidence: { issueType: 'feature', prApproved: true }
+                    }
+                }
+            });
+            node_assert_1.default.strictEqual(response.status, 200);
+            content = response.data.result.content[0];
+            node_assert_1.default.ok(content.text.includes('Spec Complete!'), 'Should show completion');
+        });
+    });
+});