tachibot-mcp 2.0.2

package/dist/src/workflows/message-queue.js

@@ -0,0 +1,455 @@
+import { EventEmitter } from 'events';
+/**
+ * In-memory message queue implementation
+ * Can be replaced with Kafka/RabbitMQ for production
+ */
+export class MessageQueue extends EventEmitter {
+    constructor(config = {}) {
+        super();
+        this.queues = new Map();
+        this.processing = new Map();
+        this.deadLetterQueue = [];
+        this.stats = new Map();
+        this.handlers = new Map();
+        this.config = {
+            maxSize: 10000,
+            maxRetries: 3,
+            retryDelay: 1000,
+            batchSize: 10,
+            flushInterval: 100,
+            deadLetterQueue: true,
+            ...config
+        };
+        this.startFlushTimer();
+    }
+    /**
+     * Send a message to a topic
+     */
+    async send(topic, payload, options = {}) {
+        const messageId = this.generateMessageId();
+        const message = {
+            id: messageId,
+            topic,
+            payload,
+            timestamp: Date.now(),
+            retryCount: 0,
+            maxRetries: options.maxRetries || this.config.maxRetries,
+            priority: options.priority || 'normal',
+            headers: options.headers
+        };
+        // Check queue size limit
+        const queue = this.getQueue(topic);
+        if (queue.length >= this.config.maxSize) {
+            throw new Error(`Queue ${topic} is full (max: ${this.config.maxSize})`);
+        }
+        // Add to queue based on priority
+        this.addToQueue(topic, message);
+        this.emit('message-sent', { topic, messageId });
+        // Update stats
+        this.updateStats(topic, 'pending', 1);
+        return messageId;
+    }
+    /**
+     * Send a batch of messages
+     */
+    async sendBatch(topic, payloads, options = {}) {
+        const messageIds = [];
+        for (const payload of payloads) {
+            const id = await this.send(topic, payload, options);
+            messageIds.push(id);
+        }
+        return messageIds;
+    }
+    /**
+     * Subscribe to a topic
+     */
+    subscribe(topic, handler) {
+        if (!this.handlers.has(topic)) {
+            this.handlers.set(topic, []);
+        }
+        this.handlers.get(topic).push(handler);
+        this.emit('subscription-added', { topic });
+        // Process any pending messages
+        this.processQueue(topic);
+    }
+    /**
+     * Process messages in a queue
+     */
+    async processQueue(topic) {
+        const queue = this.getQueue(topic);
+        const handlers = this.handlers.get(topic) || [];
+        if (queue.length === 0 || handlers.length === 0) {
+            return;
+        }
+        // Get batch of messages
+        const batch = this.getNextBatch(topic);
+        for (const message of batch) {
+            // Skip if already processing
+            if (this.isProcessing(topic, message.id)) {
+                continue;
+            }
+            this.markProcessing(topic, message.id);
+            // Process message with all handlers
+            this.processMessage(topic, message, handlers);
+        }
+    }
+    /**
+     * Process a single message
+     */
+    async processMessage(topic, message, handlers) {
+        const startTime = Date.now();
+        try {
+            // Execute all handlers in parallel
+            const results = await Promise.allSettled(handlers.map(handler => handler(message)));
+            // Check if any handler failed
+            const failures = results.filter(r => r.status === 'rejected');
+            if (failures.length > 0) {
+                throw new Error(`${failures.length} handlers failed`);
+            }
+            // Success - remove from queue
+            this.removeFromQueue(topic, message.id);
+            this.markComplete(topic, message.id);
+            // Update stats
+            const processingTime = Date.now() - startTime;
+            this.updateStats(topic, 'completed', 1);
+            this.updateProcessingTime(topic, processingTime);
+            this.emit('message-processed', { topic, messageId: message.id, processingTime });
+        }
+        catch (error) {
+            // Handle failure
+            await this.handleFailure(topic, message, error);
+        }
+    }
+    /**
+     * Handle message processing failure
+     */
+    async handleFailure(topic, message, error) {
+        message.retryCount++;
+        this.markComplete(topic, message.id); // Remove from processing
+        if (message.retryCount < message.maxRetries) {
+            // Retry with delay
+            setTimeout(() => {
+                this.addToQueue(topic, message);
+                this.emit('message-retry', {
+                    topic,
+                    messageId: message.id,
+                    retryCount: message.retryCount
+                });
+            }, this.config.retryDelay * message.retryCount);
+        }
+        else {
+            // Move to dead letter queue
+            if (this.config.deadLetterQueue) {
+                this.deadLetterQueue.push(message);
+                this.updateStats(topic, 'deadLetter', 1);
+                this.emit('message-dead-letter', {
+                    topic,
+                    messageId: message.id,
+                    error: error.message
+                });
+            }
+            else {
+                this.updateStats(topic, 'failed', 1);
+                this.emit('message-failed', {
+                    topic,
+                    messageId: message.id,
+                    error: error.message
+                });
+            }
+            // Remove from queue
+            this.removeFromQueue(topic, message.id);
+        }
+    }
+    /**
+     * Get next batch of messages to process
+     */
+    getNextBatch(topic) {
+        const queue = this.getQueue(topic);
+        // Sort by priority and timestamp
+        const sorted = queue.sort((a, b) => {
+            const priorityOrder = { critical: 0, high: 1, normal: 2, low: 3 };
+            const priorityDiff = priorityOrder[a.priority] - priorityOrder[b.priority];
+            if (priorityDiff !== 0)
+                return priorityDiff;
+            return a.timestamp - b.timestamp;
+        });
+        return sorted.slice(0, this.config.batchSize);
+    }
+    /**
+     * Add message to queue based on priority
+     */
+    addToQueue(topic, message) {
+        const queue = this.getQueue(topic);
+        if (message.priority === 'critical' || message.priority === 'high') {
+            // Add to front for high priority
+            queue.unshift(message);
+        }
+        else {
+            // Add to back for normal/low priority
+            queue.push(message);
+        }
+    }
+    /**
+     * Remove message from queue
+     */
+    removeFromQueue(topic, messageId) {
+        const queue = this.getQueue(topic);
+        const index = queue.findIndex(m => m.id === messageId);
+        if (index >= 0) {
+            queue.splice(index, 1);
+        }
+    }
+    /**
+     * Get or create queue for topic
+     */
+    getQueue(topic) {
+        if (!this.queues.has(topic)) {
+            this.queues.set(topic, []);
+            this.processing.set(topic, new Set());
+            this.initStats(topic);
+        }
+        return this.queues.get(topic);
+    }
+    /**
+     * Check if message is being processed
+     */
+    isProcessing(topic, messageId) {
+        return this.processing.get(topic)?.has(messageId) || false;
+    }
+    /**
+     * Mark message as processing
+     */
+    markProcessing(topic, messageId) {
+        if (!this.processing.has(topic)) {
+            this.processing.set(topic, new Set());
+        }
+        this.processing.get(topic).add(messageId);
+        this.updateStats(topic, 'processing', 1);
+        this.updateStats(topic, 'pending', -1);
+    }
+    /**
+     * Mark message as complete
+     */
+    markComplete(topic, messageId) {
+        this.processing.get(topic)?.delete(messageId);
+        this.updateStats(topic, 'processing', -1);
+    }
+    /**
+     * Start flush timer to process queues periodically
+     */
+    startFlushTimer() {
+        this.flushTimer = setInterval(() => {
+            for (const topic of this.queues.keys()) {
+                this.processQueue(topic);
+            }
+        }, this.config.flushInterval);
+    }
+    /**
+     * Generate unique message ID
+     */
+    generateMessageId() {
+        return `msg-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    }
+    /**
+     * Initialize stats for a topic
+     */
+    initStats(topic) {
+        this.stats.set(topic, {
+            pending: 0,
+            processing: 0,
+            completed: 0,
+            failed: 0,
+            deadLetter: 0,
+            avgProcessingTime: 0,
+            throughput: 0
+        });
+    }
+    /**
+     * Update stats for a topic
+     */
+    updateStats(topic, field, delta) {
+        const stats = this.stats.get(topic);
+        if (stats) {
+            stats[field] += delta;
+        }
+    }
+    /**
+     * Update processing time stats
+     */
+    updateProcessingTime(topic, time) {
+        const stats = this.stats.get(topic);
+        if (stats) {
+            // Calculate moving average
+            const alpha = 0.1; // Smoothing factor
+            stats.avgProcessingTime = alpha * time + (1 - alpha) * stats.avgProcessingTime;
+            // Calculate throughput (messages per second)
+            stats.throughput = 1000 / stats.avgProcessingTime;
+        }
+    }
+    /**
+     * Get stats for a topic
+     */
+    getStats(topic) {
+        if (topic) {
+            return this.stats.get(topic) || this.initStats(topic) || this.stats.get(topic);
+        }
+        return new Map(this.stats);
+    }
+    /**
+     * Get dead letter queue
+     */
+    getDeadLetterQueue() {
+        return [...this.deadLetterQueue];
+    }
+    /**
+     * Retry dead letter messages
+     */
+    async retryDeadLetters(topic) {
+        const messages = topic
+            ? this.deadLetterQueue.filter(m => m.topic === topic)
+            : [...this.deadLetterQueue];
+        let retried = 0;
+        for (const message of messages) {
+            message.retryCount = 0; // Reset retry count
+            this.addToQueue(message.topic, message);
+            // Remove from dead letter queue
+            const index = this.deadLetterQueue.indexOf(message);
+            if (index >= 0) {
+                this.deadLetterQueue.splice(index, 1);
+            }
+            retried++;
+        }
+        this.emit('dead-letters-retried', { count: retried, topic });
+        return retried;
+    }
+    /**
+     * Clear a queue
+     */
+    clearQueue(topic) {
+        this.queues.set(topic, []);
+        this.processing.set(topic, new Set());
+        this.initStats(topic);
+        this.emit('queue-cleared', { topic });
+    }
+    /**
+     * Cleanup and stop processing
+     */
+    cleanup() {
+        if (this.flushTimer) {
+            clearInterval(this.flushTimer);
+        }
+        // Clear all queues
+        for (const topic of this.queues.keys()) {
+            this.clearQueue(topic);
+        }
+        this.deadLetterQueue = [];
+        this.removeAllListeners();
+    }
+}
+/**
+ * Message Queue Orchestrator for Claude → Subagent communication
+ */
+export class MessageQueueOrchestrator extends EventEmitter {
+    constructor(queueConfig) {
+        super();
+        this.pendingRequests = new Map();
+        this.queue = new MessageQueue(queueConfig);
+        this.setupResponseHandler();
+    }
+    /**
+     * Delegate task to subagent via message queue
+     */
+    async delegateToSubagent(request) {
+        const timeout = request.timeout || 30000;
+        return new Promise((resolve, reject) => {
+            // Store pending request
+            const timeoutHandle = setTimeout(() => {
+                this.pendingRequests.delete(request.id);
+                reject(new Error(`Subagent request ${request.id} timed out after ${timeout}ms`));
+            }, timeout);
+            this.pendingRequests.set(request.id, { resolve, reject, timeout: timeoutHandle });
+            // Send to message queue
+            this.queue.send('subagent-requests', request, {
+                priority: 'normal',
+                headers: {
+                    'request-id': request.id,
+                    'request-type': request.type,
+                    'timeout': timeout.toString()
+                }
+            }).catch(error => {
+                this.pendingRequests.delete(request.id);
+                clearTimeout(timeoutHandle);
+                reject(error);
+            });
+        });
+    }
+    /**
+     * Spawn ephemeral subagent
+     */
+    async spawnEphemeralSubagent(type, config) {
+        const subagentId = `${type}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+        const request = {
+            id: this.generateRequestId(),
+            type: 'spawn-subagent',
+            config: {
+                subagentId,
+                type,
+                ...config
+            },
+            payload: {}
+        };
+        const response = await this.delegateToSubagent(request);
+        if (response.error) {
+            throw new Error(`Failed to spawn subagent: ${response.error}`);
+        }
+        return subagentId;
+    }
+    /**
+     * Setup response handler
+     */
+    setupResponseHandler() {
+        this.queue.subscribe('subagent-responses', async (message) => {
+            const response = message.payload;
+            const pending = this.pendingRequests.get(response.requestId);
+            if (pending) {
+                clearTimeout(pending.timeout);
+                this.pendingRequests.delete(response.requestId);
+                if (response.error) {
+                    pending.reject(new Error(response.error));
+                }
+                else {
+                    pending.resolve(response);
+                }
+            }
+        });
+    }
+    /**
+     * Generate unique request ID
+     */
+    generateRequestId() {
+        return `req-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    }
+    /**
+     * Get queue statistics
+     */
+    getStats() {
+        return this.queue.getStats();
+    }
+    /**
+     * Cleanup
+     */
+    cleanup() {
+        // Clear pending requests
+        for (const [id, pending] of this.pendingRequests.entries()) {
+            clearTimeout(pending.timeout);
+            pending.reject(new Error('Orchestrator shutting down'));
+        }
+        this.pendingRequests.clear();
+        // Cleanup queue
+        this.queue.cleanup();
+        this.removeAllListeners();
+    }
+}
+// Export singleton instances
+export const messageQueue = new MessageQueue();
+export const mqOrchestrator = new MessageQueueOrchestrator();

package/dist/src/workflows/model-router.js

@@ -0,0 +1,189 @@
+export class ModelRouter {
+    constructor() {
+        this.models = new Map([
+            ['claude-code', {
+                    id: 'claude-code',
+                    cost: 0,
+                    quality: 10,
+                    speed: 8,
+                    reasoning: 10,
+                    useFor: ['primary reasoning', 'code', 'analysis']
+                }],
+            ['gemini-2.5-pro', {
+                    id: 'gemini-2.5-pro',
+                    cost: 10,
+                    quality: 9,
+                    speed: 7,
+                    reasoning: 9,
+                    context: '1M tokens',
+                    useFor: ['deep reasoning', 'complex analysis', 'when quality matters']
+                }],
+            ['gemini-2.5-flash', {
+                    id: 'gemini-2.5-flash',
+                    cost: 2,
+                    quality: 7,
+                    speed: 10,
+                    reasoning: 7,
+                    context: '1M tokens',
+                    useFor: ['scout mode', 'quick analysis', 'high-volume tasks']
+                }],
+            ['perplexity-sonar-pro', {
+                    id: 'perplexity-sonar-pro',
+                    cost: 6,
+                    quality: 9,
+                    speed: 7,
+                    reasoning: 8,
+                    useFor: ['web search', 'fact-checking', 'citations']
+                }],
+            ['perplexity-sonar-reasoning', {
+                    id: 'perplexity-sonar-reasoning',
+                    cost: 10,
+                    quality: 10,
+                    speed: 5,
+                    reasoning: 10,
+                    useFor: ['complex reasoning with evidence']
+                }],
+            ['grok-4', {
+                    id: 'grok-4',
+                    cost: 9,
+                    quality: 9,
+                    speed: 6,
+                    reasoning: 9,
+                    useFor: ['first-principles', 'architecture', 'challenging assumptions']
+                }],
+            ['grok-4-heavy', {
+                    id: 'grok-4-heavy',
+                    cost: 12,
+                    quality: 10,
+                    speed: 4,
+                    reasoning: 10,
+                    useFor: ['deep reasoning', 'complex problems']
+                }],
+            ['gpt5', {
+                    id: 'gpt5',
+                    cost: 12,
+                    quality: 10,
+                    speed: 7,
+                    reasoning: 10,
+                    useFor: ['primary reasoning', 'complex analysis', 'critical workflows']
+                }],
+            ['gpt5_mini', {
+                    id: 'gpt5_mini',
+                    cost: 8,
+                    quality: 9,
+                    speed: 9,
+                    reasoning: 9,
+                    useFor: ['fallback reasoning', 'challenger mode', 'cost-aware reasoning']
+                }],
+            ['gpt5_reason', {
+                    id: 'gpt5_reason',
+                    cost: 12,
+                    quality: 10,
+                    speed: 7,
+                    reasoning: 10,
+                    useFor: ['deep research', 'complex reasoning']
+                }],
+            ['qwen3-coder-480b', {
+                    id: 'qwen3-coder-480b',
+                    cost: 12,
+                    quality: 10,
+                    speed: 4,
+                    reasoning: 8,
+                    useFor: ['code generation', 'code analysis', 'refactoring']
+                }],
+            ['qwq-32b', {
+                    id: 'qwq-32b',
+                    cost: 10,
+                    quality: 9,
+                    speed: 5,
+                    reasoning: 10,
+                    useFor: ['mathematical reasoning', 'step-by-step logic']
+                }],
+            ['qwen3-30b', {
+                    id: 'qwen3-30b',
+                    cost: 6,
+                    quality: 8,
+                    speed: 7,
+                    reasoning: 8,
+                    useFor: ['general tasks', 'cheaper alternative']
+                }],
+            ['think', {
+                    id: 'think',
+                    cost: 0,
+                    quality: 6,
+                    speed: 10,
+                    reasoning: 6,
+                    useFor: ['synthesis', 'internal reasoning', 'combining insights']
+                }]
+        ]);
+    }
+    selectModel(task, constraints = {}) {
+        if (task.needsCurrentInfo || task.type === 'facts' || task.type === 'research') {
+            return 'perplexity-sonar-pro';
+        }
+        if (task.complexity > 0.8 && !constraints.budget) {
+            return constraints.budget !== undefined && constraints.budget < 10 ? 'gpt5_mini' : 'gpt5';
+        }
+        if (task.complexity < 0.2 && task.type === 'format') {
+            return 'gemini-2.5-flash';
+        }
+        if (task.type === 'synthesis') {
+            return 'think';
+        }
+        if (constraints.local) {
+            return 'lmstudio-local';
+        }
+        const taskTypeMap = {
+            'code': task.complexity > 0.7 ? 'qwen3-coder-480b' : 'gemini-2.5-flash',
+            'research': 'perplexity-sonar-pro',
+            'reasoning': task.complexity > 0.5 ? 'gpt5' : 'gpt5_mini',
+            'scout': 'multi-model',
+            'verifier': task.complexity > 0.5 ? 'gpt5' : 'gpt5_mini',
+            'challenger': 'gpt5_mini',
+            'auditor': 'perplexity-sonar-pro',
+            'architect': 'grok-4',
+            'commit_guardian': 'gemini-2.5-flash'
+        };
+        return taskTypeMap[task.type] || this.selectByConstraints(task, constraints);
+    }
+    selectByConstraints(task, constraints) {
+        let candidates = Array.from(this.models.values());
+        if (constraints.budget !== undefined) {
+            candidates = candidates.filter(m => m.cost <= constraints.budget);
+        }
+        if (constraints.speed) {
+            candidates.sort((a, b) => b.speed - a.speed);
+        }
+        else if (constraints.quality) {
+            candidates.sort((a, b) => b.quality - a.quality);
+        }
+        else {
+            candidates.sort((a, b) => {
+                const scoreA = (a.quality * 0.4 + a.speed * 0.3 + a.reasoning * 0.3) / a.cost;
+                const scoreB = (b.quality * 0.4 + b.speed * 0.3 + b.reasoning * 0.3) / b.cost;
+                return scoreB - scoreA;
+            });
+        }
+        return candidates[0]?.id || 'gpt5_mini';
+    }
+    getModelInfo(modelId) {
+        return this.models.get(modelId);
+    }
+    estimateCost(modelId, tokens) {
+        const model = this.models.get(modelId);
+        if (!model)
+            return 0;
+        const costPerMillion = model.cost;
+        return (tokens / 1000000) * costPerMillion;
+    }
+    selectModelsForVerification(variant) {
+        const variants = {
+            'quick_verify': ['gpt5_mini', 'gemini-2.5-flash', 'qwen3-30b'],
+            'deep_verify': ['gpt5', 'qwq-32b', 'gpt5_reason', 'gemini-2.5-pro', 'qwen3-coder-480b'],
+            'fact_check': ['perplexity-sonar-pro', 'gpt5', 'gemini-2.5-pro'],
+            'code_verify': ['qwen3-coder-480b', 'gpt5', 'gemini-2.5-pro'],
+            'security_verify': ['gpt5', 'qwen3-coder-480b', 'grok-4']
+        };
+        return variants[variant] || variants['quick_verify'];
+    }
+}