pangea 0.0.42 → 0.0.45

data/lib/pangea/utilities/cli/commands/drift_command.rb

@@ -0,0 +1,127 @@
+# Copyright 2025 The Pangea Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# lib/pangea/utilities/cli/commands/drift_command.rb
+require_relative '../command'
+
+module Pangea
+  module Utilities
+    module CLI
+      module Commands
+        class DriftCommand < Command
+          desc "Detect and manage infrastructure drift"
+          
+          class_option :namespace, type: :string, aliases: '-n',
+                       desc: "Namespace to use"
+          
+          desc "detect", "Detect drift in templates"
+          option :template, type: :string,
+                 desc: "Template to check"
+          option :all, type: :boolean,
+                 desc: "Check all templates"
+          def detect
+            templates = get_template_names
+            detector = Drift::Detector.new
+            
+            reports = templates.map do |template|
+              info "Checking #{template}..."
+              detector.detect_drift(template, get_namespace)
+            end
+            
+            # Summary
+            say ""
+            info "Drift Detection Summary:"
+            info "=" * 50
+            
+            reports.each do |report|
+              if report.drift_detected?
+                warning "#{report.template_name}: #{report.total_changes} changes detected (#{report.drift_severity} severity)"
+              elsif report.no_changes?
+                success "#{report.template_name}: No drift detected"
+              else
+                error "#{report.template_name}: Error - #{report.details[:error]}"
+              end
+            end
+            
+            # Exit with error if drift detected
+            exit 1 if reports.any?(&:drift_detected?)
+          end
+          
+          desc "show", "Show detailed drift report"
+          option :template, type: :string, required: true,
+                 desc: "Template name"
+          def show
+            template = options[:template]
+            detector = Drift::Detector.new
+            
+            report = detector.detect_drift(template, get_namespace)
+            
+            if report.error?
+              error "Error detecting drift: #{report.details[:error]}"
+              exit 1
+            end
+            
+            info "Drift Report for '#{template}'"
+            info "=" * 50
+            
+            if report.no_changes?
+              success "No drift detected"
+            else
+              warning "Drift detected:"
+              
+              if report.resources_to_add.any?
+                say "\nResources to add:"
+                report.resources_to_add.each { |r| say "  + #{r}", :green }
+              end
+              
+              if report.resources_to_change.any?
+                say "\nResources to change:"
+                report.resources_to_change.each { |r| say "  ~ #{r}", :yellow }
+              end
+              
+              if report.resources_to_destroy.any?
+                say "\nResources to destroy:"
+                report.resources_to_destroy.each { |r| say "  - #{r}", :red }
+              end
+              
+              say "\nSeverity: #{report.drift_severity}"
+              say "Safe to auto-remediate: #{report.safe_to_remediate? ? 'Yes' : 'No'}"
+            end
+          end
+          
+          desc "monitor", "Start drift monitoring"
+          option :interval, type: :numeric, default: 300,
+                 desc: "Check interval in seconds"
+          option :once, type: :boolean,
+                 desc: "Run once and exit"
+          def monitor
+            monitor = Drift::Monitor.new(
+              interval: options[:interval],
+              templates: options[:all] ? :all : [options[:template]].compact
+            )
+            
+            info "Starting drift monitor (interval: #{options[:interval]}s)"
+            
+            if options[:once]
+              monitor.check_all_templates
+            else
+              info "Press Ctrl+C to stop"
+              monitor.start.join
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pangea/utilities/cli/commands/state_command.rb

