kynjal-cli 4.0.0 → 4.0.1

package/dist/src/commands/doctor.js

@@ -4,53 +4,6 @@
  *
  * Created with ruv.io
  */
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 import { output } from '../output.js';
 import { existsSync, readFileSync, statSync } from 'fs';
 import { join, dirname } from 'path';
@@ -58,549 +11,427 @@ import { fileURLToPath } from 'url';
 import { execSync, exec } from 'child_process';
 import { promisify } from 'util';
 // Promisified exec with proper shell and env inheritance for cross-platform support
-var execAsync = promisify(exec);
+const execAsync = promisify(exec);
 /**
  * Execute command asynchronously with proper environment inheritance
  * Critical for Windows where PATH may not be inherited properly
  */
-function runCommand(command, timeoutMs) {
-    if (timeoutMs === void 0) { timeoutMs = 5000; }
-    return __awaiter(this, void 0, Promise, function () {
-        var stdout;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, execAsync(command, {
-                        encoding: 'utf8',
-                        timeout: timeoutMs,
-                        shell: process.platform === 'win32' ? 'cmd.exe' : '/bin/sh',
-                        env: __assign({}, process.env),
-                        windowsHide: true
-                    })];
-                case 1:
-                    stdout = (_a.sent()).stdout;
-                    return [2 /*return*/, stdout.trim()];
-            }
-        });
+async function runCommand(command, timeoutMs = 5000) {
+    const { stdout } = await execAsync(command, {
+        encoding: 'utf8',
+        timeout: timeoutMs,
+        shell: process.platform === 'win32' ? 'cmd.exe' : '/bin/sh', // Use proper shell per platform
+        env: { ...process.env }, // Explicitly inherit full environment
+        windowsHide: true, // Hide window on Windows
     });
+    return stdout.trim();
 }
 // Check Node.js version
-function checkNodeVersion() {
-    return __awaiter(this, void 0, Promise, function () {
-        var requiredMajor, version, major;
-        return __generator(this, function (_a) {
-            requiredMajor = 20;
-            version = process.version;
-            major = parseInt(version.slice(1).split('.')[0], 10);
-            if (major >= requiredMajor) {
-                return [2 /*return*/, { name: 'Node.js Version', status: 'pass', message: version + " (>= " + requiredMajor + " required)" }];
-            }
-            else if (major >= 18) {
-                return [2 /*return*/, { name: 'Node.js Version', status: 'warn', message: version + " (>= " + requiredMajor + " recommended)", fix: 'nvm install 20 && nvm use 20' }];
-            }
-            else {
-                return [2 /*return*/, { name: 'Node.js Version', status: 'fail', message: version + " (>= " + requiredMajor + " required)", fix: 'nvm install 20 && nvm use 20' }];
-            }
-            return [2 /*return*/];
-        });
-    });
+async function checkNodeVersion() {
+    const requiredMajor = 20;
+    const version = process.version;
+    const major = parseInt(version.slice(1).split('.')[0], 10);
+    if (major >= requiredMajor) {
+        return { name: 'Node.js Version', status: 'pass', message: `${version} (>= ${requiredMajor} required)` };
+    }
+    else if (major >= 18) {
+        return { name: 'Node.js Version', status: 'warn', message: `${version} (>= ${requiredMajor} recommended)`, fix: 'nvm install 20 && nvm use 20' };
+    }
+    else {
+        return { name: 'Node.js Version', status: 'fail', message: `${version} (>= ${requiredMajor} required)`, fix: 'nvm install 20 && nvm use 20' };
+    }
 }
 // Check npm version (async with proper env inheritance)
-function checkNpmVersion() {
-    return __awaiter(this, void 0, Promise, function () {
-        var version, major, _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    _b.trys.push([0, 2, , 3]);
-                    return [4 /*yield*/, runCommand('npm --version')];
-                case 1:
-                    version = _b.sent();
-                    major = parseInt(version.split('.')[0], 10);
-                    if (major >= 9) {
-                        return [2 /*return*/, { name: 'npm Version', status: 'pass', message: "v" + version }];
-                    }
-                    else {
-                        return [2 /*return*/, { name: 'npm Version', status: 'warn', message: "v" + version + " (>= 9 recommended)", fix: 'npm install -g npm@latest' }];
-                    }
-                    return [3 /*break*/, 3];
-                case 2:
-                    _a = _b.sent();
-                    return [2 /*return*/, { name: 'npm Version', status: 'fail', message: 'npm not found', fix: 'Install Node.js from https://nodejs.org' }];
-                case 3: return [2 /*return*/];
-            }
-        });
-    });
+async function checkNpmVersion() {
+    try {
+        const version = await runCommand('npm --version');
+        const major = parseInt(version.split('.')[0], 10);
+        if (major >= 9) {
+            return { name: 'npm Version', status: 'pass', message: `v${version}` };
+        }
+        else {
+            return { name: 'npm Version', status: 'warn', message: `v${version} (>= 9 recommended)`, fix: 'npm install -g npm@latest' };
+        }
+    }
+    catch {
+        return { name: 'npm Version', status: 'fail', message: 'npm not found', fix: 'Install Node.js from https://nodejs.org' };
+    }
 }
 // Check config file
