@codebakers/cli 2.3.0 → 2.4.0

package/dist/mcp/server.js

@@ -502,6 +502,76 @@ class CodeBakersServer {
                         properties: {},
                     },
                 },
+                {
+                    name: 'run_tests',
+                    description: 'Run the project test suite (npm test or configured test command). Use after completing a feature to verify everything works. Returns test results with pass/fail status.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            filter: {
+                                type: 'string',
+                                description: 'Optional filter to run specific tests (passed to test runner)',
+                            },
+                            watch: {
+                                type: 'boolean',
+                                description: 'Run in watch mode (default: false)',
+                            },
+                        },
+                    },
+                },
+                {
+                    name: 'report_pattern_gap',
+                    description: 'Report when a user request cannot be fully handled by existing patterns. This helps improve CodeBakers by tracking what patterns are missing. The AI should automatically call this when it encounters something outside pattern coverage.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            category: {
+                                type: 'string',
+                                description: 'Category of the gap (e.g., "third-party-apis", "mobile", "blockchain", "iot")',
+                            },
+                            request: {
+                                type: 'string',
+                                description: 'What the user asked for',
+                            },
+                            context: {
+                                type: 'string',
+                                description: 'Additional context about what was needed',
+                            },
+                            handledWith: {
+                                type: 'string',
+                                description: 'Which existing patterns were used as fallback',
+                            },
+                            wasSuccessful: {
+                                type: 'boolean',
+                                description: 'Whether the request was handled successfully despite the gap',
+                            },
+                        },
+                        required: ['category', 'request'],
+                    },
+                },
+                {
+                    name: 'track_analytics',
+                    description: 'Track CLI usage analytics for improving smart triggers and recommendations. Called automatically by the system for key events.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            eventType: {
+                                type: 'string',
+                                enum: ['trigger_fired', 'trigger_accepted', 'trigger_dismissed', 'topic_learned', 'command_used', 'pattern_fetched', 'build_started', 'build_completed', 'feature_added', 'audit_run', 'design_cloned'],
+                                description: 'Type of event to track',
+                            },
+                            eventData: {
+                                type: 'object',
+                                description: 'Additional data specific to the event',
+                            },
+                            projectHash: {
+                                type: 'string',
+                                description: 'Hash of project path for grouping analytics',
+                            },
+                        },
+                        required: ['eventType'],
+                    },
+                },
             ],
         }));
         // Handle tool calls
@@ -543,6 +613,12 @@ class CodeBakersServer {
                     return this.handleUpgrade(args);
                 case 'project_status':
                     return this.handleProjectStatus();
+                case 'run_tests':
+                    return this.handleRunTests(args);
+                case 'report_pattern_gap':
+                    return this.handleReportPatternGap(args);
+                case 'track_analytics':
+                    return this.handleTrackAnalytics(args);
                 default:
                     throw new types_js_1.McpError(types_js_1.ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
             }
@@ -1676,6 +1752,160 @@ Just describe what you want to build! I'll automatically:
                 }],
         };
     }
