fraim-framework 2.0.76 → 2.0.78

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

@@ -46,6 +46,9 @@ function loadFraimConfig() {
                 ...(config.customizations || {})
             }
         };
+        if (config.issueTracking && typeof config.issueTracking === 'object') {
+            mergedConfig.issueTracking = config.issueTracking;
+        }
         // Add optional workflow-driven fields only if they exist in the config
         if (config.compliance) {
             mergedConfig.compliance = config.compliance;
@@ -92,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';