cost-katana-cli 2.0.0

package/dist/commands/bulk-optimize.js

@@ -0,0 +1,863 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bulkOptimizeCommand = bulkOptimizeCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const logger_1 = require("../utils/logger");
+const config_1 = require("../utils/config");
+const axios_1 = __importDefault(require("axios"));
+const fs = __importStar(require("fs"));
+const csv_parser_1 = __importDefault(require("csv-parser"));
+const csv_writer_1 = require("csv-writer");
+function bulkOptimizeCommand(program) {
+    const bulkGroup = program
+        .command('bulk-optimize')
+        .description('🚀 Analyze and optimize multiple high-frequency prompts in one go');
+    // Main bulk-optimize command
+    bulkGroup
+        .option('--file <path>', 'CSV file with prompts to optimize')
+        .option('--format <format>', 'Output format (table, json, csv)', 'table')
+        .option('--export <path>', 'Export optimization results to file')
+        .option('-v, --verbose', 'Show detailed optimization analysis')
+        .option('--include-token-analysis', 'Include detailed token analysis')
+        .option('--include-cost-breakdown', 'Include detailed cost breakdown')
+        .option('--include-optimization-suggestions', 'Include optimization suggestions')
+        .option('--include-priority-ranking', 'Include priority ranking')
+        .action(async (options) => {
+        try {
+            await handleBulkOptimize(options);
+        }
+        catch (error) {
+            logger_1.logger.error('Bulk optimize command failed:', error);
+            process.exit(1);
+        }
+    });
+    // Batch optimization with different strategies
+    bulkGroup
+        .command('strategies')
+        .description('🚀 Optimize prompts using different strategies')
+        .option('--file <path>', 'CSV file with prompts to optimize')
+        .option('--strategies <strategies>', 'Comma-separated optimization strategies')
+        .option('--format <format>', 'Output format (table, json, csv)', 'table')
+        .option('--export <path>', 'Export strategy results to file')
+        .option('-v, --verbose', 'Show detailed strategy analysis')
+        .option('--include-token-analysis', 'Include detailed token analysis')
+        .option('--include-cost-breakdown', 'Include detailed cost breakdown')
+        .option('--include-comparison', 'Include strategy comparison')
+        .action(async (options) => {
+        try {
+            await handleStrategyOptimization(options);
+        }
+        catch (error) {
+            logger_1.logger.error('Strategy optimization failed:', error);
+            process.exit(1);
+        }
+    });
+    // Priority-based optimization
+    bulkGroup
+        .command('priority')
+        .description('🚀 Optimize prompts based on priority and impact')
+        .option('--file <path>', 'CSV file with prompts to optimize')
+        .option('--priority-criteria <criteria>', 'Priority criteria (cost, frequency, impact)', 'cost')
+        .option('--format <format>', 'Output format (table, json, csv)', 'table')
+        .option('--export <path>', 'Export priority results to file')
+        .option('-v, --verbose', 'Show detailed priority analysis')
+        .option('--include-token-analysis', 'Include detailed token analysis')
+        .option('--include-cost-breakdown', 'Include detailed cost breakdown')
+        .option('--include-impact-analysis', 'Include impact analysis')
+        .action(async (options) => {
+        try {
+            await handlePriorityOptimization(options);
+        }
+        catch (error) {
+            logger_1.logger.error('Priority optimization failed:', error);
+            process.exit(1);
+        }
+    });
+    // Model-specific optimization
+    bulkGroup
+        .command('models')
+        .description('🚀 Optimize prompts for specific models')
+        .option('--file <path>', 'CSV file with prompts to optimize')
+        .option('--target-models <models>', 'Comma-separated target models')
+        .option('--format <format>', 'Output format (table, json, csv)', 'table')
+        .option('--export <path>', 'Export model results to file')
+        .option('-v, --verbose', 'Show detailed model analysis')
+        .option('--include-token-analysis', 'Include detailed token analysis')
+        .option('--include-cost-breakdown', 'Include detailed cost breakdown')
+        .option('--include-model-comparison', 'Include model comparison')
+        .action(async (options) => {
+        try {
+            await handleModelOptimization(options);
+        }
+        catch (error) {
+            logger_1.logger.error('Model optimization failed:', error);
+            process.exit(1);
+        }
+    });
+    // Frequency-based optimization
+    bulkGroup
+        .command('frequency')
+        .description('🚀 Optimize prompts based on usage frequency')
+        .option('--file <path>', 'CSV file with prompts to optimize')
+        .option('--frequency-threshold <threshold>', 'Minimum frequency threshold', '100')
+        .option('--format <format>', 'Output format (table, json, csv)', 'table')
+        .option('--export <path>', 'Export frequency results to file')
+        .option('-v, --verbose', 'Show detailed frequency analysis')
+        .option('--include-token-analysis', 'Include detailed token analysis')
+        .option('--include-cost-breakdown', 'Include detailed cost breakdown')
+        .option('--include-frequency-analysis', 'Include frequency analysis')
+        .action(async (options) => {
+        try {
+            await handleFrequencyOptimization(options);
+        }
+        catch (error) {
+            logger_1.logger.error('Frequency optimization failed:', error);
+            process.exit(1);
+        }
+    });
+    // Cost-based optimization
+    bulkGroup
+        .command('cost')
+        .description('🚀 Optimize prompts based on cost impact')
+        .option('--file <path>', 'CSV file with prompts to optimize')
+        .option('--cost-threshold <threshold>', 'Minimum cost threshold', '0.01')
+        .option('--format <format>', 'Output format (table, json, csv)', 'table')
+        .option('--export <path>', 'Export cost results to file')
+        .option('-v, --verbose', 'Show detailed cost analysis')
+        .option('--include-token-analysis', 'Include detailed token analysis')
+        .option('--include-cost-breakdown', 'Include detailed cost breakdown')
+        .option('--include-cost-analysis', 'Include cost analysis')
+        .action(async (options) => {
+        try {
+            await handleCostOptimization(options);
+        }
+        catch (error) {
+            logger_1.logger.error('Cost optimization failed:', error);
+            process.exit(1);
+        }
+    });
+}
+async function handleBulkOptimize(options) {
+    logger_1.logger.info('🚀 Running bulk optimization...');
+    try {
+        const prompts = await loadPromptsFromFile(options.file);
+        const optimization = await runBulkOptimization(prompts, options);
+        displayBulkOptimizationResults(optimization, options);
+    }
+    catch (error) {
+        logger_1.logger.error('Failed to run bulk optimization:', error);
+        process.exit(1);
+    }
+}
+async function loadPromptsFromFile(filePath) {
+    return new Promise((resolve, reject) => {
+        const prompts = [];
+        fs.createReadStream(filePath)
+            .pipe((0, csv_parser_1.default)())
+            .on('data', (row) => {
+            prompts.push({
+                promptId: row.prompt_id,
+                promptText: row.prompt_text,
+                model: row.model,
+                frequency: parseInt(row.frequency) || 1,
+                currentCost: parseFloat(row.current_cost) || 0
+            });
+        })
+            .on('end', () => {
+            resolve(prompts);
+        })
+            .on('error', (error) => {
+            reject(new Error(`Failed to read CSV file: ${error.message}`));
+        });
+    });
+}
+async function runBulkOptimization(prompts, options) {
+    const baseUrl = config_1.configManager.get('baseUrl');
+    const apiKey = config_1.configManager.get('apiKey');
+    if (!baseUrl || !apiKey) {
+        console.log(chalk_1.default.red.bold('\n❌ Configuration Missing'));
+        console.log(chalk_1.default.gray('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+        if (!apiKey) {
+            console.log(chalk_1.default.yellow('• API Key is not set'));
+        }
+        if (!baseUrl) {
+            console.log(chalk_1.default.yellow('• Base URL is not set'));
+        }
+        console.log(chalk_1.default.gray('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+        console.log(chalk_1.default.cyan('To set up your configuration, run:'));
+        console.log(chalk_1.default.white('  cost-katana init'));
+        console.log(chalk_1.default.gray('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n'));
+        throw new Error('Configuration incomplete. Please run "cost-katana init" to set up your API key and base URL.');
+    }
+    try {
+        const params = new URLSearchParams();
+        if (options.includeTokenAnalysis)
+            params.append('includeTokenAnalysis', 'true');
+        if (options.includeCostBreakdown)
+            params.append('includeCostBreakdown', 'true');
+        if (options.includeOptimizationSuggestions)
+            params.append('includeOptimizationSuggestions', 'true');
+        if (options.includePriorityRanking)
+            params.append('includePriorityRanking', 'true');
+        const response = await axios_1.default.post(`${baseUrl}/api/bulk-optimize?${params}`, {
+            prompts: prompts,
+            options: {
+                includeTokenAnalysis: options.includeTokenAnalysis,
+                includeCostBreakdown: options.includeCostBreakdown,
+                includeOptimizationSuggestions: options.includeOptimizationSuggestions,
+                includePriorityRanking: options.includePriorityRanking
+            }
+        }, {
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            timeout: 60000,
+        });
+        if (response.status !== 200) {
+            throw new Error(`API returned status ${response.status}`);
+        }
+        if (response.data.success && response.data.data) {
+            return response.data.data;
+        }
+        else {
+            throw new Error(response.data.message || 'Invalid response format');
+        }
+    }
+    catch (error) {
+        if (error.response) {
+            throw new Error(`API Error: ${error.response.status} - ${error.response.data?.message || 'Unknown error'}`);
+        }
+        else if (error.request) {
+            throw new Error('No response received from API');
+        }
+        else {
+            throw new Error(`Request failed: ${error.message}`);
+        }
+    }
+}
+function displayBulkOptimizationResults(optimization, options) {
+    const format = options.format || 'table';
+    if (format === 'json') {
+        console.log(JSON.stringify(optimization, null, 2));
+        return;
+    }
+    else if (format === 'csv') {
+        console.log('Prompt ID,Original Tokens,Optimized Tokens,Token Reduction,Original Cost,Optimized Cost,Cost Savings,Priority');
+        optimization.results.forEach((result) => {
+            console.log(`"${result.promptId}","${result.originalTokens}","${result.optimizedTokens}","${result.tokenReduction}","${result.originalCost}","${result.optimizedCost}","${result.costSavings}","${result.priority}"`);
+        });
+        return;
+    }
+    console.log(chalk_1.default.cyan.bold('\n🚀 Bulk Optimization Results'));
+    console.log(chalk_1.default.gray('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+    // Summary Statistics
+    console.log(chalk_1.default.yellow.bold('\n📊 Summary Statistics'));
+    console.log(chalk_1.default.gray('─'.repeat(50)));
+    console.log(chalk_1.default.white('Total Prompts:'), chalk_1.default.cyan(optimization.totalPrompts));
+    console.log(chalk_1.default.white('Total Token Reduction:'), chalk_1.default.green(`${optimization.totalTokenReduction.toLocaleString()} tokens`));
+    console.log(chalk_1.default.white('Total Cost Savings:'), chalk_1.default.green(`$${optimization.totalCostSavings.toFixed(4)}`));
+    console.log(chalk_1.default.white('Average Token Reduction:'), chalk_1.default.cyan(`${optimization.averageTokenReduction}%`));
+    console.log(chalk_1.default.white('Average Cost Savings:'), chalk_1.default.cyan(`${optimization.averageCostSavings}%`));
+    console.log(chalk_1.default.white('High Impact Prompts:'), chalk_1.default.yellow(optimization.highImpactPrompts));
+    // Individual Results
+    console.log(chalk_1.default.yellow.bold('\n🔍 Individual Results'));
+    console.log(chalk_1.default.gray('─'.repeat(50)));
+    optimization.results.forEach((result, index) => {
+        const priorityColor = result.priority === 'high' ? chalk_1.default.red :
+            result.priority === 'medium' ? chalk_1.default.yellow : chalk_1.default.green;
+        const savingsColor = result.costSavings > 0 ? chalk_1.default.green : chalk_1.default.red;
+        console.log(chalk_1.default.white(`\n${index + 1}. ${result.promptId}:`));
+        console.log(chalk_1.default.gray('   ─'.repeat(40)));
+        // Basic Info
+        console.log(chalk_1.default.white('   Model:'), chalk_1.default.cyan(result.model));
+        console.log(chalk_1.default.white('   Priority:'), priorityColor(result.priority));
+        console.log(chalk_1.default.white('   Frequency:'), chalk_1.default.cyan(result.frequency));
+        // Token Analysis
+        console.log(chalk_1.default.white('   Original Tokens:'), chalk_1.default.cyan(result.originalTokens.toLocaleString()));
+        console.log(chalk_1.default.white('   Optimized Tokens:'), chalk_1.default.cyan(result.optimizedTokens.toLocaleString()));
+        console.log(chalk_1.default.white('   Token Reduction:'), chalk_1.default.green(`${result.tokenReduction}%`));
+        // Cost Analysis
+        console.log(chalk_1.default.white('   Original Cost:'), chalk_1.default.cyan(`$${result.originalCost.toFixed(4)}`));
+        console.log(chalk_1.default.white('   Optimized Cost:'), chalk_1.default.cyan(`$${result.optimizedCost.toFixed(4)}`));
+        console.log(chalk_1.default.white('   Cost Savings:'), savingsColor(`$${result.costSavings.toFixed(4)}`));
+        // Impact Analysis
+        if (result.impact) {
+            console.log(chalk_1.default.white('   Impact Score:'), chalk_1.default.cyan(result.impact.score));
+            console.log(chalk_1.default.white('   Impact Notes:'), chalk_1.default.gray(result.impact.notes));
+        }
+    });
+    // Token Analysis
+    if (optimization.tokenAnalysis) {
+        console.log(chalk_1.default.yellow.bold('\n🔢 Token Analysis'));
+        console.log(chalk_1.default.gray('─'.repeat(50)));
+        console.log(chalk_1.default.white('Total Token Reduction:'), chalk_1.default.green(`${optimization.tokenAnalysis.totalReduction.toLocaleString()} tokens`));
+        console.log(chalk_1.default.white('Average Token Reduction:'), chalk_1.default.cyan(`${optimization.tokenAnalysis.averageReduction}%`));
+        console.log(chalk_1.default.white('Max Token Reduction:'), chalk_1.default.green(`${optimization.tokenAnalysis.maxReduction}%`));
+        console.log(chalk_1.default.white('Min Token Reduction:'), chalk_1.default.cyan(`${optimization.tokenAnalysis.minReduction}%`));
+        if (optimization.tokenAnalysis.breakdown) {
+            console.log(chalk_1.default.white('\nToken Reduction Breakdown:'));
+            Object.entries(optimization.tokenAnalysis.breakdown).forEach(([range, count]) => {
+                console.log(chalk_1.default.gray(`   ${range}: ${count} prompts`));
+            });
+        }
+    }
+    // Cost Breakdown
+    if (optimization.costBreakdown) {
+        console.log(chalk_1.default.yellow.bold('\n💰 Cost Breakdown'));
+        console.log(chalk_1.default.gray('─'.repeat(50)));
+        console.log(chalk_1.default.white('Total Cost Savings:'), chalk_1.default.green(`$${optimization.costBreakdown.totalSavings.toFixed(4)}`));
+        console.log(chalk_1.default.white('Average Cost Savings:'), chalk_1.default.cyan(`${optimization.costBreakdown.averageSavings}%`));
+        console.log(chalk_1.default.white('Max Cost Savings:'), chalk_1.default.green(`$${optimization.costBreakdown.maxSavings.toFixed(4)}`));
+        console.log(chalk_1.default.white('ROI Impact:'), chalk_1.default.cyan(`${optimization.costBreakdown.roiImpact}%`));
+        if (optimization.costBreakdown.byModel) {
+            console.log(chalk_1.default.white('\nSavings by Model:'));
+            Object.entries(optimization.costBreakdown.byModel).forEach(([model, data]) => {
+                console.log(chalk_1.default.gray(`   ${model}: $${data.savings.toFixed(4)} (${data.percentage}%)`));
+            });
+        }
+    }
+    // Priority Ranking
+    if (optimization.priorityRanking) {
+        console.log(chalk_1.default.yellow.bold('\n🏆 Priority Ranking'));
+        console.log(chalk_1.default.gray('─'.repeat(50)));
+        optimization.priorityRanking.forEach((prompt, index) => {
+            const rankColor = index < 3 ? chalk_1.default.green : index < 6 ? chalk_1.default.yellow : chalk_1.default.gray;
+            console.log(chalk_1.default.white(`${index + 1}. ${prompt.promptId}:`));
+            console.log(chalk_1.default.gray(`   Priority: ${rankColor(prompt.priority)}`));
+            console.log(chalk_1.default.gray(`   Impact Score: ${prompt.impactScore}`));
+            console.log(chalk_1.default.gray(`   Potential Savings: $${prompt.potentialSavings.toFixed(4)}`));
+        });
+    }
+    // Optimization Suggestions
+    if (optimization.suggestions && optimization.suggestions.length > 0) {
+        console.log(chalk_1.default.yellow.bold('\n💡 Optimization Suggestions'));
+        console.log(chalk_1.default.gray('─'.repeat(50)));
+        optimization.suggestions.forEach((suggestion, index) => {
+            console.log(chalk_1.default.white(`\n${index + 1}. ${suggestion.type}:`));
+            console.log(chalk_1.default.gray(`   ${suggestion.description}`));
+            console.log(chalk_1.default.gray(`   Potential Savings: $${suggestion.potentialSavings.toFixed(4)}`));
+            console.log(chalk_1.default.gray(`   Implementation: ${suggestion.implementation}`));
+            console.log(chalk_1.default.gray(`   Priority: ${suggestion.priority}`));
+        });
+    }
+    // Export Results
+    if (options.export) {
+        try {
+            exportResults(optimization, options.export, format);
+            console.log(chalk_1.default.green(`\n✅ Results exported to: ${options.export}`));
+        }
+        catch (error) {
+            console.log(chalk_1.default.red(`\n❌ Failed to export results: ${error}`));
+        }
+    }
+    console.log(chalk_1.default.gray('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+}
+async function exportResults(optimization, filePath, format) {
+    if (format === 'json') {
+        fs.writeFileSync(filePath, JSON.stringify(optimization, null, 2));
+    }
+    else if (format === 'csv') {
+        const csvWriter = (0, csv_writer_1.createObjectCsvWriter)({
+            path: filePath,
+            header: [
+                { id: 'promptId', title: 'Prompt ID' },
+                { id: 'model', title: 'Model' },
+                { id: 'originalTokens', title: 'Original Tokens' },
+                { id: 'optimizedTokens', title: 'Optimized Tokens' },
+                { id: 'tokenReduction', title: 'Token Reduction %' },
+                { id: 'originalCost', title: 'Original Cost' },
+                { id: 'optimizedCost', title: 'Optimized Cost' },
+                { id: 'costSavings', title: 'Cost Savings' },
+                { id: 'priority', title: 'Priority' },
+                { id: 'frequency', title: 'Frequency' }
+            ]
+        });
+        await csvWriter.writeRecords(optimization.results);
+    }
+}
+async function handleStrategyOptimization(options) {
+    logger_1.logger.info('🚀 Running strategy-based optimization...');
+    try {
+        const prompts = await loadPromptsFromFile(options.file);
+        const strategies = options.strategies ? options.strategies.split(',') : ['token-reduction', 'cost-optimization', 'quality-preservation'];
+        const optimization = await runStrategyOptimization(prompts, strategies, options);
+        displayStrategyOptimizationResults(optimization, options);
+    }
+    catch (error) {
+        logger_1.logger.error('Failed to run strategy optimization:', error);
+        process.exit(1);
+    }
+}
+async function runStrategyOptimization(prompts, strategies, options) {
+    const baseUrl = config_1.configManager.get('baseUrl');
+    const apiKey = config_1.configManager.get('apiKey');
+    if (!baseUrl || !apiKey) {
+        throw new Error('Configuration incomplete. Please run "cost-katana init" to set up your API key and base URL.');
+    }
+    try {
+        const params = new URLSearchParams();
+        params.append('strategies', strategies.join(','));
+        if (options.includeTokenAnalysis)
+            params.append('includeTokenAnalysis', 'true');
+        if (options.includeCostBreakdown)
+            params.append('includeCostBreakdown', 'true');
+        if (options.includeComparison)
+            params.append('includeComparison', 'true');
+        const response = await axios_1.default.post(`${baseUrl}/api/bulk-optimize/strategies?${params}`, {
+            prompts: prompts,
+            strategies: strategies,
+            options: {
+                includeTokenAnalysis: options.includeTokenAnalysis,
+                includeCostBreakdown: options.includeCostBreakdown,
+                includeComparison: options.includeComparison
+            }
+        }, {
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            timeout: 60000,
+        });
+        if (response.status !== 200) {
+            throw new Error(`API returned status ${response.status}`);
+        }
+        if (response.data.success && response.data.data) {
+            return response.data.data;
+        }
+        else {
+            throw new Error(response.data.message || 'Invalid response format');
+        }
+    }
+    catch (error) {
+        if (error.response) {
+            throw new Error(`API Error: ${error.response.status} - ${error.response.data?.message || 'Unknown error'}`);
+        }
+        else if (error.request) {
+            throw new Error('No response received from API');
+        }
+        else {
+            throw new Error(`Request failed: ${error.message}`);
+        }
+    }
+}
+function displayStrategyOptimizationResults(optimization, options) {
+    const format = options.format || 'table';
+    if (format === 'json') {
+        console.log(JSON.stringify(optimization, null, 2));
+        return;
+    }
+    console.log(chalk_1.default.cyan.bold('\n🚀 Strategy Optimization Results'));
+    console.log(chalk_1.default.gray('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+    // Strategy Comparison
+    console.log(chalk_1.default.yellow.bold('\n📊 Strategy Comparison'));
+    console.log(chalk_1.default.gray('─'.repeat(50)));
+    optimization.strategyResults.forEach((strategy) => {
+        console.log(chalk_1.default.white(`\n${strategy.name}:`));
+        console.log(chalk_1.default.gray('   ─'.repeat(40)));
+        console.log(chalk_1.default.white('   Total Savings:'), chalk_1.default.green(`$${strategy.totalSavings.toFixed(4)}`));
+        console.log(chalk_1.default.white('   Token Reduction:'), chalk_1.default.cyan(`${strategy.tokenReduction}%`));
+        console.log(chalk_1.default.white('   Cost Reduction:'), chalk_1.default.green(`${strategy.costReduction}%`));
+        console.log(chalk_1.default.white('   Quality Impact:'), chalk_1.default.cyan(`${strategy.qualityImpact}%`));
+        console.log(chalk_1.default.white('   Prompts Optimized:'), chalk_1.default.cyan(strategy.promptsOptimized));
+    });
+    // Best Strategy
+    console.log(chalk_1.default.yellow.bold('\n🏆 Best Strategy'));
+    console.log(chalk_1.default.gray('─'.repeat(50)));
+    console.log(chalk_1.default.white('Strategy:'), chalk_1.default.cyan(optimization.bestStrategy.name));
+    console.log(chalk_1.default.white('Total Savings:'), chalk_1.default.green(`$${optimization.bestStrategy.savings.toFixed(4)}`));
+    console.log(chalk_1.default.white('Efficiency Score:'), chalk_1.default.cyan(`${optimization.bestStrategy.efficiencyScore}%`));
+    console.log(chalk_1.default.white('Implementation:'), chalk_1.default.gray(optimization.bestStrategy.implementation));
+    console.log(chalk_1.default.gray('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+}
+async function handlePriorityOptimization(options) {
+    logger_1.logger.info('🚀 Running priority-based optimization...');
+    try {
+        const prompts = await loadPromptsFromFile(options.file);
+        const optimization = await runPriorityOptimization(prompts, options);
+        displayPriorityOptimizationResults(optimization, options);
+    }
+    catch (error) {
+        logger_1.logger.error('Failed to run priority optimization:', error);
+        process.exit(1);
+    }
+}
+async function runPriorityOptimization(prompts, options) {
+    const baseUrl = config_1.configManager.get('baseUrl');
+    const apiKey = config_1.configManager.get('apiKey');
+    if (!baseUrl || !apiKey) {
+        throw new Error('Configuration incomplete. Please run "cost-katana init" to set up your API key and base URL.');
+    }
+    try {
+        const params = new URLSearchParams();
+        params.append('priorityCriteria', options.priorityCriteria || 'cost');
+        if (options.includeTokenAnalysis)
+            params.append('includeTokenAnalysis', 'true');
+        if (options.includeCostBreakdown)
+            params.append('includeCostBreakdown', 'true');
+        if (options.includeImpactAnalysis)
+            params.append('includeImpactAnalysis', 'true');
+        const response = await axios_1.default.post(`${baseUrl}/api/bulk-optimize/priority?${params}`, {
+            prompts: prompts,
+            priorityCriteria: options.priorityCriteria || 'cost',
+            options: {
+                includeTokenAnalysis: options.includeTokenAnalysis,
+                includeCostBreakdown: options.includeCostBreakdown,
+                includeImpactAnalysis: options.includeImpactAnalysis
+            }
+        }, {
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            timeout: 60000,
+        });
+        if (response.status !== 200) {
+            throw new Error(`API returned status ${response.status}`);
+        }
+        if (response.data.success && response.data.data) {
+            return response.data.data;
+        }
+        else {
+            throw new Error(response.data.message || 'Invalid response format');
+        }
+    }
+    catch (error) {
+        if (error.response) {
+            throw new Error(`API Error: ${error.response.status} - ${error.response.data?.message || 'Unknown error'}`);
+        }
+        else if (error.request) {
+            throw new Error('No response received from API');
+        }
+        else {
+            throw new Error(`Request failed: ${error.message}`);
+        }
+    }
+}
+function displayPriorityOptimizationResults(optimization, options) {
+    const format = options.format || 'table';
+    if (format === 'json') {
+        console.log(JSON.stringify(optimization, null, 2));
+        return;
+    }
+    console.log(chalk_1.default.cyan.bold('\n🚀 Priority Optimization Results'));
+    console.log(chalk_1.default.gray('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+    // Priority Breakdown
+    console.log(chalk_1.default.yellow.bold('\n📊 Priority Breakdown'));
+    console.log(chalk_1.default.gray('─'.repeat(50)));
+    console.log(chalk_1.default.white('High Priority:'), chalk_1.default.red(`${optimization.priorityBreakdown.high} prompts`));
+    console.log(chalk_1.default.white('Medium Priority:'), chalk_1.default.yellow(`${optimization.priorityBreakdown.medium} prompts`));
+    console.log(chalk_1.default.white('Low Priority:'), chalk_1.default.green(`${optimization.priorityBreakdown.low} prompts`));
+    // Impact Analysis
+    if (optimization.impactAnalysis) {
+        console.log(chalk_1.default.yellow.bold('\n🎯 Impact Analysis'));
+        console.log(chalk_1.default.gray('─'.repeat(50)));
+        console.log(chalk_1.default.white('High Impact Savings:'), chalk_1.default.green(`$${optimization.impactAnalysis.highImpactSavings.toFixed(4)}`));
+        console.log(chalk_1.default.white('Medium Impact Savings:'), chalk_1.default.yellow(`$${optimization.impactAnalysis.mediumImpactSavings.toFixed(4)}`));
+        console.log(chalk_1.default.white('Low Impact Savings:'), chalk_1.default.cyan(`$${optimization.impactAnalysis.lowImpactSavings.toFixed(4)}`));
+    }
+    console.log(chalk_1.default.gray('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+}
+async function handleModelOptimization(options) {
+    logger_1.logger.info('🚀 Running model-specific optimization...');
+    try {
+        const prompts = await loadPromptsFromFile(options.file);
+        const targetModels = options.targetModels ? options.targetModels.split(',') : ['gpt-4', 'gpt-3.5-turbo', 'claude-3-sonnet'];
+        const optimization = await runModelOptimization(prompts, targetModels, options);
+        displayModelOptimizationResults(optimization, options);
+    }
+    catch (error) {
+        logger_1.logger.error('Failed to run model optimization:', error);
+        process.exit(1);
+    }
+}
+async function runModelOptimization(prompts, targetModels, options) {
+    const baseUrl = config_1.configManager.get('baseUrl');
+    const apiKey = config_1.configManager.get('apiKey');
+    if (!baseUrl || !apiKey) {
+        throw new Error('Configuration incomplete. Please run "cost-katana init" to set up your API key and base URL.');
+    }
+    try {
+        const params = new URLSearchParams();
+        params.append('targetModels', targetModels.join(','));
+        if (options.includeTokenAnalysis)
+            params.append('includeTokenAnalysis', 'true');
+        if (options.includeCostBreakdown)
+            params.append('includeCostBreakdown', 'true');
+        if (options.includeModelComparison)
+            params.append('includeModelComparison', 'true');
+        const response = await axios_1.default.post(`${baseUrl}/api/bulk-optimize/models?${params}`, {
+            prompts: prompts,
+            targetModels: targetModels,
+            options: {
+                includeTokenAnalysis: options.includeTokenAnalysis,
+                includeCostBreakdown: options.includeCostBreakdown,
+                includeModelComparison: options.includeModelComparison
+            }
+        }, {
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            timeout: 60000,
+        });
+        if (response.status !== 200) {
+            throw new Error(`API returned status ${response.status}`);
+        }
+        if (response.data.success && response.data.data) {
+            return response.data.data;
+        }
+        else {
+            throw new Error(response.data.message || 'Invalid response format');
+        }
+    }
+    catch (error) {
+        if (error.response) {
+            throw new Error(`API Error: ${error.response.status} - ${error.response.data?.message || 'Unknown error'}`);
+        }
+        else if (error.request) {
+            throw new Error('No response received from API');
+        }
+        else {
+            throw new Error(`Request failed: ${error.message}`);
+        }
+    }
+}
+function displayModelOptimizationResults(optimization, options) {
+    const format = options.format || 'table';
+    if (format === 'json') {
+        console.log(JSON.stringify(optimization, null, 2));
+        return;
+    }
+    console.log(chalk_1.default.cyan.bold('\n🚀 Model Optimization Results'));
+    console.log(chalk_1.default.gray('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+    // Model Comparison
+    console.log(chalk_1.default.yellow.bold('\n📊 Model Comparison'));
+    console.log(chalk_1.default.gray('─'.repeat(50)));
+    optimization.modelResults.forEach((model) => {
+        console.log(chalk_1.default.white(`\n${model.name}:`));
+        console.log(chalk_1.default.gray('   ─'.repeat(40)));
+        console.log(chalk_1.default.white('   Total Savings:'), chalk_1.default.green(`$${model.totalSavings.toFixed(4)}`));
+        console.log(chalk_1.default.white('   Token Reduction:'), chalk_1.default.cyan(`${model.tokenReduction}%`));
+        console.log(chalk_1.default.white('   Cost Reduction:'), chalk_1.default.green(`${model.costReduction}%`));
+        console.log(chalk_1.default.white('   Prompts Optimized:'), chalk_1.default.cyan(model.promptsOptimized));
+    });
+    console.log(chalk_1.default.gray('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+}
+async function handleFrequencyOptimization(options) {
+    logger_1.logger.info('🚀 Running frequency-based optimization...');
+    try {
+        const prompts = await loadPromptsFromFile(options.file);
+        const threshold = parseInt(options.frequencyThreshold) || 100;
+        const optimization = await runFrequencyOptimization(prompts, threshold, options);
+        displayFrequencyOptimizationResults(optimization, options);
+    }
+    catch (error) {
+        logger_1.logger.error('Failed to run frequency optimization:', error);
+        process.exit(1);
+    }
+}
+async function runFrequencyOptimization(prompts, threshold, options) {
+    const baseUrl = config_1.configManager.get('baseUrl');
+    const apiKey = config_1.configManager.get('apiKey');
+    if (!baseUrl || !apiKey) {
+        throw new Error('Configuration incomplete. Please run "cost-katana init" to set up your API key and base URL.');
+    }
+    try {
+        const params = new URLSearchParams();
+        params.append('threshold', threshold.toString());
+        if (options.includeTokenAnalysis)
+            params.append('includeTokenAnalysis', 'true');
+        if (options.includeCostBreakdown)
+            params.append('includeCostBreakdown', 'true');
+        if (options.includeFrequencyAnalysis)
+            params.append('includeFrequencyAnalysis', 'true');
+        const response = await axios_1.default.post(`${baseUrl}/api/bulk-optimize/frequency?${params}`, {
+            prompts: prompts,
+            threshold: threshold,
+            options: {
+                includeTokenAnalysis: options.includeTokenAnalysis,
+                includeCostBreakdown: options.includeCostBreakdown,
+                includeFrequencyAnalysis: options.includeFrequencyAnalysis
+            }
+        }, {
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            timeout: 60000,
+        });
+        if (response.status !== 200) {
+            throw new Error(`API returned status ${response.status}`);
+        }
+        if (response.data.success && response.data.data) {
+            return response.data.data;
+        }
+        else {
+            throw new Error(response.data.message || 'Invalid response format');
+        }
+    }
+    catch (error) {
+        if (error.response) {
+            throw new Error(`API Error: ${error.response.status} - ${error.response.data?.message || 'Unknown error'}`);
+        }
+        else if (error.request) {
+            throw new Error('No response received from API');
+        }
+        else {
+            throw new Error(`Request failed: ${error.message}`);
+        }
+    }
+}
+function displayFrequencyOptimizationResults(optimization, options) {
+    const format = options.format || 'table';
+    if (format === 'json') {
+        console.log(JSON.stringify(optimization, null, 2));
+        return;
+    }
+    console.log(chalk_1.default.cyan.bold('\n🚀 Frequency Optimization Results'));
+    console.log(chalk_1.default.gray('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+    // Frequency Analysis
+    console.log(chalk_1.default.yellow.bold('\n📊 Frequency Analysis'));
+    console.log(chalk_1.default.gray('─'.repeat(50)));
+    console.log(chalk_1.default.white('Threshold:'), chalk_1.default.cyan(optimization.threshold));
+    console.log(chalk_1.default.white('High Frequency Prompts:'), chalk_1.default.red(optimization.highFrequencyPrompts));
+    console.log(chalk_1.default.white('Medium Frequency Prompts:'), chalk_1.default.yellow(optimization.mediumFrequencyPrompts));
+    console.log(chalk_1.default.white('Low Frequency Prompts:'), chalk_1.default.green(optimization.lowFrequencyPrompts));
+    // Frequency Impact
+    if (optimization.frequencyImpact) {
+        console.log(chalk_1.default.yellow.bold('\n🎯 Frequency Impact'));
+        console.log(chalk_1.default.gray('─'.repeat(50)));
+        console.log(chalk_1.default.white('High Frequency Savings:'), chalk_1.default.green(`$${optimization.frequencyImpact.highFrequencySavings.toFixed(4)}`));
+        console.log(chalk_1.default.white('Medium Frequency Savings:'), chalk_1.default.yellow(`$${optimization.frequencyImpact.mediumFrequencySavings.toFixed(4)}`));
+        console.log(chalk_1.default.white('Low Frequency Savings:'), chalk_1.default.cyan(`$${optimization.frequencyImpact.lowFrequencySavings.toFixed(4)}`));
+    }
+    console.log(chalk_1.default.gray('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+}
+async function handleCostOptimization(options) {
+    logger_1.logger.info('🚀 Running cost-based optimization...');
+    try {
+        const prompts = await loadPromptsFromFile(options.file);
+        const threshold = parseFloat(options.costThreshold) || 0.01;
+        const optimization = await runCostOptimization(prompts, threshold, options);
+        displayCostOptimizationResults(optimization, options);
+    }
+    catch (error) {
+        logger_1.logger.error('Failed to run cost optimization:', error);
+        process.exit(1);
+    }
+}
+async function runCostOptimization(prompts, threshold, options) {
+    const baseUrl = config_1.configManager.get('baseUrl');
+    const apiKey = config_1.configManager.get('apiKey');
+    if (!baseUrl || !apiKey) {
+        throw new Error('Configuration incomplete. Please run "cost-katana init" to set up your API key and base URL.');
+    }
+    try {
+        const params = new URLSearchParams();
+        params.append('threshold', threshold.toString());
+        if (options.includeTokenAnalysis)
+            params.append('includeTokenAnalysis', 'true');
+        if (options.includeCostBreakdown)
+            params.append('includeCostBreakdown', 'true');
+        if (options.includeCostAnalysis)
+            params.append('includeCostAnalysis', 'true');
+        const response = await axios_1.default.post(`${baseUrl}/api/bulk-optimize/cost?${params}`, {
+            prompts: prompts,
+            threshold: threshold,
+            options: {
+                includeTokenAnalysis: options.includeTokenAnalysis,
+                includeCostBreakdown: options.includeCostBreakdown,
+                includeCostAnalysis: options.includeCostAnalysis
+            }
+        }, {
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            timeout: 60000,
+        });
+        if (response.status !== 200) {
+            throw new Error(`API returned status ${response.status}`);
+        }
+        if (response.data.success && response.data.data) {
+            return response.data.data;
+        }
+        else {
+            throw new Error(response.data.message || 'Invalid response format');
+        }
+    }
+    catch (error) {
+        if (error.response) {
+            throw new Error(`API Error: ${error.response.status} - ${error.response.data?.message || 'Unknown error'}`);
+        }
+        else if (error.request) {
+            throw new Error('No response received from API');
+        }
+        else {
+            throw new Error(`Request failed: ${error.message}`);
+        }
+    }
+}
+function displayCostOptimizationResults(optimization, options) {
+    const format = options.format || 'table';
+    if (format === 'json') {
+        console.log(JSON.stringify(optimization, null, 2));
+        return;
+    }
+    console.log(chalk_1.default.cyan.bold('\n🚀 Cost Optimization Results'));
+    console.log(chalk_1.default.gray('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+    // Cost Analysis
+    console.log(chalk_1.default.yellow.bold('\n📊 Cost Analysis'));
+    console.log(chalk_1.default.gray('─'.repeat(50)));
+    console.log(chalk_1.default.white('Threshold:'), chalk_1.default.cyan(`$${optimization.threshold}`));
+    console.log(chalk_1.default.white('High Cost Prompts:'), chalk_1.default.red(optimization.highCostPrompts));
+    console.log(chalk_1.default.white('Medium Cost Prompts:'), chalk_1.default.yellow(optimization.mediumCostPrompts));
+    console.log(chalk_1.default.white('Low Cost Prompts:'), chalk_1.default.green(optimization.lowCostPrompts));
+    // Cost Impact
+    if (optimization.costImpact) {
+        console.log(chalk_1.default.yellow.bold('\n🎯 Cost Impact'));
+        console.log(chalk_1.default.gray('─'.repeat(50)));
+        console.log(chalk_1.default.white('High Cost Savings:'), chalk_1.default.green(`$${optimization.costImpact.highCostSavings.toFixed(4)}`));
+        console.log(chalk_1.default.white('Medium Cost Savings:'), chalk_1.default.yellow(`$${optimization.costImpact.mediumCostSavings.toFixed(4)}`));
+        console.log(chalk_1.default.white('Low Cost Savings:'), chalk_1.default.cyan(`$${optimization.costImpact.lowCostSavings.toFixed(4)}`));
+    }
+    console.log(chalk_1.default.gray('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+}
+//# sourceMappingURL=bulk-optimize.js.map