+    handleRunTests(args) {
+        const { filter, watch = false } = args;
+        const cwd = process.cwd();
+        // Detect test runner from package.json
+        let testCommand = 'npm test';
+        try {
+            const pkgPath = path.join(cwd, 'package.json');
+            if (fs.existsSync(pkgPath)) {
+                const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+                const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+                if (deps['@playwright/test']) {
+                    testCommand = 'npx playwright test';
+                }
+                else if (deps['vitest']) {
+                    testCommand = 'npx vitest run';
+                }
+                else if (deps['jest']) {
+                    testCommand = 'npx jest';
+                }
+            }
+        }
+        catch {
+            // Use default
+        }
+        // Add filter if provided
+        if (filter) {
+            testCommand += ` ${filter}`;
+        }
+        // Add watch mode
+        if (watch) {
+            testCommand = testCommand.replace(' run', ''); // Remove 'run' for vitest watch
+            if (testCommand.includes('vitest')) {
+                testCommand = testCommand.replace('vitest run', 'vitest');
+            }
+        }
+        let response = `# 🧪 Running Tests\n\n`;
+        response += `**Command:** \`${testCommand}\`\n\n`;
+        try {
+            const output = (0, child_process_1.execSync)(testCommand, {
+                cwd,
+                encoding: 'utf-8',
+                timeout: 120000, // 2 minute timeout
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            response += `## ✅ Tests Passed\n\n`;
+            response += '```\n' + output.slice(-2000) + '\n```\n';
+        }
+        catch (error) {
+            const execError = error;
+            response += `## ❌ Tests Failed\n\n`;
+            if (execError.stdout) {
+                response += '### Output\n```\n' + execError.stdout.slice(-2000) + '\n```\n\n';
+            }
+            if (execError.stderr) {
+                response += '### Errors\n```\n' + execError.stderr.slice(-1000) + '\n```\n\n';
+            }
+            response += `**Exit Code:** ${execError.status || 1}\n\n`;
+            response += `---\n\n*Fix the failing tests and run again.*`;
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: response,
+                }],
+        };
+    }
+    async handleReportPatternGap(args) {
+        const { category, request, context, handledWith, wasSuccessful = true } = args;
+        try {
+            const response = await fetch(`${this.apiUrl}/api/pattern-gaps`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${this.apiKey}`,
+                },
+                body: JSON.stringify({
+                    category,
+                    request,
+                    context,
+                    handledWith,
+                    wasSuccessful,
+                }),
+            });
+            if (!response.ok) {
+                const error = await response.json().catch(() => ({}));
+                throw new Error(error.error || 'Failed to report pattern gap');
+            }
+            const result = await response.json();
+            if (result.deduplicated) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `📊 Pattern gap already reported recently (category: ${category}). No duplicate created.`,
+                        }],
+                };
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: `✅ Pattern gap reported successfully.\n\n**Category:** ${category}\n**Request:** ${request}\n\nThis helps improve CodeBakers for everyone!`,
+                    }],
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            return {
+                content: [{
+                        type: 'text',
+                        text: `⚠️ Could not report pattern gap: ${message}\n\n(This doesn't affect your current work)`,
+                    }],
+            };
+        }
+    }
+    async handleTrackAnalytics(args) {
+        const { eventType, eventData, projectHash } = args;
+        try {
+            const response = await fetch(`${this.apiUrl}/api/cli/analytics`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${this.apiKey}`,
+                },
+                body: JSON.stringify({
+                    eventType,
+                    eventData,
+                    projectHash,
+                }),
+            });
+            if (!response.ok) {
+                // Silently fail - analytics shouldn't interrupt user workflow
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `📊 Analytics tracked: ${eventType}`,
+                        }],
+                };
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: `📊 Analytics tracked: ${eventType}`,
+                    }],
+            };
+        }
+        catch {
+            // Silently fail
+            return {
+                content: [{
+                        type: 'text',
+                        text: `📊 Analytics tracked: ${eventType}`,
+                    }],
+            };
+        }
+    }
     async run() {
         const transport = new stdio_js_1.StdioServerTransport();
         await this.server.connect(transport);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codebakers/cli",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "description": "CodeBakers CLI - Production patterns for AI-assisted development",
   "main": "dist/index.js",
   "bin": {

package/src/mcp/server.ts

@@ -532,6 +532,79 @@ class CodeBakersServer {
             properties: {},
           },
         },
+        {
+          name: 'run_tests',
+          description:
+            'Run the project test suite (npm test or configured test command). Use after completing a feature to verify everything works. Returns test results with pass/fail status.',
+          inputSchema: {
+            type: 'object' as const,
+            properties: {
+              filter: {
+                type: 'string',
+                description: 'Optional filter to run specific tests (passed to test runner)',
+              },
+              watch: {
+                type: 'boolean',
+                description: 'Run in watch mode (default: false)',
+              },
+            },
+          },
+        },
+        {
+          name: 'report_pattern_gap',
+          description:
+            'Report when a user request cannot be fully handled by existing patterns. This helps improve CodeBakers by tracking what patterns are missing. The AI should automatically call this when it encounters something outside pattern coverage.',
+          inputSchema: {
+            type: 'object' as const,
+            properties: {
+              category: {
+                type: 'string',
+                description: 'Category of the gap (e.g., "third-party-apis", "mobile", "blockchain", "iot")',
+              },
+              request: {
+                type: 'string',
+                description: 'What the user asked for',
+              },
+              context: {
+                type: 'string',
+                description: 'Additional context about what was needed',
+              },
+              handledWith: {
+                type: 'string',
+                description: 'Which existing patterns were used as fallback',
+              },
+              wasSuccessful: {
+                type: 'boolean',
+                description: 'Whether the request was handled successfully despite the gap',
+              },
+            },
+            required: ['category', 'request'],
+          },
+        },
+        {
+          name: 'track_analytics',
+          description:
+            'Track CLI usage analytics for improving smart triggers and recommendations. Called automatically by the system for key events.',
+          inputSchema: {
+            type: 'object' as const,
+            properties: {
+              eventType: {
+                type: 'string',
+                enum: ['trigger_fired', 'trigger_accepted', 'trigger_dismissed', 'topic_learned', 'command_used', 'pattern_fetched', 'build_started', 'build_completed', 'feature_added', 'audit_run', 'design_cloned'],
+                description: 'Type of event to track',
+              },
+              eventData: {
+                type: 'object',
+                description: 'Additional data specific to the event',
+              },
+              projectHash: {
+                type: 'string',
+                description: 'Hash of project path for grouping analytics',
+              },
+            },
+            required: ['eventType'],
+          },
+        },
       ],
     }));
 
@@ -595,6 +668,15 @@ class CodeBakersServer {
         case 'project_status':
           return this.handleProjectStatus();
 
+        case 'run_tests':
+          return this.handleRunTests(args as { filter?: string; watch?: boolean });
+
+        case 'report_pattern_gap':
+          return this.handleReportPatternGap(args as { category: string; request: string; context?: string; handledWith?: string; wasSuccessful?: boolean });
+
+        case 'track_analytics':
+          return this.handleTrackAnalytics(args as { eventType: string; eventData?: Record<string, unknown>; projectHash?: string });
+
         default:
           throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
       }
@@ -1888,6 +1970,175 @@ Just describe what you want to build! I'll automatically:
     };
   }
 
+  private handleRunTests(args: { filter?: string; watch?: boolean }) {
+    const { filter, watch = false } = args;
+    const cwd = process.cwd();
+
+    // Detect test runner from package.json
+    let testCommand = 'npm test';
+    try {
+      const pkgPath = path.join(cwd, 'package.json');
+      if (fs.existsSync(pkgPath)) {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+
+        if (deps['@playwright/test']) {
+          testCommand = 'npx playwright test';
+        } else if (deps['vitest']) {
+          testCommand = 'npx vitest run';
+        } else if (deps['jest']) {
+          testCommand = 'npx jest';
+        }
+      }
+    } catch {
+      // Use default
+    }
+
+    // Add filter if provided
+    if (filter) {
+      testCommand += ` ${filter}`;
+    }
+
+    // Add watch mode
+    if (watch) {
+      testCommand = testCommand.replace(' run', ''); // Remove 'run' for vitest watch
+      if (testCommand.includes('vitest')) {
+        testCommand = testCommand.replace('vitest run', 'vitest');
+      }
+    }
+
+    let response = `# 🧪 Running Tests\n\n`;
+    response += `**Command:** \`${testCommand}\`\n\n`;
+
+    try {
+      const output = execSync(testCommand, {
+        cwd,
+        encoding: 'utf-8',
+        timeout: 120000, // 2 minute timeout
+        stdio: ['pipe', 'pipe', 'pipe'],
+      });
+
+      response += `## ✅ Tests Passed\n\n`;
+      response += '```\n' + output.slice(-2000) + '\n```\n';
+    } catch (error) {
+      const execError = error as { stdout?: string; stderr?: string; status?: number };
+      response += `## ❌ Tests Failed\n\n`;
+
+      if (execError.stdout) {
+        response += '### Output\n```\n' + execError.stdout.slice(-2000) + '\n```\n\n';
+      }
+      if (execError.stderr) {
+        response += '### Errors\n```\n' + execError.stderr.slice(-1000) + '\n```\n\n';
+      }
+
+      response += `**Exit Code:** ${execError.status || 1}\n\n`;
+      response += `---\n\n*Fix the failing tests and run again.*`;
+    }
+
+    return {
+      content: [{
+        type: 'text' as const,
+        text: response,
+      }],
+    };
+  }
+
+  private async handleReportPatternGap(args: { category: string; request: string; context?: string; handledWith?: string; wasSuccessful?: boolean }) {
+    const { category, request, context, handledWith, wasSuccessful = true } = args;
+
+    try {
+      const response = await fetch(`${this.apiUrl}/api/pattern-gaps`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Bearer ${this.apiKey}`,
+        },
+        body: JSON.stringify({
+          category,
+          request,
+          context,
+          handledWith,
+          wasSuccessful,
+        }),
+      });
+
+      if (!response.ok) {
+        const error = await response.json().catch(() => ({}));
+        throw new Error(error.error || 'Failed to report pattern gap');
+      }
+
+      const result = await response.json();
+
+      if (result.deduplicated) {
+        return {
+          content: [{
+            type: 'text' as const,
+            text: `📊 Pattern gap already reported recently (category: ${category}). No duplicate created.`,
+          }],
+        };
+      }
+
+      return {
+        content: [{
+          type: 'text' as const,
+          text: `✅ Pattern gap reported successfully.\n\n**Category:** ${category}\n**Request:** ${request}\n\nThis helps improve CodeBakers for everyone!`,
+        }],
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Unknown error';
+      return {
+        content: [{
+          type: 'text' as const,
+          text: `⚠️ Could not report pattern gap: ${message}\n\n(This doesn't affect your current work)`,
+        }],
+      };
+    }
+  }
+
+  private async handleTrackAnalytics(args: { eventType: string; eventData?: Record<string, unknown>; projectHash?: string }) {
+    const { eventType, eventData, projectHash } = args;
+
+    try {
+      const response = await fetch(`${this.apiUrl}/api/cli/analytics`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Bearer ${this.apiKey}`,
+        },
+        body: JSON.stringify({
+          eventType,
+          eventData,
+          projectHash,
+        }),
+      });
+
+      if (!response.ok) {
+        // Silently fail - analytics shouldn't interrupt user workflow
+        return {
+          content: [{
+            type: 'text' as const,
+            text: `📊 Analytics tracked: ${eventType}`,
+          }],
+        };
+      }
+
+      return {
+        content: [{
+          type: 'text' as const,
+          text: `📊 Analytics tracked: ${eventType}`,
+        }],
+      };
+    } catch {
+      // Silently fail
+      return {
+        content: [{
+          type: 'text' as const,
+          text: `📊 Analytics tracked: ${eventType}`,
+        }],
+      };
+    }
+  }
+
   async run(): Promise<void> {
     const transport = new StdioServerTransport();
     await this.server.connect(transport);