kynjal-cli 4.0.0 → 4.0.1

package/dist/src/commands/status.js

@@ -2,60 +2,24 @@
  * V3 CLI Status Command
  * System status display for Claude Flow
  */
-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 { callMCPTool, MCPClientError } from '../mcp-client.js';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
 // Status refresh interval (ms)
-var DEFAULT_WATCH_INTERVAL = 2000;
+const DEFAULT_WATCH_INTERVAL = 2000;
 // Track CPU usage over time
-var lastCpuUsage = null;
-var lastCpuTime = Date.now();
+let lastCpuUsage = null;
+let lastCpuTime = Date.now();
 // Get real process CPU usage percentage
 function getProcessCpuUsage() {
-    var cpuUsage = process.cpuUsage(lastCpuUsage ? { user: lastCpuUsage.user, system: lastCpuUsage.system } : undefined);
-    var now = Date.now();
-    var elapsed = now - lastCpuTime;
+    const cpuUsage = process.cpuUsage(lastCpuUsage ? { user: lastCpuUsage.user, system: lastCpuUsage.system } : undefined);
+    const now = Date.now();
+    const elapsed = now - lastCpuTime;
     // Calculate percentage (cpuUsage is in microseconds)
-    var totalCpu = (cpuUsage.user + cpuUsage.system) / 1000; // Convert to ms
-    var percentage = elapsed > 0 ? (totalCpu / elapsed) * 100 : 0;
+    const totalCpu = (cpuUsage.user + cpuUsage.system) / 1000; // Convert to ms
+    const percentage = elapsed > 0 ? (totalCpu / elapsed) * 100 : 0;
     // Update for next call
     lastCpuUsage = cpuUsage;
     lastCpuTime = now;
@@ -63,146 +27,132 @@ function getProcessCpuUsage() {
 }
 // Get real process memory usage percentage
 function getProcessMemoryUsage() {
-    var memoryUsage = process.memoryUsage();
-    var totalMemory = os.totalmem();
-    var usedMemory = memoryUsage.heapUsed + memoryUsage.external;
+    const memoryUsage = process.memoryUsage();
+    const totalMemory = os.totalmem();
+    const usedMemory = memoryUsage.heapUsed + memoryUsage.external;
     return (usedMemory / totalMemory) * 100;
 }
 // Check if project is initialized
 function isInitialized(cwd) {
-    var configPath = path.join(cwd, '.claude-flow', 'config.yaml');
+    const configPath = path.join(cwd, '.claude-flow', 'config.yaml');
     return fs.existsSync(configPath);
 }
 // Format uptime
 function formatUptime(ms) {
-    var seconds = Math.floor(ms / 1000);
-    var minutes = Math.floor(seconds / 60);
-    var hours = Math.floor(minutes / 60);
-    var days = Math.floor(hours / 24);
+    const seconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    const days = Math.floor(hours / 24);
     if (days > 0) {
-        return days + "d " + hours % 24 + "h " + minutes % 60 + "m";
+        return `${days}d ${hours % 24}h ${minutes % 60}m`;
     }
     else if (hours > 0) {
-        return hours + "h " + minutes % 60 + "m " + seconds % 60 + "s";
+        return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
     }
     else if (minutes > 0) {
-        return minutes + "m " + seconds % 60 + "s";
+        return `${minutes}m ${seconds % 60}s`;
     }
     else {
-        return seconds + "s";
+        return `${seconds}s`;
     }
 }
 // Format bytes
 function formatBytes(bytes) {
     if (bytes === 0)
         return '0 B';
-    var k = 1024;
-    var sizes = ['B', 'KB', 'MB', 'GB'];
-    var i = Math.floor(Math.log(bytes) / Math.log(k));
-    return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + " " + sizes[i];
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return `${parseFloat((bytes / Math.pow(k, i)).toFixed(1))} ${sizes[i]}`;
 }
 // Get system status data
-function getSystemStatus() {
-    return __awaiter(this, void 0, Promise, function () {
-        var swarmStatus, mcpStatus, mcp, _a, memoryStatus, taskStatus, error_1;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    _b.trys.push([0, 8, , 9]);
-                    return [4 /*yield*/, callMCPTool('swarm_status', { includeMetrics: true })];
-                case 1:
-                    swarmStatus = _b.sent();
-                    mcpStatus = { running: false, port: null, transport: 'stdio' };
-                    _b.label = 2;
-                case 2:
-                    _b.trys.push([2, 4, , 5]);
-                    return [4 /*yield*/, callMCPTool('mcp_status', {})];
-                case 3:
-                    mcp = _b.sent();
-                    mcpStatus = mcp;
-                    return [3 /*break*/, 5];
-                case 4:
-                    _a = _b.sent();
-                    return [3 /*break*/, 5];
-                case 5: return [4 /*yield*/, callMCPTool('memory_stats', {})];
-                case 6:
-                    memoryStatus = _b.sent();
-                    return [4 /*yield*/, callMCPTool('task_summary', {})];
-                case 7:
-                    taskStatus = _b.sent();
-                    return [2 /*return*/, {
-                            initialized: true,
-                            running: true,
-                            swarm: {
-                                id: swarmStatus.swarmId,
-                                topology: swarmStatus.topology,
-                                agents: {
-                                    total: swarmStatus.agents.total,
-                                    active: swarmStatus.agents.active,
-                                    idle: swarmStatus.agents.idle
-                                },
-                                health: swarmStatus.health,
-                                uptime: swarmStatus.uptime
-                            },
-                            mcp: mcpStatus,
-                            memory: {
-                                entries: memoryStatus.entries,
-                                size: formatBytes(memoryStatus.size),
-                                backend: memoryStatus.backend,
-                                performance: {
-                                    searchTime: memoryStatus.performance.avgSearchTime,
-                                    cacheHitRate: memoryStatus.performance.cacheHitRate
-                                }
-                            },
-                            tasks: taskStatus,
-                            performance: {
-                                cpuUsage: getProcessCpuUsage(),
-                                memoryUsage: getProcessMemoryUsage(),
-                                flashAttention: '2.8x speedup',
-                                searchSpeed: '150x faster'
-                            }
-                        }];
-                case 8:
-                    error_1 = _b.sent();
-                    // System not running
-                    return [2 /*return*/, {
-                            initialized: true,
-                            running: false,
-                            swarm: {
-                                id: null,
-                                topology: 'none',
-                                agents: { total: 0, active: 0, idle: 0 },
-                                health: 'stopped',
-                                uptime: 0
-                            },
-                            mcp: { running: false, port: null, transport: 'stdio' },
-                            memory: {
-                                entries: 0,
-                                size: '0 B',
-                                backend: 'none',
-                                performance: { searchTime: 0, cacheHitRate: 0 }
-                            },
-                            tasks: { total: 0, pending: 0, running: 0, completed: 0, failed: 0 },
-                            performance: {
-                                cpuUsage: 0,
-                                memoryUsage: 0,
-                                flashAttention: 'N/A',
-                                searchSpeed: 'N/A'
-                            }
-                        }];
-                case 9: return [2 /*return*/];
+async function getSystemStatus() {
+    try {
+        // Get swarm status
+        const swarmStatus = await callMCPTool('swarm_status', { includeMetrics: true });
+        // Get MCP status
+        let mcpStatus = { running: false, port: null, transport: 'stdio' };
+        try {
+            const mcp = await callMCPTool('mcp_status', {});
+            mcpStatus = mcp;
+        }
+        catch {
+            // MCP not running
+        }
+        // Get memory status
+        const memoryStatus = await callMCPTool('memory_stats', {});
+        // Get task status
+        const taskStatus = await callMCPTool('task_summary', {});
+        return {
+            initialized: true,
+            running: true,
+            swarm: {
+                id: swarmStatus.swarmId,
+                topology: swarmStatus.topology,
+                agents: {
+                    total: swarmStatus.agents.total,
+                    active: swarmStatus.agents.active,
+                    idle: swarmStatus.agents.idle
+                },
+                health: swarmStatus.health,
+                uptime: swarmStatus.uptime
+            },
+            mcp: mcpStatus,
+            memory: {
+                entries: memoryStatus.entries,
+                size: formatBytes(memoryStatus.size),
+                backend: memoryStatus.backend,
+                performance: {
+                    searchTime: memoryStatus.performance.avgSearchTime,
+                    cacheHitRate: memoryStatus.performance.cacheHitRate
+                }
+            },
+            tasks: taskStatus,
+            performance: {
+                cpuUsage: getProcessCpuUsage(),
+                memoryUsage: getProcessMemoryUsage(),
+                flashAttention: '2.8x speedup',
+                searchSpeed: '150x faster'
             }
-        });
-    });
+        };
+    }
+    catch (error) {
+        // System not running
+        return {
+            initialized: true,
+            running: false,
+            swarm: {
+                id: null,
+                topology: 'none',
+                agents: { total: 0, active: 0, idle: 0 },
+                health: 'stopped',
+                uptime: 0
+            },
+            mcp: { running: false, port: null, transport: 'stdio' },
+            memory: {
+                entries: 0,
+                size: '0 B',
+                backend: 'none',
+                performance: { searchTime: 0, cacheHitRate: 0 }
+            },
+            tasks: { total: 0, pending: 0, running: 0, completed: 0, failed: 0 },
+            performance: {
+                cpuUsage: 0,
+                memoryUsage: 0,
+                flashAttention: 'N/A',
+                searchSpeed: 'N/A'
+            }
+        };
+    }
 }
 // Display status in text format
 function displayStatus(status) {
     output.writeln();
     // Header with overall status
-    var statusIcon = status.running
+    const statusIcon = status.running
         ? output.success('[RUNNING]')
         : output.warning('[STOPPED]');
-    output.writeln(output.bold('RuFlo V3') + " " + statusIcon);
+    output.writeln(`${output.bold('RuFlo V3')} ${statusIcon}`);
     output.writeln();
     // Swarm section
     output.writeln(output.bold('Swarm'));
@@ -265,8 +215,8 @@ function displayStatus(status) {
             { property: 'Backend', value: status.memory.backend },
             { property: 'Entries', value: status.memory.entries },
             { property: 'Size', value: status.memory.size },
-            { property: 'Search Time', value: status.memory.performance.searchTime.toFixed(2) + "ms" },
-            { property: 'Cache Hit Rate', value: (status.memory.performance.cacheHitRate * 100).toFixed(1) + "%" }
+            { property: 'Search Time', value: `${status.memory.performance.searchTime.toFixed(2)}ms` },
+            { property: 'Cache Hit Rate', value: `${(status.memory.performance.cacheHitRate * 100).toFixed(1)}%` }
         ]
     });
     output.writeln();
