fraim-framework 2.0.60 → 2.0.63

package/dist/src/utils/enforcement-utils.js

@@ -0,0 +1,239 @@
+"use strict";
+/**
+ * Enforcement Utilities for FRAIM
+ *
+ * Provides deterministic enforcement of:
+ * - Working style (PR vs Conversation)
+ * - Feedback tracking requirements
+ * - User config initialization
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initializeUserConfig = initializeUserConfig;
+exports.loadUserConfig = loadUserConfig;
+exports.getEnforcementContext = getEnforcementContext;
+exports.isCommitAllowed = isCommitAllowed;
+exports.checkUnaddressedFeedback = checkUnaddressedFeedback;
+exports.generateCommitInstructions = generateCommitInstructions;
+exports.generateFeedbackInstructions = generateFeedbackInstructions;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const child_process_1 = require("child_process");
+const script_sync_utils_js_1 = require("./script-sync-utils.js");
+const git_utils_js_1 = require("./git-utils.js");
+/**
+ * Initialize user config with default values if it doesn't exist
+ */
+function initializeUserConfig() {
+    try {
+        const userConfigPath = (0, path_1.join)((0, script_sync_utils_js_1.getUserFraimDir)(), 'config.json');
+        if (!(0, fs_1.existsSync)(userConfigPath)) {
+            const defaultConfig = {
+                workingStyle: 'PR' // Default to PR mode
+            };
+            // Ensure directory exists
+            const userFraimDir = (0, script_sync_utils_js_1.getUserFraimDir)();
+            if (!(0, fs_1.existsSync)(userFraimDir)) {
+                const { mkdirSync } = require('fs');
+                mkdirSync(userFraimDir, { recursive: true });
+            }
+            (0, fs_1.writeFileSync)(userConfigPath, JSON.stringify(defaultConfig, null, 2));
+        }
+    }
+    catch (error) {
+        console.warn('⚠️ Failed to initialize user config:', error);
+    }
+}
+/**
+ * Load user config from ~/.fraim/config.json
+ */
+function loadUserConfig() {
+    try {
+        const userConfigPath = (0, path_1.join)((0, script_sync_utils_js_1.getUserFraimDir)(), 'config.json');
+        if ((0, fs_1.existsSync)(userConfigPath)) {
+            const content = (0, fs_1.readFileSync)(userConfigPath, 'utf8');
+            return JSON.parse(content);
+        }
+    }
+    catch (error) {
+        console.warn('⚠️ Failed to load user config:', error);
+    }
+    return null;
+}
+/**
+ * Get enforcement context (working style, branch info)
+ */
+function getEnforcementContext(issueNumber, projectRoot) {
+    const userConfig = loadUserConfig();
+    const workingStyle = userConfig?.workingStyle || 'PR'; // Default to PR
+    let currentBranch = null;
+    let defaultBranch = null;
+    try {
+        currentBranch = (0, git_utils_js_1.getCurrentGitBranch)();
+        // Try to get default branch
+        try {
+            const remoteHead = (0, child_process_1.execSync)('git symbolic-ref refs/remotes/origin/HEAD', {
+                timeout: 2000,
+                stdio: 'pipe'
+            }).toString().trim();
+            const match = remoteHead.match(/refs\/remotes\/origin\/(.+)$/);
+            if (match) {
+                defaultBranch = match[1];
+            }
+        }
+        catch (e) {
+            defaultBranch = 'main'; // Fallback
+        }
+    }
+    catch (e) {
+        // Not a git repo or git command failed
+    }
+    return {
+        workingStyle,
+        currentBranch,
+        defaultBranch,
+        issueNumber,
+        projectRoot
+    };
+}
+/**
+ * Check if agent commit is allowed based on working style
+ * Note: In Conversation mode, agent NEVER commits (user commits manually)
+ */
+function isCommitAllowed(context) {
+    // If Conversation style, agent NEVER commits (user commits manually)
+    if (context.workingStyle === 'Conversation') {
+        return {
+            allowed: false,
+            reason: 'Working style is "Conversation" - agent does not commit. User commits manually.'
+        };
+    }
+    // PR style: commits only allowed on feature branches, not main/master
+    if (!context.currentBranch) {
+        return {
+            allowed: false,
+            reason: 'Not in a git repository or unable to determine current branch'
+        };
+    }
+    const defaultBranch = context.defaultBranch || 'main';
+    const isDefaultBranch = context.currentBranch === defaultBranch ||
+        context.currentBranch === 'master' ||
+        context.currentBranch === 'main';
+    if (isDefaultBranch) {
+        return {
+            allowed: false,
+            reason: `Working style is "PR" but you are on ${context.currentBranch} branch. Create a feature branch first.`
+        };
+    }
+    return { allowed: true };
+}
+/**
+ * Check for unaddressed feedback files
+ */
+function checkUnaddressedFeedback(issueNumber, projectRoot) {
+    const feedbackFiles = [];
+    if (!projectRoot) {
+        return { hasUnaddressed: false, feedbackFiles: [] };
+    }
+    try {
+        const evidenceDir = (0, path_1.join)(projectRoot, 'docs', 'evidence');
+        if (!(0, fs_1.existsSync)(evidenceDir)) {
+            return { hasUnaddressed: false, feedbackFiles: [] };
+        }
+        const files = (0, fs_1.readdirSync)(evidenceDir);
+        const issueFeedbackPattern = new RegExp(`^${issueNumber}-.*-feedback\\.md$`);
+        for (const file of files) {
+            if (issueFeedbackPattern.test(file)) {
+                const filePath = (0, path_1.join)(evidenceDir, file);
+                const content = (0, fs_1.readFileSync)(filePath, 'utf8');
+                // Check if feedback is addressed (look for "Status: Addressed" or similar markers)
+                // Simple heuristic: if file contains "Status: Addressed" or "✅ Addressed", consider it addressed
+                // If it contains "Status: Unaddressed", it's definitely unaddressed
+                const hasUnaddressed = /status:\s*unaddressed/i.test(content);
+                const isAddressed = /status:\s*addressed|✅\s*addressed/i.test(content);
+                // If explicitly unaddressed, or if no addressed markers found at all, consider unaddressed
+                // Note: If file has both, "Unaddressed" takes precedence
+                if (hasUnaddressed || (!hasUnaddressed && !isAddressed)) {
+                    feedbackFiles.push(file);
+                }
+            }
+        }
+    }
+    catch (error) {
+        console.warn('⚠️ Failed to check feedback files:', error);
+    }
+    return {
+        hasUnaddressed: feedbackFiles.length > 0,
+        feedbackFiles
+    };
+}
+/**
+ * Generate commit behavior instructions based on working style
+ */
+function generateCommitInstructions(context) {
+    // Check commit permission first (handles both Conversation and PR modes)
+    const commitCheck = isCommitAllowed(context);
+    if (context.workingStyle === 'Conversation') {
+        // Conversation mode: Agent never commits, user commits manually
+        return `\n\n**⚠️ Working Style: Conversation**\n\n` +
+            `You are in "Conversation" mode. **DO NOT commit changes**. The user will commit manually.\n\n` +
+            `**Branch Strategy**:\n` +
+            `- Work directly on ${context.defaultBranch || 'main/master'} branch\n` +
+            `- **Skip branch creation**: No need to run prep-issue.sh or create feature branches\n` +
+            `- **Skip PR creation**: Work is committed directly to ${context.defaultBranch || 'main/master'}\n\n` +
+            `**Commit Behavior**:\n` +
+            `- Make changes as requested\n` +
+            `- Do not use git commit tools\n` +
+            `- Show diff to user: "I've made these changes: [show diff]"\n` +
+            `- Suggest commit message if helpful\n` +
+            `- Wait for user to review and commit manually\n\n` +
+            `**Outcome Statements**: When documenting completion, use:\n` +
+            `- "All work ready for user review and commit" (instead of "committed to feature branch")\n` +
+            `- "Changes prepared on ${context.defaultBranch || 'main/master'} branch"\n`;
+    }
+    // PR style: Check if commits are allowed
+    if (!commitCheck.allowed) {
+        // Blocked: either on main/master or not in git repo
+        return `\n\n**⚠️ Working Style: PR**\n\n` +
+            `**BLOCKED**: ${commitCheck.reason}\n\n` +
+            `**Action Required**:\n` +
+            `1. Run prep-issue script: \`~/.fraim/scripts/prep-issue.sh ${context.issueNumber || 'ISSUE_NUMBER'}\`\n` +
+            `   OR create feature branch manually: \`git checkout -b feature/${context.issueNumber || 'issue'}-description\`\n` +
+            `2. Push branch: \`git push -u origin feature/${context.issueNumber || 'issue'}-description\`\n` +
+            `3. Then proceed with your work\n` +
+            `**DO NOT commit to ${context.currentBranch || 'main/master'} branch.**\n`;
+    }
+    // PR mode on feature branch: Commits allowed
+    return `\n\n**✅ Working Style: PR**\n\n` +
+        `You are in "PR" mode. Commits are allowed on feature branch: **${context.currentBranch}**\n\n` +
+        `**Branch Setup**:\n` +
+        `- If branch doesn't exist, run: \`~/.fraim/scripts/prep-issue.sh ${context.issueNumber || 'ISSUE_NUMBER'}\`\n` +
+        `- Confirm you're on feature branch: \`git branch --show-current\`\n\n` +
+        `**Commit Behavior**:\n` +
+        `- Create commits on this branch as you complete work\n` +
+        `- Commit message format: \`{workflow_type}({issue_number}): {description}\`\n` +
+        `- Push branch: \`git push origin ${context.currentBranch}\`\n\n` +
+        `**PR Management**:\n` +
+        `- Create PR when ready for review\n` +
+        `- **Verify PR exists** before marking work complete\n` +
+        `- Link PR to issue and add evidence document link\n\n` +
+        `**Outcome Statements**: When documenting completion, use:\n` +
+        `- "All work committed and pushed to feature branch: ${context.currentBranch}"\n`;
+}
+/**
+ * Generate feedback check instructions
+ */
+function generateFeedbackInstructions(issueNumber, projectRoot) {
+    const feedbackCheck = checkUnaddressedFeedback(issueNumber, projectRoot);
+    if (!feedbackCheck.hasUnaddressed) {
+        return '';
+    }
+    return `\n\n**⚠️ Unaddressed Feedback Detected**\n\n` +
+        `The following feedback files need to be addressed before proceeding:\n` +
+        feedbackCheck.feedbackFiles.map(f => `- \`docs/evidence/${f}\``).join('\n') +
+        `\n\n**Action Required**:\n` +
+        `1. Review each feedback file\n` +
+        `2. Address all feedback items\n` +
+        `3. Mark feedback as addressed in the file\n` +
+        `4. Then continue with this phase\n` +
+        `\n**DO NOT proceed until all feedback is addressed.**\n`;
+}

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