@@ -0,0 +1,119 @@
+# Copyright 2025 The Pangea Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# lib/pangea/utilities/cli/commands/state_command.rb
+require_relative '../command'
+
+module Pangea
+  module Utilities
+    module CLI
+      module Commands
+        class StateCommand < Command
+          desc "Manage cross-template state references"
+          
+          class_option :namespace, type: :string, aliases: '-n',
+                       desc: "Namespace to use"
+          class_option :config, type: :string, aliases: '-c',
+                       desc: "Configuration file", default: 'pangea.yaml'
+          
+          def self.banner
+            "pangea state SUBCOMMAND [OPTIONS]"
+          end
+          
+          desc "show", "Show template outputs"
+          option :template, type: :string, required: true,
+                 desc: "Template name"
+          def show
+            template = options[:template]
+            namespace = get_namespace
+            
+            registry = RemoteState::OutputRegistry.new
+            outputs = registry.available_outputs(template)
+            
+            if outputs.empty?
+              warning "No outputs registered for template '#{template}'"
+              return
+            end
+            
+            info "Outputs for template '#{template}':"
+            outputs['outputs'].each do |name, value|
+              say "  #{name}: #{value}"
+            end
+          end
+          
+          desc "export", "Export template outputs"
+          option :template, type: :string, required: true,
+                 desc: "Template name"
+          option :output, type: :string,
+                 desc: "Specific output to export"
+          def export
+            template = options[:template]
+            namespace = get_namespace
+            
+            # TODO: Read actual state and export outputs
+            info "Exporting outputs from #{template}..."
+            
+            outputs = {
+              vpc_id: "vpc-12345",
+              subnet_ids: ["subnet-123", "subnet-456"]
+            }
+            
+            registry = RemoteState::OutputRegistry.new
+            registry.register_outputs(template, outputs)
+            
+            success "Outputs exported successfully"
+          end
+          
+          desc "list", "List templates with available outputs"
+          def list
+            registry = RemoteState::OutputRegistry.new
+            templates = registry.list_templates
+            
+            if templates.empty?
+              info "No templates with registered outputs"
+              return
+            end
+            
+            info "Templates with available outputs:"
+            templates.each do |template|
+              outputs = registry.available_outputs(template)
+              say "  #{template} (#{outputs['outputs'].keys.count} outputs)"
+            end
+          end
+          
+          desc "deps", "Show template dependencies"
+          option :template, type: :string,
+                 desc: "Show dependencies for specific template"
+          def deps
+            manager = RemoteState::DependencyManager.new
+            
+            # TODO: Load dependencies from templates
+            
+            if options[:template]
+              deps = manager.get_dependencies(options[:template])
+              dependents = manager.get_dependents(options[:template])
+              
+              info "Dependencies for '#{options[:template]}':"
+              info "  Depends on: #{deps.join(', ')}" if deps.any?
+              info "  Required by: #{dependents.join(', ')}" if dependents.any?
+            else
+              info "Template dependency order:"
+              # Show all dependencies
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pangea/utilities/cost/README.md

@@ -0,0 +1,12 @@
+# Pangea Utilities - Cost
+
+## Overview
+Real-time cost tracking, forecasting, and optimization recommendations at template and architecture levels.
+
+## Components
+- Calculator: Calculate infrastructure costs
+- Optimizer: Identify cost optimization opportunities
+- ResourcePricing: AWS resource pricing data
+
+## Usage
+Basic usage examples will be added as components are implemented.

data/lib/pangea/utilities/cost/calculator.rb

