runbooks 1.1.4__py3-none-any.whl → 1.1.6__py3-none-any.whl

runbooks/inventory/core/collector.py

@@ -44,6 +44,7 @@ except ImportError:
     ENHANCED_PROFILES_AVAILABLE = False
     # Fallback profile definitions with universal environment support
     import os
+
     ENTERPRISE_PROFILES = {
         "BILLING_PROFILE": os.getenv("BILLING_PROFILE", "default-billing-profile"),
         "MANAGEMENT_PROFILE": os.getenv("MANAGEMENT_PROFILE", "default-management-profile"),
@@ -106,11 +107,12 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
         self.mcp_integrator = EnterpriseMCPIntegrator(profile)
         self.cross_module_integrator = EnterpriseCrossModuleIntegrator(profile)
         self.enable_mcp_validation = True
-        
+
         # Initialize inventory-specific MCP validator
         self.inventory_mcp_validator = None
         try:
             from ..mcp_inventory_validator import create_inventory_mcp_validator
+
             # Use profiles that would work for inventory operations
             validator_profiles = [self.active_profile]
             self.inventory_mcp_validator = create_inventory_mcp_validator(validator_profiles)
@@ -139,12 +141,12 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
     def _initialize_profile_architecture(self) -> str:
         """
         Initialize profile management following --profile or --all patterns.
-        
+
         Strategic Alignment: "Do one thing and do it well"
         - Single profile override pattern: --profile takes precedence
         - Universal AWS environment compatibility: works with ANY profile configuration
         - Graceful fallback system for discovery across different AWS setups
-        
+
         Returns:
             str: The active profile to use for all operations
         """
@@ -153,24 +155,24 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
             print_info(f"✅ Universal AWS Compatibility: Using user-specified profile '{self.profile}'")
             logger.info("Profile override via --profile parameter - universal environment support")
             return self.profile
-        
+
         # SECONDARY: Environment variable fallback with intelligent prioritization
         # Priority order: Management > Billing > Operations > Default (Organizations discovery preference)
         env_profile = (
-            os.getenv("MANAGEMENT_PROFILE") or 
-            os.getenv("BILLING_PROFILE") or 
-            os.getenv("CENTRALISED_OPS_PROFILE") or
-            os.getenv("SINGLE_AWS_PROFILE") or
-            "default"
+            os.getenv("MANAGEMENT_PROFILE")
+            or os.getenv("BILLING_PROFILE")
+            or os.getenv("CENTRALISED_OPS_PROFILE")
+            or os.getenv("SINGLE_AWS_PROFILE")
+            or "default"
         )
-        
+
         if env_profile != "default":
             print_info(f"✅ Universal AWS Compatibility: Using environment profile '{env_profile}'")
             logger.info(f"Environment variable profile selected: {env_profile}")
         else:
             print_info("✅ Universal AWS Compatibility: Using 'default' profile - works with any AWS CLI configuration")
             logger.info("Using default profile - universal compatibility mode")
-        
+
         return env_profile
 
     def _initialize_collectors(self) -> Dict[str, str]:
@@ -190,19 +192,19 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
 
         logger.debug(f"Initialized {len(collectors)} resource collectors")
         return collectors
-    
+
     def _extract_resource_counts(self, resource_data: Dict[str, Any]) -> Dict[str, int]:
         """
         Extract resource counts from collected inventory data for MCP validation.
-        
+
         Args:
             resource_data: Raw resource data from inventory collection
-            
+
         Returns:
             Dictionary mapping resource types to counts
         """
         resource_counts = {}
-        
+
         try:
             # Handle various data structures from inventory collection
             if isinstance(resource_data, dict):
@@ -215,15 +217,15 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
                         for region_data in resources.values():
                             if isinstance(region_data, list):
                                 total_count += len(region_data)
-                            elif isinstance(region_data, dict) and 'resources' in region_data:
-                                total_count += len(region_data['resources'])
+                            elif isinstance(region_data, dict) and "resources" in region_data:
+                                total_count += len(region_data["resources"])
                         resource_counts[resource_type] = total_count
                     elif isinstance(resources, int):
                         resource_counts[resource_type] = resources
-                        
+
             logger.debug(f"Extracted resource counts for validation: {resource_counts}")
             return resource_counts
-            
+
         except Exception as e:
             logger.warning(f"Failed to extract resource counts for MCP validation: {e}")
             return {}
@@ -235,17 +237,17 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
     def get_organization_accounts(self) -> List[str]:
         """
         Get list of accounts in AWS Organization with universal compatibility.
-        
-        Strategic Alignment: "Do one thing and do it well" 
+
+        Strategic Alignment: "Do one thing and do it well"
         - Universal AWS environment compatibility: works with ANY Organizations setup
         - Intelligent fallback system: Organizations → standalone account detection
         - Graceful handling of different permission scenarios
         """
         try:
             # Use active profile for Organizations operations (Universal Compatibility)
-            management_session = create_management_session(profile=self.active_profile)
+            management_session = create_management_session(profile_name=self.active_profile)
             organizations_client = management_session.client("organizations")
-            
+
             print_info(f"🔍 Universal Discovery: Attempting Organizations API with profile '{self.active_profile}'...")
             response = self._make_aws_call(organizations_client.list_accounts)
 
@@ -256,7 +258,9 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
 
             if accounts:
                 print_success(f"✅ Organizations Discovery: Found {len(accounts)} active accounts in organization")
-                logger.info(f"Organizations discovery successful: {len(accounts)} accounts with profile {self.active_profile}")
+                logger.info(
+                    f"Organizations discovery successful: {len(accounts)} accounts with profile {self.active_profile}"
+                )
                 return accounts
             else:
                 print_warning("⚠️ Organizations Discovery: No active accounts found in organization")
@@ -265,9 +269,11 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
         except Exception as e:
             # Enhanced error messages for different AWS environment scenarios
             error_message = str(e).lower()
-            
+
             if "accessdenied" in error_message or "unauthorized" in error_message:
-                print_warning(f"⚠️ Universal Compatibility: Profile '{self.active_profile}' lacks Organizations permissions")
+                print_warning(
+                    f"⚠️ Universal Compatibility: Profile '{self.active_profile}' lacks Organizations permissions"
+                )
                 print_info("💡 Single Account Mode: Continuing with current account (universal compatibility)")
             elif "organizationsnotinuse" in error_message:
                 print_info(f"ℹ️ Standalone Account: Profile '{self.active_profile}' not in an AWS Organization")
@@ -275,9 +281,9 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
             else:
                 print_warning(f"⚠️ Organizations Discovery Failed: {e}")
                 print_info("💡 Fallback Mode: Continuing with current account for universal compatibility")
-            
+
             logger.warning(f"Organization discovery failed, graceful fallback: {e}")
-            
+
             # Universal fallback: always return current account for single-account operations
             return [self.get_account_id()]
 
@@ -345,37 +351,37 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
             if self.enable_mcp_validation and self.inventory_mcp_validator:
                 try:
                     print_info("Validating inventory results with specialized inventory MCP validator")
-                    
+
                     # Extract resource counts for validation
                     # Build validation data structure that matches what the validator expects
                     resource_counts = self._extract_resource_counts(resource_data)
-                    
+
                     # Add resource counts to results for the validator to find
                     results["resource_counts"] = resource_counts
-                    
+
                     validation_data = {
                         "resource_counts": resource_counts,
                         "regions": results["metadata"].get("regions_scanned", []),
                         self.active_profile: {
                             "resource_counts": resource_counts,
-                            "regions": results["metadata"].get("regions_scanned", [])
-                        }
+                            "regions": results["metadata"].get("regions_scanned", []),
+                        },
                     }
