fraim-framework 2.0.37 → 2.0.41

package/README.md

@@ -255,6 +255,14 @@ FRAIM/
 
 ## 🚀 **Get Started in 60 Seconds**
 
+### **⚠️ Prerequisites**
+
+**Shell Requirements:**
+- **Windows**: Must use Git Bash (install from https://git-scm.com/download/win)
+- **macOS/Linux**: Default terminal works fine
+
+**Why Git Bash on Windows?** All FRAIM scripts use Unix-style paths and Bash commands. Git Bash ensures consistent behavior across platforms.
+
 ### **Install & Initialize**
 ```bash
 npm install -g fraim-framework

package/dist/src/ai-manager/ai-manager.js

@@ -0,0 +1,162 @@
+"use strict";
+/**
+ * Simplified AI Manager
+ *
+ * Single AI manager integrated into fraim-mcp-server that reads validation rules
+ * from pre-defined JSON files and provides structured review instructions.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AIManager = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+class AIManager {
+    constructor(rulesPath) {
+        // Default to rules directory - server-side only, not sent to client
+        this.rulesPath = rulesPath || (0, path_1.join)(__dirname, '..', '..', 'registry', 'ai-manager-rules');
+    }
+    /**
+     * Generate review instructions for a workflow phase
+     */
+    generateReviewInstructions(context) {
+        console.log(`🤖 AI Manager: Generating review instructions for ${context.workflowType} phase`);
+        const rules = this.loadWorkflowRules(context.workflowType);
+        if (!rules) {
+            throw new Error(`No rules found for workflow type: ${context.workflowType}`);
+        }
+        return this.formatReviewInstructions(rules, context);
+    }
+    /**
+     * Evaluate agent's review report and provide decision
+     */
+    evaluateReport(report, context) {
+        console.log(`🤖 AI Manager: Evaluating review report for ${context.workflowType} phase`);
+        const iterationCount = report.iterationCount || 1;
+        const maxIterations = 3;
+        if (report.pass) {
+            return {
+                action: 'PROCEED',
+                message: 'Review passed. Ready to submit PR to human for review.',
+                nextSteps: [
+                    'Update issue status to "status:needs-review"',
+                    'Remove "status:wip" label',
+                    'Include complete review results in evidence document',
+                    'Submit PR for human review with evidence'
+                ],
+                iterationCount
+            };
+        }
+        else {
+            // Check if max iterations reached
+            if (iterationCount >= maxIterations) {
+                return {
+                    action: 'ESCALATE',
+                    message: `Maximum iterations (${maxIterations}) reached. Escalating to human review despite failing validation.`,
+                    nextSteps: [
+                        'Update issue status to "status:needs-review"',
+                        'Add "ai-manager:max-iterations" label to indicate escalation reason',
+                        'Include all iteration attempts and failure reasons in evidence document',
+                        'Submit PR for human review with detailed iteration history',
+                        'Human reviewer should focus on the recurring validation failures'
+                    ],
+                    iterationCount,
+                    maxIterationsReached: true
+                };
+            }
+            else {
+                return {
+                    action: 'ITERATE',
+                    message: `Review failed. Address the identified issues before proceeding. (Iteration ${iterationCount}/${maxIterations})`,
+                    nextSteps: [
+                        'Fix all issues identified in the failure reasons',
+                        'Re-run validation steps to verify fixes',
+                        `Request new review instructions with iterationCount: ${iterationCount + 1}`,
+                        'Do not submit PR until review passes or max iterations reached'
+                    ],
+                    iterationCount
+                };
+            }
+        }
+    }
+    /**
+     * Load workflow rules from JSON file (server-side only)
+     */
+    loadWorkflowRules(workflowType) {
+        const rulesFile = (0, path_1.join)(this.rulesPath, `${workflowType}.json`);
+        if (!(0, fs_1.existsSync)(rulesFile)) {
+            console.warn(`⚠️ No rules file found for workflow: ${workflowType} at ${rulesFile}`);
+            return null;
+        }
+        try {
+            const content = (0, fs_1.readFileSync)(rulesFile, 'utf8');
+            return JSON.parse(content);
+        }
+        catch (error) {
+            console.error(`❌ Error loading rules for ${workflowType}:`, error);
+            return null;
+        }
+    }
+    /**
+     * Format review instructions with proper template structure
+     */
+    formatReviewInstructions(rules, context) {
+        const instructions = `# AI Manager Review Instructions
+
+## Workflow: ${rules.workflowType.toUpperCase()}
+**Issue:** #${context.issueNumber}
+**Phase:** ${context.phase}
+
+## Description
+${rules.description}
+
+## Iteration Tracking
+**IMPORTANT**: You must track your iteration count for this phase. This is your attempt number for this specific workflow phase (spec, implement, test, etc.).
+
+- **First attempt**: Use iterationCount: 1
+- **After first failure**: Use iterationCount: 2  
+- **After second failure**: Use iterationCount: 3
+- **Maximum iterations**: 3 (after 3rd failure, work will be escalated to human review)
+
+## Validation Steps
+Complete each step below and evaluate whether you meet the pass criteria:
+
+${rules.validationRules.map(rule => `
+### Step ${rule.step}: ${rule.description}
+${rule.command ? `**Command:** \`${rule.command.replace('{issue_number}', context.issueNumber)}\`` : ''}
+**Pass Criteria:** ${rule.passCriteria}
+**Weight:** ${rule.weight.toUpperCase()}${rule.weight === 'blocking' ? ' (Must pass to proceed)' : ' (Should pass for quality)'}
+**Category:** ${rule.category}
+`).join('')}
+
+## Grading Criteria
+
+### Pass Requirements
+${rules.gradingCriteria.passRequirements.map(req => `- ${req}`).join('\n')}
+
+### Fail Requirements  
+${rules.gradingCriteria.failRequirements.map(req => `- ${req}`).join('\n')}
+
+## Reporting Format
+${rules.reportingFormat.instructions}
+
+**Required Response Format:**
+\`\`\`json
+{
+  "pass": true/false,
+  "reasons": ["reason1", "reason2"], // Only required if pass=false
+  "iterationCount": 1 // REQUIRED: Your current iteration number for this phase
+}
+\`\`\`
+
+## Iteration Limits
+- **Maximum 3 iterations** per workflow phase
+- After 3 failed attempts, work will be **automatically escalated** to human review
+- Track your attempts carefully - include iterationCount in every report
+- Each workflow phase (spec, implement, test) has its own iteration counter
+
+## Next Steps
+After completing your review, report back with the JSON response above including your iteration count. The AI Manager will evaluate your report and provide next steps based on your progress and iteration count.
+`;
+        return instructions;
+    }
+}
+exports.AIManager = AIManager;