@@ -0,0 +1,174 @@
+# Copyright 2025 The Pangea Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# lib/pangea/utilities/cost/calculator.rb
+require 'json'
+
+module Pangea
+  module Utilities
+    module Cost
+      class Calculator
+        def calculate_template_cost(template_name, namespace = nil)
+          workspace_path = get_workspace_path(template_name, namespace)
+          
+          unless File.exist?(File.join(workspace_path, 'terraform.tfstate'))
+            return CostReport.new(template_name, { error: "State file not found" })
+          end
+          
+          # Parse state file
+          state = JSON.parse(File.read(File.join(workspace_path, 'terraform.tfstate')))
+          resources = extract_resources_from_state(state)
+          
+          # Calculate costs
+          resource_costs = resources.map do |resource|
+            calculate_resource_cost(resource)
+          end
+          
+          CostReport.new(template_name, {
+            resources: resource_costs,
+            total_hourly: resource_costs.sum { |r| r[:hourly] },
+            total_monthly: resource_costs.sum { |r| r[:monthly] },
+            calculated_at: Time.now
+          })
+        end
+        
+        def calculate_all_templates(namespace = nil)
+          templates = discover_templates(namespace)
+          
+          reports = templates.map do |template|
+            calculate_template_cost(template, namespace)
+          end
+          
+          {
+            namespace: namespace || 'default',
+            templates: reports,
+            total_hourly: reports.sum { |r| r.total_hourly },
+            total_monthly: reports.sum { |r| r.total_monthly }
+          }
+        end
+        
+        private
+        
+        def get_workspace_path(template_name, namespace)
+          namespace ||= 'default'
+          File.expand_path("~/.pangea/workspaces/#{namespace}/#{template_name}")
+        end
+        
+        def extract_resources_from_state(state)
+          resources = []
+          
+          return resources unless state['resources']
+          
+          state['resources'].each do |resource|
+            next unless resource['mode'] == 'managed'
+            
+            resource['instances'].each do |instance|
+              resources << {
+                type: resource['type'],
+                name: resource['name'],
+                attributes: instance['attributes']
+              }
+            end
+          end
+          
+          resources
+        end
+        
+        def calculate_resource_cost(resource)
+          pricing = ResourcePricing.get_price(resource[:type], resource[:attributes])
+          
+          {
+            type: resource[:type],
+            name: resource[:name],
+            hourly: pricing[:hourly],
+            monthly: pricing[:monthly],
+            attributes: extract_cost_relevant_attributes(resource)
+          }
+        end
+        
+        def extract_cost_relevant_attributes(resource)
+          case resource[:type]
+          when 'aws_instance'
+            {
+              instance_type: resource[:attributes]['instance_type'],
+              state: resource[:attributes]['instance_state']
+            }
+          when 'aws_db_instance'
+            {
+              instance_class: resource[:attributes]['instance_class'],
+              engine: resource[:attributes]['engine'],
+              allocated_storage: resource[:attributes]['allocated_storage']
+            }
+          else
+            {}
+          end
+        end
+        
+        def discover_templates(namespace)
+          namespace ||= 'default'
+          workspace_dir = File.expand_path("~/.pangea/workspaces/#{namespace}")
+          
+          return [] unless Dir.exist?(workspace_dir)
+          
+          Dir.entries(workspace_dir).select do |entry|
+            File.directory?(File.join(workspace_dir, entry)) && entry !~ /^\./
+          end
+        end
+      end
+      
+      class CostReport
+        attr_reader :template_name, :data
+        
+        def initialize(template_name, data)
+          @template_name = template_name
+          @data = data
+        end
+        
+        def error?
+          @data.key?(:error)
+        end
+        
+        def total_hourly
+          @data[:total_hourly] || 0
+        end
+        
+        def total_monthly
+          @data[:total_monthly] || 0
+        end
+        
+        def resources
+          @data[:resources] || []
+        end
+        
+        def to_h
+          {
+            template_name: @template_name,
+            total_hourly: total_hourly,
+            total_monthly: total_monthly,
+            resource_count: resources.length,
+            resources: resources
+          }
+        end
+        
+        def to_s
+          if error?
+            "Error calculating cost for #{@template_name}: #{@data[:error]}"
+          else
+            "#{@template_name}: $#{'%.2f' % total_hourly}/hour, $#{'%.2f' % total_monthly}/month (#{resources.length} resources)"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pangea/utilities/cost/resource_pricing.rb