-                    
+
                     # Run inventory-specific MCP validation
                     inventory_validation = self.inventory_mcp_validator.validate_inventory_data(validation_data)
-                    
+
                     results["inventory_mcp_validation"] = inventory_validation
-                    
+
                     overall_accuracy = inventory_validation.get("total_accuracy", 0)
                     if inventory_validation.get("passed_validation", False):
                         print_success(f"✅ Inventory MCP validation PASSED: {overall_accuracy:.1f}% accuracy achieved")
                     else:
                         print_warning(f"⚠️ Inventory MCP validation: {overall_accuracy:.1f}% accuracy (≥99.5% required)")
-                    
-                    # Also try the generic MCP integrator as backup
+
+                    # Also try the generic MCP integrator as backup - using proper async handling
                     try:
-                        validation_result = asyncio.run(self.mcp_integrator.validate_inventory_operations(results))
+                        validation_result = self._run_async_validation_safely(results)
                         results["mcp_validation"] = validation_result.to_dict()
                     except Exception:
                         pass  # Skip generic validation if it fails
@@ -383,10 +389,10 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
                 except Exception as e:
                     print_warning(f"Inventory MCP validation failed: {str(e)[:50]}... - continuing without validation")
                     results["inventory_mcp_validation"] = {"error": str(e), "validation_skipped": True}
-                    
-                    # Fallback to generic MCP integration
+
+                    # Fallback to generic MCP integration with proper async handling
                     try:
-                        validation_result = asyncio.run(self.mcp_integrator.validate_inventory_operations(results))
+                        validation_result = self._run_async_validation_safely(results)
                         results["mcp_validation"] = validation_result.to_dict()
                     except Exception as fallback_e:
                         results["mcp_validation"] = {"error": str(fallback_e), "validation_skipped": True}
@@ -438,12 +444,64 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
             results["errors"].append(error_msg)
             return results
 
+    def _run_async_validation_safely(self, results: Dict[str, Any]):
+        """
+        Safely run async MCP validation handling event loop conflicts.
+
+        This method properly handles the case where an event loop is already running
+        by using proper async execution patterns instead of skipping validation.
+
+        Args:
+            results: Inventory results to validate
+
+        Returns:
+            Validation result from MCP integrator
+        """
+        try:
+            # Check if event loop is already running
+            try:
+                loop = asyncio.get_running_loop()
+                # Event loop is running, we need to use a different approach
+                # Create a task that can be run in the current loop
+                import concurrent.futures
+                import threading
+
+                # Use ThreadPoolExecutor to run async code in a separate thread
+                def run_validation():
+                    new_loop = asyncio.new_event_loop()
+                    asyncio.set_event_loop(new_loop)
+                    try:
+                        return new_loop.run_until_complete(self.mcp_integrator.validate_inventory_operations(results))
+                    finally:
+                        new_loop.close()
+
+                with concurrent.futures.ThreadPoolExecutor() as executor:
+                    future = executor.submit(run_validation)
+                    return future.result(timeout=30)  # 30 second timeout
+
+            except RuntimeError:
+                # No event loop running, safe to use asyncio.run()
+                return asyncio.run(self.mcp_integrator.validate_inventory_operations(results))
+
+        except Exception as e:
+            # Create a fallback result with error information
+            class ValidationResult:
+                def to_dict(self):
+                    return {
+                        "error": f"Async validation failed: {str(e)[:100]}",
+                        "validation_skipped": True,
+                        "total_accuracy": 0.0,
+                        "passed_validation": False,
+                    }
+
+            return ValidationResult()
+
     def _collect_parallel(
         self, resource_types: List[str], account_ids: List[str], include_costs: bool
     ) -> Dict[str, Any]:
         """
         Collect inventory in parallel with enhanced performance monitoring.
-        
+
         Follows the same pattern as legacy implementation but with enterprise
         performance monitoring and error handling.
         """
@@ -486,7 +544,7 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
     ) -> Dict[str, Any]:
         """
         Collect inventory sequentially with enhanced error handling.
-        
+
         Follows the same pattern as legacy implementation but with enhanced
         error handling and progress tracking.
         """
@@ -514,16 +572,18 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
     def _collect_resource_for_account(self, resource_type: str, account_id: str, include_costs: bool) -> Dict[str, Any]:
         """
         Collect specific resource type for an account using REAL AWS API calls.
-        
+
         This method makes actual AWS API calls to discover resources, following
         the proven patterns from the existing inventory modules.
         """
         try:
             # Use active profile for AWS API calls
             session = boto3.Session(profile_name=self.active_profile)
-            
-            print_info(f"Collecting {resource_type} resources from account {account_id} using profile {self.active_profile}")
-            
+
+            print_info(
+                f"Collecting {resource_type} resources from account {account_id} using profile {self.active_profile}"
+            )
+
             if resource_type == "ec2":
                 return self._collect_ec2_instances(session, account_id)
             elif resource_type == "rds":