package/dist/src/cli/commands/init-project.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initProjectCommand = exports.runInitProject = void 0;
+const commander_1 = require("commander");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const chalk_1 = __importDefault(require("chalk"));
+const sync_1 = require("./sync");
+const types_1 = require("../../fraim/types");
+const git_utils_1 = require("../../utils/git-utils");
+const version_utils_1 = require("../../utils/version-utils");
+const checkGlobalSetup = () => {
+    const globalConfigPath = path_1.default.join(os_1.default.homedir(), '.fraim', 'config.json');
+    return fs_1.default.existsSync(globalConfigPath);
+};
+const runInitProject = async () => {
+    console.log(chalk_1.default.blue('🚀 Initializing FRAIM project...'));
+    // Check if global setup exists
+    if (!checkGlobalSetup()) {
+        console.log(chalk_1.default.red('❌ Global FRAIM setup not found.'));
+        console.log(chalk_1.default.yellow('Please run global setup first:'));
+        console.log(chalk_1.default.cyan('   fraim setup --key=<your-fraim-key>'));
+        process.exit(1);
+    }
+    const projectRoot = process.cwd();
+    const fraimDir = path_1.default.join(projectRoot, '.fraim');
+    const configPath = path_1.default.join(fraimDir, 'config.json');
+    if (!fs_1.default.existsSync(fraimDir)) {
+        fs_1.default.mkdirSync(fraimDir, { recursive: true });
+        console.log(chalk_1.default.green('✅ Created .fraim directory'));
+    }
+    else {
+        console.log(chalk_1.default.yellow('ℹ️  .fraim directory already exists'));
+    }
+    if (!fs_1.default.existsSync(configPath)) {
+        const remoteInfo = (0, git_utils_1.getGitRemoteInfo)();
+        // Git remote is optional for project init
+        const config = {
+            ...types_1.DEFAULT_FRAIM_CONFIG,
+            version: (0, version_utils_1.getFraimVersion)(),
+            project: {
+                ...types_1.DEFAULT_FRAIM_CONFIG.project,
+                name: remoteInfo.repo || path_1.default.basename(projectRoot)
+            },
+            git: {
+                ...types_1.DEFAULT_FRAIM_CONFIG.git,
+                repoOwner: remoteInfo.owner || types_1.DEFAULT_FRAIM_CONFIG.git.repoOwner,
+                repoName: remoteInfo.repo || path_1.default.basename(projectRoot)
+            }
+        };
+        fs_1.default.writeFileSync(configPath, JSON.stringify(config, null, 2));
+        console.log(chalk_1.default.green('✅ Created .fraim/config.json'));
+    }
+    // Create subdirectories
+    ['workflows'].forEach(dir => {
+        const dirPath = path_1.default.join(fraimDir, dir);
+        if (!fs_1.default.existsSync(dirPath)) {
+            fs_1.default.mkdirSync(dirPath, { recursive: true });
+            console.log(chalk_1.default.green(`✅ Created .fraim/${dir}`));
+        }
+    });
+    // Sync workflows from registry
+    await (0, sync_1.runSync)({});
+    console.log(chalk_1.default.green('\n✅ FRAIM project initialized!'));
+    console.log(chalk_1.default.cyan('Try: Ask your AI agent "list fraim workflows"'));
+};
+exports.runInitProject = runInitProject;
+exports.initProjectCommand = new commander_1.Command('init-project')
+    .description('Initialize FRAIM in the current project (requires global setup)')
+    .action(exports.runInitProject);

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

