fraim 2.0.100

package/dist/src/cli/doctor/checks/global-setup-checks.js

@@ -0,0 +1,220 @@
+"use strict";
+/**
+ * Global setup checks for FRAIM doctor command
+ * Validates global configuration and API keys
+ * Issue #144: Enhanced doctor command
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGlobalSetupChecks = getGlobalSetupChecks;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const getGlobalConfigPath = () => path_1.default.join(os_1.default.homedir(), '.fraim', 'config.json');
+/**
+ * Check if global config exists
+ */
+function checkGlobalConfigExists() {
+    return {
+        name: 'Global config exists',
+        category: 'globalSetup',
+        critical: true,
+        run: async () => {
+            if (fs_1.default.existsSync(getGlobalConfigPath())) {
+                return {
+                    status: 'passed',
+                    message: 'Global config exists',
+                    details: { path: getGlobalConfigPath() }
+                };
+            }
+            return {
+                status: 'error',
+                message: 'Global config missing',
+                suggestion: 'Run fraim setup to create global configuration',
+                command: 'fraim setup'
+            };
+        }
+    };
+}
+/**
+ * Check if mode is valid
+ */
+function checkModeValid() {
+    return {
+        name: 'Mode valid',
+        category: 'globalSetup',
+        critical: false,
+        run: async () => {
+            try {
+                if (!fs_1.default.existsSync(getGlobalConfigPath())) {
+                    return {
+                        status: 'error',
+                        message: 'Cannot check mode - global config missing'
+                    };
+                }
+                const config = JSON.parse(fs_1.default.readFileSync(getGlobalConfigPath(), 'utf8'));
+                const mode = config.mode || 'conversational';
+                const validModes = ['conversational', 'integrated', 'split'];
+                if (validModes.includes(mode)) {
+                    return {
+                        status: 'passed',
+                        message: `Mode: ${mode}`,
+                        details: { mode }
+                    };
+                }
+                return {
+                    status: 'error',
+                    message: `Invalid mode: ${mode}`,
+                    suggestion: 'Mode must be conversational, integrated, or split',
+                    details: { mode, validModes }
+                };
+            }
+            catch (error) {
+                return {
+                    status: 'error',
+                    message: 'Failed to read mode from config',
+                    details: { error: error.message }
+                };
+            }
+        }
+    };
+}
+/**
+ * Check if API key is configured
+ */
+function checkApiKeyConfigured() {
+    return {
+        name: 'API key configured',
+        category: 'globalSetup',
+        critical: false,
+        run: async () => {
+            try {
+                if (!fs_1.default.existsSync(getGlobalConfigPath())) {
+                    return {
+                        status: 'error',
+                        message: 'Cannot check API key - global config missing'
+                    };
+                }
+                const config = JSON.parse(fs_1.default.readFileSync(getGlobalConfigPath(), 'utf8'));
+                if (config.apiKey) {
+                    const maskedKey = config.apiKey.substring(0, 10) + '...';
+                    return {
+                        status: 'passed',
+                        message: `API key configured (${maskedKey})`,
+                        details: { keyPrefix: config.apiKey.substring(0, 10) }
+                    };
+                }
+                return {
+                    status: 'warning',
+                    message: 'API key not configured',
+                    suggestion: 'Add apiKey to global config for remote features',
+                    details: { configPath: getGlobalConfigPath() }
+                };
+            }
+            catch (error) {
+                return {
+                    status: 'error',
+                    message: 'Failed to read API key from config',
+                    details: { error: error.message }
+                };
+            }
+        }
+    };
+}
+/**
+ * Check if GitHub token is configured
+ */
+function checkGitHubTokenConfigured() {
+    return {
+        name: 'GitHub token configured',
+        category: 'globalSetup',
+        critical: false,
+        run: async () => {
+            try {
+                if (!fs_1.default.existsSync(getGlobalConfigPath())) {
+                    return {
+                        status: 'error',
+                        message: 'Cannot check GitHub token - global config missing'
+                    };
+                }
+                const config = JSON.parse(fs_1.default.readFileSync(getGlobalConfigPath(), 'utf8'));
+                // Check if repository provider is GitHub
+                if (config.repository?.provider === 'github') {
+                    // Token would be in IDE MCP configs, not global config
+                    return {
+                        status: 'passed',
+                        message: 'GitHub provider configured',
+                        details: { provider: 'github' }
+                    };
+                }
+                return {
+                    status: 'passed',
+                    message: 'GitHub not configured (not required)',
+                    details: { provider: config.repository?.provider || 'none' }
+                };
+            }
+            catch (error) {
+                return {
+                    status: 'error',
+                    message: 'Failed to check GitHub configuration',
+                    details: { error: error.message }
+                };
+            }
+        }
+    };
+}
+/**
+ * Check if remote URL is configured (optional)
+ */
+function checkRemoteUrlConfigured() {
+    return {
+        name: 'Remote URL configured',
+        category: 'globalSetup',
+        critical: false,
+        run: async () => {
+            try {
+                if (!fs_1.default.existsSync(getGlobalConfigPath())) {
+                    return {
+                        status: 'error',
+                        message: 'Cannot check remote URL - global config missing'
+                    };
+                }
+                const config = JSON.parse(fs_1.default.readFileSync(getGlobalConfigPath(), 'utf8'));
+                if (config.remoteUrl) {
+                    return {
+                        status: 'passed',
+                        message: `Remote URL: ${config.remoteUrl}`,
+                        details: { remoteUrl: config.remoteUrl }
+                    };
+                }
+                // Remote URL is optional - just note it's not configured
+                return {
+                    status: 'passed',
+                    message: 'Remote URL not configured (optional)',
+                    details: { configPath: getGlobalConfigPath(), optional: true }
+                };
+            }
+            catch (error) {
+                return {
+                    status: 'error',
+                    message: 'Failed to read remote URL from config',
+                    details: { error: error.message }
+                };
+            }
+        }
+    };
+}
+/**
+ * Get all global setup checks
+ */
+function getGlobalSetupChecks() {
+    return [
+        checkGlobalConfigExists(),
+        checkModeValid(),
+        checkApiKeyConfigured(),
+        checkGitHubTokenConfigured(),
+        checkRemoteUrlConfigured()
+    ];
+}

