cloud-cost-cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Phuong Vu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,235 @@
+# cloud-cost-cli
+
+**Optimize your cloud spend in seconds.**
+
+A command-line tool that analyzes your AWS, GCP, and Azure bills to identify cost-saving opportunities — idle resources, oversized instances, unattached volumes, and more.
+
+---
+
+## The Problem
+
+Cloud bills are growing faster than revenue. Engineering teams overprovision, forget to clean up dev resources, and lack visibility into what's actually costing money. Existing cost management tools are expensive, slow, or buried in complex dashboards.
+
+## The Solution
+
+`cloud-cost-cli` connects to your cloud accounts, analyzes resource usage and billing data, and outputs a ranked list of actionable savings opportunities — all in your terminal, in under 60 seconds.
+
+**What it finds:**
+- Idle EC2/Compute instances (low CPU, stopped but still billed)
+- Unattached EBS volumes and snapshots
+- Oversized RDS/database instances
+- Old load balancers with no traffic
+- Unused Elastic IPs
+- Underutilized reserved instances or savings plan mismatches
+- Redundant S3 storage (lifecycle policies missing)
+
+---
+
+## Features (MVP - Week 1–2)
+
+- ✅ AWS support (EC2, EBS, RDS, S3, ELB, Elastic IP)
+- ✅ Connect via AWS credentials (IAM read-only recommended)
+- ✅ Analyze last 30 days of usage
+- ✅ Output top 5 savings opportunities with estimated monthly savings
+- ✅ Export report as JSON, Markdown, or terminal table
+- ✅ Zero third-party API dependencies (uses AWS SDK directly)
+
+**Coming soon:**
+- GCP and Azure support
+- Slack/email alerts for new cost spikes
+- Scheduled reports (cron-friendly)
+- Team dashboard (web UI, SaaS)
+- Custom rules and thresholds
+- Terraform/IaC integration (flag risky configs before apply)
+
+---
+
+## Installation
+
+**Requirements:**
+- Node.js >= 18 (or use the standalone binary)
+- AWS credentials configured (see [AWS CLI setup](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html))
+
+**Install via npm:**
+```bash
+npm install -g cloud-cost-cli
+```
+
+**Or download standalone binary:**
+```bash
+# macOS/Linux
+curl -L https://github.com/vuhp/cloud-cost-cli/releases/latest/download/cloud-cost-cli-$(uname -s)-$(uname -m) -o /usr/local/bin/cloud-cost-cli
+chmod +x /usr/local/bin/cloud-cost-cli
+
+# Windows (PowerShell)
+Invoke-WebRequest -Uri "https://github.com/vuhp/cloud-cost-cli/releases/latest/download/cloud-cost-cli-windows-x64.exe" -OutFile "$env:USERPROFILE\bin\cloud-cost-cli.exe"
+```
+
+---
+
+## Usage
+
+**Basic scan (AWS):**
+```bash
+cloud-cost-cli scan --provider aws --profile default
+```
+
+**Specify region and output format:**
+```bash
+cloud-cost-cli scan --provider aws --region us-east-1 --output json > report.json
+```
+
+**Top N opportunities:**
+```bash
+cloud-cost-cli scan --provider aws --top 10
+```
+
+**Example output:**
+```
+Cloud Cost Optimization Report
+Provider: AWS | Region: us-east-1 | Account: 123456789012
+Analyzed: 2026-01-01 to 2026-01-31
+
+Top 5 Savings Opportunities (est. $1,245/month):
+
+1. Idle EC2 instance: i-0abc123def456
+   Type: m5.large | Running 720h | Avg CPU: 2%
+   → Recommendation: Stop or downsize to t3.small
+   → Est. savings: $65/month
+
+2. Unattached EBS volume: vol-0xyz789abc
+   Size: 500 GB (gp3) | Age: 45 days
+   → Recommendation: Delete or snapshot + delete
+   → Est. savings: $40/month
+
+3. Oversized RDS instance: mydb-production
+   Type: db.r5.xlarge | Avg connections: 5 | Avg CPU: 15%
+   → Recommendation: Downsize to db.t3.large
+   → Est. savings: $180/month
+
+4. Unused Elastic Load Balancer: my-old-alb
+   Active targets: 0 | Requests/day: 0
+   → Recommendation: Delete
+   → Est. savings: $22/month
+
+5. S3 bucket with no lifecycle policy: logs-bucket-2023
+   Size: 12 TB | Age: 18 months
+   → Recommendation: Enable Intelligent-Tiering or Glacier transition
+   → Est. savings: $938/month
+
+Total potential savings: $1,245/month ($14,940/year)
+```
+
+---
+
+## Configuration
+
+Create a config file at `~/.cloud-cost-cli/config.json` (optional):
+
+```json
+{
+  "aws": {
+    "profile": "default",
+    "regions": ["us-east-1", "us-west-2"],
+    "excludeResources": ["i-0abc123", "vol-xyz"],
+    "thresholds": {
+      "idleCpuPercent": 5,
+      "minAgeDays": 7
+    }
+  },
+  "output": {
+    "format": "table",
+    "includeRecommendations": true
+  }
+}
+```
+
+---
+
+## Roadmap
+
+**Phase 1 (Week 1–2): MVP**
+- AWS support (EC2, EBS, RDS, S3, ELB, EIP)
+- CLI with basic scan and reporting
+- GitHub Sponsors setup
+- Launch on Hacker News, Product Hunt, Reddit
+
+**Phase 2 (Month 2):**
+- GCP support
+- Azure support
+- Scheduled reports (cron mode)
+- Slack webhook integration
+- GitHub Sponsors perks (early access, priority support)
+
+**Phase 3 (Month 3+):**
+- SaaS version: connect account, weekly email reports, team dashboard
+- Paid tiers: $29/mo (alerts + history), $99/mo (multi-account + API)
+- Enterprise: on-prem, SSO, audit logs, custom rules
+- Terraform provider (flag cost risks before apply)
+
+---
+
+## Contributing
+
+Contributions welcome! Please open an issue before submitting large PRs.
+
+**Development setup:**
+```bash
+git clone https://github.com/vuhp/cloud-cost-cli.git
+cd cloud-cost-cli
+npm install
+npm run dev
+```
+
+**Run tests:**
+```bash
+npm test
+```
+
+---
+
+## Sponsorship
+
+If this tool saves you money, consider sponsoring development via [GitHub Sponsors](https://github.com/sponsors/vuhp).
+
+**Sponsor tiers:**
+- ☕ $5/mo: Thank you!
+- 🚀 $25/mo: Early access to new features + priority support
+- 💼 $100/mo: Logo on README + monthly 1:1 consultation (30 min)
+- 🏢 $500/mo: Custom rule development + dedicated Slack channel
+
+---
+
+## License
+
+MIT License - see [LICENSE](LICENSE)
+
+---
+
+## Credits
+
+**Powered by:**
+- AWS SDK for JavaScript
+- Commander.js
+- Chalk (terminal colors)
+- Table (terminal tables)
+
+---
+
+## FAQ
+
+**Q: Does this tool make changes to my infrastructure?**  
+A: No. It only reads billing and usage data. It never modifies or deletes resources.
+
+**Q: What IAM permissions are required?**  
+A: Read-only permissions for Cost Explorer, EC2, EBS, RDS, S3, ELB. See [IAM policy template](docs/iam-policy.json).
+
+**Q: How accurate are the savings estimates?**  
+A: Estimates are based on current pricing and usage patterns. Actual savings may vary.
+
+**Q: Can I run this in CI/CD?**  
+A: Yes. Use `--output json` and fail the build if savings exceed a threshold.
+
+---
+
+**Star this repo if it saves you money!** ⭐

package/dist/bin/cloud-cost-cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/cloud-cost-cli.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const scan_js_1 = require("../src/commands/scan.js");
+const program = new commander_1.Command();
+program
+    .name('cloud-cost-cli')
+    .description('Optimize your cloud spend in seconds')
+    .version('0.1.0');
+program
+    .command('scan')
+    .description('Scan cloud account for cost savings')
+    .option('--provider <aws|gcp|azure>', 'Cloud provider', 'aws')
+    .option('--region <region>', 'Cloud region (e.g., us-east-1)')
+    .option('--profile <profile>', 'AWS profile name', 'default')
+    .option('--top <N>', 'Show top N opportunities', '5')
+    .option('--output <table|json|markdown>', 'Output format', 'table')
+    .option('--days <N>', 'Analysis period in days', '30')
+    .option('--min-savings <amount>', 'Filter by minimum savings ($/month)')
+    .option('--verbose', 'Verbose logging')
+    .action(scan_js_1.scanCommand);
+program.parse();

package/dist/src/analyzers/cost-estimator.d.ts

@@ -0,0 +1,21 @@
+export declare const EC2_PRICING: Record<string, number>;
+export declare const EBS_PRICING: Record<string, number>;
+export declare const RDS_PRICING: Record<string, number>;
+export declare const S3_PRICING: {
+    standard: number;
+    intelligentTiering: number;
+    glacier: number;
+    glacierDeepArchive: number;
+};
+export declare const ELB_PRICING: {
+    alb: number;
+    nlb: number;
+    clb: number;
+};
+export declare const EIP_PRICING_HOURLY = 0.005;
+export declare function getEC2MonthlyCost(instanceType: string): number;
+export declare function getEBSMonthlyCost(sizeGB: number, volumeType: string): number;
+export declare function getRDSMonthlyCost(instanceClass: string): number;
+export declare function getS3MonthlyCost(sizeGB: number, storageClass?: string): number;
+export declare function getELBMonthlyCost(type?: 'alb' | 'nlb' | 'clb'): number;
+export declare function getEIPMonthlyCost(): number;

package/dist/src/analyzers/cost-estimator.js

@@ -0,0 +1,86 @@
+"use strict";
+// EC2 instance pricing (us-east-1, Linux, on-demand, monthly estimate)
+// Source: AWS pricing as of 2026-01, monthly = hourly × 730
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EIP_PRICING_HOURLY = exports.ELB_PRICING = exports.S3_PRICING = exports.RDS_PRICING = exports.EBS_PRICING = exports.EC2_PRICING = void 0;
+exports.getEC2MonthlyCost = getEC2MonthlyCost;
+exports.getEBSMonthlyCost = getEBSMonthlyCost;
+exports.getRDSMonthlyCost = getRDSMonthlyCost;
+exports.getS3MonthlyCost = getS3MonthlyCost;
+exports.getELBMonthlyCost = getELBMonthlyCost;
+exports.getEIPMonthlyCost = getEIPMonthlyCost;
+exports.EC2_PRICING = {
+    't2.micro': 8.47,
+    't2.small': 16.79,
+    't2.medium': 33.87,
+    't3.micro': 7.59,
+    't3.small': 15.18,
+    't3.medium': 30.37,
+    't3.large': 60.74,
+    't3.xlarge': 121.47,
+    'm5.large': 70.08,
+    'm5.xlarge': 140.16,
+    'm5.2xlarge': 280.32,
+    'm6i.large': 69.35,
+    'm6i.xlarge': 138.70,
+    'c5.large': 62.05,
+    'c5.xlarge': 124.10,
+    'r5.large': 91.25,
+    'r5.xlarge': 182.50,
+};
+// EBS pricing (us-east-1, per GB/month)
+exports.EBS_PRICING = {
+    gp3: 0.08,
+    gp2: 0.10,
+    io1: 0.125,
+    io2: 0.125,
+    st1: 0.045,
+    sc1: 0.015,
+};
+// RDS pricing (us-east-1, per month)
+exports.RDS_PRICING = {
+    'db.t3.micro': 11.01,
+    'db.t3.small': 22.63,
+    'db.t3.medium': 45.26,
+    'db.t3.large': 90.51,
+    'db.m5.large': 127.75,
+    'db.m5.xlarge': 255.50,
+    'db.r5.large': 175.20,
+    'db.r5.xlarge': 350.40,
+    'db.r5.2xlarge': 700.80,
+};
+// S3 pricing (per GB/month)
+exports.S3_PRICING = {
+    standard: 0.023,
+    intelligentTiering: 0.023, // same base, but auto-transitions
+    glacier: 0.004,
+    glacierDeepArchive: 0.00099,
+};
+// ELB pricing (per month, excluding LCU charges)
+exports.ELB_PRICING = {
+    alb: 16.43, // Application Load Balancer
+    nlb: 16.43, // Network Load Balancer
+    clb: 18.25, // Classic Load Balancer
+};
+// Elastic IP pricing (per hour when not associated)
+exports.EIP_PRICING_HOURLY = 0.005; // ~$3.65/month
+function getEC2MonthlyCost(instanceType) {
+    return exports.EC2_PRICING[instanceType] || 0;
+}
+function getEBSMonthlyCost(sizeGB, volumeType) {
+    const pricePerGB = exports.EBS_PRICING[volumeType] || 0.08;
+    return sizeGB * pricePerGB;
+}
+function getRDSMonthlyCost(instanceClass) {
+    return exports.RDS_PRICING[instanceClass] || 0;
+}
+function getS3MonthlyCost(sizeGB, storageClass = 'standard') {
+    const pricePerGB = exports.S3_PRICING[storageClass] || exports.S3_PRICING.standard;
+    return sizeGB * pricePerGB;
+}
+function getELBMonthlyCost(type = 'alb') {
+    return exports.ELB_PRICING[type];
+}
+function getEIPMonthlyCost() {
+    return exports.EIP_PRICING_HOURLY * 730; // ~$3.65
+}

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

@@ -0,0 +1,12 @@
+interface ScanCommandOptions {
+    provider: string;
+    region?: string;
+    profile?: string;
+    top?: string;
+    output?: string;
+    days?: string;
+    minSavings?: string;
+    verbose?: boolean;
+}
+export declare function scanCommand(options: ScanCommandOptions): Promise<void>;
+export {};

package/dist/src/commands/scan.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanCommand = scanCommand;
+const client_1 = require("../providers/aws/client");
+const ec2_1 = require("../providers/aws/ec2");
+const ebs_1 = require("../providers/aws/ebs");
+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 table_1 = require("../reporters/table");
+const json_1 = require("../reporters/json");
+const logger_1 = require("../utils/logger");
+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);
+        }
+        (0, logger_1.info)(`Scanning AWS account (profile: ${options.profile || 'default'}, region: ${options.region || 'us-east-1'})...`);
+        const client = new client_1.AWSClient({
+            region: options.region,
+            profile: options.profile,
+        });
+        // 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 {
+            (0, table_1.renderTable)(report, topN);
+        }
+    }
+    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');
+        }
+        else {
+            (0, logger_1.error)(`Scan failed: ${err.message}`);
+            if (options.verbose) {
+                console.error(err);
+            }
+        }
+        process.exit(1);
+    }
+}

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