@@ -0,0 +1,102 @@
+# Copyright 2025 The Pangea Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# lib/pangea/utilities/cost/resource_pricing.rb
+module Pangea
+  module Utilities
+    module Cost
+      class ResourcePricing
+        # Simplified pricing data - in production, this would come from AWS Pricing API
+        PRICING_DATA = {
+          'aws_instance' => {
+            't3.micro' => { hourly: 0.0104, monthly: 7.59 },
+            't3.small' => { hourly: 0.0208, monthly: 15.18 },
+            't3.medium' => { hourly: 0.0416, monthly: 30.37 },
+            't3.large' => { hourly: 0.0832, monthly: 60.74 },
+            'm5.large' => { hourly: 0.096, monthly: 70.08 },
+            'm5.xlarge' => { hourly: 0.192, monthly: 140.16 },
+            'm5.2xlarge' => { hourly: 0.384, monthly: 280.32 }
+          },
+          'aws_db_instance' => {
+            'db.t3.micro' => { hourly: 0.017, monthly: 12.41 },
+            'db.t3.small' => { hourly: 0.034, monthly: 24.82 },
+            'db.t3.medium' => { hourly: 0.068, monthly: 49.64 },
+            'db.m5.large' => { hourly: 0.171, monthly: 124.83 },
+            'db.m5.xlarge' => { hourly: 0.342, monthly: 249.66 }
+          },
+          'aws_lb' => {
+            'application' => { hourly: 0.0225, monthly: 16.43 },
+            'network' => { hourly: 0.0225, monthly: 16.43 }
+          },
+          'aws_nat_gateway' => {
+            'default' => { hourly: 0.045, monthly: 32.85 }
+          },
+          'aws_elasticache_cluster' => {
+            'cache.t3.micro' => { hourly: 0.017, monthly: 12.41 },
+            'cache.t3.small' => { hourly: 0.034, monthly: 24.82 },
+            'cache.t3.medium' => { hourly: 0.068, monthly: 49.64 }
+          }
+        }.freeze
+        
+        def self.get_price(resource_type, resource_spec)
+          return { hourly: 0, monthly: 0 } unless PRICING_DATA[resource_type]
+          
+          case resource_type
+          when 'aws_instance'
+            instance_type = resource_spec[:instance_type] || resource_spec['instance_type']
+            PRICING_DATA[resource_type][instance_type] || { hourly: 0, monthly: 0 }
+          when 'aws_db_instance'
+            instance_class = resource_spec[:instance_class] || resource_spec['instance_class']
+            PRICING_DATA[resource_type][instance_class] || { hourly: 0, monthly: 0 }
+          when 'aws_lb'
+            lb_type = resource_spec[:load_balancer_type] || resource_spec['load_balancer_type'] || 'application'
+            PRICING_DATA[resource_type][lb_type] || { hourly: 0, monthly: 0 }
+          when 'aws_elasticache_cluster'
+            node_type = resource_spec[:node_type] || resource_spec['node_type']
+            PRICING_DATA[resource_type][node_type] || { hourly: 0, monthly: 0 }
+          else
+            PRICING_DATA[resource_type]&.fetch('default', { hourly: 0, monthly: 0 }) || { hourly: 0, monthly: 0 }
+          end
+        end
+        
+        def self.estimate_data_transfer_cost(gb_per_month)
+          # Simplified data transfer pricing
+          if gb_per_month <= 1
+            0
+          elsif gb_per_month <= 10_000
+            (gb_per_month - 1) * 0.09
+          else
+            (9_999 * 0.09) + ((gb_per_month - 10_000) * 0.085)
+          end
+        end
+        
+        def self.estimate_storage_cost(storage_type, gb)
+          storage_pricing = {
+            'gp3' => 0.08,      # per GB-month
+            'gp2' => 0.10,      # per GB-month
+            'io1' => 0.125,     # per GB-month
+            'st1' => 0.045,     # per GB-month
+            'sc1' => 0.025,     # per GB-month
+            's3_standard' => 0.023,  # per GB-month
+            's3_ia' => 0.0125,       # per GB-month
+            's3_glacier' => 0.004    # per GB-month
+          }
+          
+          price_per_gb = storage_pricing[storage_type] || 0.10
+          gb * price_per_gb
+        end
+      end
+    end
+  end
+end

data/lib/pangea/utilities/cost.rb

@@ -0,0 +1,29 @@
+# Copyright 2025 The Pangea Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# lib/pangea/utilities/cost.rb
+module Pangea
+  module Utilities
+    module Cost
+      autoload :Calculator, 'pangea/utilities/cost/calculator'
+      autoload :Optimizer, 'pangea/utilities/cost/optimizer'
+      autoload :Report, 'pangea/utilities/cost/report'
+      autoload :ResourcePricing, 'pangea/utilities/cost/resource_pricing'
+      
+      def self.calculate(template_name, namespace = nil)
+        Calculator.new.calculate_template_cost(template_name, namespace)
+      end
+    end
+  end
+end

data/lib/pangea/utilities/drift/README.md

@@ -0,0 +1,12 @@
+# Pangea Utilities - Drift
+
+## Overview
+Continuously monitor infrastructure for configuration drift and provide automated or guided remediation.
+
+## Components
+- Detector: Detect configuration drift in templates
+- Monitor: Continuous drift monitoring service
+- Remediator: Automated drift remediation
+
+## Usage
+Basic usage examples will be added as components are implemented.