fraim-framework 2.0.77 → 2.0.78

package/dist/src/cli/commands/add-ide.js

@@ -23,6 +23,8 @@ const loadGlobalConfig = () => {
         return {
             fraimKey: config.apiKey,
             githubToken: config.tokens?.github || config.githubToken, // Support both old and new format
+            gitlabToken: config.tokens?.gitlab,
+            jiraToken: config.tokens?.jira,
             mode: config.mode
         };
     }
@@ -95,7 +97,7 @@ const saveGitHubTokenToConfig = (githubToken) => {
     }
 };
 exports.saveGitHubTokenToConfig = saveGitHubTokenToConfig;
-const configureIDEMCP = async (ide, fraimKey, githubToken) => {
+const configureIDEMCP = async (ide, fraimKey, tokens) => {
     const configPath = (0, ide_detector_1.expandPath)(ide.configPath);
     console.log(chalk_1.default.blue(`🔧 Configuring ${ide.name}...`));
     // Create backup if config exists
@@ -129,8 +131,8 @@ const configureIDEMCP = async (ide, fraimKey, githubToken) => {
             existingTomlContent = fs_1.default.readFileSync(configPath, 'utf8');
             console.log(chalk_1.default.gray(`  📋 Found existing TOML config`));
         }
-        const newTomlContent = (0, mcp_config_generator_1.generateMCPConfig)(ide.configType, fraimKey, githubToken);
-        const serversToAdd = ['fraim', 'git', 'github', 'playwright'];
+        const newTomlContent = (0, mcp_config_generator_1.generateMCPConfig)(ide.configType, fraimKey, tokens);
+        const serversToAdd = ['fraim', 'git', 'github', 'gitlab', 'jira', 'playwright'];
         const mergeResult = (0, mcp_config_generator_1.mergeTomlMCPServers)(existingTomlContent, newTomlContent, serversToAdd);
         fs_1.default.writeFileSync(configPath, mergeResult.content);
         mergeResult.addedServers.forEach(server => {
@@ -145,7 +147,7 @@ const configureIDEMCP = async (ide, fraimKey, githubToken) => {
     }
     else {
         // Handle JSON format
-        const newConfig = (0, mcp_config_generator_1.generateMCPConfig)(ide.configType, fraimKey, githubToken);
+        const newConfig = (0, mcp_config_generator_1.generateMCPConfig)(ide.configType, fraimKey, tokens);
         const newMCPServers = newConfig.mcpServers || {};
         // Merge MCP servers intelligently
         const mergedMCPServers = { ...existingMCPServers };
@@ -197,7 +199,7 @@ const listSupportedIDEs = () => {
     console.log(chalk_1.default.yellow('💡 Use "fraim add-ide --ide <name>" to configure a specific IDE'));
     console.log(chalk_1.default.yellow('   Example: fraim add-ide --ide claude'));
 };
-const promptForIDESelection = async (availableIDEs, githubToken) => {
+const promptForIDESelection = async (availableIDEs, tokens) => {
     console.log(chalk_1.default.green(`✅ Found ${availableIDEs.length} IDEs that can be configured:\n`));
     availableIDEs.forEach((ide, index) => {
         const configExists = fs_1.default.existsSync((0, ide_detector_1.expandPath)(ide.configPath));
@@ -208,10 +210,16 @@ const promptForIDESelection = async (availableIDEs, githubToken) => {
     console.log(chalk_1.default.blue('\nFRAIM will add these MCP servers:'));
     console.log(chalk_1.default.gray('   • fraim (workflows and AI management)'));
     console.log(chalk_1.default.gray('   • git (version control integration)'));
-    if (githubToken) {
-        console.log(chalk_1.default.gray('   • github (GitHub API access)'));
+    if (tokens?.github) {
+        console.log(chalk_1.default.gray('   - github (GitHub API access)'));
     }
-    console.log(chalk_1.default.gray('   • playwright (browser automation)'));
+    if (tokens?.gitlab) {
+        console.log(chalk_1.default.gray('   - gitlab (GitLab API access)'));
+    }
+    if (tokens?.jira) {
+        console.log(chalk_1.default.gray('   - jira (Jira issue tracking)'));
+    }
+    console.log(chalk_1.default.gray('   - playwright (browser automation)'));
     const response = await (0, prompts_1.default)({
         type: 'text',
         name: 'selection',
@@ -250,12 +258,18 @@ const runAddIDE = async (options) => {
         process.exit(1);
     }
     let githubToken = globalConfig.githubToken;
+    const platformTokens = {
+        github: globalConfig.githubToken,
+        gitlab: globalConfig.gitlabToken,
+        jira: globalConfig.jiraToken
+    };
     const isConversationalMode = globalConfig.mode === 'conversational';
-    if (!githubToken && !isConversationalMode) {
+    if (!githubToken && !platformTokens.gitlab && !platformTokens.jira && !isConversationalMode) {
         console.log(chalk_1.default.yellow('⚠️ No GitHub token found in configuration.'));
         githubToken = await promptForGitHubToken(false);
         if (githubToken) {
             saveGitHubTokenToConfig(githubToken);
+            platformTokens.github = githubToken;
         }
     }
     if (isConversationalMode && !githubToken) {
@@ -295,7 +309,7 @@ const runAddIDE = async (options) => {
     }
     else {
         // Interactive selection
-        idesToConfigure = await promptForIDESelection(detectedIDEs, githubToken);
+        idesToConfigure = await promptForIDESelection(detectedIDEs, platformTokens);
     }
     if (idesToConfigure.length === 0) {
         console.log(chalk_1.default.yellow('⚠️ No IDEs selected for configuration.'));
@@ -308,7 +322,7 @@ const runAddIDE = async (options) => {
     };
     for (const ide of idesToConfigure) {
         try {
-            await configureIDEMCP(ide, globalConfig.fraimKey, githubToken || '');
+            await configureIDEMCP(ide, globalConfig.fraimKey, platformTokens);
             results.successful.push(ide.name);
         }
         catch (error) {

package/dist/src/cli/commands/init-project.js

@@ -75,12 +75,19 @@ const runInitProject = async () => {
                         owner: detection.repository.owner,
                         name: detection.repository.name
                     }
-                    : {
-                        provider: 'ado',
-                        organization: detection.repository.organization,
-                        project: detection.repository.project,
-                        name: detection.repository.name
-                    };
+                    : detection.provider === 'ado'
+                        ? {
+                            provider: 'ado',
+                            organization: detection.repository.organization,
+                            project: detection.repository.project,
+                            name: detection.repository.name
+                        }
+                        : {
+                            provider: 'gitlab',
+                            namespace: detection.repository.namespace,
+                            name: detection.repository.name,
+                            projectPath: detection.repository.projectPath
+                        };
                 config = {
                     version: (0, version_utils_1.getFraimVersion)(),
                     project: {
@@ -99,6 +106,10 @@ const runInitProject = async () => {
                     console.log(chalk_1.default.gray(`   Project: ${detection.repository.project}`));
                     console.log(chalk_1.default.gray(`   Repository: ${detection.repository.name}`));
                 }
+                else if (detection.provider === 'gitlab') {
+                    console.log(chalk_1.default.gray(`   Namespace: ${detection.repository.namespace || '(none)'}`));
+                    console.log(chalk_1.default.gray(`   Repository: ${detection.repository.name}`));
+                }
             }
             else {
                 config = {

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

@@ -112,23 +112,31 @@ const promptForPlatforms = async () => {
         message: 'Select platforms (Space to select, Enter to confirm)',
         choices: [
             { title: 'GitHub', value: 'github', selected: true },
-            { title: 'Azure DevOps', value: 'ado', selected: false }
+            { title: 'Azure DevOps', value: 'ado', selected: false },
+            { title: 'GitLab', value: 'gitlab', selected: false },
+            { title: 'Jira', value: 'jira', selected: false }
         ],
         min: 1
     });
     if (!response.platforms || response.platforms.length === 0) {
         console.log(chalk_1.default.yellow('\nℹ️  No platforms selected, defaulting to GitHub'));
-        return { github: true, ado: false };
+        return { github: true, ado: false, gitlab: false, jira: false };
     }
     const platforms = {
         github: response.platforms.includes('github'),
-        ado: response.platforms.includes('ado')
+        ado: response.platforms.includes('ado'),
+        gitlab: response.platforms.includes('gitlab'),
+        jira: response.platforms.includes('jira')
     };
     console.log(chalk_1.default.blue('\n✓ Selected platforms:'));
     if (platforms.github)
-        console.log(chalk_1.default.gray('  • GitHub'));
+        console.log(chalk_1.default.gray('  - GitHub'));
     if (platforms.ado)
-        console.log(chalk_1.default.gray('  • Azure DevOps'));
+        console.log(chalk_1.default.gray('  - Azure DevOps'));
+    if (platforms.gitlab)
+        console.log(chalk_1.default.gray('  - GitLab'));
+    if (platforms.jira)
+        console.log(chalk_1.default.gray('  - Jira'));
     console.log();
     return platforms;
 };
@@ -197,6 +205,48 @@ const promptForADOToken = async () => {
     }
     throw new Error('Failed to get Azure DevOps token');
 };
+const promptForGitLabToken = async () => {
+    console.log(chalk_1.default.blue('\nGitLab Integration Setup'));
+    console.log('FRAIM requires a GitLab token for GitLab issue/repository MCP integration.\n');
+    const tokenResponse = await (0, prompts_1.default)({
+        type: 'password',
+        name: 'token',
+        message: 'Enter your GitLab token',
+        validate: (value) => {
+            if (!value)
+                return 'GitLab token is required';
+            if (!(0, token_validator_1.isValidTokenFormat)(value, 'gitlab'))
+                return 'Please enter a valid GitLab token (typically starts with glpat-)';
+            return true;
+        }
+    });
+    if (!tokenResponse.token) {
+        throw new Error('GitLab token is required');
+    }
+    console.log(chalk_1.default.green('GitLab token received\n'));
+    return tokenResponse.token;
+};
+const promptForJiraToken = async () => {
+    console.log(chalk_1.default.blue('\nJira Integration Setup'));
+    console.log('FRAIM requires a Jira API token for Jira MCP integration.\n');
+    const tokenResponse = await (0, prompts_1.default)({
+        type: 'password',
+        name: 'token',
+        message: 'Enter your Jira API token',
+        validate: (value) => {
+            if (!value)
+                return 'Jira token is required';
+            if (!(0, token_validator_1.isValidTokenFormat)(value, 'jira'))
+                return 'Please enter a valid Jira token';
+            return true;
+        }
+    });
+    if (!tokenResponse.token) {
+        throw new Error('Jira token is required');
+    }
+    console.log(chalk_1.default.green('Jira token received\n'));
+    return tokenResponse.token;
+};
 const saveGlobalConfig = (fraimKey, mode, tokens) => {
     const globalConfigDir = path_1.default.join(os_1.default.homedir(), '.fraim');
     const globalConfigPath = path_1.default.join(globalConfigDir, 'config.json');
@@ -235,7 +285,7 @@ const runSetup = async (options) => {
     console.log(chalk_1.default.blue('🚀 Welcome to FRAIM! Let\'s get you set up.\n'));
     // Determine if this is an update (adding platforms to existing setup)
     const globalConfigPath = path_1.default.join(os_1.default.homedir(), '.fraim', 'config.json');
-    const isUpdate = fs_1.default.existsSync(globalConfigPath) && (options.github || options.ado);
+    const isUpdate = fs_1.default.existsSync(globalConfigPath) && (options.github || options.ado || options.gitlab || options.jira);
     let fraimKey;
     let mode;
     const tokens = {};
@@ -252,9 +302,13 @@ const runSetup = async (options) => {
                     tokens.github = existingConfig.tokens.github;
                 if (existingConfig.tokens.ado)
                     tokens.ado = existingConfig.tokens.ado;
+                if (existingConfig.tokens.gitlab)
+                    tokens.gitlab = existingConfig.tokens.gitlab;
+                if (existingConfig.tokens.jira)
+                    tokens.jira = existingConfig.tokens.jira;
             }
             console.log(chalk_1.default.gray(`   Current mode: ${mode}`));
-            console.log(chalk_1.default.gray(`   Existing tokens: ${tokens.github ? 'GitHub ✓' : ''} ${tokens.ado ? 'ADO ✓' : ''}\n`));
+            console.log(chalk_1.default.gray(`   Existing tokens: ${tokens.github ? 'GitHub yes' : ''} ${tokens.ado ? 'ADO yes' : ''} ${tokens.gitlab ? 'GitLab yes' : ''} ${tokens.jira ? 'Jira yes' : ''}\n`));
         }
         catch (e) {
             console.log(chalk_1.default.red('❌ Failed to read existing configuration'));
@@ -288,11 +342,15 @@ const runSetup = async (options) => {
     if (mode === 'integrated') {
         let needGitHub = options.github || false;
         let needADO = options.ado || false;
+        let needGitLab = options.gitlab || false;
+        let needJira = options.jira || false;
         // If no specific platform flags and not an update, ask user
-        if (!isUpdate && !needGitHub && !needADO) {
+        if (!isUpdate && !needGitHub && !needADO && !needGitLab && !needJira) {
             const platforms = await promptForPlatforms();
             needGitHub = platforms.github;
             needADO = platforms.ado;
+            needGitLab = platforms.gitlab;
+            needJira = platforms.jira;
         }
         // Get GitHub token if needed
         if (needGitHub && !tokens.github) {
@@ -336,11 +394,51 @@ const runSetup = async (options) => {
                 }
             }
         }
-        if (!tokens.github && !tokens.ado) {
+        // Get GitLab token if needed
+        if (needGitLab && !tokens.gitlab) {
+            if (options.gitlabToken) {
+                if (!(0, token_validator_1.isValidTokenFormat)(options.gitlabToken, 'gitlab')) {
+                    console.log(chalk_1.default.red('Invalid GitLab token format'));
+                    process.exit(1);
+                }
+                tokens.gitlab = options.gitlabToken;
+            }
+            else {
+                try {
+                    tokens.gitlab = await promptForGitLabToken();
+                }
+                catch (e) {
+                    console.log(chalk_1.default.red('Failed to get GitLab token'));
+                    process.exit(1);
+                }
+            }
+        }
+        // Get Jira token if needed
+        if (needJira && !tokens.jira) {
+            if (options.jiraToken) {
+                if (!(0, token_validator_1.isValidTokenFormat)(options.jiraToken, 'jira')) {
+                    console.log(chalk_1.default.red('Invalid Jira token format'));
+                    process.exit(1);
+                }
+                tokens.jira = options.jiraToken;
+            }
+            else {
+                try {
+                    tokens.jira = await promptForJiraToken();
+                }
+                catch (e) {
+                    console.log(chalk_1.default.red('Failed to get Jira token'));
+                    process.exit(1);
+                }
+            }
+        }
+        if (!tokens.github && !tokens.ado && !tokens.gitlab && !tokens.jira) {
             console.log(chalk_1.default.yellow('⚠️  No platform tokens configured.'));
             console.log(chalk_1.default.gray('   You can add them later with:'));
             console.log(chalk_1.default.cyan('   fraim setup --github'));
-            console.log(chalk_1.default.cyan('   fraim setup --ado\n'));
+            console.log(chalk_1.default.cyan('   fraim setup --ado'));
+            console.log(chalk_1.default.cyan('   fraim setup --gitlab'));
+            console.log(chalk_1.default.cyan('   fraim setup --jira\n'));
         }
     }
     else {
@@ -354,13 +452,17 @@ const runSetup = async (options) => {
         console.log(chalk_1.default.blue('\n🔌 Configuring MCP servers...'));
         // For conversational mode, we still configure MCP but without GitHub token requirement
         // The FRAIM MCP server works without GitHub token, other servers can be optional
-        const mcpGitHubToken = tokens.github || '';
-        if (mode === 'conversational' && !mcpGitHubToken) {
+        const mcpTokens = {
+            github: tokens.github || '',
+            gitlab: tokens.gitlab || '',
+            jira: tokens.jira || ''
+        };
+        if (mode === 'conversational' && !mcpTokens.github && !mcpTokens.gitlab && !mcpTokens.jira) {
             console.log(chalk_1.default.yellow('ℹ️  Conversational mode: Configuring MCP servers without GitHub integration'));
             console.log(chalk_1.default.gray('   FRAIM workflows will work, but GitHub-specific features will be unavailable\n'));
         }
         try {
-            await (0, auto_mcp_setup_1.autoConfigureMCP)(fraimKey, mcpGitHubToken, options.ide ? [options.ide] : undefined);
+            await (0, auto_mcp_setup_1.autoConfigureMCP)(fraimKey, mcpTokens, options.ide ? [options.ide] : undefined);
         }
         catch (e) {
             console.log(chalk_1.default.yellow('⚠️  MCP configuration encountered issues'));
@@ -380,18 +482,22 @@ const runSetup = async (options) => {
     console.log(chalk_1.default.green('\n🎯 Setup complete!'));
     console.log(chalk_1.default.gray(`   Mode: ${mode}`));
     if (mode === 'integrated') {
-        console.log(chalk_1.default.gray(`   Platforms: ${tokens.github ? 'GitHub ✓' : 'GitHub ✗'} ${tokens.ado ? 'ADO ✓' : 'ADO ✗'}`));
+        console.log(chalk_1.default.gray(`   Platforms: ${tokens.github ? 'GitHub yes' : 'GitHub no'} ${tokens.ado ? 'ADO yes' : 'ADO no'} ${tokens.gitlab ? 'GitLab yes' : 'GitLab no'} ${tokens.jira ? 'Jira yes' : 'Jira no'}`));
     }
     console.log(chalk_1.default.cyan('\n📝 For future projects:'));
     console.log(chalk_1.default.cyan('   1. cd into any project directory'));
     console.log(chalk_1.default.cyan('   2. Run: fraim init-project'));
     console.log(chalk_1.default.cyan('   3. Ask your AI agent (Claude Desktop / Cowork, Cursor, etc.) "list fraim workflows"'));
-    if (mode === 'integrated' && (!tokens.github || !tokens.ado)) {
+    if (mode === 'integrated' && (!tokens.github || !tokens.ado || !tokens.gitlab || !tokens.jira)) {
         console.log(chalk_1.default.gray('\n💡 To add more platforms later:'));
         if (!tokens.github)
             console.log(chalk_1.default.gray('   fraim setup --github'));
         if (!tokens.ado)
             console.log(chalk_1.default.gray('   fraim setup --ado'));
+        if (!tokens.gitlab)
+            console.log(chalk_1.default.gray('   fraim setup --gitlab'));
+        if (!tokens.jira)
+            console.log(chalk_1.default.gray('   fraim setup --jira'));
     }
 };
 exports.runSetup = runSetup;
@@ -400,8 +506,12 @@ exports.setupCommand = new commander_1.Command('setup')
     .option('--key <key>', 'FRAIM API key')
     .option('--github-token <token>', 'GitHub Personal Access Token')
     .option('--ado-token <token>', 'Azure DevOps Personal Access Token')
+    .option('--gitlab-token <token>', 'GitLab Personal Access Token')
+    .option('--jira-token <token>', 'Jira API token')
     .option('--github', 'Add/update GitHub integration')
     .option('--ado', 'Add/update Azure DevOps integration')
+    .option('--gitlab', 'Add/update GitLab integration')
+    .option('--jira', 'Add/update Jira integration')
     .option('--all', 'Configure all detected IDEs (deprecated)')
     .option('--ide <ides>', 'Configure specific IDEs (deprecated)')
     .action(exports.runSetup);

package/dist/src/cli/setup/auto-mcp-setup.js

@@ -12,7 +12,16 @@ const ide_detector_1 = require("./ide-detector");
 const mcp_config_generator_1 = require("./mcp-config-generator");
 const token_validator_1 = require("./token-validator");
 const codex_local_config_1 = require("./codex-local-config");
-const promptForIDESelection = async (detectedIDEs, githubToken) => {
+const normalizePlatformTokens = (tokenInput) => {
+    if (!tokenInput)
+        return {};
+    if (typeof tokenInput === 'string') {
+        return tokenInput ? { github: tokenInput } : {};
+    }
+    return tokenInput;
+};
+const promptForIDESelection = async (detectedIDEs, tokenInput) => {
+    const tokens = normalizePlatformTokens(tokenInput);
     console.log(chalk_1.default.green(`✅ Found ${detectedIDEs.length} IDEs that can be configured with FRAIM:\n`));
     detectedIDEs.forEach((ide, index) => {
         const configExists = fs_1.default.existsSync((0, ide_detector_1.expandPath)(ide.configPath));
@@ -24,8 +33,14 @@ const promptForIDESelection = async (detectedIDEs, githubToken) => {
     console.log(chalk_1.default.blue('FRAIM will add these MCP servers to selected IDEs:'));
     console.log(chalk_1.default.gray('   • fraim (required for FRAIM workflows)'));
     console.log(chalk_1.default.gray('   • git (version control integration)'));
-    if (githubToken) {
-        console.log(chalk_1.default.gray('   • github (GitHub API access)'));
+    if (tokens.github) {
+        console.log(chalk_1.default.gray('   - github (GitHub API access)'));
+    }
+    if (tokens.gitlab) {
+        console.log(chalk_1.default.gray('   - gitlab (GitLab API access)'));
+    }
+    if (tokens.jira) {
+        console.log(chalk_1.default.gray('   - jira (Jira issue tracking)'));
     }
     console.log(chalk_1.default.gray('   • playwright (browser automation)'));
     console.log(chalk_1.default.yellow('\n💡 Existing MCP servers will be preserved - only missing servers will be added.'));
@@ -197,7 +212,8 @@ const validateSetupResults = async (configuredIDEs) => {
     }
 };
 exports.validateSetupResults = validateSetupResults;
-const configureIDEMCP = async (ide, fraimKey, githubToken) => {
+const configureIDEMCP = async (ide, fraimKey, tokenInput) => {
+    const tokens = normalizePlatformTokens(tokenInput);
     const configPath = (0, ide_detector_1.expandPath)(ide.configPath);
     console.log(chalk_1.default.blue(`🔧 Configuring ${ide.name}...`));
     // Create backup
@@ -228,8 +244,8 @@ const configureIDEMCP = async (ide, fraimKey, githubToken) => {
             existingTomlContent = fs_1.default.readFileSync(configPath, 'utf8');
             console.log(chalk_1.default.gray(`  📋 Found existing TOML config`));
         }
-        const newTomlContent = (0, mcp_config_generator_1.generateMCPConfig)(ide.configType, fraimKey, githubToken);
-        const serversToAdd = ['fraim', 'git', 'github', 'playwright'];
+        const newTomlContent = (0, mcp_config_generator_1.generateMCPConfig)(ide.configType, fraimKey, tokens);
+        const serversToAdd = ['fraim', 'git', 'github', 'gitlab', 'jira', 'playwright'];
         const mergeResult = (0, mcp_config_generator_1.mergeTomlMCPServers)(existingTomlContent, newTomlContent, serversToAdd);
         fs_1.default.writeFileSync(configPath, mergeResult.content);
         mergeResult.addedServers.forEach(server => {
@@ -244,7 +260,7 @@ const configureIDEMCP = async (ide, fraimKey, githubToken) => {
     }
     else {
         // For JSON configs - intelligent merging
-        const newConfig = (0, mcp_config_generator_1.generateMCPConfig)(ide.configType, fraimKey, githubToken);
+        const newConfig = (0, mcp_config_generator_1.generateMCPConfig)(ide.configType, fraimKey, tokens);
         const newMCPServers = newConfig[serversKey] || newConfig.mcpServers || {};
         // Merge MCP servers intelligently
         const mergedMCPServers = { ...existingMCPServers };
@@ -280,7 +296,8 @@ const configureIDEMCP = async (ide, fraimKey, githubToken) => {
         console.log(chalk_1.default.green(`  ✅ ${status} local Codex config: ${localResult.path}`));
     }
 };
-const autoConfigureMCP = async (fraimKey, githubToken, selectedIDEs) => {
+const autoConfigureMCP = async (fraimKey, tokenInput, selectedIDEs) => {
+    const tokens = normalizePlatformTokens(tokenInput);
     const detectedIDEs = (0, ide_detector_1.detectInstalledIDEs)();
     if (detectedIDEs.length === 0) {
         console.log(chalk_1.default.yellow('⚠️ No supported IDEs detected.'));
@@ -312,7 +329,7 @@ const autoConfigureMCP = async (fraimKey, githubToken, selectedIDEs) => {
     }
     else {
         // Interactive selection
-        idesToConfigure = await (0, exports.promptForIDESelection)(detectedIDEs, githubToken);
+        idesToConfigure = await (0, exports.promptForIDESelection)(detectedIDEs, tokens);
     }
     if (idesToConfigure.length === 0) {
         console.log(chalk_1.default.yellow('⚠️ No IDEs selected for configuration.'));
@@ -326,7 +343,7 @@ const autoConfigureMCP = async (fraimKey, githubToken, selectedIDEs) => {
     };
     for (const ide of idesToConfigure) {
         try {
-            await configureIDEMCP(ide, fraimKey, githubToken);
+            await configureIDEMCP(ide, fraimKey, tokens);
             results.successful.push(ide.name);
         }
         catch (error) {

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

@@ -1,6 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateMCPConfig = exports.generateWindsurfMCPServers = exports.generateVSCodeMCPServers = exports.generateCodexMCPServers = exports.generateKiroMCPServers = exports.generateClaudeMCPServers = exports.generateStandardMCPServers = exports.mergeTomlMCPServers = exports.extractTomlMcpServerBlock = void 0;
+const GITHUB_MCP_URL = 'https://api.githubcopilot.com/mcp/';
+const GITLAB_MCP_URL = 'https://gitlab.com/api/v4/mcp';
+const JIRA_MCP_URL = 'https://mcp.atlassian.com/v1/sse';
+const normalizeTokens = (tokenInput) => {
+    if (!tokenInput)
+        return {};
+    if (typeof tokenInput === 'string') {
+        return tokenInput ? { github: tokenInput } : {};
+    }
+    return tokenInput;
+};
 const escapeTomlString = (value) => value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
 const findTomlServerBlockRange = (content, server) => {
     const lines = content.split(/\r?\n/);
@@ -82,7 +93,8 @@ const mergeTomlMCPServers = (existingContent, generatedContent, servers) => {
     };
 };
 exports.mergeTomlMCPServers = mergeTomlMCPServers;
-const generateStandardMCPServers = (fraimKey, githubToken) => {
+const generateStandardMCPServers = (fraimKey, tokenInput) => {
+    const tokens = normalizeTokens(tokenInput);
     const servers = {
         git: {
             command: "npx",
@@ -100,19 +112,35 @@ const generateStandardMCPServers = (fraimKey, githubToken) => {
             }
         }
     };
-    // Only add GitHub server if token is provided
-    if (githubToken) {
+    if (tokens.github) {
         servers.github = {
-            serverUrl: "https://api.githubcopilot.com/mcp/",
+            serverUrl: GITHUB_MCP_URL,
+            headers: {
+                Authorization: `Bearer ${tokens.github}`
+            }
+        };
+    }
+    if (tokens.gitlab) {
+        servers.gitlab = {
+            serverUrl: GITLAB_MCP_URL,
+            headers: {
+                Authorization: `Bearer ${tokens.gitlab}`
+            }
+        };
+    }
+    if (tokens.jira) {
+        servers.jira = {
+            serverUrl: JIRA_MCP_URL,
             headers: {
-                Authorization: `Bearer ${githubToken}`
+                Authorization: `Bearer ${tokens.jira}`
             }
         };
     }
     return { mcpServers: servers };
 };
 exports.generateStandardMCPServers = generateStandardMCPServers;
-const generateClaudeMCPServers = (fraimKey, githubToken) => {
+const generateClaudeMCPServers = (fraimKey, tokenInput) => {
+    const tokens = normalizeTokens(tokenInput);
     const servers = {
         git: {
             command: "npx",
@@ -130,20 +158,38 @@ const generateClaudeMCPServers = (fraimKey, githubToken) => {
             }
         }
     };
-    // Only add GitHub server if token is provided
-    if (githubToken) {
+    if (tokens.github) {
         servers.github = {
             type: "http",
-            url: "https://api.githubcopilot.com/mcp/",
+            url: GITHUB_MCP_URL,
             headers: {
-                Authorization: `Bearer ${githubToken}`
+                Authorization: `Bearer ${tokens.github}`
+            }
+        };
+    }
+    if (tokens.gitlab) {
+        servers.gitlab = {
+            type: 'http',
+            url: GITLAB_MCP_URL,
+            headers: {
+                Authorization: `Bearer ${tokens.gitlab}`
+            }
+        };
+    }
+    if (tokens.jira) {
+        servers.jira = {
+            type: 'http',
+            url: JIRA_MCP_URL,
+            headers: {
+                Authorization: `Bearer ${tokens.jira}`
             }
         };
     }
     return { mcpServers: servers };
 };
 exports.generateClaudeMCPServers = generateClaudeMCPServers;
-const generateKiroMCPServers = (fraimKey, githubToken) => {
+const generateKiroMCPServers = (fraimKey, tokenInput) => {
+    const tokens = normalizeTokens(tokenInput);
     const servers = {
         git: {
             command: "npx",
@@ -161,36 +207,67 @@ const generateKiroMCPServers = (fraimKey, githubToken) => {
             }
         }
     };
-    // Only add GitHub server if token is provided
-    if (githubToken) {
+    if (tokens.github) {
         servers.github = {
-            url: "https://api.githubcopilot.com/mcp/",
+            url: GITHUB_MCP_URL,
+            headers: {
+                Authorization: `Bearer ${tokens.github}`
+            }
+        };
+    }
+    if (tokens.gitlab) {
+        servers.gitlab = {
+            url: GITLAB_MCP_URL,
+            headers: {
+                Authorization: `Bearer ${tokens.gitlab}`
+            }
+        };
+    }
+    if (tokens.jira) {
+        servers.jira = {
+            url: JIRA_MCP_URL,
             headers: {
-                Authorization: `Bearer ${githubToken}`
+                Authorization: `Bearer ${tokens.jira}`
             }
         };
     }
     return { mcpServers: servers };
 };
 exports.generateKiroMCPServers = generateKiroMCPServers;
-const generateCodexMCPServers = (fraimKey, githubToken) => {
+const generateCodexMCPServers = (fraimKey, tokenInput) => {
+    const tokens = normalizeTokens(tokenInput);
     const escapedFraimKey = escapeTomlString(fraimKey);
-    const escapedGithubToken = escapeTomlString(githubToken);
     let config = `
 [mcp_servers.git]
 command = "npx"
-args = ["-y", "@cyanheads/git-mcp-server"]
+args = ["-y", "@cyanheads/git-mcp-server"]
 `;
-    // Only add GitHub server if token is provided
-    if (githubToken) {
+    if (tokens.github) {
+        const escapedGithubToken = escapeTomlString(tokens.github);
         config += `
 [mcp_servers.github]
-url = "https://api.githubcopilot.com/mcp/"
+url = "${GITHUB_MCP_URL}"
 http_headers = { Authorization = "Bearer ${escapedGithubToken}" }
 `;
     }
-    config += `
-[mcp_servers.playwright]
+    if (tokens.gitlab) {
+        const escapedGitLabToken = escapeTomlString(tokens.gitlab);
+        config += `
+[mcp_servers.gitlab]
+url = "${GITLAB_MCP_URL}"
+http_headers = { Authorization = "Bearer ${escapedGitLabToken}" }
+`;
+    }
+    if (tokens.jira) {
+        const escapedJiraToken = escapeTomlString(tokens.jira);
+        config += `
+[mcp_servers.jira]
+url = "${JIRA_MCP_URL}"
+http_headers = { Authorization = "Bearer ${escapedJiraToken}" }
+`;
+    }
+    config += `
+[mcp_servers.playwright]
 command = "npx"
 args = ["-y", "@playwright/mcp"]
 
@@ -205,7 +282,8 @@ FRAIM_REMOTE_URL = "https://fraim.wellnessatwork.me"
 };
 exports.generateCodexMCPServers = generateCodexMCPServers;
 /** VS Code uses "servers" key and requires type: "stdio" for stdio servers */
-const generateVSCodeMCPServers = (fraimKey, githubToken) => {
+const generateVSCodeMCPServers = (fraimKey, tokenInput) => {
+    const tokens = normalizeTokens(tokenInput);
     const servers = {
         git: {
             type: 'stdio',
@@ -226,19 +304,38 @@ const generateVSCodeMCPServers = (fraimKey, githubToken) => {
             }
         }
     };
-    if (githubToken) {
+    if (tokens.github) {
         servers.github = {
             type: 'http',
-            url: 'https://api.githubcopilot.com/mcp/',
+            url: GITHUB_MCP_URL,
             headers: {
-                Authorization: `Bearer ${githubToken}`
+                Authorization: `Bearer ${tokens.github}`
+            }
+        };
+    }
+    if (tokens.gitlab) {
+        servers.gitlab = {
+            type: 'http',
+            url: GITLAB_MCP_URL,
+            headers: {
+                Authorization: `Bearer ${tokens.gitlab}`
+            }
+        };
+    }
+    if (tokens.jira) {
+        servers.jira = {
+            type: 'http',
+            url: JIRA_MCP_URL,
+            headers: {
+                Authorization: `Bearer ${tokens.jira}`
             }
         };
     }
     return { servers };
 };
 exports.generateVSCodeMCPServers = generateVSCodeMCPServers;
-const generateWindsurfMCPServers = (fraimKey, githubToken) => {
+const generateWindsurfMCPServers = (fraimKey, tokenInput) => {
+    const tokens = normalizeTokens(tokenInput);
     const servers = {
         git: {
             command: "npx",
@@ -256,33 +353,50 @@ const generateWindsurfMCPServers = (fraimKey, githubToken) => {
             }
         }
     };
-    // Only add GitHub server if token is provided
-    if (githubToken) {
+    if (tokens.github) {
         servers.github = {
             command: "npx",
-            args: ["-y", "@modelcontextprotocol/server-fetch", "https://api.githubcopilot.com/mcp/"],
+            args: ["-y", "@modelcontextprotocol/server-fetch", GITHUB_MCP_URL],
+            env: {
+                GITHUB_TOKEN: tokens.github
+            }
+        };
+    }
+    if (tokens.gitlab) {
+        servers.gitlab = {
+            command: 'npx',
+            args: ['-y', '@modelcontextprotocol/server-fetch', GITLAB_MCP_URL],
+            env: {
+                GITLAB_TOKEN: tokens.gitlab
+            }
+        };
+    }
+    if (tokens.jira) {
+        servers.jira = {
+            command: 'npx',
+            args: ['-y', '@modelcontextprotocol/server-fetch', JIRA_MCP_URL],
             env: {
-                GITHUB_TOKEN: githubToken
+                JIRA_TOKEN: tokens.jira
             }
         };
     }
     return { mcpServers: servers };
 };
 exports.generateWindsurfMCPServers = generateWindsurfMCPServers;
-const generateMCPConfig = (configType, fraimKey, githubToken) => {
+const generateMCPConfig = (configType, fraimKey, tokenInput) => {
     switch (configType) {
         case 'standard':
-            return (0, exports.generateStandardMCPServers)(fraimKey, githubToken);
+            return (0, exports.generateStandardMCPServers)(fraimKey, tokenInput);
         case 'claude':
-            return (0, exports.generateClaudeMCPServers)(fraimKey, githubToken);
+            return (0, exports.generateClaudeMCPServers)(fraimKey, tokenInput);
         case 'kiro':
-            return (0, exports.generateKiroMCPServers)(fraimKey, githubToken);
+            return (0, exports.generateKiroMCPServers)(fraimKey, tokenInput);
         case 'vscode':
-            return (0, exports.generateVSCodeMCPServers)(fraimKey, githubToken);
+            return (0, exports.generateVSCodeMCPServers)(fraimKey, tokenInput);
         case 'codex':
-            return (0, exports.generateCodexMCPServers)(fraimKey, githubToken);
+            return (0, exports.generateCodexMCPServers)(fraimKey, tokenInput);
         case 'windsurf':
-            return (0, exports.generateWindsurfMCPServers)(fraimKey, githubToken);
+            return (0, exports.generateWindsurfMCPServers)(fraimKey, tokenInput);
         default:
             throw new Error(`Unsupported config type: ${configType}`);
     }

package/dist/src/cli/setup/token-validator.js

@@ -44,6 +44,14 @@ const isValidTokenFormat = (token, type) => {
     if (type === 'github') {
         return token.startsWith('ghp_') || token.startsWith('github_pat_');
     }
+    if (type === 'gitlab') {
+        // GitLab PATs commonly use glpat- prefix, but keep a permissive fallback for self-managed/token variants.
+        return token.startsWith('glpat-') || token.length >= 20;
+    }
+    if (type === 'jira') {
+        // Jira API tokens do not have a stable prefix; enforce a minimum length.
+        return token.length >= 20;
+    }
     return false;
 };
 exports.isValidTokenFormat = isValidTokenFormat;

package/dist/src/cli/utils/platform-detection.js

@@ -78,6 +78,15 @@ function detectPlatformFromUrl(url) {
             confidence: 'high'
         };
     }
+    // GitLab detection
+    if (normalizedUrl.includes('gitlab.com') || normalizedUrl.includes('gitlab.')) {
+        const repository = extractGitLabInfo(url);
+        return {
+            provider: 'gitlab',
+            repository,
+            confidence: 'high'
+        };
+    }
     // ADO detection
     if (normalizedUrl.includes('dev.azure.com') ||
         normalizedUrl.includes('visualstudio.com') ||
@@ -117,6 +126,35 @@ function extractGitHubInfo(url) {
         defaultBranch: 'main'
     };
 }
+/**
+ * Extract GitLab repository information from URL
+ */
+function extractGitLabInfo(url) {
+    // GitLab URL formats:
+    // HTTPS: https://gitlab.com/group/subgroup/repo.git
+    // SSH: git@gitlab.com:group/subgroup/repo.git
+    const match = url.match(/gitlab[^\/:]*[\/:]([^?\s#]+?)(?:\.git)?$/i);
+    if (match) {
+        const projectPath = match[1].replace(/^\/+/, '');
+        const segments = projectPath.split('/').filter(Boolean);
+        const name = segments[segments.length - 1];
+        const namespace = segments.slice(0, -1).join('/');
+        return {
+            provider: 'gitlab',
+            namespace: namespace || undefined,
+            name,
+            projectPath,
+            url,
+            defaultBranch: 'main'
+        };
+    }
+    // Fallback - just mark as GitLab
+    return {
+        provider: 'gitlab',
+        url,
+        defaultBranch: 'main'
+    };
+}
 /**
  * Extract ADO repository information from URL
  */
@@ -178,6 +216,13 @@ function validateRepositoryConfig(config) {
         if (!config.name)
             errors.push('ADO repository name is required');
     }
+    if (config.provider === 'gitlab') {
+        const hasProjectPath = typeof config.projectPath === 'string' && config.projectPath.length > 0;
+        const hasNamespaceAndName = typeof config.namespace === 'string' && config.namespace.length > 0 && typeof config.name === 'string' && config.name.length > 0;
+        if (!hasProjectPath && !hasNamespaceAndName) {
+            errors.push('GitLab repository requires projectPath or namespace + name');
+        }
+    }
     return {
         valid: errors.length === 0,
         errors

package/dist/src/core/config-loader.js

@@ -95,7 +95,7 @@ function getRepositoryInfo(config) {
     // Prefer new repository config
     if (config.repository) {
         return {
-            owner: config.repository.owner || config.repository.organization,
+            owner: config.repository.owner || config.repository.organization || config.repository.namespace,
             name: config.repository.name,
             provider: config.repository.provider,
             defaultBranch: config.repository.defaultBranch

package/dist/src/core/utils/provider-utils.js

@@ -7,7 +7,11 @@ exports.detectProvider = detectProvider;
 function detectProvider(url) {
     if (!url)
         return 'github';
-    if (url.includes('dev.azure.com') || url.includes('visualstudio.com')) {
+    const normalized = url.toLowerCase();
+    if (normalized.includes('gitlab.com') || normalized.includes('gitlab.')) {
+        return 'gitlab';
+    }
+    if (normalized.includes('dev.azure.com') || normalized.includes('visualstudio.com')) {
         return 'ado';
     }
     return 'github';

package/dist/src/local-mcp-server/stdio-server.js

@@ -422,46 +422,69 @@ class FraimLocalMCPServer {
             catch (error) {
                 // If git command fails, construct URL from config if available.
                 const repositoryConfig = this.config?.repository;
-                if (repositoryConfig?.provider === 'github' && repositoryConfig.owner && repositoryConfig.name) {
+                if (repositoryConfig?.url) {
+                    repoUrl = repositoryConfig.url;
+                    this.log(`Constructed repo URL from config: ${repoUrl}`);
+                }
+                else if (repositoryConfig?.provider === 'github' && repositoryConfig.owner && repositoryConfig.name) {
                     repoUrl = `https://github.com/${repositoryConfig.owner}/${repositoryConfig.name}.git`;
-                    this.log(`📋 Constructed repo URL from config: ${repoUrl}`);
+                    this.log(`Constructed repo URL from config: ${repoUrl}`);
                 }
                 else if (repositoryConfig?.provider === 'ado' &&
                     repositoryConfig.organization &&
                     repositoryConfig.project &&
                     repositoryConfig.name) {
                     repoUrl = `https://dev.azure.com/${repositoryConfig.organization}/${repositoryConfig.project}/_git/${repositoryConfig.name}`;
-                    this.log(`📋 Constructed repo URL from config: ${repoUrl}`);
+                    this.log(`Constructed repo URL from config: ${repoUrl}`);
+                }
+                else if (repositoryConfig?.provider === 'gitlab') {
+                    const projectPath = repositoryConfig.projectPath
+                        || (repositoryConfig.namespace && repositoryConfig.name
+                            ? `${repositoryConfig.namespace}/${repositoryConfig.name}`
+                            : null);
+                    if (projectPath) {
+                        repoUrl = `https://gitlab.com/${projectPath}.git`;
+                        this.log(`Constructed repo URL from config: ${repoUrl}`);
+                    }
                 }
             }
             if (!repoUrl) {
-                this.log('⚠️ No git repository found and no config available');
+                this.log('No git repository found and no config available');
                 return null;
             }
-            // Parse owner and name from URL
+            // Parse repository identity from URL
             let name = '';
+            let owner = '';
             let organization = '';
             let project = '';
-            let owner = '';
-            // Handle GitHub URLs: https://github.com/owner/repo.git or git@github.com:owner/repo.git
-            const githubHttpsMatch = repoUrl.match(/github\.com[\/:]([^\/]+)\/([^\/\.]+)/);
-            const adoMatch = repoUrl.match(/dev\.azure\.com\/([^\/]+)\/([^\/]+)\/_git\/([^\/]+)/);
-            if (githubHttpsMatch) {
-                owner = githubHttpsMatch[1];
-                name = githubHttpsMatch[2];
+            let namespace = '';
+            let projectPath = '';
+            const githubMatch = repoUrl.match(/github\.com[\/:]([^\/]+)\/([^\/\.]+)/i);
+            const adoMatch = repoUrl.match(/dev\.azure\.com\/([^\/]+)\/([^\/]+)\/_git\/([^\/]+)/i);
+            const gitlabMatch = repoUrl.match(/gitlab[^\/:]*[\/:]([^?\s#]+?)(?:\.git)?$/i);
+            if (githubMatch) {
+                owner = githubMatch[1];
+                name = githubMatch[2];
             }
             else if (adoMatch) {
-                // Azure DevOps: organization and project are separate fields
                 organization = adoMatch[1];
                 project = adoMatch[2];
                 name = adoMatch[3];
             }
+            else if (gitlabMatch) {
+                projectPath = gitlabMatch[1].replace(/^\/+/, '');
+                const segments = projectPath.split('/').filter(Boolean);
+                name = segments[segments.length - 1] || '';
+                namespace = segments.slice(0, -1).join('/');
+            }
             else if (this.config?.repository) {
                 // Fall back to config if URL parsing fails
                 owner = this.config.repository.owner || '';
                 name = this.config.repository.name || '';
                 organization = this.config.repository.organization || '';
                 project = this.config.repository.project || '';
+                namespace = this.config.repository.namespace || '';
+                projectPath = this.config.repository.projectPath || (namespace && name ? `${namespace}/${name}` : '');
             }
             // Get current branch
             let branch = '';
@@ -483,6 +506,8 @@ class FraimLocalMCPServer {
                 name: name || 'unknown',
                 ...(organization && { organization }),
                 ...(project && { project }),
+                ...(namespace && { namespace }),
+                ...(projectPath && { projectPath }),
                 ...(branch && { branch })
             };
             if (owner) {
@@ -491,8 +516,8 @@ class FraimLocalMCPServer {
             this.repoInfo = repoInfo;
             const repoLabel = this.repoInfo.owner
                 ? `${this.repoInfo.owner}/${this.repoInfo.name}`
-                : this.repoInfo.name;
-            this.log(`✅ Detected repo info: ${repoLabel}`);
+                : this.repoInfo.projectPath || this.repoInfo.name;
+            this.log(`Detected repo info: ${repoLabel}`);
             return this.repoInfo;
         }
         catch (error) {
@@ -1055,6 +1080,44 @@ class FraimLocalMCPServer {
             request.params.arguments.sessionId = requestSessionId;
         }
     }
+    normalizeRepoContext(repo) {
+        if (!repo || typeof repo !== 'object')
+            return repo;
+        const normalized = { ...repo };
+        const detectedProvider = (0, provider_utils_1.detectProvider)(normalized.url);
+        if (typeof detectedProvider === 'string' && detectedProvider.length > 0) {
+            normalized.provider = detectedProvider;
+        }
+        if (normalized.provider !== 'gitlab')
+            return normalized;
+        if (!normalized.projectPath && typeof normalized.url === 'string') {
+            const gitlabMatch = normalized.url.match(/gitlab[^\/:]*[\/:]([^?\s#]+?)(?:\.git)?$/i);
+            if (gitlabMatch) {
+                normalized.projectPath = gitlabMatch[1].replace(/^\/+/, '');
+            }
+        }
+        if (!normalized.name && typeof normalized.projectPath === 'string') {
+            const segments = normalized.projectPath.split('/').filter(Boolean);
+            normalized.name = segments[segments.length - 1] || normalized.name;
+            normalized.namespace = normalized.namespace || segments.slice(0, -1).join('/');
+        }
+        if (normalized.projectPath || !normalized.namespace || !normalized.name)
+            return normalized;
+        normalized.projectPath = `${normalized.namespace}/${normalized.name}`;
+        return normalized;
+    }
+    normalizeIssueTrackingContext(issueTracking) {
+        if (!issueTracking || typeof issueTracking !== 'object')
+            return issueTracking;
+        if (issueTracking.provider !== 'gitlab')
+            return issueTracking;
+        if (issueTracking.projectPath || !issueTracking.namespace || !issueTracking.name)
+            return issueTracking;
+        return {
+            ...issueTracking,
+            projectPath: `${issueTracking.namespace}/${issueTracking.name}`
+        };
+    }
     /**
      * Proxy request to remote FRAIM server
      */
@@ -1083,6 +1146,7 @@ class FraimLocalMCPServer {
                         ...args.repo, // Agent values as fallback
                         ...detectedRepo // Detected values override (always win)
                     };
+                    args.repo = this.normalizeRepoContext(args.repo);
                     const repoLabel = args.repo.owner ? `${args.repo.owner}/${args.repo.name}` : args.repo.name;
                     this.log(`[req:${requestId}] Auto-detected and injected repo info: ${repoLabel}`);
                 }
@@ -1100,6 +1164,7 @@ class FraimLocalMCPServer {
                             }
                         };
                     }
+                    args.repo = this.normalizeRepoContext(args.repo);
                     const repoLabel = args.repo.owner ? `${args.repo.owner}/${args.repo.name}` : args.repo.name;
                     this.log(`[req:${requestId}] Using agent-provided repo info: ${repoLabel}`);
                 }
@@ -1109,8 +1174,12 @@ class FraimLocalMCPServer {
                         ...(args.issueTracking || {}),
                         ...configuredIssueTracking
                     };
+                    args.issueTracking = this.normalizeIssueTrackingContext(args.issueTracking);
                     this.log(`[req:${requestId}] Applied issueTracking context: ${args.issueTracking.provider || 'unknown'}`);
                 }
+                else if (args.issueTracking) {
+                    args.issueTracking = this.normalizeIssueTrackingContext(args.issueTracking);
+                }
                 const runtimeRepoContext = {
                     ...args.repo,
                     ...(args.issueTracking ? { issueTracking: args.issueTracking } : {})

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fraim-framework",
-  "version": "2.0.77",
+  "version": "2.0.78",
   "description": "FRAIM v2: Framework for Rigor-based AI Management - Transform from solo developer to AI manager orchestrating production-ready code with enterprise-grade discipline",
   "main": "index.js",
   "bin": {