tachibot-mcp 2.0.2

package/dist/src/monitoring/performance-monitor.js

@@ -0,0 +1,435 @@
+import { EventEmitter } from 'events';
+/**
+ * Performance monitoring for workflow execution
+ */
+export class PerformanceMonitor extends EventEmitter {
+    constructor() {
+        super();
+        this.metrics = [];
+        this.systemMetrics = [];
+        this.costModels = new Map();
+        this.activeRequests = new Map();
+        this.metricsRetention = 3600000; // 1 hour default
+        this.initializeCostModels();
+        this.startAggregation();
+        this.startSystemMonitoring();
+    }
+    /**
+     * Initialize cost models for different AI providers
+     */
+    initializeCostModels() {
+        // GPT-5 flagship
+        this.costModels.set('gpt5', {
+            model: 'gpt5',
+            inputTokenCost: 0.00125,
+            outputTokenCost: 0.01
+        });
+        // Gemini 2.5 Pro
+        this.costModels.set('gemini_25_pro', {
+            model: 'gemini_25_pro',
+            inputTokenCost: 0.00125,
+            outputTokenCost: 0.005
+        });
+        // GPT-5-mini (cost-effective, balanced)
+        this.costModels.set('gpt5_mini', {
+            model: 'gpt5_mini',
+            inputTokenCost: 0.00075,
+            outputTokenCost: 0.003
+        });
+        // Perplexity
+        this.costModels.set('perplexity', {
+            model: 'perplexity',
+            inputTokenCost: 0.001,
+            outputTokenCost: 0.001
+        });
+        // Focus deep reasoning (expensive)
+        this.costModels.set('focus', {
+            model: 'focus',
+            inputTokenCost: 0.005,
+            outputTokenCost: 0.02,
+            baseCost: 0.01
+        });
+    }
+    /**
+     * Start tracking a request
+     */
+    startRequest(requestId, tool) {
+        this.activeRequests.set(requestId, {
+            start: Date.now(),
+            tool
+        });
+        this.emit('request-started', { requestId, tool });
+    }
+    /**
+     * Complete tracking a request
+     */
+    completeRequest(requestId, success, tokensUsed, error, metadata) {
+        const request = this.activeRequests.get(requestId);
+        if (!request)
+            return;
+        const duration = Date.now() - request.start;
+        const cost = this.calculateCost(request.tool, tokensUsed);
+        const metric = {
+            timestamp: Date.now(),
+            requestId,
+            tool: request.tool,
+            duration,
+            tokensUsed: {
+                input: tokensUsed?.input || 0,
+                output: tokensUsed?.output || 0,
+                total: (tokensUsed?.input || 0) + (tokensUsed?.output || 0)
+            },
+            cost,
+            success,
+            error,
+            metadata
+        };
+        this.metrics.push(metric);
+        this.activeRequests.delete(requestId);
+        // Clean old metrics
+        this.cleanOldMetrics();
+        // Emit events
+        this.emit('request-completed', metric);
+        // Check for performance issues
+        this.checkPerformanceAlerts(metric);
+    }
+    /**
+     * Calculate cost based on token usage
+     */
+    calculateCost(tool, tokensUsed) {
+        if (!tokensUsed)
+            return 0;
+        const costModel = this.costModels.get(tool);
+        if (!costModel)
+            return 0;
+        const inputCost = (tokensUsed.input / 1000) * costModel.inputTokenCost;
+        const outputCost = (tokensUsed.output / 1000) * costModel.outputTokenCost;
+        const baseCost = costModel.baseCost || 0;
+        return inputCost + outputCost + baseCost;
+    }
+    /**
+     * Check for performance alerts
+     */
+    checkPerformanceAlerts(metric) {
+        // Slow response alert
+        if (metric.duration > 30000) {
+            this.emit('slow-response-alert', {
+                tool: metric.tool,
+                duration: metric.duration,
+                requestId: metric.requestId
+            });
+        }
+        // High cost alert
+        if (metric.cost > 0.1) {
+            this.emit('high-cost-alert', {
+                tool: metric.tool,
+                cost: metric.cost,
+                tokens: metric.tokensUsed.total,
+                requestId: metric.requestId
+            });
+        }
+        // High token usage alert (potential 25k limit issue)
+        if (metric.tokensUsed.total > 20000) {
+            this.emit('high-token-alert', {
+                tool: metric.tool,
+                tokens: metric.tokensUsed.total,
+                requestId: metric.requestId,
+                warning: 'Approaching 25k token limit'
+            });
+        }
+        // Error rate alert
+        if (!metric.success) {
+            const recentErrors = this.getRecentErrorRate();
+            if (recentErrors > 0.3) {
+                this.emit('high-error-rate', {
+                    errorRate: recentErrors,
+                    tool: metric.tool
+                });
+            }
+        }
+    }
+    /**
+     * Get recent error rate
+     */
+    getRecentErrorRate() {
+        const recent = this.getRecentMetrics(5); // Last 5 minutes
+        if (recent.length === 0)
+            return 0;
+        const errors = recent.filter(m => !m.success).length;
+        return errors / recent.length;
+    }
+    /**
+     * Get recent metrics
+     */
+    getRecentMetrics(minutes) {
+        const cutoff = Date.now() - (minutes * 60 * 1000);
+        return this.metrics.filter(m => m.timestamp > cutoff);
+    }
+    /**
+     * Start aggregation interval
+     */
+    startAggregation() {
+        this.aggregationInterval = setInterval(() => {
+            const aggregated = this.aggregateMetrics();
+            this.emit('metrics-aggregated', aggregated);
+        }, 60000); // Every minute
+    }
+    /**
+     * Start system monitoring
+     */
+    startSystemMonitoring() {
+        this.systemMonitorInterval = setInterval(() => {
+            const metrics = this.collectSystemMetrics();
+            this.systemMetrics.push(metrics);
+            this.emit('system-metrics', metrics);
+            // Clean old system metrics
+            const cutoff = Date.now() - this.metricsRetention;
+            this.systemMetrics = this.systemMetrics.filter(m => m.timestamp > cutoff);
+        }, 10000); // Every 10 seconds
+    }
+    /**
+     * Collect system metrics
+     */
+    collectSystemMetrics() {
+        const memUsage = process.memoryUsage();
+        const cpuUsage = process.cpuUsage();
+        return {
+            timestamp: Date.now(),
+            activeTasks: this.activeRequests.size,
+            queuedTasks: 0, // Would come from message queue
+            memoryUsage: memUsage.heapUsed / 1024 / 1024, // MB
+            cpuUsage: (cpuUsage.user + cpuUsage.system) / 1000000, // seconds
+            networkLatency: 0, // Would need actual measurement
+            errorRate: this.getRecentErrorRate(),
+            systemHealth: this.calculateSystemHealth()
+        };
+    }
+    /**
+     * Calculate system health score
+     */
+    calculateSystemHealth() {
+        let health = 1.0;
+        // Deduct for high error rate
+        const errorRate = this.getRecentErrorRate();
+        if (errorRate > 0.1)
+            health -= 0.3;
+        if (errorRate > 0.3)
+            health -= 0.3;
+        // Deduct for slow responses
+        const recent = this.getRecentMetrics(5);
+        const avgDuration = recent.length > 0
+            ? recent.reduce((sum, m) => sum + m.duration, 0) / recent.length
+            : 0;
+        if (avgDuration > 10000)
+            health -= 0.2;
+        if (avgDuration > 30000)
+            health -= 0.2;
+        // Deduct for high memory usage
+        const memUsage = process.memoryUsage().heapUsed / 1024 / 1024;
+        if (memUsage > 500)
+            health -= 0.1;
+        if (memUsage > 1000)
+            health -= 0.2;
+        return Math.max(health, 0);
+    }
+    /**
+     * Aggregate metrics by tool
+     */
+    aggregateMetrics() {
+        const aggregated = new Map();
+        const recent = this.getRecentMetrics(60); // Last hour
+        // Group by tool
+        const byTool = new Map();
+        for (const metric of recent) {
+            if (!byTool.has(metric.tool)) {
+                byTool.set(metric.tool, []);
+            }
+            byTool.get(metric.tool).push(metric);
+        }
+        // Aggregate each tool
+        for (const [tool, metrics] of byTool.entries()) {
+            const durations = metrics.map(m => m.duration).sort((a, b) => a - b);
+            const successful = metrics.filter(m => m.success).length;
+            const agg = {
+                tool,
+                totalRequests: metrics.length,
+                successRate: successful / metrics.length,
+                avgDuration: durations.reduce((a, b) => a + b, 0) / durations.length,
+                p50Duration: this.percentile(durations, 0.5),
+                p95Duration: this.percentile(durations, 0.95),
+                p99Duration: this.percentile(durations, 0.99),
+                totalTokens: metrics.reduce((sum, m) => sum + m.tokensUsed.total, 0),
+                totalCost: metrics.reduce((sum, m) => sum + m.cost, 0),
+                avgTokensPerRequest: 0,
+                avgCostPerRequest: 0,
+                throughput: 0
+            };
+            agg.avgTokensPerRequest = agg.totalTokens / metrics.length;
+            agg.avgCostPerRequest = agg.totalCost / metrics.length;
+            // Calculate throughput (requests per second)
+            if (metrics.length > 1) {
+                const timeSpan = metrics[metrics.length - 1].timestamp - metrics[0].timestamp;
+                agg.throughput = (metrics.length / timeSpan) * 1000;
+            }
+            aggregated.set(tool, agg);
+        }
+        return aggregated;
+    }
+    /**
+     * Calculate percentile
+     */
+    percentile(sorted, p) {
+        if (sorted.length === 0)
+            return 0;
+        const index = Math.ceil(sorted.length * p) - 1;
+        return sorted[Math.max(0, Math.min(index, sorted.length - 1))];
+    }
+    /**
+     * Clean old metrics
+     */
+    cleanOldMetrics() {
+        const cutoff = Date.now() - this.metricsRetention;
+        this.metrics = this.metrics.filter(m => m.timestamp > cutoff);
+    }
+    /**
+     * Get dashboard data
+     */
+    getDashboardData() {
+        const aggregated = this.aggregateMetrics();
+        const recent = this.getRecentMetrics(5);
+        const latestSystem = this.systemMetrics[this.systemMetrics.length - 1] || null;
+        // Calculate cost breakdown
+        const costBreakdown = [];
+        let totalCost = 0;
+        for (const [tool, metrics] of aggregated.entries()) {
+            totalCost += metrics.totalCost;
+            costBreakdown.push({
+                tool,
+                cost: metrics.totalCost,
+                percentage: 0
+            });
+        }
+        // Calculate percentages
+        for (const item of costBreakdown) {
+            item.percentage = totalCost > 0 ? (item.cost / totalCost) * 100 : 0;
+        }
+        // Sort by cost
+        costBreakdown.sort((a, b) => b.cost - a.cost);
+        // Generate alerts
+        const alerts = [];
+        if (latestSystem) {
+            if (latestSystem.errorRate > 0.3) {
+                alerts.push(`High error rate: ${(latestSystem.errorRate * 100).toFixed(1)}%`);
+            }
+            if (latestSystem.systemHealth < 0.5) {
+                alerts.push(`Low system health: ${(latestSystem.systemHealth * 100).toFixed(0)}%`);
+            }
+            if (latestSystem.memoryUsage > 1000) {
+                alerts.push(`High memory usage: ${latestSystem.memoryUsage.toFixed(0)}MB`);
+            }
+        }
+        // Check for expensive tools
+        for (const [tool, metrics] of aggregated.entries()) {
+            if (metrics.avgCostPerRequest > 0.05) {
+                alerts.push(`High cost for ${tool}: $${metrics.avgCostPerRequest.toFixed(3)}/request`);
+            }
+        }
+        return {
+            currentRequests: this.activeRequests.size,
+            recentMetrics: recent,
+            aggregatedMetrics: aggregated,
+            systemMetrics: latestSystem,
+            costBreakdown,
+            performanceAlerts: alerts
+        };
+    }
+    /**
+     * Get cost optimization recommendations
+     */
+    getCostOptimizationRecommendations() {
+        const recommendations = [];
+        const aggregated = this.aggregateMetrics();
+        for (const [tool, metrics] of aggregated.entries()) {
+            // Check for high token usage
+            if (metrics.avgTokensPerRequest > 10000) {
+                recommendations.push(`${tool}: High token usage (${metrics.avgTokensPerRequest.toFixed(0)} avg). Consider chunking or summarization.`);
+            }
+            // Check for low success rate
+            if (metrics.successRate < 0.8) {
+                recommendations.push(`${tool}: Low success rate (${(metrics.successRate * 100).toFixed(1)}%). Consider fallback strategies.`);
+            }
+            // Check for slow performance
+            if (metrics.avgDuration > 20000) {
+                recommendations.push(`${tool}: Slow performance (${(metrics.avgDuration / 1000).toFixed(1)}s avg). Consider timeout or alternative.`);
+            }
+        }
+        // General recommendations
+        if (this.getRecentErrorRate() > 0.2) {
+            recommendations.push('High overall error rate. Enable circuit breakers and fallback strategies.');
+        }
+        const totalCost = Array.from(aggregated.values())
+            .reduce((sum, m) => sum + m.totalCost, 0);
+        if (totalCost > 10) {
+            recommendations.push(`High cost in last hour: $${totalCost.toFixed(2)}. Review workflow efficiency.`);
+        }
+        return recommendations;
+    }
+    /**
+     * Export metrics for analysis
+     */
+    exportMetrics(format = 'json') {
+        if (format === 'json') {
+            return JSON.stringify({
+                metrics: this.metrics,
+                systemMetrics: this.systemMetrics,
+                aggregated: Object.fromEntries(this.aggregateMetrics()),
+                exported: new Date().toISOString()
+            }, null, 2);
+        }
+        else {
+            // CSV format
+            const headers = [
+                'timestamp', 'requestId', 'tool', 'duration',
+                'inputTokens', 'outputTokens', 'totalTokens',
+                'cost', 'success', 'error'
+            ].join(',');
+            const rows = this.metrics.map(m => [
+                m.timestamp,
+                m.requestId,
+                m.tool,
+                m.duration,
+                m.tokensUsed.input,
+                m.tokensUsed.output,
+                m.tokensUsed.total,
+                m.cost.toFixed(4),
+                m.success,
+                m.error || ''
+            ].join(','));
+            return [headers, ...rows].join('\n');
+        }
+    }
+    /**
+     * Set metrics retention period
+     */
+    setRetention(milliseconds) {
+        this.metricsRetention = milliseconds;
+        this.cleanOldMetrics();
+    }
+    /**
+     * Cleanup
+     */
+    cleanup() {
+        if (this.aggregationInterval) {
+            clearInterval(this.aggregationInterval);
+        }
+        if (this.systemMonitorInterval) {
+            clearInterval(this.systemMonitorInterval);
+        }
+        this.metrics = [];
+        this.systemMetrics = [];
+        this.activeRequests.clear();
+        this.removeAllListeners();
+    }
+}
+// Export singleton instance
+export const performanceMonitor = new PerformanceMonitor();

