fraim 2.0.100

package/dist/src/cli/setup/ide-detector.js

@@ -0,0 +1,179 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expandPath = exports.findIDEByName = exports.getAllSupportedIDEs = exports.detectInstalledIDEs = exports.IDE_CONFIGS = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const expandPath = (filePath) => {
+    if (filePath.startsWith('~/')) {
+        return path_1.default.join(os_1.default.homedir(), filePath.slice(2));
+    }
+    return filePath;
+};
+exports.expandPath = expandPath;
+const checkMultiplePaths = (paths) => {
+    return paths.some(p => fs_1.default.existsSync(expandPath(p)));
+};
+const detectClaude = () => {
+    const paths = [
+        '~/.claude.json',
+        '~/.claude',
+        '~/Library/Application Support/Cloud',
+        '~/Library/Application Support/Claude',
+        '~/AppData/Roaming/Claude'
+    ];
+    return checkMultiplePaths(paths);
+};
+const detectVSCode = () => {
+    const paths = [
+        '~/.vscode',
+        '~/Library/Application Support/Code',
+        '~/AppData/Roaming/Code',
+        '~/.config/Code'
+    ];
+    return checkMultiplePaths(paths);
+};
+const detectCursor = () => {
+    const paths = [
+        '~/.cursor',
+        '~/Library/Application Support/Cursor',
+        '~/AppData/Roaming/Cursor',
+        '~/.config/Cursor'
+    ];
+    return checkMultiplePaths(paths);
+};
+const detectWindsurf = () => {
+    const paths = [
+        '~/.codeium/windsurf',
+        '~/Library/Application Support/Windsurf',
+        '~/AppData/Roaming/Windsurf',
+        '~/.config/windsurf'
+    ];
+    return checkMultiplePaths(paths);
+};
+exports.IDE_CONFIGS = [
+    {
+        name: 'Claude Code',
+        configPath: '~/.claude.json',
+        configFormat: 'json',
+        configType: 'claude-code',
+        detectMethod: detectClaude,
+        alternativePaths: [
+            '~/.claude/settings.json'
+        ],
+        description: 'Anthropic Claude Code CLI tool'
+    },
+    {
+        name: 'Claude Desktop / Cowork',
+        configPath: '~/AppData/Roaming/Claude/claude_desktop_config.json',
+        configFormat: 'json',
+        configType: 'claude',
+        detectMethod: detectClaude,
+        alternativePaths: [
+            '~/Library/Application Support/Claude/claude_desktop_config.json'
+        ],
+        description: 'Anthropic Claude Desktop and Cowork application'
+    },
+    {
+        name: 'Antigravity',
+        configPath: '~/.gemini/antigravity/mcp_config.json',
+        configFormat: 'json',
+        configType: 'standard',
+        detectMethod: () => fs_1.default.existsSync(expandPath('~/.gemini/antigravity')),
+        description: 'Google Gemini Antigravity IDE'
+    },
+    {
+        name: 'Kiro',
+        configPath: '~/.kiro/settings/mcp.json',
+        configFormat: 'json',
+        configType: 'kiro',
+        detectMethod: () => fs_1.default.existsSync(expandPath('~/.kiro')),
+        description: 'Kiro AI-powered IDE'
+    },
+    {
+        name: 'Cursor',
+        configPath: '~/.cursor/mcp.json',
+        configFormat: 'json',
+        configType: 'kiro',
+        detectMethod: detectCursor,
+        alternativePaths: [
+            '~/Library/Application Support/Cursor/mcp.json',
+            '~/AppData/Roaming/Cursor/mcp.json',
+            '~/.config/Cursor/mcp.json'
+        ],
+        description: 'Cursor AI code editor'
+    },
+    {
+        name: 'VSCode',
+        configPath: process.platform === 'win32'
+            ? '~/AppData/Roaming/Code/User/mcp.json'
+            : process.platform === 'darwin'
+                ? '~/Library/Application Support/Code/User/mcp.json'
+                : '~/.config/Code/User/mcp.json',
+        configFormat: 'json',
+        configType: 'vscode',
+        detectMethod: detectVSCode,
+        alternativePaths: [
+            '~/Library/Application Support/Code/User/mcp.json',
+            '~/AppData/Roaming/Code/User/mcp.json',
+            '~/.config/Code/User/mcp.json'
+        ],
+        description: 'Visual Studio Code'
+    },
+    {
+        name: 'Codex',
+        configPath: '~/.codex/config.toml',
+        configFormat: 'toml',
+        configType: 'codex',
+        detectMethod: () => fs_1.default.existsSync(expandPath('~/.codex')),
+        description: 'Codex AI development environment'
+    },
+    {
+        name: 'Windsurf',
+        configPath: '~/.codeium/windsurf/mcp_config.json',
+        configFormat: 'json',
+        configType: 'windsurf',
+        detectMethod: detectWindsurf,
+        alternativePaths: [
+            '~/Library/Application Support/Windsurf/mcp_config.json',
+            '~/AppData/Roaming/Windsurf/mcp_config.json',
+            '~/.config/windsurf/mcp_config.json'
+        ],
+        description: 'Codeium Windsurf IDE'
+    }
+];
+const findBestConfigPath = (ide) => {
+    // First try the default path
+    if (fs_1.default.existsSync(expandPath(ide.configPath))) {
+        return ide.configPath;
+    }
+    // Then try alternative paths
+    if (ide.alternativePaths) {
+        for (const altPath of ide.alternativePaths) {
+            if (fs_1.default.existsSync(expandPath(altPath))) {
+                return altPath;
+            }
+        }
+    }
+    // Return default path if nothing found (will be created)
+    return ide.configPath;
+};
+const detectInstalledIDEs = () => {
+    return exports.IDE_CONFIGS.filter(ide => ide.detectMethod()).map(ide => ({
+        ...ide,
+        configPath: findBestConfigPath(ide)
+    }));
+};
+exports.detectInstalledIDEs = detectInstalledIDEs;
+const getAllSupportedIDEs = () => {
+    return exports.IDE_CONFIGS;
+};
+exports.getAllSupportedIDEs = getAllSupportedIDEs;
+const findIDEByName = (name) => {
+    return exports.IDE_CONFIGS.find(ide => ide.name.toLowerCase().includes(name.toLowerCase()) ||
+        name.toLowerCase().includes(ide.name.toLowerCase()));
+};
+exports.findIDEByName = findIDEByName;

