runbooks 1.1.2__tar.gz → 1.1.3__tar.gz

{runbooks-1.1.2/src/runbooks.egg-info → runbooks-1.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: runbooks
-Version: 1.1.2
+Version: 1.1.3
 Summary: CloudOps Automation Toolkit with Enhanced Cloud Foundations Assessment for DevOps and SRE teams.
 Author-email: Maintainers <nnthanh101@gmail.com>
 License-Expression: Apache-2.0

{runbooks-1.1.2 → runbooks-1.1.3}/pyproject.toml

@@ -13,7 +13,7 @@
 ## Metadata: https://docs.astral.sh/uv/concepts/projects/config/
 name = "runbooks"
 ## Enhanced with AWS Operations integration, unified CLI architecture, and comprehensive service operations
-version = "1.1.2"
+version = "1.1.3"
 description = "CloudOps Automation Toolkit with Enhanced Cloud Foundations Assessment for DevOps and SRE teams."
 readme = "README.md"
 requires-python = ">=3.11,<3.14"

{runbooks-1.1.2 → runbooks-1.1.3}/src/runbooks/__init__.py

@@ -61,7 +61,7 @@ s3_ops = S3Operations()
 
 # Centralized Version Management - Single Source of Truth
 # All modules MUST import __version__ from this location
-__version__ = "1.1.2"
+__version__ = "1.1.3"
 
 # Fallback for legacy importlib.metadata usage during transition
 try:

{runbooks-1.1.2 → runbooks-1.1.3}/src/runbooks/cloudops/cost_optimizer.py

@@ -20,6 +20,7 @@ Source Notebooks:
 """
 
 import asyncio
+import json
 import time
 from typing import Dict, List, Optional, Any, Tuple
 import boto3
@@ -64,25 +65,31 @@ class CostOptimizer(CloudOpsBase):
     """
     
     def __init__(
-        self, 
-        profile: str = "default", 
+        self,
+        profile: str = "default",
         dry_run: bool = True,
-        execution_mode: ExecutionMode = ExecutionMode.DRY_RUN
+        execution_mode: ExecutionMode = ExecutionMode.DRY_RUN,
+        region: str = "us-east-1"
     ):
         """
         Initialize Cost Optimizer with enterprise patterns.
-        
+
         Args:
             profile: AWS profile (typically billing profile for cost data)
             dry_run: Enable safe analysis mode (default True)
             execution_mode: Execution mode for operations
+            region: AWS region for operations (default us-east-1)
         """
         super().__init__(profile, dry_run, execution_mode)
-        
-        print_header("CloudOps Cost Optimizer", "1.0.0")
+
+        # Initialize region attribute
+        self.region = region
+
+        from runbooks import __version__
+        print_header("CloudOps Cost Optimizer", __version__)
         print_info(f"Execution mode: {execution_mode.value}")
         print_info(f"Profile: {profile}")
-        
+
         if dry_run:
             print_warning("🛡️  DRY RUN MODE: No resources will be modified")
 
@@ -1220,7 +1227,7 @@ class CostOptimizer(CloudOpsBase):
             CostOptimizationResult with WorkSpaces cleanup analysis
         """
         operation_name = "WorkSpaces Cost Optimization"
-        print_header(f"🏢 {operation_name} (FinOps-24)")
+        print_header(f"🏢 {operation_name}")
         
         # Import existing workspaces analyzer
         try:
@@ -1349,20 +1356,70 @@ class CostOptimizer(CloudOpsBase):
         with create_progress_bar() as progress:
             task = progress.add_task("Analyzing RDS manual snapshots...", total=100)
             
-            # Step 1: Discover manual RDS snapshots across regions
+            # Step 1: Discover manual RDS snapshots using proven AWS Config aggregator method
             all_manual_snapshots = []
-            regions = ['us-east-1', 'us-west-2', 'ap-southeast-2']  # Common regions
-            
-            for region in regions:
-                regional_client = self.session.client('rds', region_name=region)
-                try:
-                    response = regional_client.describe_db_snapshots(
-                        SnapshotType='manual',
-                        MaxRecords=100
-                    )
-                    all_manual_snapshots.extend(response.get('DBSnapshots', []))
-                except Exception as e:
-                    print_warning(f"Could not access region {region}: {e}")
+
+            try:
+                # Use AWS Config aggregator to discover all RDS snapshots across organization
+                config_client = self.session.client('config', region_name='ap-southeast-2')
+
+                # Get all RDS snapshots via AWS Config aggregator (proven method)
+                response = config_client.select_aggregate_resource_config(
+                    Expression="SELECT configuration, accountId, awsRegion WHERE resourceType = 'AWS::RDS::DBSnapshot'",
+                    ConfigurationAggregatorName='organization-aggregator',
+                    MaxResults=100  # AWS limit is 100
+                )
+
+                print_info(f"Found {len(response.get('Results', []))} RDS snapshots via AWS Config aggregator")
+
+                # Process snapshots found by Config aggregator
+                for result in response.get('Results', []):
+                    try:
+                        resource_data = json.loads(result)
+                        config_data = resource_data.get('configuration', {})
+
+                        # Handle case where configuration might be a string
+                        if isinstance(config_data, str):
+                            config_data = json.loads(config_data)
+
+                        # Filter for manual snapshots only
+                        if config_data.get('snapshotType') == 'manual':
+                            # Create snapshot object compatible with describe_db_snapshots format
+                            snapshot = {
+                                'DBSnapshotIdentifier': config_data.get('dBSnapshotIdentifier'),
+                                'SnapshotCreateTime': datetime.fromisoformat(config_data.get('snapshotCreateTime', '').replace('Z', '+00:00')) if config_data.get('snapshotCreateTime') else datetime.now(),
+                                'AllocatedStorage': config_data.get('allocatedStorage', 0),
+                                'DBInstanceIdentifier': config_data.get('dBInstanceIdentifier'),
+                                'SnapshotType': config_data.get('snapshotType'),
+                                'Status': config_data.get('status', 'available'),
+                                'Engine': config_data.get('engine'),
+                                'EngineVersion': config_data.get('engineVersion')
+                            }
+                            all_manual_snapshots.append(snapshot)
+                    except Exception as e:
+                        print_warning(f"Error processing snapshot from Config: {e}")
+
+                print_success(f"Successfully processed {len(all_manual_snapshots)} manual snapshots from Config aggregator")
+
+            except Exception as e:
+                print_warning(f"AWS Config aggregator query failed, falling back to regional discovery: {e}")
+
+                # Fallback to regional discovery if Config aggregator fails
+                regions = ['us-east-1', 'us-west-2', 'ap-southeast-2', 'eu-west-1', 'ap-southeast-1']  # Extended regions
+
+                for region in regions:
+                    regional_client = self.session.client('rds', region_name=region)
+                    try:
+                        # Get all manual snapshots in this region
+                        paginator = regional_client.get_paginator('describe_db_snapshots')
+                        page_iterator = paginator.paginate(SnapshotType='manual')
+
+                        for page in page_iterator:
+                            all_manual_snapshots.extend(page.get('DBSnapshots', []))
+
+                        print_info(f"Found {len([s for s in all_manual_snapshots if 'region' not in s])} manual snapshots in {region}")
+                    except Exception as e:
+                        print_warning(f"Could not access region {region}: {e}")
             
             progress.update(task, advance=40)
             
@@ -1376,7 +1433,86 @@ class CostOptimizer(CloudOpsBase):
             
             progress.update(task, advance=70)
             
-            # Step 3: Calculate estimated savings
+            # Step 3: Use enhanced RDS snapshot optimizer for consistent results
+            try:
+                from runbooks.finops.rds_snapshot_optimizer import EnhancedRDSSnapshotOptimizer
+
+                print_info("🔧 Using enhanced RDS snapshot optimization logic...")
+                enhanced_optimizer = EnhancedRDSSnapshotOptimizer(profile=self.profile, dry_run=dry_run)
+
+                if enhanced_optimizer.initialize_session():
+                    # Discover all snapshots (not just manual)
+                    all_snapshots = enhanced_optimizer.discover_snapshots_via_config_aggregator()
+
+                    if all_snapshots:
+                        # Run enhanced optimization analysis
+                        optimization_results = enhanced_optimizer.analyze_optimization_opportunities(
+                            all_snapshots, age_threshold=snapshot_age_threshold_days
+                        )
+
+                        # Use comprehensive scenario for realistic savings
+                        comprehensive_scenario = optimization_results['optimization_scenarios']['comprehensive']
+
+                        # Create resource impacts for comprehensive scenario
+                        resource_impacts = []
+                        for snapshot in comprehensive_scenario['snapshots']:
+                            resource_impacts.append(
+                                ResourceImpact(
+                                    resource_type="rds-snapshot",
+                                    resource_id=snapshot.get('DBSnapshotIdentifier', 'unknown'),
+                                    region=snapshot.get('Region', 'unknown'),
+                                    account_id=snapshot.get('AccountId', 'unknown'),
+                                    estimated_monthly_cost=snapshot.get('EstimatedMonthlyCost', 0.0),
+                                    projected_savings=snapshot.get('EstimatedMonthlyCost', 0.0),
+                                    risk_level=RiskLevel.MEDIUM,
+                                    modification_required=True,
+                                    resource_name=f"RDS Snapshot {snapshot.get('DBSnapshotIdentifier', 'unknown')}",
+                                    estimated_downtime=0.0
+                                )
+                            )
+
+                        progress.update(task, advance=100)
+
+                        return CostOptimizationResult(
+                            scenario=BusinessScenario.COST_OPTIMIZATION,
+                            scenario_name=operation_name,
+                            execution_timestamp=datetime.now(),
+                            execution_mode=self.execution_mode,
+                            execution_time=30.0,
+                            success=True,
+                            error_message=None,
+                            resources_analyzed=optimization_results['total_snapshots'],
+                            resources_impacted=resource_impacts,
+                            business_metrics=self.create_business_metrics(
+                                total_savings=optimization_results['potential_monthly_savings'],
+                                overall_risk=RiskLevel.MEDIUM
+                            ),
+                            recommendations=[
+                                f"Review {optimization_results['cleanup_candidates']} snapshots older than {snapshot_age_threshold_days} days",
+                                f"Potential annual savings: ${optimization_results['potential_annual_savings']:,.2f}",
+                                "Consider implementing automated retention policies",
+                                "Review backup requirements before deletion"
+                            ],
+                            # CostOptimizationResult specific fields
+                            current_monthly_spend=optimization_results.get('current_monthly_spend', 0.0),
+                            optimized_monthly_spend=optimization_results.get('current_monthly_spend', 0.0) - optimization_results['potential_monthly_savings'],
+                            savings_percentage=(optimization_results['potential_monthly_savings'] / max(optimization_results.get('current_monthly_spend', 1), 1)) * 100,
+                            annual_savings=optimization_results['potential_annual_savings'],
+                            total_monthly_savings=optimization_results['potential_monthly_savings'],
+                            affected_resources=optimization_results['cleanup_candidates'],
+                            resource_impacts=resource_impacts
+                        )
+                    else:
+                        print_warning("No snapshots discovered via enhanced optimizer")
+
+            except ImportError as e:
+                print_warning(f"Enhanced optimizer not available, using legacy logic: {e}")
+            except Exception as e:
+                print_warning(f"Enhanced optimizer failed, using legacy logic: {e}")
+
+            # Fallback to legacy calculation for compatibility
+            print_info("Using legacy optimization calculation...")
+            # Step 3: Calculate estimated savings (legacy)
             # Based on JIRA data: $5K-24K range for manual snapshots
             total_size_gb = sum(snapshot.get('AllocatedStorage', 0) for snapshot in old_snapshots)
             estimated_monthly_savings = total_size_gb * 0.05  # ~$0.05/GB-month for snapshots

{runbooks-1.1.2 → runbooks-1.1.3}/src/runbooks/common/business_logic.py

@@ -189,7 +189,7 @@ class UniversalBusinessLogic:
         # Apply proven profile management patterns
         selected_profile = get_profile_for_operation("operational", profile)
 
-        print_header(f"{resource_type.title()} {operation.title()}", f"v1.0.0 - {self.module_name}")
+        print_header(f"{resource_type.title()} {operation.title()}", f"v1.1.2 - {self.module_name}")
         print_info(f"Using profile: {selected_profile}")
 
         # Standard operation tracking

{runbooks-1.1.2 → runbooks-1.1.3}/src/runbooks/common/rich_utils.py

@@ -611,14 +611,14 @@ def create_columns(items: List[Any], equal: bool = True, expand: bool = True) ->
 # Manager's Cost Optimization Scenario Formatting Functions
 def format_workspaces_analysis(workspaces_data: Dict[str, Any], target_savings: int = 12518) -> Panel:
     """
-    Format WorkSpaces cost analysis for manager's FinOps-24 scenario.
-    
+    Format WorkSpaces cost analysis for manager's priority scenario.
+
     Based on manager's requirement for $12,518 annual savings through
     cleanup of unused WorkSpaces with zero usage in last 6 months.
-    
+
     Args:
         workspaces_data: Dictionary containing WorkSpaces cost and utilization data
-        target_savings: Annual savings target (default: $12,518 from FinOps-24)
+        target_savings: Annual savings target (default: $12,518)
         
     Returns:
         Rich Panel with formatted WorkSpaces analysis
@@ -654,7 +654,7 @@ def format_workspaces_analysis(workspaces_data: Dict[str, Any], target_savings:
 
 [{status_style}]{status}[/]"""
 
-    return Panel(content, title="[bright_cyan]FinOps-24: WorkSpaces Cost Optimization[/bright_cyan]", 
+    return Panel(content, title="[bright_cyan]WorkSpaces Cost Optimization[/bright_cyan]",
                 border_style="bright_green" if target_achievement >= 90 else "yellow")
 
 

{runbooks-1.1.2 → runbooks-1.1.3}/src/runbooks/finops/README.md

@@ -25,9 +25,9 @@ runbooks finops --help                              # View all functionality
 runbooks finops --scenario workspaces --profile PROFILE     # WorkSpaces optimization
 runbooks finops --scenario nat-gateway --profile PROFILE    # NAT Gateway optimization
 runbooks finops --scenario elastic-ip --profile PROFILE     # Elastic IP management
-runbooks finops --scenario ebs --profile PROFILE            # EBS optimization
-runbooks finops --scenario snapshots --profile PROFILE      # RDS snapshots cleanup
-runbooks finops --scenario commvault --profile PROFILE      # Backup analysis
+runbooks finops --scenario ebs-optimization --profile PROFILE # EBS optimization
+runbooks finops --scenario rds-snapshots --profile PROFILE  # RDS snapshots cleanup
+runbooks finops --scenario backup-investigation --profile PROFILE # Backup analysis
 runbooks finops --scenario vpc-cleanup --profile PROFILE    # VPC cleanup
 
 # AWS Cost Explorer metrics (working)

{runbooks-1.1.2 → runbooks-1.1.3}/src/runbooks/finops/cli.py

@@ -228,7 +228,7 @@ def main() -> int:
     parser.add_argument(
         "--scenario",
         type=str,
-        help="Business scenario analysis (workspaces, snapshots, commvault, nat-gateway, elastic-ip, ebs, vpc-cleanup)",
+        help="Business scenario analysis (workspaces, rds-snapshots, backup-investigation, nat-gateway, elastic-ip, ebs-optimization, vpc-cleanup)",
     )
     parser.add_argument(
         "--help-scenario",
@@ -272,93 +272,58 @@ def main() -> int:
 
             console.print(f"[bold cyan]🎯 Executing Business Scenario: {args.scenario}[/bold cyan]")
 
-            # Define scenario execution functions with proper parameters
-            # CRITICAL FIX: Use enterprise profile management for proper BILLING_PROFILE fallback
-            from runbooks.common.profile_utils import get_profile_for_operation
-
-            def execute_workspaces_scenario():
-                from runbooks.finops.scenarios import finops_workspaces
-                # Use enterprise profile resolution: User > Environment > Default
-                profile_param = get_profile_for_operation("billing", args.profiles[0] if args.profiles else None)
-                return finops_workspaces(profile=profile_param)
-
-            def execute_snapshots_scenario():
-                from runbooks.finops.scenarios import finops_snapshots
-                # Use enterprise profile resolution: User > Environment > Default
-                profile_param = get_profile_for_operation("billing", args.profiles[0] if args.profiles else None)
-                return finops_snapshots(profile=profile_param)
-
-            def execute_commvault_scenario():
-                from runbooks.finops.scenarios import finops_commvault
-                # Use enterprise profile resolution: User > Environment > Default
-                profile_param = get_profile_for_operation("billing", args.profiles[0] if args.profiles else None)
-                return finops_commvault(profile=profile_param)
-
-            def execute_nat_gateway_scenario():
-                from runbooks.finops.nat_gateway_optimizer import nat_gateway_optimizer
-                # Use enterprise profile resolution: User > Environment > Default
-                profile_param = get_profile_for_operation("billing", args.profiles[0] if args.profiles else None)
-                regions = args.regions if args.regions else ['us-east-1']
-                # Call the CLI function with default parameters
-                nat_gateway_optimizer(
-                    profile=profile_param,
-                    regions=regions,
-                    dry_run=True,
-                    export_format='json',
-                    output_file=None,
-                    usage_threshold_days=7
-                )
-                return {"scenario": "nat-gateway", "status": "completed", "profile": profile_param}
-
-            def execute_ebs_scenario():
-                # Create a simplified EBS scenario execution
-                print_info("EBS optimization scenario analysis")
-                # Use enterprise profile resolution: User > Environment > Default
-                profile_param = get_profile_for_operation("billing", args.profiles[0] if args.profiles else None)
-                return {"scenario": "ebs", "status": "completed", "profile": profile_param}
-
-            def execute_vpc_cleanup_scenario():
-                # Create a simplified VPC cleanup scenario execution
-                print_info("VPC cleanup scenario analysis")
-                # Use enterprise profile resolution: User > Environment > Default
-                profile_param = get_profile_for_operation("billing", args.profiles[0] if args.profiles else None)
-                return {"scenario": "vpc-cleanup", "status": "completed", "profile": profile_param}
-
-            def execute_elastic_ip_scenario():
-                # Create a simplified elastic IP scenario execution
-                print_info("Elastic IP optimization scenario analysis")
-                # Use enterprise profile resolution: User > Environment > Default
-                profile_param = get_profile_for_operation("billing", args.profiles[0] if args.profiles else None)
-                return {"scenario": "elastic-ip", "status": "completed", "profile": profile_param}
-
-            # Map scenarios to execution functions
-            scenario_map = {
-                'workspaces': execute_workspaces_scenario,
-                'snapshots': execute_snapshots_scenario,
-                'commvault': execute_commvault_scenario,
-                'nat-gateway': execute_nat_gateway_scenario,
-                'ebs': execute_ebs_scenario,
-                'vpc-cleanup': execute_vpc_cleanup_scenario,
-                'elastic-ip': execute_elastic_ip_scenario,
-            }
-
-            if args.scenario not in scenario_map:
-                print_error(f"Unknown scenario: '{args.scenario}'")
-                print_info("Available scenarios: " + ", ".join(scenario_map.keys()))
-                return 1
-
-            # Execute scenario
-            scenario_func = scenario_map[args.scenario]
-            result = scenario_func()
-
-            print_success(f"✅ Scenario '{args.scenario}' completed successfully")
-
-            # Export results if requested
-            if args.report_type and result:
-                from runbooks.finops.helpers import export_scenario_results
-                export_scenario_results(result, args.scenario, args.report_type, args.dir)
-
-            return 0
+            # CRITICAL FIX: Handle --all flag for scenarios by using dashboard router logic
+            if hasattr(args, "all") and args.all:
+                print_info("🔍 --all flag detected: Integrating with dashboard router for organization discovery")
+
+                # Use dashboard router to handle --all flag and get profiles
+                from runbooks.finops.dashboard_router import create_dashboard_router
+                router = create_dashboard_router()
+                use_case, routing_config = router.detect_use_case(args)
+
+                # Extract profiles from routing config
+                profiles_to_use = routing_config.get("profiles_to_analyze", [])
+                if not profiles_to_use:
+                    print_error("--all flag failed to discover any profiles")
+                    return 1
+
+                print_success(f"Discovered {len(profiles_to_use)} profiles for scenario execution")
+
+                # Execute scenario across all discovered profiles
+                all_results = []
+                for profile in profiles_to_use:
+                    print_info(f"Executing scenario '{args.scenario}' for profile: {profile}")
+
+                    # Create a copy of args with single profile for execution
+                    single_profile_args = argparse.Namespace(**vars(args))
+                    single_profile_args.profiles = [profile]
+                    single_profile_args.all = False  # Disable --all for individual execution
+
+                    # Execute scenario with single profile (recursive call but with all=False)
+                    result = _execute_single_scenario(single_profile_args)
+                    if result:
+                        all_results.append(result)
+
+                # Combine results and export if requested
+                combined_result = {
+                    "scenario": args.scenario,
+                    "status": "completed",
+                    "profiles_analyzed": len(profiles_to_use),
+                    "individual_results": all_results,
+                    "organization_scope": use_case == "organization_wide"
+                }
+
+                print_success(f"✅ Scenario '{args.scenario}' completed for {len(profiles_to_use)} profiles")
+
+                # Export results if requested
+                if args.report_type and combined_result:
+                    from runbooks.finops.helpers import export_scenario_results
+                    export_scenario_results(combined_result, args.scenario, args.report_type, args.dir)
+
+                return 0
+            else:
+                # Handle single profile execution (existing logic)
+                return _execute_single_scenario(args)
 
         except ImportError as e:
             console.print(f"[red]❌ Scenario '{args.scenario}' not available: {e}[/red]")
@@ -367,26 +332,127 @@ def main() -> int:
             console.print(f"[red]❌ Scenario execution failed: {e}[/red]")
             return 1
 
+
+def _execute_single_scenario(args: argparse.Namespace) -> int:
+    """Execute a scenario for a single profile (internal helper function)."""
+    import argparse
+    from runbooks.common.rich_utils import print_header, print_success, print_error, print_info
+    from runbooks.common.profile_utils import get_profile_for_operation
+
+    def execute_workspaces_scenario():
+        from runbooks.finops.scenarios import finops_workspaces
+        # Use enterprise profile resolution: User > Environment > Default
+        profile_param = get_profile_for_operation("billing", args.profiles[0] if args.profiles else None)
+        return finops_workspaces(profile=profile_param)
+
+    def execute_snapshots_scenario():
+        from runbooks.finops.scenarios import finops_snapshots
+        # Use enterprise profile resolution: User > Environment > Default
+        profile_param = get_profile_for_operation("billing", args.profiles[0] if args.profiles else None)
+        return finops_snapshots(profile=profile_param)
+
+    def execute_commvault_scenario():
+        from runbooks.finops.scenarios import finops_commvault
+        # Use enterprise profile resolution: User > Environment > Default
+        profile_param = get_profile_for_operation("billing", args.profiles[0] if args.profiles else None)
+        return finops_commvault(profile=profile_param)
+
+    def execute_nat_gateway_scenario():
+        from runbooks.finops.nat_gateway_optimizer import nat_gateway_optimizer
+        # Use enterprise profile resolution: User > Environment > Default
+        profile_param = get_profile_for_operation("billing", args.profiles[0] if args.profiles else None)
+        regions = args.regions if args.regions else ['us-east-1']
+        # Call the CLI function with default parameters
+        nat_gateway_optimizer(
+            profile=profile_param,
+            regions=regions,
+            dry_run=True,
+            export_format='json',
+            output_file=None,
+            usage_threshold_days=7
+        )
+        return {"scenario": "nat-gateway", "status": "completed", "profile": profile_param}
+
+    def execute_ebs_scenario():
+        # Create a simplified EBS scenario execution
+        print_info("EBS optimization scenario analysis")
+        # Use enterprise profile resolution: User > Environment > Default
+        profile_param = get_profile_for_operation("billing", args.profiles[0] if args.profiles else None)
+        return {"scenario": "ebs", "status": "completed", "profile": profile_param}
+
+    def execute_vpc_cleanup_scenario():
+        # Create a simplified VPC cleanup scenario execution
+        print_info("VPC cleanup scenario analysis")
+        # Use enterprise profile resolution: User > Environment > Default
+        profile_param = get_profile_for_operation("billing", args.profiles[0] if args.profiles else None)
+        return {"scenario": "vpc-cleanup", "status": "completed", "profile": profile_param}
+
+    def execute_elastic_ip_scenario():
+        # Create a simplified elastic IP scenario execution
+        print_info("Elastic IP optimization scenario analysis")
+        # Use enterprise profile resolution: User > Environment > Default
+        profile_param = get_profile_for_operation("billing", args.profiles[0] if args.profiles else None)
+        return {"scenario": "elastic-ip", "status": "completed", "profile": profile_param}
+
+    # Map scenarios to execution functions
+    scenario_map = {
+        'workspaces': execute_workspaces_scenario,
+        'rds-snapshots': execute_snapshots_scenario,
+        'backup-investigation': execute_commvault_scenario,
+        'nat-gateway': execute_nat_gateway_scenario,
+        'ebs-optimization': execute_ebs_scenario,
+        'vpc-cleanup': execute_vpc_cleanup_scenario,
+        'elastic-ip': execute_elastic_ip_scenario,
+    }
+
+    if args.scenario not in scenario_map:
+        print_error(f"Unknown scenario: '{args.scenario}'")
+        print_info("Available scenarios: " + ", ".join(scenario_map.keys()))
+        return 1
+
+    # Execute scenario
+    scenario_func = scenario_map[args.scenario]
+    result = scenario_func()
+
+    print_success(f"✅ Scenario '{args.scenario}' completed successfully")
+
+    # Export results if requested
+    if args.report_type and result:
+        from runbooks.finops.helpers import export_scenario_results
+        export_scenario_results(result, args.scenario, args.report_type, args.dir)
+
+    return 0
+
+
     # Handle PDCA mode
     if args.pdca or args.pdca_continuous:
-        import asyncio
-
-        from runbooks.finops.pdca_engine import AutonomousPDCAEngine, PDCAThresholds
+        try:
+            import asyncio
+            from runbooks.finops.pdca_engine import AutonomousPDCAEngine, PDCAThresholds
+
+            console.print("[bold bright_cyan]🤖 Launching Autonomous PDCA Engine...[/]")
+
+            # Configure PDCA thresholds
+            thresholds = PDCAThresholds(
+                max_risk_score=25,
+                max_cost_increase=10.0,
+                max_untagged_resources=50,
+                max_unused_eips=5,
+                max_budget_overruns=1,
+            )
 
-        console.print("[bold bright_cyan]🤖 Launching Autonomous PDCA Engine...[/]")
+            # Initialize PDCA engine
+            artifacts_dir = args.dir or "artifacts"
 
-        # Configure PDCA thresholds
-        thresholds = PDCAThresholds(
-            max_risk_score=25,
-            max_cost_increase=10.0,
-            max_untagged_resources=50,
-            max_unused_eips=5,
-            max_budget_overruns=1,
-        )
+            # Ensure artifacts directory exists
+            import os
+            os.makedirs(artifacts_dir, exist_ok=True)
 
-        # Initialize PDCA engine
-        artifacts_dir = args.dir or "artifacts"
-        engine = AutonomousPDCAEngine(thresholds=thresholds, artifacts_dir=artifacts_dir)
+            engine = AutonomousPDCAEngine(thresholds=thresholds, artifacts_dir=artifacts_dir)
+        except ImportError as e:
+            console.print(f"[red]❌ PDCA Engine not available: {e}[/]")
+            console.print("[yellow]💡 PDCA functionality requires additional setup[/]")
+            return 1
 
         try:
             # Determine execution mode