cloud-cost-cli 0.1.1 → 0.2.0

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[]>;

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.js

@@ -37,5 +37,7 @@ function renderTable(report, topN = 5) {
     });
     console.log(table.toString());
     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`));
 }

package/dist/src/utils/formatter.d.ts

@@ -1,3 +1,5 @@
 export declare function formatCurrency(amount: number): string;
+export declare function formatBytes(bytes: number, decimals?: number): string;
+export declare function formatPercent(value: number, decimals?: number): string;
 export declare function formatDate(date: Date): string;
 export declare function daysSince(date: Date): number;

package/dist/src/utils/formatter.js

@@ -1,10 +1,38 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatCurrency = formatCurrency;
+exports.formatBytes = formatBytes;
+exports.formatPercent = formatPercent;
 exports.formatDate = formatDate;
 exports.daysSince = daysSince;
 function formatCurrency(amount) {
-    return `$${amount.toFixed(2)}`;
+    const formatted = new Intl.NumberFormat('en-US', {
+        style: 'currency',
+        currency: 'USD',
+        minimumFractionDigits: 2,
+        maximumFractionDigits: 2,
+    }).format(amount);
+    return formatted;
+}
+function formatBytes(bytes, decimals = 2) {
+    if (bytes === 0)
+        return '0 B';
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB', 'TB', 'PB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    // Don't use decimals for bytes
+    if (i === 0) {
+        return `${bytes} B`;
+    }
+    const value = bytes / Math.pow(k, i);
+    const formatted = decimals === 0
+        ? Math.round(value).toString()
+        : value.toFixed(decimals);
+    return `${formatted} ${sizes[i]}`;
+}
+function formatPercent(value, decimals = 1) {
+    const percent = value * 100;
+    return `${percent.toFixed(decimals)}%`;
 }
 function formatDate(date) {
     return date.toISOString().split('T')[0];