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

package/dist/src/commands/scan.js

@@ -8,104 +8,274 @@ const rds_1 = require("../providers/aws/rds");
 const s3_1 = require("../providers/aws/s3");
 const elb_1 = require("../providers/aws/elb");
 const eip_1 = require("../providers/aws/eip");
+const client_2 = require("../providers/azure/client");
+const vms_1 = require("../providers/azure/vms");
+const disks_1 = require("../providers/azure/disks");
+const storage_1 = require("../providers/azure/storage");
+const sql_1 = require("../providers/azure/sql");
+const public_ips_1 = require("../providers/azure/public-ips");
 const table_1 = require("../reporters/table");
 const json_1 = require("../reporters/json");
 const logger_1 = require("../utils/logger");
+const ai_1 = require("../services/ai");
+const ask_1 = require("./ask");
+const config_1 = require("../utils/config");
 async function scanCommand(options) {
     try {
-        if (options.provider !== 'aws') {
-            (0, logger_1.error)(`Provider "${options.provider}" not yet supported. Use --provider aws`);
-            process.exit(1);
+        if (options.provider === 'aws') {
+            await scanAWS(options);
         }
-        const client = new client_1.AWSClient({
-            region: options.region,
-            profile: options.profile,
-        });
-        (0, logger_1.info)(`Scanning AWS account (profile: ${options.profile || 'default'}, region: ${client.region})...`);
-        // Run analyzers in parallel
-        (0, logger_1.info)('Analyzing EC2 instances...');
-        const ec2Promise = (0, ec2_1.analyzeEC2Instances)(client);
-        (0, logger_1.info)('Analyzing EBS volumes...');
-        const ebsPromise = (0, ebs_1.analyzeEBSVolumes)(client);
-        (0, logger_1.info)('Analyzing RDS instances...');
-        const rdsPromise = (0, rds_1.analyzeRDSInstances)(client);
-        (0, logger_1.info)('Analyzing S3 buckets...');
-        const s3Promise = (0, s3_1.analyzeS3Buckets)(client);
-        (0, logger_1.info)('Analyzing Load Balancers...');
-        const elbPromise = (0, elb_1.analyzeELBs)(client);
-        (0, logger_1.info)('Analyzing Elastic IPs...');
-        const eipPromise = (0, eip_1.analyzeElasticIPs)(client);
-        // Wait for all analyzers to complete
-        const [ec2Opportunities, ebsOpportunities, rdsOpportunities, s3Opportunities, elbOpportunities, eipOpportunities,] = await Promise.all([
-            ec2Promise,
-            ebsPromise,
-            rdsPromise,
-            s3Promise,
-            elbPromise,
-            eipPromise,
-        ]);
-        (0, logger_1.success)(`Found ${ec2Opportunities.length} EC2 opportunities`);
-        (0, logger_1.success)(`Found ${ebsOpportunities.length} EBS opportunities`);
-        (0, logger_1.success)(`Found ${rdsOpportunities.length} RDS opportunities`);
-        (0, logger_1.success)(`Found ${s3Opportunities.length} S3 opportunities`);
-        (0, logger_1.success)(`Found ${elbOpportunities.length} ELB opportunities`);
-        (0, logger_1.success)(`Found ${eipOpportunities.length} EIP opportunities`);
-        // Combine opportunities
-        const allOpportunities = [
-            ...ec2Opportunities,
-            ...ebsOpportunities,
-            ...rdsOpportunities,
-            ...s3Opportunities,
-            ...elbOpportunities,
-            ...eipOpportunities,
-        ];
-        // Filter by minimum savings if specified
-        const minSavings = options.minSavings ? parseFloat(options.minSavings) : 0;
-        const filteredOpportunities = allOpportunities.filter((opp) => opp.estimatedSavings >= minSavings);
-        // Calculate totals
-        const totalPotentialSavings = filteredOpportunities.reduce((sum, opp) => sum + opp.estimatedSavings, 0);
-        const summary = {
-            totalResources: filteredOpportunities.length,
-            idleResources: filteredOpportunities.filter((o) => o.category === 'idle').length,
-            oversizedResources: filteredOpportunities.filter((o) => o.category === 'oversized').length,
-            unusedResources: filteredOpportunities.filter((o) => o.category === 'unused').length,
-        };
-        const report = {
-            provider: 'aws',
-            accountId: 'N/A', // Will fetch from STS in future
-            region: client.region,
-            scanPeriod: {
-                start: new Date(Date.now() - (parseInt(options.days || '30') * 24 * 60 * 60 * 1000)),
-                end: new Date(),
-            },
-            opportunities: filteredOpportunities,
-            totalPotentialSavings,
-            summary,
-        };
-        // Render output
-        const topN = parseInt(options.top || '5');
-        if (options.output === 'json') {
-            (0, json_1.renderJSON)(report);
+        else if (options.provider === 'azure') {
+            await scanAzure(options);
         }
         else {
-            (0, table_1.renderTable)(report, topN);
+            (0, logger_1.error)(`Provider "${options.provider}" not yet supported. Use --provider aws or --provider azure`);
+            process.exit(1);
         }
     }
     catch (err) {
-        if (err.name === 'CredentialsProviderError' || err.message?.includes('credentials')) {
-            (0, logger_1.error)('AWS credentials not found or invalid.');
-            console.log('\nTo configure AWS credentials:');
-            console.log('1. Run: aws configure');
-            console.log('2. Or set environment variables: AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY');
-            console.log('3. Or use --profile flag with a configured profile');
-            console.log('\nSee: https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html');
+        (0, logger_1.error)(`Scan failed: ${err.message}`);
+        if (options.verbose) {
+            console.error(err);
         }
-        else {
-            (0, logger_1.error)(`Scan failed: ${err.message}`);
-            if (options.verbose) {
-                console.error(err);
+        process.exit(1);
+    }
+}
+async function scanAWS(options) {
+    const client = new client_1.AWSClient({
+        region: options.region,
+        profile: options.profile,
+    });
+    (0, logger_1.info)(`Scanning AWS account (profile: ${options.profile || 'default'}, region: ${client.region})...`);
+    if (options.accurate) {
+        (0, logger_1.info)('Note: --accurate flag is not yet implemented. Using estimated pricing.');
+        (0, logger_1.info)('Real-time pricing will be available in a future release.');
+    }
+    // Run analyzers in parallel
+    (0, logger_1.info)('Analyzing EC2 instances...');
+    const ec2Promise = (0, ec2_1.analyzeEC2Instances)(client);
+    (0, logger_1.info)('Analyzing EBS volumes...');
+    const ebsPromise = (0, ebs_1.analyzeEBSVolumes)(client);
+    (0, logger_1.info)('Analyzing RDS instances...');
+    const rdsPromise = (0, rds_1.analyzeRDSInstances)(client);
+    (0, logger_1.info)('Analyzing S3 buckets...');
+    const s3Promise = (0, s3_1.analyzeS3Buckets)(client);
+    (0, logger_1.info)('Analyzing Load Balancers...');
+    const elbPromise = (0, elb_1.analyzeELBs)(client);
+    (0, logger_1.info)('Analyzing Elastic IPs...');
+    const eipPromise = (0, eip_1.analyzeElasticIPs)(client);
+    // Wait for all analyzers to complete
+    const [ec2Opportunities, ebsOpportunities, rdsOpportunities, s3Opportunities, elbOpportunities, eipOpportunities,] = await Promise.all([
+        ec2Promise,
+        ebsPromise,
+        rdsPromise,
+        s3Promise,
+        elbPromise,
+        eipPromise,
+    ]);
+    (0, logger_1.success)(`Found ${ec2Opportunities.length} EC2 opportunities`);
+    (0, logger_1.success)(`Found ${ebsOpportunities.length} EBS opportunities`);
+    (0, logger_1.success)(`Found ${rdsOpportunities.length} RDS opportunities`);
+    (0, logger_1.success)(`Found ${s3Opportunities.length} S3 opportunities`);
+    (0, logger_1.success)(`Found ${elbOpportunities.length} ELB opportunities`);
+    (0, logger_1.success)(`Found ${eipOpportunities.length} EIP opportunities`);
+    // Combine opportunities
+    const allOpportunities = [
+        ...ec2Opportunities,
+        ...ebsOpportunities,
+        ...rdsOpportunities,
+        ...s3Opportunities,
+        ...elbOpportunities,
+        ...eipOpportunities,
+    ];
+    // Filter by minimum savings if specified
+    const minSavings = options.minSavings ? parseFloat(options.minSavings) : 0;
+    const filteredOpportunities = allOpportunities.filter((opp) => opp.estimatedSavings >= minSavings);
+    // Calculate totals
+    const totalPotentialSavings = filteredOpportunities.reduce((sum, opp) => sum + opp.estimatedSavings, 0);
+    const summary = {
+        totalResources: filteredOpportunities.length,
+        idleResources: filteredOpportunities.filter((o) => o.category === 'idle').length,
+        oversizedResources: filteredOpportunities.filter((o) => o.category === 'oversized').length,
+        unusedResources: filteredOpportunities.filter((o) => o.category === 'unused').length,
+    };
+    const report = {
+        provider: 'aws',
+        accountId: 'N/A', // Will fetch from STS in future
+        region: client.region,
+        scanPeriod: {
+            start: new Date(Date.now() - (parseInt(options.days || '30') * 24 * 60 * 60 * 1000)),
+            end: new Date(),
+        },
+        opportunities: filteredOpportunities,
+        totalPotentialSavings,
+        summary,
+    };
+    // Render output
+    const topN = parseInt(options.top || '5');
+    let aiService;
+    if (options.explain) {
+        // 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;
+        const maxExplanations = fileConfig.ai?.maxExplanations;
+        // Debug logging
+        if (process.env.DEBUG) {
+            console.error('options.aiProvider:', options.aiProvider, '(type:', typeof options.aiProvider, ')');
+            console.error('fileConfig.ai?.provider:', fileConfig.ai?.provider);
+            console.error('Provider detected:', provider);
+            console.error('Has API key in config:', !!fileConfig.ai?.apiKey);
+            console.error('Has env API key:', !!process.env.OPENAI_API_KEY);
+        }
+        if (provider === 'openai' && !process.env.OPENAI_API_KEY && !fileConfig.ai?.apiKey) {
+            (0, logger_1.error)('--explain with OpenAI requires OPENAI_API_KEY environment variable or config file');
+            (0, logger_1.info)('Set it with: export OPENAI_API_KEY="sk-..."');
+            (0, logger_1.info)('Or use --ai-provider ollama for local AI (requires Ollama installed)');
+            process.exit(1);
+        }
+        try {
+            aiService = new ai_1.AIService({
+                provider,
+                apiKey: provider === 'openai' ? (process.env.OPENAI_API_KEY || fileConfig.ai?.apiKey) : undefined,
+                model,
+                maxExplanations,
+            });
+            if (provider === 'ollama') {
+                (0, logger_1.info)('Using local Ollama for AI explanations (privacy-first, no API costs)');
             }
         }
-        process.exit(1);
+        catch (error) {
+            error(`Failed to initialize AI service: ${error.message}`);
+            process.exit(1);
+        }
+    }
+    // Save scan cache for natural language queries
+    (0, ask_1.saveScanCache)(options.provider, options.region, report);
+    if (options.output === 'json') {
+        (0, json_1.renderJSON)(report);
+    }
+    else {
+        await (0, table_1.renderTable)(report, topN, aiService);
+    }
+}
+async function scanAzure(options) {
+    const client = new client_2.AzureClient({
+        subscriptionId: options.subscriptionId,
+        location: options.location,
+    });
+    (0, logger_1.info)(`Scanning Azure subscription (${client.subscriptionId})...`);
+    if (client.location) {
+        (0, logger_1.info)(`Filtering resources by location: ${client.location}`);
+    }
+    else {
+        (0, logger_1.info)('Scanning all locations (no filter specified)');
+    }
+    if (options.accurate) {
+        (0, logger_1.info)('Note: --accurate flag is not yet implemented. Using estimated pricing.');
+    }
+    // Run analyzers in parallel
+    (0, logger_1.info)('Analyzing Virtual Machines...');
+    const vmPromise = (0, vms_1.analyzeAzureVMs)(client);
+    (0, logger_1.info)('Analyzing Managed Disks...');
+    const diskPromise = (0, disks_1.analyzeAzureDisks)(client);
+    (0, logger_1.info)('Analyzing Storage Accounts...');
+    const storagePromise = (0, storage_1.analyzeAzureStorage)(client);
+    (0, logger_1.info)('Analyzing SQL Databases...');
+    const sqlPromise = (0, sql_1.analyzeAzureSQL)(client);
+    (0, logger_1.info)('Analyzing Public IP Addresses...');
+    const ipPromise = (0, public_ips_1.analyzeAzurePublicIPs)(client);
+    // Wait for all analyzers to complete
+    const [vmOpportunities, diskOpportunities, storageOpportunities, sqlOpportunities, ipOpportunities,] = await Promise.all([
+        vmPromise,
+        diskPromise,
+        storagePromise,
+        sqlPromise,
+        ipPromise,
+    ]);
+    (0, logger_1.success)(`Found ${vmOpportunities.length} VM opportunities`);
+    (0, logger_1.success)(`Found ${diskOpportunities.length} Disk opportunities`);
+    (0, logger_1.success)(`Found ${storageOpportunities.length} Storage opportunities`);
+    (0, logger_1.success)(`Found ${sqlOpportunities.length} SQL opportunities`);
+    (0, logger_1.success)(`Found ${ipOpportunities.length} Public IP opportunities`);
+    // Combine opportunities
+    const allOpportunities = [
+        ...vmOpportunities,
+        ...diskOpportunities,
+        ...storageOpportunities,
+        ...sqlOpportunities,
+        ...ipOpportunities,
+    ];
+    // Filter by minimum savings if specified
+    const minSavings = options.minSavings ? parseFloat(options.minSavings) : 0;
+    const filteredOpportunities = allOpportunities.filter((opp) => opp.estimatedSavings >= minSavings);
+    // Calculate totals
+    const totalPotentialSavings = filteredOpportunities.reduce((sum, opp) => sum + opp.estimatedSavings, 0);
+    const summary = {
+        totalResources: filteredOpportunities.length,
+        idleResources: filteredOpportunities.filter((o) => o.category === 'idle').length,
+        oversizedResources: filteredOpportunities.filter((o) => o.category === 'oversized').length,
+        unusedResources: filteredOpportunities.filter((o) => o.category === 'unused').length,
+    };
+    const report = {
+        provider: 'azure',
+        accountId: client.subscriptionId,
+        region: client.location || 'all',
+        scanPeriod: {
+            start: new Date(Date.now() - (parseInt(options.days || '7') * 24 * 60 * 60 * 1000)),
+            end: new Date(),
+        },
+        opportunities: filteredOpportunities,
+        totalPotentialSavings,
+        summary,
+    };
+    // Render output
+    const topN = parseInt(options.top || '5');
+    let aiService;
+    if (options.explain) {
+        // 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;
+        const maxExplanations = fileConfig.ai?.maxExplanations;
+        // Debug logging
+        if (process.env.DEBUG) {
+            console.error('options.aiProvider:', options.aiProvider, '(type:', typeof options.aiProvider, ')');
+            console.error('fileConfig.ai?.provider:', fileConfig.ai?.provider);
+            console.error('Provider detected:', provider);
+            console.error('Has API key in config:', !!fileConfig.ai?.apiKey);
+            console.error('Has env API key:', !!process.env.OPENAI_API_KEY);
+        }
+        if (provider === 'openai' && !process.env.OPENAI_API_KEY && !fileConfig.ai?.apiKey) {
+            (0, logger_1.error)('--explain with OpenAI requires OPENAI_API_KEY environment variable or config file');
+            (0, logger_1.info)('Set it with: export OPENAI_API_KEY="sk-..."');
+            (0, logger_1.info)('Or use --ai-provider ollama for local AI (requires Ollama installed)');
+            process.exit(1);
+        }
+        try {
+            aiService = new ai_1.AIService({
+                provider,
+                apiKey: provider === 'openai' ? (process.env.OPENAI_API_KEY || fileConfig.ai?.apiKey) : undefined,
+                model,
+                maxExplanations,
+            });
+            if (provider === 'ollama') {
+                (0, logger_1.info)('Using local Ollama for AI explanations (privacy-first, no API costs)');
+            }
+        }
+        catch (error) {
+            error(`Failed to initialize AI service: ${error.message}`);
+            process.exit(1);
+        }
+    }
+    // Save scan cache for natural language queries
+    (0, ask_1.saveScanCache)('azure', client.location, report);
+    if (options.output === 'json') {
+        (0, json_1.renderJSON)(report);
+    }
+    else {
+        await (0, table_1.renderTable)(report, topN, aiService);
     }
 }

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

@@ -0,0 +1,8 @@
+import { SavingsOpportunity } from '../types';
+interface ScriptCommandOptions {
+    opportunity: string;
+    output?: string;
+}
+export declare function scriptCommand(options: ScriptCommandOptions): Promise<void>;
+export declare function generateScriptForOpportunity(opportunity: SavingsOpportunity): string | null;
+export {};

package/dist/src/commands/script.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scriptCommand = scriptCommand;
+exports.generateScriptForOpportunity = generateScriptForOpportunity;
+const script_generator_1 = require("../services/script-generator");
+const logger_1 = require("../utils/logger");
+async function scriptCommand(options) {
+    (0, logger_1.info)('Script generation is currently only available after running a scan.');
+    (0, logger_1.info)('Usage: cloud-cost-cli scan --provider aws --region us-east-1');
+    (0, logger_1.info)('Then use the displayed resource IDs to generate scripts.');
+    // This is a placeholder - in a real implementation, we'd:
+    // 1. Load scan results from a cache/temp file
+    // 2. Find the opportunity by index or ID
+    // 3. Generate the script
+    // 4. Output to file or stdout
+    (0, logger_1.error)('Script generation requires a recent scan. Run "scan" first.');
+    process.exit(1);
+}
+// Helper function to generate script for a single opportunity
+function generateScriptForOpportunity(opportunity) {
+    const generator = new script_generator_1.ScriptGenerator();
+    const script = generator.generateRemediation(opportunity);
+    if (!script) {
+        return null;
+    }
+    return generator.renderScript(script);
+}

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

@@ -0,0 +1,20 @@
+import { ComputeManagementClient } from '@azure/arm-compute';
+import { StorageManagementClient } from '@azure/arm-storage';
+import { SqlManagementClient } from '@azure/arm-sql';
+import { NetworkManagementClient } from '@azure/arm-network';
+import { MonitorClient } from '@azure/arm-monitor';
+export interface AzureClientConfig {
+    subscriptionId?: string;
+    location?: string;
+}
+export declare class AzureClient {
+    private credential;
+    subscriptionId: string;
+    location: string;
+    constructor(config?: AzureClientConfig);
+    getComputeClient(): ComputeManagementClient;
+    getStorageClient(): StorageManagementClient;
+    getSqlClient(): SqlManagementClient;
+    getNetworkClient(): NetworkManagementClient;
+    getMonitorClient(): MonitorClient;
+}

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AzureClient = void 0;
+const identity_1 = require("@azure/identity");
+const arm_compute_1 = require("@azure/arm-compute");
+const arm_storage_1 = require("@azure/arm-storage");
+const arm_sql_1 = require("@azure/arm-sql");
+const arm_network_1 = require("@azure/arm-network");
+const arm_monitor_1 = require("@azure/arm-monitor");
+class AzureClient {
+    credential;
+    subscriptionId;
+    location;
+    constructor(config = {}) {
+        // Use Azure SDK's default credential chain (env vars, CLI, managed identity)
+        this.credential = new identity_1.DefaultAzureCredential();
+        // Get subscription ID from env or config
+        this.subscriptionId = config.subscriptionId || process.env.AZURE_SUBSCRIPTION_ID || '';
+        if (!this.subscriptionId) {
+            throw new Error('Azure subscription ID not found. Set AZURE_SUBSCRIPTION_ID environment variable or use --subscription-id flag.');
+        }
+        // Default to East US if no location specified
+        this.location = config.location || '';
+    }
+    getComputeClient() {
+        return new arm_compute_1.ComputeManagementClient(this.credential, this.subscriptionId);
+    }
+    getStorageClient() {
+        return new arm_storage_1.StorageManagementClient(this.credential, this.subscriptionId);
+    }
+    getSqlClient() {
+        return new arm_sql_1.SqlManagementClient(this.credential, this.subscriptionId);
+    }
+    getNetworkClient() {
+        return new arm_network_1.NetworkManagementClient(this.credential, this.subscriptionId);
+    }
+    getMonitorClient() {
+        return new arm_monitor_1.MonitorClient(this.credential, this.subscriptionId);
+    }
+}
+exports.AzureClient = AzureClient;

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

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

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

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AZURE_DISK_PRICING = void 0;
+exports.analyzeAzureDisks = analyzeAzureDisks;
+// Azure Managed Disk pricing (per GB/month, East US)
+exports.AZURE_DISK_PRICING = {
+    'Premium_LRS': 0.135, // Premium SSD
+    'StandardSSD_LRS': 0.075, // Standard SSD
+    'Standard_LRS': 0.045, // Standard HDD
+};
+function getDiskMonthlyCost(sizeGB, diskType) {
+    const pricePerGB = exports.AZURE_DISK_PRICING[diskType] || 0.075;
+    return sizeGB * pricePerGB;
+}
+async function analyzeAzureDisks(client) {
+    const computeClient = client.getComputeClient();
+    const opportunities = [];
+    try {
+        // List all managed disks
+        const disks = computeClient.disks.list();
+        for await (const disk of disks) {
+            if (!disk.id || !disk.name)
+                continue;
+            // Filter by location if specified
+            if (client.location && disk.location?.toLowerCase() !== client.location.toLowerCase()) {
+                continue;
+            }
+            const sizeGB = disk.diskSizeGB || 0;
+            const diskType = disk.sku?.name || 'Standard_LRS';
+            const currentCost = getDiskMonthlyCost(sizeGB, diskType);
+            // Opportunity 1: Unattached disk
+            if (disk.diskState === 'Unattached') {
+                opportunities.push({
+                    id: `azure-disk-unattached-${disk.name}`,
+                    provider: 'azure',
+                    resourceType: 'disk',
+                    resourceId: disk.id,
+                    resourceName: disk.name,
+                    category: 'unused',
+                    currentCost,
+                    estimatedSavings: currentCost,
+                    confidence: 'high',
+                    recommendation: `Unattached disk (${sizeGB} GB). Delete if no longer needed.`,
+                    metadata: {
+                        sizeGB,
+                        diskType,
+                        location: disk.location,
+                        diskState: disk.diskState,
+                    },
+                    detectedAt: new Date(),
+                });
+            }
+            // Opportunity 2: Premium disk that could be Standard SSD
+            else if (diskType === 'Premium_LRS' && sizeGB < 256) {
+                const newType = 'StandardSSD_LRS';
+                const newCost = getDiskMonthlyCost(sizeGB, newType);
+                const savings = currentCost - newCost;
+                if (savings > 5) {
+                    opportunities.push({
+                        id: `azure-disk-premium-${disk.name}`,
+                        provider: 'azure',
+                        resourceType: 'disk',
+                        resourceId: disk.id,
+                        resourceName: disk.name,
+                        category: 'oversized',
+                        currentCost,
+                        estimatedSavings: savings,
+                        confidence: 'medium',
+                        recommendation: `Consider switching from Premium SSD to Standard SSD for non-performance-critical workloads.`,
+                        metadata: {
+                            sizeGB,
+                            currentType: diskType,
+                            suggestedType: newType,
+                            location: disk.location,
+                        },
+                        detectedAt: new Date(),
+                    });
+                }
+            }
+        }
+        return opportunities;
+    }
+    catch (error) {
+        console.error('Error analyzing Azure disks:', error);
+        return opportunities;
+    }
+}

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

@@ -0,0 +1,6 @@
+export { AzureClient } from './client';
+export { analyzeAzureVMs } from './vms';
+export { analyzeAzureDisks } from './disks';
+export { analyzeAzureStorage } from './storage';
+export { analyzeAzureSQL } from './sql';
+export { analyzeAzurePublicIPs } from './public-ips';

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeAzurePublicIPs = exports.analyzeAzureSQL = exports.analyzeAzureStorage = exports.analyzeAzureDisks = exports.analyzeAzureVMs = exports.AzureClient = void 0;
+var client_1 = require("./client");
+Object.defineProperty(exports, "AzureClient", { enumerable: true, get: function () { return client_1.AzureClient; } });
+var vms_1 = require("./vms");
+Object.defineProperty(exports, "analyzeAzureVMs", { enumerable: true, get: function () { return vms_1.analyzeAzureVMs; } });
+var disks_1 = require("./disks");
+Object.defineProperty(exports, "analyzeAzureDisks", { enumerable: true, get: function () { return disks_1.analyzeAzureDisks; } });
+var storage_1 = require("./storage");
+Object.defineProperty(exports, "analyzeAzureStorage", { enumerable: true, get: function () { return storage_1.analyzeAzureStorage; } });
+var sql_1 = require("./sql");
+Object.defineProperty(exports, "analyzeAzureSQL", { enumerable: true, get: function () { return sql_1.analyzeAzureSQL; } });
+var public_ips_1 = require("./public-ips");
+Object.defineProperty(exports, "analyzeAzurePublicIPs", { enumerable: true, get: function () { return public_ips_1.analyzeAzurePublicIPs; } });

package/dist/src/providers/azure/public-ips.d.ts

@@ -0,0 +1,3 @@
+import { AzureClient } from './client';
+import { SavingsOpportunity } from '../../types/opportunity';
+export declare function analyzeAzurePublicIPs(client: AzureClient): Promise<SavingsOpportunity[]>;

package/dist/src/providers/azure/public-ips.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeAzurePublicIPs = analyzeAzurePublicIPs;
+// Azure Public IP pricing (per month, East US)
+const PUBLIC_IP_MONTHLY_COST = 3.65; // Static IP address
+async function analyzeAzurePublicIPs(client) {
+    const networkClient = client.getNetworkClient();
+    const opportunities = [];
+    try {
+        // List all public IP addresses
+        const publicIPs = networkClient.publicIPAddresses.listAll();
+        for await (const ip of publicIPs) {
+            if (!ip.id || !ip.name)
+                continue;
+            // Filter by location if specified
+            if (client.location && ip.location?.toLowerCase() !== client.location.toLowerCase()) {
+                continue;
+            }
+            // Opportunity: Unassociated public IP
+            if (!ip.ipConfiguration) {
+                opportunities.push({
+                    id: `azure-ip-unassociated-${ip.name}`,
+                    provider: 'azure',
+                    resourceType: 'public-ip',
+                    resourceId: ip.id,
+                    resourceName: ip.name,
+                    category: 'unused',
+                    currentCost: PUBLIC_IP_MONTHLY_COST,
+                    estimatedSavings: PUBLIC_IP_MONTHLY_COST,
+                    confidence: 'high',
+                    recommendation: 'Unassociated public IP address. Delete if not needed.',
+                    metadata: {
+                        ipAddress: ip.ipAddress,
+                        allocationMethod: ip.publicIPAllocationMethod,
+                        location: ip.location,
+                    },
+                    detectedAt: new Date(),
+                });
+            }
+        }
+        return opportunities;
+    }
+    catch (error) {
+        console.error('Error analyzing Azure public IPs:', error);
+        return opportunities;
+    }
+}

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

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