fraim-framework 2.0.59 → 2.0.62

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

@@ -20,13 +20,15 @@ const axios_1 = __importDefault(require("axios"));
 class FraimLocalMCPServer {
     constructor() {
         this.config = null;
+        this.clientSupportsRoots = false;
+        this.workspaceRoot = null;
+        this.pendingRootsRequest = false;
         this.remoteUrl = process.env.FRAIM_REMOTE_URL || 'https://fraim.wellnessatwork.me';
         this.apiKey = process.env.FRAIM_API_KEY || '';
         if (!this.apiKey) {
             this.logError('❌ FRAIM_API_KEY environment variable is required');
             process.exit(1);
         }
-        this.loadConfig();
         this.log('🚀 FRAIM Local MCP Server starting...');
         this.log(`📡 Remote server: ${this.remoteUrl}`);
         this.log(`🔑 API key: ${this.apiKey.substring(0, 10)}...`);
@@ -39,20 +41,68 @@ class FraimLocalMCPServer {
         console.error(`[FRAIM ERROR] ${message}`);
     }
     findProjectRoot() {
-        // Start from cwd and search upwards for .fraim directory
+        // If we already have workspace root from MCP roots, use it
+        if (this.workspaceRoot) {
+            this.log(`✅ Using workspace root from MCP roots: ${this.workspaceRoot}`);
+            return this.workspaceRoot;
+        }
+        // Log all potentially useful environment variables for debugging
+        this.log(`🔍 Environment variables:`);
+        this.log(`   WORKSPACE_FOLDER_PATHS: ${process.env.WORKSPACE_FOLDER_PATHS || '(not set)'}`);
+        this.log(`   WORKSPACE_FOLDER: ${process.env.WORKSPACE_FOLDER || '(not set)'}`);
+        this.log(`   PROJECT_ROOT: ${process.env.PROJECT_ROOT || '(not set)'}`);
+        this.log(`   VSCODE_CWD: ${process.env.VSCODE_CWD || '(not set)'}`);
+        this.log(`   INIT_CWD: ${process.env.INIT_CWD || '(not set)'}`);
+        this.log(`   HOME: ${process.env.HOME || '(not set)'}`);
+        this.log(`   USERPROFILE: ${process.env.USERPROFILE || '(not set)'}`);
+        // Priority 1: Check for IDE-provided workspace environment variables
+        const workspaceHints = [
+            process.env.WORKSPACE_FOLDER_PATHS?.split(':')[0], // Cursor provides this (colon-separated for multi-root)
+            process.env.WORKSPACE_FOLDER, // VSCode and others
+            process.env.PROJECT_ROOT,
+            process.env.VSCODE_CWD,
+            process.env.INIT_CWD,
+        ];
+        for (const hint of workspaceHints) {
+            if (hint && (0, fs_1.existsSync)((0, path_1.join)(hint, '.fraim'))) {
+                this.log(`✅ Found .fraim via workspace env var: ${hint}`);
+                return hint;
+            }
+        }
+        // Priority 2: Search upwards from cwd, but skip home directory
         let currentDir = process.cwd();
         const root = (0, path_1.parse)(currentDir).root;
+        const homeDir = process.env.HOME || process.env.USERPROFILE;
+        this.log(`🔍 Starting search from: ${currentDir}`);
+        if (homeDir) {
+            this.log(`🏠 Home directory (will skip): ${homeDir}`);
+        }
         while (currentDir !== root) {
             const fraimDir = (0, path_1.join)(currentDir, '.fraim');
+            this.log(`   Checking: ${fraimDir}`);
             if ((0, fs_1.existsSync)(fraimDir)) {
+                // Skip home directory .fraim - continue searching for project-specific one
+                if (homeDir && currentDir === homeDir) {
+                    this.log(`   ⚠️  Skipping home directory .fraim, continuing search...`);
+                    currentDir = (0, path_1.dirname)(currentDir);
+                    continue;
+                }
+                this.log(`✅ Found .fraim at: ${currentDir}`);
                 return currentDir;
             }
             currentDir = (0, path_1.dirname)(currentDir);
         }
+        // Priority 3: Fall back to home directory .fraim if nothing else found
+        if (homeDir && (0, fs_1.existsSync)((0, path_1.join)(homeDir, '.fraim'))) {
+            this.log(`⚠️  Using home directory .fraim as fallback: ${homeDir}`);
+            return homeDir;
+        }
+        this.log(`❌ No .fraim directory found`);
         return null;
     }
     loadConfig() {
         try {
+            this.log(`📍 Process started from: ${process.cwd()}`);
             // Try to find project root by searching for .fraim directory
             const projectDir = this.findProjectRoot() || process.cwd();
             const configPath = (0, path_1.join)(projectDir, '.fraim', 'config.json');
@@ -153,11 +203,58 @@ class FraimLocalMCPServer {
             };
         }
     }
+    /**
+     * Try to request workspace roots from MCP client
+     */
+    requestRootsFromClient() {
+        if (!this.clientSupportsRoots || this.pendingRootsRequest) {
+            return;
+        }
+        try {
+            this.log('🔍 Requesting workspace roots from client...');
+            this.pendingRootsRequest = true;
+            // Send roots/list request to client via stdout
+            const rootsRequest = {
+                jsonrpc: '2.0',
+                id: 'fraim-roots-query',
+                method: 'roots/list',
+                params: {}
+            };
+            this.log(`📤 Sending roots/list request: ${JSON.stringify(rootsRequest)}`);
+            process.stdout.write(JSON.stringify(rootsRequest) + '\n');
+        }
+        catch (error) {
+            this.log(`⚠️  Failed to request roots: ${error.message}`);
+            this.pendingRootsRequest = false;
+            // Fall back to env var search
+            this.loadConfig();
+        }
+    }
     /**
      * Handle incoming MCP request
      */
     async handleRequest(request) {
         this.log(`📥 ${request.method}`);
+        // Special handling for initialize request
+        if (request.method === 'initialize') {
+            // Check if client supports roots
+            const clientCapabilities = request.params?.capabilities;
+            if (clientCapabilities?.roots) {
+                this.clientSupportsRoots = true;
+                this.log(`✅ Client supports roots capability (listChanged: ${clientCapabilities.roots.listChanged})`);
+            }
+            // Proxy initialize to remote server first
+            const response = await this.proxyToRemote(request);
+            const processedResponse = this.processResponse(response);
+            // After successful initialization, load config using fallback methods
+            if (!processedResponse.error) {
+                // For now, don't request roots - just use env var + upward search
+                // TODO: Implement roots/list properly after initialization is complete
+                this.loadConfig();
+            }
+            this.log(`📤 ${request.method} → ${processedResponse.error ? 'ERROR' : 'OK'}`);
+            return processedResponse;
+        }
         // Proxy to remote server
         const response = await this.proxyToRemote(request);
         // Process template substitution
@@ -165,6 +262,47 @@ class FraimLocalMCPServer {
         this.log(`📤 ${request.method} → ${processedResponse.error ? 'ERROR' : 'OK'}`);
         return processedResponse;
     }
+    /**
+     * Handle incoming MCP response (to our roots/list request)
+     */
+    handleResponse(response) {
+        // Check if this is a response to our roots/list request
+        if (response.id === 'fraim-roots-query') {
+            this.log(`📥 Response to roots/list request`);
+            this.pendingRootsRequest = false;
+            if (response.error) {
+                this.log(`⚠️  Client returned error for roots/list: ${response.error.message}`);
+                // Fall back to env var + upward search
+                this.loadConfig();
+            }
+            else {
+                const roots = response.result?.roots;
+                if (roots && Array.isArray(roots) && roots.length > 0) {
+                    // Use the first root (typically the primary workspace folder)
+                    const firstRoot = roots[0];
+                    if (firstRoot.uri && firstRoot.uri.startsWith('file://')) {
+                        // Convert file:// URI to local path
+                        // Handle both Unix (/path) and Windows (C:/path) paths
+                        let rootPath = firstRoot.uri.replace('file://', '');
+                        // Windows: file:///C:/path -> C:/path
+                        rootPath = rootPath.replace(/^\/([A-Z]:)/i, '$1');
+                        this.log(`✅ Got workspace root from client: ${rootPath} (${firstRoot.name || 'unnamed'})`);
+                        this.workspaceRoot = rootPath;
+                        // Now load config with the correct workspace root
+                        this.loadConfig();
+                    }
+                    else {
+                        this.log(`⚠️  Root URI is not a file:// URI: ${firstRoot.uri}`);
+                        this.loadConfig();
+                    }
+                }
+                else {
+                    this.log('⚠️  No roots provided by client');
+                    this.loadConfig();
+                }
+            }
+        }
+    }
     /**
      * Start STDIO server
      */
@@ -180,13 +318,28 @@ class FraimLocalMCPServer {
                 buffer = buffer.slice(newlineIndex + 1);
                 if (line) {
                     try {
-                        const request = JSON.parse(line);
-                        const response = await this.handleRequest(request);
-                        // Send response to stdout
-                        process.stdout.write(JSON.stringify(response) + '\n');
+                        const message = JSON.parse(line);
+                        // Distinguish between requests and responses
+                        // Requests have 'method', responses have 'result' or 'error' (but no 'method')
+                        if ('method' in message && message.method) {
+                            // This is a request from the client
+                            const response = await this.handleRequest(message);
+                            // Only send response if we got one (null means we handled it internally)
+                            if (response) {
+                                process.stdout.write(JSON.stringify(response) + '\n');
+                            }
+                        }
+                        else if ('result' in message || 'error' in message) {
+                            // This is a response from the client (to our roots/list request)
+                            this.handleResponse(message);
+                            // Don't send anything back - this was a response to our request
+                        }
+                        else {
+                            this.logError(`Unknown message type: ${JSON.stringify(message)}`);
+                        }
                     }
                     catch (error) {
-                        this.logError(`Request processing failed: ${error.message}`);
+                        this.logError(`Message processing failed: ${error.message}`);
                         // Send error response
                         const errorResponse = {
                             jsonrpc: '2.0',

package/dist/src/utils/workflow-parser.js

@@ -2,18 +2,33 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkflowParser = void 0;
 const fs_1 = require("fs");
+const path_1 = require("path");
 class WorkflowParser {
     /**
      * Parse a workflow markdown file into a structured definition
+     * Supports two formats:
+     * 1. Phase-based workflows with JSON frontmatter (e.g., implement, spec)
+     * 2. Simple workflows without frontmatter (e.g., bootstrap workflows)
      */
     static parse(filePath) {
         if (!(0, fs_1.existsSync)(filePath))
             return null;
         const content = (0, fs_1.readFileSync)(filePath, 'utf-8');
-        // 1. Extract JSON Metadata
+        // Try to extract JSON Metadata (frontmatter)
         const metadataMatch = content.match(/^---\r?\n([\s\S]+?)\r?\n---/);
-        if (!metadataMatch)
-            return null;
+        if (metadataMatch) {
+            // Phase-based workflow with frontmatter
+            return this.parsePhaseBasedWorkflow(filePath, content, metadataMatch);
+        }
+        else {
+            // Simple workflow without frontmatter
+            return this.parseSimpleWorkflow(filePath, content);
+        }
+    }
+    /**
+     * Parse a phase-based workflow with JSON frontmatter
+     */
+    static parsePhaseBasedWorkflow(filePath, content, metadataMatch) {
         let metadata;
         try {
             metadata = JSON.parse(metadataMatch[1]);
@@ -22,7 +37,7 @@ class WorkflowParser {
             console.error(`❌ Failed to parse JSON metadata in ${filePath}:`, e);
             return null;
         }
-        // 2. Extract Overview (Content after metadata but before first phase header)
+        // Extract Overview (Content after metadata but before first phase header)
         const contentAfterMetadata = content.substring(metadataMatch[0].length).trim();
         const firstPhaseIndex = contentAfterMetadata.search(/^##\s+Phase:/m);
         let overview = '';
@@ -34,7 +49,7 @@ class WorkflowParser {
         else {
             overview = contentAfterMetadata;
         }
-        // 3. Extract Phases (id -> content)
+        // Extract Phases (id -> content)
         const phases = new Map();
         const phaseSections = restOfContent.split(/^##\s+Phase:\s+/m);
         // Skip the first part (empty or overview overlap)
@@ -44,15 +59,32 @@ class WorkflowParser {
             const firstLine = sectionLines[0].trim();
             // Extract phase ID (slug before any (Phase X) or space)
             const id = firstLine.split(/[ (]/)[0].trim().toLowerCase();
-            // The content includes the header (we'll reconstruct it for the agent or just return the body)
-            // But usually, the agent wants the whole section including the Phase ID header.
-            // We'll store the whole section but prepend the header because split removed it.
+            // Store the whole section with header
             phases.set(id, `## Phase: ${section.trim()}`);
         }
         return {
             metadata,
             overview,
-            phases
+            phases,
+            isSimple: false
+        };
+    }
+    /**
+     * Parse a simple workflow without frontmatter (bootstrap-style)
+     */
+    static parseSimpleWorkflow(filePath, content) {
+        // Extract workflow name from filename
+        const workflowName = (0, path_1.basename)(filePath, '.md');
+        // For simple workflows, the entire content is the overview
+        // No phases, just execution steps
+        const metadata = {
+            name: workflowName
+        };
+        return {
+            metadata,
+            overview: content.trim(),
+            phases: new Map(),
+            isSimple: true
         };
     }
     /**

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.59",
+  "version": "2.0.62",
   "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": {