tachibot-mcp 2.0.2

package/dist/src/optimization/context-pruner.js

@@ -0,0 +1,196 @@
+export class ContextPruner {
+    constructor() {
+        this.strategies = new Map([
+            ['embedding-similarity', this.pruneByEmbedding.bind(this)],
+            ['keyword', this.pruneByKeyword.bind(this)],
+            ['length', this.pruneByLength.bind(this)],
+            ['hybrid', this.pruneHybrid.bind(this)]
+        ]);
+    }
+    prune(text, options) {
+        const strategy = this.strategies.get(options.strategy) || this.pruneByLength.bind(this);
+        const pruned = strategy(text, options);
+        const originalTokens = this.estimateTokens(text);
+        const prunedTokens = this.estimateTokens(pruned);
+        const tokensReduced = originalTokens - prunedTokens;
+        const reductionRate = tokensReduced / originalTokens;
+        return {
+            original: text,
+            pruned,
+            tokensReduced,
+            reductionRate,
+            preservedSections: this.identifyPreservedSections(text, pruned)
+        };
+    }
+    pruneByEmbedding(text, options) {
+        const sentences = this.splitIntoSentences(text);
+        const scores = this.calculateSentenceImportance(sentences);
+        const sortedSentences = sentences
+            .map((sentence, index) => ({ sentence, score: scores[index], index }))
+            .sort((a, b) => b.score - a.score);
+        let result = [];
+        let currentTokens = 0;
+        for (const item of sortedSentences) {
+            const sentenceTokens = this.estimateTokens(item.sentence);
+            if (currentTokens + sentenceTokens <= options.maxTokens) {
+                result.push(item.sentence);
+                currentTokens += sentenceTokens;
+            }
+        }
+        // Preserve order
+        result = result.sort((a, b) => {
+            const indexA = sentences.indexOf(a);
+            const indexB = sentences.indexOf(b);
+            return indexA - indexB;
+        });
+        return result.join(' ');
+    }
+    pruneByKeyword(text, options) {
+        const keywords = this.extractKeywords(text);
+        const sentences = this.splitIntoSentences(text);
+        const scoredSentences = sentences.map(sentence => {
+            const score = keywords.reduce((sum, keyword) => {
+                return sum + (sentence.toLowerCase().includes(keyword.toLowerCase()) ? 1 : 0);
+            }, 0);
+            return { sentence, score };
+        });
+        scoredSentences.sort((a, b) => b.score - a.score);
+        let result = [];
+        let currentTokens = 0;
+        for (const item of scoredSentences) {
+            const sentenceTokens = this.estimateTokens(item.sentence);
+            if (currentTokens + sentenceTokens <= options.maxTokens) {
+                result.push(item.sentence);
+                currentTokens += sentenceTokens;
+            }
+        }
+        return result.join(' ');
+    }
+    pruneByLength(text, options) {
+        const targetLength = options.maxTokens * 4; // Rough character estimate
+        if (text.length <= targetLength) {
+            return text;
+        }
+        const sections = this.splitIntoSections(text);
+        let result = '';
+        for (const section of sections) {
+            if (result.length + section.length <= targetLength) {
+                result += section + '\n\n';
+            }
+            else {
+                const remaining = targetLength - result.length;
+                result += section.substring(0, remaining);
+                break;
+            }
+        }
+        return result.trim();
+    }
+    pruneHybrid(text, options) {
+        // Combine multiple strategies
+        const embeddingWeight = 0.4;
+        const keywordWeight = 0.3;
+        const recencyWeight = 0.3;
+        const sentences = this.splitIntoSentences(text);
+        const embeddingScores = this.calculateSentenceImportance(sentences);
+        const keywords = this.extractKeywords(text);
+        const finalScores = sentences.map((sentence, index) => {
+            const embeddingScore = embeddingScores[index] * embeddingWeight;
+            const keywordScore = keywords.reduce((sum, keyword) => {
+                return sum + (sentence.toLowerCase().includes(keyword.toLowerCase()) ? 1 : 0);
+            }, 0) * keywordWeight;
+            const recencyScore = (index / sentences.length) * recencyWeight;
+            return {
+                sentence,
+                score: embeddingScore + keywordScore + recencyScore,
+                index
+            };
+        });
+        finalScores.sort((a, b) => b.score - a.score);
+        let result = [];
+        let currentTokens = 0;
+        for (const item of finalScores) {
+            const sentenceTokens = this.estimateTokens(item.sentence);
+            if (currentTokens + sentenceTokens <= options.maxTokens) {
+                result.push(item);
+                currentTokens += sentenceTokens;
+            }
+        }
+        // Preserve original order
+        result.sort((a, b) => a.index - b.index);
+        return result.map(item => item.sentence).join(' ');
+    }
+    splitIntoSentences(text) {
+        return text.match(/[^.!?]+[.!?]+/g) || [text];
+    }
+    splitIntoSections(text) {
+        return text.split(/\n\n+/).filter(s => s.trim());
+    }
+    calculateSentenceImportance(sentences) {
+        // Simplified importance calculation
+        return sentences.map(sentence => {
+            let score = 0;
+            // Length factor
+            if (sentence.length > 50 && sentence.length < 200)
+                score += 0.3;
+            // Contains numbers or data
+            if (/\d+/.test(sentence))
+                score += 0.2;
+            // Contains technical terms (simplified)
+            const technicalTerms = ['function', 'class', 'method', 'api', 'error', 'bug', 'feature'];
+            technicalTerms.forEach(term => {
+                if (sentence.toLowerCase().includes(term))
+                    score += 0.1;
+            });
+            // Question or conclusion indicators
+            if (sentence.includes('?') || sentence.includes('therefore') || sentence.includes('conclusion')) {
+                score += 0.3;
+            }
+            return Math.min(score, 1);
+        });
+    }
+    extractKeywords(text) {
+        const words = text.toLowerCase().split(/\s+/);
+        const wordFreq = new Map();
+        const stopWords = new Set([
+            'the', 'is', 'at', 'which', 'on', 'a', 'an', 'as', 'are', 'was', 'were',
+            'been', 'be', 'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would',
+            'could', 'should', 'may', 'might', 'must', 'can', 'this', 'that', 'these',
+            'those', 'i', 'you', 'he', 'she', 'it', 'we', 'they', 'what', 'which', 'who',
+            'when', 'where', 'why', 'how', 'all', 'each', 'every', 'both', 'few', 'more',
+            'most', 'other', 'some', 'such', 'no', 'nor', 'not', 'only', 'own', 'same',
+            'so', 'than', 'too', 'very', 'just', 'but', 'for', 'with', 'about', 'into',
+            'through', 'during', 'before', 'after', 'above', 'below', 'to', 'from', 'of', 'in'
+        ]);
+        for (const word of words) {
+            if (word.length > 3 && !stopWords.has(word)) {
+                wordFreq.set(word, (wordFreq.get(word) || 0) + 1);
+            }
+        }
+        return Array.from(wordFreq.entries())
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 10)
+            .map(([word]) => word);
+    }
+    estimateTokens(text) {
+        return Math.ceil(text.length / 4);
+    }
+    identifyPreservedSections(original, pruned) {
+        const prunedSentences = this.splitIntoSentences(pruned);
+        return prunedSentences.slice(0, 3).map(s => s.substring(0, 50) + '...');
+    }
+    getRecommendedStrategy(text, requirements) {
+        const length = text.length;
+        const hasCode = /```[\s\S]*?```/.test(text);
+        const hasNumbers = /\d+/.test(text);
+        if (hasCode) {
+            return 'keyword'; // Preserve code blocks
+        }
+        if (length > 10000) {
+            return 'hybrid'; // Use multiple strategies for long text
+        }
+        if (hasNumbers || requirements.preserveData) {
+            return 'embedding-similarity'; // Better at preserving important data
+        }
+        return 'length'; // Simple and fast for short text
+    }
+}

