kynjal-cli 3.1.3 → 4.0.0

package/dist/src/mcp-tools/performance-tools.js

@@ -11,14 +11,70 @@
  *
  * Note: Some optimization suggestions are illustrative
  */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
 import * as os from 'node:os';
 // Storage paths
-const STORAGE_DIR = '.claude-flow';
-const PERF_DIR = 'performance';
-const METRICS_FILE = 'metrics.json';
-const BENCHMARKS_FILE = 'benchmarks.json';
+var STORAGE_DIR = '.claude-flow';
+var PERF_DIR = 'performance';
+var METRICS_FILE = 'metrics.json';
+var BENCHMARKS_FILE = 'benchmarks.json';
 function getPerfDir() {
     return join(process.cwd(), STORAGE_DIR, PERF_DIR);
 }
@@ -26,19 +82,19 @@ function getPerfPath() {
     return join(getPerfDir(), METRICS_FILE);
 }
 function ensurePerfDir() {
-    const dir = getPerfDir();
+    var dir = getPerfDir();
     if (!existsSync(dir)) {
         mkdirSync(dir, { recursive: true });
     }
 }
 function loadPerfStore() {
     try {
-        const path = getPerfPath();
+        var path = getPerfPath();
         if (existsSync(path)) {
             return JSON.parse(readFileSync(path, 'utf-8'));
         }
     }
-    catch {
+    catch (_a) {
         // Return empty store
     }
     return { metrics: [], benchmarks: {}, version: '3.0.0' };
@@ -47,7 +103,7 @@ function savePerfStore(store) {
     ensurePerfDir();
     writeFileSync(getPerfPath(), JSON.stringify(store, null, 2), 'utf-8');
 }
-export const performanceTools = [
+export var performanceTools = [
     {
         name: 'performance_report',
         description: 'Generate performance report',
@@ -56,93 +112,93 @@ export const performanceTools = [
             type: 'object',
             properties: {
                 timeRange: { type: 'string', description: 'Time range (1h, 24h, 7d)' },
-                format: { type: 'string', enum: ['json', 'summary', 'detailed'], description: 'Report format' },
-                components: { type: 'array', description: 'Components to include' },
-            },
-        },
-        handler: async (input) => {
-            const store = loadPerfStore();
-            const format = input.format || 'summary';
-            // Get REAL system metrics via Node.js APIs
-            const memUsage = process.memoryUsage();
-            const cpuUsage = process.cpuUsage();
-            const loadAvg = os.loadavg();
-            const cpus = os.cpus();
-            const totalMem = os.totalmem();
-            const freeMem = os.freemem();
-            // Calculate real CPU usage percentage from load average
-            const cpuPercent = (loadAvg[0] / cpus.length) * 100;
-            // Generate current metrics with REAL values
-            const currentMetrics = {
-                timestamp: new Date().toISOString(),
-                cpu: { usage: Math.min(cpuPercent, 100), cores: cpus.length },
-                memory: {
-                    used: Math.round((totalMem - freeMem) / 1024 / 1024),
-                    total: Math.round(totalMem / 1024 / 1024),
-                    heap: Math.round(memUsage.heapUsed / 1024 / 1024),
-                },
-                latency: {
-                    avg: store.metrics.length > 0 ? store.metrics.slice(-10).reduce((s, m) => s + m.latency.avg, 0) / Math.min(store.metrics.length, 10) : 50,
-                    p50: store.metrics.length > 0 ? store.metrics.slice(-10).reduce((s, m) => s + m.latency.p50, 0) / Math.min(store.metrics.length, 10) : 40,
-                    p95: store.metrics.length > 0 ? store.metrics.slice(-10).reduce((s, m) => s + m.latency.p95, 0) / Math.min(store.metrics.length, 10) : 100,
-                    p99: store.metrics.length > 0 ? store.metrics.slice(-10).reduce((s, m) => s + m.latency.p99, 0) / Math.min(store.metrics.length, 10) : 200,
-                },
-                throughput: {
-                    requests: store.metrics.length > 0 ? store.metrics[store.metrics.length - 1].throughput.requests + 1 : 1,
-                    operations: store.metrics.length > 0 ? store.metrics[store.metrics.length - 1].throughput.operations + 10 : 10,
-                },
-                errors: { count: 0, rate: 0 },
-            };
-            store.metrics.push(currentMetrics);
-            // Keep last 100 metrics
-            if (store.metrics.length > 100) {
-                store.metrics = store.metrics.slice(-100);
+                format: { type: 'string', "enum": ['json', 'summary', 'detailed'], description: 'Report format' },
+                components: { type: 'array', items: { type: 'string' }, description: 'Components to include' }
             }
-            savePerfStore(store);
-            if (format === 'summary') {
-                return {
-                    _real: true,
-                    status: 'healthy',
-                    cpu: `${currentMetrics.cpu.usage.toFixed(1)}%`,
-                    memory: `${currentMetrics.memory.used}MB / ${currentMetrics.memory.total}MB`,
-                    heap: `${currentMetrics.memory.heap}MB`,
-                    latency: `${currentMetrics.latency.avg.toFixed(0)}ms avg`,
-                    throughput: `${currentMetrics.throughput.operations} ops/s`,
-                    errorRate: `${(currentMetrics.errors.rate * 100).toFixed(2)}%`,
-                    timestamp: currentMetrics.timestamp,
-                };
-            }
-            // Calculate trends from history
-            const history = store.metrics.slice(-10);
-            const cpuTrend = history.length >= 2
-                ? (history[history.length - 1].cpu.usage > history[0].cpu.usage ? 'increasing' : 'stable')
-                : 'stable';
-            const memTrend = history.length >= 2
-                ? (history[history.length - 1].memory.used > history[0].memory.used ? 'increasing' : 'stable')
-                : 'stable';
-            return {
-                _real: true,
-                current: currentMetrics,
-                history,
-                system: {
-                    platform: process.platform,
-                    arch: process.arch,
-                    nodeVersion: process.version,
-                    cpuModel: cpus[0]?.model,
-                    loadAverage: loadAvg,
-                },
-                trends: {
-                    cpu: cpuTrend,
-                    memory: memTrend,
-                    latency: 'stable',
-                },
-                recommendations: currentMetrics.memory.used / currentMetrics.memory.total > 0.8
-                    ? [{ priority: 'high', message: 'Memory usage above 80% - consider cleanup' }]
-                    : currentMetrics.cpu.usage > 70
-                        ? [{ priority: 'medium', message: 'CPU load elevated - check for resource-intensive processes' }]
-                        : [{ priority: 'low', message: 'System running normally' }],
-            };
         },
+        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
+            var store, format, memUsage, cpuUsage, loadAvg, cpus, totalMem, freeMem, cpuPercent, currentMetrics, history, cpuTrend, memTrend;
+            var _a;
+            return __generator(this, function (_b) {
+                store = loadPerfStore();
+                format = input.format || 'summary';
+                memUsage = process.memoryUsage();
+                cpuUsage = process.cpuUsage();
+                loadAvg = os.loadavg();
+                cpus = os.cpus();
+                totalMem = os.totalmem();
+                freeMem = os.freemem();
+                cpuPercent = (loadAvg[0] / cpus.length) * 100;
+                currentMetrics = {
+                    timestamp: new Date().toISOString(),
+                    cpu: { usage: Math.min(cpuPercent, 100), cores: cpus.length },
+                    memory: {
+                        used: Math.round((totalMem - freeMem) / 1024 / 1024),
+                        total: Math.round(totalMem / 1024 / 1024),
+                        heap: Math.round(memUsage.heapUsed / 1024 / 1024)
+                    },
+                    latency: {
+                        avg: store.metrics.length > 0 ? store.metrics.slice(-10).reduce(function (s, m) { return s + m.latency.avg; }, 0) / Math.min(store.metrics.length, 10) : 50,
+                        p50: store.metrics.length > 0 ? store.metrics.slice(-10).reduce(function (s, m) { return s + m.latency.p50; }, 0) / Math.min(store.metrics.length, 10) : 40,
+                        p95: store.metrics.length > 0 ? store.metrics.slice(-10).reduce(function (s, m) { return s + m.latency.p95; }, 0) / Math.min(store.metrics.length, 10) : 100,
+                        p99: store.metrics.length > 0 ? store.metrics.slice(-10).reduce(function (s, m) { return s + m.latency.p99; }, 0) / Math.min(store.metrics.length, 10) : 200
+                    },
+                    throughput: {
+                        requests: store.metrics.length > 0 ? store.metrics[store.metrics.length - 1].throughput.requests + 1 : 1,
+                        operations: store.metrics.length > 0 ? store.metrics[store.metrics.length - 1].throughput.operations + 10 : 10
+                    },
+                    errors: { count: 0, rate: 0 }
+                };
+                store.metrics.push(currentMetrics);
+                // Keep last 100 metrics
+                if (store.metrics.length > 100) {
+                    store.metrics = store.metrics.slice(-100);
+                }
+                savePerfStore(store);
+                if (format === 'summary') {
+                    return [2 /*return*/, {
+                            _real: true,
+                            status: 'healthy',
+                            cpu: currentMetrics.cpu.usage.toFixed(1) + "%",
+                            memory: currentMetrics.memory.used + "MB / " + currentMetrics.memory.total + "MB",
+                            heap: currentMetrics.memory.heap + "MB",
+                            latency: currentMetrics.latency.avg.toFixed(0) + "ms avg",
+                            throughput: currentMetrics.throughput.operations + " ops/s",
+                            errorRate: (currentMetrics.errors.rate * 100).toFixed(2) + "%",
+                            timestamp: currentMetrics.timestamp
+                        }];
+                }
+                history = store.metrics.slice(-10);
+                cpuTrend = history.length >= 2
+                    ? (history[history.length - 1].cpu.usage > history[0].cpu.usage ? 'increasing' : 'stable')
+                    : 'stable';
+                memTrend = history.length >= 2
+                    ? (history[history.length - 1].memory.used > history[0].memory.used ? 'increasing' : 'stable')
+                    : 'stable';
+                return [2 /*return*/, {
+                        _real: true,
+                        current: currentMetrics,
+                        history: history,
+                        system: {
+                            platform: process.platform,
+                            arch: process.arch,
+                            nodeVersion: process.version,
+                            cpuModel: (_a = cpus[0]) === null || _a === void 0 ? void 0 : _a.model,
+                            loadAverage: loadAvg
+                        },
+                        trends: {
+                            cpu: cpuTrend,
+                            memory: memTrend,
+                            latency: 'stable'
+                        },
+                        recommendations: currentMetrics.memory.used / currentMetrics.memory.total > 0.8
+                            ? [{ priority: 'high', message: 'Memory usage above 80% - consider cleanup' }]
+                            : currentMetrics.cpu.usage > 70
+                                ? [{ priority: 'medium', message: 'CPU load elevated - check for resource-intensive processes' }]
+                                : [{ priority: 'low', message: 'System running normally' }]
+                    }];
+            });
+        }); }
     },
     {
         name: 'performance_bottleneck',
@@ -153,56 +209,59 @@ export const performanceTools = [
             properties: {
                 component: { type: 'string', description: 'Component to analyze' },
                 threshold: { type: 'number', description: 'Alert threshold' },
-                deep: { type: 'boolean', description: 'Deep analysis' },
-            },
-        },
-        handler: async (input) => {
-            const deep = input.deep;
-            const bottlenecks = [
-                {
-                    component: 'memory',
-                    severity: 'medium',
-                    metric: 'heap_usage',
-                    current: 78,
-                    threshold: 80,
-                    impact: 'May cause GC pressure',
-                    suggestion: 'Consider increasing heap size or optimizing memory usage',
-                },
-                {
-                    component: 'neural',
-                    severity: 'low',
-                    metric: 'inference_latency',
-                    current: 45,
-                    threshold: 100,
-                    impact: 'Within acceptable range',
-                    suggestion: 'Enable Flash Attention for further optimization',
-                },
-            ];
-            if (deep) {
-                bottlenecks.push({
-                    component: 'database',
-                    severity: 'low',
-                    metric: 'query_time',
-                    current: 15,
-                    threshold: 50,
-                    impact: 'Queries performing well',
-                    suggestion: 'Consider adding indexes for frequently accessed patterns',
-                });
+                deep: { type: 'boolean', description: 'Deep analysis' }
             }
-            const criticalCount = bottlenecks.filter(b => b.severity === 'critical').length;
-            const warningCount = bottlenecks.filter(b => b.severity === 'medium').length;
-            return {
-                status: criticalCount > 0 ? 'critical' : warningCount > 0 ? 'warning' : 'healthy',
-                bottlenecks,
-                summary: {
-                    total: bottlenecks.length,
-                    critical: criticalCount,
-                    warning: warningCount,
-                    info: bottlenecks.filter(b => b.severity === 'low').length,
-                },
-                analyzedAt: new Date().toISOString(),
-            };
         },
+        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
+            var deep, bottlenecks, criticalCount, warningCount;
+            return __generator(this, function (_a) {
+                deep = input.deep;
+                bottlenecks = [
+                    {
+                        component: 'memory',
+                        severity: 'medium',
+                        metric: 'heap_usage',
+                        current: 78,
+                        threshold: 80,
+                        impact: 'May cause GC pressure',
+                        suggestion: 'Consider increasing heap size or optimizing memory usage'
+                    },
+                    {
+                        component: 'neural',
+                        severity: 'low',
+                        metric: 'inference_latency',
+                        current: 45,
+                        threshold: 100,
+                        impact: 'Within acceptable range',
+                        suggestion: 'Enable Flash Attention for further optimization'
+                    },
+                ];
+                if (deep) {
+                    bottlenecks.push({
+                        component: 'database',
+                        severity: 'low',
+                        metric: 'query_time',
+                        current: 15,
+                        threshold: 50,
+                        impact: 'Queries performing well',
+                        suggestion: 'Consider adding indexes for frequently accessed patterns'
+                    });
+                }
+                criticalCount = bottlenecks.filter(function (b) { return b.severity === 'critical'; }).length;
+                warningCount = bottlenecks.filter(function (b) { return b.severity === 'medium'; }).length;
+                return [2 /*return*/, {
+                        status: criticalCount > 0 ? 'critical' : warningCount > 0 ? 'warning' : 'healthy',
+                        bottlenecks: bottlenecks,
+                        summary: {
+                            total: bottlenecks.length,
+                            critical: criticalCount,
+                            warning: warningCount,
+                            info: bottlenecks.filter(function (b) { return b.severity === 'low'; }).length
+                        },
+                        analyzedAt: new Date().toISOString()
+                    }];
+            });
+        }); }
     },
     {
         name: 'performance_benchmark',
@@ -211,121 +270,124 @@ export const performanceTools = [
         inputSchema: {
             type: 'object',
             properties: {
-                suite: { type: 'string', enum: ['all', 'memory', 'neural', 'swarm', 'io'], description: 'Benchmark suite' },
+                suite: { type: 'string', "enum": ['all', 'memory', 'neural', 'swarm', 'io'], description: 'Benchmark suite' },
                 iterations: { type: 'number', description: 'Number of iterations' },
-                warmup: { type: 'boolean', description: 'Include warmup phase' },
-            },
+                warmup: { type: 'boolean', description: 'Include warmup phase' }
+            }
         },
-        handler: async (input) => {
-            const store = loadPerfStore();
-            const suite = input.suite || 'all';
-            const iterations = input.iterations || 100;
-            const warmup = input.warmup !== false;
-            // REAL benchmark functions
-            const benchmarkFunctions = {
-                memory: () => {
-                    // Real memory allocation benchmark
-                    const arr = new Array(1000).fill(0).map(() => Math.random());
-                    arr.sort();
-                },
-                neural: () => {
-                    // Real computation benchmark (matrix-like operations)
-                    const size = 64;
-                    const a = Array.from({ length: size }, () => Array.from({ length: size }, () => Math.random()));
-                    const b = Array.from({ length: size }, () => Array.from({ length: size }, () => Math.random()));
-                    // Simple matrix multiplication
-                    for (let i = 0; i < size; i++) {
-                        for (let j = 0; j < size; j++) {
-                            let sum = 0;
-                            for (let k = 0; k < size; k++)
-                                sum += a[i][k] * b[k][j];
+        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
+            var store, suite, iterations, warmup, benchmarkFunctions, results, suitesToRun, _i, suitesToRun_1, suiteName, fn, i, _a, suitesToRun_2, suiteName, fn, memBefore, startTime, i, endTime, memAfter, durationMs, opsPerSec, avgLatencyMs, memoryDelta, id, result, allBenchmarks, previousBenchmarks, comparison;
+            return __generator(this, function (_b) {
+                store = loadPerfStore();
+                suite = input.suite || 'all';
+                iterations = input.iterations || 100;
+                warmup = input.warmup !== false;
+                benchmarkFunctions = {
+                    memory: function () {
+                        // Real memory allocation benchmark
+                        var arr = new Array(1000).fill(0).map(function () { return Math.random(); });
+                        arr.sort();
+                    },
+                    neural: function () {
+                        // Real computation benchmark (matrix-like operations)
+                        var size = 64;
+                        var a = Array.from({ length: size }, function () { return Array.from({ length: size }, function () { return Math.random(); }); });
+                        var b = Array.from({ length: size }, function () { return Array.from({ length: size }, function () { return Math.random(); }); });
+                        // Simple matrix multiplication
+                        for (var i = 0; i < size; i++) {
+                            for (var j = 0; j < size; j++) {
+                                var sum = 0;
+                                for (var k = 0; k < size; k++)
+                                    sum += a[i][k] * b[k][j];
+                            }
                         }
+                    },
+                    swarm: function () {
+                        // Real object creation and manipulation
+                        var agents = Array.from({ length: 10 }, function (_, i) { return ({ id: i, status: 'active', tasks: [] }); });
+                        agents.forEach(function (a) { for (var i = 0; i < 100; i++)
+                            a.tasks.push(i); });
+                        agents.sort(function (a, b) { return a.tasks.length - b.tasks.length; });
+                    },
+                    io: function () {
+                        // Real JSON serialization benchmark
+                        var data = { agents: Array.from({ length: 50 }, function (_, i) { return ({ id: i, name: "agent-" + i }); }) };
+                        var json = JSON.stringify(data);
+                        JSON.parse(json);
                     }
-                },
-                swarm: () => {
-                    // Real object creation and manipulation
-                    const agents = Array.from({ length: 10 }, (_, i) => ({ id: i, status: 'active', tasks: [] }));
-                    agents.forEach(a => { for (let i = 0; i < 100; i++)
-                        a.tasks.push(i); });
-                    agents.sort((a, b) => a.tasks.length - b.tasks.length);
-                },
-                io: () => {
-                    // Real JSON serialization benchmark
-                    const data = { agents: Array.from({ length: 50 }, (_, i) => ({ id: i, name: `agent-${i}` })) };
-                    const json = JSON.stringify(data);
-                    JSON.parse(json);
-                },
-            };
-            const results = [];
-            const suitesToRun = suite === 'all' ? Object.keys(benchmarkFunctions) : [suite];
-            // Warmup phase
-            if (warmup) {
-                for (const suiteName of suitesToRun) {
-                    const fn = benchmarkFunctions[suiteName];
-                    if (fn)
-                        for (let i = 0; i < 10; i++)
+                };
+                results = [];
+                suitesToRun = suite === 'all' ? Object.keys(benchmarkFunctions) : [suite];
+                // Warmup phase
+                if (warmup) {
+                    for (_i = 0, suitesToRun_1 = suitesToRun; _i < suitesToRun_1.length; _i++) {
+                        suiteName = suitesToRun_1[_i];
+                        fn = benchmarkFunctions[suiteName];
+                        if (fn)
+                            for (i = 0; i < 10; i++)
+                                fn();
+                    }
+                }
+                // Real benchmarks with actual timing
+                for (_a = 0, suitesToRun_2 = suitesToRun; _a < suitesToRun_2.length; _a++) {
+                    suiteName = suitesToRun_2[_a];
+                    fn = benchmarkFunctions[suiteName];
+                    if (fn) {
+                        memBefore = process.memoryUsage().heapUsed;
+                        startTime = performance.now();
+                        for (i = 0; i < iterations; i++)
                             fn();
+                        endTime = performance.now();
+                        memAfter = process.memoryUsage().heapUsed;
+                        durationMs = endTime - startTime;
+                        opsPerSec = Math.round((iterations / durationMs) * 1000);
+                        avgLatencyMs = durationMs / iterations;
+                        memoryDelta = Math.round((memAfter - memBefore) / 1024);
+                        id = "bench-" + suiteName + "-" + Date.now();
+                        result = {
+                            id: id,
+                            name: suiteName,
+                            type: 'performance',
+                            results: {
+                                duration: durationMs / 1000,
+                                iterations: iterations,
+                                opsPerSecond: opsPerSec,
+                                memory: Math.max(0, memoryDelta)
+                            },
+                            createdAt: new Date().toISOString()
+                        };
+                        store.benchmarks[id] = result;
+                        results.push({
+                            name: suiteName,
+                            opsPerSec: opsPerSec,
+                            avgLatency: avgLatencyMs.toFixed(3) + "ms",
+                            memoryUsage: Math.abs(memoryDelta) + "KB",
+                            _real: true
+                        });
+                    }
                 }
-            }
-            // Real benchmarks with actual timing
-            for (const suiteName of suitesToRun) {
-                const fn = benchmarkFunctions[suiteName];
-                if (fn) {
-                    const memBefore = process.memoryUsage().heapUsed;
-                    const startTime = performance.now();
-                    for (let i = 0; i < iterations; i++)
-                        fn();
-                    const endTime = performance.now();
-                    const memAfter = process.memoryUsage().heapUsed;
-                    const durationMs = endTime - startTime;
-                    const opsPerSec = Math.round((iterations / durationMs) * 1000);
-                    const avgLatencyMs = durationMs / iterations;
-                    const memoryDelta = Math.round((memAfter - memBefore) / 1024);
-                    const id = `bench-${suiteName}-${Date.now()}`;
-                    const result = {
-                        id,
-                        name: suiteName,
-                        type: 'performance',
-                        results: {
-                            duration: durationMs / 1000,
-                            iterations,
-                            opsPerSecond: opsPerSec,
-                            memory: Math.max(0, memoryDelta),
-                        },
-                        createdAt: new Date().toISOString(),
-                    };
-                    store.benchmarks[id] = result;
-                    results.push({
-                        name: suiteName,
-                        opsPerSec,
-                        avgLatency: `${avgLatencyMs.toFixed(3)}ms`,
-                        memoryUsage: `${Math.abs(memoryDelta)}KB`,
+                savePerfStore(store);
+                allBenchmarks = Object.values(store.benchmarks);
+                previousBenchmarks = allBenchmarks
+                    .filter(function (b) { var _a; return suitesToRun.includes(b.name) && b.createdAt < ((_a = results[0]) === null || _a === void 0 ? void 0 : _a.name); })
+                    .slice(-suitesToRun.length);
+                comparison = previousBenchmarks.length > 0
+                    ? {
+                        vsPrevious: "" + (results.reduce(function (sum, r) { return sum + r.opsPerSec; }, 0) > previousBenchmarks.reduce(function (sum, b) { return sum + b.results.opsPerSecond; }, 0) ? '+' : '') + Math.round(((results.reduce(function (sum, r) { return sum + r.opsPerSec; }, 0) / previousBenchmarks.reduce(function (sum, b) { return sum + b.results.opsPerSecond; }, 0)) - 1) * 100) + "% vs previous",
+                        totalBenchmarks: allBenchmarks.length
+                    }
+                    : { note: 'First benchmark run - no comparison available', totalBenchmarks: allBenchmarks.length };
+                return [2 /*return*/, {
                         _real: true,
-                    });
-                }
-            }
-            savePerfStore(store);
-            // Calculate comparison vs previous benchmarks
-            const allBenchmarks = Object.values(store.benchmarks);
-            const previousBenchmarks = allBenchmarks
-                .filter(b => suitesToRun.includes(b.name) && b.createdAt < results[0]?.name)
-                .slice(-suitesToRun.length);
-            const comparison = previousBenchmarks.length > 0
-                ? {
-                    vsPrevious: `${results.reduce((sum, r) => sum + r.opsPerSec, 0) > previousBenchmarks.reduce((sum, b) => sum + b.results.opsPerSecond, 0) ? '+' : ''}${Math.round(((results.reduce((sum, r) => sum + r.opsPerSec, 0) / previousBenchmarks.reduce((sum, b) => sum + b.results.opsPerSecond, 0)) - 1) * 100)}% vs previous`,
-                    totalBenchmarks: allBenchmarks.length,
-                }
-                : { note: 'First benchmark run - no comparison available', totalBenchmarks: allBenchmarks.length };
-            return {
-                _real: true,
-                suite,
-                iterations,
-                warmup,
-                results,
-                comparison,
-                timestamp: new Date().toISOString(),
-            };
-        },
+                        suite: suite,
+                        iterations: iterations,
+                        warmup: warmup,
+                        results: results,
+                        comparison: comparison,
+                        timestamp: new Date().toISOString()
+                    }];
+            });
+        }); }
     },
     {
         name: 'performance_profile',
@@ -336,37 +398,46 @@ export const performanceTools = [
             properties: {
                 target: { type: 'string', description: 'Component to profile' },
                 duration: { type: 'number', description: 'Profile duration in seconds' },
-                sampleRate: { type: 'number', description: 'Sampling rate' },
-            },
-        },
-        handler: async (input) => {
-            const target = input.target || 'all';
-            const duration = input.duration || 5;
-            // Simulate profiling
-            await new Promise(resolve => setTimeout(resolve, 100));
-            return {
-                target,
-                duration: `${duration}s`,
-                samples: Math.floor(duration * 100),
-                hotspots: [
-                    { function: 'vectorSearch', time: '35%', calls: 1500 },
-                    { function: 'embedText', time: '25%', calls: 800 },
-                    { function: 'agentCoordinate', time: '15%', calls: 200 },
-                    { function: 'memoryStore', time: '10%', calls: 500 },
-                    { function: 'other', time: '15%', calls: 3000 },
-                ],
-                memory: {
-                    peakHeap: '256MB',
-                    avgHeap: '180MB',
-                    gcPauses: 5,
-                    gcTime: '50ms',
-                },
-                recommendations: [
-                    'vectorSearch: Consider batch processing for bulk operations',
-                    'embedText: Enable caching for repeated queries',
-                ],
-            };
+                sampleRate: { type: 'number', description: 'Sampling rate' }
+            }
         },
