fraim 2.0.100

package/dist/src/cli/doctor/checks/scripts-checks.js

@@ -0,0 +1,157 @@
+"use strict";
+/**
+ * Scripts checks for FRAIM doctor command
+ * Validates user scripts directory and sync status
+ * Issue #144: Enhanced doctor command
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getScriptsChecks = getScriptsChecks;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const SCRIPTS_DIR = path_1.default.join(os_1.default.homedir(), '.fraim', 'scripts');
+/**
+ * Check if scripts directory exists
+ */
+function checkScriptsDirectoryExists() {
+    return {
+        name: 'Scripts directory exists',
+        category: 'scripts',
+        critical: false,
+        run: async () => {
+            if (fs_1.default.existsSync(SCRIPTS_DIR)) {
+                return {
+                    status: 'passed',
+                    message: 'Scripts directory exists',
+                    details: { path: SCRIPTS_DIR }
+                };
+            }
+            return {
+                status: 'warning',
+                message: 'Scripts directory missing',
+                suggestion: 'Run fraim sync to hydrate local scripts for the repo.',
+                command: 'fraim sync'
+            };
+        }
+    };
+}
+/**
+ * Check if scripts are synced
+ */
+function checkScriptsSynced() {
+    return {
+        name: 'Scripts synced',
+        category: 'scripts',
+        critical: false,
+        run: async () => {
+            if (!fs_1.default.existsSync(SCRIPTS_DIR)) {
+                return {
+                    status: 'warning',
+                    message: 'Cannot check scripts - directory missing'
+                };
+            }
+            try {
+                const scripts = fs_1.default.readdirSync(SCRIPTS_DIR).filter(f => f.endsWith('.js') || f.endsWith('.ts') || f.endsWith('.sh'));
+                if (scripts.length > 0) {
+                    return {
+                        status: 'passed',
+                        message: `${scripts.length} scripts synced`,
+                        details: { scriptCount: scripts.length }
+                    };
+                }
+                return {
+                    status: 'warning',
+                    message: 'No scripts found',
+                    suggestion: 'Run fraim sync to hydrate local scripts.',
+                    command: 'fraim sync'
+                };
+            }
+            catch (error) {
+                return {
+                    status: 'error',
+                    message: 'Failed to check scripts',
+                    details: { error: error.message }
+                };
+            }
+        }
+    };
+}
+/**
+ * Check if scripts are executable (Unix/Linux/macOS only)
+ */
+function checkScriptsExecutable() {
+    return {
+        name: 'Scripts executable',
+        category: 'scripts',
+        critical: false,
+        run: async () => {
+            // Skip on Windows
+            if (process.platform === 'win32') {
+                return {
+                    status: 'passed',
+                    message: 'Script permissions check skipped (Windows)',
+                    details: { platform: 'win32', reason: 'Windows does not use Unix-style executable permissions' }
+                };
+            }
+            if (!fs_1.default.existsSync(SCRIPTS_DIR)) {
+                return {
+                    status: 'warning',
+                    message: 'Cannot check permissions - directory missing'
+                };
+            }
+            try {
+                const scripts = fs_1.default.readdirSync(SCRIPTS_DIR).filter(f => f.endsWith('.sh'));
+                if (scripts.length === 0) {
+                    return {
+                        status: 'passed',
+                        message: 'No shell scripts to check',
+                        details: { scriptCount: 0 }
+                    };
+                }
+                let nonExecutable = 0;
+                for (const script of scripts) {
+                    const scriptPath = path_1.default.join(SCRIPTS_DIR, script);
+                    const stats = fs_1.default.statSync(scriptPath);
+                    // Check if executable bit is set (mode & 0o111)
+                    if ((stats.mode & 0o111) === 0) {
+                        nonExecutable++;
+                    }
+                }
+                if (nonExecutable === 0) {
+                    return {
+                        status: 'passed',
+                        message: `All ${scripts.length} shell scripts executable`,
+                        details: { scriptCount: scripts.length }
+                    };
+                }
+                return {
+                    status: 'warning',
+                    message: `${nonExecutable} scripts not executable`,
+                    suggestion: `Run: chmod +x ${SCRIPTS_DIR}/*.sh`,
+                    command: `chmod +x ${SCRIPTS_DIR}/*.sh`,
+                    details: { nonExecutable, total: scripts.length }
+                };
+            }
+            catch (error) {
+                return {
+                    status: 'error',
+                    message: 'Failed to check script permissions',
+                    details: { error: error.message }
+                };
+            }
+        }
+    };
+}
+/**
+ * Get all scripts checks
+ */
+function getScriptsChecks() {
+    return [
+        checkScriptsDirectoryExists(),
+        checkScriptsSynced(),
+        checkScriptsExecutable()
+    ];
+}

package/dist/src/cli/doctor/checks/workflow-checks.js

