cloud-cost-cli 0.3.0 → 0.4.0

package/README.md

@@ -5,9 +5,10 @@
 
 **Optimize your cloud spend in seconds.**
 
-A command-line tool that analyzes your AWS and Azure resources to identify cost-saving opportunities — idle resources, oversized instances, unattached volumes, and more.
+A command-line tool that analyzes your AWS, Azure, and GCP resources to identify cost-saving opportunities — idle resources, oversized instances, unattached volumes, and more.
 
-**✨ NEW in v0.3.0:** AI-powered explanations and natural language queries!
+**✨ NEW in v0.4.0:** GCP support (Compute Engine + Cloud Storage)!  
+**✨ v0.3.0:** AI-powered explanations and natural language queries!
 
 ---
 
@@ -20,7 +21,7 @@ Cloud bills are growing faster than revenue. Engineering teams overprovision, fo
 `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 VMs/EC2 instances (low CPU, stopped but still billed)
+- Idle VMs/Compute instances (low CPU, stopped but still billed)
 - Unattached volumes, disks, and snapshots
 - Oversized database instances (RDS, Azure SQL)
 - Old load balancers with no traffic
@@ -33,9 +34,10 @@ Cloud bills are growing faster than revenue. Engineering teams overprovision, fo
 ## Features
 
 **Current capabilities:**
-- ✅ **Multi-cloud support** - AWS and Azure
+- ✅ **Multi-cloud support** - AWS, Azure, and GCP
 - ✅ **AWS analyzers** - EC2, EBS, RDS, S3, ELB, Elastic IP
 - ✅ **Azure analyzers** - VMs, Managed Disks, Storage, SQL, Public IPs
+- ✅ **GCP analyzers** - Compute Engine, Cloud Storage, Cloud SQL, Persistent Disks, Static IPs
 - ✅ **🤖 AI-powered explanations** - Get human-readable explanations for why resources are costing money
 - ✅ **💬 Natural language queries** - Ask questions like "What's my biggest cost?" or "Show me idle VMs"
 - ✅ **🔒 Privacy-first AI** - Use local Ollama or cloud OpenAI
@@ -46,10 +48,9 @@ Cloud bills are growing faster than revenue. Engineering teams overprovision, fo
 - ✅ Output top savings opportunities with estimated monthly savings
 - ✅ Export report as JSON or terminal table
 - ✅ Filter by minimum savings amount
-- ✅ Comprehensive test suite (84 tests)
 
 **Potential future additions:**
-- GCP support (Compute Engine, Cloud Storage, Cloud SQL)
+- More GCP services (Cloud Functions, Load Balancers, etc.)
 - Real-time pricing API integration
 - Additional AWS services (Lambda, DynamoDB, CloudFront, etc.)
 - Additional Azure services (App Services, CosmosDB, etc.)
@@ -75,6 +76,10 @@ No commitment on timeline - contributions welcome!
     - [Azure CLI](https://learn.microsoft.com/en-us/cli/azure/install-azure-cli) (`az login`) OR
     - Service Principal (env vars: `AZURE_CLIENT_ID`, `AZURE_CLIENT_SECRET`, `AZURE_TENANT_ID`) OR
     - Managed Identity (for Azure VMs)
+  - **GCP**:
+    - [gcloud CLI](https://cloud.google.com/sdk/docs/install) (`gcloud auth application-default login`) OR
+    - Service Account JSON key (env var: `GOOGLE_APPLICATION_CREDENTIALS`) OR
+    - Compute Engine default credentials (for GCP VMs)
 - **Optional for AI features**:
   - OpenAI API key OR
   - [Ollama](https://ollama.ai) installed locally (free, private, runs on your machine)
@@ -110,6 +115,23 @@ export AZURE_SUBSCRIPTION_ID="your-subscription-id"
 cloud-cost-cli scan --provider azure --location eastus
 ```
 