package/dist/src/cli/setup/mcp-config-generator.js

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateMCPConfig = exports.generateWindsurfMCPServers = exports.generateVSCodeMCPServers = exports.generateCodexMCPServers = exports.generateKiroMCPServers = exports.generateClaudeCodeMCPServers = exports.generateClaudeMCPServers = exports.generateStandardMCPServers = exports.mergeTomlMCPServers = exports.extractTomlMcpServerBlock = void 0;
+const mcp_server_builder_1 = require("../mcp/mcp-server-builder");
+const ide_formats_1 = require("../mcp/ide-formats");
+const normalizeTokens = (tokenInput) => {
+    if (!tokenInput)
+        return {};
+    if (typeof tokenInput === 'string') {
+        return tokenInput ? { github: tokenInput } : {};
+    }
+    return tokenInput;
+};
+const findTomlServerBlockRange = (content, server) => {
+    const lines = content.split(/\r?\n/);
+    const serverSection = `mcp_servers.${server}`;
+    const serverHeader = `[${serverSection}]`;
+    const start = lines.findIndex(line => line.trim() === serverHeader);
+    if (start === -1) {
+        return null;
+    }
+    let end = lines.length;
+    for (let i = start + 1; i < lines.length; i++) {
+        const sectionMatch = lines[i].trim().match(/^\[([^\]]+)\]$/);
+        if (!sectionMatch)
+            continue;
+        const sectionName = sectionMatch[1];
+        if (sectionName === serverSection || sectionName.startsWith(`${serverSection}.`)) {
+            continue;
+        }
+        end = i;
+        break;
+    }
+    return { start, end };
+};
+const extractTomlMcpServerBlock = (content, server) => {
+    const range = findTomlServerBlockRange(content, server);
+    if (!range)
+        return null;
+    const lines = content.split(/\r?\n/);
+    return lines.slice(range.start, range.end).join('\n').trim();
+};
+exports.extractTomlMcpServerBlock = extractTomlMcpServerBlock;
+const removeTomlMcpServerBlock = (content, server) => {
+    const range = findTomlServerBlockRange(content, server);
+    if (!range)
+        return content;
+    const lines = content.split(/\r?\n/);
+    const updated = [...lines.slice(0, range.start), ...lines.slice(range.end)].join('\n');
+    return updated.replace(/\n{3,}/g, '\n\n').trimEnd();
+};
+const appendTomlBlock = (content, block) => {
+    const trimmedContent = content.trimEnd();
+    const trimmedBlock = block.trim();
+    if (!trimmedBlock)
+        return trimmedContent;
+    if (!trimmedContent)
+        return `${trimmedBlock}\n`;
+    return `${trimmedContent}\n\n${trimmedBlock}\n`;
+};
+const mergeTomlMCPServers = (existingContent, generatedContent, servers) => {
+    let merged = existingContent || '';
+    const addedServers = [];
+    const replacedServers = [];
+    const skippedServers = [];
+    for (const server of servers) {
+        const newBlock = (0, exports.extractTomlMcpServerBlock)(generatedContent, server);
+        if (!newBlock) {
+            skippedServers.push(server);
+            continue;
+        }
+        const existingBlock = (0, exports.extractTomlMcpServerBlock)(merged, server);
+        if (existingBlock && existingBlock.trim() === newBlock.trim()) {
+            skippedServers.push(server);
+            continue;
+        }
+        if (existingBlock) {
+            merged = removeTomlMcpServerBlock(merged, server);
+            merged = appendTomlBlock(merged, newBlock);
+            replacedServers.push(server);
+            continue;
+        }
+        merged = appendTomlBlock(merged, newBlock);
+        addedServers.push(server);
+    }
+    return {
+        content: merged.trimEnd() + '\n',
+        addedServers,
+        replacedServers,
+        skippedServers
+    };
+};
+exports.mergeTomlMCPServers = mergeTomlMCPServers;
+// Helper function to add all provider servers with their configs
+const addProviderServers = async (builder, tokens, providerConfigs) => {
+    for (const [providerId, token] of Object.entries(tokens)) {
+        if (token) {
+            // Get provider-specific config if it exists
+            const config = providerConfigs?.[providerId];
+            await builder.addProvider(providerId, token, config);
+        }
+    }
+};
+const generateStandardMCPServers = async (fraimKey, tokenInput, providerConfigs) => {
+    const tokens = normalizeTokens(tokenInput);
+    const builder = new mcp_server_builder_1.MCPServerBuilder();
+    builder.addBaseServers(fraimKey);
+    // Dynamically add provider servers based on available tokens
+    await addProviderServers(builder, tokens, providerConfigs);
+    const format = (0, ide_formats_1.getIDEFormat)('standard');
+    return format.transform(builder.getServers());
+};
+exports.generateStandardMCPServers = generateStandardMCPServers;
+const generateClaudeMCPServers = async (fraimKey, tokenInput, providerConfigs) => {
+    const tokens = normalizeTokens(tokenInput);
+    const builder = new mcp_server_builder_1.MCPServerBuilder();
+    builder.addBaseServers(fraimKey);
+    // Claude Desktop does not support HTTPS MCP servers (GitHub, GitLab, Jira)
+    // These cause Claude Desktop to break on boot
+    // See: https://github.com/mathursrus/FRAIM/issues/132
+    // The ClaudeFormat adapter will filter out HTTP servers
+    await addProviderServers(builder, tokens, providerConfigs);
+    const format = (0, ide_formats_1.getIDEFormat)('claude');
+    return format.transform(builder.getServers());
+};
+exports.generateClaudeMCPServers = generateClaudeMCPServers;
+const generateClaudeCodeMCPServers = async (fraimKey, tokenInput, providerConfigs) => {
+    const tokens = normalizeTokens(tokenInput);
+    const builder = new mcp_server_builder_1.MCPServerBuilder();
+    builder.addBaseServers(fraimKey);
+    await addProviderServers(builder, tokens, providerConfigs);
+    const format = (0, ide_formats_1.getIDEFormat)('claude-code');
+    return format.transform(builder.getServers());
+};
+exports.generateClaudeCodeMCPServers = generateClaudeCodeMCPServers;
+const generateKiroMCPServers = async (fraimKey, tokenInput, providerConfigs) => {
+    const tokens = normalizeTokens(tokenInput);
+    const builder = new mcp_server_builder_1.MCPServerBuilder();
+    builder.addBaseServers(fraimKey);
+    await addProviderServers(builder, tokens, providerConfigs);
+    const format = (0, ide_formats_1.getIDEFormat)('kiro');
+    return format.transform(builder.getServers());
+};
+exports.generateKiroMCPServers = generateKiroMCPServers;
+const generateCodexMCPServers = async (fraimKey, tokenInput, providerConfigs) => {
+    const tokens = normalizeTokens(tokenInput);
+    const builder = new mcp_server_builder_1.MCPServerBuilder();
+    builder.addBaseServers(fraimKey);
+    await addProviderServers(builder, tokens, providerConfigs);
+    const format = (0, ide_formats_1.getIDEFormat)('codex');
+    return format.transform(builder.getServers());
+};
+exports.generateCodexMCPServers = generateCodexMCPServers;
+const generateVSCodeMCPServers = async (fraimKey, tokenInput, providerConfigs) => {
+    const tokens = normalizeTokens(tokenInput);
+    const builder = new mcp_server_builder_1.MCPServerBuilder();
+    builder.addBaseServers(fraimKey);
+    await addProviderServers(builder, tokens, providerConfigs);
+    const format = (0, ide_formats_1.getIDEFormat)('vscode');
+    return format.transform(builder.getServers());
+};
+exports.generateVSCodeMCPServers = generateVSCodeMCPServers;
+const generateWindsurfMCPServers = async (fraimKey, tokenInput, providerConfigs) => {
+    const tokens = normalizeTokens(tokenInput);
+    const builder = new mcp_server_builder_1.MCPServerBuilder();
+    builder.addBaseServers(fraimKey);
+    await addProviderServers(builder, tokens, providerConfigs);
+    const format = (0, ide_formats_1.getIDEFormat)('windsurf');
+    return format.transform(builder.getServers());
+};
+exports.generateWindsurfMCPServers = generateWindsurfMCPServers;
+const generateMCPConfig = async (configType, fraimKey, tokenInput, providerConfigs) => {
+    switch (configType) {
+        case 'standard':
+            return await (0, exports.generateStandardMCPServers)(fraimKey, tokenInput, providerConfigs);
+        case 'claude':
+            return await (0, exports.generateClaudeMCPServers)(fraimKey, tokenInput, providerConfigs);
+        case 'claude-code':
+            return await (0, exports.generateClaudeCodeMCPServers)(fraimKey, tokenInput, providerConfigs);
+        case 'kiro':
+            return await (0, exports.generateKiroMCPServers)(fraimKey, tokenInput, providerConfigs);
+        case 'vscode':
+            return await (0, exports.generateVSCodeMCPServers)(fraimKey, tokenInput, providerConfigs);
+        case 'codex':
+            return await (0, exports.generateCodexMCPServers)(fraimKey, tokenInput, providerConfigs);
+        case 'windsurf':
+            return await (0, exports.generateWindsurfMCPServers)(fraimKey, tokenInput, providerConfigs);
+        default:
+            throw new Error(`Unsupported config type: ${configType}`);
+    }
+};
+exports.generateMCPConfig = generateMCPConfig;