fraim-framework 2.0.44 → 2.0.45

package/dist/src/fraim-mcp-server.js

@@ -170,7 +170,6 @@ class FraimMCPServer {
         // Initialize database service
         this.dbService = new db_service_1.FraimDbService();
         this.sessionManager = new SessionManager(this.dbService);
-        this.aiManager = new ai_manager_1.AIManager();
         // Load FRAIM configuration
         this.config = (0, config_loader_1.loadFraimConfig)();
         // Find registry directory (check dist first for production, then source)
@@ -178,6 +177,8 @@ class FraimMCPServer {
         // Build file index from filesystem (includes registry and .fraim)
         this.buildFileIndex();
         this.buildWorkflowKeywords();
+        // Initialize AI Coach with file index
+        this.aiCoach = new ai_manager_1.AICoach(this.fileIndex);
         // Apply core middleware first (logging and auth)
         this.app.use(this.requestLogger.bind(this));
         this.app.use(this.versionCheck.bind(this));
@@ -282,6 +283,10 @@ class FraimMCPServer {
         if (req.path === '/health' || req.path.startsWith('/admin')) {
             return next();
         }
+        // Skip auth in test mode
+        if (process.env.NODE_ENV === 'test') {
+            return next();
+        }
         const apiKey = req.headers['x-api-key'] || req.query['api-key'];
         if (!apiKey) {
             console.error(`[FRAIM AUTH] Missing API key for ${req.method} ${req.path}`);
@@ -983,95 +988,55 @@ Supports dry-run mode to preview the operation.`,
                     }
                 },
                 {
-                    name: 'ai_manager_request_review',
-                    description: `Request self-review instructions from AI Manager after completing workflow phase.
+                    name: 'seekCoachingOnNextStep',
+                    description: `Get coaching on what to do next in your implementation workflow.
 
-The AI Manager provides detailed review instructions including:
-- Step-by-step validation criteria
-- Pass/fail criteria for each step
-- Commands to run for verification
-- Grading guidelines and reporting format
+The AI Coach provides phase-specific instructions based on your current progress:
+- If starting: Get initial phase instructions (usually scoping)
+- If completed phase: Provide evidence for validation, get next phase instructions
+- If stuck/incomplete: Get guidance to continue current phase
 
-Use this when you believe your work is complete and ready for review.
-Currently supports: spec, implement phases (more phases coming soon).`,
+This is your single point of contact for workflow guidance with evidence validation.`,
                     inputSchema: {
                         type: 'object',
                         properties: {
                             workflowType: {
                                 type: 'string',
-                                description: 'Type of workflow phase completed',
-                                enum: ['spec', 'design', 'implement', 'test']
+                                description: 'Type of workflow you are following',
+                                enum: ['implement', 'spec', 'design', 'test']
                             },
                             issueNumber: {
                                 type: 'string',
-                                description: 'Issue number being worked on'
-                            },
-                            phase: {
-                                type: 'string',
-                                description: 'Specific phase name (e.g., "specification", "implementation")'
-                            }
-                        },
-                        required: ['workflowType', 'issueNumber', 'phase']
-                    }
-                },
-                {
-                    name: 'ai_manager_report_grade',
-                    description: `Report your self-assessment to AI Manager after completing self-review.
-
-Provide results from review in JSON format:
-- pass: true/false based on review assessment
-- reasons: array of failure reasons (only if pass=false)
-- iterationCount: REQUIRED - your current iteration number for this phase
-
-AI Manager will evaluate your report and provide next steps:
-- PROCEED: Ready to submit PR for human review
-- ITERATE: Fix issues and retry (max 3 iterations)
-- ESCALATE: Max iterations reached, escalate to human review
-
-IMPORTANT: Track your iteration count per workflow phase. Each phase (spec, implement, test) has its own counter.
-Maximum 3 iterations per phase before automatic escalation to human review.`,
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            workflowType: {
-                                type: 'string',
-                                description: 'Type of workflow phase',
-                                enum: ['spec', 'design', 'implement', 'test']
+                                description: 'Issue number you are working on'
                             },
-                            issueNumber: {
+                            currentPhase: {
                                 type: 'string',
-                                description: 'Issue number being worked on'
+                                description: 'Phase you just completed or are working on (e.g., "scoping", "repro", "code")'
                             },
-                            phase: {
+                            status: {
                                 type: 'string',
-                                description: 'Specific phase name'
+                                description: 'Status of your current phase',
+                                enum: ['starting', 'complete', 'incomplete', 'failure']
                             },
-                            report: {
+                            findings: {
                                 type: 'object',
-                                description: 'Your self-assessment report in JSON format',
+                                description: 'Your findings/results from the current phase (varies by phase)',
                                 properties: {
-                                    pass: {
-                                        type: 'boolean',
-                                        description: 'Whether your work passes all validation criteria'
-                                    },
-                                    reasons: {
+                                    uncertainties: {
                                         type: 'array',
-                                        description: 'Array of specific reasons for failure (only required if pass=false)',
-                                        items: {
-                                            type: 'string'
-                                        }
-                                    },
-                                    iterationCount: {
-                                        type: 'number',
-                                        description: 'REQUIRED: Your current iteration number for this workflow phase (1, 2, or 3)',
-                                        minimum: 1,
-                                        maximum: 3
+                                        items: { type: 'string' },
+                                        description: 'Any unclear aspects that need clarification (used for help messages)'
                                     }
                                 },
-                                required: ['pass', 'iterationCount']
+                                additionalProperties: true
+                            },
+                            evidence: {
+                                type: 'object',
+                                description: 'Evidence submission for validation (varies by phase - can contain any relevant evidence)',
+                                additionalProperties: true
                             }
                         },
-                        required: ['workflowType', 'issueNumber', 'phase', 'report']
+                        required: ['workflowType', 'issueNumber', 'currentPhase', 'status']
                     }
                 }
             ]
@@ -1110,10 +1075,8 @@ Maximum 3 iterations per phase before automatic escalation to human review.`,
                 };
             case 'fraim_connect':
                 return await this.handleFraimConnect(toolArgs, context.apiKey, context.userId);
-            case 'ai_manager_request_review':
-                return await this.handleAIManagerRequestReview(toolArgs);
-            case 'ai_manager_report_grade':
-                return await this.handleAIManagerReportGrade(toolArgs);
+            case 'seekCoachingOnNextStep':
+                return await this.handleSeekCoachingOnNextStep(toolArgs);
             default:
                 throw new Error(`Unknown tool: ${toolName} `);
         }
@@ -1548,102 +1511,31 @@ If \`.fraim/config.json\` doesn't exist:
             sessionId: sessionId
         };
     }
-    async handleAIManagerRequestReview(args) {
-        try {
-            console.log(`🤖 AI Manager: Generating review instructions for ${args.workflowType} phase`);
-            const instructions = this.aiManager.generateReviewInstructions({
-                workflowType: args.workflowType,
-                issueNumber: args.issueNumber,
-                phase: args.phase
-            });
-            return {
-                content: [{
-                        type: 'text',
-                        text: instructions
-                    }]
-            };
-        }
-        catch (error) {
-            console.error('❌ AI Manager request review failed:', error);
-            return {
-                content: [{
-                        type: 'text',
-                        text: `# ❌ AI Manager Request Failed\n\n**Error**: ${error instanceof Error ? error.message : 'Unknown error'}\n\nPlease check your request parameters and try again.`
-                    }],
-                error: error instanceof Error ? error.message : 'Unknown error'
-            };
-        }
-    }
-    async handleAIManagerReportGrade(args) {
+    async handleSeekCoachingOnNextStep(args) {
         try {
-            console.log(`🤖 AI Manager: Evaluating review report for ${args.workflowType} phase`);
-            const decision = this.aiManager.evaluateReport(args.report, {
+            const response = await this.aiCoach.handleCoachingRequest({
                 workflowType: args.workflowType,
                 issueNumber: args.issueNumber,
-                phase: args.phase
-            });
-            // Format response for agent
-            let response = `# 🤖 AI Manager Evaluation Result\n\n`;
-            const actionEmoji = decision.action === 'PROCEED' ? '✅' :
-                decision.action === 'ESCALATE' ? '⚠️' : '🔄';
-            response += `## Decision: ${actionEmoji} ${decision.action}\n\n`;
-            response += `**Message**: ${decision.message}\n\n`;
-            if (decision.iterationCount) {
-                response += `**Iteration Count**: ${decision.iterationCount}/3\n\n`;
-            }
-            response += `## Next Steps\n\n`;
-            decision.nextSteps.forEach((step, index) => {
-                response += `${index + 1}. ${step}\n`;
+                currentPhase: args.currentPhase,
+                status: args.status,
+                evidence: args.evidence,
+                findings: args.findings
             });
-            response += `\n`;
-            if (decision.action === 'PROCEED') {
-                response += `## 🎉 Ready for Human Review!\n\n`;
-                response += `Your work has passed AI Manager validation. You should now:\n\n`;
-                response += `1. **Submit PR** with complete evidence document\n`;
-                response += `2. **Update issue labels** to status:needs-review\n`;
-                response += `3. **Include this AI Manager validation** in your evidence\n\n`;
-            }
-            else if (decision.action === 'ESCALATE') {
-                response += `## ⚠️ Escalated to Human Review\n\n`;
-                response += `Maximum iterations reached. Your work will be reviewed by a human despite validation failures:\n\n`;
-                response += `1. **Submit PR** with detailed iteration history\n`;
-                response += `2. **Add escalation label** (ai-manager:max-iterations)\n`;
-                response += `3. **Document all attempts** and failure reasons in evidence\n`;
-                response += `4. **Human reviewer** will focus on recurring validation issues\n\n`;
-            }
-            else {
-                response += `## 🔧 Work Required\n\n`;
-                response += `Your work needs improvement. You should:\n\n`;
-                response += `1. **Address all failure reasons** listed below\n`;
-                response += `2. **Re-run validation steps** to verify fixes\n`;
-                response += `3. **Request new review** using ai_manager_request_review\n`;
-                response += `4. **Include iterationCount: ${(decision.iterationCount || 1) + 1}** in next report\n`;
-                response += `5. **Do NOT submit PR** until review passes or escalates\n\n`;
-            }
-            response += `## Your Report Summary\n\n`;
-            response += `**Pass**: ${args.report.pass}\n`;
-            response += `**Iteration**: ${args.report.iterationCount || 1}/3\n`;
-            if (args.report.reasons && args.report.reasons.length > 0) {
-                response += `**Failure Reasons**:\n`;
-                args.report.reasons.forEach((reason) => {
-                    response += `- ${reason}\n`;
-                });
-            }
             return {
                 content: [{
                         type: 'text',
                         text: response
-                    }],
-                decision: decision
+                    }]
             };
         }
         catch (error) {
-            console.error('❌ AI Manager report evaluation failed:', error);
+            console.error('❌ AI Coach guidance failed:', error);
             return {
                 content: [{
                         type: 'text',
-                        text: `# ❌ AI Manager Evaluation Failed\n\n**Error**: ${error instanceof Error ? error.message : 'Unknown error'}\n\nPlease check your report format and try again.`
+                        text: `# ❌ AI Coach Guidance Failed\n\n**Error**: ${error instanceof Error ? error.message : 'Unknown error'}\n\nPlease check your request parameters and try again.`
                     }],
+                isError: true,
                 error: error instanceof Error ? error.message : 'Unknown error'
             };
         }

package/dist/src/static-website-middleware.js

@@ -0,0 +1,75 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStaticWebsiteMiddleware = createStaticWebsiteMiddleware;
+const express_1 = __importDefault(require("express"));
+const path_1 = require("path");
+const fs_1 = require("fs");
+/**
+ * Middleware to serve the FRAIM website at /fraim endpoint
+ * This serves the static website files from the website directory
+ */
+function createStaticWebsiteMiddleware() {
+    const router = express_1.default.Router();
+    // Find the website directory
+    const websitePath = findWebsitePath();
+    if (!websitePath) {
+        console.warn('⚠️ Website directory not found. FRAIM website will not be available at /fraim');
+        return router;
+    }
+    console.log(`🌐 Serving FRAIM website from: ${websitePath}`);
+    // Serve static files from website directory at /fraim endpoint only
+    router.use('/fraim', express_1.default.static(websitePath, {
+        index: 'index.html',
+        setHeaders: (res, path) => {
+            // Set proper MIME types
+            if (path.endsWith('.css')) {
+                res.setHeader('Content-Type', 'text/css');
+            }
+            else if (path.endsWith('.js')) {
+                res.setHeader('Content-Type', 'application/javascript');
+            }
+            else if (path.endsWith('.png')) {
+                res.setHeader('Content-Type', 'image/png');
+            }
+            else if (path.endsWith('.jpg') || path.endsWith('.jpeg')) {
+                res.setHeader('Content-Type', 'image/jpeg');
+            }
+            else if (path.endsWith('.svg')) {
+                res.setHeader('Content-Type', 'image/svg+xml');
+            }
+            // Cache static assets for 1 hour
+            if (path.match(/\.(css|js|png|jpg|jpeg|svg|ico)$/)) {
+                res.setHeader('Cache-Control', 'public, max-age=3600');
+            }
+        }
+    }));
+    return router;
+}
+/**
+ * Find the website directory
+ * Checks multiple possible locations
+ */
+function findWebsitePath() {
+    const possiblePaths = [
+        // Production: dist/website
+        (0, path_1.join)(process.cwd(), 'dist', 'website'),
+        // Development: website
+        (0, path_1.join)(process.cwd(), 'website'),
+        // Relative to server file: ../website
+        (0, path_1.join)(__dirname, '..', 'website'),
+        // Relative to server file: ../../website  
+        (0, path_1.join)(__dirname, '..', '..', 'website')
+    ];
+    for (const path of possiblePaths) {
+        if ((0, fs_1.existsSync)(path)) {
+            const indexPath = (0, path_1.join)(path, 'index.html');
+            if ((0, fs_1.existsSync)(indexPath)) {
+                return path;
+            }
+        }
+    }
+    return null;
+}