@@ -5,7 +5,6 @@ exports.determineDatabaseName = determineDatabaseName;
 exports.getCurrentGitBranch = getCurrentGitBranch;
 exports.determineSchema = determineSchema;
 exports.getDefaultBranch = getDefaultBranch;
-exports.getGitRemoteInfo = getGitRemoteInfo;
 const child_process_1 = require("child_process");
 /**
  * Gets a unique port based on the current git branch name (if it's an issue branch)
@@ -94,29 +93,3 @@ function getDefaultBranch() {
     // Default fallback
     return 'main';
 }
-/**
- * Gets the GitHub remote info (owner and repo name)
- */
-function getGitRemoteInfo() {
-    try {
-        const remoteUrl = (0, child_process_1.execSync)('git remote get-url origin', {
-            timeout: 2000, // 2 second timeout
-            stdio: 'pipe'
-        }).toString().trim();
-        // Match both HTTPS and SSH formats
-        // HTTPS: https://github.com/owner/repo.git OR https://github.com/owner/repo
-        // SSH: git@github.com:owner/repo.git OR git@github.com:owner/repo
-        const match = remoteUrl.match(/github\.com[/:]([^/]+)\/([^/.]+?)(?:\.git)?$/);
-        if (match) {
-            return {
-                owner: match[1],
-                repo: match[2],
-                defaultBranch: getDefaultBranch()
-            };
-        }
-    }
-    catch (e) {
-        // Silently fail if not a git repo or no origin
-    }
-    return { owner: null, repo: null };
-}

