kynjal-cli 3.1.4 → 4.0.0

package/dist/src/commands/status.js

@@ -1,25 +1,61 @@
 /**
  * V3 CLI Status Command
- * System status display for KynjalFlow
+ * 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)
-const DEFAULT_WATCH_INTERVAL = 2000;
+var DEFAULT_WATCH_INTERVAL = 2000;
 // Track CPU usage over time
-let lastCpuUsage = null;
-let lastCpuTime = Date.now();
+var lastCpuUsage = null;
+var lastCpuTime = Date.now();
 // Get real process CPU usage percentage
 function getProcessCpuUsage() {
-    const cpuUsage = process.cpuUsage(lastCpuUsage ? { user: lastCpuUsage.user, system: lastCpuUsage.system } : undefined);
-    const now = Date.now();
-    const elapsed = now - lastCpuTime;
+    var cpuUsage = process.cpuUsage(lastCpuUsage ? { user: lastCpuUsage.user, system: lastCpuUsage.system } : undefined);
+    var now = Date.now();
+    var elapsed = now - lastCpuTime;
     // Calculate percentage (cpuUsage is in microseconds)
-    const totalCpu = (cpuUsage.user + cpuUsage.system) / 1000; // Convert to ms
-    const percentage = elapsed > 0 ? (totalCpu / elapsed) * 100 : 0;
+    var totalCpu = (cpuUsage.user + cpuUsage.system) / 1000; // Convert to ms
+    var percentage = elapsed > 0 ? (totalCpu / elapsed) * 100 : 0;
     // Update for next call
     lastCpuUsage = cpuUsage;
     lastCpuTime = now;
@@ -27,132 +63,146 @@ function getProcessCpuUsage() {
 }
 // Get real process memory usage percentage
 function getProcessMemoryUsage() {
-    const memoryUsage = process.memoryUsage();
-    const totalMemory = os.totalmem();
-    const usedMemory = memoryUsage.heapUsed + memoryUsage.external;
+    var memoryUsage = process.memoryUsage();
+    var totalMemory = os.totalmem();
+    var usedMemory = memoryUsage.heapUsed + memoryUsage.external;
     return (usedMemory / totalMemory) * 100;
 }
 // Check if project is initialized
 function isInitialized(cwd) {
-    const configPath = path.join(cwd, '.claude-flow', 'config.yaml');
+    var configPath = path.join(cwd, '.claude-flow', 'config.yaml');
     return fs.existsSync(configPath);
 }
 // Format uptime
 function formatUptime(ms) {
-    const seconds = Math.floor(ms / 1000);
-    const minutes = Math.floor(seconds / 60);
-    const hours = Math.floor(minutes / 60);
-    const days = Math.floor(hours / 24);
+    var seconds = Math.floor(ms / 1000);
+    var minutes = Math.floor(seconds / 60);
+    var hours = Math.floor(minutes / 60);
+    var 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';
-    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]}`;
+    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];
 }
 // Get system status data
-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'
+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*/];
             }
-        };
-    }
+        });
+    });
 }
 // Display status in text format
 function displayStatus(status) {
     output.writeln();
     // Header with overall status
-    const statusIcon = status.running
+    var statusIcon = status.running
         ? output.success('[RUNNING]')
         : output.warning('[STOPPED]');
-    output.writeln(`${output.bold('KynjalFlow V3')} ${statusIcon}`);
+    output.writeln(output.bold('RuFlo V3') + " " + statusIcon);
     output.writeln();
     // Swarm section
     output.writeln(output.bold('Swarm'));
@@ -215,15 +265,20 @@ 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();
     // MCP section
     output.writeln(output.bold('MCP Server'));
     if (status.mcp.running) {
-        output.printInfo(`  Running on port ${status.mcp.port} (${status.mcp.transport})`);
+        if (status.mcp.transport === 'stdio') {
+            output.printInfo('  Running (stdio mode)');
+        }
+        else {
+            output.printInfo("  Running on port " + status.mcp.port + " (" + status.mcp.transport + ")");
+        }
     }
     else {
         output.printInfo('  Not running');
@@ -233,10 +288,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) + "%"
         ]);
     }
 }
@@ -255,294 +310,352 @@ function formatHealth(health) {
     }
 }
 // Main status action
-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('KynjalFlow is not initialized in this directory');
-        output.printInfo('Run "claude-flow 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
-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'
+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 }];
+        }
     });
-    // 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 ? `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`
+}); };
+// 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 } }
+                }];
         });
-    }
-    // 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
-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 });
+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 });
+                            });
+                        })];
+            }
         });
     });
 }
 // Agents subcommand
-const agentsCommand = {
+var agentsCommand = {
     name: 'agents',
     description: 'Show detailed agent status',
-    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)}`);
+    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*/];
             }
-            return { success: false, exitCode: 1 };
-        }
-    }
+        });
+    }); }
 };
 // Tasks subcommand
-const tasksCommand = {
+var tasksCommand = {
     name: 'tasks',
     description: 'Show detailed task status',
-    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)}`);
+    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*/];
             }
-            return { success: false, exitCode: 1 };
-        }
-    }
+        });
+    }); }
 };
 // Memory subcommand
-const memoryCommand = {
+var memoryCommand = {
     name: 'memory',
     description: 'Show detailed memory status',
-    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}`);
+    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*/];
             }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
-            }
-            return { success: false, exitCode: 1 };
-        }
-    }
+        });
+    }); }
 };
 // Main status command
-export const statusCommand = {
+export var statusCommand = {
     name: 'status',
     description: 'Show system status',
     subcommands: [agentsCommand, tasksCommand, memoryCommand],
@@ -552,20 +665,20 @@ export const 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: [