@@ -277,7 +227,7 @@ function displayStatus(status) {
             output.printInfo('  Running (stdio mode)');
         }
         else {
-            output.printInfo("  Running on port " + status.mcp.port + " (" + status.mcp.transport + ")");
+            output.printInfo(`  Running on port ${status.mcp.port} (${status.mcp.transport})`);
         }
     }
     else {
@@ -288,10 +238,10 @@ function displayStatus(status) {
     if (status.running) {
         output.writeln(output.bold('V3 Performance Gains'));
         output.printList([
-            "Flash Attention: " + output.success(status.performance.flashAttention),
-            "Vector Search: " + output.success(status.performance.searchSpeed),
-            "CPU Usage: " + status.performance.cpuUsage.toFixed(1) + "%",
-            "Memory Usage: " + status.performance.memoryUsage.toFixed(1) + "%"
+            `Flash Attention: ${output.success(status.performance.flashAttention)}`,
+            `Vector Search: ${output.success(status.performance.searchSpeed)}`,
+            `CPU Usage: ${status.performance.cpuUsage.toFixed(1)}%`,
+            `Memory Usage: ${status.performance.memoryUsage.toFixed(1)}%`
         ]);
     }
 }
@@ -310,352 +260,296 @@ function formatHealth(health) {
     }
 }
 // Main status action
