fraim-framework 2.0.83 → 2.0.85

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

@@ -227,10 +227,11 @@ class FraimLocalMCPServer {
         this.pendingFallbackEvents = [];
         this.fallbackSummaryEmitted = false;
         this.remoteUrl = process.env.FRAIM_REMOTE_URL || 'https://fraim.wellnessatwork.me';
-        this.apiKey = process.env.FRAIM_API_KEY || '';
+        this.apiKey = this.loadApiKey();
         this.localVersion = this.detectLocalVersion();
         if (!this.apiKey) {
-            this.logError('❌ FRAIM_API_KEY environment variable is required');
+            this.logError('❌ FRAIM API key is required');
+            this.logError('   Set FRAIM_API_KEY environment variable or add apiKey to ~/.fraim/config.json');
             process.exit(1);
         }
         this.log('🚀 FRAIM Local MCP Server starting... [DEBUG-PROXY-V3]');
@@ -239,6 +240,33 @@ class FraimLocalMCPServer {
         this.log(`Local MCP version: ${this.localVersion}`);
         this.log(`🔍 DEBUG BUILD: Machine detection v2 active`);
     }
+    /**
+     * Load API key from environment variable or user config file
+     * Priority: FRAIM_API_KEY env var > ~/.fraim/config.json
+     */
+    loadApiKey() {
+        // First try environment variable (for IDE MCP configs)
+        if (process.env.FRAIM_API_KEY) {
+            return process.env.FRAIM_API_KEY;
+        }
+        // Fallback to user config file
+        try {
+            const homeDir = process.env.HOME || process.env.USERPROFILE || '';
+            if (!homeDir)
+                return '';
+            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'));
+                if (config.apiKey) {
+                    return config.apiKey;
+                }
+            }
+        }
+        catch (error) {
+            // Ignore errors, will fail with clear message below
+        }
+        return '';
+    }
     log(message) {
         // Log to stderr (stdout is reserved for MCP protocol)
         const key = this.apiKey || 'MISSING_API_KEY';
@@ -736,37 +764,9 @@ class FraimLocalMCPServer {
                 if (parsed) {
                     engine.setProviderTemplates(provider, parsed);
                     this.writeCachedTemplateFile(filename, parsed);
-                    continue;
-                }
-            }
-            const bundled = this.readBundledTemplateFile(filename);
-            if (bundled) {
-                engine.setProviderTemplates(provider, bundled);
-            }
-        }
-    }
-    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)
@@ -790,6 +790,45 @@ class FraimLocalMCPServer {
         }
         return this.applyAgentFallbackForUnresolvedProxy(processedResponse);
     }
