feedbackbasket-mcp-server 1.0.0

package/README.md

@@ -0,0 +1,192 @@
+# FeedbackBasket MCP Server
+
+Model Context Protocol (MCP) server for FeedbackBasket that allows AI assistants to query your project feedback and bug reports.
+
+## Features
+
+- 🔍 **List Projects** - View all your FeedbackBasket projects with summary statistics
+- 📝 **Get Feedback** - Retrieve feedback with filtering by category, status, sentiment, and more
+- 🐛 **Get Bug Reports** - Specifically fetch bug reports with severity classification
+- 🔎 **Search Feedback** - Search across all feedback content using text queries
+- 🔐 **Secure Authentication** - Uses API keys with project-level access control
+- 📊 **Rich Statistics** - Get counts by category, status, sentiment, and severity
+
+## Installation & Setup
+
+### 1. Generate API Key
+
+First, you'll need to create an API key from your FeedbackBasket account:
+
+1. **Visit** [feedbackbasket.com](https://feedbackbasket.com) and log into your account
+2. **Navigate** to your Account Settings (click your profile → Account)
+3. **Find** the "MCP API Keys" section
+4. **Click** "New API Key"
+5. **Name your key** (e.g., "Claude Desktop", "Cursor IDE", "Windsurf")
+6. **Select projects** you want to grant access to (or leave empty for all projects)
+7. **Copy the generated API key** (starts with `fb_key_`) - you'll only see the full key once!
+
+> 💡 **Tip**: You can manage your API keys anytime from your account settings at [feedbackbasket.com/account](https://feedbackbasket.com/account)
+
+### 2. Configure Your Editor
+
+Add the MCP server to your editor's configuration:
+
+#### Quick Setup (All Editors)
+```json
+{
+  "mcpServers": {
+    "feedbackbasket": {
+      "command": "npx",
+      "args": ["-y", "@feedbackbasket/mcp-server@latest", "--api-key", "fb_key_your_api_key_here"]
+    }
+  }
+}
+```
+
+#### Detailed Examples
+
+#### Claude Desktop
+```json
+{
+  "mcpServers": {
+    "feedbackbasket": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@feedbackbasket/mcp-server@latest",
+        "--api-key",
+        "fb_key_your_api_key_here"
+      ]
+    }
+  }
+}
+```
+
+#### Cursor/Windsurf
+```json
+{
+  "mcpServers": {
+    "feedbackbasket": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@feedbackbasket/mcp-server@latest",
+        "--api-key",
+        "fb_key_your_api_key_here"
+      ]
+    }
+  }
+}
+```
+
+#### Environment Variable (Alternative)
+```json
+{
+  "mcpServers": {
+    "feedbackbasket": {
+      "command": "npx",
+      "args": ["-y", "@feedbackbasket/mcp-server@latest"],
+      "env": {
+        "FEEDBACKBASKET_API_KEY": "fb_key_your_api_key_here"
+      }
+    }
+  }
+}
+```
+
+## Usage Examples
+
+Once configured, you can ask your AI assistant:
+
+### Project Overview
+- "Show me all my FeedbackBasket projects"
+- "What projects do I have and how much feedback do they have?"
+
+### Bug Reports
+- "Show me all bug reports from my projects"
+- "Get high severity bug reports that are still pending"
+- "Find bug reports for my main website project"
+
+### Feedback Analysis
+- "Show me negative feedback from the last week"
+- "Get all feature requests from my mobile app project"
+- "Search for feedback containing 'login error'"
+
+### Filtering & Search
+- "Show me reviewed feedback with positive sentiment"
+- "Find all pending bug reports with high severity"
+- "Search for feedback about 'payment issues' in my e-commerce project"
+
+## Available Tools
+
+### `list_projects`
+Lists all projects accessible by your API key with summary statistics.
+
+### `get_feedback`
+Retrieves feedback with optional filtering:
+- `projectId` - Filter by specific project
+- `category` - Filter by BUG, FEATURE, or REVIEW
+- `status` - Filter by PENDING, REVIEWED, or DONE
+- `sentiment` - Filter by POSITIVE, NEGATIVE, or NEUTRAL
+- `search` - Text search in feedback content
+- `limit` - Number of results (max 100)
+- `includeNotes` - Include internal notes
+
+### `get_bug_reports`
+Specifically fetches bug reports with computed severity:
+- `projectId` - Filter by specific project
+- `status` - Filter by bug status
+- `severity` - Filter by high, medium, or low severity
+- `search` - Text search in bug reports
+- `limit` - Number of results (max 100)
+- `includeNotes` - Include internal notes
+
+### `search_feedback`
+Searches feedback content across all accessible projects:
+- `query` - Search text (required)
+- `projectId` - Limit to specific project
+- `category` - Filter by category
+- `limit` - Number of results (max 50)
+
+## Security & Privacy
+
+- ✅ **Read-only access** - MCP server can only read data, never modify
+- ✅ **Project-level permissions** - Grant access only to specific projects
+- ✅ **API key authentication** - Secure token-based authentication
+- ✅ **Usage tracking** - Monitor API key usage in your dashboard
+- ✅ **Revokable access** - Instantly deactivate API keys if needed
+- ✅ **Subscription limits respected** - Only returns feedback within your plan limits
+
+## Troubleshooting
+
+### "Invalid or missing API key"
+- Check that your API key starts with `fb_key_`
+- Ensure the API key is still active in your dashboard
+- Verify the API key has access to at least one project
+
+### "No projects found"
+- Make sure your API key has been granted access to projects
+- Check that you have projects in your FeedbackBasket account
+
+### "Authentication failed"
+- Verify your API key hasn't been revoked
+- Check that the API key format is correct (71 characters, starts with `fb_key_`)
+
+### Installation Issues
+- Ensure you have Node.js installed
+- Try clearing npx cache: `npx clear-npx-cache`
+- Check your internet connection for package downloads
+
+## API Key Management
+
+Visit your [FeedbackBasket dashboard](https://feedbackbasket.com/dashboard/settings) to:
+- Generate new API keys
+- Manage project access for existing keys
+- View usage statistics
+- Deactivate or delete keys
+- Monitor key activity
+
+## Support
+
+- 🐛 Issues: [GitHub Issues](https://github.com/deifos/feedbackbasket-mcp/issues)
+- 📖 Docs: [FeedbackBasket Documentation](https://feedbackbasket.com/docs)

package/dist/client.d.ts

@@ -0,0 +1,60 @@
+export declare class FeedbackBasketClient {
+    private api;
+    constructor(apiKey: string, baseUrl?: string);
+    /**
+     * List all projects accessible by the API key
+     */
+    listProjects(): Promise<{
+        content: Array<{
+            type: string;
+            text: string;
+        }>;
+    }>;
+    /**
+     * Get feedback for projects
+     */
+    getFeedback(params?: {
+        projectId?: string;
+        category?: 'BUG' | 'FEATURE' | 'REVIEW';
+        status?: 'PENDING' | 'REVIEWED' | 'DONE';
+        sentiment?: 'POSITIVE' | 'NEGATIVE' | 'NEUTRAL';
+        limit?: number;
+        search?: string;
+        includeNotes?: boolean;
+    }): Promise<{
+        content: Array<{
+            type: string;
+            text: string;
+        }>;
+    }>;
+    /**
+     * Get bug reports specifically
+     */
+    getBugReports(params?: {
+        projectId?: string;
+        status?: 'PENDING' | 'REVIEWED' | 'DONE';
+        severity?: 'high' | 'medium' | 'low';
+        limit?: number;
+        search?: string;
+        includeNotes?: boolean;
+    }): Promise<{
+        content: Array<{
+            type: string;
+            text: string;
+        }>;
+    }>;
+    /**
+     * Search feedback across all accessible projects
+     */
+    searchFeedback(query: string, options?: {
+        projectId?: string;
+        category?: 'BUG' | 'FEATURE' | 'REVIEW';
+        limit?: number;
+    }): Promise<{
+        content: Array<{
+            type: string;
+            text: string;
+        }>;
+    }>;
+    private handleError;
+}

package/dist/client.js

@@ -0,0 +1,207 @@
+import axios, { AxiosError } from 'axios';
+export class FeedbackBasketClient {
+    api;
+    constructor(apiKey, baseUrl = 'https://feedbackbasket.com') {
+        this.api = axios.create({
+            baseURL: `${baseUrl}/api/mcp`,
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'Content-Type': 'application/json',
+                'User-Agent': 'FeedbackBasket-MCP/1.0.0',
+            },
+            timeout: 30000, // 30 second timeout
+        });
+    }
+    /**
+     * List all projects accessible by the API key
+     */
+    async listProjects() {
+        try {
+            const response = await this.api.post('/projects', {});
+            const projects = response.data.projects;
+            if (projects.length === 0) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: 'No projects found. Make sure your API key has access to projects in your FeedbackBasket dashboard.'
+                        }]
+                };
+            }
+            const projectList = projects.map(project => {
+                const totalFeedback = project.stats.totalFeedback;
+                const pendingCount = project.stats.byStatus.PENDING;
+                const bugCount = project.stats.byCategory.BUG;
+                return [
+                    `**${project.name}**`,
+                    `  URL: ${project.url}`,
+                    `  Total Feedback: ${totalFeedback}`,
+                    `  Pending: ${pendingCount} | Bugs: ${bugCount}`,
+                    `  Created: ${new Date(project.createdAt).toLocaleDateString()}`,
+                    ''
+                ].join('\n');
+            }).join('\n');
+            const summary = [
+                `# FeedbackBasket Projects (${projects.length} total)\n`,
+                projectList,
+                `\n*API Key: ${response.data.apiKeyInfo.name} (${response.data.apiKeyInfo.usageCount} uses)*`
+            ].join('\n');
+            return {
+                content: [{
+                        type: 'text',
+                        text: summary
+                    }]
+            };
+        }
+        catch (error) {
+            throw this.handleError('Failed to fetch projects', error);
+        }
+    }
+    /**
+     * Get feedback for projects
+     */
+    async getFeedback(params = {}) {
+        try {
+            const response = await this.api.post('/feedback', {
+                limit: 20,
+                includeNotes: false,
+                ...params,
+            });
+            const feedback = response.data.feedback;
+            if (feedback.length === 0) {
+                const filters = Object.entries(params)
+                    .filter(([_, value]) => value !== undefined)
+                    .map(([key, value]) => `${key}: ${value}`)
+                    .join(', ');
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `No feedback found${filters ? ` with filters: ${filters}` : ''}.`
+                        }]
+                };
+            }
+            const feedbackList = feedback.map(item => {
+                const category = item.category || 'UNCATEGORIZED';
+                const sentiment = item.sentiment || 'UNKNOWN';
+                const confidenceText = item.categoryConfidence
+                    ? ` (${Math.round(item.categoryConfidence * 100)}% confidence)`
+                    : '';
+                return [
+                    `**${category}${confidenceText} | ${sentiment} | ${item.status}**`,
+                    `Project: ${item.project.name}`,
+                    `Content: ${item.content.length > 100 ? item.content.substring(0, 100) + '...' : item.content}`,
+                    item.email ? `Email: ${item.email}` : '',
+                    item.notes && params.includeNotes ? `Notes: ${item.notes}` : '',
+                    `Created: ${new Date(item.createdAt).toLocaleDateString()}`,
+                    ''
+                ].filter(Boolean).join('\n');
+            }).join('\n');
+            const summary = [
+                `# Feedback Results (${feedback.length} of ${response.data.pagination.totalCount})\n`,
+                feedbackList,
+                response.data.pagination.hasMore ? `\n*Showing first ${feedback.length} results. Use offset parameter to get more.*` : '',
+                `\n*API Key: ${response.data.apiKeyInfo.name}*`
+            ].join('\n');
+            return {
+                content: [{
+                        type: 'text',
+                        text: summary
+                    }]
+            };
+        }
+        catch (error) {
+            throw this.handleError('Failed to fetch feedback', error);
+        }
+    }
+    /**
+     * Get bug reports specifically
+     */
+    async getBugReports(params = {}) {
+        try {
+            const response = await this.api.post('/feedback/bugs', {
+                limit: 20,
+                includeNotes: false,
+                ...params,
+            });
+            const bugReports = response.data.bugReports;
+            if (bugReports.length === 0) {
+                const filters = Object.entries(params)
+                    .filter(([_, value]) => value !== undefined)
+                    .map(([key, value]) => `${key}: ${value}`)
+                    .join(', ');
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `No bug reports found${filters ? ` with filters: ${filters}` : ''}.`
+                        }]
+                };
+            }
+            const bugList = bugReports.map(bug => {
+                const severityEmoji = bug.severity === 'high' ? '🔴' : bug.severity === 'medium' ? '🟡' : '🟢';
+                const statusEmoji = bug.status === 'PENDING' ? '⏳' : bug.status === 'REVIEWED' ? '👁️' : '✅';
+                return [
+                    `${severityEmoji} **${bug.severity.toUpperCase()} SEVERITY** ${statusEmoji} ${bug.status}`,
+                    `Project: ${bug.project.name}`,
+                    `Bug: ${bug.content.length > 150 ? bug.content.substring(0, 150) + '...' : bug.content}`,
+                    bug.email ? `Reported by: ${bug.email}` : '',
+                    bug.notes && params.includeNotes ? `Notes: ${bug.notes}` : '',
+                    `Reported: ${new Date(bug.createdAt).toLocaleDateString()}`,
+                    ''
+                ].filter(Boolean).join('\n');
+            }).join('\n');
+            const stats = response.data.stats;
+            const statsText = [
+                `## Bug Statistics`,
+                `Total Bugs: ${stats.totalBugs}`,
+                `🔴 High: ${stats.bySeverity.high} | 🟡 Medium: ${stats.bySeverity.medium} | 🟢 Low: ${stats.bySeverity.low}`,
+                `⏳ Pending: ${stats.byStatus.pending} | 👁️ Reviewed: ${stats.byStatus.reviewed} | ✅ Done: ${stats.byStatus.done}`,
+                ''
+            ].join('\n');
+            const summary = [
+                `# Bug Reports (${bugReports.length} of ${response.data.pagination.totalCount})\n`,
+                statsText,
+                bugList,
+                response.data.pagination.hasMore ? `\n*Showing first ${bugReports.length} results. Use offset parameter to get more.*` : '',
+                `\n*API Key: ${response.data.apiKeyInfo.name}*`
+            ].join('\n');
+            return {
+                content: [{
+                        type: 'text',
+                        text: summary
+                    }]
+            };
+        }
+        catch (error) {
+            throw this.handleError('Failed to fetch bug reports', error);
+        }
+    }
+    /**
+     * Search feedback across all accessible projects
+     */
+    async searchFeedback(query, options = {}) {
+        return this.getFeedback({
+            search: query,
+            limit: options.limit || 10,
+            ...(options.projectId && { projectId: options.projectId }),
+            ...(options.category && { category: options.category }),
+        });
+    }
+    handleError(message, error) {
+        if (error instanceof AxiosError) {
+            const status = error.response?.status;
+            const responseMessage = error.response?.data?.message || error.message;
+            if (status === 401) {
+                return new Error(`Authentication failed: ${responseMessage}. Check your API key.`);
+            }
+            else if (status === 403) {
+                return new Error(`Access denied: ${responseMessage}. Check your API key permissions.`);
+            }
+            else if (status === 429) {
+                return new Error(`Rate limit exceeded: ${responseMessage}. Please try again later.`);
+            }
+            else {
+                return new Error(`${message}: ${responseMessage} (HTTP ${status})`);
+            }
+        }
+        return new Error(`${message}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,230 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { program } from 'commander';
+import { FeedbackBasketClient } from './client.js';
+// Parse command line arguments
+program
+    .option('--api-key <key>', 'FeedbackBasket API key')
+    .option('--base-url <url>', 'Base URL for FeedbackBasket API', 'https://feedbackbasket.com')
+    .parse();
+const options = program.opts();
+const apiKey = options.apiKey || process.env.FEEDBACKBASKET_API_KEY;
+if (!apiKey) {
+    console.error('Error: API key required.');
+    console.error('Usage: Use --api-key option or set FEEDBACKBASKET_API_KEY environment variable');
+    process.exit(1);
+}
+// Validate API key format
+if (!/^fb_key_[a-f0-9]{64}$/.test(apiKey)) {
+    console.error('Error: Invalid API key format. API keys should start with "fb_key_" followed by 64 hexadecimal characters.');
+    process.exit(1);
+}
+const client = new FeedbackBasketClient(apiKey, options.baseUrl);
+// Create MCP server
+const server = new Server({
+    name: 'feedbackbasket-mcp',
+    version: '1.0.0',
+    capabilities: {
+        tools: {},
+    },
+});
+// List available tools
+server.setRequestHandler(ListToolsRequestSchema, async (_request) => {
+    return {
+        tools: [
+            {
+                name: 'list_projects',
+                description: 'List all FeedbackBasket projects accessible by your API key with summary statistics',
+                inputSchema: {
+                    type: 'object',
+                    properties: {},
+                    additionalProperties: false,
+                },
+            },
+            {
+                name: 'get_feedback',
+                description: 'Get feedback from your FeedbackBasket projects with filtering options',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        projectId: {
+                            type: 'string',
+                            description: 'Filter by specific project ID',
+                        },
+                        category: {
+                            type: 'string',
+                            enum: ['BUG', 'FEATURE', 'REVIEW'],
+                            description: 'Filter by feedback category',
+                        },
+                        status: {
+                            type: 'string',
+                            enum: ['PENDING', 'REVIEWED', 'DONE'],
+                            description: 'Filter by feedback status',
+                        },
+                        sentiment: {
+                            type: 'string',
+                            enum: ['POSITIVE', 'NEGATIVE', 'NEUTRAL'],
+                            description: 'Filter by sentiment analysis result',
+                        },
+                        search: {
+                            type: 'string',
+                            description: 'Search feedback content for specific text',
+                        },
+                        limit: {
+                            type: 'number',
+                            description: 'Maximum number of results to return (default: 20, max: 100)',
+                            minimum: 1,
+                            maximum: 100,
+                        },
+                        includeNotes: {
+                            type: 'boolean',
+                            description: 'Include internal notes in the response (default: false)',
+                        },
+                    },
+                    additionalProperties: false,
+                },
+            },
+            {
+                name: 'get_bug_reports',
+                description: 'Get bug reports specifically from your FeedbackBasket projects',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        projectId: {
+                            type: 'string',
+                            description: 'Filter by specific project ID',
+                        },
+                        status: {
+                            type: 'string',
+                            enum: ['PENDING', 'REVIEWED', 'DONE'],
+                            description: 'Filter by bug status',
+                        },
+                        severity: {
+                            type: 'string',
+                            enum: ['high', 'medium', 'low'],
+                            description: 'Filter by computed severity (based on sentiment: negative=high, neutral=medium, positive=low)',
+                        },
+                        search: {
+                            type: 'string',
+                            description: 'Search bug report content for specific text',
+                        },
+                        limit: {
+                            type: 'number',
+                            description: 'Maximum number of results to return (default: 20, max: 100)',
+                            minimum: 1,
+                            maximum: 100,
+                        },
+                        includeNotes: {
+                            type: 'boolean',
+                            description: 'Include internal notes in the response (default: false)',
+                        },
+                    },
+                    additionalProperties: false,
+                },
+            },
+            {
+                name: 'search_feedback',
+                description: 'Search for feedback across all accessible projects using text search',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        query: {
+                            type: 'string',
+                            description: 'Search query to find in feedback content',
+                        },
+                        projectId: {
+                            type: 'string',
+                            description: 'Limit search to specific project',
+                        },
+                        category: {
+                            type: 'string',
+                            enum: ['BUG', 'FEATURE', 'REVIEW'],
+                            description: 'Filter search results by category',
+                        },
+                        limit: {
+                            type: 'number',
+                            description: 'Maximum number of results (default: 10)',
+                            minimum: 1,
+                            maximum: 50,
+                        },
+                    },
+                    required: ['query'],
+                    additionalProperties: false,
+                },
+            },
+        ],
+    };
+});
+// Handle tool calls
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        switch (name) {
+            case 'list_projects':
+                return await client.listProjects();
+            case 'get_feedback':
+                return await client.getFeedback(args || {});
+            case 'get_bug_reports':
+                return await client.getBugReports(args || {});
+            case 'search_feedback':
+                if (!args || typeof args !== 'object' || !('query' in args) || typeof args.query !== 'string') {
+                    throw new Error('Search query is required');
+                }
+                const searchOptions = {};
+                if (typeof args.projectId === 'string') {
+                    searchOptions.projectId = args.projectId;
+                }
+                if (typeof args.category === 'string' && ['BUG', 'FEATURE', 'REVIEW'].includes(args.category)) {
+                    searchOptions.category = args.category;
+                }
+                if (typeof args.limit === 'number') {
+                    searchOptions.limit = args.limit;
+                }
+                return await client.searchFeedback(args.query, searchOptions);
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error: ${errorMessage}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+// Start the server
+async function main() {
+    try {
+        const transport = new StdioServerTransport();
+        await server.connect(transport);
+        // Server is now running and will handle requests via stdio
+        console.error('FeedbackBasket MCP server started successfully');
+    }
+    catch (error) {
+        console.error('Failed to start MCP server:', error);
+        process.exit(1);
+    }
+}
+// Handle graceful shutdown
+process.on('SIGINT', () => {
+    console.error('Received SIGINT, shutting down gracefully...');
+    process.exit(0);
+});
+process.on('SIGTERM', () => {
+    console.error('Received SIGTERM, shutting down gracefully...');
+    process.exit(0);
+});
+if (import.meta.url === `file://${process.argv[1]}`) {
+    main().catch((error) => {
+        console.error('Fatal error:', error);
+        process.exit(1);
+    });
+}

package/dist/types.d.ts

@@ -0,0 +1,117 @@
+export interface Project {
+    id: string;
+    name: string;
+    url: string;
+    description?: string;
+    createdAt: string;
+    updatedAt: string;
+    stats: {
+        totalFeedback: number;
+        byCategory: {
+            BUG: number;
+            FEATURE: number;
+            REVIEW: number;
+            UNKNOWN: number;
+        };
+        byStatus: {
+            PENDING: number;
+            REVIEWED: number;
+            DONE: number;
+        };
+    };
+}
+export interface Feedback {
+    id: string;
+    content: string;
+    email?: string;
+    status: 'PENDING' | 'REVIEWED' | 'DONE';
+    notes?: string;
+    category?: 'BUG' | 'FEATURE' | 'REVIEW';
+    categorySource: 'manual' | 'ai';
+    categoryConfidence?: number;
+    sentiment?: 'POSITIVE' | 'NEGATIVE' | 'NEUTRAL';
+    sentimentSource: 'manual' | 'ai';
+    sentimentConfidence?: number;
+    isAiAnalyzed: boolean;
+    aiAnalyzedAt?: string;
+    aiReasoning?: string;
+    project: {
+        id: string;
+        name: string;
+        url: string;
+    };
+    createdAt: string;
+    updatedAt: string;
+}
+export interface BugReport extends Feedback {
+    severity: 'high' | 'medium' | 'low';
+}
+export interface FeedbackBasketResponse<T> {
+    data?: T;
+    error?: {
+        message: string;
+        code?: string;
+    };
+}
+export interface ProjectsResponse {
+    projects: Project[];
+    totalProjects: number;
+    apiKeyInfo: {
+        name: string;
+        usageCount: number;
+    };
+}
+export interface FeedbackResponse {
+    feedback: Feedback[];
+    pagination: {
+        totalCount: number;
+        limit: number;
+        offset: number;
+        hasMore: boolean;
+        nextOffset: number | null;
+    };
+    filters: {
+        projectId?: string;
+        category?: string;
+        status?: string;
+        sentiment?: string;
+        search?: string;
+    };
+    apiKeyInfo: {
+        name: string;
+        usageCount: number;
+    };
+}
+export interface BugReportsResponse {
+    bugReports: BugReport[];
+    stats: {
+        totalBugs: number;
+        bySeverity: {
+            high: number;
+            medium: number;
+            low: number;
+        };
+        byStatus: {
+            pending: number;
+            reviewed: number;
+            done: number;
+        };
+    };
+    pagination: {
+        totalCount: number;
+        limit: number;
+        offset: number;
+        hasMore: boolean;
+        nextOffset: number | null;
+    };
+    filters: {
+        projectId?: string;
+        status?: string;
+        severity?: string;
+        search?: string;
+    };
+    apiKeyInfo: {
+        name: string;
+        usageCount: number;
+    };
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+// Shared types for the MCP server based on actual database schema
+export {};

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "feedbackbasket-mcp-server",
+  "version": "1.0.0",
+  "description": "MCP server for FeedbackBasket project data access",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "feedbackbasket-mcp-server": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsx src/index.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "feedbackbasket",
+    "feedback",
+    "projects",
+    "ai-assistant",
+    "claude-desktop",
+    "cursor"
+  ],
+  "author": "deifosv",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/deifos/feedbackbasket-mcp.git"
+  },
+  "homepage": "https://feedbackbasket.com",
+  "bugs": {
+    "url": "https://github.com/deifos/feedbackbasket-mcp/issues"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^0.4.0",
+    "axios": "^1.6.0",
+    "commander": "^11.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0",
+    "tsx": "^4.0.0"
+  },
+  "files": [
+    "dist/**/*",
+    "README.md"
+  ]
+}