fraim 2.0.100

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

@@ -0,0 +1,162 @@
+"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.syncCommand = exports.runSync = void 0;
+const commander_1 = require("commander");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const config_loader_1 = require("../../core/config-loader");
+const version_utils_1 = require("../utils/version-utils");
+const script_sync_utils_1 = require("../utils/script-sync-utils");
+const git_utils_1 = require("../../core/utils/git-utils");
+const agent_adapters_1 = require("../utils/agent-adapters");
+const project_fraim_paths_1 = require("../../core/utils/project-fraim-paths");
+/**
+ * Load API key from user-level config (~/.fraim/config.json)
+ */
+function loadUserApiKey() {
+    const userConfigPath = path_1.default.join((0, script_sync_utils_1.getUserFraimDir)(), 'config.json');
+    if (!fs_1.default.existsSync(userConfigPath)) {
+        return undefined;
+    }
+    try {
+        const userConfig = JSON.parse(fs_1.default.readFileSync(userConfigPath, 'utf8'));
+        return userConfig.apiKey;
+    }
+    catch {
+        console.warn(chalk_1.default.yellow('Failed to read user-level config for API key'));
+        return undefined;
+    }
+}
+function updateVersionInConfig(fraimDir) {
+    const configPath = path_1.default.join(fraimDir, 'config.json');
+    if (!fs_1.default.existsSync(configPath)) {
+        return;
+    }
+    try {
+        const currentConfig = JSON.parse(fs_1.default.readFileSync(configPath, 'utf8'));
+        const newVersion = (0, version_utils_1.getFraimVersion)();
+        if (currentConfig.version !== newVersion) {
+            currentConfig.version = newVersion;
+            fs_1.default.writeFileSync(configPath, JSON.stringify(currentConfig, null, 2));
+            console.log(chalk_1.default.green(`Updated FRAIM version to ${newVersion} in config.`));
+        }
+    }
+    catch {
+        console.warn(chalk_1.default.yellow('Could not update version in config.json.'));
+    }
+}
+const runSync = async (options) => {
+    const projectRoot = process.cwd();
+    const config = (0, config_loader_1.loadFraimConfig)();
+    const fraimDir = (0, project_fraim_paths_1.getWorkspaceFraimDir)(projectRoot);
+    const isNpx = process.env.npm_config_prefix === undefined || process.env.npm_lifecycle_event === 'npx';
+    const isGlobal = !isNpx && (process.env.npm_config_global === 'true' || process.env.npm_config_prefix);
+    if (isGlobal && !options.skipUpdates) {
+        console.log(chalk_1.default.yellow('You are running a global installation of FRAIM.'));
+        console.log(chalk_1.default.gray('Updates are not automatic in this mode.'));
+        console.log(chalk_1.default.cyan('Recommended: Use "npx fraim-framework@latest sync" instead.\n'));
+    }
+    const { syncFromRemote } = await Promise.resolve().then(() => __importStar(require('../utils/remote-sync')));
+    if (options.local) {
+        console.log(chalk_1.default.blue('Syncing FRAIM jobs from local server...'));
+        const localPort = process.env.FRAIM_MCP_PORT ? parseInt(process.env.FRAIM_MCP_PORT) : (0, git_utils_1.getPort)();
+        const result = await syncFromRemote({
+            remoteUrl: `http://localhost:${localPort}`,
+            apiKey: 'local-dev',
+            projectRoot,
+            skipUpdates: true
+        });
+        if (result.success) {
+            console.log(chalk_1.default.green(`Successfully synced ${result.employeeJobsSynced} ai-employee jobs, ${result.managerJobsSynced} ai-manager jobs, ${result.skillsSynced} skills, ${result.rulesSynced} rules, ${result.scriptsSynced} scripts, and ${result.docsSynced} docs from local server`));
+            updateVersionInConfig(fraimDir);
+            const adapterUpdates = (0, agent_adapters_1.ensureAgentAdapterFiles)(projectRoot);
+            if (adapterUpdates.length > 0) {
+                console.log(chalk_1.default.green(`Updated FRAIM agent adapter files: ${adapterUpdates.join(', ')}`));
+            }
+            return;
+        }
+        console.error(chalk_1.default.red(`Local sync failed: ${result.error}`));
+        console.error(chalk_1.default.yellow('Make sure the FRAIM MCP server is running locally (npm run dev).'));
+        process.exit(1);
+    }
+    let apiKey = loadUserApiKey() || config.apiKey || process.env.FRAIM_API_KEY;
+    if (!apiKey) {
+        if (process.env.TEST_MODE === 'true') {
+            console.log(chalk_1.default.yellow('TEST_MODE: No API key configured. Using test placeholder key.'));
+            apiKey = 'test-mode-key';
+        }
+        else {
+            console.error(chalk_1.default.red('No API key configured. Cannot sync.'));
+            console.error(chalk_1.default.yellow(`Set FRAIM_API_KEY in your environment, or add apiKey to ~/.fraim/config.json or ${(0, project_fraim_paths_1.getWorkspaceFraimDisplayPath)('config.json')}`));
+            console.error(chalk_1.default.yellow('Or use --local to sync from a locally running FRAIM server.'));
+            process.exit(1);
+        }
+    }
+    console.log(chalk_1.default.blue('Syncing FRAIM jobs from remote server...'));
+    const result = await syncFromRemote({
+        remoteUrl: config.remoteUrl,
+        apiKey,
+        projectRoot,
+        skipUpdates: options.skipUpdates || false
+    });
+    if (!result.success) {
+        console.error(chalk_1.default.red(`Remote sync failed: ${result.error}`));
+        console.error(chalk_1.default.yellow('Check your API key and network connection.'));
+        if (process.env.TEST_MODE === 'true') {
+            console.log(chalk_1.default.yellow('TEST_MODE: Continuing without remote sync (server may be unavailable).'));
+            updateVersionInConfig(fraimDir);
+            return;
+        }
+        process.exit(1);
+    }
+    console.log(chalk_1.default.green(`Successfully synced ${result.employeeJobsSynced} ai-employee jobs, ${result.managerJobsSynced} ai-manager jobs, ${result.skillsSynced} skills, ${result.rulesSynced} rules, ${result.scriptsSynced} scripts, and ${result.docsSynced} docs from remote`));
+    updateVersionInConfig(fraimDir);
+    const adapterUpdates = (0, agent_adapters_1.ensureAgentAdapterFiles)(projectRoot);
+    if (adapterUpdates.length > 0) {
+        console.log(chalk_1.default.green(`Updated FRAIM agent adapter files: ${adapterUpdates.join(', ')}`));
+    }
+};
+exports.runSync = runSync;
+exports.syncCommand = new commander_1.Command('sync')
+    .description('Sync job stubs from the framework registry')
+    .option('-f, --force', 'Force sync even if digest matches')
+    .option('--skip-updates', 'Skip checking for CLI updates (legacy)')
+    .option('--local', 'Sync from local development server (port derived from git branch)')
+    .action(exports.runSync);

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

