osagent 0.1.87 → 0.1.89

package/dist/src/ui/commands/doctorCommand.js

@@ -0,0 +1,1042 @@
+/**
+ * @license
+ * Copyright 2025 OSAgent OC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { CommandKind } from './types.js';
+import React from 'react';
+import { Text } from 'ink';
+import { t } from '../../i18n/index.js';
+import { execSync } from 'child_process';
+import { existsSync, readdirSync, mkdirSync, writeFileSync, readFileSync } from 'fs';
+import { homedir, platform, release, cpus, totalmem, freemem } from 'os';
+import { join } from 'path';
+import { createBox, createTree, icons, formatBytes, box, } from '../utils/terminalUI.js';
+// Plain text helpers (no ANSI codes - they get escaped by the UI security layer)
+const plainStatusIcon = (status) => {
+    switch (status) {
+        case 'ok':
+        case 'success':
+            return `[✓]`;
+        case 'warning':
+            return `[!]`;
+        case 'error':
+            return `[✗]`;
+        case 'info':
+            return `[i]`;
+        case 'pending':
+            return `[○]`;
+    }
+};
+const plainDivider = (width = 50) => '─'.repeat(width);
+const plainKeyValue = (key, value, keyWidth = 20) => {
+    return `${key.padEnd(keyWidth)}${value}`;
+};
+const plainSectionHeader = (title, icon) => {
+    const prefix = icon ? `${icon} ` : '';
+    return `═══ ${prefix}${title} ═══`;
+};
+// ============================================================================
+// SYSTEM INFO
+// ============================================================================
+function getSystemInfo() {
+    let npmVersion = 'unknown';
+    try {
+        npmVersion = execSync('npm --version 2>/dev/null', { encoding: 'utf-8' }).trim();
+    }
+    catch {
+        // ignore
+    }
+    const cpuInfo = cpus();
+    const cpuModel = cpuInfo.length > 0 ? cpuInfo[0].model : 'unknown';
+    return {
+        os: `${platform()} ${release()}`,
+        arch: process.arch,
+        nodeVersion: process.version,
+        npmVersion,
+        memory: `${formatBytes(freemem())} free / ${formatBytes(totalmem())} total`,
+        cpu: `${cpuModel} (${cpuInfo.length} cores)`,
+    };
+}
+function detectInstallMethod() {
+    const execPath = process.execPath;
+    const argv0 = process.argv[0] || '';
+    // Check for common npm global paths
+    const npmGlobalPaths = [
+        '/usr/local/lib/node_modules',
+        '/usr/lib/node_modules',
+        'node_modules/.bin',
+        '/opt/homebrew/lib/node_modules',
+    ];
+    if (npmGlobalPaths.some(p => execPath.includes(p) || argv0.includes(p))) {
+        return 'npm-global';
+    }
+    // Check for Homebrew
+    if (execPath.includes('/opt/homebrew/') || execPath.includes('/usr/local/Cellar/')) {
+        return 'homebrew';
+    }
+    // Check for local npm install
+    if (execPath.includes('node_modules') || argv0.includes('.osagent/local')) {
+        return 'npm-local';
+    }
+    // Check for native install (common locations)
+    if (execPath.includes('.local/bin') || argv0.includes('.local/bin')) {
+        return 'native';
+    }
+    // Check if running from source (development)
+    if (process.cwd().includes('osagent') && existsSync(join(process.cwd(), 'package.json'))) {
+        return 'source';
+    }
+    return 'npm-global'; // Default assumption for npm-installed packages
+}
+function getInstallationInfo() {
+    const method = detectInstallMethod();
+    // Get paths
+    const execPath = process.execPath;
+    const argv0 = process.argv[0] || execPath;
+    // Check for ripgrep/search
+    let searchStatus = 'missing';
+    try {
+        // Check bundled vendor directory first
+        const vendorRgPath = join(__dirname, '..', '..', 'vendor', 'ripgrep');
+        if (existsSync(vendorRgPath)) {
+            searchStatus = 'OK (bundled)';
+        }
+        else {
+            // Check system ripgrep
+            execSync('which rg 2>/dev/null', { encoding: 'utf-8' });
+            searchStatus = 'OK (system)';
+        }
+    }
+    catch {
+        // Check if rg exists in common locations
+        const rgPaths = ['/usr/local/bin/rg', '/opt/homebrew/bin/rg', '/usr/bin/rg'];
+        if (rgPaths.some(p => existsSync(p))) {
+            searchStatus = 'OK (system)';
+        }
+    }
+    // Check for multiple installations
+    const multipleInstalls = [];
+    const possiblePaths = [
+        { path: join(homedir(), '.osagent', 'local'), method: 'npm-local' },
+        { path: '/usr/local/bin/osagent', method: 'npm-global' },
+        { path: join(homedir(), '.local', 'bin', 'osagent'), method: 'native' },
+        { path: '/opt/homebrew/bin/osagent', method: 'homebrew' },
+    ];
+    for (const { path: checkPath, method: checkMethod } of possiblePaths) {
+        if (existsSync(checkPath) && checkMethod !== method) {
+            multipleInstalls.push({ method: checkMethod, path: checkPath });
+        }
+    }
+    return {
+        method,
+        version: getCurrentVersion(),
+        path: execPath,
+        invokedPath: argv0,
+        autoUpdates: true, // Default for npm
+        searchStatus,
+        multipleInstalls: multipleInstalls.length > 0 ? multipleInstalls : undefined,
+    };
+}
+// ============================================================================
+// VERSION CHECKS
+// ============================================================================
+function getCurrentVersion() {
+    try {
+        // First try to get from package.json in the install location
+        const pkg = execSync('npm list -g osagent --json 2>/dev/null', { encoding: 'utf-8' });
+        const parsed = JSON.parse(pkg);
+        return parsed.dependencies?.osagent?.version || 'unknown';
+    }
+    catch {
+        // Fallback to checking npm view
+        try {
+            return execSync('npm view osagent version 2>/dev/null', { encoding: 'utf-8' }).trim();
+        }
+        catch {
+            return 'unknown';
+        }
+    }
+}
+function getLatestVersion() {
+    try {
+        const result = execSync('npm view osagent version 2>/dev/null', { encoding: 'utf-8' });
+        return result.trim();
+    }
+    catch {
+        return 'unknown';
+    }
+}
+function fetchReleaseNotes(currentVersion, latestVersion) {
+    try {
+        // Fetch npm package info to get recent versions and their publish dates
+        const result = execSync('npm view osagent --json 2>/dev/null', { encoding: 'utf-8' });
+        const packageInfo = JSON.parse(result);
+        const changes = [];
+        // Get time info for versions
+        const times = packageInfo.time || {};
+        const publishDate = times[latestVersion]
+            ? new Date(times[latestVersion]).toLocaleDateString('en-US', {
+                year: 'numeric',
+                month: 'short',
+                day: 'numeric'
+            })
+            : 'recently';
+        // Try to get description from package info
+        if (packageInfo.description) {
+            changes.push(`Latest: ${packageInfo.description}`);
+        }
+        // Add version bump info
+        changes.push(`Version ${currentVersion} → ${latestVersion}`);
+        changes.push(`Published: ${publishDate}`);
+        return {
+            version: latestVersion,
+            date: publishDate,
+            changes,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function compareVersions(current, latest) {
+    // Returns: -1 if current < latest, 0 if equal, 1 if current > latest
+    if (current === 'unknown' || latest === 'unknown')
+        return 0;
+    const currentParts = current.split('.').map(p => parseInt(p, 10));
+    const latestParts = latest.split('.').map(p => parseInt(p, 10));
+    for (let i = 0; i < Math.max(currentParts.length, latestParts.length); i++) {
+        const c = currentParts[i] || 0;
+        const l = latestParts[i] || 0;
+        if (c < l)
+            return -1;
+        if (c > l)
+            return 1;
+    }
+    return 0;
+}
+// ============================================================================
+// HEALTH CHECKS
+// ============================================================================
+function checkNodeVersion() {
+    const version = process.version;
+    const major = parseInt(version.slice(1).split('.')[0], 10);
+    if (major >= 20) {
+        return { name: 'Node.js Runtime', status: 'ok', message: `${version}` };
+    }
+    else if (major >= 18) {
+        return {
+            name: 'Node.js Runtime',
+            status: 'warning',
+            message: `${version} (upgrade recommended)`,
+            fix: 'Install Node.js 20+ for best performance',
+        };
+    }
+    return {
+        name: 'Node.js Runtime',
+        status: 'error',
+        message: `${version} (unsupported)`,
+        fix: 'Install Node.js 20+ from https://nodejs.org',
+    };
+}
+function checkOllamaInstalled() {
+    try {
+        const result = execSync('ollama --version 2>&1', { encoding: 'utf-8', timeout: 5000 });
+        const version = result.match(/ollama version ([\d.]+)/)?.[1] || result.trim();
+        return { name: 'Ollama CLI', status: 'ok', message: `v${version}` };
+    }
+    catch {
+        return {
+            name: 'Ollama CLI',
+            status: 'warning',
+            message: 'not installed',
+            fix: 'Install from https://ollama.com for local models',
+            autoFix: async () => {
+                if (platform() === 'darwin') {
+                    try {
+                        execSync('brew install ollama', { encoding: 'utf-8', stdio: 'pipe' });
+                        return true;
+                    }
+                    catch {
+                        return false;
+                    }
+                }
+                return false;
+            },
+        };
+    }
+}
+/**
+ * Get Ollama endpoint URL, checking multiple sources:
+ * 1. OLLAMA_HOST env var (official Ollama config)
+ * 2. OLLAMA_BASE_URL env var (alternative)
+ * 3. Default localhost:11434
+ *
+ * For WSL users, also provides hints about host.docker.internal
+ */
+function getOllamaEndpoint() {
+    // Check env vars first
+    const ollamaHost = process.env['OLLAMA_HOST'];
+    if (ollamaHost) {
+        // OLLAMA_HOST can be just host:port or full URL
+        const url = ollamaHost.startsWith('http') ? ollamaHost : `http://${ollamaHost}`;
+        return { url: url.replace(/\/$/, ''), source: 'OLLAMA_HOST' };
+    }
+    const ollamaBaseUrl = process.env['OLLAMA_BASE_URL'];
+    if (ollamaBaseUrl) {
+        return { url: ollamaBaseUrl.replace(/\/v1\/?$/, '').replace(/\/$/, ''), source: 'OLLAMA_BASE_URL' };
+    }
+    return { url: 'http://localhost:11434', source: 'default' };
+}
+function checkOllamaRunning() {
+    const { url: primaryUrl, source } = getOllamaEndpoint();
+    // List of endpoints to try (for WSL compatibility)
+    const endpoints = [
+        primaryUrl,
+        // WSL-specific fallbacks (only try if primary is localhost)
+        ...(primaryUrl.includes('localhost') || primaryUrl.includes('127.0.0.1')
+            ? ['http://host.docker.internal:11434', 'http://172.17.0.1:11434']
+            : []),
+    ];
+    for (const endpoint of endpoints) {
+        try {
+            execSync(`curl -s --max-time 2 ${endpoint}/api/tags`, { encoding: 'utf-8' });
+            const displayEndpoint = endpoint.replace('http://', '').replace(':11434', ':11434');
+            const sourceNote = source !== 'default' ? ` (from ${source})` : '';
+            return {
+                name: 'Ollama Server',
+                status: 'ok',
+                message: `running on ${displayEndpoint}${sourceNote}`,
+                details: endpoint !== primaryUrl ? [`Fallback: ${endpoint}`] : undefined,
+            };
+        }
+        catch {
+            // Try next endpoint
+        }
+    }
+    // None worked - provide helpful error for WSL users
+    const isWSL = platform() === 'linux' && release().toLowerCase().includes('microsoft');
+    const fix = isWSL
+        ? 'WSL detected. Set OLLAMA_HOST=host.docker.internal:11434 or your Windows IP'
+        : 'Run: ollama serve';
+    return {
+        name: 'Ollama Server',
+        status: 'warning',
+        message: 'not reachable',
+        fix,
+        details: isWSL
+            ? [
+                `Tried: ${endpoints.join(', ')}`,
+                'Windows Ollama needs: export OLLAMA_HOST=host.docker.internal:11434',
+            ]
+            : [`Tried: ${primaryUrl}`],
+        autoFix: async () => {
+            try {
+                // Start ollama in background using spawn
+                const { spawn } = await import('child_process');
+                const child = spawn('ollama', ['serve'], {
+                    detached: true,
+                    stdio: 'ignore',
+                });
+                child.unref();
+                // Give it a moment to start
+                await new Promise(resolve => setTimeout(resolve, 2000));
+                // Check if it started
+                try {
+                    execSync(`curl -s --max-time 2 ${primaryUrl}/api/tags`, { encoding: 'utf-8' });
+                    return true;
+                }
+                catch {
+                    return false;
+                }
+            }
+            catch {
+                return false;
+            }
+        },
+    };
+}
+function checkGitInstalled() {
+    try {
+        const result = execSync('git --version 2>&1', { encoding: 'utf-8', timeout: 5000 });
+        const version = result.match(/git version ([\d.]+)/)?.[1] || 'installed';
+        return { name: 'Git', status: 'ok', message: `v${version}` };
+    }
+    catch {
+        return {
+            name: 'Git',
+            status: 'warning',
+            message: 'not installed',
+            fix: 'Install Git for version control features',
+        };
+    }
+}
+function checkAPIKeys() {
+    const keys = {
+        OLLAMA_API_KEY: !!process.env['OLLAMA_API_KEY'],
+        GROQ_API_KEY: !!process.env['GROQ_API_KEY'],
+        OPENAI_API_KEY: !!process.env['OPENAI_API_KEY'],
+    };
+    const found = Object.entries(keys).filter(([_, v]) => v).map(([k]) => k);
+    if (found.length > 0) {
+        return {
+            name: 'API Keys',
+            status: 'ok',
+            message: found.map(k => k.replace('_API_KEY', '')).join(', '),
+        };
+    }
+    return {
+        name: 'API Keys',
+        status: 'warning',
+        message: 'none configured',
+        fix: 'Set OLLAMA_API_KEY, GROQ_API_KEY, or OPENAI_API_KEY',
+        details: [
+            'export OLLAMA_API_KEY="your-key"',
+            'Or configure in ~/.osagent/settings.json',
+        ],
+    };
+}
+function checkSettings() {
+    const settingsPath = join(homedir(), '.osagent', 'settings.json');
+    if (existsSync(settingsPath)) {
+        try {
+            const content = readFileSync(settingsPath, 'utf-8');
+            const settings = JSON.parse(content);
+            const keys = Object.keys(settings);
+            return {
+                name: 'Settings File',
+                status: 'ok',
+                message: `${keys.length} settings configured`,
+                details: keys.slice(0, 5),
+            };
+        }
+        catch {
+            return {
+                name: 'Settings File',
+                status: 'error',
+                message: 'invalid JSON',
+                fix: 'Fix JSON syntax or delete ~/.osagent/settings.json',
+            };
+        }
+    }
+    return {
+        name: 'Settings File',
+        status: 'ok',
+        message: 'using defaults',
+    };
+}
+function checkSystemPrompt() {
+    const promptPath = join(homedir(), '.osagent', 'system.md');
+    if (existsSync(promptPath)) {
+        try {
+            const content = readFileSync(promptPath, 'utf-8');
+            const lines = content.split('\n').length;
+            return {
+                name: 'System Prompt',
+                status: 'ok',
+                message: `custom (${lines} lines)`,
+            };
+        }
+        catch {
+            return {
+                name: 'System Prompt',
+                status: 'warning',
+                message: 'unreadable',
+            };
+        }
+    }
+    return { name: 'System Prompt', status: 'ok', message: 'default' };
+}
+function checkCustomAgents() {
+    const agentsDir = join(homedir(), '.osagent', 'agents');
+    if (existsSync(agentsDir)) {
+        try {
+            const agents = readdirSync(agentsDir).filter(f => f.endsWith('.json') || f.endsWith('.yaml') || f.endsWith('.yml'));
+            if (agents.length > 0) {
+                return {
+                    name: 'Custom Agents',
+                    status: 'ok',
+                    message: `${agents.length} agents`,
+                    details: agents.slice(0, 5),
+                };
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    return { name: 'Custom Agents', status: 'ok', message: 'none' };
+}
+function checkCustomCommands() {
+    const commandsDir = join(homedir(), '.osagent', 'commands');
+    if (existsSync(commandsDir)) {
+        try {
+            const commands = readdirSync(commandsDir).filter(f => f.endsWith('.js') || f.endsWith('.ts') || f.endsWith('.toml'));
+            if (commands.length > 0) {
+                return {
+                    name: 'Custom Commands',
+                    status: 'ok',
+                    message: `${commands.length} commands`,
+                    details: commands.slice(0, 5),
+                };
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    return { name: 'Custom Commands', status: 'ok', message: 'none' };
+}
+function checkMCPServers() {
+    const mcpPath = join(homedir(), '.osagent', 'mcp.json');
+    if (existsSync(mcpPath)) {
+        try {
+            const content = readFileSync(mcpPath, 'utf-8');
+            const mcp = JSON.parse(content);
+            const servers = Object.keys(mcp.mcpServers || {});
+            if (servers.length > 0) {
+                return {
+                    name: 'MCP Servers',
+                    status: 'ok',
+                    message: `${servers.length} configured`,
+                    details: servers.slice(0, 5),
+                };
+            }
+        }
+        catch {
+            return {
+                name: 'MCP Servers',
+                status: 'warning',
+                message: 'invalid config',
+                fix: 'Fix ~/.osagent/mcp.json syntax',
+            };
+        }
+    }
+    return { name: 'MCP Servers', status: 'ok', message: 'none' };
+}
+function checkDiskSpace() {
+    try {
+        if (platform() === 'darwin' || platform() === 'linux') {
+            const result = execSync('df -h ~ | tail -1', { encoding: 'utf-8' });
+            const parts = result.trim().split(/\s+/);
+            const available = parts[3];
+            const usePercent = parseInt(parts[4], 10);
+            if (usePercent > 90) {
+                return {
+                    name: 'Disk Space',
+                    status: 'warning',
+                    message: `${available} free (${usePercent}% used)`,
+                    fix: 'Free up disk space',
+                };
+            }
+            return {
+                name: 'Disk Space',
+                status: 'ok',
+                message: `${available} free`,
+            };
+        }
+    }
+    catch {
+        // ignore
+    }
+    return { name: 'Disk Space', status: 'ok', message: 'unknown' };
+}
+// ============================================================================
+// FORMATTERS
+// ============================================================================
+function formatReport(checks, systemInfo, currentVersion, latestVersion, autoFix = false) {
+    const lines = [];
+    const width = 60;
+    // Get installation info
+    const installInfo = getInstallationInfo();
+    // Header
+    lines.push('');
+    const headerBox = createBox('osagent doctor', width);
+    lines.push(headerBox.top);
+    lines.push(headerBox.line(centerPad(`${icons.doctor} System Health Report`, width - 4)));
+    lines.push(headerBox.bottom);
+    lines.push('');
+    // Installation Diagnostics
+    lines.push(plainSectionHeader('Diagnostics', icons.terminal));
+    lines.push(plainDivider(width));
+    lines.push(`└ Currently running: ${installInfo.method} (${installInfo.version})`);
+    lines.push(`└ Path: ${installInfo.path}`);
+    lines.push(`└ Auto-updates: ${installInfo.autoUpdates ? 'enabled' : 'disabled'}`);
+    lines.push(`└ Search: ${installInfo.searchStatus}`);
+    // Multiple installations warning
+    if (installInfo.multipleInstalls && installInfo.multipleInstalls.length > 0) {
+        lines.push('');
+        lines.push(`${icons.warning} Warning: Multiple installations found`);
+        for (const install of installInfo.multipleInstalls) {
+            lines.push(`└ ${install.method} at ${install.path}`);
+        }
+    }
+    lines.push('');
+    // Version info
+    const updateAvailable = currentVersion !== 'unknown' &&
+        latestVersion !== 'unknown' &&
+        currentVersion !== latestVersion;
+    lines.push(plainSectionHeader('Version', icons.package));
+    lines.push(plainDivider(width));
+    lines.push(plainKeyValue('Installed', currentVersion));
+    if (updateAvailable) {
+        lines.push(plainKeyValue('Available', `${latestVersion} (update available)`));
+    }
+    else {
+        lines.push(plainKeyValue('Status', 'up to date'));
+    }
+    lines.push('');
+    // System info
+    lines.push(plainSectionHeader('System', icons.terminal));
+    lines.push(plainDivider(width));
+    lines.push(plainKeyValue('OS', systemInfo.os));
+    lines.push(plainKeyValue('Architecture', systemInfo.arch));
+    lines.push(plainKeyValue('Node.js', systemInfo.nodeVersion));
+    lines.push(plainKeyValue('npm', systemInfo.npmVersion));
+    lines.push(plainKeyValue('Memory', systemInfo.memory));
+    lines.push('');
+    // Health checks
+    lines.push(plainSectionHeader('Health Checks', icons.shield));
+    lines.push(plainDivider(width));
+    let errorCount = 0;
+    let warningCount = 0;
+    const fixes = [];
+    for (const check of checks) {
+        const icon = plainStatusIcon(check.status);
+        lines.push(`${icon} ${check.name.padEnd(20)} ${check.message}`);
+        if (check.details && check.details.length > 0) {
+            for (const detail of check.details) {
+                lines.push(`   ${box.pipe} ${detail}`);
+            }
+        }
+        if (check.status === 'error')
+            errorCount++;
+        if (check.status === 'warning')
+            warningCount++;
+        if (check.fix) {
+            fixes.push(`${check.name}: ${check.fix}`);
+        }
+    }
+    lines.push('');
+    // Summary
+    lines.push(plainSectionHeader('Summary', icons.sparkle));
+    lines.push(plainDivider(width));
+    const total = checks.length;
+    const passed = total - errorCount - warningCount;
+    if (errorCount === 0 && warningCount === 0) {
+        lines.push('');
+        lines.push(`  ✔ All systems go`);
+        lines.push('');
+    }
+    else if (errorCount === 0) {
+        lines.push(`${passed} passed, ${warningCount} warnings`);
+        lines.push('  ⚠ System functional with warnings');
+    }
+    else {
+        lines.push(`${passed} passed, ${warningCount} warnings, ${errorCount} errors`);
+        lines.push('  ✖ Issues detected - see recommended actions below');
+    }
+    lines.push('');
+    // Recommended fixes
+    if (fixes.length > 0) {
+        lines.push(plainSectionHeader('Recommended Actions', icons.wrench));
+        lines.push(plainDivider(width));
+        fixes.forEach((fix, i) => {
+            lines.push(`  ${i + 1}. ${fix}`);
+        });
+        lines.push('');
+        if (!autoFix) {
+            lines.push('Run /doctor fix to auto-fix issues');
+        }
+    }
+    // Quick actions
+    if (updateAvailable) {
+        lines.push('');
+        lines.push(`${icons.update} Update available! Run: /doctor update`);
+    }
+    lines.push('');
+    lines.push(plainSectionHeader('Quick Commands', icons.lightning));
+    lines.push(plainDivider(width));
+    lines.push(`  /doctor update  - Update to latest version`);
+    lines.push(`  /doctor fix     - Auto-fix issues`);
+    lines.push(`  /doctor init    - Initialize config directory`);
+    lines.push('');
+    return lines;
+}
+function centerPad(text, width) {
+    const stripped = text.replace(/\x1b\[[0-9;]*m/g, '');
+    const padding = Math.max(0, width - stripped.length);
+    const leftPad = Math.floor(padding / 2);
+    return ' '.repeat(leftPad) + text;
+}
+// ============================================================================
+// COMMAND DEFINITION
+// ============================================================================
+export const doctorCommand = {
+    name: 'doctor',
+    get description() {
+        return t('Check system health, run diagnostics, and auto-fix issues');
+    },
+    kind: CommandKind.BUILT_IN,
+    subCommands: [
+        {
+            name: 'update',
+            get description() {
+                return t('Update osagent to the latest version');
+            },
+            kind: CommandKind.BUILT_IN,
+            action: async () => {
+                const lines = [];
+                lines.push('');
+                lines.push(plainSectionHeader('Updating osagent...', icons.update));
+                lines.push(plainDivider(50));
+                try {
+                    lines.push(`${icons.pending} Checking current version...`);
+                    const oldVersion = getCurrentVersion();
+                    const latestVersion = getLatestVersion();
+                    // Check if already up to date
+                    if (compareVersions(oldVersion, latestVersion) >= 0) {
+                        lines.push('');
+                        lines.push(`${icons.success} Already up to date!`);
+                        lines.push('');
+                        lines.push(plainKeyValue('Current version', oldVersion));
+                        lines.push(plainKeyValue('Latest version', latestVersion));
+                        lines.push('');
+                        return {
+                            type: 'message',
+                            messageType: 'info',
+                            content: lines.join('\n'),
+                        };
+                    }
+                    // Show release info
+                    const releaseInfo = fetchReleaseNotes(oldVersion, latestVersion);
+                    if (releaseInfo) {
+                        lines.push('');
+                        lines.push(plainSectionHeader('Release Info', icons.package));
+                        lines.push(plainDivider(50));
+                        for (const change of releaseInfo.changes) {
+                            lines.push(`  ${icons.arrow} ${change}`);
+                        }
+                        lines.push('');
+                    }
+                    lines.push(`${icons.pending} Installing latest version...`);
+                    execSync('npm install -g osagent@latest 2>&1', { encoding: 'utf-8', stdio: 'pipe' });
+                    const newVersion = getLatestVersion();
+                    lines.push('');
+                    lines.push(`${icons.success} Updated successfully!`);
+                    lines.push('');
+                    lines.push(plainKeyValue('Previous', oldVersion));
+                    lines.push(plainKeyValue('Current', newVersion));
+                    lines.push('');
+                    lines.push('Restart osagent to use the new version.');
+                    return {
+                        type: 'message',
+                        messageType: 'info',
+                        content: lines.join('\n'),
+                    };
+                }
+                catch (error) {
+                    lines.push('');
+                    lines.push(`${icons.error} Update failed`);
+                    lines.push('');
+                    lines.push('Try manually:');
+                    lines.push('  sudo npm install -g osagent@latest');
+                    return {
+                        type: 'message',
+                        messageType: 'error',
+                        content: lines.join('\n'),
+                    };
+                }
+            },
+        },
+        {
+            name: 'fix',
+            get description() {
+                return t('Automatically fix issues where possible');
+            },
+            kind: CommandKind.BUILT_IN,
+            action: async () => {
+                const lines = [];
+                lines.push('');
+                lines.push(plainSectionHeader('Auto-fixing issues...', icons.wrench));
+                lines.push(plainDivider(50));
+                const checks = [
+                    checkNodeVersion(),
+                    checkOllamaInstalled(),
+                    checkOllamaRunning(),
+                    checkGitInstalled(),
+                    checkSettings(),
+                    checkAPIKeys(),
+                ];
+                let fixed = 0;
+                let failed = 0;
+                for (const check of checks) {
+                    if (check.status !== 'ok' && check.autoFix) {
+                        lines.push(`> Fixing: ${check.name}...`);
+                        try {
+                            const success = await check.autoFix();
+                            if (success) {
+                                lines.push(`  ${plainStatusIcon('ok')} ${check.name} fixed`);
+                                fixed++;
+                            }
+                            else {
+                                lines.push(`  ${plainStatusIcon('warning')} ${check.name} - manual fix needed`);
+                                if (check.fix) {
+                                    lines.push(`    ${icons.arrow} ${check.fix}`);
+                                }
+                                failed++;
+                            }
+                        }
+                        catch {
+                            lines.push(`  ${plainStatusIcon('error')} ${check.name} - fix failed`);
+                            failed++;
+                        }
+                    }
+                    else if (check.status !== 'ok' && check.fix) {
+                        lines.push(`${plainStatusIcon('warning')} ${check.name} - manual fix needed`);
+                        lines.push(`  ${icons.arrow} ${check.fix}`);
+                    }
+                }
+                // Initialize directory structure if missing
+                const baseDir = join(homedir(), '.osagent');
+                const dirs = ['agents', 'commands', 'prompts', 'memory'];
+                for (const dir of dirs) {
+                    const path = join(baseDir, dir);
+                    if (!existsSync(path)) {
+                        mkdirSync(path, { recursive: true });
+                        lines.push(`${plainStatusIcon('ok')} Created ${dir}/ directory`);
+                        fixed++;
+                    }
+                }
+                lines.push('');
+                lines.push(plainDivider(50));
+                if (fixed > 0) {
+                    lines.push(`${icons.success} ${fixed} issues fixed`);
+                }
+                if (failed > 0) {
+                    lines.push(`${icons.warning} ${failed} issues need manual attention`);
+                }
+                if (fixed === 0 && failed === 0) {
+                    lines.push(`${icons.success} No issues to fix!`);
+                }
+                return {
+                    type: 'message',
+                    messageType: 'info',
+                    content: lines.join('\n'),
+                };
+            },
+        },
+        {
+            name: 'init',
+            get description() {
+                return t('Initialize ~/.osagent directory with recommended structure');
+            },
+            kind: CommandKind.BUILT_IN,
+            action: async () => {
+                const lines = [];
+                lines.push('');
+                lines.push(plainSectionHeader('Initializing osagent...', icons.gear));
+                lines.push(plainDivider(50));
+                const baseDir = join(homedir(), '.osagent');
+                const dirs = ['agents', 'commands', 'prompts', 'memory', 'skills'];
+                try {
+                    for (const dir of dirs) {
+                        const path = join(baseDir, dir);
+                        mkdirSync(path, { recursive: true });
+                        lines.push(`${plainStatusIcon('ok')} Created ${dir}/`);
+                    }
+                    // Create example agent
+                    const exampleAgent = {
+                        name: 'example-agent',
+                        description: 'An example custom agent',
+                        systemPrompt: 'You are a helpful assistant specialized in...',
+                        model: 'qwen3-coder:480b-cloud',
+                        tier: 'specialist',
+                    };
+                    const agentPath = join(baseDir, 'agents', 'example-agent.json');
+                    if (!existsSync(agentPath)) {
+                        writeFileSync(agentPath, JSON.stringify(exampleAgent, null, 2));
+                        lines.push(`${plainStatusIcon('ok')} Created example-agent.json`);
+                    }
+                    // Create example skill
+                    const exampleSkill = {
+                        name: 'example-skill',
+                        description: 'An example custom skill',
+                        triggers: [{ type: 'keyword', patterns: ['example', 'demo'] }],
+                        steps: [
+                            { name: 'step1', prompt: 'First step...' },
+                            { name: 'step2', prompt: 'Second step...', dependsOn: ['step1'] },
+                        ],
+                    };
+                    const skillPath = join(baseDir, 'skills', 'example-skill.json');
+                    if (!existsSync(skillPath)) {
+                        writeFileSync(skillPath, JSON.stringify(exampleSkill, null, 2));
+                        lines.push(`${plainStatusIcon('ok')} Created example-skill.json`);
+                    }
+                    lines.push('');
+                    lines.push(plainDivider(50));
+                    lines.push(`${icons.success} Initialization complete!`);
+                    lines.push('');
+                    lines.push(plainSectionHeader('Directory Structure', icons.folder));
+                    lines.push(createTree([
+                        { label: '~/.osagent/', children: [
+                                { label: 'agents/ - Custom AI agents' },
+                                { label: 'commands/ - Custom slash commands' },
+                                { label: 'prompts/ - Custom prompts' },
+                                { label: 'skills/ - Custom skills/workflows' },
+                                { label: 'memory/ - Memory storage' },
+                            ] },
+                    ]).join('\n'));
+                    return {
+                        type: 'message',
+                        messageType: 'info',
+                        content: lines.join('\n'),
+                    };
+                }
+                catch (error) {
+                    return {
+                        type: 'message',
+                        messageType: 'error',
+                        content: `${icons.error} Failed to initialize: ${error}`,
+                    };
+                }
+            },
+        },
+    ],
+    action: async (context) => {
+        const currentVersion = getCurrentVersion();
+        const latestVersion = getLatestVersion();
+        const updateAvailable = compareVersions(currentVersion, latestVersion) < 0;
+        // If update is available and user hasn't confirmed yet, show update prompt
+        if (updateAvailable && !context.overwriteConfirmed) {
+            const releaseInfo = fetchReleaseNotes(currentVersion, latestVersion);
+            // Build the confirmation prompt
+            const promptLines = [
+                '',
+                plainSectionHeader('Update Available', icons.update),
+                plainDivider(50),
+                '',
+                `  Current version: ${currentVersion}`,
+                `  Latest version:  ${latestVersion}`,
+                '',
+            ];
+            if (releaseInfo) {
+                promptLines.push(plainSectionHeader('Release Info', icons.package));
+                promptLines.push(plainDivider(50));
+                for (const change of releaseInfo.changes) {
+                    promptLines.push(`  ${icons.arrow} ${change}`);
+                }
+                promptLines.push('');
+            }
+            promptLines.push(plainDivider(50));
+            promptLines.push('');
+            promptLines.push('  Update now? This will run: npm install -g osagent@latest');
+            promptLines.push('');
+            return {
+                type: 'confirm_action',
+                prompt: React.createElement(Text, null, promptLines.join('\n')),
+                originalInvocation: {
+                    raw: context.invocation?.raw || '/doctor',
+                },
+            };
+        }
+        // If user confirmed the update, perform it
+        if (updateAvailable && context.overwriteConfirmed) {
+            const lines = [];
+            lines.push('');
+            lines.push(plainSectionHeader('Updating osagent...', icons.update));
+            lines.push(plainDivider(50));
+            try {
+                lines.push(`${icons.pending} Checking current version...`);
+                const oldVersion = currentVersion;
+                lines.push(`${icons.pending} Installing latest version...`);
+                execSync('npm install -g osagent@latest 2>&1', { encoding: 'utf-8', stdio: 'pipe' });
+                const newVersion = getLatestVersion();
+                lines.push('');
+                lines.push(`${icons.success} Updated successfully!`);
+                lines.push('');
+                lines.push(plainKeyValue('Previous', oldVersion));
+                lines.push(plainKeyValue('Current', newVersion));
+                lines.push('');
+                lines.push('Restart osagent to use the new version.');
+                lines.push('');
+                // Now show the doctor report
+                lines.push(plainDivider(50));
+                lines.push('');
+                const checks = [
+                    checkNodeVersion(),
+                    checkOllamaInstalled(),
+                    checkOllamaRunning(),
+                    checkGitInstalled(),
+                    checkDiskSpace(),
+                    checkAPIKeys(),
+                    checkSettings(),
+                    checkSystemPrompt(),
+                    checkCustomAgents(),
+                    checkCustomCommands(),
+                    checkMCPServers(),
+                ];
+                const systemInfo = getSystemInfo();
+                const report = formatReport(checks, systemInfo, newVersion, newVersion);
+                lines.push(...report);
+                return {
+                    type: 'message',
+                    messageType: 'info',
+                    content: lines.join('\n'),
+                };
+            }
+            catch (error) {
+                lines.push('');
+                lines.push(`${icons.error} Update failed`);
+                lines.push('');
+                lines.push('Try manually:');
+                lines.push('  sudo npm install -g osagent@latest');
+                lines.push('');
+                // Still show the doctor report even if update failed
+                const checks = [
+                    checkNodeVersion(),
+                    checkOllamaInstalled(),
+                    checkOllamaRunning(),
+                    checkGitInstalled(),
+                    checkDiskSpace(),
+                    checkAPIKeys(),
+                    checkSettings(),
+                    checkSystemPrompt(),
+                    checkCustomAgents(),
+                    checkCustomCommands(),
+                    checkMCPServers(),
+                ];
+                const systemInfo = getSystemInfo();
+                const report = formatReport(checks, systemInfo, currentVersion, latestVersion);
+                lines.push(...report);
+                return {
+                    type: 'message',
+                    messageType: 'error',
+                    content: lines.join('\n'),
+                };
+            }
+        }
+        // No update available or declined - show normal doctor report
+        const checks = [
+            checkNodeVersion(),
+            checkOllamaInstalled(),
+            checkOllamaRunning(),
+            checkGitInstalled(),
+            checkDiskSpace(),
+            checkAPIKeys(),
+            checkSettings(),
+            checkSystemPrompt(),
+            checkCustomAgents(),
+            checkCustomCommands(),
+            checkMCPServers(),
+        ];
+        const systemInfo = getSystemInfo();
+        const report = formatReport(checks, systemInfo, currentVersion, latestVersion);
+        return {
+            type: 'message',
+            messageType: 'info',
+            content: report.join('\n'),
+        };
+    },
+};
+//# sourceMappingURL=doctorCommand.js.map