@@ -0,0 +1,27 @@
+import { EC2Client } from '@aws-sdk/client-ec2';
+import { CloudWatchClient } from '@aws-sdk/client-cloudwatch';
+import { CostExplorerClient } from '@aws-sdk/client-cost-explorer';
+import { RDSClient } from '@aws-sdk/client-rds';
+import { S3Client } from '@aws-sdk/client-s3';
+import { ElasticLoadBalancingV2Client } from '@aws-sdk/client-elastic-load-balancing-v2';
+export interface AWSClientOptions {
+    region?: string;
+    profile?: string;
+}
+export declare class AWSClient {
+    private ec2;
+    private cloudwatch;
+    private costExplorer;
+    private rds;
+    private s3;
+    private elb;
+    region: string;
+    profile: string;
+    constructor(options: AWSClientOptions);
+    getEC2Client(): EC2Client;
+    getCloudWatchClient(): CloudWatchClient;
+    getCostExplorerClient(): CostExplorerClient;
+    getRDSClient(): RDSClient;
+    getS3Client(): S3Client;
+    getELBClient(): ElasticLoadBalancingV2Client;
+}

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

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AWSClient = void 0;
+const client_ec2_1 = require("@aws-sdk/client-ec2");
+const client_cloudwatch_1 = require("@aws-sdk/client-cloudwatch");
+const client_cost_explorer_1 = require("@aws-sdk/client-cost-explorer");
+const client_rds_1 = require("@aws-sdk/client-rds");
+const client_s3_1 = require("@aws-sdk/client-s3");
+const client_elastic_load_balancing_v2_1 = require("@aws-sdk/client-elastic-load-balancing-v2");
+const credential_providers_1 = require("@aws-sdk/credential-providers");
+class AWSClient {
+    ec2;
+    cloudwatch;
+    costExplorer;
+    rds;
+    s3;
+    elb;
+    region;
+    profile;
+    constructor(options) {
+        this.region = options.region || 'us-east-1';
+        this.profile = options.profile || 'default';
+        // Use environment credentials if available, otherwise fall back to profile
+        const credentials = process.env.AWS_ACCESS_KEY_ID
+            ? (0, credential_providers_1.fromEnv)()
+            : (0, credential_providers_1.fromIni)({ profile: this.profile });
+        this.ec2 = new client_ec2_1.EC2Client({ region: this.region, credentials });
+        this.cloudwatch = new client_cloudwatch_1.CloudWatchClient({ region: this.region, credentials });
+        this.costExplorer = new client_cost_explorer_1.CostExplorerClient({ region: 'us-east-1', credentials });
+        this.rds = new client_rds_1.RDSClient({ region: this.region, credentials });
+        this.s3 = new client_s3_1.S3Client({ region: this.region, credentials });
+        this.elb = new client_elastic_load_balancing_v2_1.ElasticLoadBalancingV2Client({ region: this.region, credentials });
+    }
+    getEC2Client() {
+        return this.ec2;
+    }
+    getCloudWatchClient() {
+        return this.cloudwatch;
+    }
+    getCostExplorerClient() {
+        return this.costExplorer;
+    }
+    getRDSClient() {
+        return this.rds;
+    }
+    getS3Client() {
+        return this.s3;
+    }
+    getELBClient() {
+        return this.elb;
+    }
+}
+exports.AWSClient = AWSClient;

