fraim-framework 2.0.62 → 2.0.64

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

@@ -3,11 +3,16 @@
 /**
  * FRAIM Local MCP Server - STDIO Version
  *
- * Simple proxy that:
+ * Proxy that:
  * 1. Accepts MCP requests via stdin/stdout
  * 2. Proxies to remote FRAIM server
- * 3. Performs template substitution using local .fraim/config.json
- * 4. Returns processed content to agent
+ * 3. Performs template substitution:
+ *    - Config variables: {{config.path.to.value}}
+ *    - Platform-specific actions: {{get_issue}}, {{create_pr}}, etc.
+ * 4. Automatically detects and injects machine/repo info for fraim_connect
+ * 5. Substitutes {{delivery.*}} templates based on user's workingStyle
+ *    (PR or Conversation from ~/.fraim/config.json). Delivery phases live
+ *    server-side in the workflow; the proxy just fills in mode-specific content.
  */
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -16,6 +21,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FraimLocalMCPServer = void 0;
 const fs_1 = require("fs");
 const path_1 = require("path");
+const os_1 = require("os");
+const child_process_1 = require("child_process");
+const crypto_1 = require("crypto");
 const axios_1 = __importDefault(require("axios"));
 class FraimLocalMCPServer {
     constructor() {
@@ -23,8 +31,11 @@ class FraimLocalMCPServer {
         this.clientSupportsRoots = false;
         this.workspaceRoot = null;
         this.pendingRootsRequest = false;
+        this.machineInfo = null;
+        this.repoInfo = null;
         this.remoteUrl = process.env.FRAIM_REMOTE_URL || 'https://fraim.wellnessatwork.me';
         this.apiKey = process.env.FRAIM_API_KEY || '';
+        this.localVersion = this.detectLocalVersion();
         if (!this.apiKey) {
             this.logError('❌ FRAIM_API_KEY environment variable is required');
             process.exit(1);
@@ -32,13 +43,36 @@ class FraimLocalMCPServer {
         this.log('🚀 FRAIM Local MCP Server starting...');
         this.log(`📡 Remote server: ${this.remoteUrl}`);
         this.log(`🔑 API key: ${this.apiKey.substring(0, 10)}...`);
+        this.log(`Local MCP version: ${this.localVersion}`);
     }
     log(message) {
         // Log to stderr (stdout is reserved for MCP protocol)
-        console.error(`[FRAIM] ${message}`);
+        const key = this.apiKey || 'MISSING_API_KEY';
+        console.error(`[FRAIM key:${key}] ${message}`);
     }
     logError(message) {
-        console.error(`[FRAIM ERROR] ${message}`);
+        const key = this.apiKey || 'MISSING_API_KEY';
+        console.error(`[FRAIM ERROR key:${key}] ${message}`);
+    }
+    detectLocalVersion() {
+        const candidates = [
+            (0, path_1.join)(__dirname, '..', '..', '..', 'package.json'),
+            (0, path_1.join)(__dirname, '..', '..', 'package.json')
+        ];
+        for (const pkgPath of candidates) {
+            try {
+                if (!(0, fs_1.existsSync)(pkgPath))
+                    continue;
+                const pkg = JSON.parse((0, fs_1.readFileSync)(pkgPath, 'utf8'));
+                if (typeof pkg.version === 'string' && pkg.version.trim().length > 0) {
+                    return pkg.version;
+                }
+            }
+            catch {
+                // Ignore and try the next candidate
+            }
+        }
+        return 'unknown';
     }
     findProjectRoot() {
         // If we already have workspace root from MCP roots, use it
@@ -122,40 +156,325 @@ class FraimLocalMCPServer {
         }
     }
     /**
-     * Substitute template variables in content
-     * Replaces {{config.path.to.value}} with actual values from config
+     * Automatically detect machine information
      */
-    substituteTemplates(content) {
-        if (!this.config)
-            return content;
-        return content.replace(/\{\{config\.([^}]+)\}\}/g, (match, path) => {
+    detectMachineInfo() {
+        if (this.machineInfo) {
+            return this.machineInfo;
+        }
+        try {
+            this.machineInfo = {
+                hostname: (0, os_1.hostname)(),
+                platform: (0, os_1.platform)(),
+                memory: (0, os_1.totalmem)(),
+                cpus: (0, os_1.cpus)().length
+            };
+            this.log(`✅ Detected machine info: ${this.machineInfo.hostname} (${this.machineInfo.platform})`);
+            return this.machineInfo;
+        }
+        catch (error) {
+            this.logError(`Failed to detect machine info: ${error}`);
+            return {
+                hostname: 'unknown',
+                platform: 'unknown'
+            };
+        }
+    }
+    /**
+     * Automatically detect repository information from git
+     */
+    detectRepoInfo() {
+        if (this.repoInfo) {
+            return this.repoInfo;
+        }
+        try {
+            const projectDir = this.findProjectRoot() || process.cwd();
+            // Try to get git remote URL
+            let repoUrl = '';
             try {
-                const keys = path.split('.');
-                let value = this.config;
-                for (const key of keys) {
-                    if (value && typeof value === 'object' && key in value) {
-                        value = value[key];
+                repoUrl = (0, child_process_1.execSync)('git remote get-url origin', {
+                    cwd: projectDir,
+                    encoding: 'utf8',
+                    stdio: ['pipe', 'pipe', 'pipe']
+                }).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 {
-                        // Keep original placeholder if path not found
-                        return match;
+                    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}`;
                     }
+                    this.log(`📋 Constructed repo URL from config: ${repoUrl}`);
                 }
-                return String(value);
+            }
+            if (!repoUrl) {
+                this.log('⚠️ No git repository found and no config available');
+                return null;
+            }
+            // Parse owner and name from URL
+            let owner = '';
+            let name = '';
+            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];
+            }
+            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 (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 || '';
+            }
+            // Get current branch
+            let branch = '';
+            try {
+                branch = (0, child_process_1.execSync)('git branch --show-current', {
+                    cwd: projectDir,
+                    encoding: 'utf8',
+                    stdio: ['pipe', 'pipe', 'pipe']
+                }).trim();
             }
             catch (error) {
-                // Keep original placeholder on error
-                return match;
+                // Fall back to config default branch if available
+                if (this.config?.repository?.defaultBranch) {
+                    branch = this.config.repository.defaultBranch;
+                }
             }
+            this.repoInfo = {
+                url: repoUrl,
+                owner: owner || 'unknown',
+                name: name || 'unknown',
+                ...(organization && { organization }),
+                ...(project && { project }),
+                ...(branch && { branch })
+            };
+            this.log(`✅ Detected repo info: ${this.repoInfo.owner}/${this.repoInfo.name}`);
+            return this.repoInfo;
+        }
+        catch (error) {
+            this.logError(`Failed to detect repo info: ${error}`);
+            return null;
+        }
+    }
+    /**
+     * Get the user's working style preference from ~/.fraim/config.json
+     */
+    getWorkingStyle() {
+        try {
+            const homeDir = process.env.HOME || process.env.USERPROFILE || '';
+            const configPath = (0, path_1.join)(homeDir, '.fraim', 'config.json');
+            if ((0, fs_1.existsSync)(configPath)) {
+                const config = JSON.parse((0, fs_1.readFileSync)(configPath, 'utf8'));
+                return config.workingStyle || 'PR';
+            }
+        }
+        catch {
+            // Ignore errors, default to PR
+        }
+        return 'PR';
+    }
+    /**
+     * Substitute template variables in content
+     * Supports:
+     * 1. {{config.path.to.value}} - Config substitution
+     * 2. {{config.path.to.value | "fallback instruction"}} - With fallback
+     * 3. {{delivery.*}} - Working-style-specific delivery templates (from registry/providers/delivery-*.json)
+     * 4. Platform-specific action templates (GitHub vs ADO, from registry/providers/*.json)
+     */
+    substituteTemplates(content) {
+        let result = content;
+        // First, substitute config variables with fallback support (only if config exists)
+        if (this.config) {
+            result = result.replace(/\{\{config\.([^}|]+)(?:\s*\|\s*"([^"]+)")?\}\}/g, (match, path, fallback) => {
+                try {
+                    const value = this.getNestedValue(this.config, path.trim());
+                    if (value !== undefined) {
+                        // Config value exists - substitute it
+                        return typeof value === 'object'
+                            ? JSON.stringify(value)
+                            : String(value);
+                    }
+                    if (fallback !== undefined) {
+                        // Config value missing - use fallback instruction
+                        return fallback;
+                    }
+                    // No fallback provided - keep placeholder
+                    return match;
+                }
+                catch (error) {
+                    // On error, use fallback if provided, otherwise keep placeholder
+                    return fallback !== undefined ? fallback : match;
+                }
+            });
+        }
+        // Second, substitute {{delivery.*}} templates based on workingStyle
+        // Loaded from registry/providers/delivery-{mode}.json (same pattern as platform templates)
+        const deliveryValues = this.loadDeliveryTemplates();
+        if (deliveryValues) {
+            result = result.replace(/\{\{delivery\.([^}]+)\}\}/g, (match, key) => {
+                const value = deliveryValues[`delivery.${key.trim()}`];
+                return value !== undefined ? value : match;
+            });
+        }
+        // Third, substitute platform-specific action templates
+        // This works independently of config - only needs repo info
+        result = this.substitutePlatformActions(result);
+        return result;
+    }
+    /**
+     * Load delivery templates from registry based on workingStyle.
+     * Follows the same pattern as loadProviderTemplates (registry/providers/*.json).
+     */
+    loadDeliveryTemplates() {
+        const workingStyle = this.getWorkingStyle();
+        const filename = workingStyle === 'Conversation' ? 'delivery-conversation.json' : 'delivery-pr.json';
+        try {
+            const projectRoot = this.findProjectRoot();
+            if (projectRoot) {
+                const deliveryPath = (0, path_1.join)(projectRoot, 'registry', 'providers', filename);
+                if ((0, fs_1.existsSync)(deliveryPath)) {
+                    return JSON.parse((0, fs_1.readFileSync)(deliveryPath, 'utf-8'));
+                }
+            }
+            // Fallback: Try node_modules/@fraim/framework
+            const nodeModulesPath = (0, path_1.join)(process.cwd(), 'node_modules', '@fraim', 'framework', 'registry', 'providers', filename);
+            if ((0, fs_1.existsSync)(nodeModulesPath)) {
+                return JSON.parse((0, fs_1.readFileSync)(nodeModulesPath, 'utf-8'));
+            }
+            this.log(`⚠️ Could not find delivery templates: ${filename}`);
+            return null;
+        }
+        catch (error) {
+            this.log(`⚠️ Failed to load delivery templates: ${error.message}`);
+            return null;
+        }
+    }
+    /**
+     * Substitute platform-specific action templates
+     * Replaces {{action}} with provider-specific MCP tool calls
+     */
+    substitutePlatformActions(content) {
+        // Detect provider from repo info
+        const provider = this.detectProvider();
+        // Load provider templates
+        const templates = this.loadProviderTemplates(provider);
+        if (!templates) {
+            return content; // No templates available, return unchanged
+        }
+        let result = content;
+        // Replace {{action}} with provider-specific implementations
+        for (const [action, template] of Object.entries(templates)) {
+            const regex = new RegExp(`\\{\\{${action}\\}\\}`, 'g');
+            // Substitute repository variables in the template
+            const renderedTemplate = this.renderActionTemplate(template, provider);
+            result = result.replace(regex, renderedTemplate);
+        }
+        return result;
+    }
+    /**
+     * Detect provider from repository info
+     */
+    detectProvider() {
+        if (!this.repoInfo) {
+            return 'github'; // Default
+        }
+        const url = this.repoInfo.url || '';
+        if (url.includes('dev.azure.com') || url.includes('visualstudio.com')) {
+            return 'ado';
+        }
+        // Check config for explicit provider
+        if (this.config?.repository?.provider) {
+            return this.config.repository.provider;
+        }
+        return 'github'; // Default
+    }
+    /**
+     * Load provider templates from registry
+     */
+    loadProviderTemplates(provider) {
+        try {
+            // Try to load from project root first
+            const projectRoot = this.findProjectRoot();
+            if (projectRoot) {
+                const providerPath = (0, path_1.join)(projectRoot, 'registry', 'providers', `${provider}.json`);
+                if ((0, fs_1.existsSync)(providerPath)) {
+                    return JSON.parse((0, fs_1.readFileSync)(providerPath, 'utf-8'));
+                }
+            }
+            // Fallback: Try to load from node_modules/@fraim/framework
+            const nodeModulesPath = (0, path_1.join)(process.cwd(), 'node_modules', '@fraim', 'framework', 'registry', 'providers', `${provider}.json`);
+            if ((0, fs_1.existsSync)(nodeModulesPath)) {
+                return JSON.parse((0, fs_1.readFileSync)(nodeModulesPath, 'utf-8'));
+            }
+            this.log(`⚠️ Could not find provider templates for: ${provider}`);
+            return null;
+        }
+        catch (error) {
+            this.log(`⚠️ Failed to load provider templates: ${error.message}`);
+            return null;
+        }
+    }
+    /**
+     * Render action template with repository variables
+     */
+    renderActionTemplate(template, provider) {
+        if (!this.repoInfo && !this.config?.repository) {
+            return template; // No repo info available
+        }
+        return template.replace(/\{\{([^}]+)\}\}/g, (match, path) => {
+            const trimmedPath = path.trim();
+            // Handle repository.* variables
+            if (trimmedPath.startsWith('repository.')) {
+                const repoPath = trimmedPath.substring('repository.'.length);
+                // Try repoInfo first (from git detection)
+                if (this.repoInfo) {
+                    const value = this.getNestedValue(this.repoInfo, repoPath);
+                    if (value !== undefined)
+                        return String(value);
+                }
+                // Fallback to config
+                if (this.config?.repository) {
+                    const value = this.getNestedValue(this.config.repository, repoPath);
+                    if (value !== undefined)
+                        return String(value);
+                }
+            }
+            // Keep original placeholder if not found
+            return match;
         });
     }
+    /**
+     * Get nested value from object using dot notation
+     */
+    getNestedValue(obj, path) {
+        return path.split('.').reduce((current, key) => {
+            return current && current[key] !== undefined ? current[key] : undefined;
+        }, obj);
+    }
     /**
      * Process template substitution in MCP response
      */
     processResponse(response) {
         if (!response.result)
             return response;
-        // Process content fields that might contain templates
+        // Recursively substitute templates in all string values
         const processValue = (value) => {
             if (typeof value === 'string') {
                 return this.substituteTemplates(value);
@@ -181,24 +500,90 @@ class FraimLocalMCPServer {
      * Proxy request to remote FRAIM server
      */
     async proxyToRemote(request) {
+        const requestId = (0, crypto_1.randomUUID)();
         try {
+            // Special handling for fraim_connect - automatically inject machine and repo info
+            if (request.method === 'tools/call' && request.params?.name === 'fraim_connect') {
+                this.log(`[req:${requestId}] Intercepting fraim_connect to inject machine/repo info`);
+                const args = request.params.arguments || {};
+                // REQUIRED: Auto-detect and inject machine info
+                const detectedMachine = this.detectMachineInfo();
+                args.machine = {
+                    ...args.machine, // Agent values as fallback
+                    ...detectedMachine // Detected values override (always win)
+                };
+                this.log(`[req:${requestId}] Auto-detected and injected machine info: ${args.machine.hostname} (${args.machine.platform}), ${Math.round(args.machine.memory / 1024 / 1024 / 1024)}GB RAM, ${args.machine.cpus} CPUs`);
+                // REQUIRED: Auto-detect and inject repo info
+                const detectedRepo = this.detectRepoInfo();
+                if (detectedRepo) {
+                    args.repo = {
+                        ...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}`);
+                }
+                else {
+                    // If detection fails completely, return error instead of sending garbage
+                    this.logError(`[req:${requestId}] Could not detect repo info and no config available`);
+                    return {
+                        jsonrpc: '2.0',
+                        id: request.id,
+                        error: {
+                            code: -32603,
+                            message: 'Failed to detect repository information. Please ensure you are in a git repository or have .fraim/config.json configured with repository details.'
+                        }
+                    };
+                }
+                // Update the request with injected info
+                request.params.arguments = args;
+            }
+            this.log(`[req:${requestId}] Proxying ${request.method} to ${this.remoteUrl}/mcp`);
             const response = await axios_1.default.post(`${this.remoteUrl}/mcp`, request, {
                 headers: {
                     'Content-Type': 'application/json',
-                    'x-api-key': this.apiKey
+                    'x-api-key': this.apiKey,
+                    'x-fraim-request-id': requestId,
+                    'x-fraim-local-version': this.localVersion
                 },
                 timeout: 30000
             });
             return response.data;
         }
         catch (error) {
-            this.logError(`Remote request failed: ${error.message}`);
+            const status = error?.response?.status;
+            const remoteData = error?.response?.data;
+            this.logError(`[req:${requestId}] Remote request failed (${status || 'no-status'}): ${error.message}`);
+            if (remoteData && typeof remoteData === 'object') {
+                const forwarded = {
+                    jsonrpc: typeof remoteData.jsonrpc === 'string' ? remoteData.jsonrpc : '2.0',
+                    id: remoteData.id ?? request.id,
+                    error: remoteData.error ?? {
+                        code: -32603,
+                        message: `Remote server error (${status || 'unknown status'}): ${error.message}`
+                    }
+                };
+                if (forwarded.error && typeof forwarded.error === 'object') {
+                    const existingData = forwarded.error.data;
+                    forwarded.error.data = {
+                        ...(existingData && typeof existingData === 'object' ? existingData : {}),
+                        fraimRequestId: requestId,
+                        remoteStatus: status ?? null,
+                        localMcpVersion: this.localVersion
+                    };
+                }
+                return forwarded;
+            }
             return {
                 jsonrpc: '2.0',
                 id: request.id,
                 error: {
                     code: -32603,
-                    message: `Remote server error: ${error.message}`
+                    message: `Remote server error: ${error.message}`,
+                    data: {
+                        fraimRequestId: requestId,
+                        remoteStatus: status ?? null,
+                        localMcpVersion: this.localVersion
+                    }
                 }
             };
         }
@@ -257,7 +642,7 @@ class FraimLocalMCPServer {
         }
         // Proxy to remote server
         const response = await this.proxyToRemote(request);
-        // Process template substitution
+        // Process template substitution (config vars, platform actions, delivery templates)
         const processedResponse = this.processResponse(response);
         this.log(`📤 ${request.method} → ${processedResponse.error ? 'ERROR' : 'OK'}`);
         return processedResponse;