fraim 2.0.100

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

@@ -0,0 +1,331 @@
+"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.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 codex_local_config_1 = require("./codex-local-config");
+const provider_registry_1 = require("../providers/provider-registry");
+const normalizePlatformTokens = (tokenInput) => {
+    if (!tokenInput)
+        return {};
+    if (typeof tokenInput === 'string') {
+        return tokenInput ? { github: tokenInput } : {};
+    }
+    return tokenInput;
+};
+const promptForIDESelection = async (detectedIDEs, tokenInput) => {
+    const tokens = normalizePlatformTokens(tokenInput);
+    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('FRAIM will add these MCP servers to selected IDEs:'));
+    console.log(chalk_1.default.gray('   • fraim (required for FRAIM jobs)'));
+    console.log(chalk_1.default.gray('   • git (version control integration)'));
+    // Show configured provider MCP servers dynamically
+    const allProviderIds = await (0, provider_registry_1.getAllProviderIds)();
+    for (const providerId of allProviderIds) {
+        if (tokens[providerId]) {
+            const provider = await (0, provider_registry_1.getProvider)(providerId);
+            if (provider) {
+                console.log(chalk_1.default.gray(`   - ${providerId} (${provider.displayName} 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;
+// Re-export promptForProviderToken for backward compatibility
+// This maintains the same interface but uses the generic system
+const promptForGitHubToken = async () => {
+    const { promptForProviderToken } = await Promise.resolve().then(() => __importStar(require('./provider-prompts')));
+    const { getProviderClient } = await Promise.resolve().then(() => __importStar(require('../api/get-provider-client')));
+    const client = getProviderClient();
+    return promptForProviderToken(client, 'github');
+};
+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, tokenInput, providerConfigs) => {
+    const tokens = normalizePlatformTokens(tokenInput);
+    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 = {};
+    const serversKey = ide.configType === 'vscode' ? 'servers' : 'mcpServers';
+    if (fs_1.default.existsSync(configPath) && ide.configFormat === 'json') {
+        try {
+            existingConfig = JSON.parse(fs_1.default.readFileSync(configPath, 'utf8'));
+            existingMCPServers = existingConfig[serversKey] || {};
+            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 = await (0, mcp_config_generator_1.generateMCPConfig)(ide.configType, fraimKey, tokens, providerConfigs);
+        const { getAllMCPServerIds } = await Promise.resolve().then(() => __importStar(require('../mcp/mcp-server-registry')));
+        const serversToAdd = getAllMCPServerIds();
+        const mergeResult = (0, mcp_config_generator_1.mergeTomlMCPServers)(existingTomlContent, newTomlContent, serversToAdd);
+        fs_1.default.writeFileSync(configPath, mergeResult.content);
+        mergeResult.addedServers.forEach(server => {
+            console.log(chalk_1.default.green(`  ✅ Added ${server} MCP server`));
+        });
+        mergeResult.replacedServers.forEach(server => {
+            console.log(chalk_1.default.green(`  ✅ Updated ${server} MCP server`));
+        });
+        mergeResult.skippedServers.forEach(server => {
+            console.log(chalk_1.default.gray(`  ⏭️ Skipped ${server} (already configured or not requested)`));
+        });
+    }
+    else {
+        // For JSON configs - intelligent merging
+        const newConfig = await (0, mcp_config_generator_1.generateMCPConfig)(ide.configType, fraimKey, tokens, providerConfigs);
+        const newMCPServers = newConfig[serversKey] || newConfig.mcpServers || {};
+        // Merge MCP servers intelligently
+        const mergedMCPServers = { ...existingMCPServers };
+        const addedServers = [];
+        const updatedServers = [];
+        const skippedServers = [];
+        // Servers that should always be updated (not skipped)
+        const alwaysUpdateServers = new Set(['fraim', 'github', 'gitlab', 'jira', 'ado', 'linear']);
+        for (const [serverName, serverConfig] of Object.entries(newMCPServers)) {
+            if (!existingMCPServers[serverName]) {
+                mergedMCPServers[serverName] = serverConfig;
+                addedServers.push(serverName);
+            }
+            else if (alwaysUpdateServers.has(serverName)) {
+                // Always update these servers to ensure keys/tokens are current
+                mergedMCPServers[serverName] = serverConfig;
+                updatedServers.push(serverName);
+            }
+            else {
+                skippedServers.push(serverName);
+            }
+        }
+        // Merge with existing config (VS Code uses "servers", others use "mcpServers")
+        const mergedConfig = {
+            ...existingConfig,
+            [serversKey]: 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`));
+        });
+        updatedServers.forEach(server => {
+            console.log(chalk_1.default.blue(`  🔄 Updated ${server} MCP server`));
+        });
+        skippedServers.forEach(server => {
+            console.log(chalk_1.default.gray(`  ⏭️  Skipped ${server} (already exists)`));
+        });
+    }
+    console.log(chalk_1.default.green(`✅ Updated ${configPath}`));
+    if (ide.configType === 'codex') {
+        const localResult = (0, codex_local_config_1.ensureCodexLocalConfig)(process.cwd());
+        const status = localResult.created ? 'Created' : localResult.updated ? 'Updated' : 'Verified';
+        console.log(chalk_1.default.green(`  ✅ ${status} local Codex config: ${localResult.path}`));
+    }
+};
+const autoConfigureMCP = async (fraimKey, tokenInput, selectedIDEs, providerConfigs) => {
+    const tokens = normalizePlatformTokens(tokenInput);
+    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, 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, tokens);
+    }
+    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, tokens, providerConfigs);
+            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: npx fraim-framework@latest init-project'));
+        console.log(chalk_1.default.cyan('   4. Tell your AI agent: "Onboard this project"'));
+    }
+};
+exports.autoConfigureMCP = autoConfigureMCP;

