fraim-framework 2.0.80 → 2.0.82

package/README.md

@@ -306,9 +306,11 @@ FRAIM uses the official Model Context Protocol (MCP) server for Jira integration
 ```json
 {
   "jira": {
-    "command": "npx",
-    "args": ["-y", "@modelcontextprotocol/server-jira"],
+    "command": "uvx",
+    "args": ["mcp-atlassian"],
     "env": {
+      "JIRA_URL": "https://mycompany.atlassian.net",
+      "JIRA_USERNAME": "user@mycompany.com",
       "JIRA_API_TOKEN": "your-token-here"
     }
   }
@@ -316,9 +318,9 @@ FRAIM uses the official Model Context Protocol (MCP) server for Jira integration
 ```
 
 **⚠️ Common Issues**:
-- **Old configuration format**: If you see `https://mcp.atlassian.com/v1/sse` in your config, this is incorrect. Run `fraim setup --jira` to update.
+- **Old package name**: If you see `@modelcontextprotocol/server-jira` in your config, this package doesn't exist. Run `fraim setup --jira` to update to the correct `mcp-atlassian` package.
 - **Token format**: Jira API tokens typically start with `ATATT3`. If your token doesn't match this format, verify you created an API token (not a personal access token).
-- **First run slow**: The first time `npx` runs the Jira MCP server, it downloads the package. This is normal and only happens once.
+- **First run slow**: The first time `uvx` runs the Jira MCP server, it downloads the package. This is normal and only happens once.
 
 **Troubleshooting**:
 ```bash

package/dist/src/cli/commands/add-provider.js

@@ -0,0 +1,383 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addProviderCommand = exports.runAddProvider = void 0;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const prompts_1 = __importDefault(require("prompts"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const token_validator_1 = require("../setup/token-validator");
+const mcp_config_generator_1 = require("../setup/mcp-config-generator");
+const ide_detector_1 = require("../setup/ide-detector");
+const script_sync_utils_1 = require("../utils/script-sync-utils");
+const mcp_config_generator_2 = require("../setup/mcp-config-generator");
+const loadGlobalConfig = () => {
+    const globalConfigPath = path_1.default.join((0, script_sync_utils_1.getUserFraimDir)(), 'config.json');
+    if (!fs_1.default.existsSync(globalConfigPath)) {
+        return null;
+    }
+    try {
+        return JSON.parse(fs_1.default.readFileSync(globalConfigPath, 'utf8'));
+    }
+    catch (e) {
+        return null;
+    }
+};
+const saveGlobalConfig = (config) => {
+    const globalConfigPath = path_1.default.join((0, script_sync_utils_1.getUserFraimDir)(), 'config.json');
+    fs_1.default.writeFileSync(globalConfigPath, JSON.stringify(config, null, 2));
+};
+const promptForGitHubToken = async () => {
+    console.log(chalk_1.default.blue('\n🔑 GitHub Token'));
+    console.log(chalk_1.default.gray('Create a token at: https://github.com/settings/tokens'));
+    console.log(chalk_1.default.gray('Required scopes: repo, read:org, read:user\n'));
+    const response = await (0, prompts_1.default)({
+        type: 'password',
+        name: 'token',
+        message: 'Enter your GitHub token (ghp_...):',
+        validate: (value) => {
+            if (!value)
+                return 'Token is required';
+            if (!(0, token_validator_1.isValidTokenFormat)(value, 'github')) {
+                return 'Invalid GitHub token format (should start with ghp_)';
+            }
+            return true;
+        }
+    });
+    if (!response.token) {
+        throw new Error('GitHub token is required');
+    }
+    return response.token;
+};
+const promptForGitLabToken = async () => {
+    console.log(chalk_1.default.blue('\n🔑 GitLab Token'));
+    console.log(chalk_1.default.gray('Create a token at: https://gitlab.com/-/profile/personal_access_tokens'));
+    console.log(chalk_1.default.gray('Required scopes: api, read_api, read_repository\n'));
+    const response = await (0, prompts_1.default)({
+        type: 'password',
+        name: 'token',
+        message: 'Enter your GitLab token (glpat-...):',
+        validate: (value) => {
+            if (!value)
+                return 'Token is required';
+            if (!(0, token_validator_1.isValidTokenFormat)(value, 'gitlab')) {
+                return 'Invalid GitLab token format (should start with glpat-)';
+            }
+            return true;
+        }
+    });
+    if (!response.token) {
+        throw new Error('GitLab token is required');
+    }
+    return response.token;
+};
+const promptForADOToken = async () => {
+    console.log(chalk_1.default.blue('\n🔑 Azure DevOps Token'));
+    console.log(chalk_1.default.gray('Create a token at: https://dev.azure.com/<org>/_usersSettings/tokens'));
+    console.log(chalk_1.default.gray('Required scopes: Code (Read & Write), Work Items (Read & Write)\n'));
+    const response = await (0, prompts_1.default)({
+        type: 'password',
+        name: 'token',
+        message: 'Enter your Azure DevOps PAT:',
+        validate: (value) => {
+            if (!value)
+                return 'Token is required';
+            if (value.length < 20)
+                return 'Token seems too short';
+            return true;
+        }
+    });
+    if (!response.token) {
+        throw new Error('Azure DevOps token is required');
+    }
+    return response.token;
+};
+const promptForJiraCredentials = async (options) => {
+    // If all options provided, skip prompts (non-interactive mode)
+    if (options.url && options.email && options.token) {
+        const baseUrl = options.url.replace(/^https?:\/\//, '').replace(/\/$/, '');
+        // Validate token format
+        if (!(0, token_validator_1.isValidTokenFormat)(options.token, 'jira')) {
+            throw new Error('Invalid Jira token format');
+        }
+        return {
+            baseUrl,
+            email: options.email,
+            token: options.token
+        };
+    }
+    console.log(chalk_1.default.blue('\n🔑 Jira Credentials'));
+    console.log(chalk_1.default.gray('Create a token at: https://id.atlassian.com/manage-profile/security/api-tokens\n'));
+    // Prompt for base URL
+    const urlResponse = await (0, prompts_1.default)({
+        type: 'text',
+        name: 'url',
+        message: 'Jira instance URL (e.g., company.atlassian.net):',
+        initial: options.url,
+        validate: (value) => {
+            if (!value)
+                return 'URL is required';
+            // Remove protocol if provided
+            const cleaned = value.replace(/^https?:\/\//, '').replace(/\/$/, '');
+            if (!cleaned.includes('.'))
+                return 'Invalid URL format';
+            return true;
+        }
+    });
+    if (!urlResponse.url) {
+        throw new Error('Jira URL is required');
+    }
+    const baseUrl = urlResponse.url.replace(/^https?:\/\//, '').replace(/\/$/, '');
+    // Prompt for email
+    const emailResponse = await (0, prompts_1.default)({
+        type: 'text',
+        name: 'email',
+        message: 'Jira account email:',
+        initial: options.email,
+        validate: (value) => {
+            if (!value)
+                return 'Email is required';
+            if (!value.includes('@'))
+                return 'Invalid email format';
+            return true;
+        }
+    });
+    if (!emailResponse.email) {
+        throw new Error('Jira email is required');
+    }
+    // Prompt for token
+    const tokenResponse = await (0, prompts_1.default)({
+        type: 'password',
+        name: 'token',
+        message: 'Jira API token:',
+        validate: (value) => {
+            if (!value)
+                return 'Token is required';
+            if (!(0, token_validator_1.isValidTokenFormat)(value, 'jira')) {
+                return 'Invalid Jira token format';
+            }
+            return true;
+        }
+    });
+    if (!tokenResponse.token) {
+        throw new Error('Jira token is required');
+    }
+    return {
+        baseUrl,
+        email: emailResponse.email,
+        token: tokenResponse.token
+    };
+};
+const updateIDEConfigs = async (provider, config) => {
+    const detectedIDEs = (0, ide_detector_1.detectInstalledIDEs)();
+    if (detectedIDEs.length === 0) {
+        console.log(chalk_1.default.yellow('⚠️ No IDEs detected. MCP configs not updated.'));
+        return;
+    }
+    console.log(chalk_1.default.blue(`\n🔧 Updating ${detectedIDEs.length} IDE configuration(s)...\n`));
+    const tokenConfig = {
+        github: config.tokens?.github,
+        gitlab: config.tokens?.gitlab,
+        jira: config.tokens?.jira
+    };
+    const jiraConfig = config.jiraConfig ? {
+        baseUrl: config.jiraConfig.baseUrl,
+        email: config.jiraConfig.email
+    } : undefined;
+    for (const ide of detectedIDEs) {
+        try {
+            const configPath = (0, ide_detector_1.expandPath)(ide.configPath);
+            if (ide.configFormat === 'json') {
+                // JSON-based config (Claude Desktop, Cursor, etc.)
+                let ideConfig = {};
+                if (fs_1.default.existsSync(configPath)) {
+                    ideConfig = JSON.parse(fs_1.default.readFileSync(configPath, 'utf8'));
+                }
+                const mcpConfig = (0, mcp_config_generator_1.generateMCPConfig)(ide.configType, config.apiKey, tokenConfig, jiraConfig);
+                const serversKey = ide.configType === 'vscode' ? 'servers' : 'mcpServers';
+                if (!ideConfig[serversKey]) {
+                    ideConfig[serversKey] = {};
+                }
+                // Add the new provider's MCP server
+                const providerServerKey = provider === 'ado' ? 'ado' : provider;
+                if (mcpConfig[serversKey] && mcpConfig[serversKey][providerServerKey]) {
+                    ideConfig[serversKey][providerServerKey] = mcpConfig[serversKey][providerServerKey];
+                    fs_1.default.writeFileSync(configPath, JSON.stringify(ideConfig, null, 2));
+                    console.log(chalk_1.default.green(`✅ Updated ${ide.name} config`));
+                }
+            }
+            else if (ide.configFormat === 'toml') {
+                // TOML-based config (Codex, Zed)
+                const mcpConfigToml = (0, mcp_config_generator_1.generateMCPConfig)(ide.configType, config.apiKey, tokenConfig, jiraConfig);
+                if (fs_1.default.existsSync(configPath)) {
+                    const existingContent = fs_1.default.readFileSync(configPath, 'utf8');
+                    // Merge only the new provider's server
+                    const serversToMerge = [provider === 'ado' ? 'ado' : provider];
+                    const mergeResult = (0, mcp_config_generator_2.mergeTomlMCPServers)(existingContent, mcpConfigToml, serversToMerge);
+                    fs_1.default.writeFileSync(configPath, mergeResult.content);
+                    console.log(chalk_1.default.green(`✅ Updated ${ide.name} config`));
+                }
+                else {
+                    console.log(chalk_1.default.yellow(`⚠️ ${ide.name} config not found, skipping`));
+                }
+            }
+        }
+        catch (error) {
+            console.log(chalk_1.default.red(`❌ Failed to update ${ide.name}: ${error instanceof Error ? error.message : 'Unknown error'}`));
+        }
+    }
+};
+const offerModeSwitch = async (config) => {
+    if (config.mode === 'split') {
+        console.log(chalk_1.default.gray('\nAlready in split mode.'));
+        return;
+    }
+    console.log(chalk_1.default.blue('\n🔄 Mode Switch Available'));
+    console.log(chalk_1.default.gray('You can now use split mode (separate platforms for code and issues).'));
+    console.log(chalk_1.default.gray('Example: GitHub for code, Jira for issue tracking\n'));
+    // Skip prompt if FRAIM_AUTO_SWITCH_MODE is set (for testing)
+    const shouldSwitch = process.env.FRAIM_AUTO_SWITCH_MODE === 'true';
+    if (!shouldSwitch && !process.env.FRAIM_AUTO_SWITCH_MODE) {
+        const response = await (0, prompts_1.default)({
+            type: 'confirm',
+            name: 'switchMode',
+            message: 'Switch to split mode?',
+            initial: false
+        });
+        if (response.switchMode) {
+            config.mode = 'split';
+            saveGlobalConfig(config);
+            console.log(chalk_1.default.green('✅ Switched to split mode'));
+            console.log(chalk_1.default.gray('Run "fraim init-project" in your projects to use split mode'));
+        }
+    }
+    else if (shouldSwitch) {
+        config.mode = 'split';
+        saveGlobalConfig(config);
+        console.log(chalk_1.default.green('✅ Switched to split mode'));
+        console.log(chalk_1.default.gray('Run "fraim init-project" in your projects to use split mode'));
+    }
+};
+const runAddProvider = async (provider, options) => {
+    console.log(chalk_1.default.blue(`\n🔧 Adding ${provider.toUpperCase()} provider...\n`));
+    // Check global setup exists
+    const config = loadGlobalConfig();
+    if (!config) {
+        console.log(chalk_1.default.red('❌ Global FRAIM setup not found.'));
+        console.log(chalk_1.default.yellow('Please run: fraim setup --key=<your-fraim-key>'));
+        process.exit(1);
+    }
+    // Initialize tokens object if it doesn't exist
+    if (!config.tokens) {
+        config.tokens = {};
+    }
+    // Check if provider already configured
+    if (provider === 'jira') {
+        if (config.tokens.jira && config.jiraConfig?.baseUrl) {
+            console.log(chalk_1.default.yellow(`⚠️ Jira is already configured (${config.jiraConfig.baseUrl})`));
+            // Skip prompt if FRAIM_FORCE_OVERWRITE is set (for testing)
+            if (!process.env.FRAIM_FORCE_OVERWRITE) {
+                const response = await (0, prompts_1.default)({
+                    type: 'confirm',
+                    name: 'overwrite',
+                    message: 'Overwrite existing Jira configuration?',
+                    initial: false
+                });
+                if (!response.overwrite) {
+                    console.log(chalk_1.default.gray('Cancelled.'));
+                    process.exit(0);
+                }
+            }
+        }
+    }
+    else {
+        if (config.tokens[provider]) {
+            console.log(chalk_1.default.yellow(`⚠️ ${provider.toUpperCase()} token already exists`));
+            // Skip prompt if FRAIM_FORCE_OVERWRITE is set (for testing)
+            if (!process.env.FRAIM_FORCE_OVERWRITE) {
+                const response = await (0, prompts_1.default)({
+                    type: 'confirm',
+                    name: 'overwrite',
+                    message: `Overwrite existing ${provider.toUpperCase()} token?`,
+                    initial: false
+                });
+                if (!response.overwrite) {
+                    console.log(chalk_1.default.gray('Cancelled.'));
+                    process.exit(0);
+                }
+            }
+        }
+    }
+    // Get credentials based on provider
+    try {
+        if (provider === 'github') {
+            const token = options.token || await promptForGitHubToken();
+            // Validate token if requested
+            if (options.validate !== false) {
+                console.log(chalk_1.default.blue('🔍 Validating GitHub token...'));
+                const isValid = await (0, token_validator_1.validateGitHubToken)(token);
+                if (!isValid) {
+                    console.log(chalk_1.default.red('❌ Invalid GitHub token'));
+                    process.exit(1);
+                }
+                console.log(chalk_1.default.green('✅ Token validated'));
+            }
+            config.tokens.github = token;
+        }
+        else if (provider === 'gitlab') {
+            const token = options.token || await promptForGitLabToken();
+            config.tokens.gitlab = token;
+        }
+        else if (provider === 'ado') {
+            const token = options.token || await promptForADOToken();
+            config.tokens.ado = token;
+        }
+        else if (provider === 'jira') {
+            const credentials = await promptForJiraCredentials(options);
+            config.tokens.jira = credentials.token;
+            config.jiraConfig = {
+                baseUrl: credentials.baseUrl,
+                email: credentials.email
+            };
+        }
+        // Save updated config
+        saveGlobalConfig(config);
+        console.log(chalk_1.default.green(`\n✅ ${provider.toUpperCase()} credentials saved to global config`));
+        // Update IDE configs
+        await updateIDEConfigs(provider, config);
+        // Offer mode switch if adding Jira
+        if (provider === 'jira') {
+            await offerModeSwitch(config);
+        }
+        console.log(chalk_1.default.green('\n🎉 Provider added successfully!'));
+        console.log(chalk_1.default.cyan('\n💡 Next steps:'));
+        console.log(chalk_1.default.gray('   1. Restart your IDE(s) to load new MCP servers'));
+        if (provider === 'jira' && config.mode === 'split') {
+            console.log(chalk_1.default.gray('   2. Run "fraim init-project" in your projects to use split mode'));
+        }
+    }
+    catch (error) {
+        console.log(chalk_1.default.red(`\n❌ Failed to add provider: ${error instanceof Error ? error.message : 'Unknown error'}`));
+        process.exit(1);
+    }
+};
+exports.runAddProvider = runAddProvider;
+exports.addProviderCommand = new commander_1.Command('add-provider')
+    .description('Add or update a provider (GitHub, GitLab, ADO, Jira) after initial setup')
+    .argument('<provider>', 'Provider to add: github, gitlab, ado, or jira')
+    .option('--token <token>', 'Provider token (will prompt if not provided)')
+    .option('--email <email>', 'Email (Jira only)')
+    .option('--url <url>', 'Instance URL (Jira only)')
+    .option('--no-validate', 'Skip token validation (GitHub only)')
+    .action(async (provider, options) => {
+    const validProviders = ['github', 'gitlab', 'ado', 'jira'];
+    if (!validProviders.includes(provider)) {
+        console.log(chalk_1.default.red(`❌ Invalid provider: ${provider}`));
+        console.log(chalk_1.default.yellow(`Valid providers: ${validProviders.join(', ')}`));
+        process.exit(1);
+    }
+    await (0, exports.runAddProvider)(provider, options);
+});

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

@@ -1,129 +1,146 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.doctorCommand = void 0;
+exports.getAllChecks = getAllChecks;
 const commander_1 = require("commander");
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const chalk_1 = __importDefault(require("chalk"));
-const inheritance_parser_1 = require("../../core/utils/inheritance-parser");
-exports.doctorCommand = new commander_1.Command('doctor')
-    .description('Validate FRAIM installation and configuration')
-    .action(async () => {
-    const projectRoot = process.cwd();
-    const fraimDir = path_1.default.join(projectRoot, '.fraim');
-    let issuesFound = 0;
-    console.log(chalk_1.default.blue('🩺 FRAIM Doctor - Checking health...\n'));
-    // 1. Check .fraim directory
-    if (!fs_1.default.existsSync(fraimDir)) {
-        console.log(chalk_1.default.red('❌ Missing .fraim/ directory. Run "fraim setup" or "fraim init-project".'));
-        issuesFound++;
-    }
-    else {
-        console.log(chalk_1.default.green('✅ .fraim/ directory exists.'));
+const fs_1 = require("fs");
+const path_1 = require("path");
+const check_runner_1 = require("../doctor/check-runner");
+const console_reporter_1 = require("../doctor/reporters/console-reporter");
+const json_reporter_1 = require("../doctor/reporters/json-reporter");
+const global_setup_checks_1 = require("../doctor/checks/global-setup-checks");
+const project_setup_checks_1 = require("../doctor/checks/project-setup-checks");
+const workflow_checks_1 = require("../doctor/checks/workflow-checks");
+const ide_config_checks_1 = require("../doctor/checks/ide-config-checks");
+const mcp_connectivity_checks_1 = require("../doctor/checks/mcp-connectivity-checks");
+const scripts_checks_1 = require("../doctor/checks/scripts-checks");
+// Read version from package.json
+const getFramVersion = () => {
+    try {
+        const packageJsonPath = (0, path_1.join)(__dirname, '../../../package.json');
+        const packageJson = JSON.parse((0, fs_1.readFileSync)(packageJsonPath, 'utf-8'));
+        return packageJson.version;
     }
-    // 2. Check workflows subdirectory
-    const workflowsDir = path_1.default.join(fraimDir, 'workflows');
-    if (!fs_1.default.existsSync(workflowsDir)) {
-        console.log(chalk_1.default.red('❌ Missing .fraim/workflows/ directory.'));
-        issuesFound++;
+    catch (error) {
+        return 'unknown';
     }
-    else {
-        const stubs = fs_1.default.readdirSync(workflowsDir).filter(f => f.endsWith('.md'));
-        console.log(chalk_1.default.green(`✅ .fraim/workflows/ exists (${stubs.length} stubs found).`));
+};
+const FRAIM_VERSION = getFramVersion();
+// Simple logger for doctor command
+const logger = {
+    info: (...args) => {
+        if (process.env.VERBOSE)
+            console.log('[DOCTOR]', ...args);
+    },
+    warn: (...args) => {
+        console.warn('[DOCTOR]', ...args);
+    },
+    error: (...args) => {
+        console.error('[DOCTOR]', ...args);
     }
-    // 3. Check config.json
-    const configPath = path_1.default.join(fraimDir, 'config.json');
-    if (!fs_1.default.existsSync(configPath)) {
-        console.log(chalk_1.default.red('❌ Missing .fraim/config.json.'));
-        issuesFound++;
+};
+// Simple metric tracker (no-op for now)
+const trackMetric = (name, value) => {
+    if (process.env.DEBUG) {
+        console.debug(`[METRIC] ${name}: ${value}`);
     }
-    else {
-        try {
-            JSON.parse(fs_1.default.readFileSync(configPath, 'utf8'));
-            console.log(chalk_1.default.green('✅ .fraim/config.json is valid JSON.'));
-        }
-        catch (e) {
-            console.log(chalk_1.default.red('❌ .fraim/config.json is corrupted.'));
-            issuesFound++;
+};
+/**
+ * Get all checks for doctor command
+ * Exported for testing
+ */
+function getAllChecks() {
+    return [
+        ...(0, global_setup_checks_1.getGlobalSetupChecks)(),
+        ...(0, project_setup_checks_1.getProjectSetupChecks)(),
+        ...(0, workflow_checks_1.getWorkflowChecks)(),
+        ...(0, ide_config_checks_1.getIDEConfigChecks)(),
+        ...(0, mcp_connectivity_checks_1.getMCPConnectivityChecks)(),
+        ...(0, scripts_checks_1.getScriptsChecks)()
+    ];
+}
+exports.doctorCommand = new commander_1.Command('doctor')
+    .description('Validate FRAIM installation and configuration')
+    .option('--test-mcp', 'Test only MCP server connectivity')
+    .option('--test-config', 'Validate only configuration files')
+    .option('--test-workflows', 'Check only workflow status')
+    .option('--verbose', 'Show detailed output including successful checks')
+    .option('--json', 'Output results as JSON')
+    .action(async (cmdOptions) => {
+    const startTime = Date.now();
+    const options = {
+        testMcp: cmdOptions.testMcp,
+        testConfig: cmdOptions.testConfig,
+        testWorkflows: cmdOptions.testWorkflows,
+        verbose: cmdOptions.verbose,
+        json: cmdOptions.json
+    };
+    // Log command start
+    logger.info('Doctor command started', {
+        flags: {
+            testMcp: options.testMcp || false,
+            testConfig: options.testConfig || false,
+            testWorkflows: options.testWorkflows || false,
+            verbose: options.verbose || false,
+            json: options.json || false
         }
-    }
-    // 4. Check sync status (remote or local)
-    // With Issue #83, stubs are no longer in the package - they're fetched from remote server
-    // Check if config has remoteUrl configured
+    });
+    // Track execution count
+    trackMetric('doctor.execution.count', 1);
+    // Track flag usage
+    if (options.testMcp)
+        trackMetric('doctor.flags.test_mcp', 1);
+    if (options.testConfig)
+        trackMetric('doctor.flags.test_config', 1);
+    if (options.testWorkflows)
+        trackMetric('doctor.flags.test_workflows', 1);
+    if (options.verbose)
+        trackMetric('doctor.flags.verbose', 1);
+    if (options.json)
+        trackMetric('doctor.flags.json', 1);
     try {
-        const config = JSON.parse(fs_1.default.readFileSync(configPath, 'utf8'));
-        if (config.remoteUrl && config.apiKey) {
-            console.log(chalk_1.default.green('✅ Remote sync configured (remoteUrl and apiKey present).'));
+        // Collect all checks
+        const checks = getAllChecks();
+        // Run checks
+        const result = await (0, check_runner_1.runChecks)(checks, options, FRAIM_VERSION);
+        const duration = Date.now() - startTime;
+        // Log results
+        logger.info('Doctor command completed', {
+            duration,
+            summary: result.summary
+        });
+        // Track metrics
+        trackMetric('doctor.execution.duration', duration);
+        trackMetric('doctor.checks.passed', result.summary.passed);
+        trackMetric('doctor.checks.warnings', result.summary.warnings);
+        trackMetric('doctor.checks.errors', result.summary.errors);
+        trackMetric('doctor.checks.total', result.summary.total);
+        // Log warnings and errors
+        if (result.summary.warnings > 0) {
+            logger.warn(`Doctor found ${result.summary.warnings} warning(s)`);
         }
-        else {
-            console.log(chalk_1.default.yellow('⚠️ Remote sync not configured. Run "fraim sync" to fetch workflows from server.'));
-            console.log(chalk_1.default.gray('   Add remoteUrl and apiKey to .fraim/config.json for remote sync.'));
+        if (result.summary.errors > 0) {
+            logger.error(`Doctor found ${result.summary.errors} error(s)`);
         }
-    }
-    catch (e) {
-        // Config check already failed above, skip this check
-    }
-    if (issuesFound === 0) {
-        console.log(chalk_1.default.green('\n✨ Everything looks great! Your project is FRAIM-ready.'));
-    }
-    else {
-        console.log(chalk_1.default.red(`\n🩹 Found ${issuesFound} issues. See recommendations above.`));
-    }
-    // 5. Check for overrides
-    const overridesDir = path_1.default.join(fraimDir, 'overrides');
-    if (fs_1.default.existsSync(overridesDir)) {
-        console.log(chalk_1.default.blue('\n📝 Override Diagnostics:\n'));
-        const overrides = [];
-        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 {
-                    overrides.push(relativePath.replace(/\\/g, '/'));
-                }
-            }
-        };
-        scanDir(overridesDir);
-        if (overrides.length === 0) {
-            console.log(chalk_1.default.gray('  No active overrides found.'));
+        // Output results
+        if (options.json) {
+            console.log((0, json_reporter_1.formatJsonOutput)(result));
         }
         else {
-            console.log(chalk_1.default.green(`  Found ${overrides.length} active override(s):\n`));
-            const parser = new inheritance_parser_1.InheritanceParser();
-            for (const override of overrides) {
-                const overridePath = path_1.default.join(overridesDir, override);
-                const content = fs_1.default.readFileSync(overridePath, 'utf-8');
-                const parseResult = parser.parse(content);
-                if (parseResult.hasImports) {
-                    console.log(chalk_1.default.white(`  📄 ${override}`));
-                    console.log(chalk_1.default.gray(`     Inherits from: ${parseResult.imports.join(', ')}`));
-                    // Validate import syntax
-                    let hasErrors = false;
-                    for (const importPath of parseResult.imports) {
-                        try {
-                            parser.sanitizePath(importPath);
-                        }
-                        catch (error) {
-                            console.log(chalk_1.default.red(`     ⚠️ Invalid import: ${error.message}`));
-                            hasErrors = true;
-                        }
-                    }
-                    if (!hasErrors) {
-                        console.log(chalk_1.default.green(`     ✅ Syntax valid`));
-                    }
-                }
-                else {
-                    console.log(chalk_1.default.white(`  📄 ${override}`));
-                    console.log(chalk_1.default.gray(`     Full override (no inheritance)`));
-                }
-                console.log('');
-            }
+            console.log((0, console_reporter_1.formatConsoleOutput)(result, options));
+        }
+        // Set exit code
+        if (result.summary.errors > 0) {
+            process.exit(2);
         }
+        else if (result.summary.warnings > 0) {
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        const duration = Date.now() - startTime;
+        logger.error('Doctor command failed', { error, duration });
+        trackMetric('doctor.execution.errors', 1);
+        throw error;
     }
 });