@@ -546,13 +606,13 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
                 print_warning(f"Resource type '{resource_type}' not supported yet")
                 return {
                     "resources": [],
-                    "count": 0, 
+                    "count": 0,
                     "resource_type": resource_type,
                     "account_id": account_id,
                     "collection_timestamp": datetime.now().isoformat(),
-                    "warning": f"Resource type {resource_type} not implemented yet"
+                    "warning": f"Resource type {resource_type} not implemented yet",
                 }
-                
+
         except Exception as e:
             error_msg = f"Failed to collect {resource_type} for account {account_id}: {e}"
             logger.error(error_msg)
@@ -569,13 +629,13 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
         try:
             region = self.region or session.region_name or "us-east-1"
             ec2_client = session.client("ec2", region_name=region)
-            
+
             print_info(f"Calling EC2 describe_instances API for account {account_id} in region {region}")
-            
+
             # Make real AWS API call with pagination support
             instances = []
-            paginator = ec2_client.get_paginator('describe_instances')
-            
+            paginator = ec2_client.get_paginator("describe_instances")
+
             for page in paginator.paginate():
                 for reservation in page.get("Reservations", []):
                     for instance in reservation.get("Instances", []):
@@ -586,7 +646,9 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
                             "state": instance["State"]["Name"],
                             "region": region,
                             "account_id": account_id,
-                            "launch_time": instance.get("LaunchTime", "").isoformat() if instance.get("LaunchTime") else "",
+                            "launch_time": instance.get("LaunchTime", "").isoformat()
+                            if instance.get("LaunchTime")
+                            else "",
                             "availability_zone": instance.get("Placement", {}).get("AvailabilityZone", ""),
                             "vpc_id": instance.get("VpcId", ""),
                             "subnet_id": instance.get("SubnetId", ""),
@@ -594,7 +656,7 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
                             "public_ip_address": instance.get("PublicIpAddress", ""),
                             "public_dns_name": instance.get("PublicDnsName", ""),
                         }
-                        
+
                         # Extract tags
                         tags = {}
                         name = "No Name Tag"
@@ -602,20 +664,20 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
                             tags[tag["Key"]] = tag["Value"]
                             if tag["Key"] == "Name":
                                 name = tag["Value"]
-                        
+
                         instance_data["tags"] = tags
                         instance_data["name"] = name
-                        
+
                         # Extract security groups
                         instance_data["security_groups"] = [
-                            {"group_id": sg["GroupId"], "group_name": sg["GroupName"]} 
+                            {"group_id": sg["GroupId"], "group_name": sg["GroupName"]}
                             for sg in instance.get("SecurityGroups", [])
                         ]
-                        
+
                         instances.append(instance_data)
-            
+
             print_success(f"Found {len(instances)} EC2 instances in account {account_id}")
-            
+
             return {
                 "instances": instances,
                 "count": len(instances),
@@ -623,7 +685,7 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
                 "region": region,
                 "account_id": account_id,
             }
-            
+
         except Exception as e:
             print_error(f"Failed to collect EC2 instances: {e}")
             raise
@@ -633,13 +695,13 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
         try:
             region = self.region or session.region_name or "us-east-1"
             rds_client = session.client("rds", region_name=region)
-            
+
             print_info(f"Calling RDS describe_db_instances API for account {account_id} in region {region}")
-            
+
             # Make real AWS API call with pagination support
             instances = []
-            paginator = rds_client.get_paginator('describe_db_instances')
-            
+            paginator = rds_client.get_paginator("describe_db_instances")
+
             for page in paginator.paginate():
                 for db_instance in page.get("DBInstances", []):
                     instance_data = {
@@ -653,15 +715,19 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
                         "multi_az": db_instance.get("MultiAZ", False),
                         "storage_type": db_instance.get("StorageType", ""),
                         "allocated_storage": db_instance.get("AllocatedStorage", 0),
-                        "endpoint": db_instance.get("Endpoint", {}).get("Address", "") if db_instance.get("Endpoint") else "",
+                        "endpoint": db_instance.get("Endpoint", {}).get("Address", "")
+                        if db_instance.get("Endpoint")
+                        else "",
                         "port": db_instance.get("Endpoint", {}).get("Port", 0) if db_instance.get("Endpoint") else 0,
-                        "vpc_id": db_instance.get("DBSubnetGroup", {}).get("VpcId", "") if db_instance.get("DBSubnetGroup") else "",
+                        "vpc_id": db_instance.get("DBSubnetGroup", {}).get("VpcId", "")
+                        if db_instance.get("DBSubnetGroup")
+                        else "",
                     }
-                    
+
                     instances.append(instance_data)
-            
+
             print_success(f"Found {len(instances)} RDS instances in account {account_id}")
-            
+
             return {
                 "instances": instances,
                 "count": len(instances),
@@ -669,7 +735,7 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
                 "region": region,
                 "account_id": account_id,
             }
-            
+
         except Exception as e:
             print_error(f"Failed to collect RDS instances: {e}")
             raise
@@ -678,20 +744,20 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
         """Collect S3 buckets using real AWS API calls."""
         try:
             s3_client = session.client("s3")
-            
+
             print_info(f"Calling S3 list_buckets API for account {account_id}")
-            
+
             # Make real AWS API call - S3 buckets are global
             response = s3_client.list_buckets()
             buckets = []
-            
+
             for bucket in response.get("Buckets", []):
                 bucket_data = {
                     "name": bucket["Name"],
                     "creation_date": bucket["CreationDate"].isoformat(),
                     "account_id": account_id,
                 }
-                
+
                 # Try to get bucket location (region)
                 try:
                     location_response = s3_client.get_bucket_location(Bucket=bucket["Name"])
@@ -702,7 +768,7 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
                 except Exception as e:
                     logger.warning(f"Could not get location for bucket {bucket['Name']}: {e}")
                     bucket_data["region"] = "unknown"
-                
+
                 # Try to get bucket versioning
                 try:
                     versioning_response = s3_client.get_bucket_versioning(Bucket=bucket["Name"])
@@ -710,18 +776,18 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
                 except Exception as e:
                     logger.warning(f"Could not get versioning for bucket {bucket['Name']}: {e}")
                     bucket_data["versioning"] = "unknown"
