@codebakers/cli 3.3.2 → 3.3.4

package/src/mcp/server.ts

@@ -1047,6 +1047,170 @@ class CodeBakersServer {
             },
           },
         },
+        {
+          name: 'detect_intent',
+          description:
+            'CALL THIS FIRST when user request is ambiguous or could match multiple MCP tools. Analyzes user input and returns which MCP tool(s) would be appropriate, with explanations. Show the result to the user and ask for confirmation before executing. This prevents accidental destructive actions.',
+          inputSchema: {
+            type: 'object' as const,
+            properties: {
+              userMessage: {
+                type: 'string',
+                description: 'The user\'s message or request to analyze',
+              },
+            },
+            required: ['userMessage'],
+          },
+        },
+        // VAPI Voice AI Tools
+        {
+          name: 'vapi_connect',
+          description:
+            'Connect to VAPI (Voice AI Platform). Sets up VAPI API credentials for voice assistant integration. Use when user says "connect vapi", "setup voice", "configure vapi", or before using other vapi_* tools.',
+          inputSchema: {
+            type: 'object' as const,
+            properties: {
+              apiKey: {
+                type: 'string',
+                description: 'VAPI API key from https://dashboard.vapi.ai',
+              },
+            },
+            required: ['apiKey'],
+          },
+        },
+        {
+          name: 'vapi_list_assistants',
+          description:
+            'List all VAPI voice assistants in your account. Shows assistant names, IDs, and configurations. Use when user asks "show my assistants", "list voice bots", or "what assistants do I have".',
+          inputSchema: {
+            type: 'object' as const,
+            properties: {
+              limit: {
+                type: 'number',
+                description: 'Maximum number of assistants to return (default: 20)',
+              },
+            },
+          },
+        },
+        {
+          name: 'vapi_create_assistant',
+          description:
+            'Create a new VAPI voice assistant with CodeBakers best practices. Generates assistant with proper prompts, voice settings, and webhook configurations. Use when user says "create assistant", "new voice bot", or "setup voice agent".',
+          inputSchema: {
+            type: 'object' as const,
+            properties: {
+              name: {
+                type: 'string',
+                description: 'Name for the assistant',
+              },
+              description: {
+                type: 'string',
+                description: 'What the assistant should do (e.g., "Customer support for a SaaS product")',
+              },
+              voice: {
+                type: 'string',
+                enum: ['alloy', 'echo', 'fable', 'onyx', 'nova', 'shimmer'],
+                description: 'Voice to use (default: alloy)',
+              },
+              webhookUrl: {
+                type: 'string',
+                description: 'Optional webhook URL for call events',
+              },
+            },
+            required: ['name', 'description'],
+          },
+        },
+        {
+          name: 'vapi_get_assistant',
+          description:
+            'Get details of a specific VAPI assistant including its configuration, prompts, and settings.',
+          inputSchema: {
+            type: 'object' as const,
+            properties: {
+              assistantId: {
+                type: 'string',
+                description: 'The assistant ID to retrieve',
+              },
+            },
+            required: ['assistantId'],
+          },
+        },
+        {
+          name: 'vapi_update_assistant',
+          description:
+            'Update an existing VAPI assistant. Modify prompts, voice settings, or configurations.',
+          inputSchema: {
+            type: 'object' as const,
+            properties: {
+              assistantId: {
+                type: 'string',
+                description: 'The assistant ID to update',
+              },
+              name: {
+                type: 'string',
+                description: 'New name for the assistant',
+              },
+              systemPrompt: {
+                type: 'string',
+                description: 'New system prompt for the assistant',
+              },
+              voice: {
+                type: 'string',
+                enum: ['alloy', 'echo', 'fable', 'onyx', 'nova', 'shimmer'],
+                description: 'New voice to use',
+              },
+            },
+            required: ['assistantId'],
+          },
+        },
+        {
+          name: 'vapi_get_calls',
+          description:
+            'Get recent call logs from VAPI. Shows call duration, status, transcripts, and costs. Use when user asks "show calls", "call history", or "what calls happened".',
+          inputSchema: {
+            type: 'object' as const,
+            properties: {
+              assistantId: {
+                type: 'string',
+                description: 'Filter by assistant ID (optional)',
+              },
+              limit: {
+                type: 'number',
+                description: 'Maximum number of calls to return (default: 20)',
+              },
+            },
+          },
+        },
+        {
+          name: 'vapi_get_call',
+          description:
+            'Get details of a specific call including full transcript, recording URL, and analysis.',
+          inputSchema: {
+            type: 'object' as const,
+            properties: {
+              callId: {
+                type: 'string',
+                description: 'The call ID to retrieve',
+              },
+            },
+            required: ['callId'],
+          },
+        },
+        {
+          name: 'vapi_generate_webhook',
+          description:
+            'Generate a VAPI webhook handler for your Next.js project. Creates API route with proper signature verification and event handling. Use when user says "add vapi webhook", "handle vapi events", or "setup call notifications".',
+          inputSchema: {
+            type: 'object' as const,
+            properties: {
+              events: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Events to handle: call-started, call-ended, speech-update, transcript, function-call, hang, tool-calls',
+              },
+            },
+          },
+        },
       ],
     }));
 
