fraim-framework 2.0.90 → 2.0.92

package/bin/fraim.js

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

package/dist/src/cli/commands/mcp.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mcpCommand = void 0;
+const commander_1 = require("commander");
+const stdio_server_1 = require("../../local-mcp-server/stdio-server");
+/**
+ * mcpCommand - Entry point for starting the local FRAIM MCP server.
+ * This integrates the local-mcp-server into the main CLI.
+ */
+exports.mcpCommand = new commander_1.Command('mcp')
+    .description('Start the local FRAIM MCP server (stdio)')
+    .action(() => {
+    const server = new stdio_server_1.FraimLocalMCPServer();
+    server.start();
+});

package/dist/src/cli/fraim.js

@@ -48,6 +48,7 @@ const add_provider_1 = require("./commands/add-provider");
 const override_1 = require("./commands/override");
 const list_overridable_1 = require("./commands/list-overridable");
 const login_1 = require("./commands/login");
+const mcp_1 = require("./commands/mcp");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const program = new commander_1.Command();
@@ -85,6 +86,7 @@ program.addCommand(add_provider_1.addProviderCommand);
 program.addCommand(override_1.overrideCommand);
 program.addCommand(list_overridable_1.listOverridableCommand);
 program.addCommand(login_1.loginCommand);
+program.addCommand(mcp_1.mcpCommand);
 // Wait for async command initialization before parsing
 (async () => {
     // Import the initialization promise from setup command

package/dist/src/cli/mcp/mcp-server-registry.js

@@ -36,7 +36,8 @@ exports.BASE_MCP_SERVERS = [
         name: 'FRAIM',
         description: 'FRAIM workflow orchestration and mentoring',
         buildServer: (fraimKey) => ({
-            command: 'fraim-mcp',
+            command: 'npx',
+            args: ['-y', 'fraim-framework@latest', 'mcp'],
             env: {
                 // Include API key for IDE configs (Codex, VSCode, etc.)
                 // The stdio-server will use this if set, otherwise falls back to ~/.fraim/config.json

package/dist/src/cli/services/device-flow-service.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceFlowService = void 0;
+const axios_1 = __importDefault(require("axios"));
+const chalk_1 = __importDefault(require("chalk"));
+class DeviceFlowService {
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Start the Device Flow Login
+     */
+    async login() {
+        console.log(chalk_1.default.blue('\n🔗 Starting Authentication...'));
+        try {
+            // 1. Request device and user codes
+            const deviceCode = await this.requestDeviceCode();
+            console.log(chalk_1.default.yellow('\nACTION REQUIRED:'));
+            console.log(`1. Go to: ${chalk_1.default.cyan.underline(deviceCode.verification_uri)}`);
+            console.log(`2. Enter the code: ${chalk_1.default.bold.green(deviceCode.user_code)}`);
+            console.log(chalk_1.default.gray(`\nWaiting for authorization (expires in ${Math.floor(deviceCode.expires_in / 60)} minutes)...`));
+            // 2. Poll for the access token
+            const token = await this.pollForToken(deviceCode.device_code, deviceCode.interval);
+            console.log(chalk_1.default.green('\n✅ Authentication Successful!'));
+            return token;
+        }
+        catch (error) {
+            console.error(chalk_1.default.red(`\n❌ Authentication failed: ${error.message}`));
+            throw error;
+        }
+    }
+    async requestDeviceCode() {
+        const response = await axios_1.default.post(this.config.authUrl, {
+            client_id: this.config.clientId,
+            scope: this.config.scope
+        }, {
+            headers: { Accept: 'application/json' }
+        });
+        return response.data;
+    }
+    async pollForToken(deviceCode, interval) {
+        let currentInterval = interval * 1000;
+        return new Promise((resolve, reject) => {
+            const poll = async () => {
+                try {
+                    const response = await axios_1.default.post(this.config.tokenUrl, {
+                        client_id: this.config.clientId,
+                        device_code: deviceCode,
+                        grant_type: 'urn:ietf:params:oauth:grant-type:device_code'
+                    }, {
+                        headers: { Accept: 'application/json' }
+                    });
+                    if (response.data.access_token) {
+                        resolve(response.data.access_token);
+                        return;
+                    }
+                    if (response.data.error) {
+                        const error = response.data.error;
+                        if (error === 'authorization_pending') {
+                            // Keep polling
+                            setTimeout(poll, currentInterval);
+                        }
+                        else if (error === 'slow_down') {
+                            currentInterval += 5000;
+                            setTimeout(poll, currentInterval);
+                        }
+                        else {
+                            reject(new Error(response.data.error_description || error));
+                        }
+                    }
+                }
+                catch (error) {
+                    reject(error);
+                }
+            };
+            setTimeout(poll, currentInterval);
+        });
+    }
+}
+exports.DeviceFlowService = DeviceFlowService;

package/dist/src/core/config-loader.js

@@ -46,6 +46,11 @@ function loadFraimConfig() {
                 ...(config.customizations || {})
             }
         };
+        if (config.customizations?.postCleanupHook || config.customizations?.cleanupCommand) {
+            if (!mergedConfig.customizations)
+                mergedConfig.customizations = {};
+            mergedConfig.customizations.postCleanupHook = config.customizations.postCleanupHook || config.customizations.cleanupCommand;
+        }
         if (config.issueTracking && typeof config.issueTracking === 'object') {
             mergedConfig.issueTracking = config.issueTracking;
         }

package/dist/src/core/types.js

@@ -2,6 +2,8 @@
 /**
  * FRAIM Configuration Types
  * TypeScript types for .fraim/config.json
+ *
+ * Each field includes rich metadata for agent detection and user interaction
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_FRAIM_CONFIG = void 0;

package/dist/src/core/utils/git-utils.js

@@ -31,7 +31,7 @@ function getPort() {
  */
 function determineDatabaseName() {
     try {
-        const branchName = process.env.FRAIM_BRANCH || (0, child_process_1.execSync)('git rev-parse --abbrev-ref HEAD').toString().trim();
+        const branchName = process.env.FRAIM_BRANCH || process.env.FRAIM_BRANCH_NAME || (0, child_process_1.execSync)('git rev-parse --abbrev-ref HEAD').toString().trim();
         const issueMatch = branchName.match(/issue-(\d+)/i) || branchName.match(/(\d+)-/);
         if (issueMatch) {
             return `fraim_issue_${issueMatch[1]}`;

package/dist/src/core/utils/stub-generator.js

@@ -50,11 +50,11 @@ function extractLeadParagraph(content) {
  * These stubs are committed to the user's repo for discoverability.
  */
 function generateWorkflowStub(workflowName, workflowPath, intent, principles) {
-    return `${STUB_MARKER}
-# FRAIM Workflow: ${workflowName}
-
-> [!IMPORTANT]
-> This is a **FRAIM-managed workflow stub**. 
+    return `${STUB_MARKER}
+# FRAIM Workflow: ${workflowName}
+
+> [!IMPORTANT]
+> This is a **FRAIM-managed workflow stub**. 
 > To load the full context (rules, templates, and execution steps), ask your AI agent to:
 > \`@fraim get_fraim_workflow("${workflowName}")\`
 >
@@ -81,19 +81,19 @@ function parseRegistryWorkflow(content) {
  * Coaching stubs are discoverability artifacts and should be resolved with get_fraim_file.
  */
 function generateJobStub(jobName, _jobPath, intent, outcome, steps) {
-    return `${STUB_MARKER}
-# FRAIM Job: ${jobName}
-
-## Intent
-${intent}
-
-## Outcome
-${outcome}
-
-## Steps
-${steps}
-
----
+    return `${STUB_MARKER}
+# FRAIM Job: ${jobName}
+
+## Intent
+${intent}
+
+## Outcome
+${outcome}
+
+## Steps
+${steps}
+
+---
 
 > [!IMPORTANT]
 > **For AI Agents:** Do NOT attempt to execute this job based on the Intent/Outcome above.
@@ -110,41 +110,41 @@ ${steps}
  * Generates a lightweight markdown stub for a skill.
  */
 function generateSkillStub(skillName, skillPath, skillInput, skillOutput) {
-    return `${STUB_MARKER}
-# FRAIM Skill: ${skillName}
-
-## Skill Input
-${skillInput}
-
-## Skill Output
-${skillOutput}
-
----
-
-> [!IMPORTANT]
-> **For AI Agents:** This is a discoverability stub for the skill.
-> All execution details must be fetched from MCP before use.
-> To retrieve the complete skill instructions, call:
-> \`get_fraim_file({ path: "skills/${skillPath}" })\`
+    return `${STUB_MARKER}
+# FRAIM Skill: ${skillName}
+
+## Skill Input
+${skillInput}
+
+## Skill Output
+${skillOutput}
+
+---
+
+> [!IMPORTANT]
+> **For AI Agents:** This is a discoverability stub for the skill.
+> All execution details must be fetched from MCP before use.
+> To retrieve the complete skill instructions, call:
+> \`get_fraim_file({ path: "skills/${skillPath}" })\`
 `;
 }
 /**
  * Generates a lightweight markdown stub for a rule.
  */
 function generateRuleStub(ruleName, rulePath, intent) {
-    return `${STUB_MARKER}
-# FRAIM Rule: ${ruleName}
-
-## Intent
-${intent}
-
----
-
-> [!IMPORTANT]
-> **For AI Agents:** This is a discoverability stub for the rule.
-> All rule details must be fetched from MCP before use.
-> To retrieve the complete rule instructions, call:
-> \`get_fraim_file({ path: "rules/${rulePath}" })\`
+    return `${STUB_MARKER}
+# FRAIM Rule: ${ruleName}
+
+## Intent
+${intent}
+
+---
+
+> [!IMPORTANT]
+> **For AI Agents:** This is a discoverability stub for the rule.
+> All rule details must be fetched from MCP before use.
+> To retrieve the complete rule instructions, call:
+> \`get_fraim_file({ path: "rules/${rulePath}" })\`
 `;
 }
 /**

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

@@ -29,6 +29,7 @@ const provider_utils_1 = require("../core/utils/provider-utils");
 const object_utils_1 = require("../core/utils/object-utils");
 const local_registry_resolver_1 = require("../core/utils/local-registry-resolver");
 const ai_mentor_1 = require("../core/ai-mentor");
+const usage_collector_js_1 = require("./usage-collector.js");
 /**
  * Handle template substitution logic separately for better testability
  */
@@ -264,6 +265,9 @@ class FraimLocalMCPServer {
         this.log(`🔑 API key: ${this.apiKey.substring(0, 10)}...`);
         this.log(`Local MCP version: ${this.localVersion}`);
         this.log(`🔍 DEBUG BUILD: Machine detection v2 active`);
+        // Initialize usage collector
+        this.usageCollector = new usage_collector_js_1.UsageCollector();
+        this.log('📊 Usage analytics collector initialized');
     }
     /**
      * Load API key from environment variable or user config file
@@ -1260,6 +1264,8 @@ class FraimLocalMCPServer {
                     this.engine.setMachineInfo(this.machineInfo);
                     this.engine.setRepoInfo(this.repoInfo);
                 }
+                // In a proxy setup, the remote server resolves the API key ID during event upload.
+                // No local resolution needed.
                 // Update the request with injected info
                 request.params.arguments = args;
             }
@@ -1402,9 +1408,9 @@ class FraimLocalMCPServer {
         // Force ALL tools/call requests to return raw definitions so the proxy
         // can resolve templates and replace includes locally
         const toolName = request.params?.name;
+        const args = request.params?.arguments || {};
         let injectedRequest = request;
         if (request.method === 'tools/call' && typeof toolName === 'string') {
-            const args = request.params.arguments || {};
             // 🔍 SMART DISPATCHER: Intercept mentoring and job/workflow tools for local overrides
             if (toolName === 'seekMentoring') {
                 try {
@@ -1482,6 +1488,11 @@ class FraimLocalMCPServer {
         }
         const response = await this._doProxyToRemote(injectedRequest, requestId);
         const processedResponse = await this.finalizeToolResponse(injectedRequest, response, requestSessionId, requestId);
+        // Single point for usage tracking - log all tool calls
+        if (injectedRequest.method === 'tools/call' && requestSessionId && toolName) {
+            const success = !processedResponse.error;
+            this.usageCollector.collectMCPCall(toolName, args, requestSessionId, success);
+        }
         this.log(`📤 ${injectedRequest.method} → ${processedResponse.error ? 'ERROR' : 'OK'}`);
         return processedResponse;
     }
@@ -1574,6 +1585,17 @@ class FraimLocalMCPServer {
     start() {
         let buffer = '';
         process.stdin.setEncoding('utf8');
+        // Set up periodic usage data upload
+        const uploadInterval = setInterval(() => {
+            this.uploadUsageData().catch(error => {
+                this.log(`⚠️ Failed to upload usage data: ${error.message}`);
+            });
+        }, 60000); // Upload every minute
+        // Clean up interval on shutdown
+        const cleanup = () => {
+            clearInterval(uploadInterval);
+            this.usageCollector.shutdown();
+        };
         process.stdin.on('data', async (chunk) => {
             buffer += chunk;
             // Process complete JSON-RPC messages (newline-delimited)
@@ -1629,21 +1651,40 @@ class FraimLocalMCPServer {
         });
         process.stdin.on('end', () => {
             this.log('🛑 Stdin closed, shutting down...');
+            cleanup();
             this.emitFallbackSummary('stdin_end');
             process.exit(0);
         });
         process.on('SIGTERM', () => {
             this.log('🛑 SIGTERM received, shutting down...');
+            cleanup();
             this.emitFallbackSummary('sigterm');
             process.exit(0);
         });
         process.on('SIGINT', () => {
             this.log('🛑 SIGINT received, shutting down...');
+            cleanup();
             this.emitFallbackSummary('sigint');
             process.exit(0);
         });
         this.log('✅ FRAIM Local MCP Server ready');
     }
+    /**
+     * Flush collected usage data to the local database
+     */
+    async uploadUsageData() {
+        if (this.usageCollector.getEventCount() === 0) {
+            return; // Nothing to flush
+        }
+        try {
+            const count = this.usageCollector.getEventCount();
+            await this.usageCollector.flush(this.remoteUrl, this.apiKey);
+            this.log(`📊 Flushed ${count} usage events to remote server`);
+        }
+        catch (error) {
+            this.log(`❌ Usage flushing error: ${error.message}`);
+        }
+    }
 }
 exports.FraimLocalMCPServer = FraimLocalMCPServer;
 FraimLocalMCPServer.AGENT_RESOLUTION_NOTICE = [

package/dist/src/local-mcp-server/usage-collector.js

@@ -0,0 +1,156 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UsageCollector = void 0;
+const axios_1 = __importDefault(require("axios"));
+/**
+ * Usage event collector for local MCP proxy
+ * Collects usage events and batches them for upload
+ */
+class UsageCollector {
+    constructor() {
+        this.events = [];
+        this.apiKeyId = null;
+    }
+    /**
+     * Set the API key ID for this session
+     */
+    setApiKeyId(apiKeyId) {
+        this.apiKeyId = apiKeyId;
+    }
+    /**
+     * Collect MCP tool call event
+     */
+    collectMCPCall(toolName, args, sessionId, success = true, duration) {
+        if (!this.apiKeyId) {
+            return; // Silently skip if no API key
+        }
+        const parsed = this.parseMCPCall(toolName, args);
+        if (!parsed)
+            return;
+        const event = {
+            type: parsed.type,
+            name: parsed.name,
+            apiKeyId: this.apiKeyId,
+            sessionId,
+            success
+        };
+        if (duration !== undefined) {
+            event.duration = duration;
+        }
+        this.events.push(event);
+    }
+    /**
+     * Collect usage event directly (for backward compatibility with tests)
+     */
+    collectEvent(type, name, sessionId, success = true, duration) {
+        if (!this.apiKeyId) {
+            return; // Silently skip if no API key
+        }
+        const event = {
+            type,
+            name,
+            apiKeyId: this.apiKeyId,
+            sessionId,
+            success
+        };
+        if (duration !== undefined) {
+            event.duration = duration;
+        }
+        this.events.push(event);
+    }
+    /**
+     * Parse MCP tool call to extract usage analytics info
+     */
+    parseMCPCall(toolName, args) {
+        switch (toolName) {
+            case 'get_fraim_job':
+                return { type: 'job', name: args.job || 'unknown' };
+            case 'get_fraim_file':
+                if (args.path) {
+                    return UsageCollector.parseComponentName(args.path);
+                }
+                return null;
+            case 'seekMentoring':
+                return { type: 'mentoring', name: args.workflowType || 'unknown' };
+            default:
+                return null;
+        }
+    }
+    /**
+     * Get collected events for upload and clear the queue
+     */
+    getEventsForUpload() {
+        const eventsToUpload = [...this.events];
+        this.events = [];
+        return eventsToUpload;
+    }
+    /**
+     * Get current event count
+     */
+    getEventCount() {
+        return this.events.length;
+    }
+    /**
+     * Flush events to the remote server via API
+     */
+    async flush(remoteUrl, apiKey) {
+        if (this.events.length === 0)
+            return;
+        const events = [...this.events];
+        this.events = [];
+        try {
+            await axios_1.default.post(`${remoteUrl}/api/analytics/events`, {
+                events,
+                apiKey
+            }, {
+                timeout: 5000,
+                headers: {
+                    'x-api-key': apiKey,
+                    'Content-Type': 'application/json'
+                }
+            });
+            // Success - events are already cleared from the queue
+        }
+        catch (error) {
+            const status = error.response?.status;
+            const message = error.response?.data?.error || error.message;
+            console.error(`❌ Failed to flush usage events (HTTP ${status}): ${message}`);
+            // Put events back at the beginning of the queue for next try
+            this.events = [...events, ...this.events];
+        }
+    }
+    /**
+     * Shutdown the collector
+     */
+    shutdown() {
+        this.events = [];
+    }
+    /**
+     * Parse component name from file path
+     */
+    static parseComponentName(path) {
+        if (path.includes('/jobs/')) {
+            const jobMatch = path.match(/\/jobs\/[^/]+\/[^/]+\/([^/]+)\.md$/);
+            if (jobMatch) {
+                return { type: 'job', name: jobMatch[1] };
+            }
+        }
+        if (path.includes('/skills/')) {
+            const skillMatch = path.match(/\/skills\/[^/]+\/([^/]+)\.md$/);
+            if (skillMatch) {
+                return { type: 'skill', name: skillMatch[1] };
+            }
+        }
+        if (path.includes('/rules/')) {
+            const ruleMatch = path.match(/\/rules\/[^/]+\/([^/]+)\.md$/);
+            if (ruleMatch) {
+                return { type: 'rule', name: ruleMatch[1] };
+            }
+        }
+        return null;
+    }
+}
+exports.UsageCollector = UsageCollector;

package/index.js

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

package/package.json

@@ -1,19 +1,19 @@
 {
   "name": "fraim-framework",
-  "version": "2.0.90",
+  "version": "2.0.92",
   "description": "FRAIM v2: Framework for Rigor-based AI Management - Transform from solo developer to AI manager orchestrating production-ready code with enterprise-grade discipline",
   "main": "index.js",
   "bin": {
     "fraim": "./index.js",
-    "fraim-framework": "./index.js",
-    "fraim-mcp": "./bin/fraim-mcp.js"
+    "fraim-framework": "./index.js"
   },
   "scripts": {
     "dev": "tsx --watch src/fraim-mcp-server.ts > server.log 2>&1",
     "dev:prod": "npm run build && node dist/src/fraim-mcp-server.js > server.log 2>&1",
-    "build": "tsc && npm run build:stubs && npm run build:fraim-brain && node scripts/copy-registry.js && npm run validate:registry && npm run validate:fraim-pro-assets && tsx scripts/validate-purity.ts",
+    "build": "tsc && npm run build:stubs && npm run build:fraim-brain && npm run build:config-schema && node scripts/copy-registry.js && npm run validate:registry && npm run validate:fraim-pro-assets && tsx scripts/validate-purity.ts",
     "build:stubs": "tsx scripts/build-stub-registry.ts",
     "build:fraim-brain": "node scripts/generate-fraim-brain.js",
+    "build:config-schema": "tsx scripts/generate-config-schema-template.ts",
     "test-all": "npm run test && npm run test:isolated && npm run test:ui",
     "test": "node scripts/test-with-server.js",
     "test:isolated": "npx tsx --test --test-reporter=spec tests/isolated/test-*.ts",
@@ -36,7 +36,7 @@
     "postinstall": "fraim sync --skip-updates || echo 'FRAIM setup skipped.'",
     "prepublishOnly": "npm run build",
     "release": "npm version patch && npm publish",
-    "validate:registry": "tsx scripts/verify-registry-paths.ts && npm run validate:workflows && npm run validate:skills && npm run validate:platform-agnostic && npm run validate:template-namespaces && npm run validate:config-fallbacks && npm run validate:bootstrap-config-coverage && npm run validate:provider-action-mappings && npm run validate:fidelity && npm run validate:config-tokens && npm run validate:brain-mapping",
+    "validate:registry": "tsx scripts/verify-registry-paths.ts && npm run validate:workflows && npm run validate:skills && npm run validate:platform-agnostic && npm run validate:template-namespaces && npm run validate:config-fallbacks && npm run validate:bootstrap-config-coverage && npm run validate:provider-action-mappings && npm run validate:fidelity && npm run validate:config-tokens && npm run validate:brain-mapping && npm run validate:template-syntax",
     "validate:brain-mapping": "tsx scripts/validate-brain-mapping.ts",
     "validate:fraim-pro-assets": "tsx scripts/validate-fraim-pro-assets.ts",
     "validate:workflows": "tsx scripts/validate-workflows.ts",
@@ -47,7 +47,8 @@
     "validate:bootstrap-config-coverage": "tsx scripts/validate-bootstrap-config-coverage.ts",
     "validate:provider-action-mappings": "tsx scripts/validate-provider-action-mappings.ts",
     "validate:fidelity": "tsx scripts/validate-fidelity.ts",
-    "validate:config-tokens": "tsx scripts/validate-config-tokens.ts"
+    "validate:config-tokens": "tsx scripts/validate-config-tokens.ts",
+    "validate:template-syntax": "tsx scripts/validate-template-syntax.ts"
   },
   "repository": {
     "type": "git",
@@ -82,10 +83,12 @@
   },
   "devDependencies": {
     "@playwright/test": "^1.58.2",
+    "@types/adm-zip": "^0.5.7",
     "@types/cors": "^2.8.19",
     "@types/express": "^5.0.6",
     "@types/node": "^20.0.0",
     "@types/prompts": "^2.4.9",
+    "@types/semver": "^7.7.1",
     "fast-glob": "^3.3.3",
     "html-to-docx": "^1.8.0",
     "markdown-it": "^14.1.1",
@@ -114,6 +117,7 @@
     "access": "public"
   },
   "dependencies": {
+    "adm-zip": "^0.5.16",
     "axios": "^1.7.0",
     "chalk": "4.1.2",
     "commander": "^14.0.2",
@@ -124,8 +128,10 @@
     "node-edge-tts": "^1.2.10",
     "prompts": "^2.4.2",
     "resend": "^6.9.3",
+    "semver": "^7.7.4",
     "stripe": "^20.3.1",
     "toml": "^3.0.0",
-    "tree-kill": "^1.2.2"
+    "tree-kill": "^1.2.2",
+    "xml2js": "^0.6.2"
   }
 }

package/bin/fraim-mcp.js

@@ -1,63 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * FRAIM MCP Server - Smart Entry Point
- * This file handles both production (dist/) and development (src/) environments.
- */
-
-const path = require('path');
-const fs = require('fs');
-const { spawn } = require('child_process');
-
-/**
- * Runs the MCP server using either the compiled JS or the source TS via tsx
- */
-function runMCPServer() {
-    const distPath = path.join(__dirname, '..', 'dist', 'src', 'local-mcp-server', 'stdio-server.js');
-    const srcPath = path.join(__dirname, '..', 'src', 'local-mcp-server', 'stdio-server.ts');
-
-    // 1. Check if we have a compiled version (Production / CI)
-    if (fs.existsSync(distPath)) {
-        // Use spawn to run the compiled JS so it's treated as the main module
-        const result = spawn('node', [distPath, ...process.argv.slice(2)], {
-            stdio: 'inherit',
-            shell: false,
-            windowsHide: true
-        });
-        
-        // Forward exit code
-        result.on('exit', (code) => {
-            process.exit(code || 0);
-        });
-        
-        return;
-    }
-
-    // 2. Fallback to source version using tsx (Development)
-    if (fs.existsSync(srcPath)) {
-        // Use spawn to run tsx so it handles stdio correctly for MCP
-        const result = spawn('npx', ['tsx', srcPath, ...process.argv.slice(2)], {
-            stdio: 'inherit',
-            shell: true,
-            windowsHide: true
-        });
-        
-        // Forward exit code
-        result.on('exit', (code) => {
-            process.exit(code || 0);
-        });
-        
-        return;
-    }
-
-    console.error('❌ FRAIM MCP Server Error: Could not find server entry point.');
-    console.error('Expected one of:');
-    console.error(` - ${distPath}`);
-    console.error(` - ${srcPath}`);
-    process.exit(1);
-}
-
-// If this file is run directly, run the MCP server
-if (require.main === module) {
-    runMCPServer();
-}