-                
+
                 buckets.append(bucket_data)
-            
+
             print_success(f"Found {len(buckets)} S3 buckets in account {account_id}")
-            
+
             return {
                 "buckets": buckets,
                 "count": len(buckets),
                 "collection_timestamp": datetime.now().isoformat(),
                 "account_id": account_id,
             }
-            
+
         except Exception as e:
             print_error(f"Failed to collect S3 buckets: {e}")
             raise
@@ -731,13 +797,13 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
         try:
             region = self.region or session.region_name or "us-east-1"
             lambda_client = session.client("lambda", region_name=region)
-            
+
             print_info(f"Calling Lambda list_functions API for account {account_id} in region {region}")
-            
+
             # Make real AWS API call with pagination support
             functions = []
-            paginator = lambda_client.get_paginator('list_functions')
-            
+            paginator = lambda_client.get_paginator("list_functions")
+
             for page in paginator.paginate():
                 for function in page.get("Functions", []):
                     function_data = {
@@ -753,11 +819,11 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
                         "account_id": account_id,
                         "region": region,
                     }
-                    
+
                     functions.append(function_data)
-            
+
             print_success(f"Found {len(functions)} Lambda functions in account {account_id}")
-            
+
             return {
                 "functions": functions,
                 "count": len(functions),
@@ -765,7 +831,7 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
                 "region": region,
                 "account_id": account_id,
             }
-            
+
         except Exception as e:
             print_error(f"Failed to collect Lambda functions: {e}")
             raise
@@ -774,13 +840,13 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
         """Collect IAM resources using real AWS API calls."""
         try:
             iam_client = session.client("iam")
-            
+
             print_info(f"Calling IAM APIs for account {account_id}")
-            
+
             resources = {"users": [], "roles": [], "policies": [], "groups": []}
-            
+
             # Collect users
-            paginator = iam_client.get_paginator('list_users')
+            paginator = iam_client.get_paginator("list_users")
             for page in paginator.paginate():
                 for user in page.get("Users", []):
                     user_data = {
@@ -792,9 +858,9 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
                         "account_id": account_id,
                     }
                     resources["users"].append(user_data)
-            
+
             # Collect roles
-            paginator = iam_client.get_paginator('list_roles')
+            paginator = iam_client.get_paginator("list_roles")
             for page in paginator.paginate():
                 for role in page.get("Roles", []):
                     role_data = {
@@ -806,17 +872,17 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
                         "account_id": account_id,
                     }
                     resources["roles"].append(role_data)
-            
+
             total_count = len(resources["users"]) + len(resources["roles"])
             print_success(f"Found {total_count} IAM resources in account {account_id}")
-            
+
             return {
                 "resources": resources,
                 "count": total_count,
                 "collection_timestamp": datetime.now().isoformat(),
                 "account_id": account_id,
             }
-            
+
         except Exception as e:
             print_error(f"Failed to collect IAM resources: {e}")
             raise
@@ -826,12 +892,12 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
         try:
             region = self.region or session.region_name or "us-east-1"
             ec2_client = session.client("ec2", region_name=region)
-            
+
             print_info(f"Calling EC2 VPC APIs for account {account_id} in region {region}")
-            
+
             vpcs = []
-            paginator = ec2_client.get_paginator('describe_vpcs')
-            
+            paginator = ec2_client.get_paginator("describe_vpcs")
+
             for page in paginator.paginate():
                 for vpc in page.get("Vpcs", []):
                     vpc_data = {
@@ -843,7 +909,7 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
                         "account_id": account_id,
                         "region": region,
                     }
-                    
+
                     # Extract tags
                     tags = {}
                     name = "No Name Tag"
@@ -851,14 +917,14 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
                         tags[tag["Key"]] = tag["Value"]
                         if tag["Key"] == "Name":
                             name = tag["Value"]
-                    
+
                     vpc_data["tags"] = tags
                     vpc_data["name"] = name
-                    
+
                     vpcs.append(vpc_data)
-            
+
             print_success(f"Found {len(vpcs)} VPCs in account {account_id}")
-            
+
             return {
                 "vpcs": vpcs,
                 "count": len(vpcs),
@@ -866,7 +932,7 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
                 "region": region,
                 "account_id": account_id,
             }
-            
+
         except Exception as e:
             print_error(f"Failed to collect VPC resources: {e}")
             raise
@@ -876,12 +942,12 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
         try:
             region = self.region or session.region_name or "us-east-1"
             cf_client = session.client("cloudformation", region_name=region)
-            
+
             print_info(f"Calling CloudFormation describe_stacks API for account {account_id} in region {region}")
-            
+
             stacks = []
-            paginator = cf_client.get_paginator('describe_stacks')
-            
+            paginator = cf_client.get_paginator("describe_stacks")
+
             for page in paginator.paginate():
                 for stack in page.get("Stacks", []):
                     stack_data = {
@@ -893,14 +959,14 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
                         "account_id": account_id,
                         "region": region,
                     }
-                    
+
                     if "LastUpdatedTime" in stack:
                         stack_data["last_updated_time"] = stack["LastUpdatedTime"].isoformat()
-                    
+
                     stacks.append(stack_data)
-            
+
             print_success(f"Found {len(stacks)} CloudFormation stacks in account {account_id}")
-            
+
             return {
                 "stacks": stacks,
                 "count": len(stacks),
@@ -908,7 +974,7 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
                 "region": region,
                 "account_id": account_id,
             }
-            
+
         except Exception as e:
             print_error(f"Failed to collect CloudFormation stacks: {e}")
             raise
@@ -919,17 +985,17 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
             # Note: Cost Explorer requires specific billing permissions
             print_warning("Cost data collection requires AWS Cost Explorer permissions")
             print_info(f"Attempting to collect cost data for account {account_id}")
-            
+
             # For now, return placeholder - would need billing profile for actual cost data
             return {
                 "monthly_costs": {
                     "note": "Cost data collection requires proper billing permissions and profile",
-                    "suggestion": "Use BILLING_PROFILE environment variable or --profile with billing access"
+                    "suggestion": "Use BILLING_PROFILE environment variable or --profile with billing access",
                 },
                 "account_id": account_id,
                 "collection_timestamp": datetime.now().isoformat(),
             }
