runbooks 0.9.6__py3-none-any.whl → 0.9.8__py3-none-any.whl

runbooks/main.py

@@ -5348,9 +5348,9 @@ def emergency_response(ctx, spike_threshold, target_savings, analysis_days, max_
         
         # Export reports if requested
         if export_reports:
-            exported = result.export_reports('/tmp/emergency-cost-reports')
+            exported = result.export_reports('./tmp/emergency-cost-reports')
             if exported.get('json'):
-                print_success(f"📊 Executive reports exported to: /tmp/emergency-cost-reports")
+                print_success(f"📊 Executive reports exported to: ./tmp/emergency-cost-reports")
         
         # Exit with success/failure status
         if result.success:
@@ -5549,7 +5549,7 @@ def cost_optimization():
 @click.option("--analyze", is_flag=True, help="Perform detailed cost analysis")
 @click.option("--calculate-savings", is_flag=True, help="Calculate cost savings for cleanup")
 @click.option("--unused-days", default=180, help="Days threshold for considering WorkSpace unused (JIRA FinOps-24)")
-@click.option("--output-file", default="/tmp/workspaces_cost_analysis.csv", help="Output CSV file path")
+@click.option("--output-file", default="./tmp/workspaces_cost_analysis.csv", help="Output CSV file path")
 def workspaces(profile, region, dry_run, analyze, calculate_savings, unused_days, output_file):
     """
     FinOps-24: WorkSpaces cleanup analysis for $12,518 annual savings.
@@ -5598,7 +5598,7 @@ def workspaces(profile, region, dry_run, analyze, calculate_savings, unused_days
 @click.option("--older-than", default=90, help="Focus on snapshots older than X days (JIRA FinOps-23)")
 @click.option("--calculate-savings", is_flag=True, help="Calculate detailed cost savings analysis")
 @click.option("--analyze", is_flag=True, help="Perform comprehensive cost analysis")
-@click.option("--output-file", default="/tmp/rds_snapshots_cost_analysis.csv", help="Output CSV file path")
+@click.option("--output-file", default="./tmp/rds_snapshots_cost_analysis.csv", help="Output CSV file path")
 def rds_snapshots(profile, region, dry_run, manual_only, older_than, calculate_savings, analyze, output_file):
     """
     FinOps-23: RDS manual snapshots analysis for $5K-24K annual savings.
@@ -5645,7 +5645,7 @@ def rds_snapshots(profile, region, dry_run, manual_only, older_than, calculate_s
 @common_aws_options
 @click.option("--account", default="637423383469", help="Commvault backup account ID (JIRA FinOps-25)")
 @click.option("--investigate-utilization", is_flag=True, help="Investigate EC2 utilization patterns")
-@click.option("--output-file", default="/tmp/commvault_ec2_analysis.csv", help="Output CSV file path")
+@click.option("--output-file", default="./tmp/commvault_ec2_analysis.csv", help="Output CSV file path")
 def commvault_ec2(profile, region, dry_run, account, investigate_utilization, output_file):
     """
     FinOps-25: Commvault EC2 investigation for cost optimization.
@@ -5688,7 +5688,7 @@ def commvault_ec2(profile, region, dry_run, account, investigate_utilization, ou
 @cost_optimization.command()
 @common_aws_options
 @click.option("--all-scenarios", is_flag=True, help="Run all JIRA cost optimization scenarios")
-@click.option("--output-dir", default="/tmp/cost_optimization_reports", help="Directory for all reports")
+@click.option("--output-dir", default="./tmp/cost_optimization_reports", help="Directory for all reports")
 def comprehensive_analysis(profile, region, dry_run, all_scenarios, output_dir):
     """
     Comprehensive analysis of all JIRA cost optimization scenarios.
@@ -5850,8 +5850,8 @@ def _parse_profiles_parameter(profiles_tuple):
 )
 @click.option(
     "--scenario", 
-    type=click.Choice(["workspaces", "snapshots", "commvault"], case_sensitive=False),
-    help="Business scenario analysis: workspaces (FinOps-24: $13,020 savings), snapshots (FinOps-23: $119,700 savings), commvault (FinOps-25: investigation)"
+    type=click.Choice(["workspaces", "snapshots", "commvault", "nat-gateway", "elastic-ip", "ebs", "vpc-cleanup"], case_sensitive=False),
+    help="Business scenario analysis: workspaces (FinOps-24: $13,020 savings), snapshots (FinOps-23: $119,700 savings), commvault (FinOps-25: investigation), nat-gateway (FinOps-26: $8K-$12K potential), elastic-ip (FinOps-EIP: $3.65/month direct savings), ebs (FinOps-EBS: 15-20% storage optimization), vpc-cleanup (AWSO-05: $5,869.20 VPC cleanup savings)"
 )
 @click.pass_context
 def finops(
@@ -5891,10 +5891,14 @@ def finops(
     Comprehensive cost analysis supporting both UnblendedCost (technical) 
     and AmortizedCost (financial) perspectives for enterprise reporting.
 
-    BUSINESS SCENARIOS ($132,720+ proven savings):
+    BUSINESS SCENARIOS ($138,589+ proven savings):
         runbooks finops --scenario workspaces    # FinOps-24: WorkSpaces cleanup ($13,020 annual)
         runbooks finops --scenario snapshots     # FinOps-23: RDS snapshots ($119,700 annual)
         runbooks finops --scenario commvault     # FinOps-25: EC2 investigation framework
+        runbooks finops --scenario nat-gateway   # FinOps-26: NAT Gateway optimization ($8K-$12K potential)
+        runbooks finops --scenario elastic-ip    # FinOps-EIP: Elastic IP cleanup ($3.65/month per EIP)
+        runbooks finops --scenario ebs           # FinOps-EBS: Storage optimization (15-20% cost reduction)
+        runbooks finops --scenario vpc-cleanup   # AWSO-05: VPC cleanup ($5,869.20 annual savings)
 
     GENERAL ANALYTICS:
         runbooks finops --audit --csv --report-name audit_report
@@ -5914,20 +5918,259 @@ def finops(
         print_info(f"Executing scenario: {scenario.upper()}")
         
         try:
+            # Import CloudOps cost optimizer for enhanced JIRA scenario integration
+            from runbooks.cloudops.cost_optimizer import CostOptimizer
+            from runbooks.cloudops.models import ExecutionMode
+            import asyncio
+            
+            # Initialize CloudOps cost optimizer with enterprise patterns
+            execution_mode = ExecutionMode.DRY_RUN if dry_run else ExecutionMode.EXECUTE
+            # Ensure profile is a string, not a tuple
+            profile_str = profile[0] if isinstance(profile, (tuple, list)) and profile else profile or "default"
+            cost_optimizer = CostOptimizer(
+                profile=profile_str,
+                dry_run=dry_run,
+                execution_mode=execution_mode
+            )
+            
             if scenario.lower() == "workspaces":
                 print_info("FinOps-24: WorkSpaces cleanup analysis ($13,020 annual savings - 104% target achievement)")
-                from runbooks.finops.finops_scenarios import analyze_finops_24_workspaces
-                results = analyze_finops_24_workspaces(profile)
+                print_info("🚀 Enhanced with CloudOps enterprise integration")
+                
+                # Use CloudOps cost optimizer for enterprise-grade analysis
+                workspaces_result = asyncio.run(cost_optimizer.optimize_workspaces(
+                    usage_threshold_days=180,  # 6 months as per JIRA requirement
+                    dry_run=dry_run
+                ))
+                
+                # Convert to legacy format for backward compatibility
+                results = {
+                    "scenario": "FinOps-24",
+                    "business_case": "WorkSpaces Cleanup",
+                    "annual_savings": workspaces_result.annual_savings,
+                    "monthly_savings": workspaces_result.total_monthly_savings,
+                    "affected_resources": workspaces_result.affected_resources,
+                    "success": workspaces_result.success,
+                    "execution_mode": workspaces_result.execution_mode.value,
+                    "risk_level": workspaces_result.resource_impacts[0].risk_level.value if workspaces_result.resource_impacts else "LOW"
+                }
                 
             elif scenario.lower() == "snapshots":
                 print_info("FinOps-23: RDS snapshots optimization ($119,700 annual savings - 498% target achievement)")
-                from runbooks.finops.finops_scenarios import analyze_finops_23_rds_snapshots
-                results = analyze_finops_23_rds_snapshots(profile)
+                print_info("🚀 Enhanced with CloudOps enterprise integration")
+                
+                # Use CloudOps cost optimizer for enterprise-grade analysis
+                snapshots_result = asyncio.run(cost_optimizer.optimize_rds_snapshots(
+                    snapshot_age_threshold_days=90,  # 3 months threshold
+                    dry_run=dry_run
+                ))
+                
+                # Convert to legacy format for backward compatibility
+                results = {
+                    "scenario": "FinOps-23", 
+                    "business_case": "RDS Snapshots Cleanup",
+                    "annual_savings": snapshots_result.annual_savings,
+                    "monthly_savings": snapshots_result.total_monthly_savings,
+                    "affected_resources": snapshots_result.affected_resources,
+                    "success": snapshots_result.success,
+                    "execution_mode": snapshots_result.execution_mode.value,
+                    "risk_level": snapshots_result.resource_impacts[0].risk_level.value if snapshots_result.resource_impacts else "MEDIUM"
+                }
                 
             elif scenario.lower() == "commvault":
                 print_info("FinOps-25: Commvault EC2 investigation framework (Real AWS integration)")
-                from runbooks.finops.finops_scenarios import investigate_finops_25_commvault
-                results = investigate_finops_25_commvault(profile)
+                print_info("🚀 Enhanced with CloudOps enterprise integration")
+                
+                # Use CloudOps cost optimizer for enterprise-grade investigation
+                commvault_result = asyncio.run(cost_optimizer.investigate_commvault_ec2(
+                    account_id="637423383469",  # From JIRA specification
+                    dry_run=True  # Always dry-run for investigations
+                ))
+                
+                # Convert to legacy format for backward compatibility
+                results = {
+                    "scenario": "FinOps-25",
+                    "business_case": "Commvault EC2 Investigation", 
+                    "annual_savings": commvault_result.annual_savings,
+                    "monthly_savings": commvault_result.total_monthly_savings,
+                    "affected_resources": commvault_result.affected_resources,
+                    "success": commvault_result.success,
+                    "execution_mode": commvault_result.execution_mode.value,
+                    "risk_level": commvault_result.resource_impacts[0].risk_level.value if commvault_result.resource_impacts else "HIGH",
+                    "investigation_status": "Framework Established"
+                }
+                
+            elif scenario.lower() == "nat-gateway":
+                print_info("FinOps-26: NAT Gateway cost optimization ($8K-$12K potential annual savings)")
+                print_info("🚀 Enterprise multi-region analysis with network dependency validation")
+                
+                # Use dedicated NAT Gateway optimizer for specialized analysis
+                from runbooks.finops.nat_gateway_optimizer import NATGatewayOptimizer
+                
+                profile_str = profile[0] if isinstance(profile, (tuple, list)) and profile else profile or "default"
+                nat_optimizer = NATGatewayOptimizer(
+                    profile_name=profile_str,
+                    regions=regions or ["us-east-1", "us-west-2", "eu-west-1"]
+                )
+                
+                nat_result = asyncio.run(nat_optimizer.analyze_nat_gateways(dry_run=dry_run))
+                
+                # Convert to legacy format for backward compatibility
+                results = {
+                    "scenario": "FinOps-26", 
+                    "business_case": "NAT Gateway Cost Optimization",
+                    "annual_savings": nat_result.potential_annual_savings,
+                    "monthly_savings": nat_result.potential_monthly_savings,
+                    "total_nat_gateways": nat_result.total_nat_gateways,
+                    "analyzed_regions": nat_result.analyzed_regions,
+                    "current_annual_cost": nat_result.total_annual_cost,
+                    "execution_time": nat_result.execution_time_seconds,
+                    "mcp_validation_accuracy": nat_result.mcp_validation_accuracy,
+                    "success": True,
+                    "risk_level": "LOW",  # READ-ONLY analysis
+                    "optimization_summary": {
+                        "decommission_candidates": len([r for r in nat_result.optimization_results if r.optimization_recommendation == "decommission"]),
+                        "investigation_candidates": len([r for r in nat_result.optimization_results if r.optimization_recommendation == "investigate"]),
+                        "retain_recommendations": len([r for r in nat_result.optimization_results if r.optimization_recommendation == "retain"])
+                    }
+                }
+                
+            elif scenario.lower() == "elastic-ip":
+                print_info("FinOps-EIP: Elastic IP cost optimization ($3.65/month per unattached EIP)")
+                print_info("🚀 Enterprise multi-region analysis with DNS dependency validation")
+                
+                # Use dedicated Elastic IP optimizer for specialized analysis
+                from runbooks.finops.elastic_ip_optimizer import ElasticIPOptimizer
+                
+                profile_str = profile[0] if isinstance(profile, (tuple, list)) and profile else profile or "default"
+                eip_optimizer = ElasticIPOptimizer(
+                    profile_name=profile_str,
+                    regions=regions or ["us-east-1", "us-west-2", "eu-west-1", "us-east-2"]
+                )
+                
+                eip_result = asyncio.run(eip_optimizer.analyze_elastic_ips(dry_run=dry_run))
+                
+                # Convert to legacy format for backward compatibility
+                results = {
+                    "scenario": "FinOps-EIP", 
+                    "business_case": "Elastic IP Cost Optimization",
+                    "annual_savings": eip_result.potential_annual_savings,
+                    "monthly_savings": eip_result.potential_monthly_savings,
+                    "total_elastic_ips": eip_result.total_elastic_ips,
+                    "attached_elastic_ips": eip_result.attached_elastic_ips,
+                    "unattached_elastic_ips": eip_result.unattached_elastic_ips,
+                    "analyzed_regions": eip_result.analyzed_regions,
+                    "current_annual_cost": eip_result.total_annual_cost,
+                    "execution_time": eip_result.execution_time_seconds,
+                    "mcp_validation_accuracy": eip_result.mcp_validation_accuracy,
+                    "success": True,
+                    "risk_level": "LOW",  # READ-ONLY analysis
+                    "optimization_summary": {
+                        "release_candidates": len([r for r in eip_result.optimization_results if r.optimization_recommendation == "release"]),
+                        "investigation_candidates": len([r for r in eip_result.optimization_results if r.optimization_recommendation == "investigate"]),
+                        "retain_recommendations": len([r for r in eip_result.optimization_results if r.optimization_recommendation == "retain"])
+                    }
+                }
+            
+            elif scenario.lower() == "ebs":
+                print_info("FinOps-EBS: EBS Volume storage optimization (15-20% cost reduction potential)")
+                print_info("🚀 Enterprise comprehensive analysis: GP2→GP3 + Usage + Orphaned cleanup")
+                
+                # Use dedicated EBS optimizer for specialized analysis
+                from runbooks.finops.ebs_optimizer import EBSOptimizer
+                
+                profile_str = profile[0] if isinstance(profile, (tuple, list)) and profile else profile or "default"
+                ebs_optimizer = EBSOptimizer(
+                    profile_name=profile_str,
+                    regions=regions or ["us-east-1", "us-west-2", "eu-west-1"]
+                )
+                
+                ebs_result = asyncio.run(ebs_optimizer.analyze_ebs_volumes(dry_run=dry_run))
+                
+                # Convert to legacy format for backward compatibility
+                results = {
+                    "scenario": "FinOps-EBS", 
+                    "business_case": "EBS Volume Storage Optimization",
+                    "annual_savings": ebs_result.total_potential_annual_savings,
+                    "monthly_savings": ebs_result.total_potential_monthly_savings,
+                    "total_volumes": ebs_result.total_volumes,
+                    "gp2_volumes": ebs_result.gp2_volumes,
+                    "gp3_eligible_volumes": ebs_result.gp3_eligible_volumes,
+                    "low_usage_volumes": ebs_result.low_usage_volumes,
+                    "orphaned_volumes": ebs_result.orphaned_volumes,
+                    "analyzed_regions": ebs_result.analyzed_regions,
+                    "current_annual_cost": ebs_result.total_annual_cost,
+                    "execution_time": ebs_result.execution_time_seconds,
+                    "mcp_validation_accuracy": ebs_result.mcp_validation_accuracy,
+                    "success": True,
+                    "risk_level": "LOW",  # READ-ONLY analysis
+                    "optimization_breakdown": {
+                        "gp3_conversion_savings": ebs_result.gp3_potential_annual_savings,
+                        "low_usage_savings": ebs_result.low_usage_potential_annual_savings,
+                        "orphaned_cleanup_savings": ebs_result.orphaned_potential_annual_savings
+                    },
+                    "optimization_summary": {
+                        "gp3_convert_candidates": len([r for r in ebs_result.optimization_results if r.optimization_recommendation == "gp3_convert"]),
+                        "usage_investigation_candidates": len([r for r in ebs_result.optimization_results if r.optimization_recommendation == "investigate_usage"]),
+                        "orphaned_cleanup_candidates": len([r for r in ebs_result.optimization_results if r.optimization_recommendation == "cleanup_orphaned"]),
+                        "retain_recommendations": len([r for r in ebs_result.optimization_results if r.optimization_recommendation == "retain"])
+                    }
+                }
+            
+            elif scenario.lower() == "vpc-cleanup":
+                print_info("AWSO-05: VPC Cleanup cost optimization ($5,869.20 annual savings)")
+                print_info("🚀 Enterprise three-bucket strategy with dependency validation")
+                
+                # Use dedicated VPC Cleanup optimizer for AWSO-05 analysis
+                from runbooks.finops.vpc_cleanup_optimizer import VPCCleanupOptimizer
+                
+                profile_str = profile[0] if isinstance(profile, (tuple, list)) and profile else profile or "default"
+                vpc_optimizer = VPCCleanupOptimizer(
+                    profile=profile_str
+                )
+                
+                vpc_result = vpc_optimizer.analyze_vpc_cleanup_opportunities()
+                
+                # Convert to legacy format for backward compatibility
+                results = {
+                    "scenario": "AWSO-05", 
+                    "business_case": "VPC Cleanup Cost Optimization",
+                    "annual_savings": vpc_result.total_annual_savings,
+                    "monthly_savings": vpc_result.total_annual_savings / 12,
+                    "total_vpcs_analyzed": vpc_result.total_vpcs_analyzed,
+                    "bucket_1_internal": len(vpc_result.bucket_1_internal),
+                    "bucket_2_external": len(vpc_result.bucket_2_external),
+                    "bucket_3_control": len(vpc_result.bucket_3_control),
+                    "cleanup_ready_vpcs": len([v for v in vpc_result.cleanup_candidates if v.cleanup_recommendation == "ready"]),
+                    "investigation_vpcs": len([v for v in vpc_result.cleanup_candidates if v.cleanup_recommendation == "investigate"]),
+                    "manual_review_vpcs": len([v for v in vpc_result.cleanup_candidates if v.cleanup_recommendation == "manual_review"]),
+                    "mcp_validation_accuracy": vpc_result.mcp_validation_accuracy,
+                    "evidence_hash": vpc_result.evidence_hash,
+                    "analysis_timestamp": vpc_result.analysis_timestamp.isoformat(),
+                    "success": True,
+                    "risk_level": "GRADUATED",  # Three-bucket graduated risk approach
+                    "safety_assessment": vpc_result.safety_assessment,
+                    "three_bucket_breakdown": {
+                        "internal_data_plane": {
+                            "count": len(vpc_result.bucket_1_internal),
+                            "annual_savings": sum(v.annual_savings for v in vpc_result.bucket_1_internal),
+                            "risk_level": "LOW",
+                            "status": "Ready for deletion"
+                        },
+                        "external_interconnects": {
+                            "count": len(vpc_result.bucket_2_external),
+                            "annual_savings": sum(v.annual_savings for v in vpc_result.bucket_2_external),
+                            "risk_level": "MEDIUM",
+                            "status": "Dependency analysis required"
+                        },
+                        "control_plane": {
+                            "count": len(vpc_result.bucket_3_control),
+                            "annual_savings": sum(v.annual_savings for v in vpc_result.bucket_3_control),
+                            "risk_level": "HIGH",
+                            "status": "Security enhancement focus"
+                        }
+                    }
+                }
             
             # Handle output file if report_name specified
             if report_name:
@@ -6222,6 +6465,185 @@ def finops_mcp_validation(profile, target_accuracy):
         raise click.Abort()
 
 
+@main.command("nat-gateway")
+@click.option('--profile', help='AWS profile name (3-tier priority: User > Environment > Default)')
+@click.option('--regions', multiple=True, help='AWS regions to analyze (space-separated)')
+@click.option('--dry-run/--no-dry-run', default=True, help='Execute in dry-run mode (READ-ONLY analysis)')
+@click.option('--export-format', type=click.Choice(['json', 'csv', 'markdown']), 
+              default='json', help='Export format for results')
+@click.option('--output-file', help='Output file path for results export')
+@click.option('--usage-threshold-days', type=int, default=7, 
+              help='CloudWatch analysis period in days')
+def nat_gateway_optimizer_cmd(profile, regions, dry_run, export_format, output_file, usage_threshold_days):
+    """
+    NAT Gateway Cost Optimizer - Enterprise Multi-Region Analysis
+    
+    Part of $132,720+ annual savings methodology targeting $8K-$12K NAT Gateway optimization.
+    
+    SAFETY: READ-ONLY analysis only - no resource modifications.
+    
+    UNIFIED CLI: Use 'runbooks finops --scenario nat-gateway' for integrated workflow.
+    
+    Examples:
+        runbooks nat-gateway --analyze
+        runbooks nat-gateway --profile my-profile --regions us-east-1 us-west-2
+        runbooks nat-gateway --export-format csv --output-file nat_analysis.csv
+    """
+    try:
+        from runbooks.finops.nat_gateway_optimizer import NATGatewayOptimizer
+        import asyncio
+        
+        # Initialize optimizer
+        optimizer = NATGatewayOptimizer(
+            profile_name=profile,
+            regions=list(regions) if regions else None
+        )
+        
+        # Execute analysis
+        results = asyncio.run(optimizer.analyze_nat_gateways(dry_run=dry_run))
+        
+        # Export results if requested
+        if output_file or export_format != 'json':
+            optimizer.export_results(results, output_file, export_format)
+            
+        # Display final success message
+        from runbooks.common.rich_utils import print_success, print_info, format_cost
+        if results.potential_annual_savings > 0:
+            print_success(f"Analysis complete: {format_cost(results.potential_annual_savings)} potential annual savings identified")
+        else:
+            print_info("Analysis complete: All NAT Gateways are optimally configured")
+            
+    except KeyboardInterrupt:
+        console.print("[yellow]Analysis interrupted by user[/yellow]")
+        raise click.Abort()
+    except Exception as e:
+        console.print(f"[red]NAT Gateway analysis failed: {e}[/red]")
+        raise click.Abort()
+
+
+@main.command("elastic-ip")
+@click.option('--profile', help='AWS profile name (3-tier priority: User > Environment > Default)')
+@click.option('--regions', multiple=True, help='AWS regions to analyze (space-separated)')
+@click.option('--dry-run/--no-dry-run', default=True, help='Execute in dry-run mode (READ-ONLY analysis)')
+@click.option('--export-format', type=click.Choice(['json', 'csv', 'markdown']), 
+              default='json', help='Export format for results')
+@click.option('--output-file', help='Output file path for results export')
+def elastic_ip_optimizer_cmd(profile, regions, dry_run, export_format, output_file):
+    """
+    Elastic IP Cost Optimizer - Enterprise Multi-Region Analysis
+    
+    Part of $132,720+ annual savings methodology targeting direct cost elimination.
+    
+    SAFETY: READ-ONLY analysis only - no resource modifications.
+    
+    UNIFIED CLI: Use 'runbooks finops --scenario elastic-ip' for integrated workflow.
+
+    Examples:
+        runbooks elastic-ip --cleanup
+        runbooks elastic-ip --profile my-profile --regions us-east-1 us-west-2
+        runbooks elastic-ip --export-format csv --output-file eip_analysis.csv
+    """
+    try:
+        from runbooks.finops.elastic_ip_optimizer import ElasticIPOptimizer
+        
+        # Initialize optimizer
+        optimizer = ElasticIPOptimizer(
+            profile_name=profile,
+            regions=list(regions) if regions else None
+        )
+        
+        # Execute analysis
+        results = asyncio.run(optimizer.analyze_elastic_ips(dry_run=dry_run))
+        
+        # Export results if requested
+        if output_file or export_format != 'json':
+            optimizer.export_results(results, output_file, export_format)
+            
+        # Display final success message
+        from runbooks.common.rich_utils import print_success, print_info, format_cost
+        if results.potential_annual_savings > 0:
+            print_success(f"Analysis complete: {format_cost(results.potential_annual_savings)} potential annual savings identified")
+        else:
+            print_info("Analysis complete: All Elastic IPs are optimally configured")
+            
+    except KeyboardInterrupt:
+        console.print("[yellow]Analysis interrupted by user[/yellow]")
+        raise click.Abort()
+    except Exception as e:
+        console.print(f"[red]Elastic IP analysis failed: {e}[/red]")
+        raise click.Abort()
+
+
+@main.command("ebs")
+@click.option('--profile', help='AWS profile name (3-tier priority: User > Environment > Default)')
+@click.option('--regions', multiple=True, help='AWS regions to analyze (space-separated)')
+@click.option('--dry-run/--no-dry-run', default=True, help='Execute in dry-run mode (READ-ONLY analysis)')
+@click.option('--export-format', type=click.Choice(['json', 'csv', 'markdown']), 
+              default='json', help='Export format for results')
+@click.option('--output-file', help='Output file path for results export')
+@click.option('--usage-threshold-days', type=int, default=7, 
+              help='CloudWatch analysis period in days')
+def ebs_optimizer_cmd(profile, regions, dry_run, export_format, output_file, usage_threshold_days):
+    """
+    EBS Volume Optimizer - Enterprise Multi-Region Storage Analysis
+    
+    Comprehensive EBS storage cost optimization combining 3 strategies:
+    • GP2→GP3 conversion analysis (15-20% storage cost reduction)
+    • Low usage volume detection via CloudWatch metrics
+    • Orphaned volume cleanup from stopped/terminated instances
+    
+    Part of $132,720+ annual savings methodology completing Tier 1 High-Value engine.
+    
+    SAFETY: READ-ONLY analysis only - no resource modifications.
+    
+    UNIFIED CLI: Use 'runbooks finops --scenario ebs' for integrated workflow.
+    
+    Examples:
+        runbooks ebs --optimize
+        runbooks ebs --profile my-profile --regions us-east-1 us-west-2
+        runbooks ebs --export-format csv --output-file ebs_analysis.csv
+    """
+    try:
+        from runbooks.finops.ebs_optimizer import EBSOptimizer
+        import asyncio
+        
+        # Initialize optimizer
+        optimizer = EBSOptimizer(
+            profile_name=profile,
+            regions=list(regions) if regions else None
+        )
+        
+        # Execute comprehensive analysis
+        results = asyncio.run(optimizer.analyze_ebs_volumes(dry_run=dry_run))
+        
+        # Export results if requested
+        if output_file or export_format != 'json':
+            optimizer.export_results(results, output_file, export_format)
+            
+        # Display final success message
+        from runbooks.common.rich_utils import print_success, print_info, format_cost
+        if results.total_potential_annual_savings > 0:
+            savings_breakdown = []
+            if results.gp3_potential_annual_savings > 0:
+                savings_breakdown.append(f"GP2→GP3: {format_cost(results.gp3_potential_annual_savings)}")
+            if results.low_usage_potential_annual_savings > 0:
+                savings_breakdown.append(f"Usage: {format_cost(results.low_usage_potential_annual_savings)}")
+            if results.orphaned_potential_annual_savings > 0:
+                savings_breakdown.append(f"Orphaned: {format_cost(results.orphaned_potential_annual_savings)}")
+                
+            print_success(f"Analysis complete: {format_cost(results.total_potential_annual_savings)} potential annual savings")
+            print_info(f"Optimization strategies: {' | '.join(savings_breakdown)}")
+        else:
+            print_info("Analysis complete: All EBS volumes are optimally configured")
+            
+    except KeyboardInterrupt:
+        console.print("[yellow]Analysis interrupted by user[/yellow]")
+        raise click.Abort()
+    except Exception as e:
+        console.print(f"[red]EBS optimization analysis failed: {e}[/red]")
+        raise click.Abort()
+
+
 # ============================================================================
 # HELPER FUNCTIONS
 # ============================================================================
@@ -6931,44 +7353,69 @@ def vpc(ctx):
 
 @vpc.command()
 @common_aws_options
-@click.option("--billing-profile", help="Billing profile for cost analysis")
-@click.option("--days", default=30, help="Number of days to analyze")
-@click.option("--output-dir", default="./exports", help="Output directory for results")
+@click.option("--vpc-ids", multiple=True, help="Specific VPC IDs to analyze (space-separated)")
+@click.option("--output-dir", default="./awso_evidence", help="Output directory for evidence")
+@click.option("--generate-evidence", is_flag=True, default=True, help="Generate AWSO-05 evidence bundle")
 @click.pass_context
-def analyze(ctx, profile, region, dry_run, billing_profile, days, output_dir):
+def analyze(ctx, profile, region, dry_run, vpc_ids, output_dir, generate_evidence):
     """
-    🔍 Analyze VPC networking components and costs
+    🔍 Comprehensive VPC analysis with AWSO-05 integration
+
+    Migrated from VPC module with enhanced capabilities:
+    - Complete VPC topology discovery
+    - 12-step AWSO-05 dependency analysis  
+    - ENI gate validation for workload protection
+    - Evidence bundle generation for compliance
 
     Examples:
-        runbooks vpc analyze --profile prod --days 30
-        runbooks vpc analyze --billing-profile billing-profile
+        runbooks vpc analyze --profile prod
+        runbooks vpc analyze --vpc-ids vpc-123 vpc-456 --generate-evidence
+        runbooks vpc analyze --output-dir ./custom_evidence
     """
-    console.print("[cyan]🔍 VPC Networking Analysis[/cyan]")
+    console.print("[cyan]🔍 VPC Analysis - Enhanced with VPC Module Integration[/cyan]")
 
     try:
-        from runbooks.vpc import VPCNetworkingWrapper
+        from runbooks.operate.vpc_operations import VPCOperations
+        from runbooks.inventory.vpc_analyzer import VPCAnalyzer
 
-        # Initialize wrapper
-        wrapper = VPCNetworkingWrapper(
-            profile=profile, region=region, billing_profile=billing_profile or profile, console=console
-        )
+        # Initialize VPC operations with analyzer integration
+        vpc_ops = VPCOperations(profile=profile, region=region, dry_run=dry_run)
+        
+        # Convert tuple to list for VPC IDs
+        vpc_id_list = list(vpc_ids) if vpc_ids else None
 
-        # Analyze NAT Gateways
-        console.print("\n📊 Analyzing NAT Gateways...")
-        nat_results = wrapper.analyze_nat_gateways(days=days)
+        console.print(f"\n🔍 Starting comprehensive VPC analysis...")
+        if vpc_id_list:
+            console.print(f"Analyzing specific VPCs: {', '.join(vpc_id_list)}")
+        else:
+            console.print("Analyzing all VPCs in region")
+        console.print(f"📊 Analysis includes: topology discovery, cost analysis, AWSO-05 compliance")
 
-        # Analyze VPC Endpoints
-        console.print("\n🔗 Analyzing VPC Endpoints...")
-        vpc_endpoint_results = wrapper.analyze_vpc_endpoints()
+        # Execute integrated VPC analysis workflow
+        results = vpc_ops.execute_integrated_vpc_analysis(
+            vpc_ids=vpc_id_list,
+            generate_evidence=generate_evidence
+        )
 
-        # Export results
-        if output_dir:
-            console.print(f"\n📁 Exporting results to {output_dir}...")
-            exported = wrapper.export_results(output_dir)
-            console.print(f"[green]✅ Exported {len(exported)} files[/green]")
+        # Display results summary
+        summary = results['analysis_summary']
+        console.print(f"\n✅ VPC Analysis Complete!")
+        console.print(f"📊 Resources discovered: {summary['total_resources']}")
+        console.print(f"💰 Monthly network cost: ${summary['estimated_monthly_cost']:.2f}")
+        
+        if summary['default_vpcs_found'] > 0:
+            console.print(f"🚨 Default VPCs found: {summary['default_vpcs_found']} (security risk)")
+        
+        if summary['eni_gate_warnings'] > 0:
+            console.print(f"⚠️ ENI warnings: {summary['eni_gate_warnings']} (workload protection)")
+            
+        console.print(f"🎯 Cleanup readiness: {summary['cleanup_readiness']}")
+
+        if results.get('evidence_files'):
+            console.print(f"📋 Evidence bundle: {len(results['evidence_files'])} files in {output_dir}")
 
     except Exception as e:
-        console.print(f"[red]❌ Error: {e}[/red]")
+        console.print(f"[red]❌ VPC Analysis Error: {e}[/red]")
         logger.error(f"VPC analysis failed: {e}")
         sys.exit(1)