runbooks 0.7.9__py3-none-any.whl → 0.9.0__py3-none-any.whl

runbooks/finops/tests/test_reference_images_validation.py

@@ -45,7 +45,7 @@ class TestReferenceImage1_CostAnalysisDashboard:
     Test Case 1: Cost Analysis Dashboard Validation
 
     Validates the multi-account cost trending dashboard functionality
-    corresponding to aws-finops-dashboard reference images.
+    corresponding to runbooks finops reference images.
 
     Expected Output Characteristics:
     - Multi-account cost trends with $152,991.07 baseline

runbooks/inventory/README.md

@@ -1,4 +1,15 @@
-# AWS Cloud Foundations Inventory Scripts
+# AWS Multi-Account Discovery & Inventory (CLI)
+
+The AWS Multi-Account Discovery module is an enterprise-grade command-line tool for comprehensive AWS resource discovery across 50+ services. Built with the Rich library for beautiful terminal output, it provides multi-threaded inventory collection with enterprise-grade error handling and reporting.
+
+## 📈 *inventory-runbooks*.md Enterprise Rollout
+
+Following proven **99/100 manager score** success patterns established in FinOps:
+
+### **Rollout Strategy**: Progressive *-runbooks*.md standardization 
+- **Phase 2**: Inventory rollout with *inventory-runbooks*.md patterns ✅
+- **Current Success Rate**: 37/46 scripts (80.4%) ✅ 
+- **Integration**: Complete multi-account discovery framework
 
 ## ✅ **Current Success Rate (v0.6.1): 37/46 scripts (80.4%)**
 

runbooks/inventory/core/collector.py

@@ -7,9 +7,10 @@ cloud foundations best practices.
 
 ENHANCED v0.8.0: 4-Profile AWS SSO Architecture & Performance Benchmarking
 - Proven FinOps success patterns: 61 accounts, $474,406 validated
-- Performance targets: <45s for inventory discovery operations  
+- Performance targets: <45s for inventory discovery operations
 - Comprehensive error handling with profile fallbacks
 - Enterprise-grade reliability and monitoring
+- Phase 4: MCP Integration Framework & Cross-Module Data Flow
 """
 
 import asyncio
@@ -20,11 +21,16 @@ from typing import Any, Dict, List, Optional, Set
 from loguru import logger
 
 from runbooks.base import CloudFoundationsBase, ProgressTracker
+from runbooks.common.cross_module_integration import DataFlowType, EnterpriseCrossModuleIntegrator
+from runbooks.common.mcp_integration import EnterpriseMCPIntegrator, MCPOperationType
+from runbooks.common.profile_utils import create_management_session, get_profile_for_operation
+from runbooks.common.rich_utils import console, print_error, print_info, print_success, print_warning
 from runbooks.config import RunbooksConfig
 
 # Import the enhanced 4-profile architecture from organizations discovery
 try:
     from ..organizations_discovery import ENTERPRISE_PROFILES, PerformanceBenchmark
+
     ENHANCED_PROFILES_AVAILABLE = True
 except ImportError:
     ENHANCED_PROFILES_AVAILABLE = False
@@ -33,7 +39,7 @@ except ImportError:
         "BILLING_PROFILE": "ams-admin-Billing-ReadOnlyAccess-909135376185",
         "MANAGEMENT_PROFILE": "ams-admin-ReadOnlyAccess-909135376185",
         "CENTRALISED_OPS_PROFILE": "ams-centralised-ops-ReadOnlyAccess-335083429030",
-        "SINGLE_ACCOUNT_PROFILE": "ams-shared-services-non-prod-ReadOnlyAccess-499201730520"
+        "SINGLE_ACCOUNT_PROFILE": "ams-shared-services-non-prod-ReadOnlyAccess-499201730520",
     }
 
 
@@ -44,7 +50,7 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
     Orchestrates resource discovery across multiple accounts and regions,
     providing comprehensive inventory capabilities with enterprise-grade
     reliability and performance monitoring.
-    
+
     Features:
     - 4-profile AWS SSO architecture with failover
     - Performance benchmarking targeting <45s operations
@@ -63,7 +69,7 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
     ):
         """
         Initialize enhanced inventory collector with 4-profile architecture.
-        
+
         Args:
             profile: Primary AWS profile (overrides enterprise profile selection)
             region: AWS region