-            
+
         except Exception as e:
             print_error(f"Failed to collect cost data: {e}")
             raise
@@ -938,12 +1004,12 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
         """Collect AWS Organizations data using existing organizations discovery module."""
         try:
             print_info(f"Collecting Organizations data for account {account_id}")
-            
+
             # Use the session's profile name for organizations discovery
             profile_name = session.profile_name or self.active_profile
-            
-            org_client = session.client('organizations', region_name='us-east-1')  # Organizations is always us-east-1
-            
+
+            org_client = session.client("organizations", region_name="us-east-1")  # Organizations is always us-east-1
+
             # Collect organization structure and accounts
             organizations_data = {
                 "organization_info": {},
@@ -951,56 +1017,58 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
                 "organizational_units": [],
                 "resource_type": "organizations",
                 "account_id": account_id,
-                "collection_timestamp": datetime.now().isoformat()
+                "collection_timestamp": datetime.now().isoformat(),
             }
-            
+
             try:
                 # Get organization details
                 org_response = org_client.describe_organization()
                 organizations_data["organization_info"] = org_response.get("Organization", {})
-                
+
                 # Get all accounts in the organization
-                paginator = org_client.get_paginator('list_accounts')
+                paginator = org_client.get_paginator("list_accounts")
                 accounts = []
                 for page in paginator.paginate():
-                    accounts.extend(page.get('Accounts', []))
-                
+                    accounts.extend(page.get("Accounts", []))
+
                 organizations_data["accounts"] = accounts
                 organizations_data["count"] = len(accounts)
-                
+
                 # Get organizational units
                 try:
                     roots_response = org_client.list_roots()
-                    for root in roots_response.get('Roots', []):
-                        ou_paginator = org_client.get_paginator('list_organizational_units_for_parent')
-                        for ou_page in ou_paginator.paginate(ParentId=root['Id']):
-                            organizations_data["organizational_units"].extend(ou_page.get('OrganizationalUnits', []))
+                    for root in roots_response.get("Roots", []):
+                        ou_paginator = org_client.get_paginator("list_organizational_units_for_parent")
+                        for ou_page in ou_paginator.paginate(ParentId=root["Id"]):
+                            organizations_data["organizational_units"].extend(ou_page.get("OrganizationalUnits", []))
                 except Exception as ou_e:
                     print_warning(f"Could not collect organizational units: {ou_e}")
                     organizations_data["organizational_units"] = []
-                
+
                 print_success(f"Successfully collected {len(accounts)} accounts from organization")
-                
+
             except Exception as org_e:
                 print_warning(f"Organization data collection limited: {org_e}")
                 # Try to collect at least basic account info if not in an organization
                 try:
-                    sts_client = session.client('sts')
+                    sts_client = session.client("sts")
                     caller_identity = sts_client.get_caller_identity()
-                    organizations_data["accounts"] = [{
-                        "Id": caller_identity.get("Account"),
-                        "Name": f"Account-{caller_identity.get('Account')}",
-                        "Status": "ACTIVE",
-                        "JoinedMethod": "STANDALONE"
-                    }]
+                    organizations_data["accounts"] = [
+                        {
+                            "Id": caller_identity.get("Account"),
+                            "Name": f"Account-{caller_identity.get('Account')}",
+                            "Status": "ACTIVE",
+                            "JoinedMethod": "STANDALONE",
+                        }
+                    ]
                     organizations_data["count"] = 1
                     print_info("Collected standalone account information")
                 except Exception as sts_e:
                     print_error(f"Could not collect account information: {sts_e}")
                     organizations_data["count"] = 0
-            
+
             return organizations_data
-            
+
         except Exception as e:
             print_error(f"Failed to collect organizations data: {e}")
             raise
@@ -1008,7 +1076,7 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
     def _generate_summary(self, resource_data: Dict[str, Any]) -> Dict[str, Any]:
         """
         Generate comprehensive summary statistics from collected data.
-        
+
         Enhanced implementation with better error handling and metrics.
         """
         summary = {
@@ -1022,7 +1090,7 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
                 "failed_collections": 0,
                 "accounts_processed": set(),
                 "resource_types_processed": set(),
-            }
+            },
         }
 
         for resource_type, accounts_data in resource_data.items():
@@ -1031,7 +1099,7 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
 
             for account_id, account_data in accounts_data.items():
                 summary["collection_summary"]["accounts_processed"].add(account_id)
-                
+
                 if "error" in account_data:
                     summary["errors"].append(f"{resource_type}/{account_id}: {account_data['error']}")
                     summary["collection_summary"]["failed_collections"] += 1
@@ -1065,8 +1133,10 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
 
         # Convert sets to lists for JSON serialization
         summary["collection_summary"]["accounts_processed"] = list(summary["collection_summary"]["accounts_processed"])
-        summary["collection_summary"]["resource_types_processed"] = list(summary["collection_summary"]["resource_types_processed"])
-        
+        summary["collection_summary"]["resource_types_processed"] = list(
+            summary["collection_summary"]["resource_types_processed"]
+        )
+
         # Update collection status based on errors
         if summary["errors"]:
             if summary["collection_summary"]["successful_collections"] == 0:
@@ -1075,21 +1145,18 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
                 summary["collection_status"] = "completed_with_errors"
 
         return summary
-    
+
     def export_inventory_results(
-        self, 
-        results: Dict[str, Any], 
-        export_format: str = "json",
-        output_file: Optional[str] = None
+        self, results: Dict[str, Any], export_format: str = "json", output_file: Optional[str] = None
     ) -> str:
         """
         Export inventory results to multiple formats following proven finops patterns.
-        
+
         Args:
             results: Inventory results dictionary
             export_format: Export format (json, csv, markdown, pdf, yaml)
             output_file: Optional output file path
-        
+
         Returns:
             Export file path or formatted string content
         """
@@ -1097,15 +1164,15 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
         import csv
         from datetime import datetime
         from pathlib import Path
-        
+
         # Determine output file path
         if not output_file:
             timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
             output_file = f"/Volumes/Working/1xOps/CloudOps-Runbooks/tmp/inventory_export_{timestamp}.{export_format}"
-        
+
         # Ensure tmp directory exists
         Path(output_file).parent.mkdir(parents=True, exist_ok=True)
