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

package/dist/src/providers/azure/sql.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AZURE_SQL_PRICING = void 0;
+exports.analyzeAzureSQL = analyzeAzureSQL;
+// Azure SQL Database pricing (per month, East US, vCore model)
+exports.AZURE_SQL_PRICING = {
+    'GP_Gen5_2': 438.29, // General Purpose, 2 vCores
+    'GP_Gen5_4': 876.58, // General Purpose, 4 vCores
+    'GP_Gen5_8': 1753.16, // General Purpose, 8 vCores
+    'BC_Gen5_2': 876.58, // Business Critical, 2 vCores
+    'BC_Gen5_4': 1753.16, // Business Critical, 4 vCores
+};
+function getSQLMonthlyCost(sku) {
+    return exports.AZURE_SQL_PRICING[sku] || 500; // Fallback estimate
+}
+async function analyzeAzureSQL(client) {
+    const sqlClient = client.getSqlClient();
+    const monitorClient = client.getMonitorClient();
+    const opportunities = [];
+    try {
+        // List all SQL servers
+        const servers = sqlClient.servers.list();
+        for await (const server of servers) {
+            if (!server.id || !server.name)
+                continue;
+            // Filter by location if specified
+            if (client.location && server.location?.toLowerCase() !== client.location.toLowerCase()) {
+                continue;
+            }
+            const resourceGroup = extractResourceGroup(server.id);
+            if (!resourceGroup)
+                continue;
+            try {
+                // List databases on this server
+                const databases = sqlClient.databases.listByServer(resourceGroup, server.name);
+                for await (const db of databases) {
+                    if (!db.id || !db.name || db.name === 'master')
+                        continue;
+                    const sku = db.sku?.name || 'Unknown';
+                    const tier = db.sku?.tier || 'Unknown';
+                    const currentCost = getSQLMonthlyCost(sku);
+                    // Get DTU/CPU usage metrics
+                    const avgDtu = await getAverageDTU(monitorClient, db.id, 7);
+                    // Opportunity 1: Low utilization database
+                    if (avgDtu < 10) {
+                        opportunities.push({
+                            id: `azure-sql-underutilized-${db.name}`,
+                            provider: 'azure',
+                            resourceType: 'sql',
+                            resourceId: db.id,
+                            resourceName: db.name,
+                            category: 'oversized',
+                            currentCost,
+                            estimatedSavings: currentCost * 0.5, // Could downsize by ~50%
+                            confidence: 'medium',
+                            recommendation: `Database is underutilized (${avgDtu.toFixed(1)}% avg DTU). Consider downsizing tier.`,
+                            metadata: {
+                                sku,
+                                tier,
+                                avgDtu,
+                                server: server.name,
+                                location: db.location,
+                            },
+                            detectedAt: new Date(),
+                        });
+                    }
+                    // Opportunity 2: Business Critical that could be General Purpose
+                    if (tier === 'BusinessCritical' && avgDtu < 30) {
+                        opportunities.push({
+                            id: `azure-sql-tier-${db.name}`,
+                            provider: 'azure',
+                            resourceType: 'sql',
+                            resourceId: db.id,
+                            resourceName: db.name,
+                            category: 'oversized',
+                            currentCost,
+                            estimatedSavings: currentCost * 0.5, // BC is ~2x GP cost
+                            confidence: 'low',
+                            recommendation: 'Consider switching from Business Critical to General Purpose tier if high availability is not required.',
+                            metadata: {
+                                sku,
+                                tier,
+                                avgDtu,
+                                server: server.name,
+                            },
+                            detectedAt: new Date(),
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                // Skip this server if we can't fetch databases
+                continue;
+            }
+        }
+        return opportunities;
+    }
+    catch (error) {
+        console.error('Error analyzing Azure SQL:', error);
+        return opportunities;
+    }
+}
+async function getAverageDTU(monitorClient, resourceId, days) {
+    try {
+        const endTime = new Date();
+        const startTime = new Date();
+        startTime.setDate(startTime.getDate() - days);
+        const metrics = await monitorClient.metrics.list(resourceId, {
+            timespan: `${startTime.toISOString()}/${endTime.toISOString()}`,
+            interval: 'PT1H',
+            metricnames: 'dtu_consumption_percent',
+            aggregation: 'Average',
+        });
+        const timeseries = metrics.value?.[0]?.timeseries?.[0]?.data || [];
+        if (timeseries.length === 0) {
+            return 0;
+        }
+        const values = timeseries
+            .map((d) => d.average)
+            .filter((v) => v !== null && v !== undefined);
+        if (values.length === 0) {
+            return 0;
+        }
+        const sum = values.reduce((a, b) => a + b, 0);
+        return sum / values.length;
+    }
+    catch (error) {
+        return 0;
+    }
+}
+function extractResourceGroup(resourceId) {
+    const match = resourceId.match(/resourceGroups\/([^\/]+)/i);
+    return match ? match[1] : null;
+}

package/dist/src/providers/azure/storage.d.ts

@@ -0,0 +1,8 @@
+import { AzureClient } from './client';
+import { SavingsOpportunity } from '../../types/opportunity';
+export declare const AZURE_STORAGE_PRICING: {
+    hot: number;
+    cool: number;
+    archive: number;
+};
+export declare function analyzeAzureStorage(client: AzureClient): Promise<SavingsOpportunity[]>;

package/dist/src/providers/azure/storage.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AZURE_STORAGE_PRICING = void 0;
+exports.analyzeAzureStorage = analyzeAzureStorage;
+// Azure Blob Storage pricing (per GB/month, East US)
+exports.AZURE_STORAGE_PRICING = {
+    hot: 0.0184,
+    cool: 0.01,
+    archive: 0.002,
+};
+async function analyzeAzureStorage(client) {
+    const storageClient = client.getStorageClient();
+    const opportunities = [];
+    try {
+        // List all storage accounts
+        const accounts = storageClient.storageAccounts.list();
+        for await (const account of accounts) {
+            if (!account.id || !account.name)
+                continue;
+            // Filter by location if specified
+            if (client.location && account.location?.toLowerCase() !== client.location.toLowerCase()) {
+                continue;
+            }
+            const resourceGroup = extractResourceGroup(account.id);
+            if (!resourceGroup)
+                continue;
+            try {
+                // Get blob service properties
+                const blobServices = await storageClient.blobServices.getServiceProperties(resourceGroup, account.name);
+                // Check if lifecycle management is enabled
+                const hasLifecyclePolicy = await hasLifecycleManagement(storageClient, resourceGroup, account.name);
+                if (!hasLifecyclePolicy) {
+                    // Estimate potential savings (assume 30% of data could move to cool/archive)
+                    // This is a rough estimate - actual savings depend on usage patterns
+                    const estimatedSavings = 50; // Conservative estimate
+                    opportunities.push({
+                        id: `azure-storage-lifecycle-${account.name}`,
+                        provider: 'azure',
+                        resourceType: 'storage',
+                        resourceId: account.id,
+                        resourceName: account.name,
+                        category: 'misconfigured',
+                        currentCost: 100, // Placeholder - hard to estimate without usage data
+                        estimatedSavings,
+                        confidence: 'low',
+                        recommendation: 'Enable lifecycle management to automatically move old data to Cool or Archive tiers.',
+                        metadata: {
+                            location: account.location,
+                            accountType: account.kind,
+                            replication: account.sku?.name,
+                        },
+                        detectedAt: new Date(),
+                    });
+                }
+                // Check for public access
+                if (account.allowBlobPublicAccess === true) {
+                    opportunities.push({
+                        id: `azure-storage-public-${account.name}`,
+                        provider: 'azure',
+                        resourceType: 'storage',
+                        resourceId: account.id,
+                        resourceName: account.name,
+                        category: 'misconfigured',
+                        currentCost: 0,
+                        estimatedSavings: 0,
+                        confidence: 'high',
+                        recommendation: 'Public blob access is enabled. Review security settings.',
+                        metadata: {
+                            location: account.location,
+                            issue: 'security',
+                        },
+                        detectedAt: new Date(),
+                    });
+                }
+            }
+            catch (error) {
+                // Skip this account if we can't fetch details
+                continue;
+            }
+        }
+        return opportunities;
+    }
+    catch (error) {
+        console.error('Error analyzing Azure storage:', error);
+        return opportunities;
+    }
+}
+async function hasLifecycleManagement(storageClient, resourceGroup, accountName) {
+    try {
+        const policy = await storageClient.managementPolicies.get(resourceGroup, accountName, 'default');
+        return policy && policy.policy && policy.policy.rules && policy.policy.rules.length > 0;
+    }
+    catch (error) {
+        return false;
+    }
+}
+function extractResourceGroup(resourceId) {
+    const match = resourceId.match(/resourceGroups\/([^\/]+)/i);
+    return match ? match[1] : null;
+}

package/dist/src/providers/azure/vms.d.ts

@@ -0,0 +1,4 @@
+import { AzureClient } from './client';
+import { SavingsOpportunity } from '../../types/opportunity';
+export declare const AZURE_VM_PRICING: Record<string, number>;
+export declare function analyzeAzureVMs(client: AzureClient): Promise<SavingsOpportunity[]>;

package/dist/src/providers/azure/vms.js

@@ -0,0 +1,164 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AZURE_VM_PRICING = void 0;
+exports.analyzeAzureVMs = analyzeAzureVMs;
+const dayjs_1 = __importDefault(require("dayjs"));
+// Azure VM pricing (East US, pay-as-you-go, monthly estimate)
+// Source: Azure pricing as of 2026-01, monthly = hourly × 730
+exports.AZURE_VM_PRICING = {
+    'Standard_B1s': 7.59,
+    'Standard_B1ms': 15.33,
+    'Standard_B2s': 30.37,
+    'Standard_B2ms': 60.74,
+    'Standard_D2s_v3': 70.08,
+    'Standard_D4s_v3': 140.16,
+    'Standard_D8s_v3': 280.32,
+    'Standard_E2s_v3': 109.50,
+    'Standard_E4s_v3': 219.00,
+    'Standard_F2s_v2': 62.05,
+    'Standard_F4s_v2': 124.10,
+};
+function getVMMonthlyCost(vmSize) {
+    return exports.AZURE_VM_PRICING[vmSize] || 100; // Fallback estimate
+}
+async function analyzeAzureVMs(client) {
+    const computeClient = client.getComputeClient();
+    const monitorClient = client.getMonitorClient();
+    const opportunities = [];
+    try {
+        // List all VMs in the subscription
+        const vms = computeClient.virtualMachines.listAll();
+        for await (const vm of vms) {
+            if (!vm.id || !vm.name)
+                continue;
+            // Filter by location if specified
+            if (client.location && vm.location?.toLowerCase() !== client.location.toLowerCase()) {
+                continue;
+            }
+            const vmSize = vm.hardwareProfile?.vmSize || 'Unknown';
+            const powerState = await getVMPowerState(computeClient, vm);
+            // Skip stopped/deallocated VMs (no compute cost)
+            if (powerState === 'stopped' || powerState === 'deallocated') {
+                continue;
+            }
+            const currentCost = getVMMonthlyCost(vmSize);
+            // Get CPU metrics for the last 7 days
+            const avgCpu = await getAverageCPU(monitorClient, vm.id, 7);
+            // Opportunity 1: Idle VM (low CPU usage)
+            if (avgCpu < 5) {
+                opportunities.push({
+                    id: `azure-vm-idle-${vm.name}`,
+                    provider: 'azure',
+                    resourceType: 'vm',
+                    resourceId: vm.id,
+                    resourceName: vm.name,
+                    category: 'idle',
+                    currentCost,
+                    estimatedSavings: currentCost * 0.9, // Could stop or downsize
+                    confidence: 'high',
+                    recommendation: `VM is idle (${avgCpu.toFixed(1)}% avg CPU). Consider stopping or downsizing.`,
+                    metadata: {
+                        vmSize,
+                        avgCpu,
+                        location: vm.location,
+                        powerState,
+                    },
+                    detectedAt: new Date(),
+                });
+            }
+            // Opportunity 2: Underutilized VM (medium CPU usage)
+            else if (avgCpu < 20) {
+                const smallerSize = getSmallerVMSize(vmSize);
+                if (smallerSize) {
+                    const newCost = getVMMonthlyCost(smallerSize);
+                    const savings = currentCost - newCost;
+                    if (savings > 10) { // At least $10/month savings
+                        opportunities.push({
+                            id: `azure-vm-underutilized-${vm.name}`,
+                            provider: 'azure',
+                            resourceType: 'vm',
+                            resourceId: vm.id,
+                            resourceName: vm.name,
+                            category: 'oversized',
+                            currentCost,
+                            estimatedSavings: savings,
+                            confidence: 'medium',
+                            recommendation: `Downsize from ${vmSize} to ${smallerSize} (${avgCpu.toFixed(1)}% avg CPU).`,
+                            metadata: {
+                                vmSize,
+                                suggestedSize: smallerSize,
+                                avgCpu,
+                                location: vm.location,
+                            },
+                            detectedAt: new Date(),
+                        });
+                    }
+                }
+            }
+        }
+        return opportunities;
+    }
+    catch (error) {
+        console.error('Error analyzing Azure VMs:', error);
+        return opportunities;
+    }
+}
+async function getVMPowerState(computeClient, vm) {
+    try {
+        const resourceGroup = extractResourceGroup(vm.id);
+        if (!resourceGroup || !vm.name)
+            return 'unknown';
+        const instanceView = await computeClient.virtualMachines.instanceView(resourceGroup, vm.name);
+        const powerState = instanceView.statuses?.find((s) => s.code?.startsWith('PowerState/'));
+        return powerState?.code?.replace('PowerState/', '').toLowerCase() || 'unknown';
+    }
+    catch (error) {
+        return 'unknown';
+    }
+}
+async function getAverageCPU(monitorClient, resourceId, days) {
+    try {
+        const endTime = new Date();
+        const startTime = (0, dayjs_1.default)().subtract(days, 'days').toDate();
+        const metrics = await monitorClient.metrics.list(resourceId, {
+            timespan: `${startTime.toISOString()}/${endTime.toISOString()}`,
+            interval: 'PT1H',
+            metricnames: 'Percentage CPU',
+            aggregation: 'Average',
+        });
+        const timeseries = metrics.value?.[0]?.timeseries?.[0]?.data || [];
+        if (timeseries.length === 0) {
+            return 0;
+        }
+        const values = timeseries
+            .map((d) => d.average)
+            .filter((v) => v !== null && v !== undefined);
+        if (values.length === 0) {
+            return 0;
+        }
+        const sum = values.reduce((a, b) => a + b, 0);
+        return sum / values.length;
+    }
+    catch (error) {
+        console.error('Error fetching CPU metrics:', error);
+        return 0;
+    }
+}
+function getSmallerVMSize(currentSize) {
+    const downsizeMap = {
+        'Standard_B2ms': 'Standard_B1ms',
+        'Standard_B2s': 'Standard_B1s',
+        'Standard_D4s_v3': 'Standard_D2s_v3',
+        'Standard_D8s_v3': 'Standard_D4s_v3',
+        'Standard_E4s_v3': 'Standard_E2s_v3',
+        'Standard_F4s_v2': 'Standard_F2s_v2',
+    };
+    return downsizeMap[currentSize] || null;
+}
+function extractResourceGroup(resourceId) {
+    const match = resourceId.match(/resourceGroups\/([^\/]+)/i);
+    return match ? match[1] : null;
+}

package/dist/src/reporters/table.d.ts

@@ -1,2 +1,3 @@
 import { ScanReport } from '../types';
-export declare function renderTable(report: ScanReport, topN?: number): void;
+import { AIService } from '../services/ai';
+export declare function renderTable(report: ScanReport, topN?: number, aiService?: AIService): Promise<void>;

package/dist/src/reporters/table.js

@@ -7,7 +7,7 @@ exports.renderTable = renderTable;
 const cli_table3_1 = __importDefault(require("cli-table3"));
 const chalk_1 = __importDefault(require("chalk"));
 const utils_1 = require("../utils");
-function renderTable(report, topN = 5) {
+async function renderTable(report, topN = 5, aiService) {
     console.log(chalk_1.default.bold('\nCloud Cost Optimization Report'));
     console.log(`Provider: ${report.provider} | Region: ${report.region} | Account: ${report.accountId}`);
     console.log(`Analyzed: ${report.scanPeriod.start.toISOString().split('T')[0]} to ${report.scanPeriod.end.toISOString().split('T')[0]}\n`);
@@ -21,7 +21,8 @@ function renderTable(report, topN = 5) {
     console.log(chalk_1.default.bold(`Top ${opportunities.length} Savings Opportunities (est. ${(0, utils_1.formatCurrency)(report.totalPotentialSavings)}/month):\n`));
     const table = new cli_table3_1.default({
         head: ['#', 'Type', 'Resource ID', 'Recommendation', 'Savings/mo'],
-        colWidths: [5, 10, 25, 50, 15],
+        colWidths: [5, 12, 40, 60, 15],
+        wordWrap: true,
         style: {
             head: ['cyan'],
         },
@@ -36,6 +37,71 @@ function renderTable(report, topN = 5) {
         ]);
     });
     console.log(table.toString());
+    // Show AI explanations if enabled
+    if (aiService && aiService.isEnabled()) {
+        console.log(chalk_1.default.bold('\n🤖 AI-Powered Insights:\n'));
+        const maxExplanations = aiService.getMaxExplanations();
+        const opportunitiesToExplain = opportunities.slice(0, Math.min(maxExplanations, opportunities.length));
+        for (let i = 0; i < opportunitiesToExplain.length; i++) {
+            const opp = opportunitiesToExplain[i];
+            try {
+                console.log(chalk_1.default.cyan(`Analyzing opportunity #${i + 1}...`));
+                const explanation = await aiService.explainOpportunity(opp);
+                const cacheIndicator = explanation.cached ? chalk_1.default.dim(' (cached)') : '';
+                console.log(chalk_1.default.bold(`\n💡 Opportunity #${i + 1}: ${opp.resourceId}${cacheIndicator}`));
+                console.log(chalk_1.default.dim('─'.repeat(80)));
+                console.log(chalk_1.default.white(explanation.summary));
+                console.log();
+                console.log(chalk_1.default.bold('Why this is wasteful:'));
+                console.log(explanation.whyWasteful);
+                if (explanation.actionPlan.length > 0) {
+                    console.log();
+                    console.log(chalk_1.default.bold('Action plan:'));
+                    explanation.actionPlan.forEach((step) => {
+                        console.log(chalk_1.default.green(`  ${step}`));
+                    });
+                }
+                console.log();
+                console.log(`Risk: ${getRiskEmoji(explanation.riskLevel)} ${explanation.riskLevel.toUpperCase()}`);
+                console.log(`Time: ⏱️  ${explanation.estimatedTime}`);
+                // Try to generate remediation script
+                try {
+                    const script = await aiService.generateRemediationScript(opp);
+                    if (script) {
+                        console.log();
+                        console.log(chalk_1.default.bold('🔧 Remediation Script:'));
+                        console.log(chalk_1.default.dim('─'.repeat(80)));
+                        console.log(chalk_1.default.gray(script));
+                    }
+                }
+                catch (error) {
+                    // Script generation failed, skip silently
+                }
+                console.log();
+            }
+            catch (error) {
+                console.log(chalk_1.default.yellow(`⚠️  AI explanation failed: ${error.message}`));
+            }
+        }
+    }
+    // Show total count if there are more opportunities
+    if (report.opportunities.length > topN) {
+        console.log(chalk_1.default.dim(`\n... and ${report.opportunities.length - topN} more opportunities (use --top ${report.opportunities.length} to see all)`));
+    }
     console.log(chalk_1.default.bold(`\nTotal potential savings: ${chalk_1.default.green((0, utils_1.formatCurrency)(report.totalPotentialSavings))}/month (${chalk_1.default.green((0, utils_1.formatCurrency)(report.totalPotentialSavings * 12))}/year)`));
-    console.log(`\nSummary: ${report.summary.totalResources} resources analyzed | ${report.summary.idleResources} idle | ${report.summary.oversizedResources} oversized | ${report.summary.unusedResources} unused\n`);
+    console.log(`\nSummary: ${report.summary.totalResources} resources analyzed | ${report.summary.idleResources} idle | ${report.summary.oversizedResources} oversized | ${report.summary.unusedResources} unused`);
+    console.log(chalk_1.default.dim(`\n💡 Note: Cost estimates based on us-east-1 pricing and may vary by region.`));
+    console.log(chalk_1.default.dim(`   For more accurate estimates, actual costs depend on your usage and region.\n`));
+}
+function getRiskEmoji(risk) {
+    switch (risk) {
+        case 'low':
+            return '✅';
+        case 'medium':
+            return '⚠️';
+        case 'high':
+            return '🚨';
+        default:
+            return '❓';
+    }
 }

package/dist/src/services/ai.d.ts

@@ -0,0 +1,44 @@
+import { SavingsOpportunity } from '../types';
+export interface AIExplanation {
+    summary: string;
+    whyWasteful: string;
+    actionPlan: string[];
+    riskLevel: 'low' | 'medium' | 'high';
+    estimatedTime: string;
+    script?: string;
+    cached?: boolean;
+}
+export interface QueryAnswer {
+    response: string;
+    suggestions?: string[];
+    relatedOpportunities?: any[];
+}
+export type AIProvider = 'openai' | 'ollama';
+export interface AIConfig {
+    provider: AIProvider;
+    apiKey?: string;
+    model?: string;
+    maxExplanations?: number;
+}
+export declare class AIService {
+    private openaiClient;
+    private ollamaClient;
+    private provider;
+    private model;
+    private enabled;
+    private maxExplanations;
+    private cache;
+    private useCache;
+    private costTracker;
+    constructor(config?: AIConfig);
+    isEnabled(): boolean;
+    getMaxExplanations(): number;
+    explainOpportunity(opportunity: SavingsOpportunity): Promise<AIExplanation>;
+    generateRemediationScript(opportunity: SavingsOpportunity): Promise<string | null>;
+    private buildPrompt;
+    private parseExplanation;
+    answerQuery(query: string, scanReport: any): Promise<QueryAnswer>;
+    private buildQueryContext;
+    private buildQueryPrompt;
+    private parseQueryAnswer;
+}