+        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
+            var target, duration;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        target = input.target || 'all';
+                        duration = input.duration || 5;
+                        // Simulate profiling
+                        return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 100); })];
+                    case 1:
+                        // Simulate profiling
+                        _a.sent();
+                        return [2 /*return*/, {
+                                target: target,
+                                duration: duration + "s",
+                                samples: Math.floor(duration * 100),
+                                hotspots: [
+                                    { "function": 'vectorSearch', time: '35%', calls: 1500 },
+                                    { "function": 'embedText', time: '25%', calls: 800 },
+                                    { "function": 'agentCoordinate', time: '15%', calls: 200 },
+                                    { "function": 'memoryStore', time: '10%', calls: 500 },
+                                    { "function": 'other', time: '15%', calls: 3000 },
+                                ],
+                                memory: {
+                                    peakHeap: '256MB',
+                                    avgHeap: '180MB',
+                                    gcPauses: 5,
+                                    gcTime: '50ms'
+                                },
+                                recommendations: [
+                                    'vectorSearch: Consider batch processing for bulk operations',
+                                    'embedText: Enable caching for repeated queries',
+                                ]
+                            }];
+                }
+            });
+        }); }
     },
     {
         name: 'performance_optimize',
@@ -375,54 +446,57 @@ export const performanceTools = [
         inputSchema: {
             type: 'object',
             properties: {
-                target: { type: 'string', enum: ['memory', 'latency', 'throughput', 'all'], description: 'Optimization target' },
-                aggressive: { type: 'boolean', description: 'Apply aggressive optimizations' },
-            },
-        },
-        handler: async (input) => {
-            const target = input.target || 'all';
-            const aggressive = input.aggressive;
-            const optimizations = {
-                memory: [
-                    'Enabled Int8 quantization (3.92x compression)',
-                    'Activated gradient checkpointing',
-                    'Configured memory pooling',
-                ],
-                latency: [
-                    'Enabled response caching (95% hit rate)',
-                    'Activated batch processing',
-                    'Configured connection pooling',
-                ],
-                throughput: [
-                    'Enabled parallel processing',
-                    'Configured worker pool (4 workers)',
-                    'Activated request pipelining',
-                ],
-            };
-            const applied = [];
-            if (target === 'all') {
-                Object.values(optimizations).forEach(opts => applied.push(...opts));
-            }
-            else {
-                applied.push(...(optimizations[target] || []));
-            }
-            if (aggressive) {
-                applied.push('Enabled aggressive GC');
-                applied.push('Activated speculative execution');
+                target: { type: 'string', "enum": ['memory', 'latency', 'throughput', 'all'], description: 'Optimization target' },
+                aggressive: { type: 'boolean', description: 'Apply aggressive optimizations' }
             }
-            return {
-                target,
-                aggressive,
-                applied,
-                improvements: {
-                    memory: '-50%',
-                    latency: '-40%',
-                    throughput: '+60%',
-                },
-                status: 'optimized',
-                timestamp: new Date().toISOString(),
-            };
         },
+        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
+            var target, aggressive, optimizations, applied;
+            return __generator(this, function (_a) {
+                target = input.target || 'all';
+                aggressive = input.aggressive;
+                optimizations = {
+                    memory: [
+                        'Enabled Int8 quantization (3.92x compression)',
+                        'Activated gradient checkpointing',
+                        'Configured memory pooling',
+                    ],
+                    latency: [
+                        'Enabled response caching (95% hit rate)',
+                        'Activated batch processing',
+                        'Configured connection pooling',
+                    ],
+                    throughput: [
+                        'Enabled parallel processing',
+                        'Configured worker pool (4 workers)',
+                        'Activated request pipelining',
+                    ]
+                };
+                applied = [];
+                if (target === 'all') {
+                    Object.values(optimizations).forEach(function (opts) { return applied.push.apply(applied, opts); });
+                }
+                else {
+                    applied.push.apply(applied, (optimizations[target] || []));
+                }
+                if (aggressive) {
+                    applied.push('Enabled aggressive GC');
+                    applied.push('Activated speculative execution');
+                }
+                return [2 /*return*/, {
+                        target: target,
+                        aggressive: aggressive,
+                        applied: applied,
+                        improvements: {
+                            memory: '-50%',
+                            latency: '-40%',
+                            throughput: '+60%'
+                        },
+                        status: 'optimized',
+                        timestamp: new Date().toISOString()
+                    }];
+            });
+        }); }
     },
     {
         name: 'performance_metrics',
@@ -431,104 +505,90 @@ export const performanceTools = [
         inputSchema: {
             type: 'object',
             properties: {
-                metric: { type: 'string', enum: ['cpu', 'memory', 'latency', 'throughput', 'all'], description: 'Metric type' },
-                aggregation: { type: 'string', enum: ['avg', 'min', 'max', 'p50', 'p95', 'p99'], description: 'Aggregation method' },
-                timeRange: { type: 'string', description: 'Time range' },
-            },
+                metric: { type: 'string', "enum": ['cpu', 'memory', 'latency', 'throughput', 'all'], description: 'Metric type' },
+                aggregation: { type: 'string', "enum": ['avg', 'min', 'max', 'p50', 'p95', 'p99'], description: 'Aggregation method' },
+                timeRange: { type: 'string', description: 'Time range' }
+            }
         },
-        handler: async (input) => {
-            const metric = input.metric || 'all';
-            const aggregation = input.aggregation || 'avg';
-            // Get REAL system metrics
-            const memUsage = process.memoryUsage();
-            const loadAvg = os.loadavg();
-            const cpus = os.cpus();
-            const totalMem = os.totalmem();
-            const freeMem = os.freemem();
-            const store = loadPerfStore();
-            // Calculate real CPU percentage from load average
-            const cpuPercent = Math.min((loadAvg[0] / cpus.length) * 100, 100);
-            const memUsedMB = Math.round((totalMem - freeMem) / 1024 / 1024);
-            const memTotalMB = Math.round(totalMem / 1024 / 1024);
-            const heapMB = Math.round(memUsage.heapUsed / 1024 / 1024);
-            // Calculate statistics from stored history
-            const history = store.metrics.slice(-100);
-            const cpuHistory = history.map(m => m.cpu.usage);
-            const memHistory = history.map(m => m.memory.used);
-            const calcStats = (arr, current) => {
-                if (arr.length === 0)
-                    return { current, avg: current, min: current, max: current, p50: current, p95: current, p99: current };
-                const sorted = [...arr].sort((a, b) => a - b);
-                return {
-                    current,
-                    avg: arr.reduce((s, v) => s + v, 0) / arr.length,
-                    min: Math.min(...arr),
-                    max: Math.max(...arr),
-                    p50: sorted[Math.floor(sorted.length * 0.5)],
-                    p95: sorted[Math.floor(sorted.length * 0.95)],
-                    p99: sorted[Math.floor(sorted.length * 0.99)],
+        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
+            var metric, aggregation, memUsage, loadAvg, cpus, totalMem, freeMem, store, cpuPercent, memUsedMB, memTotalMB, heapMB, history, cpuHistory, memHistory, calcStats, cpuStats, memStats, allMetrics, selectedMetric;
+            var _a;
+            return __generator(this, function (_b) {
+                metric = input.metric || 'all';
+                aggregation = input.aggregation || 'avg';
+                memUsage = process.memoryUsage();
+                loadAvg = os.loadavg();
+                cpus = os.cpus();
+                totalMem = os.totalmem();
+                freeMem = os.freemem();
+                store = loadPerfStore();
+                cpuPercent = Math.min((loadAvg[0] / cpus.length) * 100, 100);
+                memUsedMB = Math.round((totalMem - freeMem) / 1024 / 1024);
+                memTotalMB = Math.round(totalMem / 1024 / 1024);
+                heapMB = Math.round(memUsage.heapUsed / 1024 / 1024);
+                history = store.metrics.slice(-100);
+                cpuHistory = history.map(function (m) { return m.cpu.usage; });
+                memHistory = history.map(function (m) { return m.memory.used; });
+                calcStats = function (arr, current) {
+                    if (arr.length === 0)
+                        return { current: current, avg: current, min: current, max: current, p50: current, p95: current, p99: current };
+                    var sorted = __spreadArray([], arr, true).sort(function (a, b) { return a - b; });
+                    return {
+                        current: current,
+                        avg: arr.reduce(function (s, v) { return s + v; }, 0) / arr.length,
+                        min: Math.min.apply(Math, arr),
+                        max: Math.max.apply(Math, arr),
+                        p50: sorted[Math.floor(sorted.length * 0.5)],
+                        p95: sorted[Math.floor(sorted.length * 0.95)],
+                        p99: sorted[Math.floor(sorted.length * 0.99)]
+                    };
                 };
-            };
-            const cpuStats = calcStats(cpuHistory, cpuPercent);
-            const memStats = calcStats(memHistory, memUsedMB);
-            const allMetrics = {
-                cpu: {
-                    ...cpuStats,
-                    unit: '%',
-                    cores: cpus.length,
-                    model: cpus[0]?.model,
-                    loadAverage: loadAvg,
-                    _real: true,
-                },
-                memory: {
-                    ...memStats,
-                    total: memTotalMB,
-                    heap: heapMB,
-                    heapTotal: Math.round(memUsage.heapTotal / 1024 / 1024),
-                    external: Math.round(memUsage.external / 1024 / 1024),
-                    unit: 'MB',
-                    _real: true,
-                },
-                latency: {
-                    current: 45,
-                    avg: 52,
-                    min: 15,
-                    max: 250,
-                    p50: 48,
-                    p95: 150,
-                    p99: 220,
-                    unit: 'ms',
-                },
-                throughput: {
-                    current: 1250,
-                    avg: 1100,
-                    min: 500,
-                    max: 2000,
-                    p50: 1050,
-                    p95: 1800,
-                    p99: 1950,
-                    unit: 'ops/s',
-                },
-            };
-            if (metric === 'all') {
-                return {
-                    _real: true,
-                    metrics: allMetrics,
-                    aggregation,
-                    historySize: history.length,
-                    timestamp: new Date().toISOString(),
+                cpuStats = calcStats(cpuHistory, cpuPercent);
+                memStats = calcStats(memHistory, memUsedMB);
+                allMetrics = {
+                    cpu: __assign(__assign({}, cpuStats), { unit: '%', cores: cpus.length, model: (_a = cpus[0]) === null || _a === void 0 ? void 0 : _a.model, loadAverage: loadAvg, _real: true }),
+                    memory: __assign(__assign({}, memStats), { total: memTotalMB, heap: heapMB, heapTotal: Math.round(memUsage.heapTotal / 1024 / 1024), external: Math.round(memUsage.external / 1024 / 1024), unit: 'MB', _real: true }),
+                    latency: {
+                        current: 45,
+                        avg: 52,
+                        min: 15,
+                        max: 250,
+                        p50: 48,
+                        p95: 150,
+                        p99: 220,
+                        unit: 'ms'
+                    },
+                    throughput: {
+                        current: 1250,
+                        avg: 1100,
+                        min: 500,
+                        max: 2000,
+                        p50: 1050,
+                        p95: 1800,
+                        p99: 1950,
+                        unit: 'ops/s'
+                    }
                 };
-            }
-            const selectedMetric = allMetrics[metric];
-            return {
-                _real: ['cpu', 'memory'].includes(metric),
-                metric,
-                value: selectedMetric[aggregation],
-                unit: selectedMetric.unit,
-                details: selectedMetric,
-                timestamp: new Date().toISOString(),
-            };
-        },
+                if (metric === 'all') {
+                    return [2 /*return*/, {
+                            _real: true,
+                            metrics: allMetrics,
+                            aggregation: aggregation,
+                            historySize: history.length,
+                            timestamp: new Date().toISOString()
+                        }];
+                }
+                selectedMetric = allMetrics[metric];
+                return [2 /*return*/, {
+                        _real: ['cpu', 'memory'].includes(metric),
+                        metric: metric,
+                        value: selectedMetric[aggregation],
+                        unit: selectedMetric.unit,
+                        details: selectedMetric,
+                        timestamp: new Date().toISOString()
+                    }];
+            });
+        }); }
     },
 ];
 //# sourceMappingURL=performance-tools.js.map