fraim-framework 2.0.81 → 2.0.83

package/dist/src/cli/doctor/reporters/console-reporter.js

@@ -0,0 +1,96 @@
+"use strict";
+/**
+ * Console reporter for FRAIM doctor command
+ * Formats output with colors and emojis
+ * 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.formatConsoleOutput = formatConsoleOutput;
+const chalk_1 = __importDefault(require("chalk"));
+const CATEGORY_NAMES = {
+    globalSetup: 'Global Setup',
+    projectSetup: 'Project Setup',
+    workflows: 'Workflows',
+    ideConfiguration: 'IDE Configuration',
+    mcpConnectivity: 'MCP Server Connectivity',
+    scripts: 'Scripts'
+};
+function getStatusIcon(status) {
+    switch (status) {
+        case 'passed': return '✅';
+        case 'warning': return '⚠️';
+        case 'error': return '❌';
+    }
+}
+function formatLatency(latency) {
+    if (!latency)
+        return '';
+    return chalk_1.default.gray(` (${latency}ms)`);
+}
+function formatConsoleOutput(result, options) {
+    const lines = [];
+    // Header
+    lines.push(chalk_1.default.blue('🩺 FRAIM Doctor - Comprehensive Health Check\n'));
+    // Categories
+    for (const [categoryKey, categoryResult] of Object.entries(result.categories)) {
+        // Skip empty categories
+        if (categoryResult.checks.length === 0)
+            continue;
+        const categoryName = CATEGORY_NAMES[categoryKey] || categoryKey;
+        lines.push(chalk_1.default.bold(`━━━ ${categoryName} ━━━`));
+        for (const check of categoryResult.checks) {
+            const icon = getStatusIcon(check.status);
+            const latency = formatLatency(check.latency);
+            lines.push(`${icon} ${check.message}${latency}`);
+            // Show details in verbose mode
+            if (options.verbose && check.details) {
+                for (const [key, value] of Object.entries(check.details)) {
+                    lines.push(chalk_1.default.gray(`   ${key}: ${value}`));
+                }
+            }
+            // Show suggestions for warnings and errors
+            if (check.suggestion) {
+                lines.push(chalk_1.default.blue(`   💡 ${check.suggestion}`));
+                if (check.command) {
+                    lines.push(chalk_1.default.gray(`      Run: ${check.command}`));
+                }
+            }
+        }
+        lines.push(''); // Empty line between categories
+    }
+    // Summary
+    lines.push(chalk_1.default.bold('━━━ Summary ━━━'));
+    lines.push(`${chalk_1.default.green('✅')} ${result.summary.passed} checks passed`);
+    if (result.summary.warnings > 0) {
+        lines.push(`${chalk_1.default.yellow('⚠️')} ${result.summary.warnings} warnings`);
+    }
+    if (result.summary.errors > 0) {
+        lines.push(`${chalk_1.default.red('❌')} ${result.summary.errors} errors`);
+    }
+    lines.push('');
+    // Final message
+    if (result.summary.errors === 0 && result.summary.warnings === 0) {
+        lines.push(chalk_1.default.green('✨ Everything looks great! Your FRAIM setup is healthy.'));
+    }
+    else if (result.summary.errors === 0) {
+        lines.push(chalk_1.default.yellow('⚠️ Some warnings found. See suggestions below.'));
+    }
+    else {
+        lines.push(chalk_1.default.red('❌ Issues found. See suggestions below.'));
+    }
+    // Suggestions
+    if (result.suggestions && result.suggestions.length > 0) {
+        lines.push('');
+        lines.push(chalk_1.default.blue('💡 Suggested fixes:'));
+        for (const suggestion of result.suggestions.slice(0, 5)) { // Show top 5
+            lines.push(chalk_1.default.blue(`   ${suggestion.priority}. ${suggestion.message}`));
+            if (suggestion.command) {
+                lines.push(chalk_1.default.gray(`      Run: ${suggestion.command}`));
+            }
+        }
+    }
+    return lines.join('\n');
+}

package/dist/src/cli/doctor/reporters/json-reporter.js

@@ -0,0 +1,11 @@
+"use strict";
+/**
+ * JSON reporter for FRAIM doctor command
+ * Formats output as JSON for automation
+ * Issue #144: Enhanced doctor command
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatJsonOutput = formatJsonOutput;
+function formatJsonOutput(result) {
+    return JSON.stringify(result, null, 2);
+}

package/dist/src/cli/doctor/types.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Type definitions for the FRAIM doctor command
+ * Issue #144: Enhanced doctor command
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/cli/fraim.js

@@ -1,5 +1,38 @@
 #!/usr/bin/env node
 "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 };
 };
@@ -12,9 +45,9 @@ const setup_1 = require("./commands/setup");
 const init_project_1 = require("./commands/init-project");
 const test_mcp_1 = require("./commands/test-mcp");
 const add_ide_1 = require("./commands/add-ide");
+const add_provider_1 = require("./commands/add-provider");
 const override_1 = require("./commands/override");
 const list_overridable_1 = require("./commands/list-overridable");
-const install_1 = require("./commands/install");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const program = new commander_1.Command();
@@ -49,7 +82,15 @@ program.addCommand(setup_1.setupCommand);
 program.addCommand(init_project_1.initProjectCommand);
 program.addCommand(test_mcp_1.testMCPCommand);
 program.addCommand(add_ide_1.addIDECommand);
+program.addCommand(add_provider_1.addProviderCommand);
 program.addCommand(override_1.overrideCommand);
 program.addCommand(list_overridable_1.listOverridableCommand);
-program.addCommand(install_1.installCommand);
-program.parse(process.argv);
+// Wait for async command initialization before parsing
+(async () => {
+    // Import the initialization promise from setup command
+    const { setupCommandInitialization } = await Promise.resolve().then(() => __importStar(require('./commands/setup')));
+    if (setupCommandInitialization) {
+        await setupCommandInitialization;
+    }
+    program.parse(process.argv);
+})();

package/dist/src/cli/mcp/ide-formats.js

@@ -0,0 +1,243 @@
+"use strict";
+// IDE Format Adapters - transform logical server structure to IDE-specific formats
+// Uses the centralized registry to determine server types
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IDE_FORMATS = exports.CodexFormat = exports.WindsurfFormat = exports.ClaudeCodeFormat = exports.ClaudeFormat = exports.VSCodeFormat = exports.KiroFormat = exports.StandardFormat = void 0;
+exports.getIDEFormat = getIDEFormat;
+const mcp_server_registry_1 = require("./mcp-server-registry");
+const provider_registry_1 = require("../providers/provider-registry");
+// Standard format (Cursor, Kiro, Antigravity, etc.)
+class StandardFormat {
+    constructor() {
+        this.name = 'standard';
+    }
+    transform(servers) {
+        const mcpServers = {};
+        for (const [key, server] of servers) {
+            if (server.url) {
+                // HTTP server - use serverUrl for standard format
+                mcpServers[key] = {
+                    serverUrl: server.url,
+                    headers: server.headers
+                };
+            }
+            else {
+                // stdio server
+                mcpServers[key] = {
+                    command: server.command,
+                    ...(server.args && { args: server.args }),
+                    ...(server.env && { env: server.env })
+                };
+            }
+        }
+        return { mcpServers };
+    }
+}
+exports.StandardFormat = StandardFormat;
+// Kiro format (also used by Cursor)
+class KiroFormat {
+    constructor() {
+        this.name = 'kiro';
+    }
+    transform(servers) {
+        const mcpServers = {};
+        for (const [key, server] of servers) {
+            if (server.url) {
+                // HTTP server - use url (not serverUrl)
+                mcpServers[key] = {
+                    url: server.url,
+                    headers: server.headers
+                };
+            }
+            else {
+                // stdio server
+                mcpServers[key] = {
+                    command: server.command,
+                    ...(server.args && { args: server.args }),
+                    ...(server.env && { env: server.env })
+                };
+            }
+        }
+        return { mcpServers };
+    }
+}
+exports.KiroFormat = KiroFormat;
+// VSCode format
+class VSCodeFormat {
+    constructor() {
+        this.name = 'vscode';
+    }
+    transform(servers) {
+        const vscodeServers = {};
+        for (const [key, server] of servers) {
+            if (server.url) {
+                // HTTP server
+                vscodeServers[key] = {
+                    type: 'http',
+                    url: server.url,
+                    headers: server.headers
+                };
+            }
+            else {
+                // stdio server
+                vscodeServers[key] = {
+                    type: 'stdio',
+                    command: server.command,
+                    ...(server.args && { args: server.args }),
+                    ...(server.env && { env: server.env })
+                };
+            }
+        }
+        return { servers: vscodeServers };
+    }
+}
+exports.VSCodeFormat = VSCodeFormat;
+// Claude Desktop format (excludes provider servers - Issue #132)
+class ClaudeFormat {
+    constructor() {
+        this.name = 'claude';
+    }
+    async transform(servers) {
+        const mcpServers = {};
+        for (const [key, server] of servers) {
+            // Skip all provider servers - they break Claude Desktop
+            // See: https://github.com/mathursrus/FRAIM/issues/132
+            if (await (0, mcp_server_registry_1.isProviderServer)(key)) {
+                continue;
+            }
+            // Only include base servers (git, playwright, fraim)
+            mcpServers[key] = {
+                command: server.command,
+                ...(server.args && { args: server.args }),
+                ...(server.env && { env: server.env })
+            };
+        }
+        return { mcpServers };
+    }
+}
+exports.ClaudeFormat = ClaudeFormat;
+// Claude Code format (supports HTTP servers with VSCode-style format)
+class ClaudeCodeFormat {
+    constructor() {
+        this.name = 'claude-code';
+    }
+    transform(servers) {
+        const mcpServers = {};
+        for (const [key, server] of servers) {
+            if (server.url) {
+                // HTTP server - use VSCode-style format
+                mcpServers[key] = {
+                    type: 'http',
+                    url: server.url,
+                    headers: server.headers
+                };
+            }
+            else {
+                // stdio server
+                mcpServers[key] = {
+                    command: server.command,
+                    ...(server.args && { args: server.args }),
+                    ...(server.env && { env: server.env })
+                };
+            }
+        }
+        return { mcpServers };
+    }
+}
+exports.ClaudeCodeFormat = ClaudeCodeFormat;
+// Windsurf format (uses server-fetch wrapper for HTTP servers)
+class WindsurfFormat {
+    constructor() {
+        this.name = 'windsurf';
+    }
+    async transform(servers) {
+        const mcpServers = {};
+        for (const [key, server] of servers) {
+            if (server.url) {
+                // HTTP server - wrap with server-fetch
+                const provider = await (0, provider_registry_1.getProvider)(key);
+                const tokenEnvVar = provider?.id ? `${provider.id.toUpperCase()}_TOKEN` : undefined;
+                if (tokenEnvVar && server.headers?.Authorization) {
+                    const token = server.headers.Authorization.replace('Bearer ', '');
+                    mcpServers[key] = {
+                        command: 'npx',
+                        args: ['-y', '@modelcontextprotocol/server-fetch', server.url],
+                        env: {
+                            [tokenEnvVar]: token
+                        }
+                    };
+                }
+            }
+            else {
+                // stdio server
+                mcpServers[key] = {
+                    command: server.command,
+                    ...(server.args && { args: server.args }),
+                    ...(server.env && { env: server.env })
+                };
+            }
+        }
+        return { mcpServers };
+    }
+}
+exports.WindsurfFormat = WindsurfFormat;
+// Codex format (TOML)
+class CodexFormat {
+    constructor() {
+        this.name = 'codex';
+    }
+    transform(servers) {
+        const sections = [];
+        for (const [key, server] of servers) {
+            if (server.url) {
+                // HTTP server
+                const token = server.headers?.Authorization?.replace('Bearer ', '') || '';
+                const escapedToken = this.escapeToml(token);
+                const escapedUrl = this.escapeToml(server.url);
+                sections.push(`[mcp_servers.${key}]`);
+                sections.push(`url = "${escapedUrl}"`);
+                sections.push(`http_headers = { Authorization = "Bearer ${escapedToken}" }`);
+                sections.push('');
+            }
+            else {
+                // stdio server
+                sections.push(`[mcp_servers.${key}]`);
+                sections.push(`command = "${this.escapeToml(server.command || '')}"`);
+                if (server.args && server.args.length > 0) {
+                    const argsStr = server.args.map(arg => `"${this.escapeToml(arg)}"`).join(', ');
+                    sections.push(`args = [${argsStr}]`);
+                }
+                if (server.env) {
+                    sections.push('');
+                    sections.push(`[mcp_servers.${key}.env]`);
+                    for (const [envKey, envValue] of Object.entries(server.env)) {
+                        sections.push(`${envKey} = "${this.escapeToml(envValue)}"`);
+                    }
+                }
+                sections.push('');
+            }
+        }
+        return sections.join('\n');
+    }
+    escapeToml(value) {
+        return value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+    }
+}
+exports.CodexFormat = CodexFormat;
+// Format registry
+exports.IDE_FORMATS = {
+    standard: new StandardFormat(),
+    kiro: new KiroFormat(),
+    vscode: new VSCodeFormat(),
+    claude: new ClaudeFormat(),
+    'claude-code': new ClaudeCodeFormat(),
+    windsurf: new WindsurfFormat(),
+    codex: new CodexFormat()
+};
+function getIDEFormat(configType) {
+    const format = exports.IDE_FORMATS[configType];
+    if (!format) {
+        throw new Error(`Unsupported IDE format: ${configType}`);
+    }
+    return format;
+}

package/dist/src/cli/mcp/mcp-server-builder.js

@@ -0,0 +1,48 @@
+"use strict";
+// MCP Server Builder - builds logical server structure (format-agnostic)
+// Uses the centralized registry for all server definitions
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCPServerBuilder = void 0;
+const mcp_server_registry_1 = require("./mcp-server-registry");
+class MCPServerBuilder {
+    constructor() {
+        this.servers = new Map();
+    }
+    addBaseServers(fraimKey) {
+        const baseServers = (0, mcp_server_registry_1.buildAllBaseServers)(fraimKey);
+        for (const [id, server] of baseServers) {
+            this.servers.set(id, server);
+        }
+        return this;
+    }
+    async addProvider(providerId, token, config) {
+        try {
+            const server = await (0, mcp_server_registry_1.buildProviderMCPServer)(providerId, token, config);
+            this.servers.set(providerId, server);
+        }
+        catch (error) {
+            // Always warn user when MCP server can't be built
+            // Common case: Jira without baseUrl/email config
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.warn(`⚠️  Skipping ${providerId} MCP server: ${errorMessage}`);
+        }
+        return this;
+    }
+    // Legacy methods for backward compatibility - delegate to addProvider
+    async addGitHub(token) {
+        return await this.addProvider('github', token);
+    }
+    async addGitLab(token) {
+        return await this.addProvider('gitlab', token);
+    }
+    async addJira(token, config) {
+        return await this.addProvider('jira', token, config);
+    }
+    getServers() {
+        return new Map(this.servers);
+    }
+    toObject() {
+        return Object.fromEntries(this.servers);
+    }
+}
+exports.MCPServerBuilder = MCPServerBuilder;

package/dist/src/cli/mcp/mcp-server-registry.js

@@ -0,0 +1,159 @@
+"use strict";
+// MCP Server Registry - Builds MCP servers from provider definitions
+// This file NO LONGER contains hardcoded server configurations
+// All provider MCP server configs come from the provider registry (server or local fallback)
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BASE_MCP_SERVERS = void 0;
+exports.buildProviderMCPServer = buildProviderMCPServer;
+exports.getBaseMCPServer = getBaseMCPServer;
+exports.getProviderMCPServerIds = getProviderMCPServerIds;
+exports.getAllMCPServerIds = getAllMCPServerIds;
+exports.isProviderServer = isProviderServer;
+exports.isHTTPServer = isHTTPServer;
+exports.buildAllBaseServers = buildAllBaseServers;
+const provider_registry_1 = require("../providers/provider-registry");
+exports.BASE_MCP_SERVERS = [
+    {
+        id: 'git',
+        name: 'Git',
+        description: 'Git repository operations (commit, branch, merge, etc.)',
+        buildServer: () => ({
+            command: 'npx',
+            args: ['-y', '@cyanheads/git-mcp-server']
+        })
+    },
+    {
+        id: 'playwright',
+        name: 'Playwright',
+        description: 'Browser automation and testing',
+        buildServer: () => ({
+            command: 'npx',
+            args: ['-y', '@playwright/mcp']
+        })
+    },
+    {
+        id: 'fraim',
+        name: 'FRAIM',
+        description: 'FRAIM workflow orchestration and mentoring',
+        buildServer: (fraimKey) => ({
+            command: 'fraim-mcp',
+            env: {
+                FRAIM_API_KEY: fraimKey,
+                FRAIM_REMOTE_URL: 'https://fraim.wellnessatwork.me'
+            }
+        })
+    }
+];
+// ============================================================================
+// PROVIDER MCP SERVER BUILDER (uses provider registry)
+// ============================================================================
+/**
+ * Build an MCP server for a provider using its definition from the registry
+ */
+async function buildProviderMCPServer(providerId, token, config) {
+    // Get provider definition from registry (server or local fallback)
+    const provider = await (0, provider_registry_1.getProvider)(providerId);
+    if (!provider) {
+        throw new Error(`Unknown provider: ${providerId}`);
+    }
+    if (!provider.mcpServer) {
+        throw new Error(`Provider ${providerId} does not have an MCP server configuration`);
+    }
+    const mcpConfig = provider.mcpServer;
+    // Validate config if provider requires additional config
+    if (provider.hasAdditionalConfig) {
+        const validation = await (0, provider_registry_1.validateProviderConfig)(providerId, config || {});
+        if (!validation.valid) {
+            throw new Error(`${provider.displayName} requires additional configuration: ${validation.missing.join(', ')}`);
+        }
+    }
+    // Build MCP server based on type
+    if (mcpConfig.type === 'http') {
+        return buildHTTPServer(mcpConfig, token);
+    }
+    else {
+        return buildStdioServer(mcpConfig, token, config);
+    }
+}
+/**
+ * Build an HTTP MCP server
+ */
+function buildHTTPServer(mcpConfig, token) {
+    if (!mcpConfig.url) {
+        throw new Error('HTTP MCP server requires url');
+    }
+    const authHeader = mcpConfig.authHeaderTemplate?.replace('{token}', token) || `Bearer ${token}`;
+    return {
+        url: mcpConfig.url,
+        headers: {
+            Authorization: authHeader
+        }
+    };
+}
+/**
+ * Build a stdio MCP server
+ */
+function buildStdioServer(mcpConfig, token, config) {
+    if (!mcpConfig.command) {
+        throw new Error('Stdio MCP server requires command');
+    }
+    // Build environment variables from template
+    const env = {};
+    if (mcpConfig.envTemplate) {
+        for (const [key, template] of Object.entries(mcpConfig.envTemplate)) {
+            let value = template;
+            // Replace {token} placeholder
+            value = value.replace('{token}', token);
+            // Replace {config.key} placeholders
+            if (config) {
+                for (const [configKey, configValue] of Object.entries(config)) {
+                    value = value.replace(`{config.${configKey}}`, String(configValue));
+                }
+            }
+            // Handle URL normalization for Jira
+            if (key === 'JIRA_URL' && value && !value.startsWith('http')) {
+                value = `https://${value}`;
+            }
+            env[key] = value;
+        }
+    }
+    return {
+        command: mcpConfig.command,
+        args: mcpConfig.args || [],
+        env
+    };
+}
+// ============================================================================
+// REGISTRY LOOKUP FUNCTIONS
+// ============================================================================
+function getBaseMCPServer(id) {
+    return exports.BASE_MCP_SERVERS.find(server => server.id === id);
+}
+async function getProviderMCPServerIds() {
+    // This would need to fetch all providers and filter those with MCP servers
+    // For now, return empty array - this function is not critical
+    return [];
+}
+function getAllMCPServerIds() {
+    // Return only base server IDs
+    // Provider server IDs are dynamic and come from the registry
+    return exports.BASE_MCP_SERVERS.map(s => s.id);
+}
+async function isProviderServer(serverId) {
+    const provider = await (0, provider_registry_1.getProvider)(serverId);
+    return provider !== undefined && provider.mcpServer !== undefined;
+}
+async function isHTTPServer(serverId) {
+    const provider = await (0, provider_registry_1.getProvider)(serverId);
+    return provider?.mcpServer?.type === 'http';
+}
+// ============================================================================
+// BUILDER HELPERS
+// ============================================================================
+function buildAllBaseServers(fraimKey) {
+    const servers = new Map();
+    for (const def of exports.BASE_MCP_SERVERS) {
+        servers.set(def.id, def.buildServer(fraimKey));
+    }
+    return servers;
+}

package/dist/src/cli/mcp/types.js

@@ -0,0 +1,3 @@
+"use strict";
+// Shared types for MCP configuration
+Object.defineProperty(exports, "__esModule", { value: true });