cloud-cost-cli 0.1.1 → 0.3.0-beta.1

package/dist/src/analyzers/pricing-service.js

@@ -0,0 +1,263 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PricingService = void 0;
+exports.getS3MonthlyCost = getS3MonthlyCost;
+exports.getELBMonthlyCost = getELBMonthlyCost;
+exports.getEIPMonthlyCost = getEIPMonthlyCost;
+const client_pricing_1 = require("@aws-sdk/client-pricing");
+// Cache for pricing data to avoid repeated API calls
+const pricingCache = new Map();
+class PricingService {
+    pricingClient;
+    region;
+    constructor(region = 'us-east-1') {
+        this.region = region;
+        // Pricing API is only available in us-east-1 and ap-south-1
+        this.pricingClient = new client_pricing_1.PricingClient({ region: 'us-east-1' });
+    }
+    /**
+     * Get EC2 instance on-demand pricing for the configured region
+     */
+    async getEC2Price(instanceType) {
+        const cacheKey = `ec2-${this.region}-${instanceType}`;
+        if (pricingCache.has(cacheKey)) {
+            return pricingCache.get(cacheKey);
+        }
+        try {
+            const response = await this.pricingClient.send(new client_pricing_1.GetProductsCommand({
+                ServiceCode: 'AmazonEC2',
+                Filters: [
+                    {
+                        Type: 'TERM_MATCH',
+                        Field: 'instanceType',
+                        Value: instanceType,
+                    },
+                    {
+                        Type: 'TERM_MATCH',
+                        Field: 'location',
+                        Value: this.getLocationName(this.region),
+                    },
+                    {
+                        Type: 'TERM_MATCH',
+                        Field: 'tenancy',
+                        Value: 'Shared',
+                    },
+                    {
+                        Type: 'TERM_MATCH',
+                        Field: 'operatingSystem',
+                        Value: 'Linux',
+                    },
+                    {
+                        Type: 'TERM_MATCH',
+                        Field: 'preInstalledSw',
+                        Value: 'NA',
+                    },
+                    {
+                        Type: 'TERM_MATCH',
+                        Field: 'capacitystatus',
+                        Value: 'Used',
+                    },
+                ],
+                MaxResults: 1,
+            }));
+            const hourlyPrice = this.extractPriceFromResponse(response.PriceList);
+            const monthlyPrice = hourlyPrice * 730; // 730 hours per month
+            pricingCache.set(cacheKey, monthlyPrice);
+            return monthlyPrice;
+        }
+        catch (error) {
+            // Fallback to estimate if API fails
+            return this.getFallbackEC2Price(instanceType);
+        }
+    }
+    /**
+     * Get EBS volume pricing per GB
+     */
+    async getEBSPrice(volumeType) {
+        const cacheKey = `ebs-${this.region}-${volumeType}`;
+        if (pricingCache.has(cacheKey)) {
+            return pricingCache.get(cacheKey);
+        }
+        try {
+            const response = await this.pricingClient.send(new client_pricing_1.GetProductsCommand({
+                ServiceCode: 'AmazonEC2',
+                Filters: [
+                    {
+                        Type: 'TERM_MATCH',
+                        Field: 'productFamily',
+                        Value: 'Storage',
+                    },
+                    {
+                        Type: 'TERM_MATCH',
+                        Field: 'volumeApiName',
+                        Value: volumeType,
+                    },
+                    {
+                        Type: 'TERM_MATCH',
+                        Field: 'location',
+                        Value: this.getLocationName(this.region),
+                    },
+                ],
+                MaxResults: 1,
+            }));
+            const pricePerGB = this.extractPriceFromResponse(response.PriceList);
+            pricingCache.set(cacheKey, pricePerGB);
+            return pricePerGB;
+        }
+        catch (error) {
+            return this.getFallbackEBSPrice(volumeType);
+        }
+    }
+    /**
+     * Get RDS instance pricing
+     */
+    async getRDSPrice(instanceClass, engine = 'mysql') {
+        const cacheKey = `rds-${this.region}-${instanceClass}-${engine}`;
+        if (pricingCache.has(cacheKey)) {
+            return pricingCache.get(cacheKey);
+        }
+        try {
+            const response = await this.pricingClient.send(new client_pricing_1.GetProductsCommand({
+                ServiceCode: 'AmazonRDS',
+                Filters: [
+                    {
+                        Type: 'TERM_MATCH',
+                        Field: 'instanceType',
+                        Value: instanceClass,
+                    },
+                    {
+                        Type: 'TERM_MATCH',
+                        Field: 'location',
+                        Value: this.getLocationName(this.region),
+                    },
+                    {
+                        Type: 'TERM_MATCH',
+                        Field: 'databaseEngine',
+                        Value: this.normalizeEngine(engine),
+                    },
+                    {
+                        Type: 'TERM_MATCH',
+                        Field: 'deploymentOption',
+                        Value: 'Single-AZ',
+                    },
+                ],
+                MaxResults: 1,
+            }));
+            const hourlyPrice = this.extractPriceFromResponse(response.PriceList);
+            const monthlyPrice = hourlyPrice * 730;
+            pricingCache.set(cacheKey, monthlyPrice);
+            return monthlyPrice;
+        }
+        catch (error) {
+            return this.getFallbackRDSPrice(instanceClass);
+        }
+    }
+    /**
+     * Extract price from AWS Pricing API response
+     */
+    extractPriceFromResponse(priceList) {
+        if (!priceList || priceList.length === 0) {
+            return 0;
+        }
+        try {
+            const product = JSON.parse(priceList[0]);
+            const terms = product.terms?.OnDemand;
+            if (!terms)
+                return 0;
+            const termKey = Object.keys(terms)[0];
+            const priceDimensions = terms[termKey]?.priceDimensions;
+            if (!priceDimensions)
+                return 0;
+            const dimensionKey = Object.keys(priceDimensions)[0];
+            const pricePerUnit = priceDimensions[dimensionKey]?.pricePerUnit?.USD;
+            return parseFloat(pricePerUnit || '0');
+        }
+        catch (error) {
+            return 0;
+        }
+    }
+    /**
+     * Convert AWS region code to location name used in Pricing API
+     */
+    getLocationName(region) {
+        const locationMap = {
+            'us-east-1': 'US East (N. Virginia)',
+            'us-east-2': 'US East (Ohio)',
+            'us-west-1': 'US West (N. California)',
+            'us-west-2': 'US West (Oregon)',
+            'eu-west-1': 'EU (Ireland)',
+            'eu-central-1': 'EU (Frankfurt)',
+            'ap-southeast-1': 'Asia Pacific (Singapore)',
+            'ap-southeast-2': 'Asia Pacific (Sydney)',
+            'ap-northeast-1': 'Asia Pacific (Tokyo)',
+            // Add more as needed
+        };
+        return locationMap[region] || 'US East (N. Virginia)';
+    }
+    /**
+     * Normalize RDS engine name for Pricing API
+     */
+    normalizeEngine(engine) {
+        const engineMap = {
+            'mysql': 'MySQL',
+            'postgres': 'PostgreSQL',
+            'mariadb': 'MariaDB',
+            'aurora': 'Aurora MySQL',
+            'aurora-mysql': 'Aurora MySQL',
+            'aurora-postgresql': 'Aurora PostgreSQL',
+        };
+        return engineMap[engine.toLowerCase()] || 'MySQL';
+    }
+    /**
+     * Fallback estimates when API calls fail (based on us-east-1)
+     */
+    getFallbackEC2Price(instanceType) {
+        const estimates = {
+            't3.micro': 7.59,
+            't3.small': 15.18,
+            't3.medium': 30.37,
+            't3.large': 60.74,
+            'm5.large': 70.08,
+            'm5.xlarge': 140.16,
+        };
+        return estimates[instanceType] || 50; // Generic estimate
+    }
+    getFallbackEBSPrice(volumeType) {
+        const estimates = {
+            'gp3': 0.08,
+            'gp2': 0.10,
+            'io1': 0.125,
+            'io2': 0.125,
+        };
+        return estimates[volumeType] || 0.08;
+    }
+    getFallbackRDSPrice(instanceClass) {
+        const estimates = {
+            'db.t3.micro': 11.01,
+            'db.t3.small': 22.63,
+            'db.t3.medium': 45.26,
+            'db.t3.large': 90.51,
+        };
+        return estimates[instanceClass] || 100;
+    }
+}
+exports.PricingService = PricingService;
+// Simple estimates for services where Pricing API is complex (S3, ELB, EIP)
+function getS3MonthlyCost(sizeGB, storageClass = 'standard') {
+    const pricing = {
+        'STANDARD': 0.023,
+        'INTELLIGENT_TIERING': 0.023,
+        'GLACIER': 0.004,
+        'DEEP_ARCHIVE': 0.00099,
+    };
+    const pricePerGB = pricing[storageClass] || 0.023;
+    return sizeGB * pricePerGB;
+}
+function getELBMonthlyCost(type = 'alb') {
+    // ELB pricing is relatively consistent across regions (~$16-18/month base)
+    return type === 'clb' ? 18.25 : 16.43;
+}
+function getEIPMonthlyCost() {
+    // ~$3.65/month when unattached (consistent across regions)
+    return 3.65;
+}

