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

package/dist/src/utils/cache.js

@@ -0,0 +1,197 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExplanationCache = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+class ExplanationCache {
+    cacheDir;
+    cacheDuration; // in milliseconds
+    constructor(cacheDuration = 7 * 24 * 60 * 60 * 1000) {
+        this.cacheDir = path.join(process.env.HOME || '/tmp', '.cloud-cost-cli', 'cache');
+        this.cacheDuration = cacheDuration;
+        this.ensureCacheDir();
+    }
+    ensureCacheDir() {
+        if (!fs.existsSync(this.cacheDir)) {
+            fs.mkdirSync(this.cacheDir, { recursive: true });
+        }
+    }
+    hashOpportunity(data) {
+        const str = JSON.stringify({
+            provider: data.provider,
+            resourceType: data.resourceType,
+            category: data.category,
+            recommendation: data.recommendation,
+            // Include key metadata that affects the explanation
+            metadata: {
+                avgCpu: data.metadata?.avgCpu,
+                size: data.metadata?.size,
+                tier: data.metadata?.tier,
+            },
+        });
+        return crypto.createHash('sha256').update(str).digest('hex').substring(0, 16);
+    }
+    getCachePath(hash) {
+        return path.join(this.cacheDir, `${hash}.json`);
+    }
+    get(opportunityData, provider, model) {
+        const hash = this.hashOpportunity(opportunityData);
+        const cachePath = this.getCachePath(hash);
+        if (!fs.existsSync(cachePath)) {
+            return null;
+        }
+        try {
+            const data = fs.readFileSync(cachePath, 'utf-8');
+            const cached = JSON.parse(data);
+            // Check if cache is expired
+            const age = Date.now() - cached.timestamp;
+            if (age > this.cacheDuration) {
+                // Cache expired, delete it
+                fs.unlinkSync(cachePath);
+                return null;
+            }
+            // Check if provider/model match
+            if (cached.provider !== provider || cached.model !== model) {
+                return null;
+            }
+            return cached.explanation;
+        }
+        catch (error) {
+            // Invalid cache file, delete it
+            try {
+                fs.unlinkSync(cachePath);
+            }
+            catch (e) {
+                // Ignore deletion errors
+            }
+            return null;
+        }
+    }
+    set(opportunityData, provider, model, explanation) {
+        const hash = this.hashOpportunity(opportunityData);
+        const cachePath = this.getCachePath(hash);
+        const cached = {
+            opportunityHash: hash,
+            explanation,
+            timestamp: Date.now(),
+            provider,
+            model,
+        };
+        try {
+            fs.writeFileSync(cachePath, JSON.stringify(cached, null, 2), 'utf-8');
+        }
+        catch (error) {
+            // Failed to write cache, not critical - continue without caching
+        }
+    }
+    clear() {
+        let count = 0;
+        try {
+            const files = fs.readdirSync(this.cacheDir);
+            for (const file of files) {
+                if (file.endsWith('.json')) {
+                    fs.unlinkSync(path.join(this.cacheDir, file));
+                    count++;
+                }
+            }
+        }
+        catch (error) {
+            // Directory doesn't exist or can't be read
+        }
+        return count;
+    }
+    clearExpired() {
+        let count = 0;
+        try {
+            const files = fs.readdirSync(this.cacheDir);
+            for (const file of files) {
+                if (!file.endsWith('.json'))
+                    continue;
+                const filePath = path.join(this.cacheDir, file);
+                try {
+                    const data = fs.readFileSync(filePath, 'utf-8');
+                    const cached = JSON.parse(data);
+                    const age = Date.now() - cached.timestamp;
+                    if (age > this.cacheDuration) {
+                        fs.unlinkSync(filePath);
+                        count++;
+                    }
+                }
+                catch (error) {
+                    // Invalid file, delete it
+                    fs.unlinkSync(filePath);
+                    count++;
+                }
+            }
+        }
+        catch (error) {
+            // Directory doesn't exist or can't be read
+        }
+        return count;
+    }
+    getStats() {
+        let total = 0;
+        let size = 0;
+        let oldest = null;
+        try {
+            const files = fs.readdirSync(this.cacheDir);
+            for (const file of files) {
+                if (!file.endsWith('.json'))
+                    continue;
+                const filePath = path.join(this.cacheDir, file);
+                try {
+                    const stats = fs.statSync(filePath);
+                    size += stats.size;
+                    total++;
+                    const data = fs.readFileSync(filePath, 'utf-8');
+                    const cached = JSON.parse(data);
+                    if (oldest === null || cached.timestamp < oldest) {
+                        oldest = cached.timestamp;
+                    }
+                }
+                catch (error) {
+                    // Skip invalid files
+                }
+            }
+        }
+        catch (error) {
+            // Directory doesn't exist
+        }
+        return { total, size, oldest };
+    }
+}
+exports.ExplanationCache = ExplanationCache;

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

