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

package/dist/src/services/ai.js

@@ -0,0 +1,345 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AIService = void 0;
+const openai_1 = __importDefault(require("openai"));
+const ollama_1 = require("ollama");
+const script_generator_1 = require("./script-generator");
+const cache_1 = require("../utils/cache");
+const config_1 = require("../utils/config");
+const cost_tracker_1 = require("../utils/cost-tracker");
+class AIService {
+    openaiClient = null;
+    ollamaClient = null;
+    provider;
+    model = 'gpt-4o-mini';
+    enabled = false;
+    maxExplanations = 3;
+    cache;
+    useCache = true;
+    costTracker;
+    constructor(config) {
+        this.cache = new cache_1.ExplanationCache();
+        this.costTracker = new cost_tracker_1.CostTracker();
+        // Load from config file if no explicit config provided
+        if (!config) {
+            const fileConfig = config_1.ConfigLoader.load();
+            // Determine provider (precedence: explicit config > env detection)
+            let provider = 'openai';
+            if (fileConfig.ai?.provider) {
+                // User explicitly set provider in config - ALWAYS respect it
+                provider = fileConfig.ai.provider;
+            }
+            else if (fileConfig.ai?.apiKey || process.env.OPENAI_API_KEY) {
+                provider = 'openai';
+            }
+            else {
+                provider = 'ollama';
+            }
+            config = {
+                provider,
+                apiKey: fileConfig.ai?.apiKey || process.env.OPENAI_API_KEY,
+                model: fileConfig.ai?.model,
+                maxExplanations: fileConfig.ai?.maxExplanations,
+            };
+        }
+        this.provider = config.provider;
+        this.maxExplanations = config.maxExplanations || 3;
+        // Debug logging (remove later)
+        if (process.env.DEBUG) {
+            console.error('AIService config:', JSON.stringify({
+                provider: config.provider,
+                hasApiKey: !!config.apiKey,
+                model: config.model,
+            }));
+        }
+        if (config.provider === 'openai') {
+            if (!config.apiKey) {
+                throw new Error('OpenAI API key required');
+            }
+            this.openaiClient = new openai_1.default({ apiKey: config.apiKey });
+            this.model = config.model || 'gpt-4o-mini';
+            this.enabled = true;
+        }
+        else if (config.provider === 'ollama') {
+            this.ollamaClient = new ollama_1.Ollama({ host: 'http://localhost:11434' });
+            this.model = config.model || 'llama3.2:3b';
+            this.enabled = true;
+        }
+    }
+    isEnabled() {
+        return this.enabled;
+    }
+    getMaxExplanations() {
+        return this.maxExplanations;
+    }
+    async explainOpportunity(opportunity) {
+        // Check cache first
+        if (this.useCache) {
+            const cached = this.cache.get(opportunity, this.provider, this.model);
+            if (cached) {
+                return { ...cached, cached: true };
+            }
+        }
+        const prompt = this.buildPrompt(opportunity);
+        try {
+            let content;
+            if (this.provider === 'openai' && this.openaiClient) {
+                const response = await this.openaiClient.chat.completions.create({
+                    model: this.model,
+                    messages: [
+                        {
+                            role: 'system',
+                            content: 'You are a cloud cost optimization expert. Provide clear, actionable advice for reducing cloud costs. Be concise, practical, and encouraging. Focus on real-world steps users can take immediately. Always respond with valid JSON.',
+                        },
+                        {
+                            role: 'user',
+                            content: prompt,
+                        },
+                    ],
+                    temperature: 0.7,
+                    max_tokens: 500,
+                });
+                content = response.choices[0]?.message?.content || '';
+                // Track cost
+                if (response.usage) {
+                    this.costTracker.track({
+                        provider: 'openai',
+                        model: this.model,
+                        operation: 'explanation',
+                        inputTokens: response.usage.prompt_tokens,
+                        outputTokens: response.usage.completion_tokens,
+                    });
+                }
+            }
+            else if (this.provider === 'ollama' && this.ollamaClient) {
+                const response = await this.ollamaClient.chat({
+                    model: this.model,
+                    messages: [
+                        {
+                            role: 'system',
+                            content: 'You are a cloud cost optimization expert. Provide clear, actionable advice for reducing cloud costs. Be concise, practical, and encouraging. Focus on real-world steps users can take immediately. Always respond with valid JSON.',
+                        },
+                        {
+                            role: 'user',
+                            content: prompt,
+                        },
+                    ],
+                    options: {
+                        temperature: 0.7,
+                        num_predict: 500,
+                    },
+                });
+                content = response.message.content;
+            }
+            else {
+                throw new Error('No AI provider configured');
+            }
+            const explanation = this.parseExplanation(content, opportunity);
+            // Cache the result
+            if (this.useCache) {
+                this.cache.set(opportunity, this.provider, this.model, explanation);
+            }
+            return { ...explanation, cached: false };
+        }
+        catch (error) {
+            throw new Error(`AI explanation failed: ${error.message}`);
+        }
+    }
+    async generateRemediationScript(opportunity) {
+        const generator = new script_generator_1.ScriptGenerator();
+        const script = generator.generateRemediation(opportunity);
+        if (!script) {
+            return null;
+        }
+        return generator.renderScript(script);
+    }
+    buildPrompt(opportunity) {
+        return `
+Analyze this cloud cost optimization opportunity and provide actionable guidance:
+
+**Resource Details:**
+- Type: ${opportunity.resourceType}
+- ID: ${opportunity.resourceId}
+- Name: ${opportunity.resourceName || 'N/A'}
+- Category: ${opportunity.category}
+- Current Cost: $${opportunity.currentCost}/month
+- Potential Savings: $${opportunity.estimatedSavings}/month
+- Recommendation: ${opportunity.recommendation}
+- Metadata: ${JSON.stringify(opportunity.metadata, null, 2)}
+
+**Please provide:**
+
+1. **Summary** (1 sentence): Quick explanation of what's wasteful
+2. **Why Wasteful** (2-3 sentences): Explain the problem in simple terms
+3. **Action Plan** (numbered steps): Specific actions to take, prioritized
+4. **Risk Level** (low/medium/high): How risky is this change?
+5. **Estimated Time**: How long will this take to implement?
+
+Format your response as JSON:
+{
+  "summary": "...",
+  "whyWasteful": "...",
+  "actionPlan": ["1. ...", "2. ...", "3. ..."],
+  "riskLevel": "low|medium|high",
+  "estimatedTime": "X minutes/hours"
+}
+`;
+    }
+    parseExplanation(content, opportunity) {
+        try {
+            // Try to extract JSON from the response
+            const jsonMatch = content.match(/\{[\s\S]*\}/);
+            if (jsonMatch) {
+                const parsed = JSON.parse(jsonMatch[0]);
+                return {
+                    summary: parsed.summary || 'AI explanation unavailable',
+                    whyWasteful: parsed.whyWasteful || '',
+                    actionPlan: Array.isArray(parsed.actionPlan) ? parsed.actionPlan : [],
+                    riskLevel: parsed.riskLevel || 'medium',
+                    estimatedTime: parsed.estimatedTime || 'Unknown',
+                };
+            }
+            // Fallback: return the raw content as summary
+            return {
+                summary: content.substring(0, 200),
+                whyWasteful: content,
+                actionPlan: [],
+                riskLevel: 'medium',
+                estimatedTime: 'Unknown',
+            };
+        }
+        catch (error) {
+            // Parsing failed, return raw content
+            return {
+                summary: 'AI explanation available in raw format',
+                whyWasteful: content,
+                actionPlan: [],
+                riskLevel: 'medium',
+                estimatedTime: 'Unknown',
+            };
+        }
+    }
+    async answerQuery(query, scanReport) {
+        const context = this.buildQueryContext(scanReport);
+        const prompt = this.buildQueryPrompt(query, context);
+        try {
+            let content;
+            if (this.provider === 'openai' && this.openaiClient) {
+                const response = await this.openaiClient.chat.completions.create({
+                    model: this.model,
+                    messages: [
+                        {
+                            role: 'system',
+                            content: 'You are a cloud cost optimization expert. Answer user questions about their cloud costs clearly and concisely. Provide actionable insights and suggest specific cost-saving opportunities when relevant. Always respond with valid JSON.',
+                        },
+                        {
+                            role: 'user',
+                            content: prompt,
+                        },
+                    ],
+                    temperature: 0.7,
+                    max_tokens: 800,
+                });
+                content = response.choices[0]?.message?.content || '';
+                // Track cost
+                if (response.usage) {
+                    this.costTracker.track({
+                        provider: 'openai',
+                        model: this.model,
+                        operation: 'query',
+                        inputTokens: response.usage.prompt_tokens,
+                        outputTokens: response.usage.completion_tokens,
+                    });
+                }
+            }
+            else if (this.provider === 'ollama' && this.ollamaClient) {
+                const response = await this.ollamaClient.chat({
+                    model: this.model,
+                    messages: [
+                        {
+                            role: 'system',
+                            content: 'You are a cloud cost optimization expert. Answer user questions about their cloud costs clearly and concisely. Provide actionable insights and suggest specific cost-saving opportunities when relevant. Always respond with valid JSON.',
+                        },
+                        {
+                            role: 'user',
+                            content: prompt,
+                        },
+                    ],
+                    options: {
+                        temperature: 0.7,
+                        num_predict: 800,
+                    },
+                });
+                content = response.message.content;
+            }
+            else {
+                throw new Error('No AI provider configured');
+            }
+            return this.parseQueryAnswer(content, scanReport);
+        }
+        catch (error) {
+            throw new Error(`Query failed: ${error.message}`);
+        }
+    }
+    buildQueryContext(scanReport) {
+        const { summary, opportunities, totalPotentialSavings } = scanReport;
+        let context = `Cost Optimization Report:\n`;
+        context += `Total potential savings: $${totalPotentialSavings?.toFixed(2) || '0.00'}/month\n`;
+        context += `Total opportunities: ${opportunities?.length || 0}\n`;
+        context += `Idle resources: ${summary?.idleResources || 0}\n`;
+        context += `Unused resources: ${summary?.unusedResources || 0}\n`;
+        context += `Oversized resources: ${summary?.oversizedResources || 0}\n\n`;
+        if (opportunities && opportunities.length > 0) {
+            context += `Top opportunities:\n`;
+            opportunities.slice(0, 10).forEach((opp, i) => {
+                context += `${i + 1}. ${opp.resourceType} (${opp.resourceId}): ${opp.recommendation} - Save $${opp.estimatedSavings?.toFixed(2) || '0.00'}/mo\n`;
+            });
+        }
+        else {
+            context += `No opportunities found.\n`;
+        }
+        return context;
+    }
+    buildQueryPrompt(query, context) {
+        return `User question: "${query}"
+
+Context from recent cost scan:
+${context}
+
+Please answer the user's question based on this cost data. Respond in JSON format:
+{
+  "response": "Your clear, helpful answer here",
+  "suggestions": ["Optional suggestion 1", "Optional suggestion 2"],
+  "relatedOpportunityIndexes": [0, 1, 2]  // Indexes from the context (0-based)
+}`;
+    }
+    parseQueryAnswer(content, scanReport) {
+        try {
+            // Try to extract JSON from markdown code blocks
+            const jsonMatch = content.match(/```(?:json)?\s*(\{[\s\S]*?\})\s*```/);
+            const jsonStr = jsonMatch ? jsonMatch[1] : content;
+            const parsed = JSON.parse(jsonStr.trim());
+            const answer = {
+                response: parsed.response || content,
+                suggestions: Array.isArray(parsed.suggestions) ? parsed.suggestions : undefined,
+            };
+            // Map opportunity indexes to actual opportunities
+            if (Array.isArray(parsed.relatedOpportunityIndexes)) {
+                answer.relatedOpportunities = parsed.relatedOpportunityIndexes
+                    .map((idx) => scanReport.opportunities[idx])
+                    .filter((opp) => opp !== undefined);
+            }
+            return answer;
+        }
+        catch (error) {
+            // Fallback: return raw content
+            return {
+                response: content,
+            };
+        }
+    }
+}
+exports.AIService = AIService;