@@ -76,34 +82,38 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
         self.parallel = parallel
         self.use_enterprise_profiles = use_enterprise_profiles
         self.performance_target_seconds = performance_target_seconds
-        
+
         # Performance benchmarking
         self.benchmarks = []
         self.current_benchmark = None
-        
+
         # Enhanced profile management
         self.available_profiles = self._initialize_profile_architecture()
-        
+
         # Resource collectors
         self._resource_collectors = self._initialize_collectors()
-        
+
+        # Phase 4: MCP Integration Framework
+        self.mcp_integrator = EnterpriseMCPIntegrator(profile)
+        self.cross_module_integrator = EnterpriseCrossModuleIntegrator(profile)
+        self.enable_mcp_validation = True
+
+        print_info("Enhanced inventory collector with MCP integration initialized")
         logger.info(f"Enhanced inventory collector initialized with {len(self.available_profiles)} profiles")
 
     def run(self, **kwargs) -> Dict[str, Any]:
         """
         Main execution method for enhanced inventory collector.
-        
+
         This method provides the required abstract method implementation
         and serves as the primary entry point for inventory operations.
         """
-        resource_types = kwargs.get('resource_types', ['ec2', 's3'])
-        account_ids = kwargs.get('account_ids', [self.get_current_account_id()])
-        include_costs = kwargs.get('include_costs', False)
-        
+        resource_types = kwargs.get("resource_types", ["ec2", "s3"])
+        account_ids = kwargs.get("account_ids", [self.get_current_account_id()])
+        include_costs = kwargs.get("include_costs", False)
+
         return self.collect_inventory(
-            resource_types=resource_types,
-            account_ids=account_ids,
-            include_costs=include_costs
+            resource_types=resource_types, account_ids=account_ids, include_costs=include_costs
         )
 
     def _initialize_profile_architecture(self) -> Dict[str, str]:
@@ -113,11 +123,9 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
             logger.info("Using proven enterprise 4-profile AWS SSO architecture")
         else:
             # Fallback to single profile or provided profile
-            profiles = {
-                "PRIMARY_PROFILE": self.profile or "default"
-            }
+            profiles = {"PRIMARY_PROFILE": self.profile or "default"}
             logger.info(f"Using single profile architecture: {profiles['PRIMARY_PROFILE']}")
-        
+
         return profiles
 
     def _initialize_collectors(self) -> Dict[str, str]:
@@ -178,16 +186,16 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
         Returns:
             Dictionary containing inventory results with performance metrics
         """
-        
+
         # Start performance benchmark
         if ENHANCED_PROFILES_AVAILABLE:
             self.current_benchmark = PerformanceBenchmark(
                 operation_name="inventory_collection",
                 start_time=datetime.now(timezone.utc),
                 target_seconds=self.performance_target_seconds,
-                accounts_processed=len(account_ids)
+                accounts_processed=len(account_ids),
             )
-        
+
         logger.info(
             f"Starting enhanced inventory collection for {len(resource_types)} resource types across {len(account_ids)} accounts"
         )
@@ -220,6 +228,23 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
             results["resources"] = resource_data
             results["summary"] = self._generate_summary(resource_data)
 
+            # Phase 4: MCP Validation Integration
+            if self.enable_mcp_validation:
+                try:
+                    print_info("Validating inventory results with MCP integration")
+                    validation_result = asyncio.run(self.mcp_integrator.validate_inventory_operations(results))
+
+                    results["mcp_validation"] = validation_result.to_dict()
+
+                    if validation_result.success:
+                        print_success(f"MCP validation passed: {validation_result.accuracy_score}% accuracy")
+                    else:
+                        print_warning("MCP validation encountered issues - results may need review")
+
+                except Exception as e:
+                    print_warning(f"MCP validation failed: {str(e)[:50]}... - continuing without validation")
+                    results["mcp_validation"] = {"error": str(e), "validation_skipped": True}
+
             # Complete performance benchmark
             end_time = datetime.now()
             duration = (end_time - start_time).total_seconds()
@@ -228,7 +253,7 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
             if self.current_benchmark:
                 self.current_benchmark.finish(success=True)
                 self.benchmarks.append(self.current_benchmark)
-                
+
                 # Add performance metrics
                 results["performance_benchmark"] = {
                     "duration_seconds": self.current_benchmark.duration_seconds,
@@ -237,7 +262,7 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
                     "target_seconds": self.current_benchmark.target_seconds,
                     "accounts_processed": self.current_benchmark.accounts_processed,
                 }
-                
+
                 performance_color = "🟢" if self.current_benchmark.is_within_target() else "🟡"
                 logger.info(
                     f"Enhanced inventory collection completed in {duration:.1f}s "
@@ -251,19 +276,19 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
         except Exception as e:
             error_msg = f"Enhanced inventory collection failed: {e}"
             logger.error(error_msg)
-            
+
             # Complete benchmark with failure
             if self.current_benchmark:
                 self.current_benchmark.finish(success=False, error_message=error_msg)
                 self.benchmarks.append(self.current_benchmark)
-                
+
                 results["performance_benchmark"] = {
                     "duration_seconds": self.current_benchmark.duration_seconds,
                     "performance_grade": "F",
                     "target_achieved": False,
                     "error_message": error_msg,
                 }
-            
+
             results["errors"].append(error_msg)
             return results
 
@@ -272,7 +297,7 @@ class EnhancedInventoryCollector(CloudFoundationsBase):
 class InventoryCollector(EnhancedInventoryCollector):
     """
     Legacy InventoryCollector - redirects to EnhancedInventoryCollector for backward compatibility.