package/dist/src/utils/platform-detection.js

@@ -138,7 +138,7 @@ function extractAdoInfo(url) {
         };
     }
     // visualstudio.com format
-    match = url.match(/([^\.]+)\.visualstudio\.com\/([^\/]+)\/_git\/([^\/\.]+)/i);
+    match = url.match(/https?:\/\/([^\.]+)\.visualstudio\.com\/([^\/]+)\/_git\/([^\/\.]+)/i);
     if (match) {
         return {
             provider: 'ado',

package/dist/src/utils/script-sync-utils.js

@@ -31,7 +31,7 @@ function getUserScriptsDir() {
     return path_1.default.join(getUserFraimDir(), 'scripts');
 }
 /**
- * Ensure the user-level FRAIM directories exist
+ * Ensure the user-level FRAIM directories exist and initialize user config
  */
 function ensureUserFraimDirectories() {
     const userFraimDir = getUserFraimDir();
@@ -42,6 +42,11 @@ function ensureUserFraimDirectories() {
     if (!fs_1.default.existsSync(userScriptsDir)) {
         fs_1.default.mkdirSync(userScriptsDir, { recursive: true });
     }
+    // Initialize user config (~/.fraim/config.json) if it doesn't exist
+    const userConfigPath = path_1.default.join(userFraimDir, 'config.json');
+    if (!fs_1.default.existsSync(userConfigPath)) {
+        fs_1.default.writeFileSync(userConfigPath, JSON.stringify({ workingStyle: 'PR' }, null, 2));
+    }
 }
 /**
  * Get all script files from the registry (recursively)

package/dist/src/utils/validate-workflows.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateAllWorkflows = validateAllWorkflows;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const workflow_parser_js_1 = require("./workflow-parser.js");
+/**
+ * Validate all workflows in the registry
+ */
+function validateAllWorkflows(registryPath) {
+    const errors = [];
+    const workflowFiles = [];
+    function findWorkflows(dir) {
+        if (!(0, fs_1.existsSync)(dir))
+            return;
+        const entries = (0, fs_1.readdirSync)(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = (0, path_1.join)(dir, entry.name);
+            if (entry.isDirectory()) {
+                findWorkflows(fullPath);
+            }
+            else if (entry.isFile() && entry.name.endsWith('.md')) {
+                const content = (0, fs_1.readFileSync)(fullPath, 'utf-8');
+                if (content.includes('"initialPhase"')) {
+                    workflowFiles.push(fullPath);
+                }
+            }
+        }
+    }
+    findWorkflows(registryPath);
+    console.log(`🔍 Validating ${workflowFiles.length} workflows...`);
+    for (const filePath of workflowFiles) {
+        const relativePath = filePath.replace(registryPath, '');
+        try {
+            const wf = workflow_parser_js_1.WorkflowParser.parse(filePath);
+            if (!wf) {
+                errors.push(`❌ ${relativePath}: Failed to parse. Ensure JSON metadata is present and valid.`);
+                continue;
+            }
+            const { metadata, phases } = wf;
+            // 1. Initial Phase check
+            if (!phases.has(metadata.initialPhase)) {
+                errors.push(`❌ ${relativePath}: initialPhase "${metadata.initialPhase}" does not exist in phases.`);
+            }
+            // 2. Validate Phase Flow
+            for (const [phaseId, flow] of Object.entries(metadata.phases)) {
+                // Check if phase exists in markdown
+                if (!phases.has(phaseId)) {
+                    errors.push(`❌ ${relativePath}: Phase "${phaseId}" defined in metadata but missing in markdown.`);
+                }
+                // Check Success transition
+                if (flow.onSuccess && flow.onSuccess !== 'null') {
+                    if (typeof flow.onSuccess === 'string') {
+                        if (!phases.has(flow.onSuccess)) {
+                            errors.push(`❌ ${relativePath}: Phase "${phaseId}" transition onSuccess -> "${flow.onSuccess}" target not found.`);
+                        }
+                    }
+                    else {
+                        // Validate each branch of conditional success
+                        for (const [branch, target] of Object.entries(flow.onSuccess)) {
+                            if (target && target !== 'null' && !phases.has(target)) {
+                                errors.push(`❌ ${relativePath}: Phase "${phaseId}" conditional transition onSuccess[${branch}] -> "${target}" target not found.`);
+                            }
+                        }
+                    }
+                }
+                // Check Failure transition
+                if (flow.onFailure && !phases.has(flow.onFailure)) {
+                    errors.push(`❌ ${relativePath}: Phase "${phaseId}" transition onFailure -> "${flow.onFailure}" target not found.`);
+                }
+            }
+            // 3. Check for orphaned phases in markdown
+            for (const phaseId of phases.keys()) {
+                if (!metadata.phases[phaseId]) {
+                    errors.push(`⚠️  ${relativePath}: Phase "${phaseId}" exists in markdown but is NOT defined in JSON metadata.`);
+                }
+            }
+        }
+        catch (e) {
+            errors.push(`❌ ${relativePath}: Unexpected error: ${e.message}`);
+        }
+    }
+    return {
+        valid: errors.filter(e => e.startsWith('❌')).length === 0,
+        errors
+    };
+}
+// Run if called directly
+if (process.argv[1]?.includes('validate-workflows')) {
+    const registryPath = process.argv[2] || (0, path_1.join)(process.cwd(), 'registry');
+    const result = validateAllWorkflows(registryPath);
+    result.errors.forEach(err => console.error(err));
+    if (result.valid) {
+        console.log('✅ All workflows validated successfully.');
+        process.exit(0);
+    }
+    else {
+        console.error('❌ Workflow validation failed.');
+        process.exit(1);
+    }
+}

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

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

package/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fraim-framework",
-  "version": "2.0.60",
+  "version": "2.0.63",
   "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": {
@@ -25,8 +25,9 @@
     "release": "npm version patch && npm publish",
     "test-smoke-ci": "tsx --test tests/test-genericization.ts tests/test-cli.ts tests/test-stub-registry.ts tests/test-sync-stubs.ts",
     "test-all-ci": "tsx --test tests/test-*.ts",
-    "validate:registry": "tsx scripts/verify-registry-paths.ts && npm run validate:workflows",
-    "validate:workflows": "tsx scripts/validate-workflows.ts"
+    "validate:registry": "tsx scripts/verify-registry-paths.ts && npm run validate:workflows && npm run validate:platform-agnostic",
+    "validate:workflows": "tsx scripts/validate-workflows.ts",
+    "validate:platform-agnostic": "tsx scripts/validate-platform-agnostic.ts"
   },
   "repository": {
     "type": "git",

package/bin/fraim.js

@@ -1,23 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * FRAIM Framework CLI Entry Point
- *
- * This file delegates to the compiled TypeScript implementation.
- */
-
-try {
-    // In production/installed package, code is in dist/
-    require('../dist/src/cli/fraim.js');
-} catch (error) {
-    if (error.code === 'MODULE_NOT_FOUND') {
-        // In development (local clone), we might use tsx if dist is missing
-        // But typically we should just tell user to build.
-        console.error('❌ Could not find FRAIM CLI implementation.');
-        console.error('   If you are running from source, please run "npm run build" first.');
-        console.error(`   Error details: ${error.message}`);
-        process.exit(1);
-    } else {
-        throw error;
-    }
-}

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

@@ -1,65 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mcpCommand = void 0;
-const commander_1 = require("commander");
-const server_1 = require("../../local-mcp-server/server");
-const chalk_1 = __importDefault(require("chalk"));
-exports.mcpCommand = new commander_1.Command('mcp')
-    .description('Start the local FRAIM MCP server')
-    .option('-p, --port <port>', 'Port to run the server on', '3003')
-    .option('--remote-only', 'Use remote server only (skip local proxy)', false)
-    .action(async (options) => {
-    try {
-        if (options.remoteOnly) {
-            console.log(chalk_1.default.yellow('⚠️ Remote-only mode not yet implemented'));
-            console.log(chalk_1.default.blue('ℹ️ Starting local MCP server instead...'));
-        }
-        const port = parseInt(options.port);
-        if (isNaN(port) || port < 1 || port > 65535) {
-            console.error(chalk_1.default.red('❌ Invalid port number. Must be between 1 and 65535.'));
-            process.exit(1);
-        }
-        console.log(chalk_1.default.blue('🚀 Starting FRAIM Local MCP Server...'));
-        console.log(chalk_1.default.gray(`📡 Port: ${port}`));
-        console.log(chalk_1.default.gray(`🔄 Auto-updates: Every 5 minutes`));
-        console.log(chalk_1.default.gray(`📁 Cache: ~/.fraim/cache`));
-        console.log('');
-        // Set the port in environment
-        process.env.FRAIM_LOCAL_MCP_PORT = port.toString();
-        // Start the server
-        await (0, server_1.startLocalMCPServer)();
-        // Server is now running, show configuration instructions
-        console.log('');
-        console.log(chalk_1.default.green('✅ FRAIM Local MCP Server is running!'));
-        console.log('');
-        console.log(chalk_1.default.bold('📋 Agent Configuration:'));
-        console.log('');
-        console.log(chalk_1.default.gray('Add this to your agent\'s MCP configuration:'));
-        console.log('');
-        console.log(chalk_1.default.cyan(JSON.stringify({
-            "mcpServers": {
-                "fraim": {
-                    "command": "fraim",
-                    "args": ["mcp"],
-                    "env": {}
-                }
-            }
-        }, null, 2)));
-        console.log('');
-        console.log(chalk_1.default.bold('🔗 Endpoints:'));
-        console.log(chalk_1.default.gray(`  MCP: http://localhost:${port}/mcp`));
-        console.log(chalk_1.default.gray(`  Health: http://localhost:${port}/health`));
-        console.log('');
-        console.log(chalk_1.default.bold('🛑 To stop the server:'));
-        console.log(chalk_1.default.gray('  Press Ctrl+C'));
-        console.log('');
-    }
-    catch (error) {
-        console.error(chalk_1.default.red('❌ Failed to start Local MCP Server:'));
-        console.error(chalk_1.default.red(error instanceof Error ? error.message : String(error)));
-        process.exit(1);
-    }
-});