@@ -0,0 +1,171 @@
+"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.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 ide_detector_1 = require("../setup/ide-detector");
+const script_sync_utils_1 = require("../utils/script-sync-utils");
+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);
+            const servers = ide.configType === 'vscode' ? config.servers : config.mcpServers;
+            if (servers) {
+                result.configValid = true;
+                result.mcpServers = Object.keys(servers);
+            }
+            else {
+                const expectedKey = ide.configType === 'vscode' ? 'servers' : 'mcpServers';
+                result.errors.push(`No ${expectedKey} 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((0, script_sync_utils_1.getUserFraimDir)(), '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 { BASE_MCP_SERVERS } = await Promise.resolve().then(() => __importStar(require('../mcp/mcp-server-registry')));
+            const essentialServers = BASE_MCP_SERVERS.map(s => s.id); // fraim, git, 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/doctor/check-runner.js

@@ -0,0 +1,199 @@
+"use strict";
+/**
+ * Check runner for FRAIM doctor command
+ * Handles parallel execution, timeouts, and error handling
+ * Issue #144: Enhanced doctor command
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runChecks = runChecks;
+const CHECK_TIMEOUT = 2000; // 2 seconds per check
+const MCP_CHECK_TIMEOUT = 10000; // 10 seconds for MCP connectivity checks
+const TOTAL_TIMEOUT = 30000; // 30 seconds total
+// Simple logger for doctor command (optional, falls back to no-op)
+const logger = {
+    debug: (...args) => {
+        if (process.env.DEBUG)
+            console.debug('[DOCTOR]', ...args);
+    },
+    info: (...args) => {
+        if (process.env.VERBOSE)
+            console.log('[DOCTOR]', ...args);
+    },
+    warn: (...args) => {
+        console.warn('[DOCTOR]', ...args);
+    },
+    error: (...args) => {
+        console.error('[DOCTOR]', ...args);
+    }
+};
+// Simple metric tracker (no-op for now, can be enhanced later)
+const trackMetric = (name, value) => {
+    if (process.env.DEBUG) {
+        console.debug(`[METRIC] ${name}: ${value}`);
+    }
+};
+/**
+ * Run a single check with timeout
+ */
+async function runCheckWithTimeout(check, timeout = CHECK_TIMEOUT) {
+    const checkStartTime = Date.now();
+    // Use longer timeout for MCP connectivity checks
+    const effectiveTimeout = check.category === 'mcpConnectivity' ? MCP_CHECK_TIMEOUT : timeout;
+    try {
+        logger.debug(`Running check: ${check.name}`, { category: check.category });
+        const result = await Promise.race([
+            check.run(),
+            new Promise((_, reject) => setTimeout(() => reject(new Error('Timeout')), effectiveTimeout))
+        ]);
+        const checkDuration = Date.now() - checkStartTime;
+        logger.debug(`Check completed: ${check.name}`, {
+            status: result.status,
+            duration: checkDuration
+        });
+        return result;
+    }
+    catch (error) {
+        const checkDuration = Date.now() - checkStartTime;
+        if (error.message === 'Timeout') {
+            logger.warn(`Check timed out: ${check.name}`, { duration: checkDuration });
+            return {
+                status: 'warning',
+                message: `${check.name} timed out`,
+                suggestion: 'Check may be slow or unresponsive'
+            };
+        }
+        logger.error(`Check failed: ${check.name}`, { error: error.message, duration: checkDuration });
+        return {
+            status: 'error',
+            message: `${check.name} failed: ${error.message}`,
+            suggestion: 'See error details above',
+            details: { error: error.message }
+        };
+    }
+}
+/**
+ * Filter checks based on command options
+ */
+function filterChecks(checks, options) {
+    // If no specific flags, run all checks
+    if (!options.testMcp && !options.testConfig && !options.testJobs) {
+        return checks;
+    }
+    return checks.filter(check => {
+        if (options.testMcp && check.category === 'mcpConnectivity')
+            return true;
+        if (options.testConfig && (check.category === 'globalSetup' || check.category === 'projectSetup' || check.category === 'ideConfiguration'))
+            return true;
+        if (options.testJobs && check.category === 'jobs')
+            return true;
+        return false;
+    });
+}
+/**
+ * Run all checks with parallel execution and timeout
+ */
+async function runChecks(checks, options, version) {
+    const startTime = Date.now();
+    // Filter checks based on options
+    const filteredChecks = filterChecks(checks, options);
+    logger.info(`Running ${filteredChecks.length} checks`, {
+        total: checks.length,
+        filtered: filteredChecks.length,
+        options
+    });
+    // Group checks by category for logging
+    const categoryCounts = {};
+    for (const check of filteredChecks) {
+        categoryCounts[check.category] = (categoryCounts[check.category] || 0) + 1;
+    }
+    for (const [category, count] of Object.entries(categoryCounts)) {
+        logger.info(`Category: ${category}`, { checkCount: count });
+    }
+    // Run checks in parallel with overall timeout
+    const checkPromises = filteredChecks.map(check => runCheckWithTimeout(check).then(result => ({ check, result })));
+    let checkResults;
+    try {
+        checkResults = await Promise.race([
+            Promise.all(checkPromises),
+            new Promise((_, reject) => setTimeout(() => reject(new Error('Total timeout exceeded')), TOTAL_TIMEOUT))
+        ]);
+    }
+    catch (error) {
+        logger.error('Total timeout exceeded for all checks');
+        // If total timeout exceeded, return partial results
+        checkResults = [];
+    }
+    // Group results by category
+    const categories = {
+        globalSetup: { checks: [] },
+        projectSetup: { checks: [] },
+        jobs: { checks: [] },
+        ideConfiguration: { checks: [] },
+        mcpConnectivity: { checks: [] },
+        scripts: { checks: [] }
+    };
+    let passed = 0;
+    let warnings = 0;
+    let errors = 0;
+    for (const { check, result } of checkResults) {
+        const categoryResult = {
+            name: check.name,
+            status: result.status,
+            message: result.message,
+            suggestion: result.suggestion,
+            command: result.command,
+            details: result.details,
+            latency: result.latency
+        };
+        categories[check.category].checks.push(categoryResult);
+        if (result.status === 'passed')
+            passed++;
+        else if (result.status === 'warning')
+            warnings++;
+        else if (result.status === 'error')
+            errors++;
+    }
+    const duration = Date.now() - startTime;
+    // Track category durations
+    for (const [category, categoryResult] of Object.entries(categories)) {
+        if (categoryResult.checks.length > 0) {
+            trackMetric(`doctor.category.${category}.duration`, duration);
+            trackMetric(`doctor.category.${category}.checks`, categoryResult.checks.length);
+        }
+    }
+    // Track MCP latencies
+    for (const { result } of checkResults) {
+        if (result.latency !== undefined) {
+            trackMetric('doctor.mcp.latency', result.latency);
+        }
+    }
+    logger.info('All checks completed', {
+        duration,
+        passed,
+        warnings,
+        errors,
+        total: checkResults.length
+    });
+    // Generate suggestions from errors and warnings
+    const suggestions = checkResults
+        .filter(({ result }) => result.status !== 'passed' && result.suggestion)
+        .map(({ result }, index) => ({
+        priority: result.status === 'error' ? index + 1 : index + 100,
+        message: result.suggestion,
+        command: result.command,
+        reason: result.message
+    }))
+        .sort((a, b) => a.priority - b.priority);
+    return {
+        timestamp: new Date().toISOString(),
+        version,
+        summary: {
+            passed,
+            warnings,
+            errors,
+            total: checkResults.length
+        },
+        categories: categories,
+        suggestions: suggestions // Always include array, even if empty
+    };
+}