fraim-framework 2.0.64 → 2.0.65

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

@@ -44,11 +44,21 @@ class FraimLocalMCPServer {
         this.log(`📡 Remote server: ${this.remoteUrl}`);
         this.log(`🔑 API key: ${this.apiKey.substring(0, 10)}...`);
         this.log(`Local MCP version: ${this.localVersion}`);
+        this.log(`🔍 DEBUG BUILD: Machine detection v2 active`);
     }
     log(message) {
         // Log to stderr (stdout is reserved for MCP protocol)
         const key = this.apiKey || 'MISSING_API_KEY';
         console.error(`[FRAIM key:${key}] ${message}`);
+        // Also log to file for debugging
+        try {
+            const fs = require('fs');
+            const logFile = require('path').join(require('os').tmpdir(), 'fraim-mcp-proxy.log');
+            fs.appendFileSync(logFile, `${new Date().toISOString()} [${key}] ${message}\n`);
+        }
+        catch (e) {
+            // Ignore file logging errors
+        }
     }
     logError(message) {
         const key = this.apiKey || 'MISSING_API_KEY';
@@ -89,6 +99,12 @@ class FraimLocalMCPServer {
         this.log(`   INIT_CWD: ${process.env.INIT_CWD || '(not set)'}`);
         this.log(`   HOME: ${process.env.HOME || '(not set)'}`);
         this.log(`   USERPROFILE: ${process.env.USERPROFILE || '(not set)'}`);
+        this.log(`   PWD: ${process.env.PWD || '(not set)'}`);
+        this.log(`   OLDPWD: ${process.env.OLDPWD || '(not set)'}`);
+        // Log ALL env vars that might contain workspace info
+        Object.keys(process.env).filter(k => k.toLowerCase().includes('workspace') || k.toLowerCase().includes('project') || k.toLowerCase().includes('kiro')).forEach(k => {
+            this.log(`   ${k}: ${process.env[k]}`);
+        });
         // Priority 1: Check for IDE-provided workspace environment variables
         const workspaceHints = [
             process.env.WORKSPACE_FOLDER_PATHS?.split(':')[0], // Cursor provides this (colon-separated for multi-root)
@@ -160,6 +176,7 @@ class FraimLocalMCPServer {
      */
     detectMachineInfo() {
         if (this.machineInfo) {
+            this.log(`🔄 Returning cached machine info: ${JSON.stringify(this.machineInfo)}`);
             return this.machineInfo;
         }
         try {
@@ -169,7 +186,7 @@ class FraimLocalMCPServer {
                 memory: (0, os_1.totalmem)(),
                 cpus: (0, os_1.cpus)().length
             };
-            this.log(`✅ Detected machine info: ${this.machineInfo.hostname} (${this.machineInfo.platform})`);
+            this.log(`✅ Detected machine info: ${JSON.stringify(this.machineInfo)}`);
             return this.machineInfo;
         }
         catch (error) {
@@ -512,7 +529,10 @@ class FraimLocalMCPServer {
                     ...args.machine, // Agent values as fallback
                     ...detectedMachine // Detected values override (always win)
                 };
-                this.log(`[req:${requestId}] Auto-detected and injected machine info: ${args.machine.hostname} (${args.machine.platform}), ${Math.round(args.machine.memory / 1024 / 1024 / 1024)}GB RAM, ${args.machine.cpus} CPUs`);
+                this.log(`[req:${requestId}] Auto-detected and injected machine info: ${JSON.stringify(args.machine)}`);
+                if (!args.machine.memory || !args.machine.cpus) {
+                    this.logError(`[req:${requestId}] WARNING: Machine info missing memory or cpus! Detected: ${JSON.stringify(detectedMachine)}, Final: ${JSON.stringify(args.machine)}`);
+                }
                 // REQUIRED: Auto-detect and inject repo info
                 const detectedRepo = this.detectRepoInfo();
                 if (detectedRepo) {
@@ -631,7 +651,7 @@ class FraimLocalMCPServer {
             // Proxy initialize to remote server first
             const response = await this.proxyToRemote(request);
             const processedResponse = this.processResponse(response);
-            // After successful initialization, load config using fallback methods
+            // After successful initialization, load config
             if (!processedResponse.error) {
                 // For now, don't request roots - just use env var + upward search
                 // TODO: Implement roots/list properly after initialization is complete

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

@@ -0,0 +1,130 @@
+"use strict";
+/**
+ * Remote Registry Sync
+ *
+ * Fetches workflows and scripts from the remote FRAIM server
+ * instead of bundling them in the npm package.
+ *
+ * Issue: #83 - Minimize client package by fetching registry remotely
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncFromRemote = syncFromRemote;
+const axios_1 = __importDefault(require("axios"));
+const fs_1 = require("fs");
+const path_1 = require("path");
+const chalk_1 = __importDefault(require("chalk"));
+const script_sync_utils_1 = require("./script-sync-utils");
+/**
+ * Sync workflows and scripts from remote FRAIM server
+ */
+async function syncFromRemote(options) {
+    const remoteUrl = options.remoteUrl || process.env.FRAIM_REMOTE_URL || 'https://fraim.wellnessatwork.me';
+    const apiKey = options.apiKey || process.env.FRAIM_API_KEY || '';
+    if (!apiKey) {
+        return {
+            success: false,
+            workflowsSynced: 0,
+            scriptsSynced: 0,
+            error: 'FRAIM_API_KEY not set'
+        };
+    }
+    try {
+        console.log(chalk_1.default.blue('🔄 Syncing from remote FRAIM server...'));
+        console.log(chalk_1.default.gray(`   Remote: ${remoteUrl}`));
+        // Fetch registry files from remote server
+        const response = await axios_1.default.get(`${remoteUrl}/api/registry/sync`, {
+            headers: {
+                'x-api-key': apiKey
+            },
+            timeout: 30000
+        });
+        const files = response.data.files || [];
+        if (!files || files.length === 0) {
+            console.log(chalk_1.default.yellow('⚠️  No files received from remote server'));
+            return {
+                success: false,
+                workflowsSynced: 0,
+                scriptsSynced: 0,
+                error: 'No files received'
+            };
+        }
+        // Sync workflows
+        const workflowFiles = files.filter(f => f.type === 'workflow');
+        const workflowsDir = (0, path_1.join)(options.projectRoot, '.fraim', 'workflows');
+        if (!(0, fs_1.existsSync)(workflowsDir)) {
+            (0, fs_1.mkdirSync)(workflowsDir, { recursive: true });
+        }
+        // Clean existing workflows
+        cleanDirectory(workflowsDir);
+        // Write workflow files
+        for (const file of workflowFiles) {
+            const filePath = (0, path_1.join)(workflowsDir, file.path);
+            const fileDir = (0, path_1.dirname)(filePath);
+            if (!(0, fs_1.existsSync)(fileDir)) {
+                (0, fs_1.mkdirSync)(fileDir, { recursive: true });
+            }
+            (0, fs_1.writeFileSync)(filePath, file.content, 'utf8');
+            console.log(chalk_1.default.gray(`  + ${file.path}`));
+        }
+        // Sync scripts to user directory
+        const scriptFiles = files.filter(f => f.type === 'script');
+        const userDir = (0, script_sync_utils_1.getUserFraimDir)();
+        const scriptsDir = (0, path_1.join)(userDir, 'scripts');
+        if (!(0, fs_1.existsSync)(scriptsDir)) {
+            (0, fs_1.mkdirSync)(scriptsDir, { recursive: true });
+        }
+        // Clean existing scripts
+        cleanDirectory(scriptsDir);
+        // Write script files
+        for (const file of scriptFiles) {
+            const filePath = (0, path_1.join)(scriptsDir, file.path);
+            const fileDir = (0, path_1.dirname)(filePath);
+            if (!(0, fs_1.existsSync)(fileDir)) {
+                (0, fs_1.mkdirSync)(fileDir, { recursive: true });
+            }
+            (0, fs_1.writeFileSync)(filePath, file.content, 'utf8');
+            console.log(chalk_1.default.gray(`  + ${file.path}`));
+        }
+        console.log(chalk_1.default.green(`\n✅ Synced ${workflowFiles.length} workflows and ${scriptFiles.length} scripts from remote`));
+        return {
+            success: true,
+            workflowsSynced: workflowFiles.length,
+            scriptsSynced: scriptFiles.length
+        };
+    }
+    catch (error) {
+        console.error(chalk_1.default.red(`❌ Remote sync failed: ${error.message}`));
+        return {
+            success: false,
+            workflowsSynced: 0,
+            scriptsSynced: 0,
+            error: error.message
+        };
+    }
+}
+/**
+ * Clean directory contents (but keep the directory itself)
+ */
+function cleanDirectory(dirPath) {
+    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);
+        if (entry.isDirectory()) {
+            cleanDirectory(fullPath);
+            try {
+                (0, fs_1.rmdirSync)(fullPath);
+            }
+            catch (e) {
+                // Directory not empty, skip
+            }
+        }
+        else {
+            (0, fs_1.unlinkSync)(fullPath);
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fraim-framework",
-  "version": "2.0.64",
+  "version": "2.0.65",
   "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": {
@@ -9,6 +9,7 @@
   },
   "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 && node scripts/copy-ai-manager-rules.js && npm run build:stubs && npm run validate:registry",
     "build:stubs": "tsx scripts/build-stub-registry.ts",
     "test": "node scripts/test-with-server.js",
@@ -74,8 +75,6 @@
     "dist/src/cli/",
     "dist/src/fraim/",
     "dist/src/utils/",
-    "registry/stubs/",
-    "registry/scripts/",
     "bin/fraim.js",
     "bin/fraim-mcp.js",
     "index.js",

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

@@ -1,239 +0,0 @@
-"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/validate-workflows.js

@@ -1,101 +0,0 @@
-"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);
-    }
-}