fraim-framework 2.0.55 → 2.0.57

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

@@ -1,1885 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FraimMCPServer = void 0;
-const express_1 = __importDefault(require("express"));
-const cors_1 = __importDefault(require("cors"));
-const fs_1 = require("fs");
-const path_1 = require("path");
-const git_utils_1 = require("./utils/git-utils");
-const db_service_1 = require("./fraim/db-service");
-const ai_manager_1 = require("./ai-manager/ai-manager");
-const issues_1 = require("./fraim/issues");
-const template_processor_1 = require("./fraim/template-processor");
-const crypto_1 = require("crypto");
-const dotenv = __importStar(require("dotenv"));
-// Load environment variables
-dotenv.config();
-// Global error handlers for better debugging in production
-process.on('uncaughtException', (err) => {
-    console.error('❌ CRITICAL: Uncaught Exception:', err.message);
-    console.error(err.stack);
-    process.exit(1);
-});
-process.on('unhandledRejection', (reason, promise) => {
-    console.error('❌ CRITICAL: Unhandled Rejection at:', promise, 'reason:', reason);
-    process.exit(1);
-});
-console.log('🚀 FRAIM MCP Server starting up...');
-console.log(`📂 Working Directory: ${process.cwd()}`);
-console.log(`🏠 Dirname: ${__dirname}`);
-try {
-    console.log('files in current dir:', (0, fs_1.readdirSync)(process.cwd()).join(', '));
-    const distPath = (0, path_1.join)(process.cwd(), 'dist');
-    if ((0, fs_1.existsSync)(distPath)) {
-        console.log('files in dist:', (0, fs_1.readdirSync)(distPath).join(', '));
-    }
-}
-catch (e) {
-    console.warn('⚠️ Could not log directory structure:', e.message);
-}
-class SessionManager {
-    constructor(dbService) {
-        this.sessions = new Map();
-        this.dbService = dbService;
-        // Default 1m, configurable for testing
-        this.FLUSH_INTERVAL_MS = process.env.FRAIM_TELEMETRY_FLUSH_INTERVAL
-            ? parseInt(process.env.FRAIM_TELEMETRY_FLUSH_INTERVAL)
-            : 60 * 1000;
-        // Flush on shutdown
-        const cleanup = async () => {
-            console.log('🛑 Flushing telemetry sessions before shutdown...');
-            // Race flush with a 2s timeout to guarantee exit
-            const timeout = new Promise(resolve => setTimeout(resolve, 2000));
-            await Promise.race([this.flushAll(), timeout]);
-            console.log('🛑 Shutdown flush complete (or timed out). Exiting.');
-            process.exit(0);
-        };
-        process.on('SIGTERM', cleanup);
-        process.on('SIGINT', cleanup);
-    }
-    registerSession(apiKey, sessionId) {
-        const now = Date.now();
-        this.sessions.set(apiKey, { sessionId, lastWrite: now, lastActive: now });
-    }
-    async updateActivity(apiKey) {
-        let session = this.sessions.get(apiKey);
-        const now = Date.now();
-        if (!session) {
-            // Re-hydration: Check DB for an active session for this API Key
-            try {
-                const dbSession = await this.dbService.getActiveSessionByApiKey(apiKey);
-                if (dbSession) {
-                    console.log(`🔄 Re-hydrating session for API Key: ${apiKey}`);
-                    session = {
-                        sessionId: dbSession.sessionId,
-                        lastWrite: now,
-                        lastActive: now
-                    };
-                    this.sessions.set(apiKey, session);
-                }
-                else {
-                    return false;
-                }
-            }
-            catch (e) {
-                console.error('⚠️ Failed to re-hydrate session from DB:', e);
-                return false;
-            }
-        }
-        session.lastActive = now;
-        // Write-behind: Only flush to DB if > Interval elapsed
-        if (now - session.lastWrite > this.FLUSH_INTERVAL_MS) {
-            // Async write
-            this.dbService.updateSessionActivity(session.sessionId, new Date(now)).catch(e => console.error('⚠️ Failed to flush session activity:', e));
-            session.lastWrite = now;
-        }
-        return true;
-    }
-    async flushAll() {
-        const promises = [];
-        for (const [_, data] of this.sessions) {
-            // Flush the memory lastActive time
-            promises.push(this.dbService.updateSessionActivity(data.sessionId, new Date(data.lastActive)));
-        }
-        await Promise.allSettled(promises);
-    }
-}
-class FraimMCPServer {
-    constructor() {
-        this.fileIndex = new Map();
-        this.workflowKeywords = new Map();
-        this.app = (0, express_1.default)();
-        this.app.use((0, cors_1.default)());
-        this.app.use(express_1.default.json());
-        // Load server version
-        try {
-            // Try process.cwd() first as it's the root in most deployments
-            let pkgPath = (0, path_1.join)(process.cwd(), 'package.json');
-            if (!(0, fs_1.existsSync)(pkgPath)) {
-                // Fallback to relative to __dirname (dist/src/ -> ../../package.json)
-                pkgPath = (0, path_1.join)(__dirname, '..', '..', 'package.json');
-            }
-            if ((0, fs_1.existsSync)(pkgPath)) {
-                const pkg = JSON.parse((0, fs_1.readFileSync)(pkgPath, 'utf8'));
-                this.serverVersion = pkg.version;
-            }
-            else {
-                this.serverVersion = 'unknown';
-            }
-        }
-        catch (e) {
-            this.serverVersion = 'unknown';
-        }
-        // Initialize database service
-        this.dbService = new db_service_1.FraimDbService();
-        this.sessionManager = new SessionManager(this.dbService);
-        // Find registry directory (check dist first for production, then source)
-        this.registryPath = this.findRegistryPath();
-        // 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));
-        // Public health check (before auth)
-        this.app.get('/health', (req, res) => {
-            res.status(200).json({
-                status: 'ok',
-                version: this.serverVersion,
-                timestamp: new Date().toISOString(),
-                service: 'fraim-mcp-standalone'
-            });
-        });
-        this.app.use(this.authMiddleware.bind(this));
-        this.app.use(this.telemetryMiddleware.bind(this));
-        this.setupRoutes();
-    }
-    /**
-     * Middleware to log all requests
-     */
-    requestLogger(req, res, next) {
-        const start = Date.now();
-        const { method, path } = req;
-        const params = method === 'POST' ? JSON.stringify(req.body) : '';
-        res.on('finish', () => {
-            const duration = Date.now() - start;
-            const status = res.statusCode;
-            const apiKey = req.apiKeyData;
-            const keyStr = apiKey ? apiKey.key : 'ANONYMOUS';
-            if (params && params.length > 0) {
-                console.info(`${keyStr} ${method} ${path} ${status} ${duration}ms ${params}`);
-            }
-            // Log usage if authenticated
-            // DISABLE: Granular logging disabled in favor of Session Keep-Alive
-            /*
-            if (apiKey) {
-              this.dbService.logUsage({
-                keyId: apiKey.key,
-                userId: apiKey.userId,
-                method,
-                path,
-                status,
-                duration
-              }).catch(e => console.error('⚠️ Failed to log usage:', (e as Error).message));
-            }
-            */
-        });
-        next();
-    }
-    async versionCheck(req, res, next) {
-        // Skip version check in test environment
-        if (process.env.NODE_ENV === 'test') {
-            return next();
-        }
-        // Only check for /mcp, /files routes, or root POST (MCP) where AI agents are active
-        const isMcpTraffic = req.path.startsWith('/mcp') ||
-            req.path.startsWith('/files') ||
-            (req.path === '/' && req.method === 'POST');
-        if (!isMcpTraffic) {
-            return next();
-        }
-        const clientVersion = this.getClientVersion();
-        if (clientVersion && clientVersion !== this.serverVersion) {
-            // Add a notice header for agents/developers to see
-            res.setHeader('X-FRAIM-Version-Notice', `Update available: Project has ${clientVersion}, Server has ${this.serverVersion}. Run 'fraim sync' to get latest workflows and features. This will not cause issues, but you're missing all the latest capabilities of FRAIM :)`);
-            // If it's an /mcp request, we can inject it into the response later in the handler
-            // For now, storing it in the request object
-            req.versionMismatch = {
-                client: clientVersion,
-                server: this.serverVersion
-            };
-        }
-        next();
-    }
-    getClientVersion() {
-        try {
-            // Try to find FRAIM framework version in the project's node_modules or package.json
-            const projectPkgPath = (0, path_1.join)(process.cwd(), 'package.json');
-            if ((0, fs_1.existsSync)(projectPkgPath)) {
-                const pkg = JSON.parse((0, fs_1.readFileSync)(projectPkgPath, 'utf8'));
-                // Check dependencies or devDependencies
-                const deps = { ...pkg.dependencies, ...pkg.devDependencies };
-                const version = deps['@fraim/framework'];
-                if (version) {
-                    // Clean version string (remove ^, ~)
-                    return version.replace(/[\^~]/, '');
-                }
-            }
-            // Fallback: check .fraim/config.json if we implement versioning there
-            const configPath = (0, path_1.join)(process.cwd(), '.fraim', 'config.json');
-            if ((0, fs_1.existsSync)(configPath)) {
-                const config = JSON.parse((0, fs_1.readFileSync)(configPath, 'utf8'));
-                if (config.version)
-                    return config.version;
-            }
-        }
-        catch (e) {
-            // Ignore errors
-        }
-        return null;
-    }
-    /**
-     * Middleware to authenticate requests via API key
-     */
-    async authMiddleware(req, res, next) {
-        // Skip auth for public health check, admin routes, website signup, and sales inquiries
-        if (req.path === '/health' || req.path.startsWith('/admin') || req.path === '/api/signup' || req.path === '/api/sales') {
-            return next();
-        }
-        const apiKey = req.headers['x-api-key'] || req.query['api-key'];
-        // In test mode, still extract API key if provided but don't validate it
-        if (process.env.NODE_ENV === 'test') {
-            if (apiKey) {
-                // Set mock API key data for testing
-                req.apiKeyData = {
-                    key: apiKey,
-                    userId: 'test-user',
-                    orgId: 'test-org',
-                    isActive: true
-                };
-            }
-            return next();
-        }
-        if (!apiKey) {
-            console.error(`[FRAIM AUTH] Missing API key for ${req.method} ${req.path}`);
-            res.status(401).json({ error: 'Unauthorized', message: 'Missing API key' });
-            return;
-        }
-        try {
-            const apiKeyData = await this.dbService.verifyApiKey(apiKey);
-            if (apiKeyData) {
-                req.apiKeyData = apiKeyData;
-                return next();
-            }
-            console.error(`❌ FRAIM AUTH: Invalid API key: ${apiKey}`);
-            res.status(401).json({
-                error: 'Unauthorized',
-                message: 'Invalid x-api-key'
-            });
-        }
-        catch (error) {
-            const msg = error instanceof Error ? error.message : String(error);
-            console.error('❌ FRAIM AUTH: Error during verification:', msg);
-            if (error instanceof Error && error.stack)
-                console.error(error.stack);
-            res.status(500).json({ error: 'Internal Server Error', details: msg });
-        }
-    }
-    adminAuthMiddleware(req, res, next) {
-        const adminKey = process.env.FRAIM_ADMIN_KEY;
-        if (!adminKey) {
-            console.error('⚠️ FRAIM_ADMIN_KEY not configured on server');
-            return res.status(503).json({ error: 'Management API disabled (key not set)' });
-        }
-        const providedKey = req.headers['x-admin-key'];
-        if (providedKey !== adminKey) {
-            return res.status(403).json({ error: 'Forbidden: Invalid admin key' });
-        }
-        return next();
-    }
-    /**
-     * Middleware to enforce Session Handshake and track activity
-     */
-    async telemetryMiddleware(req, res, next) {
-        // Skip for non-authenticated or exempt paths
-        const exemptPaths = ['/health', '/admin', '/mcp'];
-        if (exemptPaths.some(p => req.path.startsWith(p)) && req.method === 'GET') {
-            return next();
-        }
-        // 1. Standard MCP Lifecycle & Discovery methods (Initialize, List Tools/Resources/Prompts, etc.)
-        const exemptMethods = [
-            'initialize',
-            'notifications/initialized',
-            'tools/list',
-            'resources/list',
-            'prompts/list',
-            'logging/setLevel'
-        ];
-        if (req.body && exemptMethods.includes(req.body.method)) {
-            return next();
-        }
-        // 2. FRAIM Bootstrap/Discovery Tools that don't need an active session
-        if (req.body && req.body.method === 'tools/call') {
-            const toolName = req.body.params?.name;
-            const safeTools = [
-                'fraim_connect',
-                'get_fraim_init',
-                'list_fraim_workflows',
-                'fraim_get_local_config'
-            ];
-            if (safeTools.includes(toolName))
-                return next();
-        }
-        const apiKey = req.apiKeyData?.key;
-        if (!apiKey)
-            return next(); // Auth middleware handles 401 earlier
-        // Check Session
-        const isActive = await this.sessionManager.updateActivity(apiKey);
-        if (!isActive) {
-            console.log(`⛔ Telemetry blocked request: ${req.method} ${req.path} (No Session for ${apiKey})`);
-            // Enforce Handshake with clear instructions for agents
-            res.status(400).json({
-                jsonrpc: '2.0',
-                error: {
-                    code: -32600,
-                    message: `⛔ Session Not Started. REQUIRED ACTION: Call 'fraim_connect' tool first with these parameters:
-
-{
-  "agent": {
-    "name": "YourAgentName", 
-    "model": "your-model-name"
-  },
-  "machine": {
-    "hostname": "use os.hostname()",
-    "platform": "use process.platform"
-  },
-  "repo": {
-    "url": "git remote URL",
-    "owner": "repo owner",
-    "name": "repo name"
-  }
-}
-
-After successful fraim_connect, all other FRAIM tools will work. This is required for telemetry and session management.`
-                },
-                id: req.body?.id || null
-            });
-            return;
-        }
-        console.log(`✅ Telemetry active for ${apiKey}`);
-        return next();
-    }
-    /**
-     * Get the Express application for mounting in another server
-     * This allows FRAIM routes to be accessible on the main server port (e.g., on Azure)
-     */
-    getApp() {
-        return this.app;
-    }
-    /**
-     * Find registry directory
-     * Checks dist/registry (production) first, then registry (development)
-     */
-    findRegistryPath() {
-        const distPath = (0, path_1.join)(process.cwd(), 'dist', 'registry');
-        const sourcePath = (0, path_1.join)(process.cwd(), 'registry');
-        if ((0, fs_1.existsSync)(distPath)) {
-            console.log(`📁 Using registry from dist(production)`);
-            return distPath;
-        }
-        else if ((0, fs_1.existsSync)(sourcePath)) {
-            console.log(`📁 Using registry from source(development)`);
-            return sourcePath;
-        }
-        else {
-            console.warn(`⚠️  registry directory not found at ${distPath} or ${sourcePath} `);
-            return sourcePath; // Default to source path
-        }
-    }
-    /**
-     * Build an index of all files in registry and .fraim directories
-     */
-    buildFileIndex() {
-        this.fileIndex.clear();
-        // 1. Index Global registry (packaged with the server)
-        // In development, prefer source registry over dist registry
-        let globalRegistryPath = (0, path_1.join)(__dirname, '..', 'registry');
-        if (!(0, fs_1.existsSync)(globalRegistryPath)) {
-            // Fallback to dist registry for production
-            globalRegistryPath = (0, path_1.join)(__dirname, '..', '..', 'registry');
-        }
-        if ((0, fs_1.existsSync)(globalRegistryPath)) {
-            console.log(`🌍 Indexing global registry from ${globalRegistryPath}`);
-            this.indexDirectory(globalRegistryPath, '');
-        }
-        // 2. Index Local registry (project-specific framework files)
-        const localRegistryPath = (0, path_1.join)(process.cwd(), 'registry');
-        if ((0, fs_1.existsSync)(localRegistryPath) && localRegistryPath !== globalRegistryPath) {
-            console.log(`🏠 Indexing local registry overrides from ${localRegistryPath}`);
-            this.indexDirectory(localRegistryPath, '');
-        }
-        // 3. Index .fraim custom directories (project-specific customizations)
-        const fraimBasePath = (0, path_1.join)(process.cwd(), '.fraim');
-        if ((0, fs_1.existsSync)(fraimBasePath)) {
-            console.log(`🎨 Indexing project-specific .fraim customizations`);
-            // Index custom rules
-            const rulesPath = (0, path_1.join)(process.cwd(), '.fraim/rules');
-            if ((0, fs_1.existsSync)(rulesPath)) {
-                this.indexDirectory(rulesPath, 'fraim/rules');
-            }
-            // Index custom workflows (use default path)
-            const workflowsPath = (0, path_1.join)(process.cwd(), '.fraim/workflows');
-            if ((0, fs_1.existsSync)(workflowsPath)) {
-                this.indexDirectory(workflowsPath, 'fraim/workflows');
-            }
-            // Index custom templates
-            const templatesPath = (0, path_1.join)(process.cwd(), '.fraim/templates');
-            if ((0, fs_1.existsSync)(templatesPath)) {
-                this.indexDirectory(templatesPath, 'fraim/templates');
-            }
-            // Index custom scripts
-            const scriptsPath = (0, path_1.join)(process.cwd(), '.fraim/scripts');
-            if ((0, fs_1.existsSync)(scriptsPath)) {
-                this.indexDirectory(scriptsPath, 'fraim/scripts');
-            }
-        }
-        console.log(`📚 Indexed ${this.fileIndex.size} files total (Global + Local)`);
-    }
-    /**
-     * Index files in a directory
-     */
-    indexDirectory(dir, basePath = '') {
-        const indexFile = (dirPath, relativeBase = '') => {
-            if (!(0, fs_1.existsSync)(dirPath)) {
-                return;
-            }
-            const entries = (0, fs_1.readdirSync)(dirPath, { withFileTypes: true });
-            for (const entry of entries) {
-                const fullPath = (0, path_1.join)(dirPath, entry.name);
-                const relativePath = relativeBase ? (0, path_1.join)(relativeBase, entry.name) : entry.name;
-                const normalizedPath = relativePath.replace(/\\/g, '/'); // Normalize path separators
-                if (entry.isDirectory()) {
-                    // Skip nested workspace directories
-                    if (entry.name.includes('Issue ') || entry.name.includes('Master')) {
-                        continue;
-                    }
-                    indexFile(fullPath, normalizedPath);
-                }
-                else if (entry.isFile()) {
-                    // Include .md, .ts, .sh, .html files
-                    const ext = (0, path_1.extname)(entry.name);
-                    if (['.md', '.ts', '.sh', '.html'].includes(ext)) {
-                        // Determine file type based on path
-                        let type = 'other';
-                        let category;
-                        const pathLower = normalizedPath.toLowerCase();
-                        if (pathLower.includes('workflow') || normalizedPath.startsWith('workflows/') || normalizedPath.startsWith('fraim/workflows/')) {
-                            type = 'workflow';
-                            const parts = normalizedPath.split('/');
-                            if (parts.length > 2) {
-                                category = parts[parts.length - 2]; // e.g., 'customer-development'
-                            }
-                        }
-                        else if (pathLower.includes('rule') || normalizedPath.startsWith('rules/') || normalizedPath.startsWith('fraim/rules/')) {
-                            type = 'rule';
-                        }
-                        else if (pathLower.includes('template') || normalizedPath.startsWith('templates/') || normalizedPath.startsWith('fraim/templates/')) {
-                            type = 'template';
-                            const parts = normalizedPath.split('/');
-                            if (parts.length > 2) {
-                                category = parts[parts.length - 2]; // e.g., 'specs', 'evidence'
-                            }
-                        }
-                        else if (pathLower.includes('script') || normalizedPath.startsWith('scripts/') || normalizedPath.startsWith('fraim/scripts/')) {
-                            type = 'script';
-                        }
-                        else if (normalizedPath.includes('ai-manager-rules/') && normalizedPath.includes('-phases/')) {
-                            type = 'phase';
-                            const parts = normalizedPath.split('/');
-                            if (parts.length > 2) {
-                                category = parts[parts.length - 2]; // e.g., 'implement-phases', 'spec-phases'
-                            }
-                        }
-                        // Extract keywords from filename
-                        const keywords = this.extractKeywords(entry.name, normalizedPath);
-                        const metadata = {
-                            path: normalizedPath,
-                            name: entry.name,
-                            type,
-                            category,
-                            keywords,
-                            fullPath: fullPath
-                        };
-                        // Use normalized path as key (e.g., 'workflows/spec.md' or 'fraim/rules/custom-rule.md')
-                        // Custom files override generic ones if they have the same path
-                        this.fileIndex.set(normalizedPath, metadata);
-                    }
-                }
-            }
-        };
-        indexFile(dir, basePath);
-    }
-    /**
-     * Extract keywords from filename and path
-     */
-    extractKeywords(filename, path) {
-        const keywords = [];
-        // Add filename without extension
-        const nameWithoutExt = (0, path_1.basename)(filename, (0, path_1.extname)(filename));
-        keywords.push(nameWithoutExt.toLowerCase());
-        // Split on hyphens/underscores
-        const parts = nameWithoutExt.split(/[-_]/);
-        keywords.push(...parts.map(p => p.toLowerCase()));
-        // Add path components
-        const pathParts = path.split('/');
-        keywords.push(...pathParts.map(p => p.toLowerCase()));
-        return [...new Set(keywords)]; // Remove duplicates
-    }
-    /**
-     * Build keyword mappings for workflows to enable context-aware selection
-     */
-    buildWorkflowKeywords() {
-        // Map common user intents to workflow files
-        this.workflowKeywords.set('spec', ['spec', 'specification', 'write spec', 'create spec', 'specification phase']);
-        this.workflowKeywords.set('design', ['design', 'rfc', 'technical design', 'architecture', 'design phase']);
-        this.workflowKeywords.set('implement', ['implement', 'implementation', 'code', 'develop', 'implementation phase']);
-        this.workflowKeywords.set('test', ['test', 'testing', 'write tests', 'test phase']);
-        this.workflowKeywords.set('resolve', ['resolve', 'merge', 'close issue', 'resolution']);
-        this.workflowKeywords.set('retrospect', ['retrospect', 'retrospective', 'review']);
-        // Customer development workflows
-        this.workflowKeywords.set('linkedin-outreach', ['linkedin', 'outreach', 'customer development']);
-        this.workflowKeywords.set('interview-preparation', ['interview', 'customer interview', 'preparation']);
-        this.workflowKeywords.set('insight-analysis', ['insight', 'analysis', 'customer insight']);
-        this.workflowKeywords.set('strategic-brainstorming', ['brainstorm', 'strategy', 'strategic']);
-        this.workflowKeywords.set('thank-customers', ['thank', 'gratitude', 'appreciation']);
-        this.workflowKeywords.set('weekly-newsletter', ['newsletter', 'weekly update']);
-        // New lifecycle workflows
-        this.workflowKeywords.set('prototype', ['prototype', 'poc', 'spike', 'proof of concept']);
-        this.workflowKeywords.set('marketing-strategy', ['marketing', 'promotion', 'launch strategy', 'gtm']);
-        this.workflowKeywords.set('content-creation', ['content', 'blog', 'social media', 'docs']);
-        this.workflowKeywords.set('launch-checklist', ['launch', 'release', 'go live']);
-    }
-    /**
-     * Find workflows and related files based on user query
-     */
-    findRelevantFiles(query) {
-        const queryLower = query.toLowerCase();
-        const results = [];
-        const matched = new Set();
-        // First, check for exact workflow matches
-        for (const [workflowKey, keywords] of this.workflowKeywords.entries()) {
-            if (keywords.some(keyword => queryLower.includes(keyword))) {
-                // Find the workflow file
-                const workflowPath = `workflows / ${workflowKey}.md`;
-                const metadata = this.fileIndex.get(workflowPath);
-                if (metadata && !matched.has(workflowPath)) {
-                    results.push(metadata);
-                    matched.add(workflowPath);
-                }
-                // Add related files based on workflow type
-                this.addRelatedFiles(workflowKey, results, matched);
-            }
-        }
-        // If no exact match, search by keywords in file index
-        if (results.length === 0) {
-            for (const [path, metadata] of this.fileIndex.entries()) {
-                if (metadata.keywords.some(keyword => queryLower.includes(keyword))) {
-                    if (!matched.has(path)) {
-                        results.push(metadata);
-                        matched.add(path);
-                    }
-                }
-            }
-        }
-        return results;
-    }
-    /**
-     * Add related files based on workflow type
-     */
-    addRelatedFiles(workflowKey, results, matched) {
-        // For spec workflow, include spec template
-        if (workflowKey === 'spec') {
-            const specTemplate = this.fileIndex.get('templates/specs/FEATURESPEC-TEMPLATE.md');
-            if (specTemplate && !matched.has('templates/specs/FEATURESPEC-TEMPLATE.md')) {
-                results.push(specTemplate);
-                matched.add('templates/specs/FEATURESPEC-TEMPLATE.md');
-            }
-            // Add spec evidence template
-            const specEvidence = this.fileIndex.get('templates/evidence/Spec-Evidence.md');
-            if (specEvidence && !matched.has('templates/evidence/Spec-Evidence.md')) {
-                results.push(specEvidence);
-                matched.add('templates/evidence/Spec-Evidence.md');
-            }
-            // Add relevant rules
-            this.addRuleFiles(['communication', 'pr-workflow-completeness'], results, matched);
-        }
-        // For design workflow, include design templates and rules
-        if (workflowKey === 'design') {
-            const techSpecTemplate = this.fileIndex.get('templates/specs/TECHSPEC-TEMPLATE.md');
-            if (techSpecTemplate && !matched.has('templates/specs/TECHSPEC-TEMPLATE.md')) {
-                results.push(techSpecTemplate);
-                matched.add('templates/specs/TECHSPEC-TEMPLATE.md');
-            }
-            const bugSpecTemplate = this.fileIndex.get('templates/specs/BUGSPEC-TEMPLATE.md');
-            if (bugSpecTemplate && !matched.has('templates/specs/BUGSPEC-TEMPLATE.md')) {
-                results.push(bugSpecTemplate);
-                matched.add('templates/specs/BUGSPEC-TEMPLATE.md');
-            }
-            const designEvidence = this.fileIndex.get('templates/evidence/Design-Evidence.md');
-            if (designEvidence && !matched.has('templates/evidence/Design-Evidence.md')) {
-                results.push(designEvidence);
-                matched.add('templates/evidence/Design-Evidence.md');
-            }
-            this.addRuleFiles(['spike-first-development', 'communication', 'pr-workflow-completeness'], results, matched);
-        }
-        // For implement workflow, include implementation templates and rules
-        if (workflowKey === 'implement') {
-            const implEvidence = this.fileIndex.get('templates/evidence/Implementation-FeatureEvidence.md');
-            if (implEvidence && !matched.has('templates/evidence/Implementation-FeatureEvidence.md')) {
-                results.push(implEvidence);
-                matched.add('templates/evidence/Implementation-FeatureEvidence.md');
-            }
-            const bugEvidence = this.fileIndex.get('templates/evidence/Implementation-BugEvidence.md');
-            if (bugEvidence && !matched.has('templates/evidence/Implementation-BugEvidence.md')) {
-                results.push(bugEvidence);
-                matched.add('templates/evidence/Implementation-BugEvidence.md');
-            }
-            this.addRuleFiles([
-                'mandatory-pre-completion-reflection',
-                'agent-testing-guidelines',
-                'code-quality-and-debugging-patterns',
-                'spike-first-development',
-                'pr-workflow-completeness'
-            ], results, matched);
-        }
-        // For test workflow, include test rules
-        if (workflowKey === 'test') {
-            this.addRuleFiles(['agent-testing-guidelines', 'integrity-and-test-ethics'], results, matched);
-        }
-        // New workflows related files
-        if (workflowKey === 'prototype') {
-            this.addRuleFiles(['spike-first-development'], results, matched);
-        }
-        if (workflowKey === 'marketing-strategy') {
-            const contentCreation = this.fileIndex.get('workflows/marketing/content-creation.md');
-            if (contentCreation && !matched.has('workflows/marketing/content-creation.md')) {
-                results.push(contentCreation);
-                matched.add('workflows/marketing/content-creation.md');
-            }
-            const launchChecklist = this.fileIndex.get('workflows/marketing/launch-checklist.md');
-            if (launchChecklist && !matched.has('workflows/marketing/launch-checklist.md')) {
-                results.push(launchChecklist);
-                matched.add('workflows/marketing/launch-checklist.md');
-            }
-        }
-    }
-    /**
-     * Add rule files to results
-     */
-    addRuleFiles(ruleNames, results, matched) {
-        for (const ruleName of ruleNames) {
-            // Check for project-specific override first
-            const customRulePath = `fraim/rules/${ruleName}.md`;
-            const genericRulePath = `rules/${ruleName}.md`;
-            const rule = this.fileIndex.get(customRulePath) || this.fileIndex.get(genericRulePath);
-            if (rule && !matched.has(rule.path)) {
-                results.push(rule);
-                matched.add(rule.path);
-            }
-        }
-    }
-    setupRoutes() {
-        // Files indexing endpoint
-        this.app.get('/', (req, res) => {
-            res.json({
-                name: 'FRAIM MCP Server',
-                version: '1.0.0',
-                description: 'MCP server for .ai-agents files with context-aware workflow selection',
-                endpoints: {
-                    health: '/health',
-                    mcp: '/mcp',
-                    resources: '/resources'
-                },
-                files_indexed: this.fileIndex.size
-            });
-        });
-        // MCP endpoint - GET for SSE connections (optional, some clients use this)
-        this.app.get('/mcp', (req, res) => {
-            // Allow GET requests without strict Accept header check
-            // Some MCP clients may use GET for health checks
-            const acceptHeader = req.headers.accept || '';
-            if (acceptHeader.includes('text/event-stream')) {
-                // SSE connection
-                res.writeHead(200, {
-                    'Content-Type': 'text/event-stream',
-                    'Cache-Control': 'no-cache',
-                    'Connection': 'keep-alive',
-                    'Access-Control-Allow-Origin': '*'
-                });
-                // Handle client disconnects to prevent server crash
-                res.on('error', (err) => {
-                    console.error('⚠️ SSE stream error:', err);
-                });
-                res.write('event: endpoint\n');
-                // Use absolute URL to be safe
-                const protocol = req.protocol;
-                const host = req.get('host');
-                res.write(`data: ${protocol}://${host}/mcp\n\n`);
-                // Remove confusing "connected" message that might interfere with protocol
-                // res.write(': FRAIM MCP Server\n\n'); 
-                // res.write('data: connected\n\n');
-                return;
-            }
-            // Regular GET request
-            res.json({
-                message: 'FRAIM MCP Server is running. Use POST /mcp for MCP requests.'
-            });
-        });
-        // Admin routes (protected by admin key)
-        this.app.use('/admin', this.adminAuthMiddleware.bind(this));
-        this.app.post('/admin/keys', async (req, res) => {
-            const { userId, orgId } = req.body;
-            if (!userId || !orgId) {
-                return res.status(400).json({ error: 'userId and orgId are required' });
-            }
-            const apiKey = this.dbService.generateApiKey(userId, orgId);
-            await this.dbService.createApiKey({ key: apiKey, userId, orgId });
-            res.json({ key: apiKey });
-        });
-        this.app.get('/admin/keys', async (req, res) => {
-            const keys = await this.dbService.listApiKeys();
-            res.json(keys);
-        });
-        this.app.post('/admin/keys/revoke', async (req, res) => {
-            const { key } = req.body;
-            if (!key) {
-                return res.status(400).json({ error: 'key is required' });
-            }
-            const success = await this.dbService.revokeApiKey(key);
-            res.json({ revoked: success });
-        });
-        // Website signup endpoint (public, no auth required)
-        this.app.post('/api/signup', async (req, res) => {
-            try {
-                const { email, company, useCase, source } = req.body;
-                if (!email) {
-                    return res.status(400).json({ error: 'Email is required' });
-                }
-                // Basic email validation
-                const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-                if (!emailRegex.test(email)) {
-                    return res.status(400).json({ error: 'Invalid email format' });
-                }
-                // Get client IP and user agent for analytics
-                const ipAddress = req.ip || req.connection.remoteAddress || req.headers['x-forwarded-for'];
-                const userAgent = req.headers['user-agent'];
-                const signup = {
-                    email: email.toLowerCase().trim(),
-                    company: company?.trim() || undefined,
-                    useCase: useCase || undefined,
-                    source: source || 'website',
-                    timestamp: new Date(),
-                    ipAddress,
-                    userAgent
-                };
-                await this.dbService.createWebsiteSignup(signup);
-                console.log(`✅ New website signup: ${email} (${company || 'No company'}) - ${useCase || 'No use case'}`);
-                res.json({
-                    success: true,
-                    message: 'Successfully joined the waitlist!'
-                });
-            }
-            catch (error) {
-                console.error('❌ Website signup error:', error);
-                if (error.message === 'Email already registered') {
-                    return res.status(409).json({
-                        error: 'Email already registered',
-                        message: 'This email is already on our waitlist.'
-                    });
-                }
-                res.status(500).json({
-                    error: 'Internal server error',
-                    message: 'Failed to process signup. Please try again.'
-                });
-            }
-        });
-        // Sales inquiry endpoint (public, no auth required)
-        this.app.post('/api/sales', async (req, res) => {
-            try {
-                const { email, company, projectDetails, teamSize, timeline, budget, source } = req.body;
-                if (!email || !company || !projectDetails) {
-                    return res.status(400).json({
-                        error: 'Missing required fields',
-                        message: 'Email, company, project details are required'
-                    });
-                }
-                // Basic email validation
-                const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-                if (!emailRegex.test(email)) {
-                    return res.status(400).json({ error: 'Invalid email format' });
-                }
-                // Get client IP and user agent for analytics
-                const ipAddress = req.ip || req.connection.remoteAddress || req.headers['x-forwarded-for'];
-                const userAgent = req.headers['user-agent'];
-                const inquiry = {
-                    email: email.toLowerCase().trim(),
-                    company: company.trim(),
-                    projectDetails: projectDetails.trim(),
-                    teamSize: teamSize?.trim() || undefined,
-                    timeline: timeline?.trim() || undefined,
-                    budget: budget?.trim() || undefined,
-                    source: source || 'website',
-                    timestamp: new Date(),
-                    ipAddress,
-                    userAgent
-                };
-                await this.dbService.createSalesInquiry(inquiry);
-                console.log(`💼 New sales inquiry: ${email} from ${company} - Team: ${teamSize}`);
-                res.json({
-                    success: true,
-                    message: 'Sales inquiry submitted successfully! We\'ll be in touch soon.'
-                });
-            }
-            catch (error) {
-                console.error('❌ Sales inquiry error:', error);
-                res.status(500).json({
-                    error: 'Internal server error',
-                    message: 'Failed to process sales inquiry. Please try again.'
-                });
-            }
-        });
-        // Get signups endpoint (admin only)
-        this.app.get('/admin/signups', async (req, res) => {
-            try {
-                const limit = parseInt(req.query.limit) || 100;
-                const signups = await this.dbService.getWebsiteSignups(limit);
-                res.json({ signups, total: signups.length });
-            }
-            catch (error) {
-                console.error('❌ Failed to get signups:', error);
-                res.status(500).json({ error: 'Failed to retrieve signups' });
-            }
-        });
-        // Get sales inquiries endpoint (admin only)
-        this.app.get('/admin/sales', async (req, res) => {
-            try {
-                const limit = parseInt(req.query.limit) || 100;
-                const inquiries = await this.dbService.getSalesInquiries(limit);
-                res.json({ inquiries, total: inquiries.length });
-            }
-            catch (error) {
-                console.error('❌ Failed to get sales inquiries:', error);
-                res.status(500).json({ error: 'Failed to retrieve sales inquiries' });
-            }
-        });
-        // MCP endpoint - POST for actual MCP requests
-        // Handle MCP requests on both /mcp (standard) and / (easier config)
-        this.app.post(['/', '/mcp'], async (req, res) => {
-            const { jsonrpc, method, params, id } = req.body;
-            if (jsonrpc !== '2.0') {
-                return res.status(400).json({ error: 'Invalid JSON-RPC version' });
-            }
-            try {
-                let result;
-                if (method === 'initialize') {
-                    result = this.handleInitialize();
-                }
-                else if (method === 'tools/list') {
-                    result = this.handleListTools();
-                }
-                else if (method === 'resources/list') {
-                    result = this.handleListResources();
-                }
-                else if (method === 'prompts/list') {
-                    result = this.handleListPrompts();
-                }
-                else if (method === 'tools/call') {
-                    // Pass API Key context to handleToolCall
-                    const context = {
-                        apiKey: req.apiKeyData?.key,
-                        userId: req.apiKeyData?.userId
-                    };
-                    result = await this.handleToolCall(params, context);
-                }
-                else if (method === 'notifications/initialized') {
-                    // Client initialized notification - no response needed but must not error
-                    return res.json({ jsonrpc: '2.0', id: id || null, result: true });
-                }
-                else {
-                    throw new Error(`Unknown method: ${method}`);
-                }
-                if (req.versionMismatch) {
-                    const { client, server } = req.versionMismatch;
-                    const notice = `ℹ️ **FRAIM Update Available**\n\nYour project is using FRAIM ${client}, but version ${server} is available with new features and improvements.\n\n**To update:** Run \`fraim sync\` to get the latest workflows and templates.\n\n---\n\n`;
-                    if (result && Array.isArray(result.content)) {
-                        result.content.unshift({
-                            type: 'text',
-                            text: notice
-                        });
-                    }
-                }
-                res.json({
-                    jsonrpc: '2.0',
-                    result,
-                    id
-                });
-            }
-            catch (error) {
-                res.status(500).json({
-                    jsonrpc: '2.0',
-                    error: {
-                        code: -32603,
-                        message: error instanceof Error ? error.message : 'Internal error'
-                    },
-                    id
-                });
-            }
-        });
-    }
-    handleInitialize() {
-        return {
-            protocolVersion: '2024-11-05',
-            serverInfo: {
-                name: 'fraim-mcp-server',
-                version: this.serverVersion
-            },
-            capabilities: {
-                tools: {},
-                resources: {}
-            }
-        };
-    }
-    handleListTools() {
-        return {
-            tools: [
-                {
-                    name: 'get_fraim_init',
-                    description: `Initialize FRAIM with all available rules, workflows, and usage instructions.
-
-This should be the FIRST call to FRAIM in any new session.
-Returns:
-- All rules (organized by category)
-- All workflows (organized by category)
-- Usage instructions and best practices
-- Workflow execution guidance
-
-Call this before fetching any workflow or file to understand the system.`,
-                    inputSchema: {
-                        type: 'object',
-                        properties: {},
-                        required: []
-                    }
-                },
-                {
-                    name: 'fraim_connect',
-                    description: `🚨 REQUIRED FIRST CALL: Handshake to start a FRAIM session. MUST be called at the start of every session.
-
-⚠️ CRITICAL: If you get a "Session Not Started" error from any FRAIM tool, call this tool first.
-
-Registers your environment (machine/repo/agent) for telemetry and unlocks other tools.
-
-**Agent Information**: REQUIRED - Provide your actual agent name and model (validated against known agents).
-**Machine Information**: Use os.hostname() and process.platform - required for telemetry.
-**Repository Information**: Extract and send this information from .fraim/config.json.
-
-Example call:
-{
-  "agent": {"name": "Claude", "model": "claude-3.5-sonnet"},
-  "machine": {"hostname": "my-machine", "platform": "darwin"},
-  "repo": {"url": "https://github.com/owner/repo", "owner": "owner", "name": "repo"}
-}`,
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            agent: {
-                                type: 'object',
-                                description: 'Agent identification and capabilities',
-                                properties: {
-                                    name: {
-                                        type: 'string',
-                                        description: 'Agent name (e.g., "Claude", "Cursor", "Kiro", "Windsurf", "Antigravity")',
-                                        examples: ['Claude', 'Cursor', 'Kiro', 'Windsurf', 'Antigravity']
-                                    },
-                                    model: {
-                                        type: 'string',
-                                        description: 'Model name/version (e.g., "claude-3.5-sonnet", "gpt-4", "cursor-small")',
-                                        examples: ['claude-3.5-sonnet', 'gpt-4', 'cursor-small', 'kiro-agent']
-                                    },
-                                    version: {
-                                        type: 'string',
-                                        description: 'Agent version if available',
-                                        examples: ['1.0.0', '2024.12.1']
-                                    }
-                                },
-                                required: ['name', 'model'],
-                                additionalProperties: true
-                            },
-                            machine: {
-                                type: 'object',
-                                description: 'Machine specs - use os.hostname(), process.platform, os.totalmem(), os.cpus().length',
-                                properties: {
-                                    hostname: {
-                                        type: 'string',
-                                        description: 'Machine hostname from os.hostname()'
-                                    },
-                                    platform: {
-                                        type: 'string',
-                                        description: 'Platform from process.platform (win32, darwin, linux)'
-                                    },
-                                    memory: {
-                                        type: 'number',
-                                        description: 'Total memory in bytes from os.totalmem()'
-                                    },
-                                    cpus: {
-                                        type: 'number',
-                                        description: 'CPU count from os.cpus().length'
-                                    }
-                                },
-                                required: ['hostname', 'platform'],
-                                additionalProperties: true
-                            },
-                            repo: {
-                                type: 'object',
-                                description: 'Repository context - use git remote -v or check .git/config for URL',
-                                properties: {
-                                    url: {
-                                        type: 'string',
-                                        description: 'Git repository URL from git remote -v'
-                                    },
-                                    owner: {
-                                        type: 'string',
-                                        description: 'Repository owner (extracted from URL)'
-                                    },
-                                    name: {
-                                        type: 'string',
-                                        description: 'Repository name (extracted from URL)'
-                                    },
-                                    branch: {
-                                        type: 'string',
-                                        description: 'Current branch from git branch --show-current'
-                                    }
-                                },
-                                required: ['url'],
-                                additionalProperties: true
-                            }
-                        },
-                        required: ['agent', 'machine', 'repo']
-                    }
-                },
-                {
-                    name: 'get_fraim_file',
-                    description: `Get a specific file from FRAIM by path.
-
-Examples:
-- get_fraim_file({ path: "rules/communication.md" })
-- get_fraim_file({ path: "workflows/spec.md" })
-- get_fraim_file({ path: "templates/specs/FEATURESPEC-TEMPLATE.md" })
-
-NOTE: If a .fraim override exists for a rule, workflow, template, or script,
-FRAIM will return the project-specific version instead of the generic one.`,
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            path: {
-                                type: 'string',
-                                description: 'Path to the file (e.g., rules/communication.md, workflows/spec.md)'
-                            }
-                        },
-                        required: ['path']
-                    }
-                },
-                {
-                    name: 'get_fraim_workflow',
-                    description: `Get a workflow file by name. Returns the workflow content.
-
-Examples:
-- get_fraim_workflow({ workflow: "spec" })
-- get_fraim_workflow({ workflow: "design" })
-- get_fraim_workflow({ workflow: "implement" })
-
-After receiving the workflow, follow any ACTION items to fetch related files.
-
-Common workflows:
-- "prep-issue" - Prepare environment for working on an issue
-- "spec" - Write feature specifications
-- "design" - Create technical designs
-- "implement" - Implement features / fixes
-- "test" - Write tests
-- "resolve" - Merge to master
-
-Call get_fraim_init first to see all available workflows organized by category.`,
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            workflow: {
-                                type: 'string',
-                                description: 'Workflow name (e.g., "spec", "design", "implement", "prep-issue")'
-                            }
-                        },
-                        required: ['workflow']
-                    }
-                },
-                {
-                    name: 'list_fraim_workflows',
-                    description: `List all available workflows organized by category.
-
-Returns workflows grouped by:
-- Product Development (prep-issue, spec, design, implement, test, resolve)
-- Customer Development (linkedin-outreach, customer-interview, etc.)
-- Business Development (partnership-outreach, investor-pitch, etc.)
-
-Use this to discover which workflow to call with get_fraim_workflow.`,
-                    inputSchema: {
-                        type: 'object',
-                        properties: {},
-                        required: []
-                    }
-                },
-                {
-                    name: 'fraim_get_local_config',
-                    description: 'Get instructions for reading and using local .fraim/config.json from your workspace. Use this to understand project-specific settings and replace template variables.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {},
-                        required: []
-                    }
-                },
-                {
-                    name: 'file_issue',
-                    description: `Create a GitHub issue in the FRAIM repository.
-          
-Use this tool when you need to report a bug, request a feature, or track a task.
-Supports dry-run mode to preview the operation.`,
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            title: {
-                                type: 'string',
-                                description: 'Title of the issue'
-                            },
-                            body: {
-                                type: 'string',
-                                description: 'Body/Content of the issue'
-                            },
-                            labels: {
-                                type: 'array',
-                                items: { type: 'string' },
-                                description: 'List of labels to apply'
-                            },
-                            dryRun: {
-                                type: 'boolean',
-                                description: 'If true, simulates the creation without actually notifying GitHub'
-                            }
-                        },
-                        required: ['title', 'body']
-                    }
-                },
-                {
-                    name: 'seekCoachingOnNextStep',
-                    description: `Get coaching on what to do next in your implementation workflow.
-
-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
-
-This is your single point of contact for workflow guidance with evidence validation.`,
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            workflowType: {
-                                type: 'string',
-                                description: 'Type of workflow you are following',
-                                enum: ['implement', 'spec', 'design', 'test']
-                            },
-                            issueNumber: {
-                                type: 'string',
-                                description: 'Issue number you are working on'
-                            },
-                            currentPhase: {
-                                type: 'string',
-                                description: 'Phase you just completed or are working on (e.g., "scoping", "repro", "code")'
-                            },
-                            status: {
-                                type: 'string',
-                                description: 'Status of your current phase',
-                                enum: ['starting', 'complete', 'incomplete', 'failure']
-                            },
-                            findings: {
-                                type: 'object',
-                                description: 'Your findings/results from the current phase (varies by phase)',
-                                properties: {
-                                    uncertainties: {
-                                        type: 'array',
-                                        items: { type: 'string' },
-                                        description: 'Any unclear aspects that need clarification (used for help messages)'
-                                    }
-                                },
-                                additionalProperties: true
-                            },
-                            evidence: {
-                                type: 'object',
-                                description: 'Evidence submission for validation (varies by phase - can contain any relevant evidence)',
-                                additionalProperties: true
-                            }
-                        },
-                        required: ['workflowType', 'issueNumber', 'currentPhase', 'status']
-                    }
-                }
-            ]
-        };
-    }
-    handleListResources() {
-        return {
-            resources: []
-        };
-    }
-    handleListPrompts() {
-        return {
-            prompts: []
-        };
-    }
-    async handleToolCall(params, context = {}) {
-        const { name: toolName, arguments: toolArgs } = params;
-        console.log(`🔧 MCP Server: handleToolCall called with tool: ${toolName}, args:`, JSON.stringify(toolArgs, null, 2));
-        switch (toolName) {
-            case 'get_fraim_init':
-                return await this.handleGetInit();
-            case 'get_fraim_file':
-                return await this.handleGetFile(toolArgs.path);
-            case 'get_fraim_workflow':
-                return await this.handleGetWorkflow(toolArgs.workflow, context.apiKey);
-            case 'list_fraim_workflows':
-                return await this.handleListWorkflows();
-            case 'fraim_get_local_config':
-                return await this.handleGetLocalConfig();
-            case 'file_issue':
-                const result = await (0, issues_1.fileFraimIssue)(toolArgs);
-                return {
-                    content: [{
-                            type: 'text',
-                            text: JSON.stringify(result, null, 2)
-                        }]
-                };
-            case 'fraim_connect':
-                return await this.handleFraimConnect(toolArgs, context.apiKey, context.userId);
-            case 'seekCoachingOnNextStep':
-                return await this.handleSeekCoachingOnNextStep(toolArgs);
-            default:
-                throw new Error(`Unknown tool: ${toolName} `);
-        }
-    }
-    async handleGetInit() {
-        // Get all workflows organized by category
-        const workflows = Array.from(this.fileIndex.values()).filter(f => f.type === 'workflow');
-        // Organize workflows by category
-        const categorized = {};
-        for (const wf of workflows) {
-            const category = wf.category || 'Other';
-            if (!categorized[category]) {
-                categorized[category] = [];
-            }
-            // Extract workflow name without .md extension
-            const workflowName = wf.name.replace('.md', '');
-            categorized[category].push({
-                name: workflowName,
-                path: wf.path,
-                description: this.getWorkflowDescription(workflowName)
-            });
-        }
-        // Build initialization content
-        let initContent = `# FRAIM - Your Development Workflow Assistant\n\n`;
-        initContent += `## How to Use FRAIM\n\n`;
-        initContent += `When the user says: \n`;
-        initContent += `- "I need to prototype a PoC" → Call \`get_fraim_workflow({ workflow: "prototype" })\`\n`;
-        initContent += `- "I want to write a spec" → Call \`get_fraim_workflow({ workflow: "spec" })\`\n`;
-        initContent += `- "I need to design X" → Call \`get_fraim_workflow({ workflow: "design" })\`\n`;
-        initContent += `- "Implement issue #123" → Call \`get_fraim_workflow({ workflow: "prep-issue" })\`, then \`implement\`\n`;
-        initContent += `- "Write tests" → Call \`get_fraim_workflow({ workflow: "test" })\`\n`;
-        initContent += `- "Marketing/Launch a feature" → Call \`get_fraim_workflow({ workflow: "marketing-strategy" })\`\n`;
-        initContent += `- "Merge this PR" → Call \`get_fraim_workflow({ workflow: "resolve" })\`\n\n`;
-        initContent += `## Available Workflows\n\n`;
-        for (const [category, wfs] of Object.entries(categorized)) {
-            initContent += `### ${category}\n\n`;
-            for (const wf of wfs) {
-                initContent += `- **${wf.name}**: ${wf.description}\n`;
-                initContent += `  - Call: \`get_fraim_workflow({ workflow: "${wf.name}" })\`\n\n`;
-            }
-        }
-        initContent += `## Workflow Execution Pattern\n\n`;
-        initContent += `1. Call \`get_fraim_workflow({ workflow: "<name>" })\` to get the workflow file\n`;
-        initContent += `2. The workflow will contain **ACTION** items like:\n`;
-        initContent += `   - \`ACTION: Call get_fraim_file({ path: "rules/X.md" })\`\n`;
-        initContent += `   - \`ACTION: Call get_fraim_file({ path: "templates/Y.md" })\`\n`;
-        initContent += `3. Execute each ACTION item to fetch referenced files\n`;
-        initContent += `4. Follow the workflow steps with the fetched context\n\n`;
-        initContent += `## Important Notes\n\n`;
-        initContent += `- Files are NOT sent automatically - you must fetch them via ACTION items\n`;
-        initContent += `- This keeps context minimal and focused\n`;
-        initContent += `- Use \`get_fraim_file({ path: "..." })\` to fetch any referenced file\n\n`;
-        initContent += `## 📊 Proactive Codebase Analysis\n\n`;
-        initContent += `Would you like a quick analysis of your codebase for recommendations on test coverage, quality, and architecture? If yes, you can run the following tools:\n`;
-        initContent += `- **Test Coverage**: Run \`npm run validate-coverage\` and report gaps.\n`;
-        initContent += `- **Code Quality**: Run \`./.ai-agents/scripts/code-quality-check.sh\` to identify anti-patterns.\n`;
-        initContent += `If you find issues, offer to create GitHub bugs to address them.\n\n`;
-        initContent += `## 🚀 FRAIM Value Proposition\n\n`;
-        initContent += `**For Engineers**:\n`;
-        initContent += `- Deterministic coding via BAML and clear rule enforcement.\n`;
-        initContent += `- Automated repository setup and indexing.\n`;
-        initContent += `- Continuous learning from project retrospectives.\n\n`;
-        initContent += `**For Product/Marketing**:\n`;
-        initContent += `- End-to-end lifecycle support from rapid Prototyping to Go-To-Market.\n`;
-        initContent += `- Spec-first development with high-fidelity HTML/CSS mocks.\n`;
-        initContent += `- Automated customer research and outreach workflows.\n`;
-        initContent += `- Consistent documentation and evidence gathering.\n`;
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: initContent
-                }
-            ]
-        };
-    }
-    /**
-     * Get description for a workflow
-     */
-    getWorkflowDescription(workflowName) {
-        const descriptions = {
-            // Core Development Workflows
-            'prep-issue': 'Prepare environment for working on an issue',
-            'spec': 'Write feature specifications',
-            'design': 'Create technical designs',
-            'implement': 'Implement features/fixes',
-            'test': 'Write tests',
-            'resolve': 'Merge to master',
-            'retrospect': 'Conduct retrospectives after task completion',
-            // Review Workflows
-            'review-implementation-vs-design-spec': 'Review implementation against design spec',
-            'review-implementation-vs-feature-spec': 'Review implementation against feature spec',
-            // Quality Assurance
-            'browser-validation': 'Validate in browser',
-            'iterative-improvement-cycle': 'Iterative improvement cycle',
-            // Customer Development
-            'interview-preparation': 'Prepare for customer interviews',
-            'linkedin-outreach': 'LinkedIn customer outreach',
-            'insight-analysis': 'Analyze customer insights',
-            'insight-triage': 'Triage customer insights',
-            'strategic-brainstorming': 'Strategic brainstorming sessions',
-            'weekly-newsletter': 'Create weekly newsletter',
-            'thank-customers': 'Thank customers workflow',
-            // Replicate / Reverse Engineering
-            'visual-analysis': 'Analyze visual designs',
-            'website-discovery-analysis': 'Discover and analyze websites',
-            'use-case-extraction': 'Extract use cases',
-            're-implementation-strategy': 'Plan re-implementation strategy',
-            // New Lifecycle Workflows
-            'prototype': 'Quickly explore ideas and prove concepts (spike code)',
-            'marketing-strategy': 'Define value prop, target audience, and launch plans',
-            'content-creation': 'Generate high-quality blog posts, social media, and docs',
-            'launch-checklist': 'Final technical and marketing sign-off before release'
-        };
-        return descriptions[workflowName] || 'Workflow';
-    }
-    async handleGetFile(path) {
-        const metadata = this.fileIndex.get(path);
-        if (!metadata) {
-            throw new Error(`File not found: ${path}. Use list_fraim_files to see available files.`);
-        }
-        try {
-            let content = (0, fs_1.readFileSync)(metadata.fullPath, 'utf-8');
-            // Check if file contains template variables
-            const hasTemplateVars = /\{\{config\.[^}]+\}\}/.test(content);
-            // Don't process template variables here - let agent do it with local config
-            // content = processTemplateVariables(content, this.config);
-            let header = `# ${metadata.name}\n\n`;
-            header += `**Path:** ${path}\n`;
-            header += `**Type:** ${metadata.type}\n`;
-            if (metadata.category) {
-                header += `**Category:** ${metadata.category}\n`;
-            }
-            if (hasTemplateVars) {
-                header += `\n## ⚠️ Template Variables Detected\n\n`;
-                header += `This file contains template variables like \`{{config.project.name}}\`.\n\n`;
-                header += `**You must replace these with values from your local \`.fraim/config.json\`:**\n\n`;
-                header += `1. Read \`.fraim/config.json\` from your workspace\n`;
-                header += `2. Find the config path (e.g., for \`{{config.project.name}}\`, read \`config.project.name\`)\n`;
-                header += `3. Replace the variable with the actual value\n\n`;
-                header += `**Example:**\n`;
-                header += `- Template: "Project: {{config.project.name}}"`;
-                header += `- Your config: \`{ "project": { "name": "My App" } }\`\n`;
-                header += `- Result: "Project: My App"\n\n`;
-                header += `Use \`fraim_get_local_config\` tool for detailed instructions.\n\n`;
-            }
-            if (metadata.type === 'script') {
-                header += `\n## 🛡️ Ephemeral Execution Mandatory (IP Protection)\n\n`;
-                header += `This script MUST be executed ephemerally:\n\n`;
-                header += `1. **Fetch** this content from the MCP.\n`;
-                header += `2. **Save** to a system temporary directory (e.g., \`/tmp\` or \`%TEMP%\`), NOT the local repository.\n`;
-                header += `3. **Execute** from the temporary location.\n`;
-                header += `4. **Delete** the temporary file immediately after execution.\n\n`;
-                header += `Refer to \`rules/ephemeral-execution.md\` for the full policy.\n\n`;
-            }
-            header += `---\n\n`;
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: header + content
-                    }
-                ]
-            };
-        }
-        catch (error) {
-            throw new Error(`Failed to read file: ${error instanceof Error ? error.message : 'Unknown error'}`);
-        }
-    }
-    async handleGetWorkflow(workflowName, apiKey) {
-        // Normalize workflow name (remove .md if present)
-        const normalizedName = workflowName.replace(/\.md$/, '');
-        // Try to find the workflow file
-        const workflowPath = `workflows/${normalizedName}.md`;
-        const metadata = this.fileIndex.get(workflowPath);
-        if (!metadata) {
-            // Try alternative category paths - dynamically discover categories from file index
-            const workflowCategories = new Set();
-            // Extract all unique workflow categories from the file index
-            for (const [path, fileMetadata] of this.fileIndex) {
-                if (fileMetadata.type === 'workflow' && path.startsWith('workflows/') && path.includes('/')) {
-                    const pathParts = path.split('/');
-                    if (pathParts.length >= 3) { // workflows/category/file.md
-                        workflowCategories.add(pathParts[1]);
-                    }
-                }
-            }
-            // Search through all discovered categories
-            for (const cat of workflowCategories) {
-                const altPath = `workflows/${cat}/${normalizedName}.md`;
-                const altMetadata = this.fileIndex.get(altPath);
-                if (altMetadata) {
-                    return this.returnWorkflowFile(altMetadata, apiKey);
-                }
-            }
-            // Workflow not found
-            const availableWorkflows = Array.from(this.fileIndex.values())
-                .filter(f => f.type === 'workflow')
-                .map(f => f.name.replace('.md', ''));
-            return {
-                content: [{
-                        type: 'text',
-                        text: `Workflow "${workflowName}" not found.\n\nAvailable workflows:\n${availableWorkflows.map(w => `- ${w}`).join('\n')}\n\nUse list_fraim_workflows to see all workflows organized by category.`
-                    }]
-            };
-        }
-        return this.returnWorkflowFile(metadata, apiKey);
-    }
-    /**
-     * Return a workflow file with its content
-     */
-    async returnWorkflowFile(metadata, apiKey) {
-        try {
-            const rawContent = (0, fs_1.readFileSync)(metadata.fullPath, 'utf-8');
-            // Get repository info from session if available
-            let repositoryInfo = null;
-            if (apiKey) {
-                try {
-                    const session = await this.dbService.getActiveSessionByApiKey(apiKey);
-                    if (session?.repo) {
-                        repositoryInfo = {
-                            owner: session.repo.owner,
-                            name: session.repo.name,
-                            organization: session.repo.organization,
-                            project: session.repo.project,
-                            url: session.repo.url,
-                            provider: this.detectProviderFromUrl(session.repo.url)
-                        };
-                    }
-                }
-                catch (e) {
-                    // Ignore session lookup errors, continue without repository info
-                }
-            }
-            // Process templates with provider-specific actions
-            const templateEngine = (0, template_processor_1.getTemplateEngine)(this.registryPath);
-            const processedContent = templateEngine.processWorkflow(rawContent, repositoryInfo);
-            // Build response
-            let response = `# Workflow: ${metadata.name.replace('.md', '')}\n\n`;
-            response += `**Path:** \`${metadata.path}\`\n`;
-            if (metadata.category) {
-                response += `**Category:** ${metadata.category}\n`;
-            }
-            // Add provider info if available
-            const provider = repositoryInfo?.provider || 'GITHUB';
-            response += `**Platform:** ${provider.toUpperCase()}\n`;
-            response += `\n---\n\n`;
-            response += processedContent;
-            return {
-                content: [{
-                        type: 'text',
-                        text: response
-                    }]
-            };
-        }
-        catch (error) {
-            throw new Error(`Failed to read workflow: ${error instanceof Error ? error.message : 'Unknown error'}`);
-        }
-    }
-    /**
-     * List all workflows organized by category
-     */
-    async handleListWorkflows() {
-        const workflows = Array.from(this.fileIndex.values()).filter(f => f.type === 'workflow');
-        // Organize by category
-        const categorized = {};
-        for (const wf of workflows) {
-            const category = wf.category || 'Other';
-            if (!categorized[category]) {
-                categorized[category] = [];
-            }
-            const workflowName = wf.name.replace('.md', '');
-            categorized[category].push({
-                name: workflowName,
-                path: wf.path,
-                description: this.getWorkflowDescription(workflowName)
-            });
-        }
-        // Build response - cleaner format without file paths
-        let response = `# Available FRAIM Workflows\n\n`;
-        for (const [category, wfs] of Object.entries(categorized)) {
-            response += `## ${category}\n\n`;
-            for (const wf of wfs) {
-                response += `- **${wf.name}**: ${wf.description}\n`;
-            }
-            response += `\n`;
-        }
-        response += `## How to Use\n\n`;
-        response += `Call \`get_fraim_workflow({ workflow: "<name>" })\` with the workflow name.\n`;
-        response += `Example: \`get_fraim_workflow({ workflow: "spec" })\`\n`;
-        return {
-            content: [{
-                    type: 'text',
-                    text: response
-                }]
-        };
-    }
-    async handleListFiles(type, category) {
-        let files = Array.from(this.fileIndex.values());
-        if (type !== 'all') {
-            files = files.filter(f => f.type === type);
-        }
-        if (category) {
-            files = files.filter(f => f.category === category);
-        }
-        // Sort by type, then by path
-        files.sort((a, b) => {
-            if (a.type !== b.type) {
-                return a.type.localeCompare(b.type);
-            }
-            return a.path.localeCompare(b.path);
-        });
-        const filesList = files.map(f => {
-            return `- **${f.type}**${f.category ? ` (${f.category})` : ''}: \`${f.path}\``;
-        }).join('\n');
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `# FRAIM Files\n\n**Filter:** ${type}${category ? `, category: ${category}` : ''}\n\n**Total:** ${files.length} file(s)\n\n${filesList}`
-                }
-            ]
-        };
-    }
-    async handleGetLocalConfig() {
-        const instructions = `# Using Local .fraim/config.json
-
-## Overview
-
-FRAIM workflows and templates are generic and served from the cloud. However, **you must use your local project configuration** from \`.fraim/config.json\` in your workspace to customize them for your specific project.
-
-## How to Read Local Config
-
-1. **Locate the Config File**
-   - Path: \`.fraim/config.json\` in your current workspace directory
-   - If it doesn't exist, use the \`fraim_setup\` tool to create it
-
-2. **Read the Config**
-   - Use your file reading tools to read \`.fraim/config.json\`
-   - Parse it as JSON
-   - Access nested values using dot notation (e.g., \`config.project.name\`)
-
-3. **Use Config Values**
-   - Replace template variables like \`{{config.project.name}}\` with actual values
-   - Use config values to customize commands, file paths, and workflows
-   - Example: If config says \`testing.framework: "pytest"\`, use \`pytest\` instead of generic test commands
-
-## Template Variable Replacement
-
-When you see variables like \`{{config.project.name}}\` in workflows or templates:
-
-1. **Extract the path**: \`{{config.project.name}}\` → path is \`project.name\`
-2. **Read your local config**: \`.fraim/config.json\`
-3. **Navigate to the value**: \`config.project.name\` → \`"My Project"\`
-4. **Replace**: \`{{config.project.name}}\` → \`"My Project"\`
-
-### Example
-
-**Template:**
-\`\`\`
-Project: {{config.project.name}}
-Language: {{config.project.primaryLanguage}}
-Test Framework: {{config.testing.framework}}
-\`\`\`
-
-**Your .fraim/config.json:**
-\`\`\`json
-{
-  "project": {
-    "name": "My Awesome App",
-    "primaryLanguage": "python"
-  },
-  "testing": {
-    "framework": "pytest"
-  }
-}
-\`\`\`
-
-**Result:**
-\`\`\`
-Project: My Awesome App
-Language: python
-Test Framework: pytest
-\`\`\`
-
-## Local Customizations
-
-Your project may have customizations in:
-
-- **\`.fraim/rules/\`** - Custom rules that override generic ones
-- **\`.fraim/workflows/\`** - Custom workflows that override generic ones  
-- **\`.fraim/templates/\`** - Custom templates that override generic ones
-- **\`.fraim/scripts/\`** - Custom scripts that override generic ones
-
-**Priority**: Local customizations always take precedence over generic files from the cloud.
-
-## Common Config Paths
-
-- \`config.project.name\` - Project name
-- \`config.project.primaryLanguage\` - Main programming language
-- \`config.project.type\` - Project type (saas-product, library, etc.)
-- \`config.testing.framework\` - Test framework (pytest, jest, etc.)
-- \`config.testing.testLocation\` - Where tests are located
-- \`config.testing.testNaming\` - Test file naming pattern
-- \`config.git.defaultBranch\` - Default git branch
-- \`config.git.branchNaming\` - Branch naming pattern
-
-## Workflow Execution
-
-When executing workflows:
-
-1. **Read local config first** - Understand your project's settings
-2. **Replace template variables** - Use config values in commands and file paths
-3. **Check for local customizations** - Use local overrides if they exist
-4. **Execute in workspace** - All operations happen in your project directory
-
-## If Config Doesn't Exist
-
-If \`.fraim/config.json\` doesn't exist:
-
-1. Use \`fraim_setup\` tool to create it interactively
-2. Or use default values (see FRAIM defaults)
-3. Or create it manually with project-specific settings
-
-## Next Steps
-
-1. Read \`.fraim/config.json\` from your workspace
-2. Use config values when you see \`{{config.*}}\` variables
-3. Check for local customizations in \`.fraim/\` directories
-4. Execute workflows using your project's specific settings`;
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: instructions
-                }
-            ]
-        };
-    }
-    async handleFraimConnect(args, apiKey, userId) {
-        if (!apiKey) {
-            throw new Error('No API Key found in context for fraim_connect');
-        }
-        // Validate required agent information
-        if (!args.agent?.name || !args.agent?.model) {
-            throw new Error('Agent information is required. Please provide agent.name and agent.model in your fraim_connect call.');
-        }
-        // Validate agent information to prevent BS
-        const validAgentNames = ['Claude', 'Cursor', 'Kiro', 'Windsurf', 'Antigravity', 'ChatGPT', 'Copilot'];
-        if (!validAgentNames.some(valid => args.agent.name.toLowerCase().includes(valid.toLowerCase()))) {
-            throw new Error(`Invalid agent name "${args.agent.name}". Please use one of: ${validAgentNames.join(', ')}`);
-        }
-        // Validate machine information
-        if (!args.machine?.hostname || !args.machine?.platform) {
-            throw new Error('Machine information is required. Please provide machine.hostname and machine.platform. Use os.hostname() and process.platform.');
-        }
-        // Validate repo information - check if .fraim/config.json exists and use it
-        let repoInfo = args.repo || {};
-        // Note: MCP server cannot access client-side .fraim/config.json
-        // Repository info must be provided by the client in the fraim_connect call
-        if (!repoInfo.url) {
-            throw new Error('Repository information is required. Please provide repo.url in the fraim_connect call.');
-        }
-        // 1. Generate Session ID
-        const sessionId = (0, crypto_1.randomUUID)();
-        // userId passed from context
-        const finalUserId = userId || 'unknown';
-        // 2. Create Session in DB with enhanced information
-        const session = {
-            sessionId,
-            userId: finalUserId,
-            agent: {
-                name: args.agent.name,
-                model: args.agent.model,
-                version: args.agent.version
-            },
-            machine: args.machine,
-            repo: repoInfo,
-            startTime: new Date(),
-            lastActive: new Date()
-        };
-        const keyData = await this.dbService.verifyApiKey(apiKey);
-        if (keyData)
-            session.userId = keyData.userId;
-        await this.dbService.createSession(session);
-        // 3. Register in SessionManager
-        this.sessionManager.registerSession(apiKey, sessionId);
-        // 4. Generate informative response
-        const agentInfo = `${args.agent.name}${args.agent.model ? ` (${args.agent.model})` : ''}${args.agent.version ? ` v${args.agent.version}` : ''}`;
-        const machineInfo = `${args.machine.hostname || 'unknown'} (${args.machine.platform || 'unknown'})`;
-        const repoInfoDisplay = repoInfo.name || repoInfo.url || 'unknown';
-        return {
-            content: [{
-                    type: 'text',
-                    text: `✅ **FRAIM Session Connected!**
-
-**Session ID**: ${sessionId}
-**Agent**: ${agentInfo}
-**Machine**: ${machineInfo}
-**Repository**: ${repoInfoDisplay}
-
-🔄 Telemetry active. All FRAIM tools are now unlocked.
-
-**Next Steps**: 
-- Use \`get_fraim_init\` to see available workflows
-- Use \`list_fraim_workflows\` to browse by category
-- Use \`get_fraim_workflow({ workflow: "name" })\` to start working`
-                }],
-            sessionId: sessionId
-        };
-    }
-    async handleSeekCoachingOnNextStep(args) {
-        console.log('🔧 MCP Server: handleSeekCoachingOnNextStep called with args:', JSON.stringify(args, null, 2));
-        try {
-            const response = await this.aiCoach.handleCoachingRequest({
-                workflowType: args.workflowType,
-                issueNumber: args.issueNumber,
-                currentPhase: args.currentPhase,
-                status: args.status,
-                evidence: args.evidence,
-                findings: args.findings
-            });
-            console.log('✅ MCP Server: AI Coach returned response, length:', response.length);
-            return {
-                content: [{
-                        type: 'text',
-                        text: response
-                    }]
-            };
-        }
-        catch (error) {
-            console.error('❌ AI Coach guidance failed:', error);
-            return {
-                content: [{
-                        type: 'text',
-                        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'
-            };
-        }
-    }
-    async start(port = 3002) {
-        try {
-            // Connect to database before starting server
-            await this.dbService.connect();
-            this.app.listen(port, () => {
-                console.log(`🚀 FRAIM MCP Server running on port ${port}`);
-                console.log(`📡 MCP endpoint: http://localhost:${port}/mcp`);
-                console.log(`🏥 Health check: http://localhost:${port}/health`);
-                console.log(`📚 Serving ${this.fileIndex.size} files from registry`);
-                console.log(`   Path: ${this.registryPath}`);
-            });
-        }
-        catch (error) {
-            console.error('❌ Failed to connect to database during startup:', error);
-            throw error;
-        }
-    }
-    detectProviderFromUrl(url) {
-        if (!url)
-            return 'github';
-        if (url.includes('dev.azure.com') || url.includes('visualstudio.com')) {
-            return 'ado';
-        }
-        return 'github';
-    }
-}
-exports.FraimMCPServer = FraimMCPServer;
-// Start the server if this file is run directly
-// In Azure App Service, the port is provided via process.env.PORT
-const serverPort = (0, git_utils_1.getPort)();
-const defaultFraimPort = process.env.FRAIM_MCP_PORT ? parseInt(process.env.FRAIM_MCP_PORT) : serverPort + 2;
-const port = process.env.PORT ? parseInt(process.env.PORT) : defaultFraimPort;
-const server = new FraimMCPServer();
-server.start(port).catch((error) => {
-    console.error('Failed to start FRAIM MCP Server:', error);
-    process.exit(1);
-});