@maka/maka-cli 5.2.6 → 5.2.7

package/bundle/typescript/src/commands/ai/mcp.sub.cmd.js

@@ -0,0 +1,964 @@
+import AICommand from './ai.command.js';
+import Maka from '../maka.cmd.js';
+import { Command } from '../../command.js';
+import { Log } from '../../tools/log/log.class.js';
+import express from 'express';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { z } from 'zod';
+import cors from 'cors';
+import path from 'path';
+import fs from 'fs';
+import { fileURLToPath } from 'url';
+import { execSync } from 'child_process';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+/**
+ * Get all commands from the Maka CLI
+ */
+const getAllCommands = (cmd, prefix = '') => {
+    const commands = [];
+    if (cmd._commands && cmd._commands.length > 0) {
+        for (const subCmd of cmd._commands) {
+            const fullName = prefix ? `${prefix}:${subCmd.name}` : subCmd.name;
+            // Skip internal/hidden commands
+            if (subCmd.name === 'murder' || subCmd.name === 'play') {
+                continue;
+            }
+            commands.push({
+                name: fullName,
+                aliases: subCmd.aliases ? subCmd.aliases() : 'None',
+                shortDesc: subCmd.shortDesc ? subCmd.shortDesc() : '',
+                description: subCmd.description ? subCmd.description() : '',
+                usage: subCmd.options?.usage || `maka ${fullName}`,
+                examples: subCmd.options?.examples || [],
+                validOpts: subCmd.options?.validOpts || [],
+                requiredOpts: subCmd.options?.requiredOpts || [],
+                experimental: subCmd.experimental ? subCmd.experimental() : false
+            });
+            // Recursively get subcommands
+            const subCommands = getAllCommands(subCmd, fullName);
+            commands.push(...subCommands);
+        }
+    }
+    return commands;
+};
+/**
+ * Get project configuration if in a Maka project
+ */
+const getProjectInfo = (projectPath) => {
+    try {
+        const configPath = path.join(projectPath, '.maka', 'config.json');
+        if (fs.existsSync(configPath)) {
+            const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+            return {
+                isMakaProject: true,
+                config,
+                projectPath
+            };
+        }
+    }
+    catch (e) {
+        // Not a Maka project or config error
+    }
+    return {
+        isMakaProject: false,
+        projectPath
+    };
+};
+/**
+ * Creates and configures the MCP server with tools and resources
+ */
+const createMcpServer = (projectPath, tool) => {
+    const server = new McpServer({
+        name: 'maka-cli-mcp-server',
+        version: '1.0.0'
+    }, {
+        capabilities: {
+            logging: {},
+            tools: {},
+            resources: {},
+            prompts: {}
+        }
+    });
+    const commands = getAllCommands(Maka);
+    const projectInfo = getProjectInfo(projectPath);
+    // Resource: Agent Instructions - How to work with Maka CLI
+    server.resource('agent-instructions', 'maka://instructions/agent-workflow', {
+        mimeType: 'text/markdown',
+        description: '⭐ CRITICAL: Read this first! Instructions for AI agents on how to properly work with Maka CLI'
+    }, async () => {
+        return {
+            contents: [
+                {
+                    uri: 'maka://instructions/agent-workflow',
+                    mimeType: 'text/markdown',
+                    text: `# Maka CLI Agent Workflow Instructions
+
+## ⚠️ CRITICAL: Read This Before Using Any Maka Commands
+
+### What is Maka CLI?
+
+Maka-CLI is a command line scaffolding tool for building modern web applications. It organizes file structure and automates package installation for React, GraphQL, REST APIs, Material-UI, and testing frameworks. Maka-CLI integrates with Meteor.js to develop high-performing, scalable Node.js applications deployable to on-prem and cloud infrastructures.
+
+### Key Maka Project Principles
+
+**IMPORTANT Directory Information:**
+- Maka commands can be run from **anywhere in the project** - you do NOT need to navigate to the 'app' directory
+- The CLI automatically detects the project root (where .maka directory exists) and operates relative to it
+- When making changes or generating files, stay in your current directory and let Maka handle the paths
+
+**AVOID Creating new files outside of using maka.**
+- To keep directory structure organized, new resources should be created using a maka generator, and then modified to suite the task.
+- If there is no generator for a a needed file, then it should be created as close to the implementation as possible.
+
+**Package Installation:**
+- Use \`maka npm install <package>\` for npm packages (NOT \`npm install\` directly)
+- Use \`maka add <meteor:package>\` for Meteor packages (NOT \`meteor add\` directly)
+- Maka CLI proxies these commands to the appropriate tools with correct configuration
+
+**Verifying Changes with Logs:**
+- After making changes, use the \`get-run-logs\` tool to inspect recent log output
+- Logs are located in \`.maka/logs/run-[env]-[timestamp].log\`
+- Check log timestamps to ensure the Meteor app is running and logs are current
+- ⚠️ **If logs are not recent (older than a few minutes), the app may not be running!**
+- False positives: Old success messages don't mean current changes worked
+- False negatives: Recent errors might be from old code if app wasn't restarted
+- **Best practice:** Ensure \`maka run\` is active, then check logs after changes appear
+
+
+
+
+### Required Workflow for ALL Maka Commands
+
+**NEVER execute a Maka command without following this workflow:**
+
+#### 1. INVESTIGATE OPTIONS FIRST
+- Use \`get-command-info\` tool to discover all available options for the command
+- Review required options, optional flags, allowed values, and examples
+- Understand what the command does and what it needs
+
+#### 2. BE INTERACTIVE WITH THE USER
+- **You must prompt the user for any required information**
+- Ask clear, specific questions about:
+  - Required parameters (e.g., "What should we name this component?")
+  - Technology choices (e.g., "Would you like to use TypeScript or JavaScript?")
+  - Optional features (e.g., "Should this page be private/authenticated?")
+- Present options as clear choices when applicable
+- Gather ALL necessary information before proceeding
+
+#### 3. CONSTRUCT COMPLETE COMMAND
+- Build the full command with ALL options as flags
+- Use the format: \`maka <command> <name> --option1=value --flag2 --option3=value\`
+- Boolean flags don't need values (use \`--private\`, not \`--private=true\`)
+- **Never rely on Maka's built-in interactive prompts - they don't work via MCP**
+
+#### 4. EXECUTE WITH ALL FLAGS
+- Only execute when you have all required information
+- Always include the "maka" prefix
+- Run from anywhere in the project - no need to change directories
+
+
+#### 6. Use MeteorJS Documentation to create high quality Meteor applications:
+https://docs.meteor.com/about/what-is.html
+https://docs.meteor.com/api/
+
+
+### Examples of Good Agent Behavior
+
+#### Example 1: Creating a Component
+\`\`\`
+User: "I want to create a login component"
+
+Agent: "I'll help you create a login component. Let me gather some information:
+
+1. Should this be in a specific directory? (default: components)
+2. Do you want test files generated? (default: yes)
+3. Any specific styling framework? (options: css, scss, less, stylus)
+
+User: "Put it in components/auth, yes to tests, use scss"
+
+Agent: "Perfect! I'll create the login component now."
+[Executes: maka generate:component login --baseDir=components/auth --withTests --css=scss]
+Agent: "Component created successfully and is ready to use."
+\`\`\`
+
+#### Example 2: Creating a New App
+\`\`\`
+User: "Create a new Meteor app"
+
+Agent: "I'll help you create a new Meteor application. I need some information:
+
+1. What should we name the application?
+2. JavaScript or TypeScript? (js/ts)
+3. Which client framework? (react/vue/blaze)
+4. GraphQL or REST API? (graphql/rest)
+5. CSS framework? (scss/less/css)
+
+User: "Name it MyApp, use TypeScript, React, GraphQL, and SCSS"
+
+Agent: "Great! Creating your application now..."
+[Executes: maka create MyApp --js=ts --client=react --api=graphql --css=scss]
+\`\`\`
+
+#### Example 3: Installing Packages
+\`\`\`
+User: "I need to add lodash and the accounts package"
+
+Agent: "I'll install those packages for you using the Maka CLI."
+[Executes: maka npm install lodash]
+[Executes: maka add accounts-password]
+Agent: "Packages installed successfully! lodash and accounts-password are ready to use."
+\`\`\`
+
+#### Example 4: Working from Any Directory
+\`\`\`
+User: "Add a new route for the dashboard"
+
+Agent: "I'll create a dashboard route. No need to change directories - Maka handles the paths."
+[Executes: maka generate:route dashboard --private --url=/dashboard]
+Agent: "Dashboard route created successfully and is configured."
+\`\`\`
+
+### Common Pitfalls to Avoid
+
+❌ **BAD:** Executing \`maka create MyApp\` and letting Maka prompt for options
+✅ **GOOD:** Asking user for preferences, then executing \`maka create MyApp --js=ts --client=react --api=graphql\`
+
+❌ **BAD:** Running \`npm install lodash\` directly
+✅ **GOOD:** Running \`maka npm install lodash\` through Maka CLI
+
+❌ **BAD:** Running \`cd app && maka generate:component MyComponent\`
+✅ **GOOD:** Running \`maka generate:component MyComponent\` from anywhere in the project
+
+### Summary
+
+**Your role as an AI agent:**
+1. 🔍 **Investigate** - Use get-command-info to understand the command
+2. 💬 **Interact** - Prompt the user for all necessary information
+3. 🔧 **Construct** - Build complete command with all flags
+4. ▶️ **Execute** - Run the command with full options (from anywhere in the project)
+
+**Remember:**
+- Run Maka commands from anywhere in the project (no need to cd to 'app')
+- Use \`maka npm install\` and \`maka add\` for package management
+- Provide all options as command-line flags (interactive prompts don't work via MCP)
+
+This ensures a smooth experience since Maka's interactive prompts cannot work through the MCP protocol.`
+                }
+            ]
+        };
+    });
+    // Tool: List all available Maka CLI commands
+    server.tool('list-maka-commands', 'List all available Maka CLI commands with descriptions. NOTE: Many commands support interactive prompts, but when using via MCP/API, always provide all required options as command-line flags to avoid interactive prompts.', {
+        filter: z.string().optional().describe('Filter commands by name or category (e.g., "aws", "generate", "deploy")')
+    }, async ({ filter }) => {
+        let filteredCommands = commands;
+        if (filter) {
+            filteredCommands = commands.filter(cmd => cmd.name.toLowerCase().includes(filter.toLowerCase()) ||
+                cmd.shortDesc.toLowerCase().includes(filter.toLowerCase()));
+        }
+        const commandList = filteredCommands.map(cmd => {
+            const experimental = cmd.experimental ? ' (experimental)' : '';
+            return `• maka ${cmd.name}${experimental}\n  ${cmd.shortDesc}\n  Usage: ${cmd.usage}`;
+        }).join('\n\n');
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Available Maka CLI Commands:\n\n${commandList}\n\nTotal: ${filteredCommands.length} commands\n\n⚠️  IMPORTANT NOTES:\n• All commands must be prefixed with "maka" when executing\n• Always provide all options as command-line flags (e.g., --option=value)\n• Never rely on interactive prompts - use get-command-info to see available options\n• Example: maka generate:page myPage --private --url=/custom-path`
+                }
+            ]
+        };
+    });
+    // Tool: Get detailed command information
+    server.tool('get-command-info', 'Get detailed information about a specific Maka CLI command', {
+        command: z.string().describe('Command name (e.g., "create", "generate:component", "aws:create-instance")')
+    }, async ({ command }) => {
+        const cmd = commands.find(c => c.name === command ||
+            c.name.replace(/:/g, '-') === command ||
+            c.aliases === command);
+        if (!cmd) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Command "${command}" not found. Use list-maka-commands to see available commands.`
+                    }
+                ]
+            };
+        }
+        // Format valid options with details if available
+        const formatValidOpts = (opts) => {
+            if (!opts || opts.length === 0)
+                return null;
+            return opts.map((opt) => {
+                if (typeof opt === 'string') {
+                    return `  --${opt}`;
+                }
+                else if (opt.name) {
+                    const parts = [`  --${opt.name}`];
+                    if (opt.boolFlag)
+                        parts.push(' (boolean flag)');
+                    if (opt.description)
+                        parts.push(`\n    ${opt.description}`);
+                    if (opt.values)
+                        parts.push(`\n    Allowed values: ${opt.values.join(', ')}`);
+                    return parts.join('');
+                }
+                return `  --${opt}`;
+            }).join('\n');
+        };
+        const validOptsFormatted = formatValidOpts(cmd.validOpts);
+        const requiredOptsFormatted = cmd.requiredOpts?.length > 0
+            ? cmd.requiredOpts.map((o) => `  --${o.name || o}`).join('\n')
+            : null;
+        const details = [
+            `Command: maka ${cmd.name}`,
+            cmd.aliases !== 'None' ? `Aliases: maka ${cmd.aliases}` : null,
+            `\nDescription:\n${cmd.description || cmd.shortDesc}`,
+            `\nUsage:\n${cmd.usage}`,
+            requiredOptsFormatted ? `\n⚠️  Required Options (must be provided):\n${requiredOptsFormatted}` : null,
+            validOptsFormatted ? `\nAvailable Options:\n${validOptsFormatted}` : null,
+            cmd.examples?.length > 0 ? `\nExamples:\n${cmd.examples.map((e) => `  ${e}`).join('\n')}` : null,
+            cmd.experimental ? '\n⚠️  This is an experimental command' : null,
+            `\n💡 IMPORTANT: When executing via MCP/API:`,
+            `   • Always provide options as flags: --option=value or --flag`,
+            `   • Do not rely on interactive prompts`,
+            `   • Use: maka ${cmd.name} <args> [--option=value ...]`
+        ].filter(Boolean).join('\n');
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: details
+                }
+            ]
+        };
+    });
+    // Tool: Execute Maka CLI command (read-only operations)
+    server.tool('execute-maka-command', 'Execute a Maka CLI command (use with caution - some commands may modify files). CRITICAL: (1) Always include "maka" prefix, (2) Always provide ALL options as command-line flags to avoid interactive prompts, (3) Use get-command-info first to see available options.', {
+        command: z.string().describe('Full command with all options as flags (e.g., "maka create myApp --js=jsx --css=scss", "maka generate:page homePage --private --url=/home"). NEVER rely on interactive prompts - always specify options explicitly.'),
+        workingDirectory: z.string().optional().describe('Working directory for the command (defaults to current project path)')
+    }, async ({ command, workingDirectory }) => {
+        const cwd = workingDirectory || projectPath;
+        let fullCommand = command.trim();
+        try {
+            // Ensure command starts with "maka"
+            if (!fullCommand.startsWith('maka ') && !fullCommand.startsWith('maka\t')) {
+                fullCommand = `maka ${fullCommand}`;
+            }
+            // Safety check: prevent destructive operations
+            // Use word boundaries to avoid false positives (e.g., "rm" in "confirm")
+            const dangerousCommands = ['murder', 'uninstall', 'delete'];
+            const dangerousPattern = new RegExp(`\\b(${dangerousCommands.join('|')})\\b`, 'i');
+            // Check for standalone 'rm' command (not as part of other words)
+            const rmPattern = /\brm\s+/i;
+            if (dangerousPattern.test(fullCommand) || rmPattern.test(fullCommand)) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: '⚠️  This command may be destructive and cannot be executed via MCP for safety reasons.'
+                        }
+                    ]
+                };
+            }
+            const output = execSync(fullCommand, {
+                cwd,
+                encoding: 'utf-8',
+                timeout: 120000, // 2 minutes for create commands
+                maxBuffer: 10 * 1024 * 1024, // 10MB
+                stdio: 'pipe' // Ensure we capture all output
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `✅ Command executed successfully:\n${fullCommand}\n\nOutput:\n${output}`
+                    }
+                ]
+            };
+        }
+        catch (error) {
+            // Capture all available error information
+            const errorDetails = [
+                `❌ Error executing command: ${fullCommand}`,
+                `\nWorking Directory: ${cwd}`,
+                `\nError Message: ${error.message}`,
+                error.stdout ? `\nStdout:\n${error.stdout}` : '',
+                error.stderr ? `\nStderr:\n${error.stderr}` : '',
+                error.status !== undefined ? `\nExit Code: ${error.status}` : '',
+                error.signal ? `\nSignal: ${error.signal}` : ''
+            ].filter(Boolean).join('\n');
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: errorDetails
+                    }
+                ]
+            };
+        }
+    });
+    // Tool: Get run logs
+    server.tool('get-run-logs', 'Read recent Meteor run logs to verify changes and check application status. IMPORTANT: Check log timestamps - if logs are old, the app may not be running!', {
+        env: z.string().optional().describe('Environment name (e.g., "local", "development"). Defaults to "local"'),
+        lines: z.number().optional().describe('Number of lines to read from the end of the most recent log file (default: 100)')
+    }, async ({ env, lines }) => {
+        if (!projectInfo.isMakaProject) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Not in a Maka project. Run logs are only available in Maka projects.'
+                    }
+                ]
+            };
+        }
+        try {
+            const environment = env || 'local';
+            const lineCount = lines || 100;
+            const logsDir = path.join(projectPath, '.maka', 'logs');
+            if (!fs.existsSync(logsDir)) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `No logs directory found at .maka/logs/\n\nThis usually means:\n1. The app has never been run with \`maka run\`, OR\n2. Logging was disabled with \`--no-log\` flag\n\nTo generate logs, run: maka run`
+                        }
+                    ]
+                };
+            }
+            // Try to use the "latest" log file first (symlink or copy)
+            const latestLogPath = path.join(logsDir, `run-${environment}-latest.log`);
+            let mostRecentLog = null;
+            if (fs.existsSync(latestLogPath)) {
+                // Use the latest log file
+                const stats = fs.statSync(latestLogPath);
+                mostRecentLog = {
+                    name: `run-${environment}-latest.log`,
+                    path: latestLogPath,
+                    mtime: stats.mtime
+                };
+            }
+            else {
+                // Fallback: Find all log files for this environment and use most recent
+                const logFiles = fs.readdirSync(logsDir)
+                    .filter(file => file.startsWith(`run-${environment}-`) && file.endsWith('.log') && !file.includes('latest'))
+                    .map(file => ({
+                    name: file,
+                    path: path.join(logsDir, file),
+                    mtime: fs.statSync(path.join(logsDir, file)).mtime
+                }))
+                    .sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+                if (logFiles.length === 0) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: `No log files found for environment: ${environment}\n\nAvailable log files:\n${fs.readdirSync(logsDir).join('\n')}\n\nTo generate logs for this environment, run: maka run --env=${environment}`
+                            }
+                        ]
+                    };
+                }
+                mostRecentLog = logFiles[0];
+            }
+            const logContent = fs.readFileSync(mostRecentLog.path, 'utf-8');
+            const logLines = logContent.split('\n');
+            const recentLines = logLines.slice(-lineCount).join('\n');
+            // Calculate how old the log is
+            const now = new Date();
+            const logAge = Math.floor((now.getTime() - mostRecentLog.mtime.getTime()) / 1000);
+            const logAgeMinutes = Math.floor(logAge / 60);
+            const logAgeSeconds = logAge % 60;
+            let ageWarning = '';
+            if (logAge > 300) { // 5 minutes
+                ageWarning = `\n⚠️  WARNING: This log is ${logAgeMinutes} minutes old! The Meteor app may not be running.\n`;
+            }
+            else if (logAge > 60) {
+                ageWarning = `\n⚠️  Note: Log is ${logAgeMinutes} minutes ${logAgeSeconds} seconds old.\n`;
+            }
+            else {
+                ageWarning = `\n✅ Log is recent (${logAgeSeconds} seconds old) - app appears to be running.\n`;
+            }
+            // Count total log files for this environment
+            const allLogFiles = fs.readdirSync(logsDir)
+                .filter(file => file.startsWith(`run-${environment}-`) && file.endsWith('.log') && !file.includes('latest'));
+            const response = [
+                `Most Recent Log: ${mostRecentLog.name}`,
+                `Last Modified: ${mostRecentLog.mtime.toISOString()}`,
+                ageWarning,
+                `Showing last ${lineCount} lines:\n`,
+                `${'='.repeat(80)}`,
+                recentLines,
+                `${'='.repeat(80)}`,
+                `\nTotal log files for ${environment}: ${allLogFiles.length}`,
+                `Log file path: ${path.relative(projectPath, mostRecentLog.path)}`
+            ].join('\n');
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: response
+                    }
+                ]
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error reading logs: ${error.message}`
+                    }
+                ]
+            };
+        }
+    });
+    // Tool: Get project information
+    server.tool('get-project-info', 'Get information about the current Maka project', {}, async () => {
+        if (!projectInfo.isMakaProject) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Current directory is not a Maka project.\nPath: ${projectPath}\n\nTo create a new Maka project, use: maka create <app-name>`
+                    }
+                ]
+            };
+        }
+        const info = [
+            `Project Information:`,
+            `\nProject Path: ${projectPath}`,
+            `\nConfiguration:\n${JSON.stringify(projectInfo.config, null, 2)}`
+        ].join('\n');
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: info
+                }
+            ]
+        };
+    });
+    // Resource: Maka CLI Commands Reference
+    server.resource('maka-commands-reference', 'maka://commands/all', {
+        mimeType: 'application/json',
+        description: 'Complete reference of all Maka CLI commands in JSON format'
+    }, async () => {
+        return {
+            contents: [
+                {
+                    uri: 'maka://commands/all',
+                    mimeType: 'application/json',
+                    text: JSON.stringify(commands, null, 2)
+                }
+            ]
+        };
+    });
+    // Resource: Project Configuration
+    server.resource('project-config', 'maka://project/config', {
+        mimeType: 'application/json',
+        description: 'Current project configuration'
+    }, async () => {
+        return {
+            contents: [
+                {
+                    uri: 'maka://project/config',
+                    mimeType: 'application/json',
+                    text: JSON.stringify(projectInfo, null, 2)
+                }
+            ]
+        };
+    });
+    // Resource: Maka CLI Version and Info
+    server.resource('maka-info', 'maka://info', {
+        mimeType: 'application/json',
+        description: 'Maka CLI version and system information'
+    }, async () => {
+        try {
+            const versionOutput = execSync('maka --version', {
+                encoding: 'utf-8',
+                cwd: projectPath
+            }).trim();
+            return {
+                contents: [
+                    {
+                        uri: 'maka://info',
+                        mimeType: 'application/json',
+                        text: JSON.stringify({
+                            version: versionOutput,
+                            platform: process.platform,
+                            nodeVersion: process.version,
+                            cwd: projectPath
+                        }, null, 2)
+                    }
+                ]
+            };
+        }
+        catch (error) {
+            return {
+                contents: [
+                    {
+                        uri: 'maka://info',
+                        mimeType: 'application/json',
+                        text: JSON.stringify({
+                            error: 'Failed to get Maka CLI version',
+                            message: error.message
+                        }, null, 2)
+                    }
+                ]
+            };
+        }
+    });
+    // Prompt: Create new component
+    server.prompt('create-component', 'Generate a prompt for creating a new component with Maka CLI', {
+        componentName: z.string().describe('Name of the component to create'),
+        componentType: z.enum(['component', 'page', 'layout', 'template']).optional().describe('Type of component (default: component)')
+    }, async ({ componentName, componentType }) => {
+        const type = componentType || 'component';
+        return {
+            messages: [
+                {
+                    role: 'user',
+                    content: {
+                        type: 'text',
+                        text: `I want to create a new ${type} named "${componentName}" in my Maka project. Can you help me with the correct command and explain what it will generate?`
+                    }
+                },
+                {
+                    role: 'assistant',
+                    content: {
+                        type: 'text',
+                        text: `I'll help you create a ${type} named "${componentName}".\n\nCommand:\nmaka generate:${type} ${componentName}\n\nThis will create:\n- Component file with boilerplate code\n- Associated test file\n- Styles/CSS file\n- Proper imports and exports\n\nWould you like me to show you more options or execute this command?`
+                    }
+                }
+            ]
+        };
+    });
+    // Prompt: Deployment helper
+    server.prompt('deploy-help', 'Get help with deploying a Maka application', {
+        environment: z.enum(['dev', 'staging', 'production']).optional().describe('Target environment'),
+        platform: z.enum(['aws', 'docker', 'custom']).optional().describe('Deployment platform')
+    }, async ({ environment, platform }) => {
+        const env = environment || 'production';
+        const plat = platform || 'aws';
+        return {
+            messages: [
+                {
+                    role: 'user',
+                    content: {
+                        type: 'text',
+                        text: `I need help deploying my Maka application to ${env} environment using ${plat}. What are the steps?`
+                    }
+                },
+                {
+                    role: 'assistant',
+                    content: {
+                        type: 'text',
+                        text: `Here's a guide for deploying to ${env} using ${plat}:\n\n` +
+                            (plat === 'aws' ?
+                                `AWS Deployment Steps:\n1. Configure AWS credentials\n2. Use: maka aws:create-instance --env ${env}\n3. Use: maka deploy --env ${env}\n\nAvailable AWS commands:\n- maka aws:create-instance\n- maka aws:set-host\n- maka aws:terminate-instance\n\nWould you like details on any specific step?` :
+                                plat === 'docker' ?
+                                    `Docker Deployment Steps:\n1. Build: maka build:docker\n2. Configure your docker-compose.yml\n3. Deploy: docker-compose up -d\n\nWould you like help with Docker configuration?` :
+                                    `Custom Deployment:\n1. Build your app: maka run --production\n2. Configure your deployment settings\n3. Use maka deploy command with custom settings\n\nWould you like help with custom deployment configuration?`)
+                    }
+                }
+            ]
+        };
+    });
+    // Prompt: How to use Maka commands via MCP
+    server.prompt('mcp-command-usage', 'Guide on how to properly execute Maka commands via MCP (avoiding interactive prompts)', {}, async () => {
+        return {
+            messages: [
+                {
+                    role: 'user',
+                    content: {
+                        type: 'text',
+                        text: 'How do I properly execute Maka CLI commands through the MCP server?'
+                    }
+                },
+                {
+                    role: 'assistant',
+                    content: {
+                        type: 'text',
+                        text: `📘 Guide: Executing Maka Commands via MCP
+
+🔑 KEY RULES:
+1. Always prefix commands with "maka"
+2. Never rely on interactive prompts
+3. Always provide ALL options as command-line flags
+4. Use get-command-info tool first to see available options
+
+✅ CORRECT USAGE:
+• maka create myApp --js=jsx --css=scss --client=react
+• maka generate:page homePage --private --url=/home
+• maka generate:component Button --baseDir=components
+• maka generate:api Users --withMethods --withRest
+
+❌ INCORRECT USAGE:
+• generate:page homePage (missing "maka" prefix)
+• maka create myApp (missing required options, will prompt)
+• maka generate:page (missing page name)
+
+📋 WORKFLOW:
+1. Use list-maka-commands to find the command
+2. Use get-command-info to see all available options
+3. Execute with execute-maka-command, providing all options
+4. Check the output for success/errors
+
+💡 TIP: Boolean flags don't need values:
+   --private (not --private=true)
+
+Would you like to see specific examples for any command?`
+                    }
+                }
+            ]
+        };
+    });
+    // Prompt: Project setup wizard
+    server.prompt('project-setup', 'Interactive guide for setting up a new Maka project', {
+        projectType: z.enum(['basic', 'full-stack', 'api']).optional().describe('Type of project to create')
+    }, async ({ projectType }) => {
+        const type = projectType || 'basic';
+        return {
+            messages: [
+                {
+                    role: 'user',
+                    content: {
+                        type: 'text',
+                        text: `I want to create a new ${type} Maka project. Can you guide me through the setup?`
+                    }
+                },
+                {
+                    role: 'assistant',
+                    content: {
+                        type: 'text',
+                        text: `I'll guide you through creating a ${type} Maka project!\n\n` +
+                            `Step 1: Create the project\n` +
+                            `Command: maka create <your-app-name>\n\n` +
+                            `Step 2: Navigate to your project\n` +
+                            `Command: cd <your-app-name>\n\n` +
+                            `Step 3: Install dependencies\n` +
+                            `Command: maka install meteor\n\n` +
+                            `Step 4: Run your app\n` +
+                            `Command: maka run\n\n` +
+                            `Additional setup options:\n` +
+                            `- Generate components: maka generate:component <name>\n` +
+                            `- Add API routes: maka generate:api <name>\n` +
+                            `- Configure deployment: Use maka deploy commands\n\n` +
+                            `Would you like help with any specific step?`
+                    }
+                }
+            ]
+        };
+    });
+    return server;
+};
+Command.create({
+    name: 'mcp',
+    usage: 'maka ai:mcp [--port=3000] [--host=localhost]',
+    validOpts: ['port', 'host'],
+    shortDesc: 'Start an MCP server with HTTP transport',
+    description: `
+  Start a Model Context Protocol (MCP) server with HTTP transport.
+
+  The server exposes Maka CLI capabilities, commands, and project information
+  to MCP clients like Claude Desktop or other AI assistants.
+
+  Features:
+    • List all available commands
+    • Get detailed command documentation
+    • Execute Maka CLI commands (with safety restrictions)
+    • Access project information and configuration
+    • Interactive prompts for common workflows
+
+  Options:
+    --port    Port to listen on (default: 3000)
+    --host    Host to bind to (default: localhost)
+  `,
+    examples: [
+        'maka ai:mcp',
+        'maka ai:mcp --port=8080',
+        'maka ai:mcp --host=0.0.0.0 --port=3001'
+    ]
+}, async function (args, opts) {
+    try {
+        const port = opts.port || 5050;
+        const host = opts.host || 'localhost';
+        const projectPath = process.cwd();
+        // Check if we're in a Maka project and create MCP configurations
+        const isMakaProject = this.validateMakaProject();
+        if (isMakaProject) {
+            Log.notice('Detected Maka project - setting up MCP configurations...');
+            // Create .claude directory if it doesn't exist
+            const claudeDir = path.join(projectPath, '.claude');
+            if (!fs.existsSync(claudeDir)) {
+                fs.mkdirSync(claudeDir, { recursive: true });
+            }
+            // Create Claude Code MCP configuration
+            const claudeMcpPath = path.join(claudeDir, 'mcp.json');
+            const claudeMcpConfig = {
+                mcpServers: {
+                    'maka-cli': {
+                        command: 'maka',
+                        args: ['ai:mcp', `--port=${port}`],
+                        autoApprove: ['list-maka-commands', 'get-command-info', 'get-project-info', 'get-run-logs']
+                    }
+                }
+            };
+            if (!fs.existsSync(claudeMcpPath)) {
+                fs.writeFileSync(claudeMcpPath, JSON.stringify(claudeMcpConfig, null, 2));
+                Log.success(`Created Claude Code MCP config: ${path.relative(projectPath, claudeMcpPath)}`);
+            }
+            else {
+                Log.info(`Claude Code MCP config already exists: ${path.relative(projectPath, claudeMcpPath)}`);
+            }
+            // Create .vscode directory if it doesn't exist
+            const vscodeDir = path.join(projectPath, '.vscode');
+            if (!fs.existsSync(vscodeDir)) {
+                fs.mkdirSync(vscodeDir, { recursive: true });
+            }
+            // Create GitHub Copilot / VS Code MCP configuration
+            const vscodeMcpPath = path.join(vscodeDir, 'mcp.json');
+            const vscodeMcpConfig = {
+                servers: {
+                    'maka-cli': {
+                        type: 'http',
+                        url: `http://${host}:${port}/mcp`
+                    }
+                }
+            };
+            if (!fs.existsSync(vscodeMcpPath)) {
+                fs.writeFileSync(vscodeMcpPath, JSON.stringify(vscodeMcpConfig, null, 2));
+                Log.success(`Created VS Code/Copilot MCP config: ${path.relative(projectPath, vscodeMcpPath)}`);
+            }
+            else {
+                Log.info(`VS Code/Copilot MCP config already exists: ${path.relative(projectPath, vscodeMcpPath)}`);
+            }
+        }
+        Log.notice(`Starting Maka CLI MCP Server`);
+        Log.bright(`Project: ${projectPath}`);
+        const app = express();
+        app.use(express.json());
+        // Configure CORS to expose Mcp-Session-Id header for browser-based clients
+        app.use(cors({
+            origin: '*', // Allow all origins - adjust as needed for production
+            exposedHeaders: ['Mcp-Session-Id']
+        }));
+        // Health check endpoint
+        app.get('/health', (req, res) => {
+            res.json({
+                status: 'ok',
+                name: 'maka-cli-mcp-server',
+                version: '1.0.0',
+                projectPath
+            });
+        });
+        // Main MCP endpoint
+        app.post('/mcp', async (req, res) => {
+            const server = createMcpServer(projectPath, this);
+            try {
+                const transport = new StreamableHTTPServerTransport({
+                    sessionIdGenerator: undefined // Stateless mode
+                });
+                await server.connect(transport);
+                await transport.handleRequest(req, res, req.body);
+                res.on('close', () => {
+                    transport.close().catch(console.error);
+                    server.close().catch(console.error);
+                });
+            }
+            catch (error) {
+                console.error('Error handling MCP request:', error);
+                if (!res.headersSent) {
+                    res.status(500).json({
+                        jsonrpc: '2.0',
+                        error: {
+                            code: -32603,
+                            message: 'Internal server error'
+                        },
+                        id: null
+                    });
+                }
+            }
+        });
+        // Handle unsupported methods on /mcp endpoint
+        app.get('/mcp', (req, res) => {
+            res.status(405).json({
+                jsonrpc: '2.0',
+                error: {
+                    code: -32000,
+                    message: 'Method not allowed. Use POST for MCP requests.'
+                },
+                id: null
+            });
+        });
+        app.delete('/mcp', (req, res) => {
+            res.status(405).json({
+                jsonrpc: '2.0',
+                error: {
+                    code: -32000,
+                    message: 'Method not allowed.'
+                },
+                id: null
+            });
+        });
+        // Start the server
+        const server = app.listen(port, host, () => {
+            Log.success(`MCP Server listening on http://${host}:${port}`);
+            Log.notice('\n📋 Register with Claude Code:');
+            Log.bright(`  claude mcp add --transport http maka-cli http://${host}:${port}/mcp`);
+            Log.notice('\n📋 GitHub Copilot / VS Code (.vscode/mcp.json):');
+            Log.bright(`  {`);
+            Log.bright(`    "servers": {`);
+            Log.bright(`      "maka-cli": {`);
+            Log.bright(`        "type": "http",`);
+            Log.bright(`        "url": "http://${host}:${port}/mcp"`);
+            Log.bright(`      }`);
+            Log.bright(`    }`);
+            Log.bright(`  }`);
+            Log.notice('\nEndpoints:');
+            Log.bright(`  POST http://${host}:${port}/mcp - MCP protocol endpoint`);
+            Log.bright(`  GET  http://${host}:${port}/health - Health check`);
+            Log.notice('\nAvailable Tools:');
+            Log.bright('  • list-maka-commands - List all Maka CLI commands');
+            Log.bright('  • get-command-info - Get detailed command information');
+            Log.bright('  • execute-maka-command - Execute Maka CLI commands');
+            Log.bright('  • get-run-logs - Read recent Meteor run logs (check timestamps!)');
+            Log.bright('  • get-project-info - Get current project information');
+            Log.notice('\nAvailable Resources:');
+            Log.bright('  ⭐ maka://instructions/agent-workflow - CRITICAL: Read this first! Agent workflow instructions');
+            Log.bright('  • maka://commands/all - Complete commands reference');
+            Log.bright('  • maka://project/config - Project configuration');
+            Log.bright('  • maka://info - Maka CLI version and system info');
+            Log.notice('\nAvailable Prompts:');
+            Log.bright('  • mcp-command-usage - Guide for using commands via MCP (READ THIS FIRST!)');
+            Log.bright('  • create-component - Component creation wizard');
+            Log.bright('  • deploy-help - Deployment assistance');
+            Log.bright('  • project-setup - Project setup guide');
+            Log.notice('\n⚠️  IMPORTANT for AI Clients:');
+            Log.bright('  • Always provide options as command-line flags');
+            Log.bright('  • Never rely on interactive prompts');
+            Log.bright('  • Use get-command-info to see available options');
+            Log.header('\n Press Ctrl+C to stop the server');
+        });
+        // Handle graceful shutdown
+        const shutdown = async () => {
+            Log.notice('\nShutting down MCP server...');
+            server.close(() => {
+                Log.success('Server stopped');
+                process.exit(0);
+            });
+        };
+        process.on('SIGINT', shutdown);
+        process.on('SIGTERM', shutdown);
+    }
+    catch (e) {
+        Log.error('Failed to start MCP server');
+        console.error(e);
+        process.exit(1);
+    }
+}, AICommand);
+//# sourceMappingURL=mcp.sub.cmd.js.map