@@ -1180,6 +1344,34 @@ class CodeBakersServer {
         case 'update_patterns':
           return this.handleUpdatePatterns(args as { force?: boolean });
 
+        case 'detect_intent':
+          return this.handleDetectIntent(args as { userMessage: string });
+
+        // VAPI Voice AI handlers
+        case 'vapi_connect':
+          return this.handleVapiConnect(args as { apiKey: string });
+
+        case 'vapi_list_assistants':
+          return this.handleVapiListAssistants(args as { limit?: number });
+
+        case 'vapi_create_assistant':
+          return this.handleVapiCreateAssistant(args as { name: string; description: string; voice?: string; webhookUrl?: string });
+
+        case 'vapi_get_assistant':
+          return this.handleVapiGetAssistant(args as { assistantId: string });
+
+        case 'vapi_update_assistant':
+          return this.handleVapiUpdateAssistant(args as { assistantId: string; name?: string; systemPrompt?: string; voice?: string });
+
+        case 'vapi_get_calls':
+          return this.handleVapiGetCalls(args as { assistantId?: string; limit?: number });
+
+        case 'vapi_get_call':
+          return this.handleVapiGetCall(args as { callId: string });
+
+        case 'vapi_generate_webhook':
+          return this.handleVapiGenerateWebhook(args as { events?: string[] });
+
         default:
           throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
       }
@@ -5303,6 +5495,637 @@ ${handlers.join('\n')}
     };
   }
 