-function checkConfigFile() {
-    return __awaiter(this, void 0, Promise, function () {
-        var jsonPaths, _i, jsonPaths_1, configPath, content, yamlPaths, _a, yamlPaths_1, configPath;
-        return __generator(this, function (_b) {
-            jsonPaths = [
-                '.claude-flow/config.json',
-                'claude-flow.config.json',
-                '.claude-flow.json'
-            ];
-            for (_i = 0, jsonPaths_1 = jsonPaths; _i < jsonPaths_1.length; _i++) {
-                configPath = jsonPaths_1[_i];
-                if (existsSync(configPath)) {
-                    try {
-                        content = readFileSync(configPath, 'utf8');
-                        JSON.parse(content);
-                        return [2 /*return*/, { name: 'Config File', status: 'pass', message: "Found: " + configPath }];
-                    }
-                    catch (e) {
-                        return [2 /*return*/, { name: 'Config File', status: 'fail', message: "Invalid JSON: " + configPath, fix: 'Fix JSON syntax in config file' }];
-                    }
-                }
+async function checkConfigFile() {
+    // JSON configs (parse-validated)
+    const jsonPaths = [
+        '.claude-flow/config.json',
+        'claude-flow.config.json',
+        '.claude-flow.json'
+    ];
+    for (const configPath of jsonPaths) {
+        if (existsSync(configPath)) {
+            try {
+                const content = readFileSync(configPath, 'utf8');
+                JSON.parse(content);
+                return { name: 'Config File', status: 'pass', message: `Found: ${configPath}` };
             }
-            yamlPaths = [
-                '.claude-flow/config.yaml',
-                '.claude-flow/config.yml',
-                'claude-flow.config.yaml'
-            ];
-            for (_a = 0, yamlPaths_1 = yamlPaths; _a < yamlPaths_1.length; _a++) {
-                configPath = yamlPaths_1[_a];
-                if (existsSync(configPath)) {
-                    return [2 /*return*/, { name: 'Config File', status: 'pass', message: "Found: " + configPath }];
-                }
+            catch (e) {
+                return { name: 'Config File', status: 'fail', message: `Invalid JSON: ${configPath}`, fix: 'Fix JSON syntax in config file' };
             }
-            return [2 /*return*/, { name: 'Config File', status: 'warn', message: 'No config file (using defaults)', fix: 'claude-flow config init' }];
-        });
-    });
+        }
+    }
+    // YAML configs (existence-checked only — no heavy yaml parser dependency)
+    const yamlPaths = [
+        '.claude-flow/config.yaml',
+        '.claude-flow/config.yml',
+        'claude-flow.config.yaml'
+    ];
+    for (const configPath of yamlPaths) {
+        if (existsSync(configPath)) {
+            return { name: 'Config File', status: 'pass', message: `Found: ${configPath}` };
+        }
+    }
+    return { name: 'Config File', status: 'warn', message: 'No config file (using defaults)', fix: 'claude-flow config init' };
 }
 // Check daemon status
-function checkDaemonStatus() {
-    return __awaiter(this, void 0, Promise, function () {
-        var pidFile, pid;
-        return __generator(this, function (_a) {
+async function checkDaemonStatus() {
+    try {
+        const pidFile = '.claude-flow/daemon.pid';
+        if (existsSync(pidFile)) {
+            const pid = readFileSync(pidFile, 'utf8').trim();
             try {
-                pidFile = '.claude-flow/daemon.pid';
-                if (existsSync(pidFile)) {
-                    pid = readFileSync(pidFile, 'utf8').trim();
-                    try {
-                        process.kill(parseInt(pid, 10), 0); // Check if process exists
-                        return [2 /*return*/, { name: 'Daemon Status', status: 'pass', message: "Running (PID: " + pid + ")" }];
-                    }
-                    catch (_b) {
-                        return [2 /*return*/, { name: 'Daemon Status', status: 'warn', message: 'Stale PID file', fix: 'rm .claude-flow/daemon.pid && claude-flow daemon start' }];
-                    }
-                }
-                return [2 /*return*/, { name: 'Daemon Status', status: 'warn', message: 'Not running', fix: 'claude-flow daemon start' }];
+                process.kill(parseInt(pid, 10), 0); // Check if process exists
+                return { name: 'Daemon Status', status: 'pass', message: `Running (PID: ${pid})` };
             }
-            catch (_c) {
-                return [2 /*return*/, { name: 'Daemon Status', status: 'warn', message: 'Unable to check', fix: 'claude-flow daemon status' }];
+            catch {
+                return { name: 'Daemon Status', status: 'warn', message: 'Stale PID file', fix: 'rm .claude-flow/daemon.pid && claude-flow daemon start' };
             }
-            return [2 /*return*/];
-        });
-    });
+        }
+        return { name: 'Daemon Status', status: 'warn', message: 'Not running', fix: 'claude-flow daemon start' };
+    }
+    catch {
+        return { name: 'Daemon Status', status: 'warn', message: 'Unable to check', fix: 'claude-flow daemon status' };
+    }
 }
 // Check memory database
-function checkMemoryDatabase() {
-    return __awaiter(this, void 0, Promise, function () {
-        var dbPaths, _i, dbPaths_1, dbPath, stats, sizeMB;
-        return __generator(this, function (_a) {
-            dbPaths = [
-                '.claude-flow/memory.db',
-                '.swarm/memory.db',
-                'data/memory.db'
-            ];
-            for (_i = 0, dbPaths_1 = dbPaths; _i < dbPaths_1.length; _i++) {
-                dbPath = dbPaths_1[_i];
-                if (existsSync(dbPath)) {
-                    try {
-                        stats = statSync(dbPath);
-                        sizeMB = (stats.size / 1024 / 1024).toFixed(2);
-                        return [2 /*return*/, { name: 'Memory Database', status: 'pass', message: dbPath + " (" + sizeMB + " MB)" }];
-                    }
-                    catch (_b) {
-                        return [2 /*return*/, { name: 'Memory Database', status: 'warn', message: dbPath + " (unable to stat)" }];
-                    }
-                }
+async function checkMemoryDatabase() {
+    const dbPaths = [
+        '.claude-flow/memory.db',
+        '.swarm/memory.db',
+        'data/memory.db'
+    ];
+    for (const dbPath of dbPaths) {
+        if (existsSync(dbPath)) {
+            try {
+                const stats = statSync(dbPath);
+                const sizeMB = (stats.size / 1024 / 1024).toFixed(2);
+                return { name: 'Memory Database', status: 'pass', message: `${dbPath} (${sizeMB} MB)` };
             }
-            return [2 /*return*/, { name: 'Memory Database', status: 'warn', message: 'Not initialized', fix: 'claude-flow memory configure --backend hybrid' }];
-        });
-    });
+            catch {
+                return { name: 'Memory Database', status: 'warn', message: `${dbPath} (unable to stat)` };
+            }
+        }
+    }
+    return { name: 'Memory Database', status: 'warn', message: 'Not initialized', fix: 'claude-flow memory configure --backend hybrid' };
 }
 // Check API keys
-function checkApiKeys() {
-    return __awaiter(this, void 0, Promise, function () {
-        var keys, found, _i, keys_1, key, inClaudeCode;
-        return __generator(this, function (_a) {
-            keys = ['ANTHROPIC_API_KEY', 'CLAUDE_API_KEY', 'OPENAI_API_KEY'];
-            found = [];
-            for (_i = 0, keys_1 = keys; _i < keys_1.length; _i++) {
-                key = keys_1[_i];
-                if (process.env[key]) {
-                    found.push(key);
-                }
-            }
-            inClaudeCode = !!(process.env.CLAUDE_CODE || process.env.CLAUDE_PROJECT_DIR || process.env.MCP_SESSION_ID);
-            if (found.includes('ANTHROPIC_API_KEY') || found.includes('CLAUDE_API_KEY')) {
-                return [2 /*return*/, { name: 'API Keys', status: 'pass', message: "Found: " + found.join(', ') }];
-            }
-            else if (inClaudeCode) {
-                return [2 /*return*/, { name: 'API Keys', status: 'pass', message: 'Claude Code (managed internally)' }];
-            }
-            else if (found.length > 0) {
-                return [2 /*return*/, { name: 'API Keys', status: 'warn', message: "Found: " + found.join(', ') + " (no Claude key)", fix: 'export ANTHROPIC_API_KEY=your_key' }];
-            }
-            else {
-                return [2 /*return*/, { name: 'API Keys', status: 'warn', message: 'No API keys found', fix: 'export ANTHROPIC_API_KEY=your_key' }];
-            }
-            return [2 /*return*/];
-        });
-    });
+async function checkApiKeys() {
+    const keys = ['ANTHROPIC_API_KEY', 'CLAUDE_API_KEY', 'OPENAI_API_KEY'];
+    const found = [];
+    for (const key of keys) {
+        if (process.env[key]) {
+            found.push(key);
+        }
+    }
+    // Detect Claude Code environment — API keys are managed internally
+    const inClaudeCode = !!(process.env.CLAUDE_CODE || process.env.CLAUDE_PROJECT_DIR || process.env.MCP_SESSION_ID);
+    if (found.includes('ANTHROPIC_API_KEY') || found.includes('CLAUDE_API_KEY')) {
+        return { name: 'API Keys', status: 'pass', message: `Found: ${found.join(', ')}` };
+    }
+    else if (inClaudeCode) {
+        return { name: 'API Keys', status: 'pass', message: 'Claude Code (managed internally)' };
+    }
+    else if (found.length > 0) {
+        return { name: 'API Keys', status: 'warn', message: `Found: ${found.join(', ')} (no Claude key)`, fix: 'export ANTHROPIC_API_KEY=your_key' };
+    }
+    else {
+        return { name: 'API Keys', status: 'warn', message: 'No API keys found', fix: 'export ANTHROPIC_API_KEY=your_key' };
+    }
 }
 // Check git (async with proper env inheritance)
-function checkGit() {
-    return __awaiter(this, void 0, Promise, function () {
-        var version, _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    _b.trys.push([0, 2, , 3]);
-                    return [4 /*yield*/, runCommand('git --version')];
-                case 1:
-                    version = _b.sent();
-                    return [2 /*return*/, { name: 'Git', status: 'pass', message: version.replace('git version ', 'v') }];
-                case 2:
-                    _a = _b.sent();
-                    return [2 /*return*/, { name: 'Git', status: 'warn', message: 'Not installed', fix: 'Install git from https://git-scm.com' }];
-                case 3: return [2 /*return*/];
-            }
-        });
-    });
+async function checkGit() {
+    try {
+        const version = await runCommand('git --version');
+        return { name: 'Git', status: 'pass', message: version.replace('git version ', 'v') };
+    }
+    catch {
+        return { name: 'Git', status: 'warn', message: 'Not installed', fix: 'Install git from https://git-scm.com' };
+    }
 }
 // Check if in git repo (async with proper env inheritance)
-function checkGitRepo() {
-    return __awaiter(this, void 0, Promise, function () {
-        var _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    _b.trys.push([0, 2, , 3]);
-                    return [4 /*yield*/, runCommand('git rev-parse --git-dir')];
-                case 1:
-                    _b.sent();
-                    return [2 /*return*/, { name: 'Git Repository', status: 'pass', message: 'In a git repository' }];
-                case 2:
-                    _a = _b.sent();
-                    return [2 /*return*/, { name: 'Git Repository', status: 'warn', message: 'Not a git repository', fix: 'git init' }];
-                case 3: return [2 /*return*/];
-            }
-        });
-    });
+async function checkGitRepo() {
+    try {
+        await runCommand('git rev-parse --git-dir');
+        return { name: 'Git Repository', status: 'pass', message: 'In a git repository' };
+    }
+    catch {
+        return { name: 'Git Repository', status: 'warn', message: 'Not a git repository', fix: 'git init' };
+    }
 }
 // Check MCP servers
-function checkMcpServers() {
-    return __awaiter(this, void 0, Promise, function () {
-        var mcpConfigPaths, _i, mcpConfigPaths_1, configPath, content, servers, count, hasClaudeFlow;
-        return __generator(this, function (_a) {
-            mcpConfigPaths = [
-                join(process.env.HOME || '', '.claude/claude_desktop_config.json'),
-                join(process.env.HOME || '', '.config/claude/mcp.json'),
-                '.mcp.json'
-            ];
-            for (_i = 0, mcpConfigPaths_1 = mcpConfigPaths; _i < mcpConfigPaths_1.length; _i++) {
-                configPath = mcpConfigPaths_1[_i];
-                if (existsSync(configPath)) {
-                    try {
-                        content = JSON.parse(readFileSync(configPath, 'utf8'));
-                        servers = content.mcpServers || content.servers || {};
-                        count = Object.keys(servers).length;
-                        hasClaudeFlow = 'claude-flow' in servers || 'claude-flow_alpha' in servers || 'ruflo' in servers || 'ruflo_alpha' in servers;
-                        if (hasClaudeFlow) {
-                            return [2 /*return*/, { name: 'MCP Servers', status: 'pass', message: count + " servers (ruflo configured)" }];
-                        }
-                        else {
-                            return [2 /*return*/, { name: 'MCP Servers', status: 'warn', message: count + " servers (ruflo not found)", fix: 'claude mcp add ruflo -- npx -y ruflo@latest mcp start' }];
-                        }
-                    }
-                    catch (_b) {
-                        // continue to next path
-                    }
+async function checkMcpServers() {
+    const mcpConfigPaths = [
+        join(process.env.HOME || '', '.claude/claude_desktop_config.json'),
+        join(process.env.HOME || '', '.config/claude/mcp.json'),
+        '.mcp.json'
+    ];
+    for (const configPath of mcpConfigPaths) {
+        if (existsSync(configPath)) {
+            try {
+                const content = JSON.parse(readFileSync(configPath, 'utf8'));
+                const servers = content.mcpServers || content.servers || {};
+                const count = Object.keys(servers).length;
+                const hasClaudeFlow = 'claude-flow' in servers || 'claude-flow_alpha' in servers || 'ruflo' in servers || 'ruflo_alpha' in servers;
+                if (hasClaudeFlow) {
+                    return { name: 'MCP Servers', status: 'pass', message: `${count} servers (ruflo configured)` };
+                }
+                else {
+                    return { name: 'MCP Servers', status: 'warn', message: `${count} servers (ruflo not found)`, fix: 'claude mcp add ruflo -- npx -y ruflo@latest mcp start' };
                 }
             }
-            return [2 /*return*/, { name: 'MCP Servers', status: 'warn', message: 'No MCP config found', fix: 'claude mcp add claude-flow npx @claude-flow/cli@v3alpha mcp start' }];
-        });
-    });
+            catch {
+                // continue to next path
+            }
+        }
+    }
+    return { name: 'MCP Servers', status: 'warn', message: 'No MCP config found', fix: 'claude mcp add claude-flow npx @claude-flow/cli@v3alpha mcp start' };
 }
 // Check disk space (async with proper env inheritance)
-function checkDiskSpace() {
-    var _a;
-    return __awaiter(this, void 0, Promise, function () {
-        var output_str, parts, available, usePercent, _b;
-        return __generator(this, function (_c) {
-            switch (_c.label) {
-                case 0:
-                    _c.trys.push([0, 2, , 3]);
-                    if (process.platform === 'win32') {
-                        return [2 /*return*/, { name: 'Disk Space', status: 'pass', message: 'Check skipped on Windows' }];
-                    }
-                    return [4 /*yield*/, runCommand('df -Ph . | tail -1')];
-                case 1:
-                    output_str = _c.sent();
-                    parts = output_str.split(/\s+/);
-                    available = parts[3];
-                    usePercent = parseInt(((_a = parts[4]) === null || _a === void 0 ? void 0 : _a.replace('%', '')) || '0', 10);
-                    if (isNaN(usePercent)) {
-                        return [2 /*return*/, { name: 'Disk Space', status: 'warn', message: (available || 'unknown') + " available (unable to parse usage)" }];
-                    }
-                    if (usePercent > 90) {
-                        return [2 /*return*/, { name: 'Disk Space', status: 'fail', message: available + " available (" + usePercent + "% used)", fix: 'Free up disk space' }];
-                    }
-                    else if (usePercent > 80) {
-                        return [2 /*return*/, { name: 'Disk Space', status: 'warn', message: available + " available (" + usePercent + "% used)" }];
-                    }
-                    return [2 /*return*/, { name: 'Disk Space', status: 'pass', message: available + " available" }];
-                case 2:
-                    _b = _c.sent();
-                    return [2 /*return*/, { name: 'Disk Space', status: 'warn', message: 'Unable to check' }];
-                case 3: return [2 /*return*/];
-            }
-        });
-    });
+async function checkDiskSpace() {
+    try {
+        if (process.platform === 'win32') {
+            return { name: 'Disk Space', status: 'pass', message: 'Check skipped on Windows' };
+        }
+        // Use df -Ph for POSIX mode (guarantees single-line output even with long device names)
+        const output_str = await runCommand('df -Ph . | tail -1');
+        const parts = output_str.split(/\s+/);
+        // POSIX format: Filesystem Size Used Avail Capacity Mounted
+        const available = parts[3];
+        const usePercent = parseInt(parts[4]?.replace('%', '') || '0', 10);
+        if (isNaN(usePercent)) {
+            return { name: 'Disk Space', status: 'warn', message: `${available || 'unknown'} available (unable to parse usage)` };
+        }
+        if (usePercent > 90) {
+            return { name: 'Disk Space', status: 'fail', message: `${available} available (${usePercent}% used)`, fix: 'Free up disk space' };
+        }
+        else if (usePercent > 80) {
+            return { name: 'Disk Space', status: 'warn', message: `${available} available (${usePercent}% used)` };
+        }
+        return { name: 'Disk Space', status: 'pass', message: `${available} available` };
+    }
+    catch {
+        return { name: 'Disk Space', status: 'warn', message: 'Unable to check' };
+    }
 }
 // Check TypeScript/build (async with proper env inheritance)
-function checkBuildTools() {
-    return __awaiter(this, void 0, Promise, function () {
-        var tscVersion, _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    _b.trys.push([0, 2, , 3]);
-                    return [4 /*yield*/, runCommand('npx tsc --version', 10000)];
-                case 1:
-                    tscVersion = _b.sent();
-                    if (!tscVersion || tscVersion.includes('not found')) {
-                        return [2 /*return*/, { name: 'TypeScript', status: 'warn', message: 'Not installed locally', fix: 'npm install -D typescript' }];
-                    }
-                    return [2 /*return*/, { name: 'TypeScript', status: 'pass', message: tscVersion.replace('Version ', 'v') }];
-                case 2:
-                    _a = _b.sent();
-                    return [2 /*return*/, { name: 'TypeScript', status: 'warn', message: 'Not installed locally', fix: 'npm install -D typescript' }];
-                case 3: return [2 /*return*/];
-            }
-        });
-    });
+async function checkBuildTools() {
+    try {
+        const tscVersion = await runCommand('npx tsc --version', 10000); // tsc can be slow
+        if (!tscVersion || tscVersion.includes('not found')) {
+            return { name: 'TypeScript', status: 'warn', message: 'Not installed locally', fix: 'npm install -D typescript' };
+        }
+        return { name: 'TypeScript', status: 'pass', message: tscVersion.replace('Version ', 'v') };
+    }
+    catch {
+        return { name: 'TypeScript', status: 'warn', message: 'Not installed locally', fix: 'npm install -D typescript' };
+    }
 }
 // Check for stale npx cache (version freshness)
-function checkVersionFreshness() {
-    var _a, _b;
-    return __awaiter(this, void 0, Promise, function () {
-        var currentVersion, thisFile, dir, candidate, pkg, parent, isNpx, latestVersion, npmInfo, _c, parseVersion, current, latest, isOutdated, fix, error_1;
-        return __generator(this, function (_d) {
-            switch (_d.label) {
-                case 0:
-                    _d.trys.push([0, 5, , 6]);
-                    currentVersion = '0.0.0';
-                    try {
-                        thisFile = fileURLToPath(import.meta.url);
-                        dir = dirname(thisFile);
-                        // Walk up from the current file's directory until we find the
-                        // package.json that belongs to @claude-flow/cli (or claude-flow/cli).
-                        // Walk until dirname(dir) === dir (filesystem root on any platform).
-                        for (;;) {
-                            candidate = join(dir, 'package.json');
-                            try {
-                                if (existsSync(candidate)) {
-                                    pkg = JSON.parse(readFileSync(candidate, 'utf8'));
-                                    if (pkg.version &&
-                                        typeof pkg.name === 'string' &&
-                                        (pkg.name === '@claude-flow/cli' || pkg.name === 'claude-flow' || pkg.name === 'ruflo')) {
-                                        currentVersion = pkg.version;
-                                        break;
-                                    }
-                                }
-                            }
-                            catch (_e) {
-                                // Unreadable/invalid JSON -- skip and keep walking up
-                            }
-                            parent = dirname(dir);
-                            if (parent === dir)
-                                break; // reached root
-                            dir = parent;
+async function checkVersionFreshness() {
+    try {
+        // Get current CLI version from package.json
+        // Use import.meta.url to reliably locate our own package.json,
+        // regardless of how deep the compiled file sits (e.g. dist/src/commands/).
+        let currentVersion = '0.0.0';
+        try {
+            const thisFile = fileURLToPath(import.meta.url);
+            let dir = dirname(thisFile);
+            // Walk up from the current file's directory until we find the
+            // package.json that belongs to @claude-flow/cli (or claude-flow/cli).
+            // Walk until dirname(dir) === dir (filesystem root on any platform).
+            for (;;) {
+                const candidate = join(dir, 'package.json');
+                try {
+                    if (existsSync(candidate)) {
+                        const pkg = JSON.parse(readFileSync(candidate, 'utf8'));
+                        if (pkg.version &&
+                            typeof pkg.name === 'string' &&
+                            (pkg.name === '@claude-flow/cli' || pkg.name === 'claude-flow' || pkg.name === 'ruflo')) {
+                            currentVersion = pkg.version;
+                            break;
                         }
                     }
-                    catch (_f) {
-                        // Fall back to a default
-                        currentVersion = '0.0.0';
-                    }
-                    isNpx = ((_a = process.argv[1]) === null || _a === void 0 ? void 0 : _a.includes('_npx')) ||
-                        ((_b = process.env.npm_execpath) === null || _b === void 0 ? void 0 : _b.includes('npx')) ||
-                        process.cwd().includes('_npx');
-                    latestVersion = currentVersion;
-                    _d.label = 1;
-                case 1:
-                    _d.trys.push([1, 3, , 4]);
-                    return [4 /*yield*/, runCommand('npm view @claude-flow/cli@alpha version', 5000)];
-                case 2:
-                    npmInfo = _d.sent();
-                    latestVersion = npmInfo.trim();
-                    return [3 /*break*/, 4];
-                case 3:
-                    _c = _d.sent();
-                    // Can't reach npm registry - skip check
-                    return [2 /*return*/, {
-                            name: 'Version Freshness',
-                            status: 'warn',
-                            message: "v" + currentVersion + " (cannot check registry)"
-                        }];
-                case 4:
-                    parseVersion = function (v) {
-                        var match = v.match(/^(\d+)\.(\d+)\.(\d+)(?:-[a-zA-Z]+\.(\d+))?/);
-                        if (!match)
-                            return { major: 0, minor: 0, patch: 0, prerelease: 0 };
-                        return {
-                            major: parseInt(match[1], 10) || 0,
-                            minor: parseInt(match[2], 10) || 0,
-                            patch: parseInt(match[3], 10) || 0,
-                            prerelease: parseInt(match[4], 10) || 0
-                        };
-                    };
-                    current = parseVersion(currentVersion);
-                    latest = parseVersion(latestVersion);
-                    isOutdated = (latest.major > current.major ||
-                        (latest.major === current.major && latest.minor > current.minor) ||
-                        (latest.major === current.major && latest.minor === current.minor && latest.patch > current.patch) ||
-                        (latest.major === current.major && latest.minor === current.minor && latest.patch === current.patch && latest.prerelease > current.prerelease));
-                    if (isOutdated) {
-                        fix = isNpx
-                            ? 'rm -rf ~/.npm/_npx/* && npx -y @claude-flow/cli@latest'
-                            : 'npm update @claude-flow/cli';
-                        return [2 /*return*/, {
-                                name: 'Version Freshness',
-                                status: 'warn',
-                                message: "v" + currentVersion + " (latest: v" + latestVersion + ")" + (isNpx ? ' [npx cache stale]' : ''),
-                                fix: fix
-                            }];
-                    }
-                    return [2 /*return*/, {
-                            name: 'Version Freshness',
-                            status: 'pass',
-                            message: "v" + currentVersion + " (up to date)"
-                        }];
-                case 5:
-                    error_1 = _d.sent();
-                    return [2 /*return*/, {
-                            name: 'Version Freshness',
-                            status: 'warn',
-                            message: 'Unable to check version freshness'
-                        }];
-                case 6: return [2 /*return*/];
+                }
+                catch {
+                    // Unreadable/invalid JSON -- skip and keep walking up
+                }
+                const parent = dirname(dir);
+                if (parent === dir)
+                    break; // reached root
+                dir = parent;
             }
-        });
-    });
+        }
+        catch {
+            // Fall back to a default
+            currentVersion = '0.0.0';
+        }
+        // Check if running via npx (look for _npx in process path or argv)
+        const isNpx = process.argv[1]?.includes('_npx') ||
+            process.env.npm_execpath?.includes('npx') ||
+            process.cwd().includes('_npx');
+        // Query npm for latest version (using alpha tag since that's what we publish to)
+        let latestVersion = currentVersion;
+        try {
+            const npmInfo = await runCommand('npm view @claude-flow/cli@alpha version', 5000);
+            latestVersion = npmInfo.trim();
+        }
+        catch {
+            // Can't reach npm registry - skip check
+            return {
+                name: 'Version Freshness',
+                status: 'warn',
+                message: `v${currentVersion} (cannot check registry)`
+            };
+        }
+        // Parse version numbers for comparison (handle prerelease like 3.0.0-alpha.84)
+        const parseVersion = (v) => {
+            const match = v.match(/^(\d+)\.(\d+)\.(\d+)(?:-[a-zA-Z]+\.(\d+))?/);
+            if (!match)
+                return { major: 0, minor: 0, patch: 0, prerelease: 0 };
+            return {
+                major: parseInt(match[1], 10) || 0,
+                minor: parseInt(match[2], 10) || 0,
+                patch: parseInt(match[3], 10) || 0,
+                prerelease: parseInt(match[4], 10) || 0
+            };
+        };
+        const current = parseVersion(currentVersion);
+        const latest = parseVersion(latestVersion);
+        // Compare versions (including prerelease number)
+        const isOutdated = (latest.major > current.major ||
+            (latest.major === current.major && latest.minor > current.minor) ||
+            (latest.major === current.major && latest.minor === current.minor && latest.patch > current.patch) ||
+            (latest.major === current.major && latest.minor === current.minor && latest.patch === current.patch && latest.prerelease > current.prerelease));
+        if (isOutdated) {
+            const fix = isNpx
+                ? 'rm -rf ~/.npm/_npx/* && npx -y @claude-flow/cli@latest'
+                : 'npm update @claude-flow/cli';
+            return {
+                name: 'Version Freshness',
+                status: 'warn',
+                message: `v${currentVersion} (latest: v${latestVersion})${isNpx ? ' [npx cache stale]' : ''}`,
+                fix
+            };
+        }
+        return {
+            name: 'Version Freshness',
+            status: 'pass',
+            message: `v${currentVersion} (up to date)`
+        };
+    }
+    catch (error) {
+        return {
+            name: 'Version Freshness',
+            status: 'warn',
+            message: 'Unable to check version freshness'
+        };
+    }
 }
 // Check Claude Code CLI (async with proper env inheritance)
-function checkClaudeCode() {
-    return __awaiter(this, void 0, Promise, function () {
-        var version, versionMatch, versionStr, _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    _b.trys.push([0, 2, , 3]);
-                    return [4 /*yield*/, runCommand('claude --version')];
-                case 1:
-                    version = _b.sent();
-                    versionMatch = version.match(/v?(\d+\.\d+\.\d+)/);
-                    versionStr = versionMatch ? "v" + versionMatch[1] : version;
-                    return [2 /*return*/, { name: 'Claude Code CLI', status: 'pass', message: versionStr }];
-                case 2:
-                    _a = _b.sent();
-                    return [2 /*return*/, {
-                            name: 'Claude Code CLI',
-                            status: 'warn',
-                            message: 'Not installed',
-                            fix: 'npm install -g @anthropic-ai/claude-code'
-                        }];
-                case 3: return [2 /*return*/];
-            }
-        });
-    });
+async function checkClaudeCode() {
+    try {
+        const version = await runCommand('claude --version');
+        // Parse version from output like "claude 1.0.0" or "Claude Code v1.0.0"
+        const versionMatch = version.match(/v?(\d+\.\d+\.\d+)/);
+        const versionStr = versionMatch ? `v${versionMatch[1]}` : version;
+        return { name: 'Claude Code CLI', status: 'pass', message: versionStr };
+    }
+    catch {
+        return {
+            name: 'Claude Code CLI',
+            status: 'warn',
+            message: 'Not installed',
+            fix: 'npm install -g @anthropic-ai/claude-code'
+        };
+    }
 }
 // Install Claude Code CLI
-function installClaudeCode() {
-    return __awaiter(this, void 0, Promise, function () {
-        return __generator(this, function (_a) {
-            try {
-                output.writeln();
-                output.writeln(output.bold('Installing Claude Code CLI...'));
-                execSync('npm install -g @anthropic-ai/claude-code', {
-                    encoding: 'utf8',
-                    stdio: 'inherit'
-                });
-                output.writeln(output.success('Claude Code CLI installed successfully!'));
-                return [2 /*return*/, true];
-            }
-            catch (error) {
-                output.writeln(output.error('Failed to install Claude Code CLI'));
-                if (error instanceof Error) {
-                    output.writeln(output.dim(error.message));
-                }
-                return [2 /*return*/, false];
-            }
-            return [2 /*return*/];
+async function installClaudeCode() {
+    try {
+        output.writeln();
+        output.writeln(output.bold('Installing Claude Code CLI...'));
+        execSync('npm install -g @anthropic-ai/claude-code', {
+            encoding: 'utf8',
+            stdio: 'inherit'
         });
-    });
+        output.writeln(output.success('Claude Code CLI installed successfully!'));
+        return true;
+    }
+    catch (error) {
+        output.writeln(output.error('Failed to install Claude Code CLI'));
+        if (error instanceof Error) {
+            output.writeln(output.dim(error.message));
+        }
+        return false;
+    }
 }
 // Check agentic-flow v3 integration (filesystem-based to avoid slow WASM/DB init)
-function checkAgenticFlow() {
-    return __awaiter(this, void 0, Promise, function () {
-        var candidates, pkgJsonPath, _i, candidates_1, p, pkg, version, exports, features;
-        return __generator(this, function (_a) {
-            try {
-                candidates = [
-                    join(process.cwd(), 'node_modules', 'agentic-flow', 'package.json'),
-                    join(process.cwd(), '..', 'node_modules', 'agentic-flow', 'package.json'),
-                ];
-                pkgJsonPath = null;
-                for (_i = 0, candidates_1 = candidates; _i < candidates_1.length; _i++) {
-                    p = candidates_1[_i];
-                    if (existsSync(p)) {
-                        pkgJsonPath = p;
-                        break;
-                    }
-                }
-                if (!pkgJsonPath) {
-                    return [2 /*return*/, {
-                            name: 'agentic-flow',
-                            status: 'warn',
-                            message: 'Not installed (optional — embeddings/routing will use fallbacks)',
-                            fix: 'npm install agentic-flow@latest'
-                        }];
-                }
-                pkg = JSON.parse(readFileSync(pkgJsonPath, 'utf-8'));
-                version = pkg.version || 'unknown';
-                exports = pkg.exports || {};
-                features = [
-                    exports['./reasoningbank'] ? 'ReasoningBank' : null,
-                    exports['./router'] ? 'Router' : null,
-                    exports['./transport/quic'] ? 'QUIC' : null,
-                ].filter(Boolean);
-                return [2 /*return*/, {
-                        name: 'agentic-flow',
-                        status: 'pass',
-                        message: "v" + version + " (" + features.join(', ') + ")"
-                    }];
+async function checkAgenticFlow() {
+    try {
+        // Walk common node_modules paths to find agentic-flow/package.json
+        const candidates = [
+            join(process.cwd(), 'node_modules', 'agentic-flow', 'package.json'),
+            join(process.cwd(), '..', 'node_modules', 'agentic-flow', 'package.json'),
+        ];
+        let pkgJsonPath = null;
+        for (const p of candidates) {
+            if (existsSync(p)) {
+                pkgJsonPath = p;
+                break;
             }
-            catch (_b) {
-                return [2 /*return*/, { name: 'agentic-flow', status: 'warn', message: 'Check failed' }];
-            }
-            return [2 /*return*/];
-        });
-    });
+        }
+        if (!pkgJsonPath) {
+            return {
+                name: 'agentic-flow',
+                status: 'warn',
+                message: 'Not installed (optional — embeddings/routing will use fallbacks)',
+                fix: 'npm install agentic-flow@latest'
+            };
+        }
+        const pkg = JSON.parse(readFileSync(pkgJsonPath, 'utf-8'));
+        const version = pkg.version || 'unknown';
+        const exports = pkg.exports || {};
+        const features = [
+            exports['./reasoningbank'] ? 'ReasoningBank' : null,
+            exports['./router'] ? 'Router' : null,
+            exports['./transport/quic'] ? 'QUIC' : null,
+        ].filter(Boolean);
+        return {
+            name: 'agentic-flow',
+            status: 'pass',
+            message: `v${version} (${features.join(', ')})`
+        };
+    }
+    catch {
+        return { name: 'agentic-flow', status: 'warn', message: 'Check failed' };
+    }
 }
 // Format health check result
 function formatCheck(check) {
-    var icon = check.status === 'pass' ? output.success('✓') :
+    const icon = check.status === 'pass' ? output.success('✓') :
         check.status === 'warn' ? output.warning('⚠') :
             output.error('✗');
-    return icon + " " + check.name + ": " + check.message;
+    return `${icon} ${check.name}: ${check.message}`;
 }
 // Main doctor command
-export var doctorCommand = {
+export const doctorCommand = {
     name: 'doctor',
     description: 'System diagnostics and health checks',
     options: [
@@ -609,14 +440,14 @@ export var doctorCommand = {
             short: 'f',
             description: 'Show fix commands for issues',
             type: 'boolean',
-            "default": false
+            default: false
         },
         {
             name: 'install',
             short: 'i',
             description: 'Auto-install missing dependencies (Claude Code CLI)',
             type: 'boolean',
-            "default": false
+            default: false
         },
         {
             name: 'component',
@@ -629,7 +460,7 @@ export var doctorCommand = {
             short: 'v',
             description: 'Verbose output',
             type: 'boolean',
-            "default": false
+            default: false
         }
     ],
     examples: [
@@ -639,163 +470,150 @@ export var doctorCommand = {
         { command: 'claude-flow doctor -c version', description: 'Check for stale npx cache' },
         { command: 'claude-flow doctor -c claude', description: 'Check Claude Code CLI only' }
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var showFix, autoInstall, component, verbose, allChecks, componentMap, checksToRun, results, fixes, spinner, checkResults, _i, checkResults_1, settledResult, result, errorResult, error_2, claudeCodeResult, installed, newCheck, idx, fixIdx, passed, warnings, failed, summaryParts, _a, fixes_1, fix;
-        var _b;
-        return __generator(this, function (_c) {
-            switch (_c.label) {
-                case 0:
-                    showFix = ctx.flags.fix;
-                    autoInstall = ctx.flags.install;
-                    component = ctx.flags.component;
-                    verbose = ctx.flags.verbose;
-                    output.writeln();
-                    output.writeln(output.bold('RuFlo Doctor'));
-                    output.writeln(output.dim('System diagnostics and health check'));
-                    output.writeln(output.dim('─'.repeat(50)));
-                    output.writeln();
-                    allChecks = [
-                        checkVersionFreshness,
-                        checkNodeVersion,
-                        checkNpmVersion,
-                        checkClaudeCode,
-                        checkGit,
-                        checkGitRepo,
-                        checkConfigFile,
-                        checkDaemonStatus,
-                        checkMemoryDatabase,
-                        checkApiKeys,
-                        checkMcpServers,
-                        checkDiskSpace,
-                        checkBuildTools,
-                        checkAgenticFlow
-                    ];
-                    componentMap = {
-                        'version': checkVersionFreshness,
-                        'freshness': checkVersionFreshness,
-                        'node': checkNodeVersion,
-                        'npm': checkNpmVersion,
-                        'claude': checkClaudeCode,
-                        'config': checkConfigFile,
-                        'daemon': checkDaemonStatus,
-                        'memory': checkMemoryDatabase,
-                        'api': checkApiKeys,
-                        'git': checkGit,
-                        'mcp': checkMcpServers,
-                        'disk': checkDiskSpace,
-                        'typescript': checkBuildTools,
-                        'agentic-flow': checkAgenticFlow
-                    };
-                    checksToRun = allChecks;
-                    if (component && componentMap[component]) {
-                        checksToRun = [componentMap[component]];
-                    }
-                    results = [];
-                    fixes = [];
-                    spinner = output.createSpinner({ text: 'Running health checks in parallel...', spinner: 'dots' });
-                    spinner.start();
-                    _c.label = 1;
-                case 1:
-                    _c.trys.push([1, 3, , 4]);
-                    return [4 /*yield*/, Promise.allSettled(checksToRun.map(function (check) { return check(); }))];
-                case 2:
-                    checkResults = _c.sent();
-                    spinner.stop();
-                    // Process results in order
-                    for (_i = 0, checkResults_1 = checkResults; _i < checkResults_1.length; _i++) {
-                        settledResult = checkResults_1[_i];
-                        if (settledResult.status === 'fulfilled') {
-                            result = settledResult.value;
-                            results.push(result);
-                            output.writeln(formatCheck(result));
-                            if (result.fix && (result.status === 'fail' || result.status === 'warn')) {
-                                fixes.push(result.name + ": " + result.fix);
-                            }
-                        }
-                        else {
-                            errorResult = {
-                                name: 'Check',
-                                status: 'fail',
-                                message: ((_b = settledResult.reason) === null || _b === void 0 ? void 0 : _b.message) || 'Unknown error'
-                            };
-                            results.push(errorResult);
-                            output.writeln(formatCheck(errorResult));
-                        }
+    action: async (ctx) => {
+        const showFix = ctx.flags.fix;
+        const autoInstall = ctx.flags.install;
+        const component = ctx.flags.component;
+        const verbose = ctx.flags.verbose;
+        output.writeln();
+        output.writeln(output.bold('RuFlo Doctor'));
+        output.writeln(output.dim('System diagnostics and health check'));
+        output.writeln(output.dim('─'.repeat(50)));
+        output.writeln();
+        const allChecks = [
+            checkVersionFreshness,
+            checkNodeVersion,
+            checkNpmVersion,
+            checkClaudeCode,
+            checkGit,
+            checkGitRepo,
+            checkConfigFile,
+            checkDaemonStatus,
+            checkMemoryDatabase,
+            checkApiKeys,
+            checkMcpServers,
+            checkDiskSpace,
+            checkBuildTools,
+            checkAgenticFlow
+        ];
+        const componentMap = {
+            'version': checkVersionFreshness,
+            'freshness': checkVersionFreshness,
+            'node': checkNodeVersion,
+            'npm': checkNpmVersion,
+            'claude': checkClaudeCode,
+            'config': checkConfigFile,
+            'daemon': checkDaemonStatus,
+            'memory': checkMemoryDatabase,
+            'api': checkApiKeys,
+            'git': checkGit,
+            'mcp': checkMcpServers,
+            'disk': checkDiskSpace,
+            'typescript': checkBuildTools,
+            'agentic-flow': checkAgenticFlow
+        };
+        let checksToRun = allChecks;
+        if (component && componentMap[component]) {
+            checksToRun = [componentMap[component]];
+        }
+        const results = [];
+        const fixes = [];
+        // OPTIMIZATION: Run all checks in parallel for 3-5x faster execution
+        const spinner = output.createSpinner({ text: 'Running health checks in parallel...', spinner: 'dots' });
+        spinner.start();
+        try {
+            // Execute all checks concurrently
+            const checkResults = await Promise.allSettled(checksToRun.map(check => check()));
+            spinner.stop();
+            // Process results in order
+            for (const settledResult of checkResults) {
+                if (settledResult.status === 'fulfilled') {
+                    const result = settledResult.value;
+                    results.push(result);
+                    output.writeln(formatCheck(result));
+                    if (result.fix && (result.status === 'fail' || result.status === 'warn')) {
+                        fixes.push(`${result.name}: ${result.fix}`);
                     }
-                    return [3 /*break*/, 4];
-                case 3:
-                    error_2 = _c.sent();
-                    spinner.stop();
-                    output.writeln(output.error('Failed to run health checks'));
-                    return [3 /*break*/, 4];
-                case 4:
-                    if (!autoInstall) return [3 /*break*/, 7];
-                    claudeCodeResult = results.find(function (r) { return r.name === 'Claude Code CLI'; });
-                    if (!(claudeCodeResult && claudeCodeResult.status !== 'pass')) return [3 /*break*/, 7];
-                    return [4 /*yield*/, installClaudeCode()];
-                case 5:
-                    installed = _c.sent();
-                    if (!installed) return [3 /*break*/, 7];
-                    return [4 /*yield*/, checkClaudeCode()];
-                case 6:
-                    newCheck = _c.sent();
-                    idx = results.findIndex(function (r) { return r.name === 'Claude Code CLI'; });
+                }
+                else {
+                    const errorResult = {
+                        name: 'Check',
+                        status: 'fail',
+                        message: settledResult.reason?.message || 'Unknown error'
+                    };
+                    results.push(errorResult);
+                    output.writeln(formatCheck(errorResult));
+                }
+            }
+        }
+        catch (error) {
+            spinner.stop();
+            output.writeln(output.error('Failed to run health checks'));
+        }
+        // Auto-install missing dependencies if requested
+        if (autoInstall) {
+            const claudeCodeResult = results.find(r => r.name === 'Claude Code CLI');
+            if (claudeCodeResult && claudeCodeResult.status !== 'pass') {
+                const installed = await installClaudeCode();
+                if (installed) {
+                    // Re-check Claude Code after installation
+                    const newCheck = await checkClaudeCode();
+                    const idx = results.findIndex(r => r.name === 'Claude Code CLI');
                     if (idx !== -1) {
                         results[idx] = newCheck;
-                        fixIdx = fixes.findIndex(function (f) { return f.startsWith('Claude Code CLI:'); });
+                        // Update fixes list
+                        const fixIdx = fixes.findIndex(f => f.startsWith('Claude Code CLI:'));
                         if (fixIdx !== -1 && newCheck.status === 'pass') {
                             fixes.splice(fixIdx, 1);
                         }
                     }
                     output.writeln(formatCheck(newCheck));
-                    _c.label = 7;
-                case 7:
-                    passed = results.filter(function (r) { return r.status === 'pass'; }).length;
-                    warnings = results.filter(function (r) { return r.status === 'warn'; }).length;
-                    failed = results.filter(function (r) { return r.status === 'fail'; }).length;
-                    output.writeln();
-                    output.writeln(output.dim('─'.repeat(50)));
-                    output.writeln();
-                    summaryParts = [
-                        output.success(passed + " passed"),
-                        warnings > 0 ? output.warning(warnings + " warnings") : null,
-                        failed > 0 ? output.error(failed + " failed") : null
-                    ].filter(Boolean);
-                    output.writeln("Summary: " + summaryParts.join(', '));
-                    // Show fixes
-                    if (showFix && fixes.length > 0) {
-                        output.writeln();
-                        output.writeln(output.bold('Suggested Fixes:'));
-                        output.writeln();
-                        for (_a = 0, fixes_1 = fixes; _a < fixes_1.length; _a++) {
-                            fix = fixes_1[_a];
-                            output.writeln(output.dim("  " + fix));
-                        }
-                    }
-                    else if (fixes.length > 0 && !showFix) {
-                        output.writeln();
-                        output.writeln(output.dim("Run with --fix to see " + fixes.length + " suggested fix" + (fixes.length > 1 ? 'es' : '')));
-                    }
-                    // Overall result
-                    if (failed > 0) {
-                        output.writeln();
-                        output.writeln(output.error('Some checks failed. Please address the issues above.'));
-                        return [2 /*return*/, { success: false, exitCode: 1, data: { passed: passed, warnings: warnings, failed: failed, results: results } }];
-                    }
-                    else if (warnings > 0) {
-                        output.writeln();
-                        output.writeln(output.warning('All checks passed with some warnings.'));
-                        return [2 /*return*/, { success: true, data: { passed: passed, warnings: warnings, failed: failed, results: results } }];
-                    }
-                    else {
-                        output.writeln();
-                        output.writeln(output.success('All checks passed! System is healthy.'));
-                        return [2 /*return*/, { success: true, data: { passed: passed, warnings: warnings, failed: failed, results: results } }];
-                    }
-                    return [2 /*return*/];
+                }
             }
-        });
-    }); }
+        }
+        // Summary
+        const passed = results.filter(r => r.status === 'pass').length;
+        const warnings = results.filter(r => r.status === 'warn').length;
+        const failed = results.filter(r => r.status === 'fail').length;
+        output.writeln();
+        output.writeln(output.dim('─'.repeat(50)));
+        output.writeln();
+        const summaryParts = [
+            output.success(`${passed} passed`),
+            warnings > 0 ? output.warning(`${warnings} warnings`) : null,
+            failed > 0 ? output.error(`${failed} failed`) : null
+        ].filter(Boolean);
+        output.writeln(`Summary: ${summaryParts.join(', ')}`);
+        // Show fixes
+        if (showFix && fixes.length > 0) {
+            output.writeln();
+            output.writeln(output.bold('Suggested Fixes:'));
+            output.writeln();
+            for (const fix of fixes) {
+                output.writeln(output.dim(`  ${fix}`));
+            }
+        }
+        else if (fixes.length > 0 && !showFix) {
+            output.writeln();
+            output.writeln(output.dim(`Run with --fix to see ${fixes.length} suggested fix${fixes.length > 1 ? 'es' : ''}`));
+        }
+        // Overall result
+        if (failed > 0) {
+            output.writeln();
+            output.writeln(output.error('Some checks failed. Please address the issues above.'));
+            return { success: false, exitCode: 1, data: { passed, warnings, failed, results } };
+        }
+        else if (warnings > 0) {
+            output.writeln();
+            output.writeln(output.warning('All checks passed with some warnings.'));
+            return { success: true, data: { passed, warnings, failed, results } };
+        }
+        else {
+            output.writeln();
+            output.writeln(output.success('All checks passed! System is healthy.'));
+            return { success: true, data: { passed, warnings, failed, results } };
+        }
+    }
 };
 export default doctorCommand;
 //# sourceMappingURL=doctor.js.map