clawsql 0.2.1 → 0.2.3

package/dist/cli/commands/doctor.js

@@ -3,7 +3,6 @@
  * ClawSQL CLI - Doctor Command
  *
  * Diagnoses system health and suggests fixes for common issues.
- * Similar to `brew doctor` or `npm doctor`.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.doctorCommand = void 0;
@@ -11,189 +10,128 @@ const components_js_1 = require("../ui/components.js");
 const child_process_1 = require("child_process");
 const openclaw_integration_js_1 = require("../agent/openclaw-integration.js");
 const docker_prereq_js_1 = require("../utils/docker-prereq.js");
-/**
- * Doctor command
- */
+const ai_config_js_1 = require("../utils/ai-config.js");
+// ============================================================================
+// Command Definition
+// ============================================================================
 exports.doctorCommand = {
     name: 'doctor',
     description: 'Diagnose system issues and suggest fixes',
     usage: '/doctor [--fix]',
-    handler: async (args, ctx) => {
-        const formatter = ctx.formatter;
-        const shouldFix = args.includes('--fix');
-        console.log(formatter.header('ClawSQL Doctor'));
+    handler: async (_args, ctx) => {
+        console.log(ctx.formatter.header('ClawSQL Doctor'));
         console.log(components_js_1.theme.muted('Running diagnostics...\n'));
         const results = [];
-        // Run all diagnostic checks
         await runDiagnostics(ctx, results);
-        // Display results
         displayResults(results);
-        // Summary
-        const errors = results.filter(r => r.severity === 'error');
-        const warnings = results.filter(r => r.severity === 'warning');
-        console.log();
-        if (errors.length === 0 && warnings.length === 0) {
-            console.log(components_js_1.theme.success(`${components_js_1.indicators.check} All systems healthy!`));
-        }
-        else {
-            console.log(components_js_1.theme.warning(`Found ${errors.length} error(s) and ${warnings.length} warning(s)`));
-            if (!shouldFix && (errors.length > 0 || warnings.length > 0)) {
-                console.log(components_js_1.theme.muted('\nSome issues may have automatic fixes available.'));
-            }
-        }
+        printSummary(results);
     },
 };
-/**
- * Run all diagnostic checks
- */
+// ============================================================================
+// Diagnostic Runner
+// ============================================================================
 async function runDiagnostics(ctx, results) {
-    // Platform checks
     const runtime = await checkContainerRuntime(results);
-    await checkDockerImages(runtime, results);
-    await checkClawSQLAPI(ctx, results);
-    await checkOrchestrator(ctx, results);
-    await checkProxySQL(ctx, results);
-    await checkPrometheus(ctx, results);
-    await checkOpenClaw(ctx, results);
-    // Configuration checks
+    await Promise.all([
+        checkDockerImages(runtime, results),
+        checkClawSQLAPI(ctx, results),
+        checkOrchestrator(ctx, results),
+        checkProxySQL(ctx, results),
+        checkPrometheus(ctx, results),
+        checkOpenClaw(ctx, results),
+    ]);
     checkConfiguration(ctx, results);
-    // MySQL checks
-    await checkMySQLInstances(ctx, results);
-    await checkReplicationTopology(ctx, results);
-    // Sync check
-    await checkProxySQLSync(ctx, results);
 }
-/**
- * Check container runtime availability
- */
+// ============================================================================
+// Individual Checks
+// ============================================================================
 async function checkContainerRuntime(results) {
-    const runtimes = ['docker', 'podman'];
-    let foundRuntime = '';
-    for (const runtime of runtimes) {
-        try {
-            const result = await execCommand([runtime, 'info'], true);
-            if (result.success) {
-                foundRuntime = runtime;
-                break;
-            }
-        }
-        catch {
-            // Continue to next runtime
-        }
-    }
-    if (foundRuntime) {
-        results.push({
-            name: 'Container Runtime',
-            severity: 'ok',
-            message: `${foundRuntime} is installed and running`,
-        });
-        // Check if containers are running
-        try {
-            const psResult = await execCommand([foundRuntime, 'ps', '--filter', 'name=clawsql', '--filter', 'name=orchestrator',
-                '--filter', 'name=proxysql', '-q'], true);
-            const containerCount = psResult.stdout.trim().split('\n').filter(Boolean).length;
-            if (containerCount === 0) {
-                results.push({
-                    name: 'Platform Containers',
-                    severity: 'warning',
-                    message: 'No ClawSQL containers are running',
-                    fix: 'Start the platform with: /start',
-                    fixCommand: '/start',
-                });
-            }
-            else {
-                results.push({
-                    name: 'Platform Containers',
-                    severity: 'ok',
-                    message: `${containerCount} container(s) running`,
-                });
-            }
-        }
-        catch {
-            results.push({
-                name: 'Platform Containers',
-                severity: 'warning',
-                message: 'Could not check container status',
-            });
-        }
-    }
-    else {
+    const runtime = await (0, docker_prereq_js_1.detectRuntime)();
+    if (!runtime) {
         results.push({
             name: 'Container Runtime',
             severity: 'error',
             message: 'No container runtime found (docker or podman required)',
             fix: 'Install Docker from https://docs.docker.com/get-docker/',
         });
+        return null;
     }
-    return foundRuntime || null;
-}
-/**
- * Check if Docker images are installed
- */
-async function checkDockerImages(runtime, results) {
-    if (!runtime) {
-        return; // Already reported in container runtime check
+    results.push({
+        name: 'Container Runtime',
+        severity: 'ok',
+        message: `${runtime} is installed and running`,
+    });
+    const psResult = await execCommand([runtime, 'ps', '--filter', 'name=clawsql', '--filter', 'name=orchestrator', '--filter', 'name=proxysql', '-q'], true);
+    const containerCount = psResult.stdout.trim().split('\n').filter(Boolean).length;
+    if (containerCount === 0) {
+        results.push({
+            name: 'Platform Containers',
+            severity: 'warning',
+            message: 'No ClawSQL containers are running',
+            fix: 'Start the platform with: /start',
+            fixCommand: '/start',
+        });
     }
-    const imageStatus = await (0, docker_prereq_js_1.checkImagesInstalled)(runtime);
-    if (imageStatus.installed.length === imageStatus.total) {
+    else {
         results.push({
-            name: 'Docker Images',
+            name: 'Platform Containers',
             severity: 'ok',
-            message: `All ${imageStatus.total} images installed`,
+            message: `${containerCount} container(s) running`,
         });
     }
-    else if (imageStatus.installed.length === 0) {
+    return runtime;
+}
+async function checkDockerImages(runtime, results) {
+    if (!runtime)
+        return;
+    const status = await (0, docker_prereq_js_1.checkImagesInstalled)(runtime);
+    if (status.installed.length === status.total) {
+        results.push({ name: 'Docker Images', severity: 'ok', message: `All ${status.total} images installed` });
+    }
+    else if (status.installed.length === 0) {
         results.push({
             name: 'Docker Images',
             severity: 'error',
             message: 'No Docker images installed',
-            detail: 'Required images have not been pulled',
             fix: 'Pull images with: /install',
             fixCommand: '/install',
         });
     }
     else {
+        const missing = status.missing.slice(0, 3).map(i => i.split('/').pop()).join(', ');
         results.push({
             name: 'Docker Images',
             severity: 'warning',
-            message: `${imageStatus.installed.length}/${imageStatus.total} images installed`,
-            detail: `Missing: ${imageStatus.missing.slice(0, 3).map(i => i.split('/').pop()).join(', ')}${imageStatus.missing.length > 3 ? '...' : ''}`,
+            message: `${status.installed.length}/${status.total} images installed`,
+            detail: `Missing: ${missing}${status.missing.length > 3 ? '...' : ''}`,
             fix: 'Pull missing images with: /install',
             fixCommand: '/install',
         });
     }
 }
-/**
- * Check ClawSQL API health
- */
 async function checkClawSQLAPI(ctx, results) {
     try {
         const response = await fetch(`http://localhost:${ctx.settings.api.port}/health`, {
             signal: AbortSignal.timeout(5000),
         });
-        if (response.ok) {
-            const data = await response.json();
-            if (data.status === 'healthy') {
-                results.push({
-                    name: 'ClawSQL API',
-                    severity: 'ok',
-                    message: `Running on port ${ctx.settings.api.port}`,
-                });
-            }
-            else {
-                results.push({
-                    name: 'ClawSQL API',
-                    severity: 'error',
-                    message: `API returned status: ${data.status}`,
-                    fix: 'Check logs: docker logs clawsql',
-                });
-            }
+        if (!response.ok) {
+            results.push({
+                name: 'ClawSQL API',
+                severity: 'error',
+                message: `API returned HTTP ${response.status}`,
+                fix: 'Check logs: docker logs clawsql',
+            });
+            return;
+        }
+        const data = await response.json();
+        if (data.status === 'healthy') {
+            results.push({ name: 'ClawSQL API', severity: 'ok', message: `Running on port ${ctx.settings.api.port}` });
         }
         else {
             results.push({
                 name: 'ClawSQL API',
                 severity: 'error',
-                message: `API returned HTTP ${response.status}`,
+                message: `API returned status: ${data.status}`,
                 fix: 'Check logs: docker logs clawsql',
             });
         }
@@ -209,54 +147,20 @@ async function checkClawSQLAPI(ctx, results) {
         });
     }
 }
-/**
- * Check Orchestrator health
- */
 async function checkOrchestrator(ctx, results) {
+    // Health check
     try {
         const isHealthy = await ctx.orchestrator.healthCheck();
-        if (isHealthy) {
-            results.push({
-                name: 'Orchestrator',
-                severity: 'ok',
-                message: `Running at ${ctx.settings.orchestrator.url}`,
-            });
-            // Check if instances are discovered
-            try {
-                const clusters = await ctx.orchestrator.getClusters();
-                if (clusters.length === 0) {
-                    results.push({
-                        name: 'MySQL Topology',
-                        severity: 'warning',
-                        message: 'No MySQL instances discovered in Orchestrator',
-                        fix: 'Register instances with: /instances register <host>',
-                        fixCommand: '/instances register <mysql-host>',
-                    });
-                }
-                else {
-                    results.push({
-                        name: 'MySQL Topology',
-                        severity: 'ok',
-                        message: `${clusters.length} cluster(s) discovered`,
-                    });
-                }
-            }
-            catch {
-                results.push({
-                    name: 'MySQL Topology',
-                    severity: 'warning',
-                    message: 'Could not retrieve topology information',
-                });
-            }
-        }
-        else {
+        if (!isHealthy) {
             results.push({
                 name: 'Orchestrator',
                 severity: 'error',
                 message: 'Health check failed',
                 fix: 'Check Orchestrator container: docker logs orchestrator',
             });
+            return;
         }
+        results.push({ name: 'Orchestrator', severity: 'ok', message: `Running at ${ctx.settings.orchestrator.url}` });
     }
     catch {
         results.push({
@@ -264,92 +168,63 @@ async function checkOrchestrator(ctx, results) {
             severity: 'error',
             message: 'Cannot connect to Orchestrator',
             detail: `Expected at ${ctx.settings.orchestrator.url}`,
-            fix: 'Ensure Orchestrator container is running: docker ps | grep orchestrator',
+            fix: 'Ensure container is running: docker ps | grep orchestrator',
         });
     }
 }
-/**
- * Check ProxySQL health
- */
 async function checkProxySQL(ctx, results) {
     try {
         await ctx.proxysql.connect();
-        results.push({
-            name: 'ProxySQL',
-            severity: 'ok',
-            message: `Admin interface running on port ${ctx.settings.proxysql.adminPort}`,
-        });
-        // Check if MySQL servers are configured
-        try {
-            const servers = await ctx.proxysql.getServers();
-            if (servers.length === 0) {
+        results.push({ name: 'ProxySQL', severity: 'ok', message: `Admin interface on port ${ctx.settings.proxysql.adminPort}` });
+        const servers = await ctx.proxysql.getServers();
+        if (servers.length === 0) {
+            results.push({
+                name: 'ProxySQL Servers',
+                severity: 'warning',
+                message: 'No MySQL servers configured',
+                fix: 'Register instances, then sync with: /clusters sync',
+            });
+        }
+        else {
+            const online = servers.filter(s => s.status === 'ONLINE').length;
+            if (online === servers.length) {
+                results.push({ name: 'ProxySQL Servers', severity: 'ok', message: `${online}/${servers.length} servers online` });
+            }
+            else {
                 results.push({
                     name: 'ProxySQL Servers',
                     severity: 'warning',
-                    message: 'No MySQL servers configured in ProxySQL',
-                    fix: 'Register MySQL instances, then sync with: /clusters sync',
+                    message: `${online}/${servers.length} servers online`,
+                    fix: 'Check MySQL server connectivity and credentials',
                 });
             }
-            else {
-                const onlineServers = servers.filter(s => s.status === 'ONLINE');
-                if (onlineServers.length === servers.length) {
-                    results.push({
-                        name: 'ProxySQL Servers',
-                        severity: 'ok',
-                        message: `${onlineServers.length}/${servers.length} servers online`,
-                    });
-                }
-                else {
-                    results.push({
-                        name: 'ProxySQL Servers',
-                        severity: 'warning',
-                        message: `${onlineServers.length}/${servers.length} servers online`,
-                        fix: 'Check MySQL server connectivity and credentials',
-                    });
-                }
-            }
-        }
-        catch {
-            results.push({
-                name: 'ProxySQL Servers',
-                severity: 'warning',
-                message: 'Could not retrieve server configuration',
-            });
         }
         await ctx.proxysql.close();
     }
     catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
         results.push({
             name: 'ProxySQL',
             severity: 'error',
             message: 'Cannot connect to ProxySQL admin interface',
-            detail: message,
-            fix: 'Ensure ProxySQL container is running: docker ps | grep proxysql',
+            detail: error instanceof Error ? error.message : String(error),
+            fix: 'Ensure container is running: docker ps | grep proxysql',
         });
     }
 }
-/**
- * Check Prometheus health
- */
 async function checkPrometheus(ctx, results) {
     try {
         const response = await fetch(`${ctx.settings.prometheus.url}/-/healthy`, {
             signal: AbortSignal.timeout(5000),
         });
         if (response.ok) {
-            results.push({
-                name: 'Prometheus',
-                severity: 'ok',
-                message: `Running at ${ctx.settings.prometheus.url}`,
-            });
+            results.push({ name: 'Prometheus', severity: 'ok', message: `Running at ${ctx.settings.prometheus.url}` });
         }
         else {
             results.push({
                 name: 'Prometheus',
                 severity: 'warning',
                 message: `Health check returned status ${response.status}`,
-                fix: 'Check Prometheus container: docker logs prometheus',
+                fix: 'Check container: docker logs prometheus',
             });
         }
     }
@@ -363,109 +238,130 @@ async function checkPrometheus(ctx, results) {
         });
     }
 }
-/**
- * Check OpenClaw AI Gateway health
- */
 async function checkOpenClaw(_ctx, results) {
     try {
-        const status = await (0, openclaw_integration_js_1.getOpenClawStatus)();
-        if (status.available) {
-            // Check gateway health
-            const gatewayHealthy = await (0, openclaw_integration_js_1.isGatewayHealthy)();
-            if (gatewayHealthy) {
-                if (status.isDocker) {
-                    results.push({
-                        name: 'OpenClaw Gateway',
-                        severity: 'ok',
-                        message: 'Running in Docker container (ws://localhost:18789)',
-                    });
-                }
-                else if (status.isLocal) {
+        const status = await (0, openclaw_integration_js_1.getDetailedOpenClawStatus)();
+        if (!status.available) {
+            // Check if container exists but stopped
+            const runtime = await (0, docker_prereq_js_1.detectRuntime)();
+            if (runtime) {
+                const psResult = await execCommand([runtime, 'ps', '-a', '--filter', 'name=openclaw', '--format', '{{.Status}}'], true);
+                const containerStatus = psResult.stdout.trim();
+                if (containerStatus && !containerStatus.toLowerCase().includes('up')) {
                     results.push({
                         name: 'OpenClaw Gateway',
-                        severity: 'ok',
-                        message: 'Using local installation (ws://localhost:18789)',
+                        severity: 'warning',
+                        message: 'OpenClaw container exists but is not running',
+                        detail: `Status: ${containerStatus}`,
+                        fix: 'Restart the platform with: /start',
+                        fixCommand: '/start',
                     });
+                    return;
                 }
             }
+            results.push({
+                name: 'OpenClaw Gateway',
+                severity: 'warning',
+                message: 'OpenClaw gateway is not available',
+                detail: 'AI features will not work without OpenClaw',
+                fix: 'Start with: /start',
+                fixCommand: '/start',
+            });
+            return;
+        }
+        if (!status.gatewayHealthy) {
+            results.push({
+                name: 'OpenClaw Gateway',
+                severity: 'warning',
+                message: 'Gateway is not responding',
+                fix: 'Check logs: docker logs openclaw',
+            });
+            return;
+        }
+        const modeDisplay = status.mode === 'docker' ? 'Running in Docker' : 'Using local installation';
+        results.push({ name: 'OpenClaw Gateway', severity: 'ok', message: `${modeDisplay} (ws://localhost:18789)` });
+        // Check for auto-detected AI config from environment
+        const aiConfig = (0, ai_config_js_1.detectAIConfigFromEnv)();
+        // Model info
+        if (status.modelInfo.configured && status.modelInfo.model) {
+            results.push({
+                name: 'OpenClaw Model',
+                severity: 'ok',
+                message: `${status.modelInfo.provider || 'custom'}: ${status.modelInfo.model}`,
+            });
+        }
+        else if (aiConfig.provider !== 'none') {
+            results.push({
+                name: 'OpenClaw Model',
+                severity: 'ok',
+                message: `${aiConfig.provider}${aiConfig.model ? '/' + aiConfig.model : ''} (auto-detected)`,
+            });
+        }
+        else {
+            results.push({
+                name: 'OpenClaw Model',
+                severity: 'info',
+                message: 'Using bundled qwen model (limited)',
+                fix: 'Set ANTHROPIC_API_KEY or OPENAI_API_KEY for better AI',
+            });
+        }
+        // Quick AI test - optional, can be slow
+        // Use a simple gateway health check instead of full AI query
+        const httpUrl = openclaw_integration_js_1.CONFIG.gatewayUrl.replace('ws://', 'http://').replace('wss://', 'https://');
+        try {
+            const start = Date.now();
+            const response = await fetch(`${httpUrl}/health`, {
+                signal: AbortSignal.timeout(5000),
+            });
+            const latency = Date.now() - start;
+            if (response.ok) {
+                results.push({ name: 'OpenClaw AI Test', severity: 'ok', message: `Gateway healthy (${latency}ms)` });
+            }
             else {
                 results.push({
-                    name: 'OpenClaw Gateway',
+                    name: 'OpenClaw AI Test',
                     severity: 'warning',
-                    message: 'Gateway is not responding',
-                    detail: 'Container is running but gateway health check failed',
+                    message: `Gateway returned ${response.status}`,
                     fix: 'Check logs: docker logs openclaw',
                 });
             }
         }
-        else {
-            // Check if Docker OpenClaw container exists but is not running
-            const runtime = await (0, docker_prereq_js_1.detectRuntime)();
-            if (runtime) {
-                try {
-                    const psResult = await execCommand([runtime, 'ps', '-a', '--filter', 'name=openclaw', '--format', '{{.Status}}'], true);
-                    const containerStatus = psResult.stdout.trim();
-                    if (containerStatus && !containerStatus.toLowerCase().includes('up')) {
-                        results.push({
-                            name: 'OpenClaw Gateway',
-                            severity: 'warning',
-                            message: 'OpenClaw container exists but is not running',
-                            detail: `Container status: ${containerStatus}`,
-                            fix: 'Restart the platform with: /start',
-                            fixCommand: '/start',
-                        });
-                        return;
-                    }
-                }
-                catch {
-                    // Continue to default message
-                }
-            }
+        catch {
             results.push({
-                name: 'OpenClaw Gateway',
+                name: 'OpenClaw AI Test',
                 severity: 'warning',
-                message: 'OpenClaw gateway is not available',
-                detail: 'AI-powered features will not work without OpenClaw',
-                fix: 'Start the platform with: /start to launch OpenClaw in Docker',
-                fixCommand: '/start',
+                message: 'Gateway health check failed',
+                fix: 'Check logs: docker logs openclaw',
             });
         }
     }
     catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
         results.push({
             name: 'OpenClaw Gateway',
             severity: 'warning',
-            message: 'Could not check OpenClaw status',
-            detail: message,
-            fix: 'Ensure OpenClaw container is running: docker ps | grep openclaw',
+            message: 'Could not check status',
+            detail: error instanceof Error ? error.message : String(error),
+            fix: 'Ensure container is running: docker ps | grep openclaw',
         });
     }
 }
-/**
- * Check configuration issues
- */
 function checkConfiguration(ctx, results) {
-    // Check API token secret
     if (ctx.settings.api.tokenSecret === 'change-me-in-production') {
         results.push({
             name: 'API Token Secret',
             severity: 'warning',
             message: 'Using default token secret (not secure for production)',
-            fix: 'Set environment variable: API_TOKEN_SECRET=<your-secret>',
+            fix: 'Set: API_TOKEN_SECRET=<your-secret>',
         });
     }
-    // Check MySQL credentials
     if (!ctx.settings.mysql.adminPassword) {
         results.push({
             name: 'MySQL Credentials',
             severity: 'warning',
             message: 'MySQL admin password not configured',
-            detail: 'Required for instance discovery and management',
-            fix: 'Set environment variable: MYSQL_ADMIN_PASSWORD=<password>',
+            fix: 'Set: MYSQL_ADMIN_PASSWORD=<password>',
         });
     }
-    // Check auto-failover
     if (!ctx.settings.failover.autoFailoverEnabled) {
         results.push({
             name: 'Auto Failover',
@@ -474,333 +370,88 @@ function checkConfiguration(ctx, results) {
             fix: 'Enable with: AUTO_FAILOVER_ENABLED=true',
         });
     }
-    // Check metadata database
     if (!ctx.settings.metadataDb.host) {
-        results.push({
-            name: 'Metadata Database',
-            severity: 'ok',
-            message: 'Using auto-provisioned metadata-mysql container',
-        });
-    }
-}
-/**
- * Check MySQL instances health
- */
-async function checkMySQLInstances(ctx, results) {
-    try {
-        const clusters = await ctx.orchestrator.getClusters();
-        for (const clusterName of clusters) {
-            const topology = await ctx.orchestrator.getTopology(clusterName);
-            if (!topology)
-                continue;
-            // Check primary
-            if (topology.primary) {
-                if (topology.primary.state !== 'online') {
-                    results.push({
-                        name: `Primary [${topology.name || clusterName}]`,
-                        severity: 'error',
-                        message: `Primary ${topology.primary.host}:${topology.primary.port} is ${topology.primary.state}`,
-                        fix: 'Check MySQL instance status and connectivity',
-                    });
-                }
-                else {
-                    results.push({
-                        name: `Primary [${topology.name || clusterName}]`,
-                        severity: 'ok',
-                        message: `${topology.primary.host}:${topology.primary.port} is online`,
-                    });
-                }
-            }
-            else {
-                results.push({
-                    name: `Primary [${topology.name || clusterName}]`,
-                    severity: 'error',
-                    message: 'No primary found for cluster',
-                    fix: 'Check replication setup or promote a replica: /failover switchover',
-                });
-            }
-            // Check replicas
-            for (const replica of topology.replicas) {
-                if (replica.state !== 'online') {
-                    results.push({
-                        name: `Replica [${topology.name || clusterName}]`,
-                        severity: 'warning',
-                        message: `Replica ${replica.host}:${replica.port} is ${replica.state}`,
-                        fix: 'Check replica MySQL status and replication connection',
-                    });
-                }
-                else if (replica.replicationLag !== undefined && replica.replicationLag > 60) {
-                    results.push({
-                        name: `Replica Lag [${topology.name || clusterName}]`,
-                        severity: 'warning',
-                        message: `Replica ${replica.host}:${replica.port} has high lag (${replica.replicationLag}s)`,
-                        fix: 'Check replica performance and network connectivity',
-                    });
-                }
-            }
-        }
-    }
-    catch {
-        // Already handled in Orchestrator check
+        results.push({ name: 'Metadata Database', severity: 'ok', message: 'Using auto-provisioned container' });
     }
 }
-/**
- * Check replication topology issues
- */
-async function checkReplicationTopology(ctx, results) {
-    try {
-        const analysis = await ctx.orchestrator.getReplicationAnalysis();
-        for (const issue of analysis) {
-            const analysisType = issue.Analysis;
-            const description = issue.Description;
-            const affectedHost = issue.Key?.Hostname;
-            if (analysisType && !analysisType.includes('NoProblem')) {
-                results.push({
-                    name: 'Replication Analysis',
-                    severity: 'warning',
-                    message: `${analysisType}: ${affectedHost || 'unknown'}`,
-                    detail: description,
-                    fix: 'Review Orchestrator UI for details: http://localhost:3000',
-                });
-            }
-        }
-    }
-    catch {
-        // Orchestrator may not be available
-    }
-}
-/**
- * Check ProxySQL sync with Orchestrator topology
- */
-async function checkProxySQLSync(ctx, results) {
-    try {
-        // Get topology from Orchestrator
-        const clusters = await ctx.orchestrator.getClusters();
-        if (clusters.length === 0) {
-            return; // No clusters to sync
-        }
-        // Get ProxySQL server stats and hostgroups
-        let proxysqlServers = [];
-        let hostgroups = [];
-        try {
-            await ctx.proxysql.connect();
-            proxysqlServers = await ctx.proxysql.getServers();
-            hostgroups = await ctx.proxysql.getReplicationHostgroups();
-            await ctx.proxysql.close();
-        }
-        catch {
-            // ProxySQL not available - already reported in checkProxySQL
-            return;
-        }
-        // Build expected instances from Orchestrator
-        const expectedInstances = new Map();
-        for (const clusterName of clusters) {
-            const topology = await ctx.orchestrator.getTopology(clusterName);
-            if (!topology)
-                continue;
-            if (topology.primary) {
-                const key = `${topology.primary.host}:${topology.primary.port}`;
-                expectedInstances.set(key, {
-                    host: topology.primary.host,
-                    port: topology.primary.port,
-                    role: 'primary',
-                    cluster: topology.name || clusterName,
-                });
-            }
-            for (const replica of topology.replicas) {
-                const key = `${replica.host}:${replica.port}`;
-                expectedInstances.set(key, {
-                    host: replica.host,
-                    port: replica.port,
-                    role: 'replica',
-                    cluster: topology.name || clusterName,
-                });
-            }
-        }
-        // Build actual ProxySQL instances
-        const proxysqlInstances = new Map();
-        for (const server of proxysqlServers) {
-            const key = `${server.hostname}:${server.port}`;
-            proxysqlInstances.set(key, {
-                host: server.hostname,
-                port: server.port,
-                hostgroup: server.hostgroupId,
-                status: server.status,
-            });
-        }
-        // Determine default hostgroups (coerce to numbers)
-        const defaultWriterHG = hostgroups.length > 0 ? Number(hostgroups[0].writerHostgroup) : 10;
-        const defaultReaderHG = hostgroups.length > 0 ? Number(hostgroups[0].readerHostgroup) : 20;
-        // Check for missing instances in ProxySQL
-        const missingInProxySQL = [];
-        const wrongHostgroup = [];
-        for (const [key, instance] of expectedInstances) {
-            const proxysqlInstance = proxysqlInstances.get(key);
-            if (!proxysqlInstance) {
-                missingInProxySQL.push(`${key} (${instance.role})`);
-            }
-            else {
-                // Check if hostgroup is correct (coerce both to numbers for comparison)
-                const actualHG = Number(proxysqlInstance.hostgroup);
-                const expectedHG = instance.role === 'primary' ? defaultWriterHG : defaultReaderHG;
-                // Skip if both are NaN or if they match
-                if (!isNaN(actualHG) && !isNaN(expectedHG) && actualHG !== expectedHG) {
-                    wrongHostgroup.push(`${key} is in hg:${actualHG}, expected hg:${expectedHG}`);
-                }
-            }
-        }
-        // Check for orphan instances in ProxySQL (not in Orchestrator)
-        const orphanInstances = [];
-        for (const [key, instance] of proxysqlInstances) {
-            if (!expectedInstances.has(key)) {
-                orphanInstances.push(`${key} (hg:${instance.hostgroup})`);
-            }
-        }
-        // Report findings
-        if (missingInProxySQL.length > 0) {
-            results.push({
-                name: 'ProxySQL Sync',
-                severity: 'warning',
-                message: `${missingInProxySQL.length} instance(s) from Orchestrator missing in ProxySQL`,
-                detail: missingInProxySQL.slice(0, 5).join(', ') + (missingInProxySQL.length > 5 ? '...' : ''),
-                fix: 'Sync clusters to ProxySQL with: /clusters sync',
-                fixCommand: '/clusters sync',
-            });
-        }
-        if (wrongHostgroup.length > 0) {
-            results.push({
-                name: 'ProxySQL Hostgroups',
-                severity: 'warning',
-                message: `${wrongHostgroup.length} instance(s) in wrong hostgroup`,
-                detail: wrongHostgroup.slice(0, 3).join('; '),
-                fix: 'Re-sync clusters to ProxySQL with: /clusters sync',
-                fixCommand: '/clusters sync',
-            });
-        }
-        if (orphanInstances.length > 0) {
-            results.push({
-                name: 'ProxySQL Orphans',
-                severity: 'warning',
-                message: `${orphanInstances.length} instance(s) in ProxySQL not in Orchestrator`,
-                detail: orphanInstances.slice(0, 3).join(', '),
-                fix: 'Remove orphan servers from ProxySQL or register them in Orchestrator',
-            });
-        }
-        // All synced properly
-        if (missingInProxySQL.length === 0 && wrongHostgroup.length === 0 && orphanInstances.length === 0 && expectedInstances.size > 0) {
-            results.push({
-                name: 'ProxySQL Sync',
-                severity: 'ok',
-                message: `All ${expectedInstances.size} instances properly synced`,
-            });
-        }
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        results.push({
-            name: 'ProxySQL Sync',
-            severity: 'warning',
-            message: 'Could not verify ProxySQL sync',
-            detail: message,
-        });
-    }
-}
-/**
- * Display diagnostic results
- */
+// ============================================================================
+// Display Utilities
+// ============================================================================
 function displayResults(results) {
-    // Group by severity
-    const errors = results.filter(r => r.severity === 'error');
-    const warnings = results.filter(r => r.severity === 'warning');
-    const ok = results.filter(r => r.severity === 'ok');
-    const info = results.filter(r => r.severity === 'info');
-    // Display errors first
-    if (errors.length > 0) {
-        console.log(components_js_1.theme.error.bold('\n✗ Errors:\n'));
-        for (const result of errors) {
-            displayResult(result);
-        }
+    const groups = {
+        error: [],
+        warning: [],
+        info: [],
+        ok: [],
+    };
+    for (const r of results) {
+        groups[r.severity].push(r);
     }
-    // Display warnings
-    if (warnings.length > 0) {
-        console.log(components_js_1.theme.warning.bold('\n◆ Warnings:\n'));
-        for (const result of warnings) {
-            displayResult(result);
-        }
+    if (groups.error.length > 0) {
+        console.log(components_js_1.theme.error.bold('✗ Errors:'));
+        groups.error.forEach(displayResult);
     }
-    // Display info
-    if (info.length > 0) {
-        console.log(components_js_1.theme.info.bold('\n○ Information:\n'));
-        for (const result of info) {
-            displayResult(result);
-        }
+    if (groups.warning.length > 0) {
+        console.log(components_js_1.theme.warning.bold('◆ Warnings:'));
+        groups.warning.forEach(displayResult);
     }
-    // Display healthy checks
-    if (ok.length > 0) {
-        console.log(components_js_1.theme.success.bold('\n✓ Healthy:\n'));
-        for (const result of ok) {
-            console.log(components_js_1.theme.muted(`  ${result.name}: `) + components_js_1.theme.success(result.message));
-        }
+    if (groups.info.length > 0) {
+        console.log(components_js_1.theme.info.bold('○ Information:'));
+        groups.info.forEach(displayResult);
+    }
+    if (groups.ok.length > 0) {
+        console.log(components_js_1.theme.success.bold('✓ Healthy:'));
+        groups.ok.forEach(r => console.log(components_js_1.theme.muted(`  ${r.name}: `) + components_js_1.theme.success(r.message)));
     }
 }
-/**
- * Display a single diagnostic result
- */
 function displayResult(result) {
-    const severityStyles = {
-        error: components_js_1.theme.error,
-        warning: components_js_1.theme.warning,
-        ok: components_js_1.theme.success,
-        info: components_js_1.theme.info,
-    };
-    const severityIcons = {
+    const icons = {
         error: components_js_1.theme.error(components_js_1.indicators.cross),
         warning: components_js_1.theme.warning(components_js_1.indicators.warning),
-        ok: components_js_1.theme.success(components_js_1.indicators.check),
         info: components_js_1.theme.info(components_js_1.indicators.info),
+        ok: components_js_1.theme.success(components_js_1.indicators.check),
     };
-    const icon = severityIcons[result.severity];
-    const nameColor = severityStyles[result.severity];
-    console.log(`  ${icon} ${nameColor.bold(result.name)}: ${result.message}`);
-    if (result.detail) {
+    const colorFn = {
+        error: components_js_1.theme.error,
+        warning: components_js_1.theme.warning,
+        info: components_js_1.theme.info,
+        ok: components_js_1.theme.success,
+    }[result.severity];
+    console.log(`  ${icons[result.severity]} ${colorFn.bold(result.name)}: ${result.message}`);
+    if (result.detail)
         console.log(components_js_1.theme.muted(`      ${result.detail}`));
-    }
-    if (result.fix) {
+    if (result.fix)
         console.log(components_js_1.theme.primary(`      Fix: ${result.fix}`));
-    }
-    if (result.fixCommand) {
+    if (result.fixCommand)
         console.log(components_js_1.theme.muted(`      Command: ${result.fixCommand}`));
+}
+function printSummary(results) {
+    const errors = results.filter(r => r.severity === 'error').length;
+    const warnings = results.filter(r => r.severity === 'warning').length;
+    if (errors === 0 && warnings === 0) {
+        console.log(components_js_1.theme.success(`${components_js_1.indicators.check} All systems healthy!`));
     }
+    else {
+        console.log(components_js_1.theme.warning(`Found ${errors} error(s) and ${warnings} warning(s)`));
+    }
+    // Add hint for MySQL cluster details
     console.log();
+    console.log(components_js_1.theme.muted('  For MySQL cluster details, use: /topology or /clusters'));
 }
-/**
- * Execute a shell command
- */
+// ============================================================================
+// Process Execution
+// ============================================================================
 function execCommand(cmd, silent = false) {
     return new Promise((resolve) => {
-        const proc = (0, child_process_1.spawn)(cmd[0], cmd.slice(1), {
-            stdio: silent ? 'pipe' : 'inherit',
-        });
+        const proc = (0, child_process_1.spawn)(cmd[0], cmd.slice(1), { stdio: silent ? 'pipe' : 'inherit' });
         let stdout = '';
         let stderr = '';
         if (silent) {
             proc.stdout?.on('data', (data) => { stdout += data; });
             proc.stderr?.on('data', (data) => { stderr += data; });
         }
-        proc.on('close', (code) => {
-            resolve({
-                success: code === 0,
-                stdout,
-                stderr,
-            });
-        });
-        proc.on('error', () => {
-            resolve({
-                success: false,
-                stdout: '',
-                stderr: 'Failed to execute command',
-            });
-        });
+        proc.on('close', (code) => resolve({ success: code === 0, stdout, stderr }));
+        proc.on('error', () => resolve({ success: false, stdout: '', stderr: 'Failed to execute' }));
     });
 }
 exports.default = exports.doctorCommand;