fraim-framework 2.0.82 → 2.0.83

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 });

package/dist/src/cli/providers/local-provider-registry.js

@@ -0,0 +1,145 @@
+"use strict";
+// Local provider registry - fallback when server is unavailable
+// This is the original provider metadata that was in provider-registry.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLocalProvider = getLocalProvider;
+exports.getAllLocalProviders = getAllLocalProviders;
+exports.getAllLocalProviderIds = getAllLocalProviderIds;
+exports.isValidLocalProviderId = isValidLocalProviderId;
+exports.getLocalProviderDisplayName = getLocalProviderDisplayName;
+exports.getLocalProviderSetupInstructions = getLocalProviderSetupInstructions;
+exports.getLocalProviderConfigRequirements = getLocalProviderConfigRequirements;
+exports.localRequiresAdditionalConfig = localRequiresAdditionalConfig;
+exports.validateLocalProviderConfig = validateLocalProviderConfig;
+exports.getLocalProvidersWithCapability = getLocalProvidersWithCapability;
+exports.getLocalProviderIdsWithCapability = getLocalProviderIdsWithCapability;
+exports.localProviderHasCapability = localProviderHasCapability;
+// Local provider definitions (fallback data)
+const LOCAL_PROVIDERS = [
+    {
+        id: 'github',
+        displayName: 'GitHub',
+        description: 'GitHub repository and issue management',
+        capabilities: ['code', 'issues', 'integrated'],
+        docsUrl: 'https://docs.github.com',
+        setupInstructions: 'Create a Personal Access Token at https://github.com/settings/tokens',
+        hasAdditionalConfig: false,
+        mcpServer: {
+            type: 'http',
+            url: 'https://api.githubcopilot.com/mcp/',
+            authHeaderTemplate: 'Bearer {token}'
+        }
+    },
+    {
+        id: 'gitlab',
+        displayName: 'GitLab',
+        description: 'GitLab repository and issue management',
+        capabilities: ['code', 'issues', 'integrated'],
+        docsUrl: 'https://docs.gitlab.com',
+        setupInstructions: 'Create a Personal Access Token in your GitLab settings',
+        hasAdditionalConfig: false,
+        mcpServer: {
+            type: 'http',
+            url: 'https://gitlab.com/api/v4/mcp',
+            authHeaderTemplate: 'Bearer {token}'
+        }
+    },
+    {
+        id: 'ado',
+        displayName: 'Azure DevOps',
+        description: 'Azure DevOps repository and issue management',
+        capabilities: ['code', 'issues', 'integrated'],
+        docsUrl: 'https://docs.microsoft.com/azure/devops',
+        setupInstructions: 'Create a Personal Access Token in Azure DevOps',
+        hasAdditionalConfig: false
+    },
+    {
+        id: 'jira',
+        displayName: 'Jira',
+        description: 'Jira issue tracking and project management',
+        capabilities: ['issues'],
+        docsUrl: 'https://support.atlassian.com/jira',
+        setupInstructions: 'Create an API token at https://id.atlassian.com/manage-profile/security/api-tokens',
+        hasAdditionalConfig: true,
+        mcpServer: {
+            type: 'stdio',
+            command: 'uvx',
+            args: ['mcp-atlassian'],
+            envTemplate: {
+                JIRA_URL: '{config.baseUrl}',
+                JIRA_USERNAME: '{config.email}',
+                JIRA_API_TOKEN: '{token}'
+            }
+        }
+    }
+];
+const JIRA_CONFIG_REQUIREMENTS = [
+    {
+        key: 'baseUrl',
+        displayName: 'Jira Instance URL',
+        description: 'Your Jira instance URL (e.g., mycompany.atlassian.net)',
+        required: true,
+        type: 'url',
+        cliOptionName: 'url'
+    },
+    {
+        key: 'email',
+        displayName: 'Email Address',
+        description: 'Your Jira account email address',
+        required: true,
+        type: 'email'
+    }
+];
+function getLocalProvider(id) {
+    return LOCAL_PROVIDERS.find(p => p.id === id);
+}
+function getAllLocalProviders() {
+    return [...LOCAL_PROVIDERS];
+}
+function getAllLocalProviderIds() {
+    return LOCAL_PROVIDERS.map(p => p.id);
+}
+function isValidLocalProviderId(id) {
+    return LOCAL_PROVIDERS.some(p => p.id === id);
+}
+function getLocalProviderDisplayName(providerId) {
+    const provider = getLocalProvider(providerId);
+    return provider?.displayName || providerId;
+}
+function getLocalProviderSetupInstructions(providerId) {
+    const provider = getLocalProvider(providerId);
+    return provider?.setupInstructions || '';
+}
+function getLocalProviderConfigRequirements(providerId) {
+    if (providerId === 'jira') {
+        return JIRA_CONFIG_REQUIREMENTS;
+    }
+    return [];
+}
+function localRequiresAdditionalConfig(providerId) {
+    return getLocalProviderConfigRequirements(providerId).length > 0;
+}
+function validateLocalProviderConfig(providerId, config) {
+    const requirements = getLocalProviderConfigRequirements(providerId);
+    const missing = [];
+    for (const req of requirements) {
+        if (req.required && !config[req.key]) {
+            missing.push(req.key);
+        }
+    }
+    return {
+        valid: missing.length === 0,
+        missing
+    };
+}
+function getLocalProvidersWithCapability(capability) {
+    return LOCAL_PROVIDERS.filter(provider => provider.capabilities.includes(capability));
+}
+function getLocalProviderIdsWithCapability(capability) {
+    const providers = getLocalProvidersWithCapability(capability);
+    return providers.map(p => p.id);
+}
+function localProviderHasCapability(providerId, capability) {
+    const provider = getLocalProvider(providerId);
+    return provider ? provider.capabilities.includes(capability) : false;
+}