fraim-framework 2.0.36 → 2.0.38

package/dist/src/cli/setup/auto-mcp-setup.js

@@ -0,0 +1,367 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.autoConfigureMCP = exports.validateSetupResults = exports.promptForGitHubToken = exports.promptForIDESelection = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const prompts_1 = __importDefault(require("prompts"));
+const ide_detector_1 = require("./ide-detector");
+const mcp_config_generator_1 = require("./mcp-config-generator");
+const token_validator_1 = require("./token-validator");
+const promptForIDESelection = async (detectedIDEs) => {
+    console.log(chalk_1.default.green(`✅ Found ${detectedIDEs.length} IDEs that can be configured with FRAIM:\n`));
+    detectedIDEs.forEach((ide, index) => {
+        const configExists = fs_1.default.existsSync((0, ide_detector_1.expandPath)(ide.configPath));
+        const statusIcon = configExists ? '📝' : '📄';
+        const statusText = configExists ? 'has config' : 'new config';
+        console.log(chalk_1.default.white(`   ${index + 1}. ${ide.name} ${statusIcon} (${statusText})`));
+        console.log(chalk_1.default.gray(`      Config: ${ide.configPath}`));
+    });
+    console.log(chalk_1.default.blue('\nFRAIM will add these MCP servers to selected IDEs:'));
+    console.log(chalk_1.default.gray('   • fraim (required for FRAIM workflows)'));
+    console.log(chalk_1.default.gray('   • git (version control integration)'));
+    console.log(chalk_1.default.gray('   • github (GitHub API access)'));
+    console.log(chalk_1.default.gray('   • playwright (browser automation)'));
+    console.log(chalk_1.default.yellow('\n💡 Existing MCP servers will be preserved - only missing servers will be added.'));
+    const response = await (0, prompts_1.default)({
+        type: 'text',
+        name: 'selection',
+        message: 'Configure FRAIM for which IDEs? (Enter \'all\' or numbers like \'1,3\')',
+        initial: 'all',
+        validate: (value) => {
+            if (value.toLowerCase() === 'all')
+                return true;
+            if (value.toLowerCase() === 'none' || value.toLowerCase() === 'skip')
+                return true;
+            const numbers = value.split(',').map(n => parseInt(n.trim()));
+            const valid = numbers.every(n => n >= 1 && n <= detectedIDEs.length && !isNaN(n));
+            return valid || 'Please enter "all", "none", or valid numbers (e.g., "1,3")';
+        }
+    });
+    if (response.selection.toLowerCase() === 'all') {
+        return detectedIDEs;
+    }
+    if (response.selection.toLowerCase() === 'none' || response.selection.toLowerCase() === 'skip') {
+        return [];
+    }
+    const selectedIndices = response.selection.split(',').map((n) => parseInt(n.trim()) - 1);
+    return selectedIndices.map((i) => detectedIDEs[i]).filter((ide) => ide !== undefined);
+};
+exports.promptForIDESelection = promptForIDESelection;
+const promptForGitHubToken = async () => {
+    console.log(chalk_1.default.blue('\n🔧 GitHub Integration Setup'));
+    console.log('FRAIM requires a GitHub Personal Access Token to function properly.\n');
+    console.log(chalk_1.default.yellow('🔑 Why GitHub token is required:'));
+    console.log(chalk_1.default.gray('   • Create and manage GitHub issues'));
+    console.log(chalk_1.default.gray('   • Access repository information'));
+    console.log(chalk_1.default.gray('   • Perform git operations through MCP'));
+    console.log(chalk_1.default.gray('   • Enable full development workflow automation\n'));
+    const hasToken = await (0, prompts_1.default)({
+        type: 'confirm',
+        name: 'hasToken',
+        message: 'Do you have a GitHub Personal Access Token?',
+        initial: false
+    });
+    if (!hasToken.hasToken) {
+        console.log(chalk_1.default.yellow('\n📝 To create a GitHub Personal Access Token:'));
+        console.log(chalk_1.default.gray('   1. Go to https://github.com/settings/tokens'));
+        console.log(chalk_1.default.gray('   2. Click "Generate new token (classic)"'));
+        console.log(chalk_1.default.gray('   3. Select these scopes:'));
+        console.log(chalk_1.default.gray('      • repo (Full control of private repositories)'));
+        console.log(chalk_1.default.gray('      • read:org (Read org and team membership)'));
+        console.log(chalk_1.default.gray('      • read:user (Read user profile data)'));
+        console.log(chalk_1.default.gray('   4. Set expiration (recommend 90 days or no expiration)'));
+        console.log(chalk_1.default.gray('   5. Click "Generate token" and copy it immediately'));
+        console.log(chalk_1.default.yellow('   ⚠️ You won\'t be able to see the token again!\n'));
+        const openBrowser = await (0, prompts_1.default)({
+            type: 'confirm',
+            name: 'open',
+            message: 'Open GitHub token creation page in browser?',
+            initial: true
+        });
+        if (openBrowser.open) {
+            const { spawn } = require('child_process');
+            const url = 'https://github.com/settings/tokens';
+            try {
+                // Cross-platform browser opening
+                const command = process.platform === 'win32' ? 'start' :
+                    process.platform === 'darwin' ? 'open' : 'xdg-open';
+                spawn(command, [url], { detached: true, stdio: 'ignore' });
+                console.log(chalk_1.default.green('   🌐 Opened GitHub in your browser'));
+            }
+            catch (e) {
+                console.log(chalk_1.default.yellow(`   ⚠️ Could not open browser. Please visit: ${url}`));
+            }
+        }
+    }
+    let token = null;
+    let attempts = 0;
+    const maxAttempts = 3;
+    while (!token && attempts < maxAttempts) {
+        const tokenResponse = await (0, prompts_1.default)({
+            type: 'password',
+            name: 'token',
+            message: attempts === 0
+                ? 'Enter your GitHub token (required)'
+                : `Enter your GitHub token (attempt ${attempts + 1}/${maxAttempts})`,
+            validate: (value) => {
+                if (!value)
+                    return 'GitHub token is required for FRAIM to function';
+                if ((0, token_validator_1.isValidTokenFormat)(value, 'github'))
+                    return true;
+                return 'Please enter a valid GitHub token (starts with ghp_ or github_pat_)';
+            }
+        });
+        if (!tokenResponse.token) {
+            console.log(chalk_1.default.red('\n❌ GitHub token is required for FRAIM to function properly.\n'));
+            console.log('FRAIM requires both keys to provide value:');
+            console.log(chalk_1.default.gray('   • FRAIM key: Access to workflows and AI management features'));
+            console.log(chalk_1.default.gray('   • GitHub token: Essential for git operations, issue management, and repository access\n'));
+            console.log('Without GitHub integration, FRAIM workflows cannot:');
+            console.log(chalk_1.default.gray('   • Create or manage GitHub issues'));
+            console.log(chalk_1.default.gray('   • Access repository information'));
+            console.log(chalk_1.default.gray('   • Perform git operations through MCP'));
+            console.log(chalk_1.default.gray('   • Provide full development workflow automation\n'));
+            const retry = await (0, prompts_1.default)({
+                type: 'confirm',
+                name: 'retry',
+                message: 'Would you like to try entering the GitHub token again?',
+                initial: true
+            });
+            if (!retry.retry) {
+                console.log(chalk_1.default.red('Setup cancelled. Run \'fraim setup --key=<fraim-key>\' again when you have both tokens.'));
+                process.exit(1);
+            }
+            attempts++;
+            continue;
+        }
+        console.log(chalk_1.default.blue('   🔍 Validating GitHub token...'));
+        // Validate token
+        const isValid = await (0, token_validator_1.validateGitHubToken)(tokenResponse.token);
+        if (isValid) {
+            console.log(chalk_1.default.green('   ✅ GitHub token validated successfully!\n'));
+            return tokenResponse.token;
+        }
+        else {
+            console.log(chalk_1.default.red('   ❌ Invalid GitHub token or network error'));
+            console.log(chalk_1.default.yellow('   💡 Make sure the token has the required scopes and hasn\'t expired\n'));
+            attempts++;
+        }
+    }
+    console.log(chalk_1.default.red('\n❌ Maximum attempts reached. Setup cancelled.'));
+    console.log(chalk_1.default.gray('Please ensure you have a valid GitHub token and try again.'));
+    console.log(chalk_1.default.blue('💡 Run "fraim setup --key=<fraim-key> --github-token=<github-token>" to skip prompts.'));
+    process.exit(1);
+};
+exports.promptForGitHubToken = promptForGitHubToken;
+const backupConfig = (configPath) => {
+    if (fs_1.default.existsSync(configPath)) {
+        const backupPath = `${configPath}.fraim-backup-${Date.now()}`;
+        fs_1.default.copyFileSync(configPath, backupPath);
+        console.log(chalk_1.default.gray(`  📁 Backup created: ${backupPath}`));
+    }
+};
+const testMCPConnection = async (ide) => {
+    // This is a placeholder for future MCP connection testing
+    // For now, we'll just check if the config file was created successfully
+    const configPath = (0, ide_detector_1.expandPath)(ide.configPath);
+    return fs_1.default.existsSync(configPath);
+};
+const validateSetupResults = async (configuredIDEs) => {
+    if (configuredIDEs.length === 0)
+        return;
+    console.log(chalk_1.default.blue('\n🔍 Validating setup results...'));
+    const validationResults = await Promise.all(configuredIDEs.map(async (ide) => {
+        const isValid = await testMCPConnection(ide);
+        return { ide: ide.name, valid: isValid };
+    }));
+    const validIDEs = validationResults.filter(r => r.valid);
+    const invalidIDEs = validationResults.filter(r => !r.valid);
+    if (validIDEs.length > 0) {
+        console.log(chalk_1.default.green(`✅ ${validIDEs.length} IDEs configured successfully:`));
+        validIDEs.forEach(({ ide }) => {
+            console.log(chalk_1.default.green(`   • ${ide}`));
+        });
+    }
+    if (invalidIDEs.length > 0) {
+        console.log(chalk_1.default.red(`❌ ${invalidIDEs.length} IDEs may have configuration issues:`));
+        invalidIDEs.forEach(({ ide }) => {
+            console.log(chalk_1.default.red(`   • ${ide}`));
+        });
+    }
+};
+exports.validateSetupResults = validateSetupResults;
+const configureIDEMCP = async (ide, fraimKey, githubToken) => {
+    const configPath = (0, ide_detector_1.expandPath)(ide.configPath);
+    console.log(chalk_1.default.blue(`🔧 Configuring ${ide.name}...`));
+    // Create backup
+    backupConfig(configPath);
+    // Ensure directory exists
+    const configDir = path_1.default.dirname(configPath);
+    if (!fs_1.default.existsSync(configDir)) {
+        fs_1.default.mkdirSync(configDir, { recursive: true });
+        console.log(chalk_1.default.gray(`  📁 Created directory: ${configDir}`));
+    }
+    let existingConfig = {};
+    let existingMCPServers = {};
+    if (fs_1.default.existsSync(configPath) && ide.configFormat === 'json') {
+        try {
+            existingConfig = JSON.parse(fs_1.default.readFileSync(configPath, 'utf8'));
+            existingMCPServers = existingConfig.mcpServers || {};
+            console.log(chalk_1.default.gray(`  📋 Found existing config with ${Object.keys(existingMCPServers).length} MCP servers`));
+        }
+        catch (e) {
+            console.log(chalk_1.default.yellow(`  ⚠️ Could not parse existing ${ide.name} config, creating new one`));
+        }
+    }
+    if (ide.configFormat === 'toml') {
+        // For TOML (Codex), we need to handle differently
+        let existingTomlContent = '';
+        if (fs_1.default.existsSync(configPath)) {
+            existingTomlContent = fs_1.default.readFileSync(configPath, 'utf8');
+            console.log(chalk_1.default.gray(`  📋 Found existing TOML config`));
+        }
+        const newTomlContent = (0, mcp_config_generator_1.generateMCPConfig)(ide.configType, fraimKey, githubToken);
+        // For TOML, we'll append new servers if they don't exist
+        let finalContent = existingTomlContent;
+        const serversToAdd = ['fraim', 'git', 'github', 'playwright'];
+        const addedServers = [];
+        for (const server of serversToAdd) {
+            if (!existingTomlContent.includes(`[mcp_servers.${server}]`)) {
+                // Extract this server's config from the new content
+                const serverRegex = new RegExp(`\\[mcp_servers\\.${server}\\][\\s\\S]*?(?=\\[mcp_servers\\.|$)`, 'g');
+                const serverMatch = newTomlContent.match(serverRegex);
+                if (serverMatch) {
+                    finalContent += '\n' + serverMatch[0].trim() + '\n';
+                    addedServers.push(server);
+                }
+            }
+            else {
+                console.log(chalk_1.default.gray(`  ⏭️ Skipped ${server} (already exists)`));
+            }
+        }
+        fs_1.default.writeFileSync(configPath, finalContent);
+        addedServers.forEach(server => {
+            console.log(chalk_1.default.green(`  ✅ Added ${server} MCP server`));
+        });
+    }
+    else {
+        // For JSON configs - intelligent merging
+        const newConfig = (0, mcp_config_generator_1.generateMCPConfig)(ide.configType, fraimKey, githubToken);
+        const newMCPServers = newConfig.mcpServers || {};
+        // Merge MCP servers intelligently
+        const mergedMCPServers = { ...existingMCPServers };
+        const addedServers = [];
+        const skippedServers = [];
+        for (const [serverName, serverConfig] of Object.entries(newMCPServers)) {
+            if (!existingMCPServers[serverName]) {
+                mergedMCPServers[serverName] = serverConfig;
+                addedServers.push(serverName);
+            }
+            else {
+                skippedServers.push(serverName);
+            }
+        }
+        // Merge with existing config
+        const mergedConfig = {
+            ...existingConfig,
+            ...newConfig,
+            mcpServers: mergedMCPServers
+        };
+        // Write updated config
+        fs_1.default.writeFileSync(configPath, JSON.stringify(mergedConfig, null, 2));
+        addedServers.forEach(server => {
+            console.log(chalk_1.default.green(`  ✅ Added ${server} MCP server`));
+        });
+        skippedServers.forEach(server => {
+            console.log(chalk_1.default.gray(`  ⏭️ Skipped ${server} (already exists)`));
+        });
+    }
+    console.log(chalk_1.default.green(`✅ Updated ${configPath}`));
+};
+const autoConfigureMCP = async (fraimKey, githubToken, selectedIDEs) => {
+    const detectedIDEs = (0, ide_detector_1.detectInstalledIDEs)();
+    if (detectedIDEs.length === 0) {
+        console.log(chalk_1.default.yellow('⚠️ No supported IDEs detected.'));
+        console.log(chalk_1.default.gray('Supported IDEs: Claude Desktop, Antigravity, Kiro, Cursor, VSCode, Codex, Windsurf'));
+        console.log(chalk_1.default.blue('\n💡 You can install an IDE and run setup again later.'));
+        console.log(chalk_1.default.gray('   Or continue with manual MCP configuration.'));
+        const continueAnyway = await (0, prompts_1.default)({
+            type: 'confirm',
+            name: 'continue',
+            message: 'Continue setup without IDE configuration?',
+            initial: true
+        });
+        if (!continueAnyway.continue) {
+            console.log(chalk_1.default.red('Setup cancelled. Install an IDE and run setup again.'));
+            process.exit(1);
+        }
+        return;
+    }
+    let idesToConfigure;
+    if (selectedIDEs && selectedIDEs.length > 0) {
+        // Use command line specified IDEs
+        idesToConfigure = detectedIDEs.filter(ide => selectedIDEs.some(selected => ide.name.toLowerCase().includes(selected.toLowerCase())));
+        if (idesToConfigure.length === 0) {
+            console.log(chalk_1.default.yellow(`⚠️ No IDEs found matching: ${selectedIDEs.join(', ')}`));
+            console.log(chalk_1.default.gray('Available IDEs:'));
+            detectedIDEs.forEach(ide => console.log(chalk_1.default.gray(`   • ${ide.name}`)));
+            return;
+        }
+    }
+    else {
+        // Interactive selection
+        idesToConfigure = await (0, exports.promptForIDESelection)(detectedIDEs);
+    }
+    if (idesToConfigure.length === 0) {
+        console.log(chalk_1.default.yellow('⚠️ No IDEs selected for configuration.'));
+        console.log(chalk_1.default.blue('💡 You can run "fraim setup" again later to configure IDEs.'));
+        return;
+    }
+    console.log(chalk_1.default.blue(`\n🚀 Configuring ${idesToConfigure.length} IDEs...`));
+    const results = {
+        successful: [],
+        failed: []
+    };
+    for (const ide of idesToConfigure) {
+        try {
+            await configureIDEMCP(ide, fraimKey, githubToken);
+            results.successful.push(ide.name);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            results.failed.push({ ide: ide.name, error: errorMessage });
+            console.log(chalk_1.default.red(`❌ Failed to configure ${ide.name}: ${errorMessage}`));
+        }
+    }
+    // Summary
+    console.log(chalk_1.default.green(`\n🎉 Setup Summary:`));
+    console.log(chalk_1.default.green(`   ✅ Successfully configured: ${results.successful.length} IDEs`));
+    if (results.successful.length > 0) {
+        results.successful.forEach(ide => {
+            console.log(chalk_1.default.green(`      • ${ide}`));
+        });
+    }
+    if (results.failed.length > 0) {
+        console.log(chalk_1.default.red(`   ❌ Failed to configure: ${results.failed.length} IDEs`));
+        results.failed.forEach(({ ide, error }) => {
+            console.log(chalk_1.default.red(`      • ${ide}: ${error}`));
+        });
+        console.log(chalk_1.default.yellow('\n💡 You can try running setup again or configure these IDEs manually.'));
+    }
+    if (results.successful.length > 0) {
+        console.log(chalk_1.default.blue('\n🔄 Please restart your configured IDEs to load the new MCP servers.'));
+        // Validate setup results
+        const successfulIDEs = idesToConfigure.filter(ide => results.successful.includes(ide.name));
+        await (0, exports.validateSetupResults)(successfulIDEs);
+        console.log(chalk_1.default.blue('\n🎯 Next steps:'));
+        console.log(chalk_1.default.cyan('   1. Restart your configured IDEs'));
+        console.log(chalk_1.default.cyan('   2. Go to any project directory'));
+        console.log(chalk_1.default.cyan('   3. Run: fraim init-project'));
+        console.log(chalk_1.default.cyan('   4. Ask your AI agent: "list fraim workflows"'));
+    }
+};
+exports.autoConfigureMCP = autoConfigureMCP;