@@ -0,0 +1,37 @@
+export interface Config {
+    ai?: {
+        provider?: 'openai' | 'ollama';
+        apiKey?: string;
+        model?: string;
+        maxExplanations?: number;
+        cache?: {
+            enabled?: boolean;
+            ttlDays?: number;
+        };
+    };
+    scan?: {
+        defaultProvider?: 'aws' | 'azure';
+        defaultRegion?: string;
+        defaultTop?: number;
+        minSavings?: number;
+    };
+    aws?: {
+        profile?: string;
+        region?: string;
+    };
+    azure?: {
+        subscriptionId?: string;
+        location?: string;
+    };
+}
+export declare class ConfigLoader {
+    private static CONFIG_FILENAME;
+    private static DEFAULT_CONFIG;
+    static load(): Config;
+    static save(config: Config): void;
+    static getConfigPath(): string;
+    private static findConfigFile;
+    private static mergeConfig;
+    static validate(config: Config): string[];
+    static generateExample(): string;
+}

package/dist/src/utils/config.js

@@ -0,0 +1,175 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigLoader = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+class ConfigLoader {
+    static CONFIG_FILENAME = '.cloud-cost-cli.json';
+    static DEFAULT_CONFIG = {
+        ai: {
+            provider: 'openai',
+            maxExplanations: 3,
+            cache: {
+                enabled: true,
+                ttlDays: 7,
+            },
+        },
+        scan: {
+            defaultProvider: 'aws',
+            defaultTop: 5,
+        },
+    };
+    static load() {
+        const configPath = this.findConfigFile();
+        if (!configPath) {
+            return this.DEFAULT_CONFIG;
+        }
+        try {
+            const content = fs.readFileSync(configPath, 'utf-8');
+            const userConfig = JSON.parse(content);
+            // Merge with defaults
+            return this.mergeConfig(this.DEFAULT_CONFIG, userConfig);
+        }
+        catch (error) {
+            console.warn(`Warning: Failed to load config from ${configPath}: ${error.message}`);
+            return this.DEFAULT_CONFIG;
+        }
+    }
+    static save(config) {
+        const configPath = path.join(os.homedir(), this.CONFIG_FILENAME);
+        try {
+            fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8');
+        }
+        catch (error) {
+            throw new Error(`Failed to save config: ${error.message}`);
+        }
+    }
+    static getConfigPath() {
+        return this.findConfigFile() || path.join(os.homedir(), this.CONFIG_FILENAME);
+    }
+    static findConfigFile() {
+        // Search order:
+        // 1. Current directory
+        // 2. Home directory
+        // 3. XDG_CONFIG_HOME/cloud-cost-cli/
+        const searchPaths = [
+            path.join(process.cwd(), this.CONFIG_FILENAME),
+            path.join(os.homedir(), this.CONFIG_FILENAME),
+            path.join(process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config'), 'cloud-cost-cli', 'config.json'),
+        ];
+        for (const configPath of searchPaths) {
+            if (fs.existsSync(configPath)) {
+                return configPath;
+            }
+        }
+        return null;
+    }
+    static mergeConfig(defaults, user) {
+        return {
+            ai: {
+                ...defaults.ai,
+                ...user.ai,
+                cache: {
+                    ...defaults.ai?.cache,
+                    ...user.ai?.cache,
+                },
+            },
+            scan: {
+                ...defaults.scan,
+                ...user.scan,
+            },
+            aws: {
+                ...defaults.aws,
+                ...user.aws,
+            },
+            azure: {
+                ...defaults.azure,
+                ...user.azure,
+            },
+        };
+    }
+    static validate(config) {
+        const errors = [];
+        if (config.ai?.provider && !['openai', 'ollama'].includes(config.ai.provider)) {
+            errors.push(`Invalid AI provider: ${config.ai.provider}. Must be 'openai' or 'ollama'.`);
+        }
+        if (config.ai?.maxExplanations !== undefined) {
+            if (config.ai.maxExplanations < 1 || config.ai.maxExplanations > 10) {
+                errors.push('ai.maxExplanations must be between 1 and 10');
+            }
+        }
+        if (config.ai?.cache?.ttlDays !== undefined) {
+            if (config.ai.cache.ttlDays < 1 || config.ai.cache.ttlDays > 365) {
+                errors.push('ai.cache.ttlDays must be between 1 and 365');
+            }
+        }
+        if (config.scan?.defaultProvider && !['aws', 'azure'].includes(config.scan.defaultProvider)) {
+            errors.push(`Invalid default provider: ${config.scan.defaultProvider}`);
+        }
+        return errors;
+    }
+    static generateExample() {
+        const example = {
+            ai: {
+                provider: 'openai',
+                apiKey: 'sk-your-openai-key-here',
+                model: 'gpt-4o-mini',
+                maxExplanations: 3,
+                cache: {
+                    enabled: true,
+                    ttlDays: 7,
+                },
+            },
+            scan: {
+                defaultProvider: 'aws',
+                defaultRegion: 'us-east-1',
+                defaultTop: 5,
+                minSavings: 10,
+            },
+            aws: {
+                profile: 'default',
+                region: 'us-east-1',
+            },
+            azure: {
+                subscriptionId: 'your-subscription-id',
+                location: 'eastus',
+            },
+        };
+        return JSON.stringify(example, null, 2);
+    }
+}
+exports.ConfigLoader = ConfigLoader;

package/dist/src/utils/cost-tracker.d.ts

@@ -0,0 +1,33 @@
+export interface CostEntry {
+    timestamp: number;
+    provider: 'openai' | 'ollama';
+    model: string;
+    operation: 'explanation' | 'query';
+    inputTokens: number;
+    outputTokens: number;
+    estimatedCost: number;
+}
+export interface CostSummary {
+    totalCost: number;
+    totalOperations: number;
+    byProvider: {
+        [key: string]: {
+            cost: number;
+            operations: number;
+        };
+    };
+    byModel: {
+        [key: string]: {
+            cost: number;
+            operations: number;
+        };
+    };
+}
+export declare class CostTracker {
+    private logPath;
+    constructor();
+    track(entry: Omit<CostEntry, 'timestamp' | 'estimatedCost'>): void;
+    getSummary(daysBack?: number): CostSummary;
+    clear(): void;
+    private calculateCost;
+}

package/dist/src/utils/cost-tracker.js

@@ -0,0 +1,135 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CostTracker = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+class CostTracker {
+    logPath;
+    constructor() {
+        const logDir = path.join(os.homedir(), '.cloud-cost-cli', 'costs');
+        if (!fs.existsSync(logDir)) {
+            fs.mkdirSync(logDir, { recursive: true });
+        }
+        this.logPath = path.join(logDir, 'usage.jsonl');
+    }
+    track(entry) {
+        const cost = this.calculateCost(entry.provider, entry.model, entry.inputTokens, entry.outputTokens);
+        const fullEntry = {
+            ...entry,
+            timestamp: Date.now(),
+            estimatedCost: cost,
+        };
+        try {
+            fs.appendFileSync(this.logPath, JSON.stringify(fullEntry) + '\n', 'utf-8');
+        }
+        catch (error) {
+            // Failed to log, not critical
+        }
+    }
+    getSummary(daysBack = 30) {
+        const cutoff = Date.now() - (daysBack * 24 * 60 * 60 * 1000);
+        const summary = {
+            totalCost: 0,
+            totalOperations: 0,
+            byProvider: {},
+            byModel: {},
+        };
+        if (!fs.existsSync(this.logPath)) {
+            return summary;
+        }
+        try {
+            const content = fs.readFileSync(this.logPath, 'utf-8');
+            const lines = content.trim().split('\n').filter(l => l.length > 0);
+            for (const line of lines) {
+                try {
+                    const entry = JSON.parse(line);
+                    if (entry.timestamp < cutoff) {
+                        continue;
+                    }
+                    summary.totalCost += entry.estimatedCost;
+                    summary.totalOperations++;
+                    // By provider
+                    if (!summary.byProvider[entry.provider]) {
+                        summary.byProvider[entry.provider] = { cost: 0, operations: 0 };
+                    }
+                    summary.byProvider[entry.provider].cost += entry.estimatedCost;
+                    summary.byProvider[entry.provider].operations++;
+                    // By model
+                    if (!summary.byModel[entry.model]) {
+                        summary.byModel[entry.model] = { cost: 0, operations: 0 };
+                    }
+                    summary.byModel[entry.model].cost += entry.estimatedCost;
+                    summary.byModel[entry.model].operations++;
+                }
+                catch (e) {
+                    // Skip invalid lines
+                }
+            }
+        }
+        catch (error) {
+            // Failed to read log
+        }
+        return summary;
+    }
+    clear() {
+        try {
+            if (fs.existsSync(this.logPath)) {
+                fs.unlinkSync(this.logPath);
+            }
+        }
+        catch (error) {
+            // Failed to clear
+        }
+    }
+    calculateCost(provider, model, inputTokens, outputTokens) {
+        if (provider === 'ollama') {
+            return 0; // Local, free
+        }
+        // OpenAI pricing (as of 2024)
+        // https://openai.com/pricing
+        const pricing = {
+            'gpt-4o': { input: 2.50 / 1_000_000, output: 10.00 / 1_000_000 },
+            'gpt-4o-mini': { input: 0.150 / 1_000_000, output: 0.600 / 1_000_000 },
+            'gpt-4-turbo': { input: 10.00 / 1_000_000, output: 30.00 / 1_000_000 },
+            'gpt-4': { input: 30.00 / 1_000_000, output: 60.00 / 1_000_000 },
+            'gpt-3.5-turbo': { input: 0.50 / 1_000_000, output: 1.50 / 1_000_000 },
+        };
+        const modelPricing = pricing[model] || pricing['gpt-4o-mini']; // Default fallback
+        return (inputTokens * modelPricing.input) + (outputTokens * modelPricing.output);
+    }
+}
+exports.CostTracker = CostTracker;

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

package/docs/RELEASE.md

@@ -4,31 +4,20 @@ This document describes how to publish a new version of cloud-cost-cli.
 
 ## Prerequisites
 
-### 1. NPM Granular Access Token
-
-npm now uses "Granular Access Tokens" instead of automation tokens.
-
-**Create the token:**
-1. Go to https://www.npmjs.com/settings/YOUR_USERNAME/tokens
-2. Click **"Generate New Token"** → **"Granular Access Token"**
-3. Configure the token:
-   - **Token name**: `cloud-cost-cli-publish` (or any name)
-   - **Expiration**: 1 year (or No expiration)
-   - **Packages and scopes**: Select packages → Choose `cloud-cost-cli`
-   - **Permissions**: Read and write
-   - **⚠️ IMPORTANT**: Under "Additional options" → **Disable "Require two-factor authentication for this token"**
-     - This allows GitHub Actions to publish without OTP
-     - The token itself is still secure (stored in GitHub Secrets)
-4. Click **"Generate Token"**
-5. Copy the token (starts with `npm_...`)
-
-### 2. Add Token to GitHub Secrets
-
-1. Go to https://github.com/vuhp/cloud-cost-cli/settings/secrets/actions
-2. Click **"New repository secret"** (or edit existing `NPM_TOKEN`)
-3. Name: `NPM_TOKEN`
-4. Value: (paste the `npm_...` token with 2FA disabled)
-5. Click **"Add secret"** or **"Update secret"**
+### npm Trusted Publishing (OIDC)
+
+This project uses **npm trusted publishing** via GitHub Actions. No npm token is required!
+
+**Configuration:**
+- Already configured on npm for this package
+- GitHub Actions is set as a trusted publisher
+- Publishing happens automatically via OIDC (OpenID Connect)
+
+**Benefits:**
+- ✅ No tokens to rotate or secure
+- ✅ No 2FA required for automation
+- ✅ More secure (GitHub's identity proves authenticity)
+- ✅ Automatic provenance statements
 
 ## Steps to Release