fraim-framework 2.0.76 → 2.0.78

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

@@ -106,19 +106,49 @@ class FraimTemplateEngine {
         return null;
     }
     substitutePlatformActions(content) {
-        const provider = (0, provider_utils_1.detectProvider)(this.repoInfo?.url);
-        const templates = this.loadProviderTemplates(provider);
-        if (!templates)
-            return content;
+        const codeProvider = this.getCodeProvider();
+        const issueProvider = this.getIssueProvider();
+        const codeTemplates = this.loadProviderTemplates(codeProvider);
+        const issueTemplates = issueProvider ? this.loadProviderTemplates(issueProvider) : null;
         let result = content;
-        for (const [action, template] of Object.entries(templates)) {
-            const escapedAction = action.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-            const regex = new RegExp(`\\{\\{${FraimTemplateEngine.PROXY_ACTION_PREFIX}${escapedAction}\\}\\}`, 'g');
-            const renderedTemplate = this.renderActionTemplate(template);
-            result = result.replace(regex, renderedTemplate);
+        if (issueTemplates) {
+            for (const [action, template] of Object.entries(issueTemplates)) {
+                if (!FraimTemplateEngine.ISSUE_ACTIONS.has(action))
+                    continue;
+                const escapedAction = action.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+                const regex = new RegExp(`\\{\\{${FraimTemplateEngine.PROXY_ACTION_PREFIX}${escapedAction}\\}\\}`, 'g');
+                result = result.replace(regex, this.renderActionTemplate(template));
+            }
+        }
+        if (codeTemplates) {
+            for (const [action, template] of Object.entries(codeTemplates)) {
+                if (issueProvider && issueProvider !== codeProvider && FraimTemplateEngine.ISSUE_ACTIONS.has(action))
+                    continue;
+                const escapedAction = action.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+                const regex = new RegExp(`\\{\\{${FraimTemplateEngine.PROXY_ACTION_PREFIX}${escapedAction}\\}\\}`, 'g');
+                result = result.replace(regex, this.renderActionTemplate(template));
+            }
         }
         return result;
     }
+    getCodeProvider() {
+        const repoProvider = this.repoInfo?.provider || this.config?.repository?.provider;
+        if (typeof repoProvider === 'string' && repoProvider.trim().length > 0) {
+            return repoProvider;
+        }
+        return (0, provider_utils_1.detectProvider)(this.repoInfo?.url || this.config?.repository?.url);
+    }
+    getIssueProvider() {
+        const fromRepoInfo = this.repoInfo?.issueTracking?.provider;
+        if (typeof fromRepoInfo === 'string' && fromRepoInfo.trim().length > 0) {
+            return fromRepoInfo;
+        }
+        const fromConfig = this.config?.issueTracking?.provider;
+        if (typeof fromConfig === 'string' && fromConfig.trim().length > 0) {
+            return fromConfig;
+        }
+        return null;
+    }
     loadProviderTemplates(provider) {
         if (this.providerTemplatesCache[provider])
             return this.providerTemplatesCache[provider];
@@ -130,11 +160,12 @@ class FraimTemplateEngine {
         return null;
     }
     renderActionTemplate(template) {
-        if (!this.repoInfo && !this.config?.repository) {
+        if (!this.repoInfo && !this.config?.repository && !this.config?.issueTracking) {
             return template;
         }
         return template.replace(/\{\{([^}]+)\}\}/g, (match, path) => {
             const trimmedPath = path.trim();
+            // Handle proxy.repository.* variables
             if (trimmedPath.startsWith('proxy.repository.')) {
                 const repoPath = trimmedPath.substring('proxy.repository.'.length);
                 if (this.repoInfo) {
@@ -148,12 +179,36 @@ class FraimTemplateEngine {
                         return String(value);
                 }
             }
+            // Handle proxy.issueTracking.* variables (for split provider mode)
+            if (trimmedPath.startsWith('proxy.issueTracking.')) {
+                const issueTrackingPath = trimmedPath.substring('proxy.issueTracking.'.length);
+                if (this.repoInfo?.issueTracking) {
+                    const value = (0, object_utils_1.getNestedValue)(this.repoInfo.issueTracking, issueTrackingPath);
+                    if (value !== undefined)
+                        return String(value);
+                }
+                if (this.config?.issueTracking) {
+                    const value = (0, object_utils_1.getNestedValue)(this.config.issueTracking, issueTrackingPath);
+                    if (value !== undefined)
+                        return String(value);
+                }
+            }
             return match;
         });
     }
 }
 exports.FraimTemplateEngine = FraimTemplateEngine;
 FraimTemplateEngine.PROXY_ACTION_PREFIX = 'proxy.action.';
+FraimTemplateEngine.ISSUE_ACTIONS = new Set([
+    'get_issue',
+    'update_issue_status',
+    'add_issue_comment',
+    'create_issue',
+    'assign_issue',
+    'search_issues',
+    'close_issue',
+    'list_issues'
+]);
 class FraimLocalMCPServer {
     constructor() {
         this.config = null;
@@ -365,48 +420,71 @@ class FraimLocalMCPServer {
                 }).trim();
             }
             catch (error) {
-                // If git command fails, construct URL from config if available
-                if (this.config?.repository?.owner && this.config?.repository?.name) {
-                    const provider = this.config.repository.provider || 'github';
-                    if (provider === 'github') {
-                        repoUrl = `https://github.com/${this.config.repository.owner}/${this.config.repository.name}.git`;
-                    }
-                    else if (provider === 'ado') {
-                        // Azure DevOps URL format
-                        repoUrl = `https://dev.azure.com/${this.config.repository.owner}/${this.config.repository.name}/_git/${this.config.repository.name}`;
+                // If git command fails, construct URL from config if available.
+                const repositoryConfig = this.config?.repository;
+                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}`);
+                }
+                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}`);
+                }
+                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}`);
                     }
-                    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
-            let owner = '';
+            // Parse repository identity from URL
             let name = '';
+            let owner = '';
             let organization = '';
             let project = '';
-            // 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];
-                owner = organization; // For compatibility
                 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 = '';
@@ -423,15 +501,23 @@ class FraimLocalMCPServer {
                     branch = this.config.repository.defaultBranch;
                 }
             }
-            this.repoInfo = {
+            const repoInfo = {
                 url: repoUrl,
-                owner: owner || 'unknown',
                 name: name || 'unknown',
                 ...(organization && { organization }),
                 ...(project && { project }),
+                ...(namespace && { namespace }),
+                ...(projectPath && { projectPath }),
                 ...(branch && { branch })
             };
-            this.log(`✅ Detected repo info: ${this.repoInfo.owner}/${this.repoInfo.name}`);
+            if (owner) {
+                repoInfo.owner = owner;
+            }
+            this.repoInfo = repoInfo;
+            const repoLabel = this.repoInfo.owner
+                ? `${this.repoInfo.owner}/${this.repoInfo.name}`
+                : this.repoInfo.projectPath || this.repoInfo.name;
+            this.log(`Detected repo info: ${repoLabel}`);
             return this.repoInfo;
         }
         catch (error) {
@@ -630,25 +716,57 @@ class FraimLocalMCPServer {
         if (!hasDirectProviderPlaceholders && !hasDeliveryPlaceholders)
             return;
         const engine = this.ensureEngine();
-        const provider = (0, provider_utils_1.detectProvider)(this.detectRepoInfo()?.url);
-        if (engine.hasProviderTemplates(provider))
-            return;
-        if (engine.loadProviderTemplates(provider))
-            return;
-        const filename = `${provider}.json`;
-        const cached = this.readCachedTemplateFile(filename);
-        if (cached) {
-            engine.setProviderTemplates(provider, cached);
-            return;
+        const codeProvider = engine.getCodeProvider();
+        const issueProvider = engine.getIssueProvider();
+        const providers = Array.from(new Set([codeProvider, issueProvider].filter((provider) => typeof provider === 'string' && provider.length > 0)));
+        for (const provider of providers) {
+            if (engine.hasProviderTemplates(provider))
+                continue;
+            if (engine.loadProviderTemplates(provider))
+                continue;
+            const filename = `${provider}.json`;
+            const cached = this.readCachedTemplateFile(filename);
+            if (cached) {
+                engine.setProviderTemplates(provider, cached);
+                continue;
+            }
+            const remoteContent = await this.fetchRegistryFileFromServer(`providers/${filename}`, requestSessionId);
+            if (remoteContent) {
+                const parsed = this.parseTemplateJson(remoteContent, `providers/${filename}`);
+                if (parsed) {
+                    engine.setProviderTemplates(provider, parsed);
+                    this.writeCachedTemplateFile(filename, parsed);
+                    continue;
+                }
+            }
+            const bundled = this.readBundledTemplateFile(filename);
+            if (bundled) {
+                engine.setProviderTemplates(provider, bundled);
+            }
         }
-        const remoteContent = await this.fetchRegistryFileFromServer(`providers/${filename}`, requestSessionId);
-        if (!remoteContent)
-            return;
-        const parsed = this.parseTemplateJson(remoteContent, `providers/${filename}`);
-        if (!parsed)
-            return;
-        engine.setProviderTemplates(provider, parsed);
-        this.writeCachedTemplateFile(filename, parsed);
+    }
+    readBundledTemplateFile(filename) {
+        const candidates = [
+            (0, path_1.join)(__dirname, '..', '..', '..', 'registry', 'providers', filename),
+            (0, path_1.join)(__dirname, '..', '..', 'registry', 'providers', filename),
+            (0, path_1.join)(process.cwd(), 'registry', 'providers', filename)
+        ];
+        for (const candidate of candidates) {
+            try {
+                if (!(0, fs_1.existsSync)(candidate))
+                    continue;
+                const content = (0, fs_1.readFileSync)(candidate, 'utf8');
+                const parsed = JSON.parse(content);
+                if (parsed && typeof parsed === 'object') {
+                    this.log(`✅ Loaded bundled provider template: ${candidate}`);
+                    return parsed;
+                }
+            }
+            catch (error) {
+                this.log(`⚠️ Failed to load bundled template ${candidate}: ${error.message}`);
+            }
+        }
+        return null;
     }
     async hydrateTemplateCachesForResponse(response, requestSessionId) {
         if (!response.result)
@@ -661,10 +779,12 @@ class FraimLocalMCPServer {
         let processedResponse = this.processResponse(response);
         // Delivery substitution can introduce provider action placeholders (e.g. {{proxy.action.update_issue_status}})
         // that were not visible pre-substitution. Run one targeted re-hydration pass if needed.
-        const provider = (0, provider_utils_1.detectProvider)(this.detectRepoInfo()?.url);
         const engine = this.ensureEngine();
-        if (this.responseHasPotentialProviderPlaceholders(processedResponse) &&
-            !engine.hasProviderTemplates(provider)) {
+        const codeProvider = engine.getCodeProvider();
+        const issueProvider = engine.getIssueProvider();
+        const providers = Array.from(new Set([codeProvider, issueProvider].filter((provider) => typeof provider === 'string' && provider.length > 0)));
+        const hasMissingProviderTemplate = providers.some((provider) => !engine.hasProviderTemplates(provider));
+        if (this.responseHasPotentialProviderPlaceholders(processedResponse) && hasMissingProviderTemplate) {
             await this.ensureProviderTemplatesAvailable(processedResponse, requestSessionId);
             processedResponse = this.processResponse(processedResponse);
         }
@@ -960,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
      */
@@ -988,7 +1146,9 @@ class FraimLocalMCPServer {
                         ...args.repo, // Agent values as fallback
                         ...detectedRepo // Detected values override (always win)
                     };
-                    this.log(`[req:${requestId}] Auto-detected and injected repo info: ${args.repo.owner}/${args.repo.name}`);
+                    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}`);
                 }
                 else {
                     // If detection fails, use agent-provided values (if any)
@@ -1004,12 +1164,30 @@ class FraimLocalMCPServer {
                             }
                         };
                     }
-                    this.log(`[req:${requestId}] Using agent-provided repo info: ${args.repo.owner}/${args.repo.name}`);
+                    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}`);
                 }
+                const configuredIssueTracking = this.config?.issueTracking;
+                if (configuredIssueTracking && typeof configuredIssueTracking === 'object') {
+                    args.issueTracking = {
+                        ...(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 } : {})
+                };
                 // Keep proxy runtime repository context in sync with connect payload.
-                this.repoInfo = args.repo;
+                this.repoInfo = runtimeRepoContext;
                 if (this.engine) {
-                    this.engine.setRepoInfo(args.repo);
+                    this.engine.setRepoInfo(runtimeRepoContext);
                 }
                 // Update the request with injected info
                 request.params.arguments = args;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fraim-framework",
-  "version": "2.0.76",
+  "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": {