-        
+
         try:
             if export_format.lower() == "json":
                 return self._export_json(results, output_file)
@@ -1119,169 +1186,189 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
                 return self._export_pdf(results, output_file)
             else:
                 raise ValueError(f"Unsupported export format: {export_format}")
-                
+
         except Exception as e:
             error_msg = f"Export failed for format {export_format}: {e}"
             print_error(error_msg)
             logger.error(error_msg)
             raise
-    
+
     def _export_json(self, results: Dict[str, Any], output_file: str) -> str:
         """Export results to JSON format."""
-        with open(output_file, 'w') as f:
+        with open(output_file, "w") as f:
             json.dump(results, f, indent=2, default=str)
-        
+
         print_success(f"Inventory exported to JSON: {output_file}")
         return output_file
-    
+
     def _export_csv(self, results: Dict[str, Any], output_file: str) -> str:
         """Export results to CSV format with real AWS data structure."""
         import csv
-        
-        with open(output_file, 'w', newline='') as f:
+
+        with open(output_file, "w", newline="") as f:
             writer = csv.writer(f)
-            
+
             # Write header
             writer.writerow(["Account", "Region", "Resource Type", "Resource ID", "Name", "Status", "Additional Info"])
-            
+
             # Write data rows from real AWS resource structure
             resource_data = results.get("resources", {})
-            
+
             for resource_type, accounts_data in resource_data.items():
                 for account_id, account_data in accounts_data.items():
                     if "error" in account_data:
                         # Handle error cases
-                        writer.writerow([
-                            account_id,
-                            account_data.get("region", "unknown"),
-                            resource_type,
-                            "",
-                            "",
-                            "ERROR",
-                            account_data.get("error", "")
-                        ])
+                        writer.writerow(
+                            [
+                                account_id,
+                                account_data.get("region", "unknown"),
+                                resource_type,
+                                "",
+                                "",
+                                "ERROR",
+                                account_data.get("error", ""),
+                            ]
+                        )
                         continue
-                    
+
                     account_region = account_data.get("region", "unknown")
-                    
+
                     # Handle different resource types with their specific data structures
                     if resource_type == "ec2" and "instances" in account_data:
                         for instance in account_data["instances"]:
-                            writer.writerow([
-                                account_id,
-                                instance.get("region", account_region),
-                                "ec2-instance",
-                                instance.get("instance_id", ""),
-                                instance.get("name", "No Name Tag"),
-                                instance.get("state", ""),
-                                f"Type: {instance.get('instance_type', '')}, AZ: {instance.get('availability_zone', '')}"
-                            ])
-                    
+                            writer.writerow(
+                                [
+                                    account_id,
+                                    instance.get("region", account_region),
+                                    "ec2-instance",
+                                    instance.get("instance_id", ""),
+                                    instance.get("name", "No Name Tag"),
+                                    instance.get("state", ""),
+                                    f"Type: {instance.get('instance_type', '')}, AZ: {instance.get('availability_zone', '')}",
+                                ]
+                            )
+
                     elif resource_type == "rds" and "instances" in account_data:
                         for instance in account_data["instances"]:
-                            writer.writerow([
-                                account_id,
-                                instance.get("region", account_region),
-                                "rds-instance",
-                                instance.get("db_instance_identifier", ""),
-                                instance.get("db_instance_identifier", ""),
-                                instance.get("status", ""),
-                                f"Engine: {instance.get('engine', '')}, Class: {instance.get('instance_class', '')}"
-                            ])
-                    
+                            writer.writerow(
+                                [
+                                    account_id,
+                                    instance.get("region", account_region),
+                                    "rds-instance",
+                                    instance.get("db_instance_identifier", ""),
+                                    instance.get("db_instance_identifier", ""),
+                                    instance.get("status", ""),
+                                    f"Engine: {instance.get('engine', '')}, Class: {instance.get('instance_class', '')}",
+                                ]
+                            )
+
                     elif resource_type == "s3" and "buckets" in account_data:
                         for bucket in account_data["buckets"]:
-                            writer.writerow([
-                                account_id,
-                                bucket.get("region", account_region),
-                                "s3-bucket",
-                                bucket.get("name", ""),
-                                bucket.get("name", ""),
-                                "",
-                                f"Created: {bucket.get('creation_date', '')}"
-                            ])
-                    
+                            writer.writerow(
+                                [
+                                    account_id,
+                                    bucket.get("region", account_region),
+                                    "s3-bucket",
+                                    bucket.get("name", ""),
+                                    bucket.get("name", ""),
+                                    "",
+                                    f"Created: {bucket.get('creation_date', '')}",
+                                ]
+                            )
+
                     elif resource_type == "lambda" and "functions" in account_data:
                         for function in account_data["functions"]:
-                            writer.writerow([
-                                account_id,
-                                function.get("region", account_region),
-                                "lambda-function",
-                                function.get("function_name", ""),
-                                function.get("function_name", ""),
-                                "",
-                                f"Runtime: {function.get('runtime', '')}, Memory: {function.get('memory_size', '')}MB"
-                            ])
-                    
+                            writer.writerow(
+                                [
+                                    account_id,
+                                    function.get("region", account_region),
+                                    "lambda-function",
+                                    function.get("function_name", ""),
+                                    function.get("function_name", ""),
+                                    "",
+                                    f"Runtime: {function.get('runtime', '')}, Memory: {function.get('memory_size', '')}MB",
+                                ]
+                            )
+
                     elif resource_type == "iam" and "resources" in account_data:
                         iam_resources = account_data["resources"]
                         for user in iam_resources.get("users", []):
-                            writer.writerow([
-                                account_id,
-                                "global",
-                                "iam-user",
-                                user.get("user_name", ""),
-                                user.get("user_name", ""),
-                                "",
-                                f"ARN: {user.get('arn', '')}"
-                            ])
+                            writer.writerow(
+                                [
+                                    account_id,
+                                    "global",
+                                    "iam-user",
+                                    user.get("user_name", ""),
+                                    user.get("user_name", ""),
+                                    "",
+                                    f"ARN: {user.get('arn', '')}",
+                                ]
+                            )
                         for role in iam_resources.get("roles", []):
