fraim 2.0.100

package/dist/src/cli/commands/setup.js

@@ -0,0 +1,651 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupCommandInitialization = exports.setupCommand = exports.runSetup = void 0;
+// Refactored setup.ts - Generic provider system with zero hardcoded provider knowledge
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const prompts_1 = __importDefault(require("prompts"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const auto_mcp_setup_1 = require("../setup/auto-mcp-setup");
+const version_utils_1 = require("../utils/version-utils");
+const platform_detection_1 = require("../utils/platform-detection");
+const provider_client_1 = require("../api/provider-client");
+const provider_prompts_1 = require("../setup/provider-prompts");
+const provider_registry_1 = require("../providers/provider-registry");
+const init_project_1 = require("./init-project");
+const script_sync_utils_1 = require("../utils/script-sync-utils");
+function parseModeOption(mode) {
+    if (mode === 'conversational' || mode === 'integrated' || mode === 'split') {
+        return mode;
+    }
+    console.log(chalk_1.default.red(`❌ Invalid mode "${mode}"`));
+    console.log(chalk_1.default.yellow('💡 Valid values: integrated, split, conversational'));
+    process.exit(1);
+}
+const promptForFraimKey = async () => {
+    console.log(chalk_1.default.blue('🔑 FRAIM Key Setup'));
+    console.log('FRAIM requires a valid API key to access workflows and features.\n');
+    let key = null;
+    let attempts = 0;
+    const maxAttempts = 3;
+    while (!key && attempts < maxAttempts) {
+        const keyResponse = await (0, prompts_1.default)({
+            type: 'password',
+            name: 'key',
+            message: attempts === 0
+                ? 'Enter your FRAIM key (required)'
+                : `Enter your FRAIM key (attempt ${attempts + 1}/${maxAttempts})`,
+            validate: (value) => {
+                if (!value)
+                    return 'FRAIM key is required';
+                return true;
+            }
+        });
+        if (!keyResponse.key) {
+            console.log(chalk_1.default.red('\n❌ FRAIM key is required to proceed.'));
+            console.log(chalk_1.default.gray('If you need a key, please email sid.mathur@gmail.com to request one.\n'));
+            const retry = await (0, prompts_1.default)({
+                type: 'confirm',
+                name: 'retry',
+                message: 'Would you like to try entering the FRAIM key again?',
+                initial: true
+            });
+            if (!retry.retry) {
+                console.log(chalk_1.default.red('Setup cancelled. Please obtain a FRAIM key and try again.'));
+                process.exit(1);
+            }
+            attempts++;
+            continue;
+        }
+        console.log(chalk_1.default.green('✅ FRAIM key accepted\n'));
+        return keyResponse.key;
+    }
+    console.log(chalk_1.default.red('\n❌ Maximum attempts reached. Setup cancelled.'));
+    console.log(chalk_1.default.gray('Please ensure you have a valid FRAIM key and try again.'));
+    process.exit(1);
+};
+const promptForMode = async () => {
+    console.log(chalk_1.default.blue('\n🎯 Usage Mode Selection'));
+    console.log(chalk_1.default.gray('Choose how you want to use FRAIM:\n'));
+    const response = await (0, prompts_1.default)({
+        type: 'select',
+        name: 'mode',
+        message: 'Select your preferred mode',
+        choices: [
+            {
+                title: 'Integrated Mode',
+                value: 'integrated',
+                description: 'Single platform for both code hosting and issue tracking'
+            },
+            {
+                title: 'Split Mode',
+                value: 'split',
+                description: 'Separate platforms for code hosting and issue tracking'
+            },
+            {
+                title: 'Conversational Mode',
+                value: 'conversational',
+                description: 'AI workflows only, no platform integration required'
+            }
+        ],
+        initial: 0
+    });
+    if (!response.mode) {
+        console.log(chalk_1.default.yellow('\nℹ️  No mode selected, defaulting to Integrated Mode'));
+        return 'integrated';
+    }
+    if (response.mode === 'conversational') {
+        console.log(chalk_1.default.blue('\n✓ Conversational mode selected'));
+        console.log(chalk_1.default.gray('  You can use FRAIM workflows without platform credentials.'));
+        console.log(chalk_1.default.gray('  Platform features (issues, PRs) will be unavailable.\n'));
+    }
+    else if (response.mode === 'split') {
+        console.log(chalk_1.default.blue('\n✓ Split mode selected'));
+        console.log(chalk_1.default.gray('  You can use different platforms for code hosting and issue tracking.\n'));
+    }
+    else {
+        console.log(chalk_1.default.blue('\n✓ Integrated mode selected'));
+        console.log(chalk_1.default.gray('  Full platform integration will be available.\n'));
+    }
+    return response.mode;
+};
+const saveGlobalConfig = (fraimKey, mode, tokens, configs) => {
+    const globalConfigDir = (0, script_sync_utils_1.getUserFraimDir)();
+    const globalConfigPath = path_1.default.join(globalConfigDir, 'config.json');
+    if (!fs_1.default.existsSync(globalConfigDir)) {
+        fs_1.default.mkdirSync(globalConfigDir, { recursive: true });
+    }
+    // Read existing config to preserve any existing data
+    let existingConfig = {};
+    if (fs_1.default.existsSync(globalConfigPath)) {
+        try {
+            existingConfig = JSON.parse(fs_1.default.readFileSync(globalConfigPath, 'utf8'));
+        }
+        catch (e) {
+            // Ignore parse errors, will create new config
+        }
+    }
+    // Merge provider configs (e.g., jiraConfig)
+    const providerConfigs = { ...(existingConfig.providerConfigs || {}) };
+    Object.entries(configs).forEach(([providerId, config]) => {
+        providerConfigs[`${providerId}Config`] = {
+            ...(providerConfigs[`${providerId}Config`] || {}),
+            ...config
+        };
+    });
+    const config = {
+        version: (0, version_utils_1.getFraimVersion)(),
+        apiKey: fraimKey,
+        mode: mode,
+        tokens: {
+            ...(existingConfig.tokens || {}),
+            ...tokens
+        },
+        providerConfigs,
+        configuredAt: new Date().toISOString(),
+        userPreferences: {
+            autoSync: true,
+            backupConfigs: true
+        }
+    };
+    fs_1.default.writeFileSync(globalConfigPath, JSON.stringify(config, null, 2));
+    console.log(chalk_1.default.green('✅ Global FRAIM configuration saved'));
+};
+// Parse CLI options into generic format using provider registry from server
+// Tokens/config are optional - will prompt if not provided
+const parseLegacyOptions = async (options, fraimKey) => {
+    const requestedProviders = [];
+    const providedTokens = {};
+    const providedConfigs = {};
+    // Use provider registry (with fallback) instead of direct client call
+    const { getAllProviderIds, getProviderConfigRequirements } = await Promise.resolve().then(() => __importStar(require('../providers/provider-registry')));
+    const providerIds = await getAllProviderIds();
+    // Dynamically check for provider flags from server registry
+    for (const providerId of providerIds) {
+        // Check for provider flag (e.g., --github)
+        if (options[providerId]) {
+            requestedProviders.push(providerId);
+        }
+        // Check for token option (e.g., --github-token)
+        const tokenKey = `${providerId}Token`;
+        if (options[tokenKey]) {
+            providedTokens[providerId] = options[tokenKey];
+        }
+        // Check for provider-specific config options
+        const configReqs = await getProviderConfigRequirements(providerId);
+        if (configReqs.length > 0) {
+            const config = {};
+            let hasAnyConfig = false;
+            configReqs.forEach(req => {
+                // Use custom CLI option name if provided, otherwise convert key to camelCase
+                const optionSuffix = req.cliOptionName
+                    ? req.cliOptionName.charAt(0).toUpperCase() + req.cliOptionName.slice(1)
+                    : req.key.charAt(0).toUpperCase() + req.key.slice(1);
+                const optionKey = `${providerId}${optionSuffix}`;
+                if (options[optionKey]) {
+                    config[req.key] = options[optionKey];
+                    hasAnyConfig = true;
+                }
+            });
+            if (hasAnyConfig) {
+                providedConfigs[providerId] = config;
+            }
+        }
+    }
+    return { requestedProviders, providedTokens, providedConfigs };
+};
+const runSetup = async (options) => {
+    console.log(chalk_1.default.blue('🚀 Welcome to FRAIM! Let\'s get you set up.\n'));
+    // Determine if this is an update (adding platforms to existing setup)
+    const globalConfigPath = path_1.default.join((0, script_sync_utils_1.getUserFraimDir)(), 'config.json');
+    const isUpdate = fs_1.default.existsSync(globalConfigPath);
+    let fraimKey;
+    let mode;
+    const tokens = {};
+    const configs = {};
+    let requestedProviders = [];
+    let providedTokens = {};
+    let providedConfigs = {};
+    if (isUpdate) {
+        // Update existing setup - add platforms
+        console.log(chalk_1.default.blue('📝 Existing FRAIM configuration detected.\n'));
+        try {
+            const existingConfig = JSON.parse(fs_1.default.readFileSync(globalConfigPath, 'utf8'));
+            // Allow updating FRAIM key even without provider changes
+            fraimKey = options.key || existingConfig.apiKey;
+            // Now we can parse options with the FRAIM key
+            const parsed = await parseLegacyOptions(options, fraimKey);
+            requestedProviders = parsed.requestedProviders;
+            providedTokens = parsed.providedTokens;
+            providedConfigs = parsed.providedConfigs;
+            // Check if this is just a key update or a provider update
+            const isKeyUpdate = options.key && options.key !== existingConfig.apiKey;
+            const isProviderUpdate = requestedProviders.length > 0;
+            // If no specific changes requested, offer interactive update
+            if (!isKeyUpdate && !isProviderUpdate) {
+                console.log(chalk_1.default.gray('   Current configuration:'));
+                console.log(chalk_1.default.gray(`   • Mode: ${existingConfig.mode || 'integrated'}`));
+                // Show existing tokens
+                const { getProvider } = await Promise.resolve().then(() => __importStar(require('../providers/provider-registry')));
+                if (existingConfig.tokens && Object.keys(existingConfig.tokens).length > 0) {
+                    const providerNames = await Promise.all(Object.keys(existingConfig.tokens).map(async (id) => {
+                        const provider = await getProvider(id);
+                        return provider?.displayName || id;
+                    }));
+                    console.log(chalk_1.default.gray(`   • Providers: ${providerNames.join(', ')}`));
+                }
+                else {
+                    console.log(chalk_1.default.gray('   • Providers: none'));
+                }
+                console.log();
+                // Ask user what they want to do
+                const response = await (0, prompts_1.default)({
+                    type: 'select',
+                    name: 'action',
+                    message: 'What would you like to do?',
+                    choices: [
+                        {
+                            title: 'Add a provider',
+                            value: 'add-provider',
+                            description: 'Add a new platform integration (GitHub, GitLab, etc.)'
+                        },
+                        {
+                            title: 'Update FRAIM key',
+                            value: 'update-key',
+                            description: 'Change your FRAIM API key'
+                        },
+                        {
+                            title: 'Reconfigure from scratch',
+                            value: 'reconfigure',
+                            description: 'Start fresh setup (will preserve existing config as backup)'
+                        },
+                        {
+                            title: 'Cancel',
+                            value: 'cancel',
+                            description: 'Exit without making changes'
+                        }
+                    ],
+                    initial: 0
+                });
+                if (!response.action || response.action === 'cancel') {
+                    console.log(chalk_1.default.gray('\nSetup cancelled. No changes made.'));
+                    return;
+                }
+                if (response.action === 'add-provider') {
+                    console.log(chalk_1.default.blue('\n📦 Adding a provider...\n'));
+                    const providerClient = new provider_client_1.ProviderClient(fraimKey, process.env.FRAIM_REMOTE_URL || undefined);
+                    // Prompt for which provider to add
+                    const providersToAdd = await (0, provider_prompts_1.promptForProviders)(providerClient);
+                    requestedProviders = providersToAdd;
+                }
+                else if (response.action === 'update-key') {
+                    console.log(chalk_1.default.blue('\n🔑 Updating FRAIM key...\n'));
+                    fraimKey = await promptForFraimKey();
+                }
+                else if (response.action === 'reconfigure') {
+                    console.log(chalk_1.default.blue('\n🔄 Starting fresh setup...\n'));
+                    // Backup existing config
+                    const backupPath = globalConfigPath + '.backup.' + Date.now();
+                    fs_1.default.copyFileSync(globalConfigPath, backupPath);
+                    console.log(chalk_1.default.gray(`   Backed up existing config to: ${path_1.default.basename(backupPath)}\n`));
+                    // Treat as fresh setup
+                    fraimKey = options.key || await promptForFraimKey();
+                    console.log(chalk_1.default.green('✅ FRAIM key accepted\n'));
+                    mode = options.mode ? parseModeOption(options.mode) : await promptForMode();
+                    const parsed = await parseLegacyOptions(options, fraimKey);
+                    requestedProviders = parsed.requestedProviders;
+                    providedTokens = parsed.providedTokens;
+                    providedConfigs = parsed.providedConfigs;
+                    // Clear existing tokens/configs for fresh start
+                    Object.keys(tokens).forEach(key => delete tokens[key]);
+                    Object.keys(configs).forEach(key => delete configs[key]);
+                    // Continue with fresh setup flow
+                    const providerClient = new provider_client_1.ProviderClient(fraimKey, process.env.FRAIM_REMOTE_URL || undefined);
+                    if (mode === 'integrated') {
+                        let providersToSetup = requestedProviders;
+                        if (providersToSetup.length === 0) {
+                            providersToSetup = await (0, provider_prompts_1.promptForProviders)(providerClient);
+                        }
+                        for (const providerId of providersToSetup) {
+                            try {
+                                const creds = await (0, provider_prompts_1.promptForProviderCredentials)(providerClient, providerId, providedTokens[providerId], providedConfigs[providerId]);
+                                tokens[providerId] = creds.token;
+                                if (creds.config) {
+                                    configs[providerId] = creds.config;
+                                }
+                            }
+                            catch (e) {
+                                const providerName = await (0, provider_registry_1.getProviderDisplayName)(providerId);
+                                console.log(chalk_1.default.red(`❌ Failed to get ${providerName} credentials`));
+                                process.exit(1);
+                            }
+                        }
+                    }
+                    else if (mode === 'split') {
+                        // Split mode setup
+                        console.log(chalk_1.default.blue('\n🔀 Split Mode Configuration'));
+                        console.log(chalk_1.default.gray('Configure separate platforms for code hosting and issue tracking.\n'));
+                        const codeRepoProvider = await (0, provider_prompts_1.promptForSingleProvider)(providerClient, 'code');
+                        const creds1 = await (0, provider_prompts_1.promptForProviderCredentials)(providerClient, codeRepoProvider, providedTokens[codeRepoProvider], providedConfigs[codeRepoProvider]);
+                        tokens[codeRepoProvider] = creds1.token;
+                        if (creds1.config) {
+                            configs[codeRepoProvider] = creds1.config;
+                        }
+                        const issueProvider = await (0, provider_prompts_1.promptForSingleProvider)(providerClient, 'issues');
+                        if (!tokens[issueProvider]) {
+                            const creds2 = await (0, provider_prompts_1.promptForProviderCredentials)(providerClient, issueProvider, providedTokens[issueProvider], providedConfigs[issueProvider]);
+                            tokens[issueProvider] = creds2.token;
+                            if (creds2.config) {
+                                configs[issueProvider] = creds2.config;
+                            }
+                        }
+                    }
+                    // Save and configure MCP
+                    console.log(chalk_1.default.blue('\n💾 Saving global configuration...'));
+                    saveGlobalConfig(fraimKey, mode, tokens, configs);
+                    console.log(chalk_1.default.blue('\n🔌 Configuring MCP servers...'));
+                    const mcpTokens = {};
+                    Object.entries(tokens).forEach(([id, token]) => {
+                        mcpTokens[id] = token;
+                    });
+                    const providerConfigsMap = {};
+                    Object.entries(configs).forEach(([providerId, config]) => {
+                        providerConfigsMap[providerId] = config;
+                    });
+                    await (0, auto_mcp_setup_1.autoConfigureMCP)(fraimKey, mcpTokens, options.ide ? [options.ide] : undefined, providerConfigsMap);
+                    console.log(chalk_1.default.green('\n🎯 Reconfiguration complete!'));
+                    return;
+                }
+            }
+            mode = existingConfig.mode || 'integrated';
+            // Preserve existing tokens
+            if (existingConfig.tokens) {
+                Object.assign(tokens, existingConfig.tokens);
+            }
+            // Preserve existing configs
+            if (existingConfig.providerConfigs) {
+                Object.entries(existingConfig.providerConfigs).forEach(([key, value]) => {
+                    const providerId = key.replace('Config', '');
+                    configs[providerId] = value;
+                });
+            }
+        }
+        catch (e) {
+            console.log(chalk_1.default.red('❌ Failed to read existing configuration'));
+            console.error('Error details:', e);
+            process.exit(1);
+        }
+    }
+    else {
+        // Initial setup
+        console.log(chalk_1.default.yellow('📋 This setup will:'));
+        console.log(chalk_1.default.gray('   • Validate your FRAIM key'));
+        console.log(chalk_1.default.gray('   • Choose your usage mode'));
+        console.log(chalk_1.default.gray('   • Configure platform integrations'));
+        console.log(chalk_1.default.gray('   • Sync FRAIM scripts to your system\n'));
+        // Get FRAIM key
+        fraimKey = options.key || await promptForFraimKey();
+        console.log(chalk_1.default.green('✅ FRAIM key accepted\n'));
+        // Ask for mode preference (or use explicit option)
+        mode = options.mode ? parseModeOption(options.mode) : await promptForMode();
+        // Parse provider CLI flags on first-time setup too
+        const parsed = await parseLegacyOptions(options, fraimKey);
+        requestedProviders = parsed.requestedProviders;
+        providedTokens = parsed.providedTokens;
+        providedConfigs = parsed.providedConfigs;
+    }
+    const providerClient = new provider_client_1.ProviderClient(fraimKey, process.env.FRAIM_REMOTE_URL || undefined);
+    // Handle platform tokens based on mode
+    if (mode === 'integrated') {
+        let providersToSetup = requestedProviders;
+        // If no specific providers requested and not an update, ask user
+        if (!isUpdate && providersToSetup.length === 0) {
+            providersToSetup = await (0, provider_prompts_1.promptForProviders)(providerClient);
+        }
+        // Get credentials for each provider
+        for (const providerId of providersToSetup) {
+            if (!tokens[providerId]) {
+                try {
+                    // Use provided tokens if available, otherwise prompt
+                    const creds = await (0, provider_prompts_1.promptForProviderCredentials)(providerClient, providerId, providedTokens[providerId], providedConfigs[providerId]);
+                    tokens[providerId] = creds.token;
+                    if (creds.config) {
+                        configs[providerId] = creds.config;
+                    }
+                }
+                catch (e) {
+                    const providerName = await (0, provider_registry_1.getProviderDisplayName)(providerId);
+                    console.log(chalk_1.default.red(`❌ Failed to get ${providerName} credentials`));
+                    process.exit(1);
+                }
+            }
+        }
+        if (Object.keys(tokens).length === 0) {
+            console.log(chalk_1.default.yellow('⚠️  No platform tokens configured.'));
+            console.log(chalk_1.default.gray('   You can add them later with:'));
+            const allProviderIds = await (0, provider_registry_1.getAllProviderIds)();
+            allProviderIds.forEach(id => {
+                console.log(chalk_1.default.cyan(`   fraim setup --${id}`));
+            });
+            console.log();
+        }
+    }
+    else if (mode === 'split') {
+        // Split mode: separate platforms for code repository and issue tracking
+        console.log(chalk_1.default.blue('\n🔀 Split Mode Configuration'));
+        console.log(chalk_1.default.gray('Configure separate platforms for code hosting and issue tracking.\n'));
+        // Get code repository platform
+        const codeRepoProvider = await (0, provider_prompts_1.promptForSingleProvider)(providerClient, 'code');
+        // Get code repository credentials
+        if (!tokens[codeRepoProvider]) {
+            try {
+                // Use provided tokens if available, otherwise prompt
+                const creds = await (0, provider_prompts_1.promptForProviderCredentials)(providerClient, codeRepoProvider, providedTokens[codeRepoProvider], providedConfigs[codeRepoProvider]);
+                tokens[codeRepoProvider] = creds.token;
+                if (creds.config) {
+                    configs[codeRepoProvider] = creds.config;
+                }
+            }
+            catch (e) {
+                const providerName = await (0, provider_registry_1.getProviderDisplayName)(codeRepoProvider);
+                console.log(chalk_1.default.red(`❌ Failed to get ${providerName} credentials`));
+                process.exit(1);
+            }
+        }
+        // Get issue tracking platform
+        const issueProvider = await (0, provider_prompts_1.promptForSingleProvider)(providerClient, 'issues');
+        // Get issue tracking credentials (if different from code repo)
+        if (!tokens[issueProvider]) {
+            try {
+                // Use provided tokens if available, otherwise prompt
+                const creds = await (0, provider_prompts_1.promptForProviderCredentials)(providerClient, issueProvider, providedTokens[issueProvider], providedConfigs[issueProvider]);
+                tokens[issueProvider] = creds.token;
+                if (creds.config) {
+                    configs[issueProvider] = creds.config;
+                }
+            }
+            catch (e) {
+                const providerName = await (0, provider_registry_1.getProviderDisplayName)(issueProvider);
+                console.log(chalk_1.default.red(`❌ Failed to get ${providerName} credentials`));
+                process.exit(1);
+            }
+        }
+        const codeRepoName = await (0, provider_registry_1.getProviderDisplayName)(codeRepoProvider);
+        const issueName = await (0, provider_registry_1.getProviderDisplayName)(issueProvider);
+        console.log(chalk_1.default.green(`\n✅ Split mode configured: ${codeRepoName} (code) + ${issueName} (issues)\n`));
+    }
+    else {
+        console.log(chalk_1.default.gray('ℹ️  Conversational mode: No platform tokens needed\n'));
+    }
+    // Save global configuration
+    console.log(chalk_1.default.blue('💾 Saving global configuration...'));
+    saveGlobalConfig(fraimKey, mode, tokens, configs);
+    // Configure MCP servers
+    if (!isUpdate) {
+        // Initial setup - configure all detected IDEs
+        console.log(chalk_1.default.blue('\n🔌 Configuring MCP servers...'));
+        // Convert to legacy format for MCP config generator
+        const mcpTokens = {};
+        Object.entries(tokens).forEach(([id, token]) => {
+            mcpTokens[id] = token;
+        });
+        if (mode === 'conversational' && Object.keys(mcpTokens).length === 0) {
+            console.log(chalk_1.default.yellow('ℹ️  Conversational mode: Configuring MCP servers without platform integration'));
+            console.log(chalk_1.default.gray('   FRAIM workflows will work, but platform-specific features will be unavailable\n'));
+        }
+        try {
+            // Build providerConfigs map from configs
+            const providerConfigsMap = {};
+            Object.entries(configs).forEach(([providerId, config]) => {
+                providerConfigsMap[providerId] = config;
+            });
+            await (0, auto_mcp_setup_1.autoConfigureMCP)(fraimKey, mcpTokens, options.ide ? [options.ide] : undefined, providerConfigsMap);
+        }
+        catch (e) {
+            console.log(chalk_1.default.yellow('⚠️  MCP configuration encountered issues'));
+            console.log(chalk_1.default.gray('   You can configure MCP manually or run setup again later\n'));
+        }
+    }
+    else {
+        // Update existing setup - refresh all IDE MCP configs with new keys
+        console.log(chalk_1.default.blue('\n🔄 Updating IDE MCP configurations...'));
+        try {
+            const { detectInstalledIDEs } = await Promise.resolve().then(() => __importStar(require('../setup/ide-detector')));
+            const installedIDEs = detectInstalledIDEs();
+            if (installedIDEs.length === 0) {
+                console.log(chalk_1.default.gray('   No IDE configurations found to update'));
+            }
+            else {
+                // Convert to legacy format for MCP config generator
+                const mcpTokens = {};
+                Object.entries(tokens).forEach(([id, token]) => {
+                    mcpTokens[id] = token;
+                });
+                // Build providerConfigs map from configs
+                const providerConfigsMap = {};
+                Object.entries(configs).forEach(([providerId, config]) => {
+                    providerConfigsMap[providerId] = config;
+                });
+                const ideNames = installedIDEs.map(ide => ide.name);
+                await (0, auto_mcp_setup_1.autoConfigureMCP)(fraimKey, mcpTokens, ideNames, providerConfigsMap);
+                console.log(chalk_1.default.green(`✅ Updated MCP configs for: ${ideNames.join(', ')}`));
+            }
+        }
+        catch (e) {
+            console.log(chalk_1.default.yellow('⚠️  Failed to update IDE MCP configurations'));
+            console.log(chalk_1.default.gray('   You can update them manually with: fraim add-ide <ide-name>\n'));
+        }
+    }
+    // Auto-run project init if we're in a git repo (only on initial setup)
+    if (!isUpdate) {
+        if ((0, platform_detection_1.isGitRepository)()) {
+            console.log(chalk_1.default.blue('\n📁 Git repository detected — initializing project...'));
+            await (0, init_project_1.runInitProject)();
+        }
+        else {
+            console.log(chalk_1.default.yellow('\nℹ️  Not in a git repository — skipping project initialization.'));
+            console.log(chalk_1.default.cyan('   To initialize a project later, cd into a repo and run: fraim init-project'));
+        }
+    }
+    // Show summary
+    console.log(chalk_1.default.green('\n🎯 Setup complete!'));
+    console.log(chalk_1.default.gray(`   Mode: ${mode}`));
+    if (mode !== 'conversational') {
+        const configuredProviders = await Promise.all(Object.keys(tokens).map(async (id) => await (0, provider_registry_1.getProviderDisplayName)(id)));
+        console.log(chalk_1.default.gray(`   Platforms: ${configuredProviders.join(', ') || 'none'}`));
+    }
+    console.log(chalk_1.default.cyan('\n📝 For future projects:'));
+    console.log(chalk_1.default.cyan('   1. cd into any project directory'));
+    console.log(chalk_1.default.cyan('   2. Run: fraim init-project'));
+    console.log(chalk_1.default.cyan('   3. Tell your AI agent: "Onboard this project"'));
+    if (mode === 'integrated') {
+        const allProviderIds = await (0, provider_registry_1.getAllProviderIds)();
+        const unconfiguredProviders = allProviderIds.filter(id => !tokens[id]);
+        if (unconfiguredProviders.length > 0) {
+            console.log(chalk_1.default.gray('\n💡 To add more platforms later:'));
+            unconfiguredProviders.forEach(id => {
+                console.log(chalk_1.default.gray(`   fraim setup --${id}`));
+            });
+        }
+    }
+};
+exports.runSetup = runSetup;
+exports.setupCommand = new commander_1.Command('setup')
+    .description('Complete global FRAIM setup with platform configuration')
+    .option('--key <key>', 'FRAIM API key')
+    .option('--mode <mode>', 'Usage mode: integrated | split | conversational')
+    .option('--ide <ides>', 'Configure specific IDEs');
+// Track initialization promise for CLI entry point
+exports.setupCommandInitialization = null;
+// Dynamically add provider options from registry (async initialization)
+exports.setupCommandInitialization = (async () => {
+    try {
+        const allProviderIds = await (0, provider_registry_1.getAllProviderIds)();
+        for (const providerId of allProviderIds) {
+            const provider = await (0, provider_registry_1.getProvider)(providerId);
+            if (!provider)
+                continue;
+            // Add provider flag (e.g., --github)
+            exports.setupCommand.option(`--${providerId}`, `Add/update ${provider.displayName} integration`);
+            // Add token option (e.g., --github-token) - primarily for testing/automation
+            exports.setupCommand.option(`--${providerId}-token <token>`, `${provider.displayName} token (optional - will prompt if not provided)`);
+            // Add config options if provider requires them
+            const configReqs = await (0, provider_registry_1.getProviderConfigRequirements)(providerId);
+            configReqs.forEach(req => {
+                // Use custom CLI option name if provided, otherwise convert key to kebab-case
+                const optionSuffix = req.cliOptionName || req.key.replace(/([A-Z])/g, '-$1').toLowerCase();
+                const optionName = `${providerId}-${optionSuffix}`;
+                exports.setupCommand.option(`--${optionName} <value>`, `${req.description} (optional - will prompt if not provided)`);
+            });
+        }
+    }
+    catch (error) {
+        // If we can't fetch providers (e.g., no config yet), that's okay
+        // The command will still work, just without dynamic options
+    }
+})();
+// Wrap the action to ensure initialization completes first
+exports.setupCommand.action(async (options) => {
+    // Wait for dynamic options to be registered
+    if (exports.setupCommandInitialization) {
+        await exports.setupCommandInitialization;
+    }
+    return (0, exports.runSetup)(options);
+});