package/dist/src/cli/setup/codex-local-config.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureCodexLocalConfig = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const mcp_config_generator_1 = require("./mcp-config-generator");
+const escapeTomlString = (value) => value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+const buildFraimCwdBlock = (projectRoot) => `
+[mcp_servers.fraim]
+cwd = "${escapeTomlString(projectRoot)}"
+`;
+const ensureCodexLocalConfig = (projectRoot) => {
+    const codexDir = path_1.default.join(projectRoot, '.codex');
+    const codexConfigPath = path_1.default.join(codexDir, 'config.toml');
+    if (!fs_1.default.existsSync(codexDir)) {
+        fs_1.default.mkdirSync(codexDir, { recursive: true });
+    }
+    const hadExistingFile = fs_1.default.existsSync(codexConfigPath);
+    const existingContent = hadExistingFile ? fs_1.default.readFileSync(codexConfigPath, 'utf8') : '';
+    const generatedContent = buildFraimCwdBlock(projectRoot);
+    const mergeResult = (0, mcp_config_generator_1.mergeTomlMCPServers)(existingContent, generatedContent, ['fraim']);
+    const normalizedExisting = existingContent.replace(/\r\n/g, '\n');
+    const normalizedMerged = mergeResult.content.replace(/\r\n/g, '\n');
+    const shouldWrite = !hadExistingFile || normalizedExisting !== normalizedMerged;
+    if (shouldWrite) {
+        fs_1.default.writeFileSync(codexConfigPath, mergeResult.content);
+    }
+    return {
+        path: codexConfigPath,
+        created: !hadExistingFile,
+        updated: shouldWrite && hadExistingFile
+    };
+};
+exports.ensureCodexLocalConfig = ensureCodexLocalConfig;

package/dist/src/cli/setup/first-run.js