package/dist/src/commands/ask.d.ts

@@ -0,0 +1,11 @@
+interface AskCommandOptions {
+    provider?: string;
+    aiProvider?: string;
+    aiModel?: string;
+    region?: string;
+    location?: string;
+    subscriptionId?: string;
+}
+export declare function askCommand(query: string, options: AskCommandOptions): Promise<void>;
+export declare function saveScanCache(provider: string, region: string | undefined, report: any): void;
+export {};

package/dist/src/commands/ask.js

@@ -0,0 +1,164 @@
+"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.askCommand = askCommand;
+exports.saveScanCache = saveScanCache;
+const ai_1 = require("../services/ai");
+const logger_1 = require("../utils/logger");
+const config_1 = require("../utils/config");
+const chalk_1 = __importDefault(require("chalk"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+async function askCommand(query, options) {
+    (0, logger_1.info)(`Analyzing: "${query}"`);
+    // Load most recent scan results
+    const scanData = loadRecentScan();
+    if (!scanData) {
+        (0, logger_1.error)('No recent scan found. Please run a scan first:');
+        (0, logger_1.info)('  cloud-cost-cli scan --provider aws --region us-east-1');
+        process.exit(1);
+    }
+    const ageMinutes = Math.floor((Date.now() - scanData.timestamp) / 60000);
+    (0, logger_1.info)(`Using scan from ${ageMinutes} minutes ago (${scanData.provider}${scanData.region ? ', ' + scanData.region : ''})`);
+    // Initialize AI service
+    // Load config file to get defaults
+    const fileConfig = config_1.ConfigLoader.load();
+    // CLI flags override config file
+    const provider = options.aiProvider || fileConfig.ai?.provider || 'openai';
+    const model = options.aiModel || fileConfig.ai?.model;
+    if (provider === 'openai' && !process.env.OPENAI_API_KEY && !fileConfig.ai?.apiKey) {
+        (0, logger_1.error)('Natural language queries require OPENAI_API_KEY or --ai-provider ollama');
+        (0, logger_1.info)('Set it with: export OPENAI_API_KEY="sk-..."');
+        (0, logger_1.info)('Or run: cloud-cost-cli config set ai.provider ollama');
+        process.exit(1);
+    }
+    try {
+        const aiService = new ai_1.AIService({
+            provider,
+            apiKey: provider === 'openai' ? (process.env.OPENAI_API_KEY || fileConfig.ai?.apiKey) : undefined,
+            model,
+        });
+        console.log(chalk_1.default.cyan('\n🤔 Thinking...\n'));
+        const answer = await aiService.answerQuery(query, scanData.report);
+        console.log(chalk_1.default.bold('💡 Answer:\n'));
+        console.log(chalk_1.default.white(answer.response));
+        if (answer.suggestions && answer.suggestions.length > 0) {
+            console.log(chalk_1.default.bold('\n📋 Suggestions:\n'));
+            answer.suggestions.forEach((suggestion, i) => {
+                console.log(chalk_1.default.green(`  ${i + 1}. ${suggestion}`));
+            });
+        }
+        if (answer.relatedOpportunities && answer.relatedOpportunities.length > 0) {
+            console.log(chalk_1.default.bold('\n🎯 Related Opportunities:\n'));
+            answer.relatedOpportunities.forEach((opp, i) => {
+                console.log(chalk_1.default.yellow(`  ${i + 1}. ${opp.resourceId}: ${opp.recommendation} (Save $${opp.estimatedSavings.toFixed(2)}/mo)`));
+            });
+        }
+        console.log();
+    }
+    catch (err) {
+        (0, logger_1.error)(`Query failed: ${err.message}`);
+        process.exit(1);
+    }
+}
+function loadRecentScan() {
+    const cacheDir = path.join(process.env.HOME || '/tmp', '.cloud-cost-cli', 'scans');
+    if (!fs.existsSync(cacheDir)) {
+        return null;
+    }
+    try {
+        const files = fs.readdirSync(cacheDir)
+            .filter(f => f.endsWith('.json'))
+            .map(f => ({
+            path: path.join(cacheDir, f),
+            stat: fs.statSync(path.join(cacheDir, f)),
+        }))
+            .sort((a, b) => b.stat.mtimeMs - a.stat.mtimeMs);
+        if (files.length === 0) {
+            return null;
+        }
+        // Get most recent scan (max 24 hours old)
+        const mostRecent = files[0];
+        const ageMs = Date.now() - mostRecent.stat.mtimeMs;
+        if (ageMs > 24 * 60 * 60 * 1000) {
+            return null; // Too old
+        }
+        const data = fs.readFileSync(mostRecent.path, 'utf-8');
+        return JSON.parse(data);
+    }
+    catch (err) {
+        return null;
+    }
+}
+function saveScanCache(provider, region, report) {
+    const cacheDir = path.join(process.env.HOME || '/tmp', '.cloud-cost-cli', 'scans');
+    if (!fs.existsSync(cacheDir)) {
+        fs.mkdirSync(cacheDir, { recursive: true });
+    }
+    const cache = {
+        timestamp: Date.now(),
+        provider,
+        region,
+        report,
+    };
+    const filename = `scan-${provider}-${Date.now()}.json`;
+    const filepath = path.join(cacheDir, filename);
+    try {
+        fs.writeFileSync(filepath, JSON.stringify(cache, null, 2), 'utf-8');
+        // Clean up old scans (keep only last 10)
+        const files = fs.readdirSync(cacheDir)
+            .filter(f => f.endsWith('.json'))
+            .map(f => ({
+            path: path.join(cacheDir, f),
+            stat: fs.statSync(path.join(cacheDir, f)),
+        }))
+            .sort((a, b) => b.stat.mtimeMs - a.stat.mtimeMs);
+        // Delete all but the 10 most recent
+        files.slice(10).forEach(f => {
+            try {
+                fs.unlinkSync(f.path);
+            }
+            catch (err) {
+                // Ignore deletion errors
+            }
+        });
+    }
+    catch (err) {
+        // Failed to save cache, not critical
+    }
+}

package/dist/src/commands/config.d.ts

@@ -0,0 +1 @@
+export declare function configCommand(action: string, key?: string, value?: string): Promise<void>;

package/dist/src/commands/config.js

@@ -0,0 +1,120 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configCommand = configCommand;
+const config_1 = require("../utils/config");
+const logger_1 = require("../utils/logger");
+const chalk_1 = __importDefault(require("chalk"));
+async function configCommand(action, key, value) {
+    switch (action) {
+        case 'init':
+            initConfig();
+            break;
+        case 'show':
+            showConfig();
+            break;
+        case 'get':
+            if (!key) {
+                (0, logger_1.error)('Key required for get action');
+                process.exit(1);
+            }
+            getConfigValue(key);
+            break;
+        case 'set':
+            if (!key || !value) {
+                (0, logger_1.error)('Key and value required for set action');
+                process.exit(1);
+            }
+            setConfigValue(key, value);
+            break;
+        case 'path':
+            showConfigPath();
+            break;
+        default:
+            (0, logger_1.error)(`Unknown config action: ${action}`);
+            (0, logger_1.info)('Available actions: init, show, get, set, path');
+            process.exit(1);
+    }
+}
+function initConfig() {
+    const configPath = config_1.ConfigLoader.getConfigPath();
+    const example = config_1.ConfigLoader.generateExample();
+    (0, logger_1.info)('Creating example configuration...');
+    console.log(chalk_1.default.dim('─'.repeat(80)));
+    console.log(example);
+    console.log(chalk_1.default.dim('─'.repeat(80)));
+    config_1.ConfigLoader.save(JSON.parse(example));
+    (0, logger_1.success)(`Configuration saved to: ${configPath}`);
+    (0, logger_1.info)('Edit this file to customize your settings');
+}
+function showConfig() {
+    const config = config_1.ConfigLoader.load();
+    const configPath = config_1.ConfigLoader.getConfigPath();
+    console.log(chalk_1.default.bold(`\nConfiguration (from ${configPath}):\n`));
+    console.log(JSON.stringify(config, null, 2));
+    console.log();
+    const errors = config_1.ConfigLoader.validate(config);
+    if (errors.length > 0) {
+        console.log(chalk_1.default.yellow('⚠️  Validation warnings:'));
+        errors.forEach(err => console.log(chalk_1.default.yellow(`  - ${err}`)));
+        console.log();
+    }
+}
+function getConfigValue(key) {
+    const config = config_1.ConfigLoader.load();
+    const value = getNestedValue(config, key);
+    if (value === undefined) {
+        (0, logger_1.error)(`Key not found: ${key}`);
+        process.exit(1);
+    }
+    console.log(JSON.stringify(value, null, 2));
+}
+function setConfigValue(key, value) {
+    const config = config_1.ConfigLoader.load();
+    // Parse value (try JSON first, fall back to string)
+    let parsedValue = value;
+    try {
+        parsedValue = JSON.parse(value);
+    }
+    catch (e) {
+        // Not JSON, use as string
+    }
+    setNestedValue(config, key, parsedValue);
+    const errors = config_1.ConfigLoader.validate(config);
+    if (errors.length > 0) {
+        (0, logger_1.error)('Configuration validation failed:');
+        errors.forEach(err => console.log(chalk_1.default.red(`  - ${err}`)));
+        process.exit(1);
+    }
+    config_1.ConfigLoader.save(config);
+    (0, logger_1.success)(`Set ${key} = ${JSON.stringify(parsedValue)}`);
+}
+function showConfigPath() {
+    const configPath = config_1.ConfigLoader.getConfigPath();
+    console.log(configPath);
+}
+function getNestedValue(obj, path) {
+    const keys = path.split('.');
+    let current = obj;
+    for (const key of keys) {
+        if (current === undefined || current === null) {
+            return undefined;
+        }
+        current = current[key];
+    }
+    return current;
+}
+function setNestedValue(obj, path, value) {
+    const keys = path.split('.');
+    let current = obj;
+    for (let i = 0; i < keys.length - 1; i++) {
+        const key = keys[i];
+        if (current[key] === undefined || typeof current[key] !== 'object') {
+            current[key] = {};
+        }
+        current = current[key];
+    }
+    current[keys[keys.length - 1]] = value;
+}

package/dist/src/commands/costs.d.ts

@@ -0,0 +1,6 @@
+interface CostsCommandOptions {
+    days?: string;
+    clear?: boolean;
+}
+export declare function costsCommand(options: CostsCommandOptions): Promise<void>;
+export {};

package/dist/src/commands/costs.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.costsCommand = costsCommand;
+const cost_tracker_1 = require("../utils/cost-tracker");
+const logger_1 = require("../utils/logger");
+const chalk_1 = __importDefault(require("chalk"));
+async function costsCommand(options) {
+    const tracker = new cost_tracker_1.CostTracker();
+    if (options.clear) {
+        tracker.clear();
+        (0, logger_1.info)('Cost tracking data cleared');
+        return;
+    }
+    const days = parseInt(options.days || '30');
+    const summary = tracker.getSummary(days);
+    console.log(chalk_1.default.bold(`\n💰 AI Cost Summary (last ${days} days):\n`));
+    if (summary.totalOperations === 0) {
+        console.log(chalk_1.default.dim('No AI operations tracked yet.'));
+        console.log(chalk_1.default.dim('Use --explain or ask commands to generate AI insights.\n'));
+        return;
+    }
+    console.log(chalk_1.default.bold('Total:'));
+    console.log(`  Operations: ${summary.totalOperations}`);
+    console.log(`  Cost: $${summary.totalCost.toFixed(4)}`);
+    console.log();
+    console.log(chalk_1.default.bold('By Provider:'));
+    Object.entries(summary.byProvider).forEach(([provider, stats]) => {
+        const icon = provider === 'openai' ? '☁️ ' : '🏠';
+        console.log(`  ${icon} ${provider}:`);
+        console.log(`    Operations: ${stats.operations}`);
+        console.log(`    Cost: $${stats.cost.toFixed(4)}`);
+    });
+    console.log();
+    console.log(chalk_1.default.bold('By Model:'));
+    Object.entries(summary.byModel).forEach(([model, stats]) => {
+        console.log(`  ${model}:`);
+        console.log(`    Operations: ${stats.operations}`);
+        console.log(`    Cost: $${stats.cost.toFixed(4)}`);
+    });
+    console.log();
+    // Show average cost per operation
+    const avgCost = summary.totalCost / summary.totalOperations;
+    console.log(chalk_1.default.dim(`Average cost per operation: $${avgCost.toFixed(4)}`));
+    // Estimate monthly cost at current rate
+    const daysElapsed = days;
+    const monthlyEstimate = (summary.totalCost / daysElapsed) * 30;
+    if (daysElapsed >= 7) {
+        console.log(chalk_1.default.dim(`Estimated monthly cost: $${monthlyEstimate.toFixed(2)}`));
+    }
+    console.log();
+}

package/dist/src/commands/scan.d.ts

@@ -2,11 +2,17 @@ interface ScanCommandOptions {
     provider: string;
     region?: string;
     profile?: string;
+    subscriptionId?: string;
+    location?: string;
     top?: string;
     output?: string;
     days?: string;
     minSavings?: string;
     verbose?: boolean;
+    accurate?: boolean;
+    explain?: boolean;
+    aiProvider?: string;
+    aiModel?: string;
 }
 export declare function scanCommand(options: ScanCommandOptions): Promise<void>;
 export {};