package/dist/src/optimization/cost-monitor.js

@@ -0,0 +1,338 @@
+/**
+ * Cost Monitor - Real-time tracking and limits for API usage
+ * Part of Phase 1C implementation for cost control
+ */
+import { EventEmitter } from "events";
+export class CostMonitor extends EventEmitter {
+    constructor() {
+        super();
+        // Cost limits
+        this.limits = {
+            hourly: 1.0, // $1 per hour
+            daily: 10.0, // $10 per day
+            monthly: 300.0, // $300 per month
+        };
+        // Warning thresholds (percentage of limit)
+        this.thresholds = {
+            warning: 0.75, // 75% of limit
+            critical: 0.9, // 90% of limit
+        };
+        // Usage tracking
+        this.usage = new Map();
+        this.records = [];
+        this.modelUsage = new Map();
+        // Model pricing (updated Nov 2025 - includes GPT-5)
+        this.modelCosts = new Map([
+            // GPT-5 Models (Official pricing as of Nov 2025)
+            [
+                "gpt-5-nano",
+                { model: "gpt-5-nano", inputCost: 0.00005, outputCost: 0.0004 },
+            ], // ULTRA CHEAP!
+            [
+                "gpt-5-mini",
+                { model: "gpt-5-mini", inputCost: 0.00025, outputCost: 0.002 },
+            ],
+            ["gpt-5", { model: "gpt-5", inputCost: 0.00125, outputCost: 0.01 }],
+            [
+                "gpt-5-chat-latest",
+                { model: "gpt-5-chat-latest", inputCost: 0.00125, outputCost: 0.01 },
+            ],
+            // Existing models
+            [
+                "gemini-2.5-flash",
+                { model: "gemini-2.5-flash", inputCost: 0.000075, outputCost: 0.0003 },
+            ],
+            ["gpt-5-nano", { model: "gpt-5-nano", inputCost: 0.00005, outputCost: 0.0004 }],
+            [
+                "gpt-5-mini",
+                { model: "gpt-5-mini", inputCost: 0.00025, outputCost: 0.002 },
+            ],
+            ["gpt-5", { model: "gpt-5", inputCost: 0.0025, outputCost: 0.01 }],
+            [
+                "perplexity-sonar-pro",
+                { model: "perplexity-sonar-pro", inputCost: 0.006, outputCost: 0.006 },
+            ],
+            [
+                "claude-3.5-sonnet",
+                { model: "claude-3.5-sonnet", inputCost: 0.003, outputCost: 0.015 },
+            ],
+            ["grok-4", { model: "grok-4", inputCost: 0.005, outputCost: 0.015 }],
+        ]);
+        // Clean up old records periodically
+        setInterval(() => this.cleanupOldRecords(), 60 * 60 * 1000); // Every hour
+    }
+    /**
+     * Set custom limits
+     */
+    setLimits(limits) {
+        this.limits = { ...this.limits, ...limits };
+    }
+    /**
+     * Calculate cost for a request
+     */
+    calculateCost(model, inputTokens, outputTokens) {
+        const normalizedModel = this.normalizeModelId(model);
+        const pricing = this.modelCosts.get(normalizedModel);
+        if (!pricing) {
+            console.warn(`Unknown model pricing for: ${model}, using default`);
+            return (inputTokens * 0.001 + outputTokens * 0.002) / 1000; // Default pricing
+        }
+        return ((inputTokens * pricing.inputCost + outputTokens * pricing.outputCost) /
+            1000);
+    }
+    /**
+     * Track usage for a request
+     */
+    async trackUsage(model, inputTokens, outputTokens, requestId, userId) {
+        const normalizedModel = this.normalizeModelId(model);
+        const cost = this.calculateCost(model, inputTokens, outputTokens);
+        const now = Date.now();
+        // Check if request would exceed limits
+        const hourKey = this.getTimeKey("hour");
+        const dayKey = this.getTimeKey("day");
+        const monthKey = this.getTimeKey("month");
+        const hourlyUsage = (this.usage.get(`hour:${hourKey}`) || 0) + cost;
+        const dailyUsage = (this.usage.get(`day:${dayKey}`) || 0) + cost;
+        const monthlyUsage = (this.usage.get(`month:${monthKey}`) || 0) + cost;
+        // Check hard limits
+        if (hourlyUsage > this.limits.hourly) {
+            const alert = {
+                type: "limit_exceeded",
+                message: `Hourly limit exceeded. Current: $${hourlyUsage.toFixed(2)}, Limit: $${this.limits.hourly}`,
+                currentCost: hourlyUsage,
+                limit: this.limits.hourly,
+                timeframe: "hourly",
+            };
+            this.emit("limitExceeded", alert);
+            return { allowed: false, cost, alert };
+        }
+        if (dailyUsage > this.limits.daily) {
+            const alert = {
+                type: "limit_exceeded",
+                message: `Daily limit exceeded. Current: $${dailyUsage.toFixed(2)}, Limit: $${this.limits.daily}`,
+                currentCost: dailyUsage,
+                limit: this.limits.daily,
+                timeframe: "daily",
+            };
+            this.emit("limitExceeded", alert);
+            return { allowed: false, cost, alert };
+        }
+        // Record the usage
+        const record = {
+            timestamp: now,
+            model: normalizedModel,
+            inputTokens,
+            outputTokens,
+            cost,
+            requestId,
+            userId,
+        };
+        this.records.push(record);
+        this.usage.set(`hour:${hourKey}`, hourlyUsage);
+        this.usage.set(`day:${dayKey}`, dailyUsage);
+        this.usage.set(`month:${monthKey}`, monthlyUsage);
+        // Update model usage stats
+        const modelStats = this.modelUsage.get(normalizedModel) || {
+            count: 0,
+            cost: 0,
+        };
+        modelStats.count++;
+        modelStats.cost += cost;
+        this.modelUsage.set(normalizedModel, modelStats);
+        // Check warning thresholds
+        let alert;
+        if (hourlyUsage > this.limits.hourly * this.thresholds.critical) {
+            alert = {
+                type: "critical",
+                message: `Critical: Approaching hourly limit (${((hourlyUsage / this.limits.hourly) * 100).toFixed(0)}%)`,
+                currentCost: hourlyUsage,
+                limit: this.limits.hourly,
+                timeframe: "hourly",
+            };
+            this.emit("criticalAlert", alert);
+        }
+        else if (hourlyUsage > this.limits.hourly * this.thresholds.warning) {
+            alert = {
+                type: "warning",
+                message: `Warning: ${((hourlyUsage / this.limits.hourly) * 100).toFixed(0)}% of hourly limit used`,
+                currentCost: hourlyUsage,
+                limit: this.limits.hourly,
+                timeframe: "hourly",
+            };
+            this.emit("warningAlert", alert);
+        }
+        return { allowed: true, cost, alert };
+    }
+    /**
+     * Check if a request would be allowed
+     */
+    async checkRequest(model, estimatedTokens) {
+        // Estimate 40% input, 60% output
+        const inputTokens = estimatedTokens * 0.4;
+        const outputTokens = estimatedTokens * 0.6;
+        const estimatedCost = this.calculateCost(model, inputTokens, outputTokens);
+        const hourKey = this.getTimeKey("hour");
+        const dayKey = this.getTimeKey("day");
+        const hourlyUsage = this.usage.get(`hour:${hourKey}`) || 0;
+        const dailyUsage = this.usage.get(`day:${dayKey}`) || 0;
+        // Check if it would exceed limits
+        if (hourlyUsage + estimatedCost > this.limits.hourly) {
+            return {
+                allowed: false,
+                estimatedCost,
+                requiresConfirmation: true,
+                warning: `Would exceed hourly limit ($${this.limits.hourly})`,
+            };
+        }
+        if (dailyUsage + estimatedCost > this.limits.daily) {
+            return {
+                allowed: false,
+                estimatedCost,
+                requiresConfirmation: true,
+                warning: `Would exceed daily limit ($${this.limits.daily})`,
+            };
+        }
+        // Check if confirmation needed
+        const requiresConfirmation = estimatedCost > 0.1; // Confirm for requests > $0.10
+        return {
+            allowed: true,
+            estimatedCost,
+            requiresConfirmation,
+            warning: requiresConfirmation
+                ? `High cost request: $${estimatedCost.toFixed(2)}`
+                : undefined,
+        };
+    }
+    /**
+     * Get usage report
+     */
+    getUsageReport() {
+        const hourKey = this.getTimeKey("hour");
+        const dayKey = this.getTimeKey("day");
+        const monthKey = this.getTimeKey("month");
+        const hourlyUsage = this.usage.get(`hour:${hourKey}`) || 0;
+        const dailyUsage = this.usage.get(`day:${dayKey}`) || 0;
+        const monthlyUsage = this.usage.get(`month:${monthKey}`) || 0;
+        // Get top models by cost
+        const topModels = Array.from(this.modelUsage.entries())
+            .map(([model, stats]) => ({
+            model,
+            usage: stats.count,
+            cost: stats.cost,
+        }))
+            .sort((a, b) => b.cost - a.cost)
+            .slice(0, 5);
+        // Generate alerts
+        const alerts = [];
+        if (hourlyUsage > this.limits.hourly * this.thresholds.warning) {
+            alerts.push({
+                type: hourlyUsage > this.limits.hourly * this.thresholds.critical
+                    ? "critical"
+                    : "warning",
+                message: `${((hourlyUsage / this.limits.hourly) * 100).toFixed(0)}% of hourly limit used`,
+                currentCost: hourlyUsage,
+                limit: this.limits.hourly,
+                timeframe: "hourly",
+            });
+        }
+        if (dailyUsage > this.limits.daily * this.thresholds.warning) {
+            alerts.push({
+                type: dailyUsage > this.limits.daily * this.thresholds.critical
+                    ? "critical"
+                    : "warning",
+                message: `${((dailyUsage / this.limits.daily) * 100).toFixed(0)}% of daily limit used`,
+                currentCost: dailyUsage,
+                limit: this.limits.daily,
+                timeframe: "daily",
+            });
+        }
+        return {
+            hourly: {
+                used: hourlyUsage,
+                limit: this.limits.hourly,
+                remaining: Math.max(0, this.limits.hourly - hourlyUsage),
+                percentage: (hourlyUsage / this.limits.hourly) * 100,
+            },
+            daily: {
+                used: dailyUsage,
+                limit: this.limits.daily,
+                remaining: Math.max(0, this.limits.daily - dailyUsage),
+                percentage: (dailyUsage / this.limits.daily) * 100,
+            },
+            monthly: {
+                used: monthlyUsage,
+                limit: this.limits.monthly,
+                remaining: Math.max(0, this.limits.monthly - monthlyUsage),
+                percentage: (monthlyUsage / this.limits.monthly) * 100,
+            },
+            topModels,
+            alerts,
+        };
+    }
+    normalizeModelId(model) {
+        switch (model) {
+            case "gpt5":
+                return "gpt-5";
+            case "gpt5_mini":
+                return "gpt-5-mini";
+            case "gpt5_nano":
+                return "gpt-5-nano";
+            default:
+                return model;
+        }
+    }
+    /**
+     * Get time key for usage tracking
+     */
+    getTimeKey(period) {
+        const now = new Date();
+        switch (period) {
+            case "hour":
+                return now.toISOString().slice(0, 13); // YYYY-MM-DDTHH
+            case "day":
+                return now.toISOString().slice(0, 10); // YYYY-MM-DD
+            case "month":
+                return now.toISOString().slice(0, 7); // YYYY-MM
+        }
+    }
+    /**
+     * Clean up old records
+     */
+    cleanupOldRecords() {
+        const oneDayAgo = Date.now() - 24 * 60 * 60 * 1000;
+        // Remove records older than 24 hours
+        this.records = this.records.filter((r) => r.timestamp > oneDayAgo);
+        // Clean up old usage keys
+        const currentHour = this.getTimeKey("hour");
+        const currentDay = this.getTimeKey("day");
+        const currentMonth = this.getTimeKey("month");
+        for (const [key] of this.usage.entries()) {
+            if (key.startsWith("hour:") && !key.includes(currentHour.slice(0, 10))) {
+                this.usage.delete(key);
+            }
+            else if (key.startsWith("day:") && !key.includes(currentMonth)) {
+                this.usage.delete(key);
+            }
+        }
+    }
+    /**
+     * Reset all usage data
+     */
+    reset() {
+        this.usage.clear();
+        this.records = [];
+        this.modelUsage.clear();
+    }
+    /**
+     * Export usage data for analysis
+     */
+    exportUsageData() {
+        return {
+            records: this.records,
+            summary: this.getUsageReport(),
+            modelBreakdown: this.modelUsage,
+        };
+    }
+}
+// Export singleton instance
+export const costMonitor = new CostMonitor();