@@ -0,0 +1,242 @@
+"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.runFirstRunExperience = void 0;
+const prompts_1 = __importDefault(require("prompts"));
+const chalk_1 = __importDefault(require("chalk"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const script_sync_utils_1 = require("../utils/script-sync-utils");
+const project_fraim_paths_1 = require("../../core/utils/project-fraim-paths");
+const loadGlobalConfig = () => {
+    const globalConfigPath = path_1.default.join((0, script_sync_utils_1.getUserFraimDir)(), 'config.json');
+    if (!fs_1.default.existsSync(globalConfigPath)) {
+        return null;
+    }
+    try {
+        const config = JSON.parse(fs_1.default.readFileSync(globalConfigPath, 'utf8'));
+        return {
+            fraimKey: config.apiKey,
+            githubToken: config.githubToken
+        };
+    }
+    catch (e) {
+        return null;
+    }
+};
+const checkMCPConfigurations = () => {
+    const sources = [];
+    // Check Kiro MCP config
+    const kiroConfigPath = path_1.default.join(os_1.default.homedir(), '.kiro', 'settings', 'mcp.json');
+    if (fs_1.default.existsSync(kiroConfigPath)) {
+        try {
+            const kiroConfig = JSON.parse(fs_1.default.readFileSync(kiroConfigPath, 'utf8'));
+            if (kiroConfig.mcpServers?.fraim) {
+                sources.push('Kiro');
+            }
+        }
+        catch (e) {
+            // Ignore parsing errors
+        }
+    }
+    // Check Claude Desktop / Cowork config
+    const claudeConfigPath = path_1.default.join(os_1.default.homedir(), 'AppData', 'Roaming', 'Claude', 'claude_desktop_config.json');
+    if (fs_1.default.existsSync(claudeConfigPath)) {
+        try {
+            const claudeConfig = JSON.parse(fs_1.default.readFileSync(claudeConfigPath, 'utf8'));
+            if (claudeConfig.mcpServers?.fraim) {
+                sources.push('Claude Desktop / Cowork');
+            }
+        }
+        catch (e) {
+            // Ignore parsing errors
+        }
+    }
+    // Check macOS Claude Desktop / Cowork config path
+    const claudeMacPath = path_1.default.join(os_1.default.homedir(), 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+    if (fs_1.default.existsSync(claudeMacPath)) {
+        try {
+            const claudeConfig = JSON.parse(fs_1.default.readFileSync(claudeMacPath, 'utf8'));
+            if (claudeConfig.mcpServers?.fraim) {
+                sources.push('Claude Desktop / Cowork (macOS)');
+            }
+        }
+        catch (e) {
+            // Ignore parsing errors
+        }
+    }
+    // Check VS Code MCP config (uses "servers" key)
+    const vscodePaths = [
+        path_1.default.join(os_1.default.homedir(), 'AppData', 'Roaming', 'Code', 'User', 'mcp.json'),
+        path_1.default.join(os_1.default.homedir(), 'Library', 'Application Support', 'Code', 'User', 'mcp.json'),
+        path_1.default.join(os_1.default.homedir(), '.config', 'Code', 'User', 'mcp.json')
+    ];
+    for (const vscodePath of vscodePaths) {
+        if (fs_1.default.existsSync(vscodePath)) {
+            try {
+                const vscodeConfig = JSON.parse(fs_1.default.readFileSync(vscodePath, 'utf8'));
+                if (vscodeConfig.servers?.fraim) {
+                    sources.push('VSCode');
+                    break;
+                }
+            }
+            catch (e) {
+                // Ignore parsing errors
+            }
+        }
+    }
+    return {
+        found: sources.length > 0,
+        sources
+    };
+};
+const runFirstRunExperience = async () => {
+    // Skip interactive setup in CI/Test environments
+    if (process.env.CI === 'true' || process.env.TEST_MODE === 'true') {
+        console.log(chalk_1.default.yellow('ℹ️  Skipping interactive first-run experience (CI/TEST_MODE detected)'));
+        return;
+    }
+    console.log(chalk_1.default.blue('\n👋 Welcome to FRAIM! Let\'s get you set up.\n'));
+    // Check for existing configuration
+    const globalConfig = loadGlobalConfig();
+    const mcpCheck = checkMCPConfigurations();
+    if (globalConfig && globalConfig.fraimKey) {
+        console.log(chalk_1.default.green('✅ Found existing FRAIM configuration'));
+        if (mcpCheck.found) {
+            console.log(chalk_1.default.green(`✅ Found FRAIM MCP configuration in: ${mcpCheck.sources.join(', ')}`));
+            console.log(chalk_1.default.blue('🎉 You\'re all set! FRAIM is ready to use.\n'));
+        }
+        else {
+            console.log(chalk_1.default.yellow('⚠️  FRAIM key found but no MCP configuration detected.'));
+            console.log(chalk_1.default.cyan('💡 Consider running "fraim add-ide" to configure your IDE.\n'));
+        }
+    }
+    else if (mcpCheck.found) {
+        console.log(chalk_1.default.green(`✅ Found FRAIM MCP configuration in: ${mcpCheck.sources.join(', ')}`));
+        console.log(chalk_1.default.yellow('⚠️  But no global FRAIM configuration found.'));
+        console.log(chalk_1.default.cyan('💡 Your MCP setup looks good! Skipping key setup.\n'));
+    }
+    else {
+        // No existing configuration found - ask for FRAIM key
+        console.log(chalk_1.default.yellow('🔍 No existing FRAIM configuration detected.\n'));
+        let response;
+        try {
+            response = await (0, prompts_1.default)({
+                type: 'text',
+                name: 'fraimKey',
+                message: 'Do you have a FRAIM key? (Input key or press Enter to skip)',
+                validate: (value) => true // Optional input
+            });
+        }
+        catch (e) {
+            console.warn(chalk_1.default.yellow('\n⚠️  Interactive prompts experienced an issue. Skipping setup.\n'));
+            return;
+        }
+        if (response.fraimKey && response.fraimKey.trim().length > 0) {
+            const key = response.fraimKey.trim();
+            console.log(chalk_1.default.green('\n✅ Key received.'));
+            console.log(chalk_1.default.yellow('\nPlease add the following to your IDE\'s MCP config (e.g. claude_desktop_config.json):'));
+            const mcpConfig = {
+                mcpServers: {
+                    fraim: {
+                        serverUrl: "https://fraim.wellnessatwork.me",
+                        headers: {
+                            "x-api-key": key
+                        }
+                    }
+                }
+            };
+            console.log(chalk_1.default.cyan(JSON.stringify(mcpConfig, null, 2)));
+            console.log('\n');
+        }
+        else {
+            console.log(chalk_1.default.yellow('\nℹ️  If you need a key, please email sid.mathur@gmail.com to request one.\n'));
+        }
+    }
+    // 2. Ask about Architecture Document
+    const archResponse = await (0, prompts_1.default)({
+        type: 'confirm',
+        name: 'hasArchDoc',
+        message: 'Do you have an architecture document for this project?',
+        initial: false
+    });
+    if (!archResponse.hasArchDoc) {
+        console.log(chalk_1.default.yellow('\n💡 To create an architecture document, please ask your IDE Agent:'));
+        console.log(chalk_1.default.cyan('  "Run the bootstrap/create-architecture workflow"'));
+        console.log(chalk_1.default.gray('  (This ensures your agent understands your codebase structure)\n'));
+    }
+    else {
+        const pathResponse = await (0, prompts_1.default)({
+            type: 'text',
+            name: 'archDocPath',
+            message: 'Please provide the relative path to your architecture document:',
+            initial: 'docs/architecture.md',
+            validate: (value) => value.length > 0 ? true : 'Path cannot be empty'
+        });
+        if (pathResponse.archDocPath) {
+            const fs = await Promise.resolve().then(() => __importStar(require('fs')));
+            const path = await Promise.resolve().then(() => __importStar(require('path')));
+            const resolvedPath = path.resolve(process.cwd(), pathResponse.archDocPath);
+            if (fs.existsSync(resolvedPath)) {
+                try {
+                    const configPath = (0, project_fraim_paths_1.getWorkspaceConfigPath)(process.cwd());
+                    if (fs.existsSync(configPath)) {
+                        const configContent = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+                        if (!configContent.customizations)
+                            configContent.customizations = {};
+                        configContent.customizations.architectureDoc = pathResponse.archDocPath;
+                        fs.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+                        console.log(chalk_1.default.green(`\n✅ Linked architecture document: ${pathResponse.archDocPath}`));
+                    }
+                    else {
+                        console.log(chalk_1.default.red(`\n❌ ${(0, project_fraim_paths_1.getWorkspaceFraimDisplayPath)('config.json')} not found. Could not save preference.`));
+                    }
+                }
+                catch (e) {
+                    console.error(chalk_1.default.red('\n❌ Failed to update config:'), e);
+                }
+            }
+            else {
+                console.log(chalk_1.default.yellow(`\n⚠️  File not found at ${pathResponse.archDocPath}. We'll skip linking it for now.`));
+            }
+        }
+    }
+    console.log(chalk_1.default.green(`\n✅ Jobs are installed in ${(0, project_fraim_paths_1.getWorkspaceFraimDisplayPath)('ai-employee/jobs')} and ${(0, project_fraim_paths_1.getWorkspaceFraimDisplayPath)('ai-manager/jobs')}.\n`));
+};
+exports.runFirstRunExperience = runFirstRunExperience;