-var statusAction = function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-    var watch, interval, healthCheck, cwd, status;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                watch = ctx.flags.watch;
-                interval = ctx.flags.interval || DEFAULT_WATCH_INTERVAL / 1000;
-                healthCheck = ctx.flags['health-check'];
-                cwd = ctx.cwd;
-                // Check initialization
-                if (!isInitialized(cwd)) {
-                    output.printError('RuFlo is not initialized in this directory');
-                    output.printInfo('Run "ruflo init" to initialize');
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                }
-                return [4 /*yield*/, getSystemStatus()];
-            case 1:
-                status = _a.sent();
-                // Health check mode
-                if (healthCheck) {
-                    return [2 /*return*/, performHealthCheck(status)];
-                }
-                // JSON output
-                if (ctx.flags.format === 'json') {
-                    output.printJson(status);
-                    return [2 /*return*/, { success: true, data: status }];
-                }
-                // Watch mode
-                if (watch) {
-                    return [2 /*return*/, watchStatus(interval)];
-                }
-                // Single status display
-                displayStatus(status);
-                return [2 /*return*/, { success: true, data: status }];
-        }
-    });
-}); };
+const statusAction = async (ctx) => {
+    const watch = ctx.flags.watch;
+    const interval = ctx.flags.interval || DEFAULT_WATCH_INTERVAL / 1000;
+    const healthCheck = ctx.flags['health-check'];
+    const cwd = ctx.cwd;
+    // Check initialization
+    if (!isInitialized(cwd)) {
+        output.printError('RuFlo is not initialized in this directory');
+        output.printInfo('Run "ruflo init" to initialize');
+        return { success: false, exitCode: 1 };
+    }
+    // Get status
+    const status = await getSystemStatus();
+    // Health check mode
+    if (healthCheck) {
+        return performHealthCheck(status);
+    }
+    // JSON output
+    if (ctx.flags.format === 'json') {
+        output.printJson(status);
+        return { success: true, data: status };
+    }
+    // Watch mode
+    if (watch) {
+        return watchStatus(interval);
+    }
+    // Single status display
+    displayStatus(status);
+    return { success: true, data: status };
+};
 // Perform health checks