-    
+
     This maintains existing API compatibility while leveraging enhanced capabilities.
     """
 
@@ -460,3 +485,106 @@ class InventoryCollector(EnhancedInventoryCollector):
         resource_types = ["ec2", "rds", "s3"]
         account_ids = [self.get_current_account_id()]
         return self.collect_inventory(resource_types, account_ids)
+
+    # Phase 4: Cross-Module Integration Methods
+    async def prepare_data_for_operate_module(self, inventory_results: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Prepare inventory data for seamless integration with operate module.
+
+        This method transforms inventory results into a format optimized for
+        operational workflows, enabling inventory → operate data flow.
+
+        Args:
+            inventory_results: Results from inventory collection
+
+        Returns:
+            Dict formatted for operate module consumption
+        """
+        try:
+            print_info("Preparing inventory data for operate module integration")
+
+            data_flow_result = await self.cross_module_integrator.execute_data_flow(
+                flow_type=DataFlowType.INVENTORY_TO_OPERATE, source_data=inventory_results
+            )
+
+            if data_flow_result.success:
+                print_success("Inventory → Operate data flow completed successfully")
+                return data_flow_result.transformed_data
+            else:
+                print_error(f"Data flow failed: {', '.join(data_flow_result.error_details)}")
+                return {}
+
+        except Exception as e:
+            print_error(f"Failed to prepare data for operate module: {str(e)}")
+            return {}
+
+    async def collect_inventory_with_operate_integration(
+        self,
+        resource_types: List[str],
+        account_ids: List[str],
+        include_costs: bool = False,
+        prepare_for_operations: bool = False,
+    ) -> Dict[str, Any]:
+        """
+        Enhanced inventory collection with automatic operate module preparation.
+
+        This method extends the standard inventory collection to automatically
+        prepare data for operational workflows when requested.
+
+        Args:
+            resource_types: List of resource types to collect
+            account_ids: List of account IDs to scan
+            include_costs: Whether to include cost information
+            prepare_for_operations: Whether to prepare data for operate module
+
+        Returns:
+            Dictionary containing inventory results and optional operate preparation
+        """
+        # Standard inventory collection
+        results = self.collect_inventory(resource_types, account_ids, include_costs)
+
+        # Optional operate module preparation
+        if prepare_for_operations:
+            operate_data = await self.prepare_data_for_operate_module(results)
+            results["operate_integration"] = {
+                "prepared_data": operate_data,
+                "integration_timestamp": datetime.now().isoformat(),
+                "operation_targets": operate_data.get("operation_targets", []),
+            }
+
+            print_success(f"Inventory collection with operate integration complete")
+
+        return results
+
+    def get_mcp_validation_status(self) -> Dict[str, Any]:
+        """
+        Get current MCP validation configuration and status.
+
+        Returns:
+            Dictionary containing MCP integration status
+        """
+        return {
+            "mcp_validation_enabled": self.enable_mcp_validation,
+            "mcp_integrator_initialized": self.mcp_integrator is not None,
+            "cross_module_integrator_initialized": self.cross_module_integrator is not None,
+            "supported_data_flows": [flow.value for flow in DataFlowType],
+            "supported_mcp_operations": [op.value for op in MCPOperationType],
+        }
+
+    def enable_cross_module_integration(self, enable: bool = True) -> None:
+        """
+        Enable or disable cross-module integration features.
+
+        Args:
+            enable: Whether to enable cross-module integration
+        """
+        if enable and (self.mcp_integrator is None or self.cross_module_integrator is None):
+            print_warning("Initializing MCP and cross-module integrators")
+            self.mcp_integrator = EnterpriseMCPIntegrator(self.profile)
+            self.cross_module_integrator = EnterpriseCrossModuleIntegrator(self.profile)
+
+        self.enable_mcp_validation = enable
+
+        status = "enabled" if enable else "disabled"
+        print_info(f"Cross-module integration {status}")
+        logger.info(f"Cross-module integration {status} for inventory collector")