-                            writer.writerow([
-                                account_id,
-                                "global",
-                                "iam-role",
-                                role.get("role_name", ""),
-                                role.get("role_name", ""),
-                                "",
-                                f"ARN: {role.get('arn', '')}"
-                            ])
-                    
+                            writer.writerow(
+                                [
+                                    account_id,
+                                    "global",
+                                    "iam-role",
+                                    role.get("role_name", ""),
+                                    role.get("role_name", ""),
+                                    "",
+                                    f"ARN: {role.get('arn', '')}",
+                                ]
+                            )
+
                     elif resource_type == "vpc" and "vpcs" in account_data:
                         for vpc in account_data["vpcs"]:
-                            writer.writerow([
-                                account_id,
-                                vpc.get("region", account_region),
-                                "vpc",
-                                vpc.get("vpc_id", ""),
-                                vpc.get("name", "No Name Tag"),
-                                vpc.get("state", ""),
-                                f"CIDR: {vpc.get('cidr_block', '')}, Default: {vpc.get('is_default', False)}"
-                            ])
-                    
+                            writer.writerow(
+                                [
+                                    account_id,
+                                    vpc.get("region", account_region),
+                                    "vpc",
+                                    vpc.get("vpc_id", ""),
+                                    vpc.get("name", "No Name Tag"),
+                                    vpc.get("state", ""),
+                                    f"CIDR: {vpc.get('cidr_block', '')}, Default: {vpc.get('is_default', False)}",
+                                ]
+                            )
+
                     elif resource_type == "cloudformation" and "stacks" in account_data:
                         for stack in account_data["stacks"]:
-                            writer.writerow([
-                                account_id,
-                                stack.get("region", account_region),
-                                "cloudformation-stack",
-                                stack.get("stack_name", ""),
-                                stack.get("stack_name", ""),
-                                stack.get("stack_status", ""),
-                                f"Created: {stack.get('creation_time', '')}"
-                            ])
-                    
+                            writer.writerow(
+                                [
+                                    account_id,
+                                    stack.get("region", account_region),
+                                    "cloudformation-stack",
+                                    stack.get("stack_name", ""),
+                                    stack.get("stack_name", ""),
+                                    stack.get("stack_status", ""),
+                                    f"Created: {stack.get('creation_time', '')}",
+                                ]
+                            )
+
                     # Handle cases where no specific resources were found but collection was successful
                     elif account_data.get("count", 0) == 0:
-                        writer.writerow([
-                            account_id,
-                            account_region,
-                            resource_type,
-                            "",
-                            "",
-                            "NO_RESOURCES",
-                            f"No {resource_type} resources found"
-                        ])
-        
+                        writer.writerow(
+                            [
+                                account_id,
+                                account_region,
+                                resource_type,
+                                "",
+                                "",
+                                "NO_RESOURCES",
+                                f"No {resource_type} resources found",
+                            ]
+                        )
+
         print_success(f"Inventory exported to CSV: {output_file}")
         return output_file
-    
+
     def _export_markdown(self, results: Dict[str, Any], output_file: str) -> str:
         """Export results to Markdown format with tables."""
         content = []
         content.append("# AWS Inventory Report")
         content.append(f"Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
         content.append("")
-        
+
         # Summary section
         total_resources = sum(
             len(resources)
@@ -1289,30 +1376,32 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
             for region_data in account_data.get("regions", {}).values()
             for resources in region_data.get("resources", {}).values()
         )
-        
+
         content.append("## Summary")
         content.append(f"- Total Accounts: {len(results.get('accounts', {}))}")
         content.append(f"- Total Resources: {total_resources}")
         content.append("")
-        
+
         # Detailed inventory
         content.append("## Detailed Inventory")
         content.append("")
         content.append("| Account | Region | Resource Type | Resource ID | Name | Status |")
         content.append("|---------|--------|---------------|-------------|------|--------|")
-        
+
         for account_id, account_data in results.get("accounts", {}).items():
             for region, region_data in account_data.get("regions", {}).items():
                 for resource_type, resources in region_data.get("resources", {}).items():
                     for resource in resources:
-                        content.append(f"| {account_id} | {region} | {resource_type} | {resource.get('id', '')} | {resource.get('name', '')} | {resource.get('state', '')} |")
-        
-        with open(output_file, 'w') as f:
-            f.write('\n'.join(content))
-        
+                        content.append(
+                            f"| {account_id} | {region} | {resource_type} | {resource.get('id', '')} | {resource.get('name', '')} | {resource.get('state', '')} |"
+                        )
+
+        with open(output_file, "w") as f:
+            f.write("\n".join(content))
+
         print_success(f"Inventory exported to Markdown: {output_file}")
         return output_file
-    
+
     def _export_yaml(self, results: Dict[str, Any], output_file: str) -> str:
         """Export results to YAML format."""
         try:
@@ -1320,13 +1409,13 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
         except ImportError:
             print_error("PyYAML not available. Install with: pip install pyyaml")
             raise
-        
-        with open(output_file, 'w') as f:
+
+        with open(output_file, "w") as f:
             yaml.dump(results, f, default_flow_style=False, sort_keys=False)
-        
+
         print_success(f"Inventory exported to YAML: {output_file}")
         return output_file
-    
+
     def _export_pdf(self, results: Dict[str, Any], output_file: str) -> str:
         """Export results to executive PDF report."""
         try:
@@ -1338,43 +1427,39 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
         except ImportError:
             # Graceful fallback to markdown if reportlab not available
             print_warning("ReportLab not available, exporting to markdown instead")
-            return self._export_markdown(results, output_file.replace('.pdf', '.md'))
-        
+            return self._export_markdown(results, output_file.replace(".pdf", ".md"))
+
         doc = SimpleDocTemplate(output_file, pagesize=A4)
         styles = getSampleStyleSheet()
         story = []
-        
+
         # Title
         title_style = ParagraphStyle(
-            'CustomTitle',
-            parent=styles['Heading1'],
-            fontSize=24,
-            spaceAfter=30,
-            textColor=colors.darkblue
+            "CustomTitle", parent=styles["Heading1"], fontSize=24, spaceAfter=30, textColor=colors.darkblue
         )
         story.append(Paragraph("AWS Inventory Report", title_style))
         story.append(Spacer(1, 20))
-        
+
         # Executive Summary
-        story.append(Paragraph("Executive Summary", styles['Heading2']))
-        
+        story.append(Paragraph("Executive Summary", styles["Heading2"]))
+
         total_resources = sum(
             len(resources)
             for account_data in results.get("accounts", {}).values()
             for region_data in account_data.get("regions", {}).values()
             for resources in region_data.get("resources", {}).values()
         )
-        
+
         summary_text = f"""
-        This report provides a comprehensive inventory of AWS resources across {len(results.get('accounts', {}))} accounts.
+        This report provides a comprehensive inventory of AWS resources across {len(results.get("accounts", {}))} accounts.
         A total of {total_resources} resources were discovered and catalogued.
         """
-        story.append(Paragraph(summary_text, styles['Normal']))
+        story.append(Paragraph(summary_text, styles["Normal"]))
         story.append(Spacer(1, 20))
-        
+
         # Build the PDF
         doc.build(story)
-        
+
         print_success(f"Inventory exported to PDF: {output_file}")
         return output_file
 
@@ -1492,7 +1577,7 @@ class InventoryCollector(EnhancedInventoryCollector):
                     "instances": [],  # Replace with real EC2 API response processing
                     "count": 0,
                     "account_id": account_id,
-                    "region": self.region or "us-east-1"
+                    "region": self.region or "us-east-1",
                 }
             elif resource_type == "rds":
                 # TODO: Implement real RDS API call