-function performHealthCheck(status) {
-    return __awaiter(this, void 0, Promise, function () {
-        var checks, failRate, _i, checks_1, check, icon, passed, warned, failed;
-        return __generator(this, function (_a) {
-            output.writeln();
-            output.writeln(output.bold('Health Check'));
-            output.writeln();
-            checks = [];
-            // Check if system is running
-            checks.push({
-                name: 'System Running',
-                status: status.running ? 'pass' : 'fail',
-                message: status.running ? 'System is running' : 'System is not running'
-            });
-            // Check swarm health
-            if (status.running) {
-                checks.push({
-                    name: 'Swarm Health',
-                    status: status.swarm.health === 'healthy' ? 'pass' :
-                        status.swarm.health === 'degraded' ? 'warn' : 'fail',
-                    message: "Swarm is " + status.swarm.health
-                });
-                // Check agent count
-                checks.push({
-                    name: 'Agents Available',
-                    status: status.swarm.agents.active > 0 ? 'pass' :
-                        status.swarm.agents.idle > 0 ? 'warn' : 'fail',
-                    message: status.swarm.agents.active + " active, " + status.swarm.agents.idle + " idle"
-                });
-                // Check MCP
-                checks.push({
-                    name: 'MCP Server',
-                    status: status.mcp.running ? 'pass' : 'warn',
-                    message: status.mcp.running
-                        ? (status.mcp.transport === 'stdio' ? 'Running (stdio mode)' : "Running on port " + status.mcp.port)
-                        : 'Not running'
-                });
-                // Check memory backend
-                checks.push({
-                    name: 'Memory Backend',
-                    status: status.memory.backend !== 'none' ? 'pass' : 'fail',
-                    message: "Using " + status.memory.backend + " backend"
-                });
-                failRate = status.tasks.total > 0
-                    ? status.tasks.failed / status.tasks.total
-                    : 0;
-                checks.push({
-                    name: 'Task Success Rate',
-                    status: failRate < 0.05 ? 'pass' : failRate < 0.2 ? 'warn' : 'fail',
-                    message: ((1 - failRate) * 100).toFixed(1) + "% success rate"
-                });
-            }
-            // Display results
-            for (_i = 0, checks_1 = checks; _i < checks_1.length; _i++) {
-                check = checks_1[_i];
-                icon = check.status === 'pass' ? output.success('[PASS]') :
-                    check.status === 'warn' ? output.warning('[WARN]') :
-                        output.error('[FAIL]');
-                output.writeln(icon + " " + check.name + ": " + check.message);
-            }
-            output.writeln();
-            passed = checks.filter(function (c) { return c.status === 'pass'; }).length;
-            warned = checks.filter(function (c) { return c.status === 'warn'; }).length;
-            failed = checks.filter(function (c) { return c.status === 'fail'; }).length;
-            if (failed === 0) {
-                output.printSuccess("All checks passed (" + passed + " passed, " + warned + " warnings)");
-            }
-            else {
-                output.printError("Health check failed (" + passed + " passed, " + warned + " warnings, " + failed + " failed)");
-            }
-            return [2 /*return*/, {
-                    success: failed === 0,
-                    exitCode: failed > 0 ? 1 : 0,
-                    data: { checks: checks, summary: { passed: passed, warned: warned, failed: failed } }
-                }];
-        });
+async function performHealthCheck(status) {
+    output.writeln();
+    output.writeln(output.bold('Health Check'));
+    output.writeln();
+    const checks = [];
+    // Check if system is running
+    checks.push({
+        name: 'System Running',
+        status: status.running ? 'pass' : 'fail',
+        message: status.running ? 'System is running' : 'System is not running'
     });
+    // Check swarm health
+    if (status.running) {
+        checks.push({
+            name: 'Swarm Health',
+            status: status.swarm.health === 'healthy' ? 'pass' :
+                status.swarm.health === 'degraded' ? 'warn' : 'fail',
+            message: `Swarm is ${status.swarm.health}`
+        });
+        // Check agent count
+        checks.push({
+            name: 'Agents Available',
+            status: status.swarm.agents.active > 0 ? 'pass' :
+                status.swarm.agents.idle > 0 ? 'warn' : 'fail',
+            message: `${status.swarm.agents.active} active, ${status.swarm.agents.idle} idle`
+        });
+        // Check MCP
+        checks.push({
+            name: 'MCP Server',
+            status: status.mcp.running ? 'pass' : 'warn',
+            message: status.mcp.running
+                ? (status.mcp.transport === 'stdio' ? 'Running (stdio mode)' : `Running on port ${status.mcp.port}`)
+                : 'Not running'
+        });
+        // Check memory backend
+        checks.push({
+            name: 'Memory Backend',
+            status: status.memory.backend !== 'none' ? 'pass' : 'fail',
+            message: `Using ${status.memory.backend} backend`
+        });
+        // Check for failed tasks
+        const failRate = status.tasks.total > 0
+            ? status.tasks.failed / status.tasks.total
+            : 0;
+        checks.push({
+            name: 'Task Success Rate',
+            status: failRate < 0.05 ? 'pass' : failRate < 0.2 ? 'warn' : 'fail',
+            message: `${((1 - failRate) * 100).toFixed(1)}% success rate`
+        });
+    }
+    // Display results
+    for (const check of checks) {
+        const icon = check.status === 'pass' ? output.success('[PASS]') :
+            check.status === 'warn' ? output.warning('[WARN]') :
+                output.error('[FAIL]');
+        output.writeln(`${icon} ${check.name}: ${check.message}`);
+    }
+    output.writeln();
+    const passed = checks.filter(c => c.status === 'pass').length;
+    const warned = checks.filter(c => c.status === 'warn').length;
+    const failed = checks.filter(c => c.status === 'fail').length;
+    if (failed === 0) {
+        output.printSuccess(`All checks passed (${passed} passed, ${warned} warnings)`);
+    }
+    else {
+        output.printError(`Health check failed (${passed} passed, ${warned} warnings, ${failed} failed)`);
+    }
+    return {
+        success: failed === 0,
+        exitCode: failed > 0 ? 1 : 0,
+        data: { checks, summary: { passed, warned, failed } }
+    };
 }
 // Watch mode - continuous status updates
-function watchStatus(intervalSeconds) {
-    return __awaiter(this, void 0, Promise, function () {
-        var refresh, intervalId;
-        var _this = this;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    output.writeln();
-                    output.writeln(output.bold('Watch Mode'));
-                    output.writeln(output.dim("Refreshing every " + intervalSeconds + "s. Press Ctrl+C to exit."));
-                    output.writeln();
-                    refresh = function () { return __awaiter(_this, void 0, void 0, function () {
-                        var status;
-                        return __generator(this, function (_a) {
-                            switch (_a.label) {
-                                case 0:
-                                    // Clear screen
-                                    process.stdout.write('\x1b[2J\x1b[H');
-                                    output.writeln(output.dim("Last updated: " + new Date().toLocaleTimeString()));
-                                    output.writeln();
-                                    return [4 /*yield*/, getSystemStatus()];
-                                case 1:
-                                    status = _a.sent();
-                                    displayStatus(status);
-                                    return [2 /*return*/];
-                            }
-                        });
-                    }); };
-                    // Initial display
-                    return [4 /*yield*/, refresh()];
-                case 1:
-                    // Initial display
-                    _a.sent();
-                    intervalId = setInterval(refresh, intervalSeconds * 1000);
-                    // Handle exit
-                    return [2 /*return*/, new Promise(function (resolve) {
-                            process.on('SIGINT', function () {
-                                clearInterval(intervalId);
-                                output.writeln();
-                                output.printInfo('Watch mode stopped');
-                                resolve({ success: true });
-                            });
-                        })];
-            }
+async function watchStatus(intervalSeconds) {
+    output.writeln();
+    output.writeln(output.bold('Watch Mode'));
+    output.writeln(output.dim(`Refreshing every ${intervalSeconds}s. Press Ctrl+C to exit.`));
+    output.writeln();
+    const refresh = async () => {
+        // Clear screen
+        process.stdout.write('\x1b[2J\x1b[H');
+        output.writeln(output.dim(`Last updated: ${new Date().toLocaleTimeString()}`));
+        output.writeln();
+        const status = await getSystemStatus();
+        displayStatus(status);
+    };
+    // Initial display
+    await refresh();
+    // Set up interval
+    const intervalId = setInterval(refresh, intervalSeconds * 1000);
+    // Handle exit
+    return new Promise((resolve) => {
+        process.on('SIGINT', () => {
+            clearInterval(intervalId);
+            output.writeln();
+            output.printInfo('Watch mode stopped');
+            resolve({ success: true });
         });
     });
 }
 // Agents subcommand
-var agentsCommand = {
+const agentsCommand = {
     name: 'agents',
     description: 'Show detailed agent status',
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var result, error_2;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    _a.trys.push([0, 2, , 3]);
-                    return [4 /*yield*/, callMCPTool('agent_list', { includeMetrics: true, status: 'all' })];
-                case 1:
-                    result = _a.sent();
-                    if (ctx.flags.format === 'json') {
-                        output.printJson(result);
-                        return [2 /*return*/, { success: true, data: result }];
-                    }
-                    output.writeln();
-                    output.writeln(output.bold('Agent Status'));
-                    output.writeln();
-                    if (result.agents.length === 0) {
-                        output.printInfo('No agents running');
-                        return [2 /*return*/, { success: true, data: result }];
-                    }
-                    output.printTable({
-                        columns: [
-                            { key: 'id', header: 'ID', width: 20 },
-                            { key: 'type', header: 'Type', width: 12 },
-                            { key: 'status', header: 'Status', width: 10 },
-                            { key: 'task', header: 'Current Task', width: 25 },
-                            { key: 'uptime', header: 'Uptime', width: 12 },
-                            { key: 'success', header: 'Success', width: 8 }
-                        ],
-                        data: result.agents.map(function (a) { return ({
-                            id: a.id,
-                            type: a.type,
-                            status: formatHealth(a.status),
-                            task: a.task || '-',
-                            uptime: formatUptime(a.uptime),
-                            success: (a.metrics.successRate * 100).toFixed(0) + "%"
-                        }); })
-                    });
-                    return [2 /*return*/, { success: true, data: result }];
-                case 2:
-                    error_2 = _a.sent();
-                    if (error_2 instanceof MCPClientError) {
-                        output.printError("Failed to get agent status: " + error_2.message);
-                    }
-                    else {
-                        output.printError("Unexpected error: " + String(error_2));
-                    }
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 3: return [2 /*return*/];
+    action: async (ctx) => {
+        try {
+            const result = await callMCPTool('agent_list', { includeMetrics: true, status: 'all' });
+            if (ctx.flags.format === 'json') {
+                output.printJson(result);
+                return { success: true, data: result };
             }
-        });
-    }); }
+            output.writeln();
+            output.writeln(output.bold('Agent Status'));
+            output.writeln();
+            if (result.agents.length === 0) {
+                output.printInfo('No agents running');
+                return { success: true, data: result };
+            }
+            output.printTable({
+                columns: [
+                    { key: 'id', header: 'ID', width: 20 },
+                    { key: 'type', header: 'Type', width: 12 },
+                    { key: 'status', header: 'Status', width: 10 },
+                    { key: 'task', header: 'Current Task', width: 25 },
+                    { key: 'uptime', header: 'Uptime', width: 12 },
+                    { key: 'success', header: 'Success', width: 8 }
+                ],
+                data: result.agents.map(a => ({
+                    id: a.id,
+                    type: a.type,
+                    status: formatHealth(a.status),
+                    task: a.task || '-',
+                    uptime: formatUptime(a.uptime),
+                    success: `${(a.metrics.successRate * 100).toFixed(0)}%`
+                }))
+            });
+            return { success: true, data: result };
+        }
+        catch (error) {
+            if (error instanceof MCPClientError) {
+                output.printError(`Failed to get agent status: ${error.message}`);
+            }
+            else {
+                output.printError(`Unexpected error: ${String(error)}`);
+            }
+            return { success: false, exitCode: 1 };
+        }
+    }
 };
 // Tasks subcommand
-var tasksCommand = {
+const tasksCommand = {
     name: 'tasks',
     description: 'Show detailed task status',
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var result, error_3;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    _a.trys.push([0, 2, , 3]);
-                    return [4 /*yield*/, callMCPTool('task_list', { status: 'all', limit: 50 })];
-                case 1:
-                    result = _a.sent();
-                    if (ctx.flags.format === 'json') {
-                        output.printJson(result);
-                        return [2 /*return*/, { success: true, data: result }];
-                    }
-                    output.writeln();
-                    output.writeln(output.bold('Task Status'));
-                    output.writeln();
-                    if (result.tasks.length === 0) {
-                        output.printInfo('No tasks');
-                        return [2 /*return*/, { success: true, data: result }];
-                    }
-                    output.printTable({
-                        columns: [
-                            { key: 'id', header: 'ID', width: 15 },
-                            { key: 'type', header: 'Type', width: 15 },
-                            { key: 'status', header: 'Status', width: 12 },
-                            { key: 'priority', header: 'Priority', width: 10 },
-                            { key: 'agent', header: 'Agent', width: 15 },
-                            { key: 'progress', header: 'Progress', width: 10 }
-                        ],
-                        data: result.tasks.map(function (t) { return ({
-                            id: t.id,
-                            type: t.type,
-                            status: formatHealth(t.status),
-                            priority: t.priority,
-                            agent: t.agent || '-',
-                            progress: t.progress + "%"
-                        }); })
-                    });
-                    return [2 /*return*/, { success: true, data: result }];
-                case 2:
-                    error_3 = _a.sent();
-                    if (error_3 instanceof MCPClientError) {
-                        output.printError("Failed to get task status: " + error_3.message);
-                    }
-                    else {
-                        output.printError("Unexpected error: " + String(error_3));
-                    }
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 3: return [2 /*return*/];
+    action: async (ctx) => {
+        try {
+            const result = await callMCPTool('task_list', { status: 'all', limit: 50 });
+            if (ctx.flags.format === 'json') {
+                output.printJson(result);
+                return { success: true, data: result };
             }
-        });
-    }); }
+            output.writeln();
+            output.writeln(output.bold('Task Status'));
+            output.writeln();
+            if (result.tasks.length === 0) {
+                output.printInfo('No tasks');
+                return { success: true, data: result };
+            }
+            output.printTable({
+                columns: [
+                    { key: 'id', header: 'ID', width: 15 },
+                    { key: 'type', header: 'Type', width: 15 },
+                    { key: 'status', header: 'Status', width: 12 },
+                    { key: 'priority', header: 'Priority', width: 10 },
+                    { key: 'agent', header: 'Agent', width: 15 },
+                    { key: 'progress', header: 'Progress', width: 10 }
+                ],
+                data: result.tasks.map(t => ({
+                    id: t.id,
+                    type: t.type,
+                    status: formatHealth(t.status),
+                    priority: t.priority,
+                    agent: t.agent || '-',
+                    progress: `${t.progress}%`
+                }))
+            });
+            return { success: true, data: result };
+        }
+        catch (error) {
+            if (error instanceof MCPClientError) {
+                output.printError(`Failed to get task status: ${error.message}`);
+            }
+            else {
+                output.printError(`Unexpected error: ${String(error)}`);
+            }
+            return { success: false, exitCode: 1 };
+        }
+    }
 };
 // Memory subcommand