package/dist/src/optimization/index.js

@@ -0,0 +1,65 @@
+/**
+ * Optimization Module - Exports for Phase 1 improvements
+ * Provides smart model routing, token optimization, and cost monitoring
+ */
+// Import singletons
+import { modelRouter } from './model-router.js';
+import { tokenOptimizer } from './token-optimizer.js';
+import { costMonitor } from './cost-monitor.js';
+// Re-export all types and classes
+export { SmartModelRouter, modelRouter, ModelTier } from './model-router.js';
+export { TokenOptimizer, tokenOptimizer } from './token-optimizer.js';
+export { CostMonitor, costMonitor } from './cost-monitor.js';
+/**
+ * Initialize all optimization modules
+ */
+export function initializeOptimizations(config) {
+    // Set cost limits if provided
+    if (config?.costLimits) {
+        costMonitor.setLimits(config.costLimits);
+    }
+    // Listen for cost alerts
+    costMonitor.on('warningAlert', (alert) => {
+        console.warn(`⚠️ Cost Warning: ${alert.message}`);
+    });
+    costMonitor.on('criticalAlert', (alert) => {
+        console.error(`🚨 Cost Critical: ${alert.message}`);
+    });
+    costMonitor.on('limitExceeded', (alert) => {
+        console.error(`🛑 Cost Limit Exceeded: ${alert.message}`);
+    });
+    console.error('✅ Optimizations initialized:');
+    console.error('  • Smart model routing enabled');
+    console.error('  • Token optimization active');
+    console.error('  • Cost monitoring configured');
+    return {
+        modelRouter,
+        tokenOptimizer,
+        costMonitor,
+    };
+}
+/**
+ * Get optimization statistics
+ */
+export function getOptimizationStats() {
+    const tokenMetrics = tokenOptimizer.getMetrics();
+    const costReport = costMonitor.getUsageReport();
+    return {
+        tokenOptimization: {
+            cacheHitRate: tokenMetrics.cacheHitRate,
+            compressionRatio: tokenMetrics.compressionRatio,
+            tokensSaved: tokenMetrics.totalSaved,
+            batchesProcessed: tokenMetrics.batchesProcessed,
+        },
+        costMonitoring: {
+            hourlyUsage: costReport.hourly.used,
+            dailyUsage: costReport.daily.used,
+            monthlyUsage: costReport.monthly.used,
+            topModels: costReport.topModels,
+        },
+        recommendations: [
+            ...tokenMetrics.recommendations,
+            ...costReport.alerts.map((a) => a.message),
+        ],
+    };
+}