package/dist/src/services/script-generator.d.ts

@@ -0,0 +1,21 @@
+import { SavingsOpportunity } from '../types';
+export interface RemediationScript {
+    description: string;
+    steps: ScriptStep[];
+    estimatedTime: string;
+    riskLevel: 'low' | 'medium' | 'high';
+    reversible: boolean;
+}
+export interface ScriptStep {
+    description: string;
+    command: string;
+    optional: boolean;
+    confirmationRequired: boolean;
+}
+export declare class ScriptGenerator {
+    generateRemediation(opportunity: SavingsOpportunity): RemediationScript | null;
+    private generateAWSScript;
+    private generateAzureScript;
+    private extractResourceGroup;
+    renderScript(script: RemediationScript): string;
+}

package/dist/src/services/script-generator.js

@@ -0,0 +1,245 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScriptGenerator = void 0;
+class ScriptGenerator {
+    generateRemediation(opportunity) {
+        const { provider, resourceType, category } = opportunity;
+        if (provider === 'aws') {
+            return this.generateAWSScript(opportunity);
+        }
+        else if (provider === 'azure') {
+            return this.generateAzureScript(opportunity);
+        }
+        return null;
+    }
+    generateAWSScript(opportunity) {
+        const { resourceType, resourceId, category, metadata } = opportunity;
+        switch (resourceType) {
+            case 'ec2':
+                if (category === 'idle') {
+                    return {
+                        description: 'Stop idle EC2 instance',
+                        steps: [
+                            {
+                                description: 'Create AMI backup (recommended)',
+                                command: `aws ec2 create-image --instance-id ${resourceId} --name "backup-${resourceId}-$(date +%Y%m%d)" --description "Pre-stop backup"`,
+                                optional: true,
+                                confirmationRequired: false,
+                            },
+                            {
+                                description: 'Stop the instance',
+                                command: `aws ec2 stop-instances --instance-ids ${resourceId}`,
+                                optional: false,
+                                confirmationRequired: true,
+                            },
+                            {
+                                description: 'Wait for instance to stop',
+                                command: `aws ec2 wait instance-stopped --instance-ids ${resourceId}`,
+                                optional: false,
+                                confirmationRequired: false,
+                            },
+                            {
+                                description: 'Verify instance state',
+                                command: `aws ec2 describe-instances --instance-ids ${resourceId} --query 'Reservations[0].Instances[0].State.Name'`,
+                                optional: false,
+                                confirmationRequired: false,
+                            },
+                        ],
+                        estimatedTime: '5-10 minutes',
+                        riskLevel: 'low',
+                        reversible: true,
+                    };
+                }
+                break;
+            case 'ebs':
+                if (category === 'unused') {
+                    return {
+                        description: 'Delete unattached EBS volume',
+                        steps: [
+                            {
+                                description: 'Create snapshot backup',
+                                command: `aws ec2 create-snapshot --volume-id ${resourceId} --description "Pre-delete backup of ${resourceId}"`,
+                                optional: true,
+                                confirmationRequired: false,
+                            },
+                            {
+                                description: 'Wait for snapshot to complete',
+                                command: `aws ec2 wait snapshot-completed --snapshot-ids <snapshot-id-from-previous-step>`,
+                                optional: true,
+                                confirmationRequired: false,
+                            },
+                            {
+                                description: 'Delete the volume',
+                                command: `aws ec2 delete-volume --volume-id ${resourceId}`,
+                                optional: false,
+                                confirmationRequired: true,
+                            },
+                        ],
+                        estimatedTime: '10-15 minutes',
+                        riskLevel: 'low',
+                        reversible: true,
+                    };
+                }
+                break;
+            case 'eip':
+                if (category === 'unused') {
+                    return {
+                        description: 'Release unassociated Elastic IP',
+                        steps: [
+                            {
+                                description: 'Verify IP is not associated',
+                                command: `aws ec2 describe-addresses --allocation-ids ${resourceId} --query 'Addresses[0].AssociationId'`,
+                                optional: false,
+                                confirmationRequired: false,
+                            },
+                            {
+                                description: 'Release the Elastic IP',
+                                command: `aws ec2 release-address --allocation-id ${resourceId}`,
+                                optional: false,
+                                confirmationRequired: true,
+                            },
+                        ],
+                        estimatedTime: '1 minute',
+                        riskLevel: 'low',
+                        reversible: false,
+                    };
+                }
+                break;
+            case 'elb':
+                if (category === 'unused') {
+                    const elbName = metadata.loadBalancerName || resourceId;
+                    return {
+                        description: 'Delete unused load balancer',
+                        steps: [
+                            {
+                                description: 'Check for active targets',
+                                command: `aws elbv2 describe-target-health --target-group-arn <target-group-arn>`,
+                                optional: true,
+                                confirmationRequired: false,
+                            },
+                            {
+                                description: 'Delete the load balancer',
+                                command: `aws elbv2 delete-load-balancer --load-balancer-arn ${resourceId}`,
+                                optional: false,
+                                confirmationRequired: true,
+                            },
+                        ],
+                        estimatedTime: '2-3 minutes',
+                        riskLevel: 'medium',
+                        reversible: false,
+                    };
+                }
+                break;
+        }
+        return null;
+    }
+    generateAzureScript(opportunity) {
+        const { resourceType, resourceId, category, metadata } = opportunity;
+        const resourceGroup = this.extractResourceGroup(resourceId);
+        if (!resourceGroup) {
+            return null;
+        }
+        switch (resourceType) {
+            case 'vm':
+                if (category === 'idle') {
+                    const vmName = metadata.vmName || resourceId;
+                    return {
+                        description: 'Stop idle Azure VM',
+                        steps: [
+                            {
+                                description: 'Deallocate (stop) the VM',
+                                command: `az vm deallocate --resource-group ${resourceGroup} --name ${vmName}`,
+                                optional: false,
+                                confirmationRequired: true,
+                            },
+                            {
+                                description: 'Verify VM state',
+                                command: `az vm show --resource-group ${resourceGroup} --name ${vmName} --query 'powerState'`,
+                                optional: false,
+                                confirmationRequired: false,
+                            },
+                        ],
+                        estimatedTime: '3-5 minutes',
+                        riskLevel: 'low',
+                        reversible: true,
+                    };
+                }
+                break;
+            case 'disk':
+                if (category === 'unused') {
+                    const diskName = metadata.diskName || 'unknown';
+                    return {
+                        description: 'Delete unattached managed disk',
+                        steps: [
+                            {
+                                description: 'Create snapshot backup',
+                                command: `az snapshot create --resource-group ${resourceGroup} --name ${diskName}-backup-$(date +%Y%m%d) --source ${resourceId}`,
+                                optional: true,
+                                confirmationRequired: false,
+                            },
+                            {
+                                description: 'Delete the disk',
+                                command: `az disk delete --resource-group ${resourceGroup} --name ${diskName} --yes`,
+                                optional: false,
+                                confirmationRequired: true,
+                            },
+                        ],
+                        estimatedTime: '5 minutes',
+                        riskLevel: 'low',
+                        reversible: true,
+                    };
+                }
+                break;
+            case 'ip':
+                if (category === 'unused') {
+                    const ipName = metadata.publicIpName || 'unknown';
+                    return {
+                        description: 'Delete unassociated public IP',
+                        steps: [
+                            {
+                                description: 'Verify IP is not associated',
+                                command: `az network public-ip show --resource-group ${resourceGroup} --name ${ipName} --query 'ipConfiguration'`,
+                                optional: false,
+                                confirmationRequired: false,
+                            },
+                            {
+                                description: 'Delete the public IP',
+                                command: `az network public-ip delete --resource-group ${resourceGroup} --name ${ipName}`,
+                                optional: false,
+                                confirmationRequired: true,
+                            },
+                        ],
+                        estimatedTime: '1 minute',
+                        riskLevel: 'low',
+                        reversible: false,
+                    };
+                }
+                break;
+        }
+        return null;
+    }
+    extractResourceGroup(resourceId) {
+        const match = resourceId.match(/resourceGroups\/([^\/]+)/i);
+        return match ? match[1] : null;
+    }
+    renderScript(script) {
+        let output = '';
+        output += `# ${script.description}\n`;
+        output += `# Estimated time: ${script.estimatedTime}\n`;
+        output += `# Risk level: ${script.riskLevel.toUpperCase()}\n`;
+        output += `# Reversible: ${script.reversible ? 'Yes' : 'No'}\n\n`;
+        script.steps.forEach((step, index) => {
+            output += `# Step ${index + 1}: ${step.description}\n`;
+            if (step.optional) {
+                output += `# (Optional)\n`;
+            }
+            if (step.confirmationRequired) {
+                output += `# ⚠️  CONFIRMATION REQUIRED - Review before running\n`;
+            }
+            output += `${step.command}\n\n`;
+        });
+        output += `# Done! Verify the changes took effect.\n`;
+        return output;
+    }
+}
+exports.ScriptGenerator = ScriptGenerator;

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

@@ -0,0 +1,25 @@
+import { AIExplanation } from '../services/ai';
+export interface CachedExplanation {
+    opportunityHash: string;
+    explanation: AIExplanation;
+    timestamp: number;
+    provider: string;
+    model: string;
+}
+export declare class ExplanationCache {
+    private cacheDir;
+    private cacheDuration;
+    constructor(cacheDuration?: number);
+    private ensureCacheDir;
+    private hashOpportunity;
+    private getCachePath;
+    get(opportunityData: any, provider: string, model: string): AIExplanation | null;
+    set(opportunityData: any, provider: string, model: string, explanation: AIExplanation): void;
+    clear(): number;
+    clearExpired(): number;
+    getStats(): {
+        total: number;
+        size: number;
+        oldest: number | null;
+    };
+}