package/dist/src/optimization/batch-executor.js

@@ -0,0 +1,121 @@
+export class BatchExecutor {
+    constructor(maxConcurrency, defaultTimeout) {
+        this.maxConcurrency = 5;
+        this.defaultTimeout = 30000;
+        if (maxConcurrency)
+            this.maxConcurrency = maxConcurrency;
+        if (defaultTimeout)
+            this.defaultTimeout = defaultTimeout;
+    }
+    async execute(tasks) {
+        const groups = this.groupTasksByDependencies(tasks);
+        const results = [];
+        for (const group of groups) {
+            const groupResults = await this.executeGroup(group);
+            results.push(...groupResults);
+        }
+        return results;
+    }
+    async executeParallel(tasks, maxConcurrency) {
+        const concurrency = maxConcurrency || this.maxConcurrency;
+        const results = [];
+        const queue = [...tasks].sort((a, b) => (b.priority || 0) - (a.priority || 0));
+        while (queue.length > 0) {
+            const batch = queue.splice(0, concurrency);
+            const batchResults = await Promise.all(batch.map(task => this.executeTask(task)));
+            results.push(...batchResults);
+        }
+        return results;
+    }
+    async executeGroup(tasks) {
+        const promises = tasks.map(task => this.executeTask(task));
+        return Promise.all(promises);
+    }
+    async executeTask(task) {
+        const startTime = Date.now();
+        const timeout = task.timeout || this.defaultTimeout;
+        try {
+            const result = await Promise.race([
+                task.fn(),
+                new Promise((_, reject) => setTimeout(() => reject(new Error('Timeout')), timeout))
+            ]);
+            return {
+                id: task.id,
+                result,
+                duration: Date.now() - startTime,
+                status: 'success'
+            };
+        }
+        catch (error) {
+            const isTimeout = error instanceof Error && error.message === 'Timeout';
+            return {
+                id: task.id,
+                error: error,
+                duration: Date.now() - startTime,
+                status: isTimeout ? 'timeout' : 'error'
+            };
+        }
+    }
+    groupTasksByDependencies(tasks) {
+        const groups = [];
+        const completed = new Set();
+        const remaining = [...tasks];
+        while (remaining.length > 0) {
+            const group = [];
+            for (let i = remaining.length - 1; i >= 0; i--) {
+                const task = remaining[i];
+                const ready = !task.dependencies ||
+                    task.dependencies.every(dep => completed.has(dep));
+                if (ready) {
+                    group.push(task);
+                    remaining.splice(i, 1);
+                }
+            }
+            if (group.length === 0 && remaining.length > 0) {
+                throw new Error('Circular dependency detected in batch tasks');
+            }
+            groups.push(group);
+            group.forEach(task => completed.add(task.id));
+        }
+        return groups;
+    }
+    generateReport(results) {
+        const successful = results.filter(r => r.status === 'success').length;
+        const failed = results.filter(r => r.status === 'error').length;
+        const timeouts = results.filter(r => r.status === 'timeout').length;
+        const totalDuration = Math.max(...results.map(r => r.duration));
+        return {
+            totalTasks: results.length,
+            successful,
+            failed,
+            timeouts,
+            totalDuration,
+            parallelGroups: Math.ceil(results.length / this.maxConcurrency)
+        };
+    }
+    async executeWithRetry(task, maxRetries = 3, backoff = 1000) {
+        let lastError;
+        for (let attempt = 0; attempt < maxRetries; attempt++) {
+            if (attempt > 0) {
+                await new Promise(resolve => setTimeout(resolve, backoff * attempt));
+            }
+            const result = await this.executeTask(task);
+            if (result.status === 'success') {
+                return result;
+            }
+            lastError = result.error;
+        }
+        return {
+            id: task.id,
+            error: lastError || new Error('Max retries exceeded'),
+            duration: 0,
+            status: 'error'
+        };
+    }
+    setMaxConcurrency(max) {
+        this.maxConcurrency = max;
+    }
+    setDefaultTimeout(timeout) {
+        this.defaultTimeout = timeout;
+    }
+}