runbooks/inventory/list_ec2_instances.py

@@ -375,13 +375,15 @@ if __name__ == "__main__":
 
     # Import Rich display utilities for professional output
     from runbooks.inventory.rich_inventory_display import (
-        display_inventory_header,
         create_inventory_progress,
-        display_ec2_inventory_results
+        display_ec2_inventory_results,
+        display_inventory_header,
     )
-    
+
     # Display professional inventory header
-    display_inventory_header("EC2", pProfiles, AccountNum if 'AccountNum' in locals() else 0, RegionNum if 'RegionNum' in locals() else 0)
+    display_inventory_header(
+        "EC2", pProfiles, AccountNum if "AccountNum" in locals() else 0, RegionNum if "RegionNum" in locals() else 0
+    )
 
     # Find credentials for all Child Accounts
     # CredentialList = get_credentials(pProfiles, pRegionList, pSkipProfiles, pSkipAccounts, pRootOnly, pAccounts, pAccessRoles, pTiming)
@@ -390,13 +392,14 @@ if __name__ == "__main__":
     )
     AccountNum = len(set([acct["AccountId"] for acct in CredentialList]))
     RegionNum = len(set([acct["Region"] for acct in CredentialList]))
-    
+
     # Update header with actual counts
     display_inventory_header("EC2", pProfiles, AccountNum, RegionNum)
-    
+
     if pTiming:
         milestone_time1 = time()
         from runbooks.common.rich_utils import print_info
+
         print_info(f"⏱️ Credential discovery completed in {(milestone_time1 - begin_time):.3f} seconds")
     # Collect all the instances from the credentials found
     AllInstances = find_all_instances(CredentialList, pStatus)

runbooks/inventory/list_ssm_parameters.py

@@ -213,21 +213,21 @@ def find_ssm_parameters(f_credentialList):
     """
     parameter_list = []
     # Import Rich display utilities for professional output
-    from runbooks.inventory.rich_inventory_display import display_inventory_header, create_inventory_progress
-    from runbooks.common.rich_utils import console, print_success, print_info
-    
+    from runbooks.common.rich_utils import console, print_info, print_success
+    from runbooks.inventory.rich_inventory_display import create_inventory_progress, display_inventory_header
+
     # Calculate operation scope
     account_count = len(set([cred["AccountId"] for cred in f_credentialList]))
     region_count = len(set([cred["Region"] for cred in f_credentialList]))
-    
+
     # Display professional header
     display_inventory_header("SSM Parameters", "multi-profile", account_count, region_count)
-    
+
     # Create Rich progress bar
     progress = create_inventory_progress(len(f_credentialList), "🔑 Discovering SSM Parameters")
     task = progress.add_task("Processing credentials", total=len(f_credentialList))
     progress.start()
-    
+
     for credential in f_credentialList:
         try:
             # Call SSM API to discover all parameters in this account/region combination
@@ -246,12 +246,12 @@ def find_ssm_parameters(f_credentialList):
         finally:
             # Update progress
             progress.update(task, advance=1)
-    
+
     progress.stop()
-    
+
     # Display completion summary
     print_success(f"✅ SSM Parameter discovery completed! Found {len(parameter_list)} parameters total")
-    
+
     return parameter_list
 
 
@@ -297,7 +297,7 @@ if __name__ == "__main__":
     ALZRegex = r"/\w{8,8}-\w{4,4}-\w{4,4}-\w{4,4}-\w{12,12}/\w{3,3}"
     # Import Rich utilities at module level
     from runbooks.common.rich_utils import console, print_header
-    
+
     # Display module header
     print_header("SSM Parameter Store Discovery", "0.7.8")