package/dist/src/cli/doctor/checks/ide-config-checks.js

@@ -0,0 +1,250 @@
+"use strict";
+/**
+ * IDE configuration checks for FRAIM doctor command
+ * Validates IDE installations and MCP configurations
+ * Issue #144: Enhanced doctor command
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getIDEConfigChecks = getIDEConfigChecks;
+const fs_1 = __importDefault(require("fs"));
+const ide_detector_1 = require("../../setup/ide-detector");
+/**
+ * Check if any IDEs are detected
+ */
+function checkIDEsDetected() {
+    return {
+        name: 'IDEs detected',
+        category: 'ideConfiguration',
+        critical: false,
+        run: async () => {
+            const installedIDEs = (0, ide_detector_1.detectInstalledIDEs)();
+            if (installedIDEs.length > 0) {
+                const ideNames = installedIDEs.map(ide => ide.name).join(', ');
+                return {
+                    status: 'passed',
+                    message: `${installedIDEs.length} IDE(s) detected: ${ideNames}`,
+                    details: {
+                        count: installedIDEs.length,
+                        ides: installedIDEs.map(ide => ide.name)
+                    }
+                };
+            }
+            return {
+                status: 'warning',
+                message: 'No IDEs detected',
+                suggestion: 'Install Claude Desktop, Cursor, or another supported IDE',
+                details: { supportedIDEs: ['Claude Desktop', 'Cursor', 'Windsurf', 'VS Code', 'Zed', 'Codex'] }
+            };
+        }
+    };
+}
+/**
+ * Check if MCP configs exist for detected IDEs
+ */
+function checkMCPConfigsExist() {
+    return {
+        name: 'MCP configs exist',
+        category: 'ideConfiguration',
+        critical: false,
+        run: async () => {
+            const installedIDEs = (0, ide_detector_1.detectInstalledIDEs)();
+            if (installedIDEs.length === 0) {
+                return {
+                    status: 'warning',
+                    message: 'No IDEs detected to check configs'
+                };
+            }
+            let existCount = 0;
+            let missingCount = 0;
+            const missing = [];
+            for (const ide of installedIDEs) {
+                const configPath = (0, ide_detector_1.expandPath)(ide.configPath);
+                if (fs_1.default.existsSync(configPath)) {
+                    existCount++;
+                }
+                else {
+                    missingCount++;
+                    missing.push(ide.name);
+                }
+            }
+            if (missingCount === 0) {
+                return {
+                    status: 'passed',
+                    message: `MCP configs exist for all ${existCount} IDE(s)`,
+                    details: { existCount }
+                };
+            }
+            if (existCount > 0) {
+                return {
+                    status: 'warning',
+                    message: `MCP configs missing for ${missingCount} IDE(s): ${missing.join(', ')}`,
+                    suggestion: 'Run fraim add-ide to configure MCP servers',
+                    command: 'fraim add-ide',
+                    details: { existCount, missingCount, missing }
+                };
+            }
+            return {
+                status: 'error',
+                message: 'No MCP configs found',
+                suggestion: 'Run fraim add-ide to configure MCP servers',
+                command: 'fraim add-ide'
+            };
+        }
+    };
+}
+/**
+ * Check if MCP configs are valid JSON/TOML
+ */
+function checkMCPConfigsValid() {
+    return {
+        name: 'MCP configs valid',
+        category: 'ideConfiguration',
+        critical: false,
+        run: async () => {
+            const installedIDEs = (0, ide_detector_1.detectInstalledIDEs)();
+            if (installedIDEs.length === 0) {
+                return {
+                    status: 'warning',
+                    message: 'No IDEs detected to validate configs'
+                };
+            }
+            let validCount = 0;
+            let invalidCount = 0;
+            const invalid = [];
+            for (const ide of installedIDEs) {
+                const configPath = (0, ide_detector_1.expandPath)(ide.configPath);
+                if (!fs_1.default.existsSync(configPath)) {
+                    continue; // Skip missing configs
+                }
+                try {
+                    if (ide.configFormat === 'json') {
+                        JSON.parse(fs_1.default.readFileSync(configPath, 'utf8'));
+                        validCount++;
+                    }
+                    else if (ide.configFormat === 'toml') {
+                        // Basic TOML validation - just check if file is readable
+                        fs_1.default.readFileSync(configPath, 'utf8');
+                        validCount++;
+                    }
+                }
+                catch (error) {
+                    invalidCount++;
+                    invalid.push(`${ide.name}: ${error.message}`);
+                }
+            }
+            if (invalidCount === 0 && validCount > 0) {
+                return {
+                    status: 'passed',
+                    message: `All ${validCount} MCP config(s) valid`,
+                    details: { validCount }
+                };
+            }
+            if (invalidCount > 0) {
+                return {
+                    status: 'error',
+                    message: `${invalidCount} invalid MCP config(s)`,
+                    suggestion: 'Fix syntax errors in MCP configuration files',
+                    details: { invalid }
+                };
+            }
+            return {
+                status: 'warning',
+                message: 'No MCP configs to validate'
+            };
+        }
+    };
+}
+/**
+ * Check if FRAIM MCP server is configured in IDEs
+ */
+function checkFraimServerConfigured() {
+    return {
+        name: 'FRAIM MCP server configured',
+        category: 'ideConfiguration',
+        critical: false,
+        run: async () => {
+            const installedIDEs = (0, ide_detector_1.detectInstalledIDEs)();
+            if (installedIDEs.length === 0) {
+                return {
+                    status: 'warning',
+                    message: 'No IDEs detected to check FRAIM server'
+                };
+            }
+            let configuredCount = 0;
+            let missingCount = 0;
+            const missing = [];
+            for (const ide of installedIDEs) {
+                const configPath = (0, ide_detector_1.expandPath)(ide.configPath);
+                if (!fs_1.default.existsSync(configPath)) {
+                    continue;
+                }
+                try {
+                    if (ide.configFormat === 'json') {
+                        const config = JSON.parse(fs_1.default.readFileSync(configPath, 'utf8'));
+                        let servers = config.mcpServers || {};
+                        if (Object.keys(servers).length === 0 && config.servers) {
+                            servers = config.servers;
+                        }
+                        if (servers['fraim']) {
+                            configuredCount++;
+                        }
+                        else {
+                            missingCount++;
+                            missing.push(ide.name);
+                        }
+                    }
+                    else if (ide.configFormat === 'toml') {
+                        const toml = require('toml');
+                        const content = fs_1.default.readFileSync(configPath, 'utf8');
+                        const config = toml.parse(content);
+                        const servers = config.mcp_servers || {};
+                        if (servers['fraim']) {
+                            configuredCount++;
+                        }
+                        else {
+                            missingCount++;
+                            missing.push(ide.name);
+                        }
+                    }
+                }
+                catch (error) {
+                    // Config validation already failed in previous check
+                }
+            }
+            if (missingCount === 0 && configuredCount > 0) {
+                return {
+                    status: 'passed',
+                    message: `FRAIM server configured in all ${configuredCount} IDE(s)`,
+                    details: { configuredCount }
+                };
+            }
+            if (missingCount > 0) {
+                return {
+                    status: 'warning',
+                    message: `FRAIM server missing in ${missingCount} IDE(s): ${missing.join(', ')}`,
+                    suggestion: 'Run fraim add-ide to configure FRAIM server',
+                    command: 'fraim add-ide',
+                    details: { missing, configuredCount, missingCount }
+                };
+            }
+            return {
+                status: 'passed',
+                message: 'No IDEs with MCP configs to check'
+            };
+        }
+    };
+}
+/**
+ * Get all IDE configuration checks
+ */
+function getIDEConfigChecks() {
+    return [
+        checkIDEsDetected(),
+        checkMCPConfigsExist(),
+        checkMCPConfigsValid(),
+        checkFraimServerConfigured()
+    ];
+}