package/dist/src/cli/setup/ide-detector.js

@@ -0,0 +1,163 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expandPath = exports.findIDEByName = exports.getAllSupportedIDEs = exports.detectInstalledIDEs = exports.IDE_CONFIGS = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const expandPath = (filePath) => {
+    if (filePath.startsWith('~/')) {
+        return path_1.default.join(os_1.default.homedir(), filePath.slice(2));
+    }
+    return filePath;
+};
+exports.expandPath = expandPath;
+const checkMultiplePaths = (paths) => {
+    return paths.some(p => fs_1.default.existsSync(expandPath(p)));
+};
+const detectClaude = () => {
+    const paths = [
+        '~/.claude',
+        '~/Library/Application Support/Claude',
+        '~/AppData/Roaming/Claude'
+    ];
+    return checkMultiplePaths(paths);
+};
+const detectVSCode = () => {
+    const paths = [
+        '~/.vscode',
+        '~/Library/Application Support/Code',
+        '~/AppData/Roaming/Code',
+        '~/.config/Code'
+    ];
+    return checkMultiplePaths(paths);
+};
+const detectCursor = () => {
+    const paths = [
+        '~/.cursor',
+        '~/Library/Application Support/Cursor',
+        '~/AppData/Roaming/Cursor',
+        '~/.config/Cursor'
+    ];
+    return checkMultiplePaths(paths);
+};
+const detectWindsurf = () => {
+    const paths = [
+        '~/.codeium/windsurf',
+        '~/Library/Application Support/Windsurf',
+        '~/AppData/Roaming/Windsurf',
+        '~/.config/windsurf'
+    ];
+    return checkMultiplePaths(paths);
+};
+exports.IDE_CONFIGS = [
+    {
+        name: 'Claude Desktop',
+        configPath: '~/.claude/settings.json',
+        configFormat: 'json',
+        configType: 'standard',
+        detectMethod: detectClaude,
+        alternativePaths: [
+            '~/Library/Application Support/Claude/settings.json',
+            '~/AppData/Roaming/Claude/settings.json'
+        ],
+        description: 'Anthropic Claude Desktop application'
+    },
+    {
+        name: 'Antigravity',
+        configPath: '~/.gemini/antigravity/mcp_config.json',
+        configFormat: 'json',
+        configType: 'standard',
+        detectMethod: () => fs_1.default.existsSync(expandPath('~/.gemini/antigravity')),
+        description: 'Google Gemini Antigravity IDE'
+    },
+    {
+        name: 'Kiro',
+        configPath: '~/.kiro/settings/mcp.json',
+        configFormat: 'json',
+        configType: 'kiro',
+        detectMethod: () => fs_1.default.existsSync(expandPath('~/.kiro')),
+        description: 'Kiro AI-powered IDE'
+    },
+    {
+        name: 'Cursor',
+        configPath: '~/.cursor/mcp.json',
+        configFormat: 'json',
+        configType: 'kiro',
+        detectMethod: detectCursor,
+        alternativePaths: [
+            '~/Library/Application Support/Cursor/mcp.json',
+            '~/AppData/Roaming/Cursor/mcp.json',
+            '~/.config/Cursor/mcp.json'
+        ],
+        description: 'Cursor AI code editor'
+    },
+    {
+        name: 'VSCode',
+        configPath: '~/.vscode/settings/mcp.json',
+        configFormat: 'json',
+        configType: 'kiro',
+        detectMethod: detectVSCode,
+        alternativePaths: [
+            '~/Library/Application Support/Code/User/settings/mcp.json',
+            '~/AppData/Roaming/Code/User/settings/mcp.json',
+            '~/.config/Code/User/settings/mcp.json'
+        ],
+        description: 'Visual Studio Code'
+    },
+    {
+        name: 'Codex',
+        configPath: '~/.codex/config.toml',
+        configFormat: 'toml',
+        configType: 'codex',
+        detectMethod: () => fs_1.default.existsSync(expandPath('~/.codex')),
+        description: 'Codex AI development environment'
+    },
+    {
+        name: 'Windsurf',
+        configPath: '~/.codeium/windsurf/mcp_config.json',
+        configFormat: 'json',
+        configType: 'windsurf',
+        detectMethod: detectWindsurf,
+        alternativePaths: [
+            '~/Library/Application Support/Windsurf/mcp_config.json',
+            '~/AppData/Roaming/Windsurf/mcp_config.json',
+            '~/.config/windsurf/mcp_config.json'
+        ],
+        description: 'Codeium Windsurf IDE'
+    }
+];
+const findBestConfigPath = (ide) => {
+    // First try the default path
+    if (fs_1.default.existsSync(expandPath(ide.configPath))) {
+        return ide.configPath;
+    }
+    // Then try alternative paths
+    if (ide.alternativePaths) {
+        for (const altPath of ide.alternativePaths) {
+            if (fs_1.default.existsSync(expandPath(altPath))) {
+                return altPath;
+            }
+        }
+    }
+    // Return default path if nothing found (will be created)
+    return ide.configPath;
+};
+const detectInstalledIDEs = () => {
+    return exports.IDE_CONFIGS.filter(ide => ide.detectMethod()).map(ide => ({
+        ...ide,
+        configPath: findBestConfigPath(ide)
+    }));
+};
+exports.detectInstalledIDEs = detectInstalledIDEs;
+const getAllSupportedIDEs = () => {
+    return exports.IDE_CONFIGS;
+};
+exports.getAllSupportedIDEs = getAllSupportedIDEs;
+const findIDEByName = (name) => {
+    return exports.IDE_CONFIGS.find(ide => ide.name.toLowerCase().includes(name.toLowerCase()) ||
+        name.toLowerCase().includes(ide.name.toLowerCase()));
+};
+exports.findIDEByName = findIDEByName;