@@ -0,0 +1,251 @@
+"use strict";
+/**
+ * Job checks for FRAIM doctor command
+ * Validates job installation and versions
+ * Issue #144: Enhanced doctor command
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getJobChecks = getJobChecks;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const inheritance_parser_1 = require("../../../core/utils/inheritance-parser");
+const project_fraim_paths_1 = require("../../../core/utils/project-fraim-paths");
+function getJobStubDirs() {
+    return [
+        (0, project_fraim_paths_1.getWorkspaceFraimPath)(process.cwd(), 'ai-employee', 'jobs'),
+        (0, project_fraim_paths_1.getWorkspaceFraimPath)(process.cwd(), 'ai-manager', 'jobs')
+    ];
+}
+/**
+ * Check if jobs directory exists
+ */
+function checkJobsDirectoryExists() {
+    return {
+        name: 'Jobs directory exists',
+        category: 'jobs',
+        critical: true,
+        run: async () => {
+            const jobDirs = getJobStubDirs();
+            const existingJobDirs = jobDirs.filter(fs_1.default.existsSync);
+            if ((0, project_fraim_paths_1.workspaceFraimExists)(process.cwd()) && existingJobDirs.length > 0) {
+                return {
+                    status: 'passed',
+                    message: 'Jobs directory exists',
+                    details: { paths: existingJobDirs }
+                };
+            }
+            return {
+                status: 'error',
+                message: 'Jobs directory missing',
+                suggestion: 'Run fraim sync to hydrate local job stubs. Onboarding can still start through MCP if your agent is already connected.',
+                command: 'fraim sync'
+            };
+        }
+    };
+}
+/**
+ * Check if job stubs are present
+ */
+function checkJobStubsPresent() {
+    return {
+        name: 'Job stubs present',
+        category: 'jobs',
+        critical: false,
+        run: async () => {
+            const jobDirs = getJobStubDirs().filter(fs_1.default.existsSync);
+            if (jobDirs.length === 0) {
+                return {
+                    status: 'error',
+                    message: 'Cannot check stubs - jobs directory missing'
+                };
+            }
+            try {
+                let stubCount = 0;
+                const countStubs = (dir) => {
+                    const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+                    for (const entry of entries) {
+                        if (entry.isDirectory()) {
+                            countStubs(path_1.default.join(dir, entry.name));
+                        }
+                        else if (entry.name.endsWith('.md')) {
+                            stubCount++;
+                        }
+                    }
+                };
+                jobDirs.forEach(countStubs);
+                if (stubCount > 0) {
+                    return {
+                        status: 'passed',
+                        message: `${stubCount} job stubs found`,
+                        details: { stubCount }
+                    };
+                }
+                return {
+                    status: 'warning',
+                    message: 'No job stubs found',
+                    suggestion: 'Run fraim sync to hydrate local job stubs. This does not block agent-led onboarding if MCP access is healthy.',
+                    command: 'fraim sync'
+                };
+            }
+            catch (error) {
+                return {
+                    status: 'error',
+                    message: 'Failed to count job stubs',
+                    details: { error: error.message }
+                };
+            }
+        }
+    };
+}
+/**
+ * Check if jobs are up to date
+ */
+function checkJobsUpToDate() {
+    return {
+        name: 'Jobs up to date',
+        category: 'jobs',
+        critical: false,
+        run: async () => {
+            const configPath = (0, project_fraim_paths_1.getWorkspaceConfigPath)(process.cwd());
+            if (!fs_1.default.existsSync(configPath)) {
+                return {
+                    status: 'warning',
+                    message: 'Cannot check job version - config missing'
+                };
+            }
+            try {
+                const config = JSON.parse(fs_1.default.readFileSync(configPath, 'utf8'));
+                const possiblePaths = [
+                    path_1.default.join(__dirname, '../../../../package.json'),
+                    path_1.default.join(__dirname, '../../../package.json'),
+                    path_1.default.join(process.cwd(), 'package.json')
+                ];
+                let packageJson = null;
+                for (const pkgPath of possiblePaths) {
+                    if (fs_1.default.existsSync(pkgPath)) {
+                        packageJson = JSON.parse(fs_1.default.readFileSync(pkgPath, 'utf8'));
+                        break;
+                    }
+                }
+                if (!packageJson) {
+                    return {
+                        status: 'warning',
+                        message: 'Cannot determine package version'
+                    };
+                }
+                const currentVersion = packageJson.version;
+                const configVersion = config.version;
+                if (configVersion === currentVersion) {
+                    return {
+                        status: 'passed',
+                        message: `Jobs up to date (v${currentVersion})`,
+                        details: { version: currentVersion }
+                    };
+                }
+                return {
+                    status: 'warning',
+                    message: `Jobs outdated (v${configVersion} -> v${currentVersion})`,
+                    suggestion: 'Update local job stubs with fraim sync.',
+                    command: 'fraim sync',
+                    details: { configVersion, currentVersion }
+                };
+            }
+            catch (error) {
+                return {
+                    status: 'error',
+                    message: 'Failed to check job version',
+                    details: { error: error.message }
+                };
+            }
+        }
+    };
+}
+/**
+ * Check if override syntax is valid
+ */
+function checkOverrideSyntaxValid() {
+    return {
+        name: 'Override syntax valid',
+        category: 'jobs',
+        critical: false,
+        run: async () => {
+            const personalizedDir = (0, project_fraim_paths_1.getWorkspaceFraimPath)(process.cwd(), 'personalized-employee');
+            if (!fs_1.default.existsSync(personalizedDir)) {
+                return {
+                    status: 'passed',
+                    message: 'No overrides (not required)',
+                    details: { overrideCount: 0 }
+                };
+            }
+            try {
+                const parser = new inheritance_parser_1.InheritanceParser();
+                const overrides = [];
+                let invalidCount = 0;
+                const errors = [];
+                const scanDir = (dir, base = '') => {
+                    const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+                    for (const entry of entries) {
+                        const relativePath = path_1.default.join(base, entry.name);
+                        if (entry.isDirectory()) {
+                            scanDir(path_1.default.join(dir, entry.name), relativePath);
+                        }
+                        else if (entry.name.endsWith('.md')) {
+                            overrides.push(relativePath);
+                        }
+                    }
+                };
+                scanDir(personalizedDir);
+                for (const override of overrides) {
+                    const overridePath = path_1.default.join(personalizedDir, override);
+                    const content = fs_1.default.readFileSync(overridePath, 'utf-8');
+                    const parseResult = parser.parse(content);
+                    if (parseResult.hasImports) {
+                        for (const importPath of parseResult.imports) {
+                            try {
+                                parser.sanitizePath(importPath);
+                            }
+                            catch (error) {
+                                invalidCount++;
+                                errors.push(`${override}: ${error.message}`);
+                            }
+                        }
+                    }
+                }
+                if (invalidCount === 0) {
+                    return {
+                        status: 'passed',
+                        message: `${overrides.length} overrides valid`,
+                        details: { overrideCount: overrides.length }
+                    };
+                }
+                return {
+                    status: 'error',
+                    message: `${invalidCount} invalid overrides found`,
+                    suggestion: 'Fix override import syntax',
+                    details: { errors }
+                };
+            }
+            catch (error) {
+                return {
+                    status: 'error',
+                    message: 'Failed to validate overrides',
+                    details: { error: error.message }
+                };
+            }
+        }
+    };
+}
+/**
+ * Get all job checks
+ */
+function getJobChecks() {
+    return [
+        checkJobsDirectoryExists(),
+        checkJobStubsPresent(),
+        checkJobsUpToDate(),
+        checkOverrideSyntaxValid()
+    ];
+}

