@bbearai/mcp-server 0.3.0

package/dist/index-api.d.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+/**
+ * BugBear MCP Server (API Version)
+ *
+ * This version uses the BugBear API instead of connecting directly to Supabase.
+ * This is the recommended setup for new projects.
+ *
+ * Configuration:
+ *   BUGBEAR_API_KEY - Your project's API key (bb_live_xxx)
+ *   BUGBEAR_API_URL - API URL (optional, defaults to https://bugbear.ai/api/v1)
+ */
+export {};

package/dist/index-api.js

@@ -0,0 +1,368 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * BugBear MCP Server (API Version)
+ *
+ * This version uses the BugBear API instead of connecting directly to Supabase.
+ * This is the recommended setup for new projects.
+ *
+ * Configuration:
+ *   BUGBEAR_API_KEY - Your project's API key (bb_live_xxx)
+ *   BUGBEAR_API_URL - API URL (optional, defaults to https://bugbear.ai/api/v1)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+// Configuration
+const API_KEY = process.env.BUGBEAR_API_KEY || '';
+// Default to production URL, but allow override for local development
+const API_URL = process.env.BUGBEAR_API_URL || 'https://app.bugbear.ai/api/v1';
+// Validate configuration
+function validateConfig() {
+    if (!API_KEY) {
+        console.error('BugBear MCP Server: BUGBEAR_API_KEY environment variable is required');
+        console.error('Get your API key from: https://bugbear.ai/settings/projects');
+        process.exit(1);
+    }
+    if (!API_KEY.startsWith('bb_live_') && !API_KEY.startsWith('bb_test_')) {
+        console.error('BugBear MCP Server: Invalid API key format');
+        console.error('API keys should start with bb_live_ or bb_test_');
+        process.exit(1);
+    }
+}
+// API helper
+async function apiRequest(endpoint, method = 'GET', body) {
+    try {
+        const url = `${API_URL}${endpoint}`;
+        const options = {
+            method,
+            headers: {
+                'Authorization': `Bearer ${API_KEY}`,
+                'Content-Type': 'application/json',
+            },
+        };
+        if (body && method !== 'GET') {
+            options.body = JSON.stringify(body);
+        }
+        const response = await fetch(url, options);
+        const json = await response.json();
+        if (!response.ok) {
+            return { error: json.error || `API error: ${response.status}` };
+        }
+        return { data: json.data };
+    }
+    catch (error) {
+        return { error: error instanceof Error ? error.message : 'API request failed' };
+    }
+}
+// Tool definitions
+const tools = [
+    {
+        name: 'list_reports',
+        description: 'List recent bug reports for the project',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                limit: {
+                    type: 'number',
+                    description: 'Maximum reports to return (default: 10, max: 50)',
+                },
+                status: {
+                    type: 'string',
+                    enum: ['new', 'reviewed', 'in_progress', 'resolved', 'closed'],
+                    description: 'Filter by status',
+                },
+                severity: {
+                    type: 'string',
+                    enum: ['critical', 'high', 'medium', 'low'],
+                    description: 'Filter by severity',
+                },
+                report_type: {
+                    type: 'string',
+                    enum: ['bug', 'test_fail', 'feedback', 'suggestion'],
+                    description: 'Filter by type',
+                },
+            },
+        },
+    },
+    {
+        name: 'get_report',
+        description: 'Get detailed information about a specific report',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                report_id: {
+                    type: 'string',
+                    description: 'The UUID of the report',
+                },
+            },
+            required: ['report_id'],
+        },
+    },
+    {
+        name: 'update_report_status',
+        description: 'Update the status of a report',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                report_id: {
+                    type: 'string',
+                    description: 'The UUID of the report',
+                },
+                status: {
+                    type: 'string',
+                    enum: ['new', 'reviewed', 'in_progress', 'resolved', 'closed'],
+                    description: 'New status',
+                },
+                resolution: {
+                    type: 'string',
+                    description: 'Resolution notes (optional)',
+                },
+            },
+            required: ['report_id', 'status'],
+        },
+    },
+    {
+        name: 'create_bug_report',
+        description: 'Create a new bug report from Claude Code',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                description: {
+                    type: 'string',
+                    description: 'Detailed description of the bug',
+                },
+                severity: {
+                    type: 'string',
+                    enum: ['critical', 'high', 'medium', 'low'],
+                    description: 'Bug severity',
+                },
+                file_path: {
+                    type: 'string',
+                    description: 'File path where the bug was found',
+                },
+                line_number: {
+                    type: 'number',
+                    description: 'Line number',
+                },
+                code_snippet: {
+                    type: 'string',
+                    description: 'Relevant code snippet',
+                },
+                suggested_fix: {
+                    type: 'string',
+                    description: 'Suggested fix',
+                },
+            },
+            required: ['description', 'severity'],
+        },
+    },
+    {
+        name: 'get_project_info',
+        description: 'Get project information and statistics',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+        },
+    },
+    {
+        name: 'list_test_cases',
+        description: 'List test cases for the project',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                limit: {
+                    type: 'number',
+                    description: 'Max test cases to return (default: 50)',
+                },
+                priority: {
+                    type: 'string',
+                    enum: ['P0', 'P1', 'P2', 'P3'],
+                    description: 'Filter by priority',
+                },
+            },
+        },
+    },
+    {
+        name: 'create_test_case',
+        description: 'Create a new test case',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                test_key: {
+                    type: 'string',
+                    description: 'Unique test ID (e.g., TC-001)',
+                },
+                title: {
+                    type: 'string',
+                    description: 'Test title',
+                },
+                description: {
+                    type: 'string',
+                    description: 'Test description',
+                },
+                steps: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            stepNumber: { type: 'number' },
+                            action: { type: 'string' },
+                            expectedResult: { type: 'string' },
+                        },
+                    },
+                    description: 'Test steps',
+                },
+                expected_result: {
+                    type: 'string',
+                    description: 'Expected outcome',
+                },
+                priority: {
+                    type: 'string',
+                    enum: ['P0', 'P1', 'P2', 'P3'],
+                    description: 'Priority level',
+                },
+            },
+            required: ['test_key', 'title', 'steps', 'expected_result'],
+        },
+    },
+    {
+        name: 'get_qa_tracks',
+        description: 'Get QA tracks for the project',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+        },
+    },
+    {
+        name: 'verify_connection',
+        description: 'Verify the API connection is working',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+        },
+    },
+];
+// Tool handlers
+async function handleTool(name, args) {
+    let result;
+    switch (name) {
+        case 'list_reports': {
+            const params = new URLSearchParams();
+            if (args.limit)
+                params.set('limit', String(args.limit));
+            if (args.status)
+                params.set('status', String(args.status));
+            if (args.severity)
+                params.set('severity', String(args.severity));
+            if (args.report_type)
+                params.set('report_type', String(args.report_type));
+            result = await apiRequest(`/reports?${params.toString()}`);
+            break;
+        }
+        case 'get_report':
+            result = await apiRequest(`/reports/${args.report_id}`);
+            break;
+        case 'update_report_status':
+            result = await apiRequest(`/reports/${args.report_id}`, 'PATCH', {
+                status: args.status,
+                resolution: args.resolution,
+            });
+            break;
+        case 'create_bug_report': {
+            // Build enhanced description with code context
+            let description = String(args.description);
+            if (args.file_path) {
+                description += `\n\n📁 File: ${args.file_path}`;
+                if (args.line_number) {
+                    description += `:${args.line_number}`;
+                }
+            }
+            if (args.code_snippet) {
+                description += `\n\n\`\`\`\n${args.code_snippet}\n\`\`\``;
+            }
+            if (args.suggested_fix) {
+                description += `\n\n💡 Suggested fix: ${args.suggested_fix}`;
+            }
+            result = await apiRequest('/reports', 'POST', {
+                report_type: 'bug',
+                description,
+                severity: args.severity,
+                app_context: {
+                    source: 'claude_code',
+                    file_path: args.file_path,
+                    line_number: args.line_number,
+                },
+            });
+            break;
+        }
+        case 'get_project_info':
+            result = await apiRequest('/project');
+            break;
+        case 'list_test_cases': {
+            const params = new URLSearchParams();
+            if (args.limit)
+                params.set('limit', String(args.limit));
+            if (args.priority)
+                params.set('priority', String(args.priority));
+            result = await apiRequest(`/test-cases?${params.toString()}`);
+            break;
+        }
+        case 'create_test_case':
+            result = await apiRequest('/test-cases', 'POST', {
+                test_key: args.test_key,
+                title: args.title,
+                description: args.description,
+                steps: args.steps,
+                expected_result: args.expected_result,
+                priority: args.priority || 'P2',
+            });
+            break;
+        case 'get_qa_tracks':
+            result = await apiRequest('/qa-tracks');
+            break;
+        case 'verify_connection':
+            result = await apiRequest('/verify');
+            break;
+        default:
+            result = { error: `Unknown tool: ${name}` };
+    }
+    if (result.error) {
+        return {
+            content: [{ type: 'text', text: `Error: ${result.error}` }],
+        };
+    }
+    return {
+        content: [{ type: 'text', text: JSON.stringify(result.data, null, 2) }],
+    };
+}
+// Main
+async function main() {
+    validateConfig();
+    const server = new index_js_1.Server({
+        name: 'bugbear',
+        version: '0.2.0',
+    }, {
+        capabilities: {
+            tools: {},
+        },
+    });
+    // List tools
+    server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
+        tools,
+    }));
+    // Handle tool calls
+    server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        return await handleTool(name, (args || {}));
+    });
+    // Connect via stdio
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+    console.error('BugBear MCP Server (API) connected');
+}
+main().catch((error) => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+/**
+ * BugBear MCP Server
+ * Allows Claude Code to query and manage bug reports via Model Context Protocol
+ */
+export {};