@@ -0,0 +1,176 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupCommand = exports.runSetup = void 0;
+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 os_1 = __importDefault(require("os"));
+const token_validator_1 = require("../setup/token-validator");
+const auto_mcp_setup_1 = require("../setup/auto-mcp-setup");
+const script_sync_utils_1 = require("../../utils/script-sync-utils");
+const version_utils_1 = require("../../utils/version-utils");
+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';
+                if ((0, token_validator_1.isValidTokenFormat)(value, 'fraim'))
+                    return true;
+                return 'Please enter a valid FRAIM key (starts with fraim_)';
+            }
+        });
+        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;
+        }
+        // Validate key
+        const isValid = await (0, token_validator_1.validateFraimKey)(keyResponse.key);
+        if (isValid) {
+            console.log(chalk_1.default.green('✅ FRAIM key validated\n'));
+            return keyResponse.key;
+        }
+        else {
+            console.log(chalk_1.default.red('❌ Invalid FRAIM key\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 FRAIM key and try again.'));
+    process.exit(1);
+};
+const saveGlobalConfig = (fraimKey) => {
+    const globalConfigDir = path_1.default.join(os_1.default.homedir(), '.fraim');
+    const globalConfigPath = path_1.default.join(globalConfigDir, 'config.json');
+    if (!fs_1.default.existsSync(globalConfigDir)) {
+        fs_1.default.mkdirSync(globalConfigDir, { recursive: true });
+    }
+    const config = {
+        version: (0, version_utils_1.getFraimVersion)(),
+        apiKey: fraimKey,
+        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'));
+};
+const syncGlobalScripts = () => {
+    console.log(chalk_1.default.blue('🔄 Syncing FRAIM scripts to user directory...'));
+    // Find registry path
+    let registryPath = path_1.default.join(__dirname, '../../../../registry');
+    if (!fs_1.default.existsSync(registryPath)) {
+        registryPath = path_1.default.join(__dirname, '../../../registry');
+    }
+    if (fs_1.default.existsSync(registryPath)) {
+        const syncResult = (0, script_sync_utils_1.syncScriptsToUserDirectory)(registryPath);
+        console.log(chalk_1.default.green(`✅ Synced ${syncResult.synced} scripts to user directory.`));
+        if (syncResult.ephemeral > 0) {
+            console.log(chalk_1.default.gray(`   ${syncResult.ephemeral} dependent scripts will use ephemeral execution.`));
+        }
+    }
+    else {
+        console.log(chalk_1.default.yellow('⚠️ Registry not found, skipping script sync.'));
+    }
+};
+const runSetup = async (options) => {
+    console.log(chalk_1.default.blue('🚀 Welcome to FRAIM! Let\'s get you set up.\n'));
+    // Show what we're about to do
+    console.log(chalk_1.default.yellow('📋 This setup will:'));
+    console.log(chalk_1.default.gray('   • Validate your FRAIM and GitHub tokens'));
+    console.log(chalk_1.default.gray('   • Create global FRAIM configuration'));
+    console.log(chalk_1.default.gray('   • Detect and configure supported IDEs'));
+    console.log(chalk_1.default.gray('   • Sync FRAIM scripts to your system'));
+    console.log(chalk_1.default.gray('   • Set up MCP servers for AI integration\n'));
+    // Get FRAIM key
+    let fraimKey = options.key;
+    if (!fraimKey) {
+        fraimKey = await promptForFraimKey();
+    }
+    else {
+        if (!(0, token_validator_1.isValidTokenFormat)(fraimKey, 'fraim')) {
+            console.log(chalk_1.default.red('❌ Invalid FRAIM key format. Key must start with fraim_'));
+            process.exit(1);
+        }
+        console.log(chalk_1.default.blue('🔑 Validating FRAIM key...'));
+        const isValid = await (0, token_validator_1.validateFraimKey)(fraimKey);
+        if (!isValid) {
+            console.log(chalk_1.default.red('❌ Invalid FRAIM key'));
+            process.exit(1);
+        }
+        console.log(chalk_1.default.green('✅ FRAIM key validated\n'));
+    }
+    // Get GitHub token
+    let githubToken = options.githubToken;
+    if (!githubToken) {
+        githubToken = await (0, auto_mcp_setup_1.promptForGitHubToken)();
+    }
+    else {
+        if (!(0, token_validator_1.isValidTokenFormat)(githubToken, 'github')) {
+            console.log(chalk_1.default.red('❌ Invalid GitHub token format. Token must start with ghp_ or github_pat_'));
+            process.exit(1);
+        }
+        console.log(chalk_1.default.blue('🔍 Validating GitHub token...'));
+        const isValid = await (0, token_validator_1.validateGitHubToken)(githubToken);
+        if (!isValid) {
+            console.log(chalk_1.default.red('❌ Invalid GitHub token'));
+            process.exit(1);
+        }
+        console.log(chalk_1.default.green('✅ GitHub token validated\n'));
+    }
+    // Save global configuration
+    console.log(chalk_1.default.blue('💾 Saving global configuration...'));
+    saveGlobalConfig(fraimKey);
+    // Sync global scripts
+    syncGlobalScripts();
+    // Configure IDEs
+    const selectedIDEs = options.ide ? options.ide.split(',') : undefined;
+    const autoAll = options.all;
+    if (autoAll && selectedIDEs) {
+        console.log(chalk_1.default.yellow('⚠️ Both --all and --ide specified. Using --ide selection.'));
+    }
+    await (0, auto_mcp_setup_1.autoConfigureMCP)(fraimKey, githubToken, selectedIDEs);
+    console.log(chalk_1.default.green('\n🎯 Setup complete! 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"'));
+    console.log(chalk_1.default.blue('\n💡 Use "fraim test-mcp" to verify your setup anytime.'));
+};
+exports.runSetup = runSetup;
+exports.setupCommand = new commander_1.Command('setup')
+    .description('Complete global FRAIM setup with IDE configuration')
+    .option('--key <key>', 'FRAIM API key')
+    .option('--github-token <token>', 'GitHub Personal Access Token')
+    .option('--all', 'Auto-configure all detected IDEs')
+    .option('--ide <ides>', 'Configure specific IDEs (comma-separated: claude,cursor,kiro)')
+    .action(exports.runSetup);

package/dist/src/cli/commands/test-mcp.js

@@ -0,0 +1,135 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testMCPCommand = exports.runTestMCP = void 0;
+const commander_1 = require("commander");
+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 ide_detector_1 = require("../setup/ide-detector");
+const testIDEConfig = async (ide) => {
+    const result = {
+        ide: ide.name,
+        configExists: false,
+        configValid: false,
+        mcpServers: [],
+        errors: []
+    };
+    const configPath = (0, ide_detector_1.expandPath)(ide.configPath);
+    if (!fs_1.default.existsSync(configPath)) {
+        result.errors.push('Config file does not exist');
+        return result;
+    }
+    result.configExists = true;
+    try {
+        if (ide.configFormat === 'json') {
+            const configContent = fs_1.default.readFileSync(configPath, 'utf8');
+            const config = JSON.parse(configContent);
+            if (config.mcpServers) {
+                result.configValid = true;
+                result.mcpServers = Object.keys(config.mcpServers);
+            }
+            else {
+                result.errors.push('No mcpServers section found');
+            }
+        }
+        else if (ide.configFormat === 'toml') {
+            const configContent = fs_1.default.readFileSync(configPath, 'utf8');
+            // Simple TOML parsing for MCP servers
+            const serverMatches = configContent.match(/\[mcp_servers\.(\w+)\]/g);
+            if (serverMatches) {
+                result.configValid = true;
+                result.mcpServers = serverMatches.map(match => match.replace(/\[mcp_servers\.(\w+)\]/, '$1'));
+            }
+            else {
+                result.errors.push('No mcp_servers sections found');
+            }
+        }
+    }
+    catch (error) {
+        result.errors.push(`Failed to parse config: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+    return result;
+};
+const checkGlobalSetup = () => {
+    const globalConfigPath = path_1.default.join(os_1.default.homedir(), '.fraim', 'config.json');
+    return fs_1.default.existsSync(globalConfigPath);
+};
+const runTestMCP = async () => {
+    console.log(chalk_1.default.blue('🔍 Testing MCP configuration...\n'));
+    // Check global setup
+    if (!checkGlobalSetup()) {
+        console.log(chalk_1.default.red('❌ Global FRAIM setup not found.'));
+        console.log(chalk_1.default.yellow('Please run: fraim setup --key=<your-fraim-key>'));
+        return;
+    }
+    console.log(chalk_1.default.green('✅ Global FRAIM setup found'));
+    // Detect IDEs
+    const detectedIDEs = (0, ide_detector_1.detectInstalledIDEs)();
+    if (detectedIDEs.length === 0) {
+        console.log(chalk_1.default.yellow('⚠️ No supported IDEs detected.'));
+        return;
+    }
+    console.log(chalk_1.default.blue(`\n🔍 Testing ${detectedIDEs.length} detected IDEs...\n`));
+    const results = await Promise.all(detectedIDEs.map(ide => testIDEConfig(ide)));
+    let totalConfigured = 0;
+    let totalWithFRAIM = 0;
+    for (const result of results) {
+        console.log(chalk_1.default.white(`📱 ${result.ide}`));
+        if (!result.configExists) {
+            console.log(chalk_1.default.red('   ❌ No MCP config found'));
+            console.log(chalk_1.default.gray(`   💡 Run: fraim setup --ide=${result.ide.toLowerCase()}`));
+        }
+        else if (!result.configValid) {
+            console.log(chalk_1.default.yellow('   ⚠️ Config exists but invalid'));
+            result.errors.forEach(error => {
+                console.log(chalk_1.default.red(`   ❌ ${error}`));
+            });
+        }
+        else {
+            totalConfigured++;
+            console.log(chalk_1.default.green(`   ✅ MCP config valid (${result.mcpServers.length} servers)`));
+            // Check for essential servers
+            const essentialServers = ['fraim', 'git', 'github', 'playwright'];
+            const hasEssential = essentialServers.filter(server => result.mcpServers.includes(server));
+            if (hasEssential.includes('fraim')) {
+                totalWithFRAIM++;
+                console.log(chalk_1.default.green('   ✅ FRAIM server configured'));
+            }
+            else {
+                console.log(chalk_1.default.yellow('   ⚠️ FRAIM server missing'));
+            }
+            if (hasEssential.length > 1) {
+                console.log(chalk_1.default.green(`   ✅ ${hasEssential.length - 1} additional servers: ${hasEssential.filter(s => s !== 'fraim').join(', ')}`));
+            }
+            const missingEssential = essentialServers.filter(server => !result.mcpServers.includes(server));
+            if (missingEssential.length > 0) {
+                console.log(chalk_1.default.yellow(`   ⚠️ Missing servers: ${missingEssential.join(', ')}`));
+            }
+        }
+        console.log(); // Empty line
+    }
+    // Summary
+    console.log(chalk_1.default.blue('📊 Summary:'));
+    console.log(chalk_1.default.green(`   ✅ ${totalConfigured}/${detectedIDEs.length} IDEs have valid MCP configs`));
+    console.log(chalk_1.default.green(`   ✅ ${totalWithFRAIM}/${detectedIDEs.length} IDEs have FRAIM configured`));
+    if (totalWithFRAIM === 0) {
+        console.log(chalk_1.default.red('\n❌ No IDEs have FRAIM configured!'));
+        console.log(chalk_1.default.yellow('💡 Run: fraim setup --key=<your-fraim-key>'));
+    }
+    else if (totalWithFRAIM < detectedIDEs.length) {
+        console.log(chalk_1.default.yellow(`\n⚠️ ${detectedIDEs.length - totalWithFRAIM} IDEs missing FRAIM configuration`));
+        console.log(chalk_1.default.yellow('💡 Run: fraim setup to configure remaining IDEs'));
+    }
+    else {
+        console.log(chalk_1.default.green('\n🎉 All detected IDEs have FRAIM configured!'));
+        console.log(chalk_1.default.blue('💡 Try running: fraim init-project in any project'));
+    }
+};
+exports.runTestMCP = runTestMCP;
+exports.testMCPCommand = new commander_1.Command('test-mcp')
+    .description('Test MCP server configurations for all detected IDEs')
+    .action(exports.runTestMCP);

package/dist/src/cli/fraim.js

@@ -10,6 +10,9 @@ const sync_1 = require("./commands/sync");
 const doctor_1 = require("./commands/doctor");
 const list_1 = require("./commands/list");
 const wizard_1 = require("./commands/wizard");
+const setup_1 = require("./commands/setup");
+const init_project_1 = require("./commands/init-project");
+const test_mcp_1 = require("./commands/test-mcp");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const program = new commander_1.Command();
@@ -42,4 +45,7 @@ program.addCommand(sync_1.syncCommand);
 program.addCommand(doctor_1.doctorCommand);
 program.addCommand(list_1.listCommand);
 program.addCommand(wizard_1.wizardCommand);
+program.addCommand(setup_1.setupCommand);
+program.addCommand(init_project_1.initProjectCommand);
+program.addCommand(test_mcp_1.testMCPCommand);
 program.parse(process.argv);