@@ -1502,7 +1587,7 @@ class InventoryCollector(EnhancedInventoryCollector):
                     "instances": [],  # Replace with real RDS API response processing
                     "count": 0,
                     "account_id": account_id,
-                    "region": self.region or "us-east-1"
+                    "region": self.region or "us-east-1",
                 }
             elif resource_type == "s3":
                 # TODO: Implement real S3 API call
@@ -1512,16 +1597,11 @@ class InventoryCollector(EnhancedInventoryCollector):
                     "buckets": [],  # Replace with real S3 API response processing
                     "count": 0,
                     "account_id": account_id,
-                    "region": self.region or "us-east-1"
+                    "region": self.region or "us-east-1",
                 }
         except Exception as e:
             # Proper error handling for AWS API failures
-            return {
-                "error": str(e),
-                "resource_type": resource_type,
-                "account_id": account_id,
-                "count": 0
-            }
+            return {"error": str(e), "resource_type": resource_type, "account_id": account_id, "count": 0}
         else:
             return {"resources": [], "count": 0, "resource_type": resource_type, "account_id": account_id}
 
@@ -1671,3 +1751,105 @@ class InventoryCollector(EnhancedInventoryCollector):
         status = "enabled" if enable else "disabled"
         print_info(f"Cross-module integration {status}")
         logger.info(f"Cross-module integration {status} for inventory collector")
+
+
+# Aliases for backward compatibility
+ResourceCollector = InventoryCollector
+CollectionResult = dict  # Simple dict for now
+CollectionError = Exception  # Simple exception for now
+
+
+def run_inventory_collection(**kwargs) -> Dict[str, Any]:
+    """
+    CLI wrapper function for inventory collection.
+
+    Provides a simple function interface to the InventoryCollector class
+    for CLI command integration.
+
+    Args:
+        **kwargs: All arguments passed to InventoryCollector and collect_inventory
+
+    Returns:
+        Dict containing inventory results
+    """
+    # Extract initialization parameters
+    profile = kwargs.pop("profile", None)
+    region = kwargs.pop("region", "us-east-1")
+    dry_run = kwargs.pop("dry_run", False)
+    all_regions = kwargs.pop("all_regions", False)
+
+    # Extract collection parameters
+    resources = kwargs.pop("resources", ())
+    all_resources = kwargs.pop("all_resources", False)
+    all_profiles = kwargs.pop("all_profiles", False)
+    include_costs = kwargs.pop("include_costs", False)
+    include_security = kwargs.pop("include_security", False)
+    include_cost_recommendations = kwargs.pop("include_cost_recommendations", False)
+    parallel = kwargs.pop("parallel", True)
+    validate = kwargs.pop("validate", False)
+    validate_all = kwargs.pop("validate_all", False)
+
+    # Extract export parameters
+    export_formats = kwargs.pop("export_formats", [])
+    output_dir = kwargs.pop("output_dir", "./awso_evidence")
+    report_name = kwargs.pop("report_name", None)
+
+    # Remaining kwargs (all, combine, etc.)
+    use_all_profiles = kwargs.pop("all", False) or all_profiles
+    combine_results = kwargs.pop("combine", False)
+
+    # Initialize collector
+    collector = InventoryCollector(profile=profile, region=region, parallel=parallel)
+
+    # Enable MCP validation if requested
+    if validate or validate_all:
+        collector.enable_mcp_validation = True
+
+    # Determine resource types
+    resource_types = list(resources) if resources else None
+    if all_resources:
+        resource_types = None  # None means all resources
+
+    # Determine regions
+    regions_to_scan = [region]
+    if all_regions:
+        # Get all enabled regions from AWS
+        try:
+            import boto3
+
+            session = boto3.Session(profile_name=profile) if profile else boto3.Session()
+            ec2 = session.client("ec2", region_name=region)
+            all_regions_response = ec2.describe_regions(AllRegions=False)
+            regions_to_scan = [r["RegionName"] for r in all_regions_response["Regions"]]
+        except Exception as e:
+            logger.warning(f"Failed to get all regions, using {region}: {e}")
+            regions_to_scan = [region]
+
+    # Determine account IDs
+    account_ids = [collector.get_current_account_id()]
+    if use_all_profiles:
+        try:
+            account_ids = collector.get_organization_accounts()
+        except Exception as e:
+            logger.warning(f"Failed to get organization accounts: {e}")
+
+    # Collect inventory
+    try:
+        results = collector.collect_inventory(
+            resource_types=resource_types or collector.get_all_resource_types(),
+            account_ids=account_ids,
+            include_costs=include_costs,
+        )
+
+        # Export if requested
+        if export_formats and export_formats != ["table"]:
+            export_results = collector.export_inventory_results(
+                results=results, formats=export_formats, output_dir=output_dir, report_name=report_name
+            )
+            results["exports"] = export_results
+
+        return results
+
+    except Exception as e:
+        logger.error(f"Inventory collection failed: {e}")
+        raise