package/dist/src/providers/aws/ebs.d.ts

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

package/dist/src/providers/aws/ebs.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeEBSVolumes = analyzeEBSVolumes;
+const client_ec2_1 = require("@aws-sdk/client-ec2");
+const cost_estimator_1 = require("../../analyzers/cost-estimator");
+const formatter_1 = require("../../utils/formatter");
+async function analyzeEBSVolumes(client) {
+    const ec2Client = client.getEC2Client();
+    const result = await ec2Client.send(new client_ec2_1.DescribeVolumesCommand({
+        Filters: [{ Name: 'status', Values: ['available'] }],
+    }));
+    const volumes = result.Volumes || [];
+    const opportunities = [];
+    for (const volume of volumes) {
+        if (!volume.VolumeId || !volume.Size || !volume.CreateTime)
+            continue;
+        const age = (0, formatter_1.daysSince)(volume.CreateTime);
+        if (age > 7) {
+            const monthlyCost = (0, cost_estimator_1.getEBSMonthlyCost)(volume.Size, volume.VolumeType || 'gp3');
+            opportunities.push({
+                id: `ebs-unattached-${volume.VolumeId}`,
+                provider: 'aws',
+                resourceType: 'ebs',
+                resourceId: volume.VolumeId,
+                resourceName: volume.Tags?.find((t) => t.Key === 'Name')?.Value,
+                category: 'unused',
+                currentCost: monthlyCost,
+                estimatedSavings: monthlyCost,
+                confidence: 'high',
+                recommendation: `Snapshot and delete, or delete if redundant (age: ${age} days)`,
+                metadata: {
+                    size: volume.Size,
+                    volumeType: volume.VolumeType,
+                    age,
+                },
+                detectedAt: new Date(),
+            });
+        }
+    }
+    return opportunities;
+}

package/dist/src/providers/aws/ec2.d.ts

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