package/dist/src/cli/doctor/reporters/console-reporter.js

@@ -0,0 +1,96 @@
+"use strict";
+/**
+ * Console reporter for FRAIM doctor command
+ * Formats output with colors and emojis
+ * Issue #144: Enhanced doctor command
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatConsoleOutput = formatConsoleOutput;
+const chalk_1 = __importDefault(require("chalk"));
+const CATEGORY_NAMES = {
+    globalSetup: 'Global Setup',
+    projectSetup: 'Project Setup',
+    jobs: 'Jobs',
+    ideConfiguration: 'IDE Configuration',
+    mcpConnectivity: 'MCP Server Connectivity',
+    scripts: 'Scripts'
+};
+function getStatusIcon(status) {
+    switch (status) {
+        case 'passed': return '✅';
+        case 'warning': return '⚠️';
+        case 'error': return '❌';
+    }
+}
+function formatLatency(latency) {
+    if (!latency)
+        return '';
+    return chalk_1.default.gray(` (${latency}ms)`);
+}
+function formatConsoleOutput(result, options) {
+    const lines = [];
+    // Header
+    lines.push(chalk_1.default.blue('🩺 FRAIM Doctor - Comprehensive Health Check\n'));
+    // Categories
+    for (const [categoryKey, categoryResult] of Object.entries(result.categories)) {
+        // Skip empty categories
+        if (categoryResult.checks.length === 0)
+            continue;
+        const categoryName = CATEGORY_NAMES[categoryKey] || categoryKey;
+        lines.push(chalk_1.default.bold(`━━━ ${categoryName} ━━━`));
+        for (const check of categoryResult.checks) {
+            const icon = getStatusIcon(check.status);
+            const latency = formatLatency(check.latency);
+            lines.push(`${icon} ${check.message}${latency}`);
+            // Show details in verbose mode
+            if (options.verbose && check.details) {
+                for (const [key, value] of Object.entries(check.details)) {
+                    lines.push(chalk_1.default.gray(`   ${key}: ${value}`));
+                }
+            }
+            // Show suggestions for warnings and errors
+            if (check.suggestion) {
+                lines.push(chalk_1.default.blue(`   💡 ${check.suggestion}`));
+                if (check.command) {
+                    lines.push(chalk_1.default.gray(`      Run: ${check.command}`));
+                }
+            }
+        }
+        lines.push(''); // Empty line between categories
+    }
+    // Summary
+    lines.push(chalk_1.default.bold('━━━ Summary ━━━'));
+    lines.push(`${chalk_1.default.green('✅')} ${result.summary.passed} checks passed`);
+    if (result.summary.warnings > 0) {
+        lines.push(`${chalk_1.default.yellow('⚠️')} ${result.summary.warnings} warnings`);
+    }
+    if (result.summary.errors > 0) {
+        lines.push(`${chalk_1.default.red('❌')} ${result.summary.errors} errors`);
+    }
+    lines.push('');
+    // Final message
+    if (result.summary.errors === 0 && result.summary.warnings === 0) {
+        lines.push(chalk_1.default.green('✨ Everything looks great! Your FRAIM setup is healthy.'));
+    }
+    else if (result.summary.errors === 0) {
+        lines.push(chalk_1.default.yellow('⚠️ Some warnings found. See suggestions below.'));
+    }
+    else {
+        lines.push(chalk_1.default.red('❌ Issues found. See suggestions below.'));
+    }
+    // Suggestions
+    if (result.suggestions && result.suggestions.length > 0) {
+        lines.push('');
+        lines.push(chalk_1.default.blue('💡 Suggested fixes:'));
+        for (const suggestion of result.suggestions.slice(0, 5)) { // Show top 5
+            lines.push(chalk_1.default.blue(`   ${suggestion.priority}. ${suggestion.message}`));
+            if (suggestion.command) {
+                lines.push(chalk_1.default.gray(`      Run: ${suggestion.command}`));
+            }
+        }
+    }
+    return lines.join('\n');
+}

package/dist/src/cli/doctor/reporters/json-reporter.js

@@ -0,0 +1,11 @@
+"use strict";
+/**
+ * JSON reporter for FRAIM doctor command
+ * Formats output as JSON for automation
+ * Issue #144: Enhanced doctor command
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatJsonOutput = formatJsonOutput;
+function formatJsonOutput(result) {
+    return JSON.stringify(result, null, 2);
+}

package/dist/src/cli/doctor/types.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Type definitions for the FRAIM doctor command
+ * Issue #144: Enhanced doctor command
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/cli/fraim.js

@@ -0,0 +1,100 @@
+#!/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 });
+const commander_1 = require("commander");
+const sync_1 = require("./commands/sync");
+const doctor_1 = require("./commands/doctor");
+const list_1 = require("./commands/list");
+const setup_1 = require("./commands/setup");
+const init_project_1 = require("./commands/init-project");
+const add_ide_1 = require("./commands/add-ide");
+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 migrate_project_fraim_1 = require("./commands/migrate-project-fraim");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const program = new commander_1.Command();
+// Load version from package.json
+// Handle both src/ (dev) and dist/ (prod) execution paths
+let packageJson = { version: 'unknown' };
+try {
+    // Robustly find package.json by searching upwards from this file's directory
+    let currentDir = __dirname;
+    let found = false;
+    for (let i = 0; i < 5; i++) { // Max search depth 5
+        const pkgPath = path_1.default.join(currentDir, 'package.json');
+        if (fs_1.default.existsSync(pkgPath)) {
+            packageJson = JSON.parse(fs_1.default.readFileSync(pkgPath, 'utf8'));
+            found = true;
+            break;
+        }
+        currentDir = path_1.default.dirname(currentDir);
+    }
+}
+catch (e) {
+    console.warn('⚠️ Could not fully resolve package.json version.');
+}
+program
+    .name('fraim')
+    .description('FRAIM Framework CLI - Manage your AI jobs and rules')
+    .version(packageJson.version);
+program.addCommand(sync_1.syncCommand);
+program.addCommand(doctor_1.doctorCommand);
+program.addCommand(list_1.listCommand);
+program.addCommand(setup_1.setupCommand);
+program.addCommand(init_project_1.initProjectCommand);
+program.addCommand(add_ide_1.addIDECommand);
+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);
+program.addCommand(migrate_project_fraim_1.migrateProjectFraimCommand);
+// Wait for async command initialization before parsing
+(async () => {
+    // Import the initialization promise from setup command
+    const { setupCommandInitialization } = await Promise.resolve().then(() => __importStar(require('./commands/setup')));
+    if (setupCommandInitialization) {
+        await setupCommandInitialization;
+    }
+    program.parse(process.argv);
+})();