-var memoryCommand = {
+const memoryCommand = {
     name: 'memory',
     description: 'Show detailed memory status',
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var result, error_4;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    _a.trys.push([0, 2, , 3]);
-                    return [4 /*yield*/, callMCPTool('memory_detailed-stats', {})];
-                case 1:
-                    result = _a.sent();
-                    if (ctx.flags.format === 'json') {
-                        output.printJson(result);
-                        return [2 /*return*/, { success: true, data: result }];
-                    }
-                    output.writeln();
-                    output.writeln(output.bold('Memory Status'));
-                    output.writeln();
-                    output.printTable({
-                        columns: [
-                            { key: 'property', header: 'Property', width: 20 },
-                            { key: 'value', header: 'Value', width: 25 }
-                        ],
-                        data: [
-                            { property: 'Backend', value: result.backend },
-                            { property: 'Total Entries', value: result.entries.toLocaleString() },
-                            { property: 'Storage Size', value: formatBytes(result.size) },
-                            { property: 'HNSW Index', value: result.performance.hnswEnabled ? 'Enabled' : 'Disabled' }
-                        ]
-                    });
-                    output.writeln();
-                    output.writeln(output.bold('Performance'));
-                    output.printTable({
-                        columns: [
-                            { key: 'metric', header: 'Metric', width: 20 },
-                            { key: 'value', header: 'Value', width: 20, align: 'right' }
-                        ],
-                        data: [
-                            { metric: 'Avg Search Time', value: result.performance.avgSearchTime.toFixed(2) + "ms" },
-                            { metric: 'Avg Write Time', value: result.performance.avgWriteTime.toFixed(2) + "ms" },
-                            { metric: 'Cache Hit Rate', value: (result.performance.cacheHitRate * 100).toFixed(1) + "%" }
-                        ]
-                    });
-                    output.writeln();
-                    output.writeln(output.bold('V3 Performance Gains'));
-                    output.printList([
-                        "Search Speed: " + output.success(result.v3Gains.searchImprovement),
-                        "Memory Usage: " + output.success(result.v3Gains.memoryReduction)
-                    ]);
-                    return [2 /*return*/, { success: true, data: result }];
-                case 2:
-                    error_4 = _a.sent();
-                    if (error_4 instanceof MCPClientError) {
-                        output.printError("Failed to get memory status: " + error_4.message);
-                    }
-                    else {
-                        output.printError("Unexpected error: " + String(error_4));
-                    }
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 3: return [2 /*return*/];
+    action: async (ctx) => {
+        try {
+            const result = await callMCPTool('memory_detailed-stats', {});
+            if (ctx.flags.format === 'json') {
+                output.printJson(result);
+                return { success: true, data: result };
             }
-        });
-    }); }
+            output.writeln();
+            output.writeln(output.bold('Memory Status'));
+            output.writeln();
+            output.printTable({
+                columns: [
+                    { key: 'property', header: 'Property', width: 20 },
+                    { key: 'value', header: 'Value', width: 25 }
+                ],
+                data: [
+                    { property: 'Backend', value: result.backend },
+                    { property: 'Total Entries', value: result.entries.toLocaleString() },
+                    { property: 'Storage Size', value: formatBytes(result.size) },
+                    { property: 'HNSW Index', value: result.performance.hnswEnabled ? 'Enabled' : 'Disabled' }
+                ]
+            });
+            output.writeln();
+            output.writeln(output.bold('Performance'));
+            output.printTable({
+                columns: [
+                    { key: 'metric', header: 'Metric', width: 20 },
+                    { key: 'value', header: 'Value', width: 20, align: 'right' }
+                ],
+                data: [
+                    { metric: 'Avg Search Time', value: `${result.performance.avgSearchTime.toFixed(2)}ms` },
+                    { metric: 'Avg Write Time', value: `${result.performance.avgWriteTime.toFixed(2)}ms` },
+                    { metric: 'Cache Hit Rate', value: `${(result.performance.cacheHitRate * 100).toFixed(1)}%` }
+                ]
+            });
+            output.writeln();
+            output.writeln(output.bold('V3 Performance Gains'));
+            output.printList([
+                `Search Speed: ${output.success(result.v3Gains.searchImprovement)}`,
+                `Memory Usage: ${output.success(result.v3Gains.memoryReduction)}`
+            ]);
+            return { success: true, data: result };
+        }
+        catch (error) {
+            if (error instanceof MCPClientError) {
+                output.printError(`Failed to get memory status: ${error.message}`);
+            }
+            else {
+                output.printError(`Unexpected error: ${String(error)}`);
+            }
+            return { success: false, exitCode: 1 };
+        }
+    }
 };
 // Main status command
-export var statusCommand = {
+export const statusCommand = {
     name: 'status',
     description: 'Show system status',
     subcommands: [agentsCommand, tasksCommand, memoryCommand],
@@ -665,20 +559,20 @@ export var statusCommand = {
             short: 'w',
             description: 'Watch mode - continuously update status',
             type: 'boolean',
-            "default": false
+            default: false
         },
         {
             name: 'interval',
             short: 'i',
             description: 'Watch mode update interval in seconds',
             type: 'number',
-            "default": 2
+            default: 2
         },
         {
             name: 'health-check',
             description: 'Perform health checks and exit',
             type: 'boolean',
-            "default": false
+            default: false
         }
     ],
     examples: [