+    shouldResolveIncludes(toolName) {
+        return toolName === 'get_fraim_workflow' ||
+            toolName === 'get_fraim_job' ||
+            toolName === 'get_fraim_file' ||
+            toolName === 'seekMentoring';
+    }
+    async resolveIncludesInResponse(response, requestSessionId) {
+        if (!response.result?.content || !Array.isArray(response.result.content)) {
+            return response;
+        }
+        const resolver = this.getRegistryResolver(requestSessionId);
+        const transformedContent = [];
+        for (const block of response.result.content) {
+            if (block?.type !== 'text' || typeof block.text !== 'string') {
+                transformedContent.push(block);
+                continue;
+            }
+            const resolvedText = await resolver.resolveIncludes(block.text);
+            transformedContent.push({
+                ...block,
+                text: resolvedText
+            });
+        }
+        return {
+            ...response,
+            result: {
+                ...response.result,
+                content: transformedContent
+            }
+        };
+    }
+    async finalizeToolResponse(request, response, requestSessionId) {
+        let finalizedResponse = response;
+        const toolName = request.params?.name;
+        if (request.method === 'tools/call' && typeof toolName === 'string' && this.shouldResolveIncludes(toolName)) {
+            finalizedResponse = await this.resolveIncludesInResponse(finalizedResponse, requestSessionId);
+        }
+        return this.processResponseWithHydration(finalizedResponse, requestSessionId);
+    }
     rewriteProxyTokensInText(text) {
         const tokens = new Set();
         const rewritten = text.replace(/\{\{\s*proxy\.([^}]+?)\s*\}\}/g, (_match, proxyPath) => {
@@ -861,35 +900,19 @@ class FraimLocalMCPServer {
                 remoteContentResolver: async (path) => {
                     // Fetch parent content from remote for inheritance
                     this.log(`🔄 Remote content resolver: fetching ${path}`);
-                    let request;
-                    if (path.startsWith('workflows/')) {
-                        // Extract workflow name from path: workflows/category/name.md -> name
-                        const pathParts = path.replace('workflows/', '').replace('.md', '').split('/');
-                        const workflowName = pathParts[pathParts.length - 1]; // Get last part (name)
-                        this.log(`🔄 Fetching workflow: ${workflowName}`);
-                        request = {
-                            jsonrpc: '2.0',
-                            id: (0, crypto_1.randomUUID)(),
-                            method: 'tools/call',
-                            params: {
-                                name: 'get_fraim_workflow',
-                                arguments: { workflow: workflowName }
-                            }
-                        };
-                    }
-                    else {
-                        // For non-workflow files (templates, rules, etc.), use get_fraim_file
-                        this.log(`🔄 Fetching file: ${path}`);
-                        request = {
-                            jsonrpc: '2.0',
-                            id: (0, crypto_1.randomUUID)(),
-                            method: 'tools/call',
-                            params: {
-                                name: 'get_fraim_file',
-                                arguments: { path }
+                    this.log(`🔄 Fetching raw file content: ${path}`);
+                    const request = {
+                        jsonrpc: '2.0',
+                        id: (0, crypto_1.randomUUID)(),
+                        method: 'tools/call',
+                        params: {
+                            name: 'get_fraim_file',
+                            arguments: {
+                                path,
+                                _internalRaw: true
                             }
-                        };
-                    }
+                        }
+                    };
                     this.applyRequestSessionId(request, requestSessionId);
                     const response = await this.proxyToRemote(request);
                     if (response.error) {
@@ -943,6 +966,38 @@ class FraimLocalMCPServer {
         // Default to product-building for unknown workflows
         return 'product-building';
     }
+    /**
+     * Find local override path for a job name by scanning override roots.
+     * Returns a registry-style path like jobs/<category>/<name>.md when found.
+     */
+    findJobOverridePath(jobName) {
+        const projectRoot = this.findProjectRoot();
+        if (!projectRoot)
+            return null;
+        const candidates = [
+            (0, path_1.join)(projectRoot, '.fraim', 'personalized-employee', 'jobs'),
+            (0, path_1.join)(projectRoot, '.fraim', 'overrides', 'jobs')
+        ];
+        for (const jobsRoot of candidates) {
+            if (!(0, fs_1.existsSync)(jobsRoot))
+                continue;
+            try {
+                const categories = (0, fs_1.readdirSync)(jobsRoot, { withFileTypes: true })
+                    .filter(entry => entry.isDirectory())
+                    .map(entry => entry.name);
+                for (const category of categories) {
+                    const jobFilePath = (0, path_1.join)(jobsRoot, category, `${jobName}.md`);
+                    if ((0, fs_1.existsSync)(jobFilePath)) {
+                        return `jobs/${category}/${jobName}.md`;
+                    }
+                }
+            }
+            catch {
+                // Best effort scan only.
+            }
+        }
+        return null;
+    }
     /**
      * Process template substitution in MCP response
      */
@@ -1305,7 +1360,7 @@ class FraimLocalMCPServer {
             }
             // Proxy initialize to remote server first
             const response = await this.proxyToRemote(request);
-            const processedResponse = await this.processResponseWithHydration(response, requestSessionId);
+            const processedResponse = await this.finalizeToolResponse(request, response, requestSessionId);
             // After successful initialization, load config
             if (!processedResponse.error) {
                 // Load config immediately for compatibility, then request roots so
@@ -1318,9 +1373,10 @@ class FraimLocalMCPServer {
             this.log(`📤 ${request.method} → ${processedResponse.error ? 'ERROR' : 'OK'}`);
             return processedResponse;
         }
-        // Intercept get_fraim_workflow and get_fraim_file for override resolution
+        // Intercept get_fraim_workflow, get_fraim_job, and get_fraim_file for override resolution
         if (request.method === 'tools/call' &&
             (request.params?.name === 'get_fraim_workflow' ||
+                request.params?.name === 'get_fraim_job' ||
                 request.params?.name === 'get_fraim_file')) {
             try {
                 const toolName = request.params.name;
@@ -1359,7 +1415,41 @@ class FraimLocalMCPServer {
                                 }
                             };
                             // Apply template substitution
-                            const processedResponse = await this.processResponseWithHydration(response, requestSessionId);
+                            const processedResponse = await this.finalizeToolResponse(request, response, requestSessionId);
+                            this.log(`📤 ${request.method} → OK`);
+                            return processedResponse;
+                        }
+                    }
+                }
+                else if (toolName === 'get_fraim_job') {
+                    const jobName = args.job;
+                    if (!jobName) {
+                        this.log('⚠️ No job name provided in get_fraim_job');
+                    }
+                    else {
+                        // Determine job path by scanning local override roots.
+                        requestedPath = this.findJobOverridePath(jobName) || `jobs/product-building/${jobName}.md`;
+                        this.log(`🔍 Checking for override: ${requestedPath}`);
+                        const resolver = this.getRegistryResolver(requestSessionId);
+                        const hasOverride = resolver.hasLocalOverride(requestedPath);
+                        this.log(`🔍 hasLocalOverride(${requestedPath}) = ${hasOverride}`);
+                        if (hasOverride) {
+                            this.log(`✅ Local override found: ${requestedPath}`);
+                            const resolved = await resolver.resolveFile(requestedPath);
+                            this.log(`📝 Override resolved (source: ${resolved.source}, inherited: ${resolved.inherited})`);
+                            const response = {
+                                jsonrpc: '2.0',
+                                id: request.id,
+                                result: {
+                                    content: [
+                                        {
+                                            type: 'text',
+                                            text: resolved.content
+                                        }
+                                    ]
+                                }
+                            };
+                            const processedResponse = await this.finalizeToolResponse(request, response, requestSessionId);
                             this.log(`📤 ${request.method} → OK`);
                             return processedResponse;
                         }
@@ -1378,6 +1468,27 @@ class FraimLocalMCPServer {
                         else {
                             this.log(`🔍 Checking for override: ${requestedPath}`);
                             const resolver = this.getRegistryResolver(requestSessionId);
+                            const isLocalFirstSyncedPath = requestedPath.startsWith('skills/') || requestedPath.startsWith('rules/');
+                            if (isLocalFirstSyncedPath && resolver.hasSyncedLocalFile(requestedPath)) {
+                                this.log(`✅ Synced local file found: ${requestedPath}`);
+                                const resolved = await resolver.resolveFile(requestedPath, { includeMetadata: false });
+                                this.log(`📝 Synced local file resolved (source: ${resolved.source}, inherited: ${resolved.inherited})`);
+                                const response = {
+                                    jsonrpc: '2.0',
+                                    id: request.id,
+                                    result: {
+                                        content: [
+                                            {
+                                                type: 'text',
+                                                text: resolved.content
+                                            }
+                                        ]
+                                    }
+                                };
+                                const processedResponse = await this.finalizeToolResponse(request, response, requestSessionId);
+                                this.log(`📤 ${request.method} → OK`);
+                                return processedResponse;
+                            }
                             const hasOverride = resolver.hasLocalOverride(requestedPath);
                             this.log(`🔍 hasLocalOverride(${requestedPath}) = ${hasOverride}`);
                             if (hasOverride) {
@@ -1398,7 +1509,7 @@ class FraimLocalMCPServer {
                                     }
                                 };
                                 // Apply template substitution
-                                const processedResponse = await this.processResponseWithHydration(response, requestSessionId);
+                                const processedResponse = await this.finalizeToolResponse(request, response, requestSessionId);
                                 this.log(`📤 ${request.method} → OK`);
                                 return processedResponse;
                             }
@@ -1414,7 +1525,7 @@ class FraimLocalMCPServer {
         }
         // Proxy to remote server
         const response = await this.proxyToRemote(request);
-        const processedResponse = await this.processResponseWithHydration(response, requestSessionId);
+        const processedResponse = await this.finalizeToolResponse(request, response, requestSessionId);
         this.log(`📤 ${request.method} → ${processedResponse.error ? 'ERROR' : 'OK'}`);
         return processedResponse;
     }

package/index.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 /**
  * FRAIM Framework - Smart Entry Point

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fraim-framework",
-  "version": "2.0.83",
+  "version": "2.0.85",
   "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": {
@@ -16,6 +16,7 @@
     "test-all": "npm run test && npm run test:isolated && npm run test:ui",
     "test": "node scripts/test-with-server.js",
     "test:isolated": "npx tsx --test --test-reporter=spec tests/isolated/test-*.ts",
+    "test:smoke": "node scripts/test-with-server.js tests/test-*.ts --tags=smoke",
     "test:ui": "playwright test",
     "test:ui:headed": "playwright test --headed",
     "start:fraim": "tsx src/fraim-mcp-server.ts",
@@ -29,14 +30,16 @@
     "postinstall": "fraim sync --skip-updates || echo 'FRAIM setup skipped.'",
     "prepublishOnly": "npm run build",
     "release": "npm version patch && npm publish",
-    "validate:registry": "tsx scripts/verify-registry-paths.ts && npm run validate:workflows && npm run validate:skills && npm run validate:platform-agnostic && npm run validate:template-namespaces && npm run validate:config-fallbacks && npm run validate:bootstrap-config-coverage && npm run validate:provider-action-mappings",
+    "validate:registry": "tsx scripts/verify-registry-paths.ts && npm run validate:workflows && npm run validate:skills && npm run validate:platform-agnostic && npm run validate:template-namespaces && npm run validate:config-fallbacks && npm run validate:bootstrap-config-coverage && npm run validate:provider-action-mappings && npm run validate:fidelity && npm run validate:config-tokens",
     "validate:workflows": "tsx scripts/validate-workflows.ts",
     "validate:platform-agnostic": "tsx scripts/validate-platform-agnostic.ts",
     "validate:skills": "tsx scripts/validate-skills.ts",
     "validate:template-namespaces": "tsx scripts/validate-template-namespaces.ts",
     "validate:config-fallbacks": "tsx scripts/validate-config-fallbacks.ts",
     "validate:bootstrap-config-coverage": "tsx scripts/validate-bootstrap-config-coverage.ts",
-    "validate:provider-action-mappings": "tsx scripts/validate-provider-action-mappings.ts"
+    "validate:provider-action-mappings": "tsx scripts/validate-provider-action-mappings.ts",
+    "validate:fidelity": "tsx scripts/validate-fidelity.ts",
+    "validate:config-tokens": "tsx scripts/validate-config-tokens.ts"
   },
   "repository": {
     "type": "git",