+  /**
+   * Detect intent from user message and suggest appropriate MCP tools
+   * Shows what would happen before executing, for user confirmation
+   */
+  private handleDetectIntent(args: { userMessage: string }) {
+    const { userMessage } = args;
+    const msg = userMessage.toLowerCase();
+
+    // Define intent patterns with their MCP tools
+    const intentPatterns = [
+      {
+        keywords: ['upgrade codebakers', 'update patterns', 'sync patterns', 'download patterns', 'get latest patterns'],
+        tool: 'update_patterns',
+        description: 'Download latest CLAUDE.md and all .claude/ modules from the CodeBakers server',
+        action: 'WRITE - Will overwrite local pattern files with server versions',
+        isDestructive: true,
+      },
+      {
+        keywords: ['upgrade', 'improve code', 'make production ready', 'code quality'],
+        tool: 'upgrade',
+        description: 'Analyze your code for quality improvements (does NOT download patterns)',
+        action: 'READ-ONLY - Analyzes code and suggests improvements',
+        isDestructive: false,
+      },
+      {
+        keywords: ['build', 'create project', 'new project', 'scaffold', 'start fresh'],
+        tool: 'scaffold_project',
+        description: 'Create a new project from scratch with CodeBakers patterns',
+        action: 'WRITE - Will create new files and folders',
+        isDestructive: true,
+      },
+      {
+        keywords: ['add feature', 'implement', 'build feature', 'create feature'],
+        tool: 'optimize_and_build',
+        description: 'Optimize your feature request with AI and fetch relevant patterns',
+        action: 'READ + ASSIST - Fetches patterns and guides implementation',
+        isDestructive: false,
+      },
+      {
+        keywords: ['audit', 'review code', 'check code', 'code review'],
+        tool: 'run_audit',
+        description: 'Run comprehensive code quality audit',
+        action: 'READ-ONLY - Analyzes code and reports issues',
+        isDestructive: false,
+      },
+      {
+        keywords: ['heal', 'fix errors', 'auto-fix', 'fix bugs'],
+        tool: 'heal',
+        description: 'AI-powered error detection and automatic fixing',
+        action: 'WRITE - May modify files to fix errors',
+        isDestructive: true,
+      },
+      {
+        keywords: ['design', 'clone design', 'copy design', 'match design'],
+        tool: 'design',
+        description: 'Clone a design from mockups, screenshots, or websites',
+        action: 'WRITE - Will generate component files',
+        isDestructive: true,
+      },
+      {
+        keywords: ['status', 'progress', "what's built", 'where am i'],
+        tool: 'project_status',
+        description: 'Show current project build progress and stats',
+        action: 'READ-ONLY - Shows project state',
+        isDestructive: false,
+      },
+      {
+        keywords: ['run tests', 'test', 'check tests'],
+        tool: 'run_tests',
+        description: 'Execute the project test suite',
+        action: 'READ-ONLY - Runs tests and reports results',
+        isDestructive: false,
+      },
+      {
+        keywords: ['list patterns', 'show patterns', 'what patterns'],
+        tool: 'list_patterns',
+        description: 'List all available CodeBakers patterns',
+        action: 'READ-ONLY - Shows available patterns',
+        isDestructive: false,
+      },
+      {
+        keywords: ['init', 'initialize', 'add patterns to existing'],
+        tool: 'init_project',
+        description: 'Add CodeBakers patterns to an existing project',
+        action: 'WRITE - Will add CLAUDE.md and .claude/ folder',
+        isDestructive: true,
+      },
+    ];
+
+    // Find matching intents
+    const matches = intentPatterns.filter(pattern =>
+      pattern.keywords.some(keyword => msg.includes(keyword))
+    );
+
+    let response = `# 🔍 Intent Detection\n\n`;
+    response += `**Your message:** "${userMessage}"\n\n`;
+
+    if (matches.length === 0) {
+      response += `## No specific MCP tool detected\n\n`;
+      response += `Your request doesn't clearly match any MCP tool. I'll proceed with general assistance.\n\n`;
+      response += `**Available tools you might want:**\n`;
+      response += `- \`update_patterns\` - Download latest patterns from server\n`;
+      response += `- \`optimize_and_build\` - Get AI help building a feature\n`;
+      response += `- \`run_audit\` - Review your code quality\n`;
+      response += `- \`project_status\` - Check build progress\n`;
+    } else if (matches.length === 1) {
+      const match = matches[0];
+      response += `## Detected Intent\n\n`;
+      response += `| Property | Value |\n`;
+      response += `|----------|-------|\n`;
+      response += `| **Tool** | \`${match.tool}\` |\n`;
+      response += `| **Description** | ${match.description} |\n`;
+      response += `| **Action Type** | ${match.action} |\n`;
+      response += `| **Destructive?** | ${match.isDestructive ? '⚠️ YES - modifies files' : '✅ NO - read-only'} |\n\n`;
+
+      if (match.isDestructive) {
+        response += `### ⚠️ Confirmation Required\n\n`;
+        response += `This action will modify files. Do you want to proceed?\n\n`;
+        response += `**Reply "yes" or "proceed" to execute, or describe what you actually want.**\n`;
+      } else {
+        response += `This is a read-only operation. Safe to proceed.\n\n`;
+        response += `**Reply "yes" to execute, or clarify your request.**\n`;
+      }
+    } else {
+      response += `## Multiple Possible Intents\n\n`;
+      response += `Your request could match several tools:\n\n`;
+
+      matches.forEach((match, i) => {
+        response += `### Option ${i + 1}: \`${match.tool}\`\n`;
+        response += `- **What it does:** ${match.description}\n`;
+        response += `- **Action:** ${match.action}\n`;
+        response += `- **Destructive:** ${match.isDestructive ? '⚠️ Yes' : '✅ No'}\n\n`;
+      });
+
+      response += `**Which option do you want?** Reply with the tool name or option number.\n`;
+    }
+
+    return {
+      content: [{
+        type: 'text' as const,
+        text: response,
+      }],
+    };
+  }
+
+  // ==================== VAPI Voice AI Handlers ====================
+
+  private getVapiKey(): string | null {
+    // Check environment variable first
+    if (process.env.VAPI_API_KEY) {
+      return process.env.VAPI_API_KEY;
+    }
+    // Check .env file in project
+    const cwd = process.cwd();
+    const envPath = path.join(cwd, '.env');
+    if (fs.existsSync(envPath)) {
+      const envContent = fs.readFileSync(envPath, 'utf-8');
+      const match = envContent.match(/VAPI_API_KEY=(.+)/);
+      if (match) {
+        return match[1].trim();
+      }
+    }
+    return null;
+  }
+
+  private async handleVapiConnect(args: { apiKey: string }) {
+    const { apiKey } = args;
+    const cwd = process.cwd();
+
+    let response = `# 🎙️ VAPI Connection Setup\n\n`;
+
+    try {
+      // Test the API key
+      const testResponse = await fetch('https://api.vapi.ai/assistant', {
+        method: 'GET',
+        headers: {
+          'Authorization': `Bearer ${apiKey}`,
+        },
+      });
+
+      if (!testResponse.ok) {
+        response += `## ❌ Invalid API Key\n\n`;
+        response += `The API key could not be validated. Please check:\n`;
+        response += `1. Go to https://dashboard.vapi.ai\n`;
+        response += `2. Navigate to Settings → API Keys\n`;
+        response += `3. Copy your API key and try again\n`;
+        return { content: [{ type: 'text' as const, text: response }] };
+      }
+
+      // Save to .env file
+      const envPath = path.join(cwd, '.env');
+      let envContent = '';
+
+      if (fs.existsSync(envPath)) {
+        envContent = fs.readFileSync(envPath, 'utf-8');
+        if (envContent.includes('VAPI_API_KEY=')) {
+          envContent = envContent.replace(/VAPI_API_KEY=.*/g, `VAPI_API_KEY=${apiKey}`);
+        } else {
+          envContent += `\n# VAPI Voice AI\nVAPI_API_KEY=${apiKey}\n`;
+        }
+      } else {
+        envContent = `# VAPI Voice AI\nVAPI_API_KEY=${apiKey}\n`;
+      }
+
+      fs.writeFileSync(envPath, envContent);
+
+      response += `## ✅ VAPI Connected Successfully!\n\n`;
+      response += `API key saved to \`.env\` file.\n\n`;
+      response += `### Available Commands:\n`;
+      response += `- \`vapi_list_assistants\` - See your assistants\n`;
+      response += `- \`vapi_create_assistant\` - Create a new voice assistant\n`;
+      response += `- \`vapi_get_calls\` - View call history\n`;
+      response += `- \`vapi_generate_webhook\` - Add webhook handler to your project\n`;
+
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Unknown error';
+      response += `## ❌ Connection Failed\n\n`;
+      response += `Error: ${message}\n`;
+    }
+
+    return { content: [{ type: 'text' as const, text: response }] };
+  }
+
+  private async handleVapiListAssistants(args: { limit?: number }) {
+    const { limit = 20 } = args;
+    const vapiKey = this.getVapiKey();
+
+    let response = `# 🎙️ VAPI Assistants\n\n`;
+
+    if (!vapiKey) {
+      response += `## ❌ Not Connected\n\n`;
+      response += `VAPI API key not found. Run \`vapi_connect\` first with your API key.\n`;
+      response += `Get your key at: https://dashboard.vapi.ai\n`;
+      return { content: [{ type: 'text' as const, text: response }] };
+    }
+
+    try {
+      const apiResponse = await fetch(`https://api.vapi.ai/assistant?limit=${limit}`, {
+        method: 'GET',
+        headers: {
+          'Authorization': `Bearer ${vapiKey}`,
+        },
+      });
+
+      if (!apiResponse.ok) {
+        throw new Error(`API error: ${apiResponse.status}`);
+      }
+
+      const assistants = await apiResponse.json();
+
+      if (!assistants || assistants.length === 0) {
+        response += `No assistants found.\n\n`;
+        response += `Create one with \`vapi_create_assistant\`!\n`;
+      } else {
+        response += `| Name | ID | Voice | Created |\n`;
+        response += `|------|-------|-------|--------|\n`;
+
+        for (const a of assistants) {
+          const created = new Date(a.createdAt).toLocaleDateString();
+          const voice = a.voice?.provider || 'default';
+          response += `| ${a.name || 'Unnamed'} | \`${a.id.slice(0, 8)}...\` | ${voice} | ${created} |\n`;
+        }
+
+        response += `\n**Total:** ${assistants.length} assistant(s)\n`;
+      }
+
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Unknown error';
+      response += `## ❌ Error\n\n`;
+      response += `Failed to fetch assistants: ${message}\n`;
+    }
+
+    return { content: [{ type: 'text' as const, text: response }] };
+  }
+
+  private async handleVapiCreateAssistant(args: { name: string; description: string; voice?: string; webhookUrl?: string }) {
+    const { name, description, voice = 'alloy', webhookUrl } = args;
+    const vapiKey = this.getVapiKey();
+
+    let response = `# 🎙️ Create VAPI Assistant\n\n`;
+
+    if (!vapiKey) {
+      response += `## ❌ Not Connected\n\n`;
+      response += `VAPI API key not found. Run \`vapi_connect\` first.\n`;
+      return { content: [{ type: 'text' as const, text: response }] };
+    }
+
+    try {
+      // Build system prompt based on description
+      const systemPrompt = `You are ${name}, a helpful voice assistant. ${description}
+
+Guidelines:
+- Be conversational and natural
+- Keep responses concise (1-2 sentences when possible)
+- Ask clarifying questions if needed
+- Be friendly but professional`;
+
+      const assistantConfig: Record<string, unknown> = {
+        name,
+        model: {
+          provider: 'openai',
+          model: 'gpt-4o-mini',
+          systemPrompt,
+        },
+        voice: {
+          provider: 'openai',
+          voiceId: voice,
+        },
+        firstMessage: `Hi! I'm ${name}. How can I help you today?`,
+      };
+
+      if (webhookUrl) {
+        assistantConfig.serverUrl = webhookUrl;
+      }
+
+      const apiResponse = await fetch('https://api.vapi.ai/assistant', {
+        method: 'POST',
+        headers: {
+          'Authorization': `Bearer ${vapiKey}`,
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(assistantConfig),
+      });
+
+      if (!apiResponse.ok) {
+        const error = await apiResponse.json();
+        throw new Error(error.message || `API error: ${apiResponse.status}`);
+      }
+
+      const assistant = await apiResponse.json();
+
+      response += `## ✅ Assistant Created!\n\n`;
+      response += `| Property | Value |\n`;
+      response += `|----------|-------|\n`;
+      response += `| **Name** | ${assistant.name} |\n`;
+      response += `| **ID** | \`${assistant.id}\` |\n`;
+      response += `| **Voice** | ${voice} |\n`;
+      response += `| **Model** | gpt-4o-mini |\n`;
+
+      response += `\n### Next Steps:\n`;
+      response += `1. Test your assistant at https://dashboard.vapi.ai\n`;
+      response += `2. Add a phone number to receive calls\n`;
+      response += `3. Use \`vapi_generate_webhook\` to handle call events\n`;
+
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Unknown error';
+      response += `## ❌ Creation Failed\n\n`;
+      response += `Error: ${message}\n`;
+    }
+
+    return { content: [{ type: 'text' as const, text: response }] };
+  }
+
+  private async handleVapiGetAssistant(args: { assistantId: string }) {
+    const { assistantId } = args;
+    const vapiKey = this.getVapiKey();
+
+    let response = `# 🎙️ Assistant Details\n\n`;
+
+    if (!vapiKey) {
+      response += `## ❌ Not Connected\n\nRun \`vapi_connect\` first.\n`;
+      return { content: [{ type: 'text' as const, text: response }] };
+    }
+
+    try {
+      const apiResponse = await fetch(`https://api.vapi.ai/assistant/${assistantId}`, {
+        headers: { 'Authorization': `Bearer ${vapiKey}` },
+      });
+
+      if (!apiResponse.ok) {
+        throw new Error(`API error: ${apiResponse.status}`);
+      }
+
+      const a = await apiResponse.json();
+
+      response += `## ${a.name || 'Unnamed Assistant'}\n\n`;
+      response += `| Property | Value |\n`;
+      response += `|----------|-------|\n`;
+      response += `| **ID** | \`${a.id}\` |\n`;
+      response += `| **Voice** | ${a.voice?.voiceId || 'default'} |\n`;
+      response += `| **Model** | ${a.model?.model || 'unknown'} |\n`;
+      response += `| **Created** | ${new Date(a.createdAt).toLocaleString()} |\n`;
+
+      if (a.model?.systemPrompt) {
+        response += `\n### System Prompt:\n\`\`\`\n${a.model.systemPrompt.slice(0, 500)}${a.model.systemPrompt.length > 500 ? '...' : ''}\n\`\`\`\n`;
+      }
+
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Unknown error';
+      response += `## ❌ Error\n\n${message}\n`;
+    }
+
+    return { content: [{ type: 'text' as const, text: response }] };
+  }
+
+  private async handleVapiUpdateAssistant(args: { assistantId: string; name?: string; systemPrompt?: string; voice?: string }) {
+    const { assistantId, name, systemPrompt, voice } = args;
+    const vapiKey = this.getVapiKey();
+
+    let response = `# 🎙️ Update Assistant\n\n`;
+
+    if (!vapiKey) {
+      response += `## ❌ Not Connected\n\nRun \`vapi_connect\` first.\n`;
+      return { content: [{ type: 'text' as const, text: response }] };
+    }
+
+    try {
+      const updates: Record<string, unknown> = {};
+      if (name) updates.name = name;
+      if (systemPrompt) updates.model = { systemPrompt };
+      if (voice) updates.voice = { provider: 'openai', voiceId: voice };
+
+      const apiResponse = await fetch(`https://api.vapi.ai/assistant/${assistantId}`, {
+        method: 'PATCH',
+        headers: {
+          'Authorization': `Bearer ${vapiKey}`,
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(updates),
+      });
+
+      if (!apiResponse.ok) {
+        throw new Error(`API error: ${apiResponse.status}`);
+      }
+
+      response += `## ✅ Assistant Updated!\n\n`;
+      response += `Updated fields:\n`;
+      if (name) response += `- Name: ${name}\n`;
+      if (systemPrompt) response += `- System prompt updated\n`;
+      if (voice) response += `- Voice: ${voice}\n`;
+
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Unknown error';
+      response += `## ❌ Update Failed\n\n${message}\n`;
+    }
+
+    return { content: [{ type: 'text' as const, text: response }] };
+  }
+
+  private async handleVapiGetCalls(args: { assistantId?: string; limit?: number }) {
+    const { assistantId, limit = 20 } = args;
+    const vapiKey = this.getVapiKey();
+
+    let response = `# 🎙️ VAPI Call History\n\n`;
+
+    if (!vapiKey) {
+      response += `## ❌ Not Connected\n\nRun \`vapi_connect\` first.\n`;
+      return { content: [{ type: 'text' as const, text: response }] };
+    }
+
+    try {
+      let url = `https://api.vapi.ai/call?limit=${limit}`;
+      if (assistantId) url += `&assistantId=${assistantId}`;
+
+      const apiResponse = await fetch(url, {
+        headers: { 'Authorization': `Bearer ${vapiKey}` },
+      });
+
+      if (!apiResponse.ok) {
+        throw new Error(`API error: ${apiResponse.status}`);
+      }
+
+      const calls = await apiResponse.json();
+
+      if (!calls || calls.length === 0) {
+        response += `No calls found.\n`;
+      } else {
+        response += `| Date | Duration | Status | Cost |\n`;
+        response += `|------|----------|--------|------|\n`;
+
+        for (const call of calls) {
+          const date = new Date(call.createdAt).toLocaleString();
+          const duration = call.endedAt ? Math.round((new Date(call.endedAt).getTime() - new Date(call.startedAt).getTime()) / 1000) : 0;
+          const cost = call.cost ? `$${call.cost.toFixed(3)}` : '-';
+          response += `| ${date} | ${duration}s | ${call.status} | ${cost} |\n`;
+        }
+
+        response += `\n**Total:** ${calls.length} call(s)\n`;
+      }
+
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Unknown error';
+      response += `## ❌ Error\n\n${message}\n`;
+    }
+
+    return { content: [{ type: 'text' as const, text: response }] };
+  }
+
+  private async handleVapiGetCall(args: { callId: string }) {
+    const { callId } = args;
+    const vapiKey = this.getVapiKey();
+
+    let response = `# 🎙️ Call Details\n\n`;
+
+    if (!vapiKey) {
+      response += `## ❌ Not Connected\n\nRun \`vapi_connect\` first.\n`;
+      return { content: [{ type: 'text' as const, text: response }] };
+    }
+
+    try {
+      const apiResponse = await fetch(`https://api.vapi.ai/call/${callId}`, {
+        headers: { 'Authorization': `Bearer ${vapiKey}` },
+      });
+
+      if (!apiResponse.ok) {
+        throw new Error(`API error: ${apiResponse.status}`);
+      }
+
+      const call = await apiResponse.json();
+
+      response += `| Property | Value |\n`;
+      response += `|----------|-------|\n`;
+      response += `| **ID** | \`${call.id}\` |\n`;
+      response += `| **Status** | ${call.status} |\n`;
+      response += `| **Started** | ${new Date(call.startedAt).toLocaleString()} |\n`;
+      if (call.endedAt) {
+        const duration = Math.round((new Date(call.endedAt).getTime() - new Date(call.startedAt).getTime()) / 1000);
+        response += `| **Duration** | ${duration} seconds |\n`;
+      }
+      if (call.cost) response += `| **Cost** | $${call.cost.toFixed(4)} |\n`;
+      if (call.recordingUrl) response += `| **Recording** | [Listen](${call.recordingUrl}) |\n`;
+
+      if (call.transcript) {
+        response += `\n### Transcript:\n\`\`\`\n${call.transcript.slice(0, 1000)}${call.transcript.length > 1000 ? '...' : ''}\n\`\`\`\n`;
+      }
+
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Unknown error';
+      response += `## ❌ Error\n\n${message}\n`;
+    }
+
+    return { content: [{ type: 'text' as const, text: response }] };
+  }
+
+  private handleVapiGenerateWebhook(args: { events?: string[] }) {
+    const { events = ['call-started', 'call-ended', 'transcript'] } = args;
+    const cwd = process.cwd();
+
+    let response = `# 🎙️ VAPI Webhook Generator\n\n`;
+
+    // Generate webhook handler code
+    const webhookCode = `import { NextRequest, NextResponse } from 'next/server';
+
+// VAPI Webhook Event Types
+type VapiEventType = ${events.map(e => `'${e}'`).join(' | ')};
+
+interface VapiWebhookPayload {
+  type: VapiEventType;
+  call?: {
+    id: string;
+    assistantId: string;
+    phoneNumber?: string;
+    customer?: {
+      number: string;
+      name?: string;
+    };
+  };
+  transcript?: string;
+  timestamp: string;
+}
+
+export async function POST(req: NextRequest) {
+  try {
+    const payload: VapiWebhookPayload = await req.json();
+
+    console.log('[VAPI Webhook]', payload.type, payload.call?.id);
+
+    switch (payload.type) {
+${events.includes('call-started') ? `      case 'call-started':
+        // Handle call started
+        // Example: Log to database, send notification
+        console.log('Call started:', payload.call?.id);
+        break;
+` : ''}${events.includes('call-ended') ? `      case 'call-ended':
+        // Handle call ended
+        // Example: Save transcript, update CRM
+        console.log('Call ended:', payload.call?.id);
+        break;
+` : ''}${events.includes('transcript') ? `      case 'transcript':
+        // Handle real-time transcript updates
+        console.log('Transcript:', payload.transcript);
+        break;
+` : ''}${events.includes('function-call') ? `      case 'function-call':
+        // Handle function calls from assistant
+        // Return data to be spoken by the assistant
+        return NextResponse.json({ result: 'Function executed' });
+` : ''}      default:
+        console.log('Unhandled event:', payload.type);
+    }
+
+    return NextResponse.json({ received: true });
+  } catch (error) {
+    console.error('[VAPI Webhook Error]', error);
+    return NextResponse.json({ error: 'Webhook error' }, { status: 400 });
+  }
+}
+`;
+
+    // Check if API route directory exists
+    const apiDir = path.join(cwd, 'src', 'app', 'api', 'webhooks', 'vapi');
+    const routePath = path.join(apiDir, 'route.ts');
+
+    if (fs.existsSync(routePath)) {
+      response += `## ⚠️ Webhook Already Exists\n\n`;
+      response += `File: \`src/app/api/webhooks/vapi/route.ts\`\n\n`;
+      response += `Here's the updated code if you want to replace it:\n\n`;
+    } else {
+      // Create directory and file
+      fs.mkdirSync(apiDir, { recursive: true });
+      fs.writeFileSync(routePath, webhookCode);
+      response += `## ✅ Webhook Created!\n\n`;
+      response += `File: \`src/app/api/webhooks/vapi/route.ts\`\n\n`;
+    }
+
+    response += `### Generated Code:\n\`\`\`typescript\n${webhookCode}\n\`\`\`\n\n`;
+
+    response += `### Setup Instructions:\n`;
+    response += `1. Deploy your app to get a public URL\n`;
+    response += `2. Go to https://dashboard.vapi.ai → Your Assistant → Settings\n`;
+    response += `3. Set webhook URL to: \`https://your-domain.com/api/webhooks/vapi\`\n`;
+    response += `4. Select events: ${events.join(', ')}\n\n`;
+
+    response += `### Handling Events:\n`;
+    response += `- \`call-started\`: Triggered when a call begins\n`;
+    response += `- \`call-ended\`: Triggered when a call ends (with transcript)\n`;
+    response += `- \`transcript\`: Real-time transcript updates\n`;
+    response += `- \`function-call\`: When assistant calls a custom function\n`;
+
+    return { content: [{ type: 'text' as const, text: response }] };
+  }
+
   async run(): Promise<void> {
     const transport = new StdioServerTransport();
     await this.server.connect(transport);