package/dist/src/cli/setup/mcp-config-generator.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateMCPConfig = exports.generateWindsurfMCPServers = exports.generateCodexMCPServers = exports.generateKiroMCPServers = exports.generateStandardMCPServers = void 0;
+const generateStandardMCPServers = (fraimKey, githubToken) => ({
+    mcpServers: {
+        git: {
+            command: "npx",
+            args: ["-y", "@cyanheads/git-mcp-server"]
+        },
+        github: {
+            serverUrl: "https://api.githubcopilot.com/mcp/",
+            headers: {
+                Authorization: `Bearer ${githubToken}`
+            }
+        },
+        playwright: {
+            command: "npx",
+            args: ["-y", "@playwright/mcp"]
+        },
+        fraim: {
+            serverUrl: "https://fraim.wellnessatwork.me",
+            headers: {
+                "x-api-key": fraimKey
+            }
+        }
+    }
+});
+exports.generateStandardMCPServers = generateStandardMCPServers;
+const generateKiroMCPServers = (fraimKey, githubToken) => ({
+    mcpServers: {
+        git: {
+            command: "npx",
+            args: ["-y", "@cyanheads/git-mcp-server"]
+        },
+        github: {
+            url: "https://api.githubcopilot.com/mcp/",
+            headers: {
+                Authorization: `Bearer ${githubToken}`
+            }
+        },
+        playwright: {
+            command: "npx",
+            args: ["-y", "@playwright/mcp"]
+        },
+        fraim: {
+            url: "https://fraim.wellnessatwork.me",
+            headers: {
+                "x-api-key": fraimKey
+            }
+        }
+    }
+});
+exports.generateKiroMCPServers = generateKiroMCPServers;
+const generateCodexMCPServers = (fraimKey, githubToken) => `
+[mcp_servers.git]
+command = "npx"
+args = ["-y", "@cyanheads/git-mcp-server"]
+
+[mcp_servers.github]
+url = "https://api.githubcopilot.com/mcp/"
+bearer_token_env_var = "GIT_TOKEN"
+
+[mcp_servers.playwright]
+command = "npx"
+args = ["-y", "@playwright/mcp"]
+
+[mcp_servers.fraim]
+url = "https://fraim.wellnessatwork.me/"
+
+[mcp_servers.fraim.headers]
+x-api-key = "${fraimKey}"
+`;
+exports.generateCodexMCPServers = generateCodexMCPServers;
+const generateWindsurfMCPServers = (fraimKey, githubToken) => ({
+    mcpServers: {
+        git: {
+            command: "npx",
+            args: ["-y", "@cyanheads/git-mcp-server"]
+        },
+        github: {
+            command: "npx",
+            args: ["-y", "@modelcontextprotocol/server-fetch", "https://api.githubcopilot.com/mcp/"],
+            env: {
+                GITHUB_TOKEN: githubToken
+            }
+        },
+        playwright: {
+            command: "npx",
+            args: ["-y", "@playwright/mcp"]
+        },
+        fraim: {
+            command: "npx",
+            args: ["-y", "@modelcontextprotocol/server-fetch", "https://fraim.wellnessatwork.me"],
+            env: {
+                FRAIM_API_KEY: fraimKey
+            }
+        }
+    }
+});
+exports.generateWindsurfMCPServers = generateWindsurfMCPServers;
+const generateMCPConfig = (configType, fraimKey, githubToken) => {
+    switch (configType) {
+        case 'standard':
+            return (0, exports.generateStandardMCPServers)(fraimKey, githubToken);
+        case 'kiro':
+            return (0, exports.generateKiroMCPServers)(fraimKey, githubToken);
+        case 'codex':
+            return (0, exports.generateCodexMCPServers)(fraimKey, githubToken);
+        case 'windsurf':
+            return (0, exports.generateWindsurfMCPServers)(fraimKey, githubToken);
+        default:
+            throw new Error(`Unsupported config type: ${configType}`);
+    }
+};
+exports.generateMCPConfig = generateMCPConfig;