+**GCP scan:**
+```bash
+# Option 1: gcloud CLI (easiest for local use)
+gcloud auth application-default login
+gcloud config set project YOUR_PROJECT_ID
+export GCP_PROJECT_ID="your-project-id"
+cloud-cost-cli scan --provider gcp --region us-central1
+
+# Option 2: Service Account (recommended for CI/CD and automation)
+export GOOGLE_APPLICATION_CREDENTIALS="/path/to/keyfile.json"
+export GCP_PROJECT_ID="your-project-id"
+cloud-cost-cli scan --provider gcp --region us-central1
+
+# Option 3: CLI flag
+cloud-cost-cli scan --provider gcp --project-id your-project-id --region us-central1
+```
+
 **How to create Azure Service Principal:**
 ```bash
 # Create service principal with Reader role

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

@@ -10,15 +10,16 @@ const program = new commander_1.Command();
 program
     .name('cloud-cost-cli')
     .description('Optimize your cloud spend in seconds')
-    .version('0.3.0-beta.1');
+    .version('0.4.0');
 program
     .command('scan')
     .description('Scan cloud account for cost savings')
-    .option('--provider <aws|azure>', 'Cloud provider', 'aws')
-    .option('--region <region>', 'AWS region (e.g., us-east-1)')
+    .option('--provider <aws|azure|gcp>', 'Cloud provider', 'aws')
+    .option('--region <region>', 'Cloud region (e.g., us-east-1 for AWS, us-central1 for GCP)')
     .option('--profile <profile>', 'AWS profile name', 'default')
     .option('--subscription-id <id>', 'Azure subscription ID')
     .option('--location <location>', 'Azure location filter (e.g., eastus, westus2) - optional, scans all if omitted')
+    .option('--project-id <id>', 'GCP project ID')
     .option('--top <N>', 'Show top N opportunities', '5')
     .option('--output <table|json|markdown>', 'Output format', 'table')
     .option('--days <N>', 'Analysis period in days', '30')

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

@@ -13,6 +13,14 @@ export declare const ELB_PRICING: {
     clb: number;
 };
 export declare const EIP_PRICING_HOURLY = 0.005;
+export declare const GCE_PRICING: Record<string, number>;
+export declare const GCS_PRICING: {
+    standard: number;
+    nearline: number;
+    coldline: number;
+    archive: number;
+};
+export declare const GCP_CLOUDSQL_PRICING: Record<string, number>;
 /**
  * Cost estimator with support for both estimate and accurate modes
  */
@@ -33,3 +41,6 @@ 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;
+export declare function getGCEMonthlyCost(machineType: string): number;
+export declare function getGCSMonthlyCost(sizeGB: number, storageClass?: string): number;
+export declare function getGCPCloudSQLMonthlyCost(tier: string): number;

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

@@ -1,12 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CostEstimator = exports.EIP_PRICING_HOURLY = exports.ELB_PRICING = exports.S3_PRICING = exports.RDS_PRICING = exports.EBS_PRICING = exports.EC2_PRICING = void 0;
+exports.CostEstimator = exports.GCP_CLOUDSQL_PRICING = exports.GCS_PRICING = exports.GCE_PRICING = 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.getGCEMonthlyCost = getGCEMonthlyCost;
+exports.getGCSMonthlyCost = getGCSMonthlyCost;
+exports.getGCPCloudSQLMonthlyCost = getGCPCloudSQLMonthlyCost;
 const pricing_service_1 = require("./pricing-service");
 // Fallback pricing estimates (based on us-east-1, Jan 2026)
 // Used when --accurate flag is not set or Pricing API fails
@@ -60,6 +63,35 @@ exports.ELB_PRICING = {
     clb: 18.25,
 };
 exports.EIP_PRICING_HOURLY = 0.005;
+// GCP Pricing (based on us-central1, Jan 2026)
+exports.GCE_PRICING = {
+    'e2-micro': 6.11,
+    'e2-small': 12.23,
+    'e2-medium': 24.45,
+    'n1-standard-1': 24.27,
+    'n1-standard-2': 48.54,
+    'n1-standard-4': 97.09,
+    'n2-standard-2': 58.99,
+    'n2-standard-4': 117.98,
+    'c2-standard-4': 152.39,
+    'c2-standard-8': 304.78,
+};
+exports.GCS_PRICING = {
+    standard: 0.020,
+    nearline: 0.010,
+    coldline: 0.004,
+    archive: 0.0012,
+};
+exports.GCP_CLOUDSQL_PRICING = {
+    'db-n1-standard-1': 46.72,
+    'db-n1-standard-2': 93.45,
+    'db-n1-standard-4': 186.89,
+    'db-n1-standard-8': 373.79,
+    'db-n1-standard-16': 747.58,
+    'db-custom-1-4096': 35.62,
+    'db-custom-2-8192': 71.23,
+    'db-custom-4-16384': 142.47,
+};
 /**
  * Cost estimator with support for both estimate and accurate modes
  */
@@ -142,3 +174,14 @@ function getELBMonthlyCost(type = 'alb') {
 function getEIPMonthlyCost() {
     return exports.EIP_PRICING_HOURLY * 730;
 }
+// GCP cost helpers
+function getGCEMonthlyCost(machineType) {
+    return exports.GCE_PRICING[machineType] || 50; // Generic estimate if unknown
+}
+function getGCSMonthlyCost(sizeGB, storageClass = 'standard') {
+    const pricePerGB = exports.GCS_PRICING[storageClass] || exports.GCS_PRICING.standard;
+    return sizeGB * pricePerGB;
+}
+function getGCPCloudSQLMonthlyCost(tier) {
+    return exports.GCP_CLOUDSQL_PRICING[tier] || 50; // Generic estimate if unknown
+}

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

@@ -4,6 +4,7 @@ interface ScanCommandOptions {
     profile?: string;
     subscriptionId?: string;
     location?: string;
+    projectId?: string;
     top?: string;
     output?: string;
     days?: string;

package/dist/src/commands/scan.js

@@ -14,6 +14,12 @@ 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 client_3 = require("../providers/gcp/client");
+const compute_1 = require("../providers/gcp/compute");
+const storage_2 = require("../providers/gcp/storage");
+const cloudsql_1 = require("../providers/gcp/cloudsql");
+const disks_2 = require("../providers/gcp/disks");
+const static_ips_1 = require("../providers/gcp/static-ips");
 const table_1 = require("../reporters/table");
 const json_1 = require("../reporters/json");
 const logger_1 = require("../utils/logger");
@@ -28,8 +34,11 @@ async function scanCommand(options) {
         else if (options.provider === 'azure') {
             await scanAzure(options);
         }
+        else if (options.provider === 'gcp') {
+            await scanGCP(options);
+        }
         else {
-            (0, logger_1.error)(`Provider "${options.provider}" not yet supported. Use --provider aws or --provider azure`);
+            (0, logger_1.error)(`Provider "${options.provider}" not yet supported. Use --provider aws, azure, or gcp`);
             process.exit(1);
         }
     }
@@ -287,3 +296,116 @@ async function scanAzure(options) {
         await (0, table_1.renderTable)(report, topN, aiService);
     }
 }
+async function scanGCP(options) {
+    const client = new client_3.GCPClient({
+        projectId: options.projectId,
+        region: options.region,
+    });
+    (0, logger_1.info)(`Scanning GCP project (${client.projectId}, region: ${client.region})...`);
+    // Test connection before scanning
+    (0, logger_1.info)('Testing GCP credentials...');
+    await client.testConnection();
+    (0, logger_1.success)('GCP credentials verified ✓');
+    // Run analyzers in parallel
+    (0, logger_1.info)('Analyzing Compute Engine instances...');
+    const gcePromise = (0, compute_1.analyzeGCEInstances)(client);
+    (0, logger_1.info)('Analyzing Cloud Storage buckets...');
+    const gcsPromise = (0, storage_2.analyzeGCSBuckets)(client);
+    (0, logger_1.info)('Analyzing Cloud SQL instances...');
+    const cloudsqlPromise = (0, cloudsql_1.analyzeCloudSQLInstances)(client);
+    (0, logger_1.info)('Analyzing Persistent Disks...');
+    const disksPromise = (0, disks_2.analyzePersistentDisks)(client);
+    (0, logger_1.info)('Analyzing Static IPs...');
+    const ipsPromise = (0, static_ips_1.analyzeStaticIPs)(client);
+    // Wait for all analyzers to complete
+    const [gceOpportunities, gcsOpportunities, cloudsqlOpportunities, disksOpportunities, ipsOpportunities,] = await Promise.all([
+        gcePromise,
+        gcsPromise,
+        cloudsqlPromise,
+        disksPromise,
+        ipsPromise,
+    ]);
+    (0, logger_1.success)(`Found ${gceOpportunities.length} Compute Engine opportunities`);
+    (0, logger_1.success)(`Found ${gcsOpportunities.length} Cloud Storage opportunities`);
+    (0, logger_1.success)(`Found ${cloudsqlOpportunities.length} Cloud SQL opportunities`);
+    (0, logger_1.success)(`Found ${disksOpportunities.length} Persistent Disk opportunities`);
+    (0, logger_1.success)(`Found ${ipsOpportunities.length} Static IP opportunities`);
+    // Combine opportunities
+    const allOpportunities = [
+        ...gceOpportunities,
+        ...gcsOpportunities,
+        ...cloudsqlOpportunities,
+        ...disksOpportunities,
+        ...ipsOpportunities,
+    ];
+    // 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: 'gcp',
+        accountId: client.projectId,
+        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;
+        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)('gcp', client.region, report);
+    if (options.output === 'json') {
+        (0, json_1.renderJSON)(report);
+    }
+    else {
+        await (0, table_1.renderTable)(report, topN, aiService);
+    }
+}

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

@@ -39,8 +39,16 @@ class AzureClient {
                 errorMsg.includes('login') ||
                 error.statusCode === 401 ||
                 error.code === 'CredentialUnavailableError') {
-                throw new Error('Azure authentication failed. Please run "az login" first or set up service principal credentials.\n' +
-                    'See: https://learn.microsoft.com/en-us/cli/azure/authenticate-azure-cli');
+                throw new Error('Azure authentication failed. Choose one of these options:\n\n' +
+                    'Option 1 - Azure CLI (easiest):\n' +
+                    '  az login\n\n' +
+                    'Option 2 - Service Principal (recommended for automation):\n' +
+                    '  export AZURE_CLIENT_ID="your-app-id"\n' +
+                    '  export AZURE_CLIENT_SECRET="your-secret"\n' +
+                    '  export AZURE_TENANT_ID="your-tenant-id"\n\n' +
+                    'Option 3 - Managed Identity (for Azure VMs):\n' +
+                    '  Runs automatically on Azure VMs with managed identity enabled\n\n' +
+                    'See: https://learn.microsoft.com/en-us/javascript/api/overview/azure/identity-readme');
             }
             throw error;
         }

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

@@ -0,0 +1,29 @@
+import { InstancesClient, DisksClient, AddressesClient, GlobalAddressesClient } from '@google-cloud/compute';
+import { Storage } from '@google-cloud/storage';
+import { MetricServiceClient } from '@google-cloud/monitoring';
+import { SqlInstancesServiceClient } from '@google-cloud/sql';
+export interface GCPClientConfig {
+    projectId?: string;
+    region?: string;
+    keyFilename?: string;
+}
+export declare class GCPClient {
+    projectId: string;
+    region: string;
+    private computeClient;
+    private disksClient;
+    private addressesClient;
+    private globalAddressesClient;
+    private storageClient;
+    private monitoringClient;
+    private sqlClient;
+    constructor(config?: GCPClientConfig);
+    testConnection(): Promise<void>;
+    getComputeClient(): InstancesClient;
+    getDisksClient(): DisksClient;
+    getAddressesClient(): AddressesClient;
+    getGlobalAddressesClient(): GlobalAddressesClient;
+    getStorageClient(): Storage;
+    getMonitoringClient(): MetricServiceClient;
+    getCloudSQLClient(): SqlInstancesServiceClient;
+}

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

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GCPClient = void 0;
+const compute_1 = require("@google-cloud/compute");
+const storage_1 = require("@google-cloud/storage");
+const monitoring_1 = require("@google-cloud/monitoring");
+const sql_1 = require("@google-cloud/sql");
+class GCPClient {
+    projectId;
+    region;
+    computeClient;
+    disksClient;
+    addressesClient;
+    globalAddressesClient;
+    storageClient;
+    monitoringClient;
+    sqlClient;
+    constructor(config = {}) {
+        // Get project ID from config, env, or default credentials
+        this.projectId =
+            config.projectId ||
+                process.env.GCP_PROJECT_ID ||
+                process.env.GOOGLE_CLOUD_PROJECT ||
+                process.env.GCLOUD_PROJECT ||
+                '';
+        if (!this.projectId) {
+            throw new Error('GCP project ID not found. Set GCP_PROJECT_ID environment variable or use --project-id flag.');
+        }
+        this.region = config.region || process.env.GCP_REGION || 'us-central1';
+        // Initialize clients with optional keyFilename
+        const clientConfig = config.keyFilename
+            ? { keyFilename: config.keyFilename }
+            : {};
+        this.computeClient = new compute_1.InstancesClient(clientConfig);
+        this.disksClient = new compute_1.DisksClient(clientConfig);
+        this.addressesClient = new compute_1.AddressesClient(clientConfig);
+        this.globalAddressesClient = new compute_1.GlobalAddressesClient(clientConfig);
+        this.storageClient = new storage_1.Storage(clientConfig);
+        this.monitoringClient = new monitoring_1.MetricServiceClient(clientConfig);
+        this.sqlClient = new sql_1.SqlInstancesServiceClient(clientConfig);
+    }
+    // Test GCP credentials by making a lightweight API call
+    async testConnection() {
+        try {
+            // Try to list instances in a single zone (limited scope)
+            const zone = `${this.region}-a`;
+            const request = {
+                project: this.projectId,
+                zone: zone,
+                maxResults: 1,
+            };
+            await this.computeClient.list(request);
+        }
+        catch (error) {
+            const errorMsg = error.message || '';
+            if (errorMsg.includes('authentication') ||
+                errorMsg.includes('credentials') ||
+                errorMsg.includes('permission') ||
+                errorMsg.includes('quota') ||
+                error.code === 401 ||
+                error.code === 403) {
+                throw new Error('GCP authentication failed. Choose one of these options:\n\n' +
+                    'Option 1 - gcloud CLI (easiest):\n' +
+                    '  gcloud auth application-default login\n' +
+                    '  gcloud config set project YOUR_PROJECT_ID\n\n' +
+                    'Option 2 - Service Account (recommended for automation):\n' +
+                    '  export GOOGLE_APPLICATION_CREDENTIALS="/path/to/keyfile.json"\n' +
+                    '  export GCP_PROJECT_ID="your-project-id"\n\n' +
+                    'Option 3 - Compute Engine (for GCP VMs):\n' +
+                    '  Runs automatically on GCP VMs with service account attached\n\n' +
+                    'See: https://cloud.google.com/docs/authentication/getting-started');
+            }
+            throw error;
+        }
+    }
+    getComputeClient() {
+        return this.computeClient;
+    }
+    getDisksClient() {
+        return this.disksClient;
+    }
+    getAddressesClient() {
+        return this.addressesClient;
+    }
+    getGlobalAddressesClient() {
+        return this.globalAddressesClient;
+    }
+    getStorageClient() {
+        return this.storageClient;
+    }
+    getMonitoringClient() {
+        return this.monitoringClient;
+    }
+    getCloudSQLClient() {
+        return this.sqlClient;
+    }
+}
+exports.GCPClient = GCPClient;

package/dist/src/providers/gcp/cloudsql.d.ts

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

package/dist/src/providers/gcp/cloudsql.js

@@ -0,0 +1,115 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeCloudSQLInstances = analyzeCloudSQLInstances;
+const cost_estimator_1 = require("../../analyzers/cost-estimator");
+const dayjs_1 = __importDefault(require("dayjs"));
+async function analyzeCloudSQLInstances(client) {
+    const sqlClient = client.getCloudSQLClient();
+    const monitoringClient = client.getMonitoringClient();
+    const opportunities = [];
+    try {
+        const request = {
+            project: client.projectId,
+        };
+        const response = await sqlClient.list(request);
+        const instances = response[0]?.items || [];
+        for (const instance of instances || []) {
+            if (!instance.name || !instance.settings?.tier)
+                continue;
+            // Get average CPU over last 30 days
+            const avgCpu = await getAvgCPU(monitoringClient, client.projectId, instance.name, 30);
+            // Detect oversized: low CPU (<20%)
+            if (avgCpu < 20 && avgCpu > 0 && instance.state === 'RUNNABLE') {
+                const tier = instance.settings.tier;
+                const currentCost = (0, cost_estimator_1.getGCPCloudSQLMonthlyCost)(tier);
+                // Estimate smaller tier
+                const smallerTier = getSmallerTier(tier);
+                const proposedCost = smallerTier ? (0, cost_estimator_1.getGCPCloudSQLMonthlyCost)(smallerTier) : 0;
+                const savings = currentCost - proposedCost;
+                if (savings > 0) {
+                    opportunities.push({
+                        id: `cloudsql-oversized-${instance.name}`,
+                        provider: 'gcp',
+                        resourceType: 'cloud-sql',
+                        resourceId: instance.name,
+                        resourceName: instance.name,
+                        category: 'oversized',
+                        currentCost,
+                        estimatedSavings: savings,
+                        confidence: 'medium',
+                        recommendation: `Downsize to ${smallerTier || 'smaller tier'} (avg CPU: ${avgCpu.toFixed(1)}%)`,
+                        metadata: {
+                            tier,
+                            avgCpu,
+                            databaseVersion: instance.databaseVersion,
+                            region: instance.region,
+                        },
+                        detectedAt: new Date(),
+                    });
+                }
+            }
+        }
+    }
+    catch (error) {
+        // Skip if Cloud SQL API is not enabled or permission issues
+    }
+    return opportunities;
+}
+async function getAvgCPU(monitoringClient, projectId, instanceName, days) {
+    const endTime = new Date();
+    const startTime = (0, dayjs_1.default)(endTime).subtract(days, 'day').toDate();
+    try {
+        const request = {
+            name: `projects/${projectId}`,
+            filter: `metric.type="cloudsql.googleapis.com/database/cpu/utilization" ` +
+                `AND resource.labels.database_id="${projectId}:${instanceName}"`,
+            interval: {
+                startTime: {
+                    seconds: Math.floor(startTime.getTime() / 1000),
+                },
+                endTime: {
+                    seconds: Math.floor(endTime.getTime() / 1000),
+                },
+            },
+            aggregation: {
+                alignmentPeriod: { seconds: 86400 }, // 1 day
+                perSeriesAligner: 'ALIGN_MEAN',
+                crossSeriesReducer: 'REDUCE_MEAN',
+            },
+        };
+        const [timeSeries] = await monitoringClient.listTimeSeries(request);
+        if (!timeSeries || timeSeries.length === 0) {
+            return 0;
+        }
+        let sum = 0;
+        let count = 0;
+        for (const series of timeSeries) {
+            for (const point of series.points || []) {
+                if (point.value?.doubleValue !== undefined) {
+                    // GCP returns CPU as a ratio (0-1), convert to percentage
+                    sum += point.value.doubleValue * 100;
+                    count++;
+                }
+            }
+        }
+        return count > 0 ? sum / count : 0;
+    }
+    catch (error) {
+        return 0;
+    }
+}
+function getSmallerTier(currentTier) {
+    // GCP Cloud SQL tier mapping (simplified)
+    const tierMap = {
+        'db-n1-standard-4': 'db-n1-standard-2',
+        'db-n1-standard-2': 'db-n1-standard-1',
+        'db-n1-standard-8': 'db-n1-standard-4',
+        'db-n1-standard-16': 'db-n1-standard-8',
+        'db-custom-4-16384': 'db-custom-2-8192',
+        'db-custom-2-8192': 'db-custom-1-4096',
+    };
+    return tierMap[currentTier] || null;
+}

package/dist/src/providers/gcp/compute.d.ts

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

package/dist/src/providers/gcp/compute.js

@@ -0,0 +1,108 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeGCEInstances = analyzeGCEInstances;
+const cost_estimator_1 = require("../../analyzers/cost-estimator");
+const dayjs_1 = __importDefault(require("dayjs"));
+async function analyzeGCEInstances(client) {
+    const computeClient = client.getComputeClient();
+    const monitoringClient = client.getMonitoringClient();
+    const opportunities = [];
+    // GCP instances are zone-specific, so we need to check multiple zones
+    const zones = await getZonesInRegion(client.region);
+    for (const zone of zones) {
+        const [instances] = await computeClient.list({
+            project: client.projectId,
+            zone: zone,
+            filter: 'status = "RUNNING"',
+        });
+        for await (const instance of instances) {
+            if (!instance.name || !instance.machineType)
+                continue;
+            // Extract machine type from full URL (e.g., "zones/us-central1-a/machineTypes/n1-standard-1")
+            const machineType = instance.machineType.split('/').pop() || '';
+            // Get average CPU over last 30 days
+            const avgCpu = await getAvgCPU(monitoringClient, client.projectId, instance.name, zone, 30);
+            if (avgCpu < 5) {
+                const monthlyCost = (0, cost_estimator_1.getGCEMonthlyCost)(machineType);
+                opportunities.push({
+                    id: `gce-idle-${instance.name}`,
+                    provider: 'gcp',
+                    resourceType: 'compute-engine',
+                    resourceId: instance.name,
+                    resourceName: instance.labels?.name || instance.name,
+                    category: 'idle',
+                    currentCost: monthlyCost,
+                    estimatedSavings: monthlyCost,
+                    confidence: 'high',
+                    recommendation: `Stop instance or downsize to e2-micro (avg CPU: ${avgCpu.toFixed(1)}%)`,
+                    metadata: {
+                        machineType,
+                        zone,
+                        avgCpu,
+                        status: instance.status,
+                    },
+                    detectedAt: new Date(),
+                });
+            }
+        }
+    }
+    return opportunities;
+}
+async function getAvgCPU(monitoringClient, projectId, instanceName, zone, days) {
+    const endTime = new Date();
+    const startTime = (0, dayjs_1.default)(endTime).subtract(days, 'day').toDate();
+    try {
+        const request = {
+            name: `projects/${projectId}`,
+            filter: `metric.type="compute.googleapis.com/instance/cpu/utilization" ` +
+                `AND resource.labels.instance_id="${instanceName}" ` +
+                `AND resource.labels.zone="${zone}"`,
+            interval: {
+                startTime: {
+                    seconds: Math.floor(startTime.getTime() / 1000),
+                },
+                endTime: {
+                    seconds: Math.floor(endTime.getTime() / 1000),
+                },
+            },
+            aggregation: {
+                alignmentPeriod: { seconds: 86400 }, // 1 day
+                perSeriesAligner: 'ALIGN_MEAN',
+                crossSeriesReducer: 'REDUCE_MEAN',
+            },
+        };
+        const [timeSeries] = await monitoringClient.listTimeSeries(request);
+        if (!timeSeries || timeSeries.length === 0) {
+            return 0;
+        }
+        let sum = 0;
+        let count = 0;
+        for (const series of timeSeries) {
+            for (const point of series.points || []) {
+                if (point.value?.doubleValue !== undefined) {
+                    // GCP returns CPU as a ratio (0-1), convert to percentage
+                    sum += point.value.doubleValue * 100;
+                    count++;
+                }
+            }
+        }
+        return count > 0 ? sum / count : 0;
+    }
+    catch (error) {
+        // Monitoring metrics may not be available for all instances
+        return 0;
+    }
+}
+function getZonesInRegion(region) {
+    // Common GCP zones per region (a, b, c, f)
+    // In a production app, you'd query this dynamically via Compute API
+    return [
+        `${region}-a`,
+        `${region}-b`,
+        `${region}-c`,
+        `${region}-f`,
+    ];
+}

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

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

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

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzePersistentDisks = analyzePersistentDisks;
+async function analyzePersistentDisks(client) {
+    const computeClient = client.getComputeClient();
+    const opportunities = [];
+    // GCP disks are zone-specific
+    const zones = await getZonesInRegion(client.region);
+    for (const zone of zones) {
+        try {
+            const disksClient = client.getDisksClient();
+            const [disks] = await disksClient.list({
+                project: client.projectId,
+                zone: zone,
+            });
+            for await (const disk of disks) {
+                if (!disk.name || !disk.sizeGb)
+                    continue;
+                // Disk is unattached if users array is empty or undefined
+                const isUnattached = !disk.users || disk.users.length === 0;
+                if (isUnattached) {
+                    const sizeGB = parseInt(disk.sizeGb.toString());
+                    const diskType = disk.type?.split('/').pop() || 'pd-standard';
+                    const pricePerGB = getDiskPricePerGB(diskType);
+                    const monthlyCost = sizeGB * pricePerGB;
+                    opportunities.push({
+                        id: `disk-unattached-${disk.name}`,
+                        provider: 'gcp',
+                        resourceType: 'persistent-disk',
+                        resourceId: disk.name,
+                        resourceName: disk.name,
+                        category: 'unused',
+                        currentCost: monthlyCost,
+                        estimatedSavings: monthlyCost,
+                        confidence: 'high',
+                        recommendation: `Delete unattached disk or create snapshot and delete`,
+                        metadata: {
+                            sizeGB,
+                            diskType,
+                            zone,
+                            creationTimestamp: disk.creationTimestamp,
+                        },
+                        detectedAt: new Date(),
+                    });
+                }
+            }
+        }
+        catch (error) {
+            // Skip zones with permission issues or API errors
+            continue;
+        }
+    }
+    return opportunities;
+}
+function getDiskPricePerGB(diskType) {
+    // GCP disk pricing per GB/month (us-central1, Jan 2026)
+    const pricing = {
+        'pd-standard': 0.040,
+        'pd-balanced': 0.100,
+        'pd-ssd': 0.170,
+        'pd-extreme': 0.125,
+    };
+    return pricing[diskType] || 0.040; // Default to standard
+}
+function getZonesInRegion(region) {
+    // Common GCP zones per region
+    return [
+        `${region}-a`,
+        `${region}-b`,
+        `${region}-c`,
+        `${region}-f`,
+    ];
+}

package/dist/src/providers/gcp/static-ips.d.ts

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

package/dist/src/providers/gcp/static-ips.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeStaticIPs = analyzeStaticIPs;
+async function analyzeStaticIPs(client) {
+    const computeClient = client.getComputeClient();
+    const opportunities = [];
+    try {
+        const addressesClient = client.getAddressesClient();
+        // Check regional addresses
+        const [regionalAddresses] = await addressesClient.list({
+            project: client.projectId,
+            region: client.region,
+        });
+        for await (const address of regionalAddresses) {
+            if (!address.name)
+                continue;
+            // Address is unused if status is RESERVED (not IN_USE)
+            const isUnused = address.status === 'RESERVED';
+            if (isUnused) {
+                // GCP charges $0.010/hour for unused static IPs
+                const monthlyCost = 0.010 * 730; // ~$7.30/month
+                opportunities.push({
+                    id: `static-ip-unused-${address.name}`,
+                    provider: 'gcp',
+                    resourceType: 'static-ip',
+                    resourceId: address.name,
+                    resourceName: address.name,
+                    category: 'unused',
+                    currentCost: monthlyCost,
+                    estimatedSavings: monthlyCost,
+                    confidence: 'high',
+                    recommendation: `Release unused static IP address`,
+                    metadata: {
+                        ipAddress: address.address,
+                        region: client.region,
+                        status: address.status,
+                    },
+                    detectedAt: new Date(),
+                });
+            }
+        }
+        // Also check global addresses
+        const globalAddressesClient = client.getGlobalAddressesClient();
+        const [globalAddresses] = await globalAddressesClient.list({
+            project: client.projectId,
+        });
+        for await (const address of globalAddresses) {
+            if (!address.name)
+                continue;
+            const isUnused = address.status === 'RESERVED';
+            if (isUnused) {
+                const monthlyCost = 0.010 * 730;
+                opportunities.push({
+                    id: `global-static-ip-unused-${address.name}`,
+                    provider: 'gcp',
+                    resourceType: 'static-ip',
+                    resourceId: address.name,
+                    resourceName: address.name,
+                    category: 'unused',
+                    currentCost: monthlyCost,
+                    estimatedSavings: monthlyCost,
+                    confidence: 'high',
+                    recommendation: `Release unused global static IP address`,
+                    metadata: {
+                        ipAddress: address.address,
+                        addressType: 'GLOBAL',
+                        status: address.status,
+                    },
+                    detectedAt: new Date(),
+                });
+            }
+        }
+    }
+    catch (error) {
+        // Skip if Compute API errors
+    }
+    return opportunities;
+}

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

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

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

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeGCSBuckets = analyzeGCSBuckets;
+const cost_estimator_1 = require("../../analyzers/cost-estimator");
+async function analyzeGCSBuckets(client) {
+    const storageClient = client.getStorageClient();
+    const [buckets] = await storageClient.getBuckets({
+        project: client.projectId,
+    });
+    const opportunities = [];
+    for (const bucket of buckets) {
+        try {
+            // Check if bucket has lifecycle management rules
+            const [metadata] = await bucket.getMetadata();
+            const lifecycleRules = metadata.lifecycle?.rule;
+            if (!lifecycleRules || lifecycleRules.length === 0) {
+                // Estimate bucket size from metadata or use placeholder
+                // In production, you'd integrate with Cloud Monitoring for accurate size
+                const estimatedSizeGB = 100; // Placeholder
+                const currentCost = (0, cost_estimator_1.getGCSMonthlyCost)(estimatedSizeGB, 'standard');
+                const nearlineCost = (0, cost_estimator_1.getGCSMonthlyCost)(estimatedSizeGB * 0.5, 'nearline'); // 50% to Nearline
+                const savings = currentCost - nearlineCost - (estimatedSizeGB * 0.5 * 0.020); // Remaining in standard
+                if (savings > 5) {
+                    opportunities.push({
+                        id: `gcs-no-lifecycle-${bucket.name}`,
+                        provider: 'gcp',
+                        resourceType: 'cloud-storage',
+                        resourceId: bucket.name,
+                        resourceName: bucket.name,
+                        category: 'misconfigured',
+                        currentCost,
+                        estimatedSavings: savings,
+                        confidence: 'low',
+                        recommendation: `Enable lifecycle policy (Nearline or Coldline transition)`,
+                        metadata: {
+                            bucketName: bucket.name,
+                            storageClass: metadata.storageClass,
+                            location: metadata.location,
+                            estimatedSizeGB,
+                        },
+                        detectedAt: new Date(),
+                    });
+                }
+            }
+        }
+        catch (error) {
+            // Skip buckets with permission issues
+            continue;
+        }
+    }
+    return opportunities;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cloud-cost-cli",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Optimize your cloud spend in seconds",
   "main": "dist/index.js",
   "bin": {
@@ -18,6 +18,8 @@
   "keywords": [
     "cloud",
     "aws",
+    "azure",
+    "gcp",
     "cost",
     "optimization",
     "cli",
@@ -25,7 +27,8 @@
     "cost-optimization",
     "aws-cli",
     "devops",
-    "cloud-cost"
+    "cloud-cost",
+    "google-cloud"
   ],
   "author": "Phuong Vu <vuhuuphuong@gmail.com>",
   "repository": {
@@ -58,6 +61,10 @@
     "@azure/arm-sql": "^10.0.0",
     "@azure/arm-storage": "^19.1.0",
     "@azure/identity": "^4.13.0",
+    "@google-cloud/compute": "^6.7.0",
+    "@google-cloud/monitoring": "^5.3.1",
+    "@google-cloud/sql": "^0.24.0",
+    "@google-cloud/storage": "^7.18.0",
     "chalk": "^5.3.0",
     "cli-table3": "^0.6.5",
     "commander": "^12.1.0",