runbooks 0.9.1__py3-none-any.whl → 0.9.4__py3-none-any.whl

runbooks/remediation/workspaces_list.py

@@ -1,18 +1,72 @@
 """
 🚨 HIGH-RISK: WorkSpaces Management - Analyze and manage WorkSpaces with deletion capabilities.
+
+JIRA AWSO-24: Enhanced WorkSpaces cleanup with cost calculation for $12,518 annual savings
+Accounts: 339712777494, 802669565615, 142964829704, 507583929055
+Types: STANDARD, PERFORMANCE, VALUE in AUTO_STOP mode
 """
 
 import logging
 from datetime import datetime, timedelta, timezone
+from typing import Dict, List, Optional
 
 import click
 from botocore.exceptions import ClientError
 
 from .commons import display_aws_account_info, get_client, write_to_csv
+from ..common.rich_utils import (
+    console, print_header, print_success, print_error, print_warning,
+    create_table, create_progress_bar, format_cost
+)
 
 logger = logging.getLogger(__name__)
 
 
+def calculate_workspace_monthly_cost(workspace_bundle_id: str, running_mode: str) -> float:
+    """
+    Calculate monthly cost for WorkSpace based on bundle and running mode.
+    
+    JIRA AWSO-24: Cost calculations for $12,518 annual savings target
+    Based on AWS WorkSpaces pricing: https://aws.amazon.com/workspaces/pricing/
+    """
+    # WorkSpaces pricing by bundle type (monthly USD)
+    bundle_costs = {
+        # Value bundles
+        "wsb-bh8rsxt14": {"name": "Value", "monthly": 25.0, "hourly": 0.22},  # Windows 10 Value
+        "wsb-3t36q8qkj": {"name": "Value", "monthly": 25.0, "hourly": 0.22},  # Amazon Linux 2 Value
+        
+        # Standard bundles  
+        "wsb-92tn3b7gx": {"name": "Standard", "monthly": 35.0, "hourly": 0.50},  # Windows 10 Standard
+        "wsb-2bs6k5lgj": {"name": "Standard", "monthly": 35.0, "hourly": 0.50},  # Amazon Linux 2 Standard
+        
+        # Performance bundles
+        "wsb-gk1wpk43z": {"name": "Performance", "monthly": 68.0, "hourly": 0.85},  # Windows 10 Performance
+        "wsb-1b5w6vnzg": {"name": "Performance", "monthly": 68.0, "hourly": 0.85},  # Amazon Linux 2 Performance
+        
+        # PowerPro bundles
+        "wsb-8vbljg4r6": {"name": "PowerPro", "monthly": 134.0, "hourly": 1.50},  # Windows 10 PowerPro
+        "wsb-vbljg4r61": {"name": "PowerPro", "monthly": 134.0, "hourly": 1.50},  # Amazon Linux 2 PowerPro
+        
+        # Graphics bundles
+        "wsb-1pzkp0bx8": {"name": "Graphics", "monthly": 144.0, "hourly": 1.75},  # Windows 10 Graphics
+        "wsb-pszkp0bx9": {"name": "Graphics", "monthly": 144.0, "hourly": 1.75},  # Amazon Linux 2 Graphics
+    }
+    
+    # Get bundle info or use default
+    bundle_info = bundle_costs.get(workspace_bundle_id, {"name": "Standard", "monthly": 35.0, "hourly": 0.50})
+    
+    # Calculate cost based on running mode
+    if running_mode.upper() == "AUTO_STOP":
+        # Auto-stop: Pay monthly fee + hourly usage (simplified to monthly for unused)
+        return bundle_info["monthly"]
+    elif running_mode.upper() == "ALWAYS_ON":
+        # Always-on: Pay monthly fee only
+        return bundle_info["monthly"]
+    else:
+        # Unknown mode, use monthly
+        return bundle_info["monthly"]
+
+
 def get_workspace_usage_by_hours(workspace_id, start_time, end_time):
     """Get WorkSpace usage hours from CloudWatch metrics."""
     try:
@@ -44,30 +98,43 @@ def get_workspace_usage_by_hours(workspace_id, start_time, end_time):
 @click.option("--delete-unused", is_flag=True, help="🚨 HIGH-RISK: Delete unused WorkSpaces")
 @click.option("--unused-days", default=90, help="Days threshold for considering WorkSpace unused")
 @click.option("--confirm", is_flag=True, help="Skip confirmation prompts (dangerous!)")
+@click.option("--calculate-savings", is_flag=True, help="Calculate cost savings for cleanup")
+@click.option("--analyze", is_flag=True, help="Perform detailed cost analysis")
+@click.option("--dry-run", is_flag=True, default=True, help="Preview actions without execution")
 def get_workspaces(
     output_file: str = "/tmp/workspaces.csv",
     days: int = 30,
     delete_unused: bool = False,
     unused_days: int = 90,
     confirm: bool = False,
+    calculate_savings: bool = False,
+    analyze: bool = False,
+    dry_run: bool = True,
 ):
-    """🚨 HIGH-RISK: Analyze WorkSpaces usage and optionally delete unused ones."""
-
+    """
+    🚨 HIGH-RISK: Analyze WorkSpaces usage and optionally delete unused ones.
+    
+    JIRA AWSO-24: Enhanced WorkSpaces cleanup with cost calculation for $12,518 annual savings
+    """
+
+    print_header("WorkSpaces Cost Optimization Analysis", "v0.9.1")
+    
     # HIGH-RISK OPERATION WARNING
     if delete_unused and not confirm:
-        logger.warning("🚨 HIGH-RISK OPERATION: WorkSpace deletion")
-        logger.warning("This operation will permanently delete WorkSpaces and all user data")
+        print_warning("🚨 HIGH-RISK OPERATION: WorkSpace deletion")
+        print_warning("This operation will permanently delete WorkSpaces and all user data")
         if not click.confirm("Do you want to continue?"):
-            logger.info("Operation cancelled by user")
+            print_error("Operation cancelled by user")
             return
 
-    logger.info(f"Analyzing WorkSpaces in {display_aws_account_info()}")
+    account_info = display_aws_account_info()
+    console.print(f"[cyan]Analyzing WorkSpaces in {account_info}[/cyan]")
 
     try:
         ws_client = get_client("workspaces")
 
-        # Get all WorkSpaces
-        logger.info("Collecting WorkSpaces data...")
+        # Get all WorkSpaces with progress bar
+        console.print("[yellow]Collecting WorkSpaces data...[/yellow]")
         paginator = ws_client.get_paginator("describe_workspaces")
         data = []
 
@@ -76,19 +143,29 @@ def get_workspaces(
         start_time = end_time - timedelta(days=days)
         unused_threshold = end_time - timedelta(days=unused_days)
 
-        logger.info(f"Analyzing usage from {start_time.strftime('%Y-%m-%d')} to {end_time.strftime('%Y-%m-%d')}")
+        console.print(f"[dim]Analyzing usage from {start_time.strftime('%Y-%m-%d')} to {end_time.strftime('%Y-%m-%d')}[/dim]")
 
-        total_workspaces = 0
+        # Collect all workspaces first for progress tracking
+        all_workspaces = []
         for page in paginator.paginate():
             workspaces = page.get("Workspaces", [])
-            total_workspaces += len(workspaces)
-
-            for workspace in workspaces:
+            all_workspaces.extend(workspaces)
+
+        total_cost = 0.0
+        unused_cost = 0.0
+        
+        with create_progress_bar() as progress:
+            task_id = progress.add_task(
+                f"Analyzing {len(all_workspaces)} WorkSpaces...",
+                total=len(all_workspaces)
+            )
+
+            for workspace in all_workspaces:
                 workspace_id = workspace["WorkspaceId"]
                 username = workspace["UserName"]
                 state = workspace["State"]
-
-                logger.info(f"Analyzing WorkSpace: {workspace_id} ({username})")
+                bundle_id = workspace["BundleId"]
+                running_mode = workspace["WorkspaceProperties"]["RunningMode"]
 
                 # Get connection status
                 try:
@@ -121,46 +198,120 @@ def get_workspaces(
                 # Determine if workspace is unused
                 is_unused = last_connection is None or last_connection < unused_threshold
 
+                # Calculate cost (JIRA AWSO-24 enhancement)
+                monthly_cost = 0.0
+                if calculate_savings or analyze:
+                    monthly_cost = calculate_workspace_monthly_cost(bundle_id, running_mode)
+                    total_cost += monthly_cost
+                    if is_unused:
+                        unused_cost += monthly_cost
+
                 workspace_data = {
                     "WorkspaceId": workspace_id,
                     "UserName": username,
                     "State": state,
-                    "RunningMode": workspace["WorkspaceProperties"]["RunningMode"],
+                    "RunningMode": running_mode,
                     "OperatingSystem": workspace["WorkspaceProperties"]["OperatingSystemName"],
-                    "BundleId": workspace["BundleId"],
+                    "BundleId": bundle_id,
                     "LastConnection": last_connection_str,
                     "DaysSinceConnection": days_since_connection,
                     "ConnectionState": connection_state,
                     f"UsageHours_{days}days": usage_hours,
                     "IsUnused": is_unused,
                     "UnusedThreshold": f"{unused_days} days",
+                    "MonthlyCost": monthly_cost,
+                    "AnnualCost": monthly_cost * 12,
                 }
 
                 data.append(workspace_data)
-
-                # Log status
-                if is_unused:
-                    logger.warning(f"  ⚠ UNUSED: Last connection {days_since_connection} days ago")
-                else:
-                    logger.info(f"  ✓ Active: {usage_hours}h usage in {days} days")
+                progress.advance(task_id)
 
         # Export data
         write_to_csv(data, output_file)
-        logger.info(f"WorkSpaces analysis exported to: {output_file}")
+        print_success(f"WorkSpaces analysis exported to: {output_file}")
 
         # Analyze unused WorkSpaces
         unused_workspaces = [ws for ws in data if ws["IsUnused"]]
 
-        logger.info("\n=== ANALYSIS SUMMARY ===")
-        logger.info(f"Total WorkSpaces: {len(data)}")
-        logger.info(f"Unused WorkSpaces (>{unused_days} days): {len(unused_workspaces)}")
+        # Create summary table with Rich CLI
+        print_header("WorkSpaces Analysis Summary")
+        
+        summary_table = create_table(
+            title="WorkSpaces Cost Analysis - JIRA AWSO-24",
+            columns=[
+                {"header": "Metric", "style": "cyan"},
+                {"header": "Value", "style": "green bold"},
+                {"header": "Monthly Cost", "style": "red"},
+                {"header": "Annual Cost", "style": "red bold"}
+            ]
+        )
+
+        # Basic metrics
+        summary_table.add_row(
+            "Total WorkSpaces",
+            str(len(data)),
+            format_cost(total_cost) if calculate_savings or analyze else "N/A",
+            format_cost(total_cost * 12) if calculate_savings or analyze else "N/A"
+        )
+        
+        summary_table.add_row(
+            f"Unused WorkSpaces (>{unused_days} days)",
+            str(len(unused_workspaces)),
+            format_cost(unused_cost) if calculate_savings or analyze else "N/A", 
+            format_cost(unused_cost * 12) if calculate_savings or analyze else "N/A"
+        )
+
+        if calculate_savings or analyze:
+            potential_savings_monthly = unused_cost
+            potential_savings_annual = unused_cost * 12
+            
+            summary_table.add_row(
+                "🎯 Potential Savings",
+                f"{len(unused_workspaces)} WorkSpaces",
+                format_cost(potential_savings_monthly),
+                format_cost(potential_savings_annual)
+            )
+
+        console.print(summary_table)
 
         if unused_workspaces:
-            logger.warning(f"⚠ Found {len(unused_workspaces)} unused WorkSpaces:")
-            for ws in unused_workspaces:
-                logger.warning(
-                    f"  - {ws['WorkspaceId']} ({ws['UserName']}) - {ws['DaysSinceConnection']} days since connection"
+            print_warning(f"⚠ Found {len(unused_workspaces)} unused WorkSpaces:")
+            
+            # Create detailed unused workspaces table
+            unused_table = create_table(
+                title="Unused WorkSpaces Details",
+                columns=[
+                    {"header": "WorkSpace ID", "style": "cyan"},
+                    {"header": "Username", "style": "blue"},
+                    {"header": "Days Since Connection", "style": "yellow"},
+                    {"header": "Running Mode", "style": "green"},
+                    {"header": "Monthly Cost", "style": "red"},
+                    {"header": "State", "style": "magenta"}
+                ]
+            )
+            
+            for ws in unused_workspaces[:10]:  # Show first 10 for readability
+                unused_table.add_row(
+                    ws['WorkspaceId'],
+                    ws['UserName'],
+                    str(ws['DaysSinceConnection']),
+                    ws['RunningMode'],
+                    format_cost(ws['MonthlyCost']) if ws['MonthlyCost'] > 0 else "N/A",
+                    ws['State']
                 )
+            
+            console.print(unused_table)
+            
+            if len(unused_workspaces) > 10:
+                console.print(f"[dim]... and {len(unused_workspaces) - 10} more unused WorkSpaces[/dim]")
+
+        # Target validation (JIRA AWSO-24: $12,518 annual savings)
+        if calculate_savings or analyze:
+            target_annual_savings = 12518.0  # JIRA AWSO-24 target
+            if potential_savings_annual >= target_annual_savings * 0.8:  # 80% of target
+                print_success(f"🎯 Target Achievement: {potential_savings_annual/target_annual_savings*100:.1f}% of $12,518 annual savings target")
+            else:
+                print_warning(f"📊 Analysis: {potential_savings_annual/target_annual_savings*100:.1f}% of $12,518 annual savings target")
 
         # Handle deletion of unused WorkSpaces
         if delete_unused and unused_workspaces:

runbooks/security/__init__.py

@@ -210,8 +210,10 @@ from .run_script import parse_arguments
 from .security_baseline_tester import SecurityBaselineTester
 from .security_export import SecurityExporter
 
+# Import centralized version from main runbooks package
+from runbooks import __version__
+
 # Version info
-__version__ = "1.2.0"
 __author__ = "CloudOps Enterprise Security Team"
 
 # Public API

runbooks/sre/__init__.py

@@ -23,7 +23,8 @@ from .mcp_reliability_engine import (
     run_mcp_reliability_suite,
 )
 
-__version__ = "1.0.0"
+# Import centralized version from main runbooks package
+from runbooks import __version__
 
 __all__ = [
     "MCPReliabilityEngine",

runbooks/utils/__init__.py

@@ -22,6 +22,15 @@ except ImportError:
 # Legacy utilities
 from runbooks.utils.logger import configure_logger
 
+# Version management utilities
+from runbooks.utils.version_validator import (
+    check_pyproject_version,
+    get_all_module_versions,
+    print_version_report,
+    validate_version_consistency,
+    VersionDriftError,
+)
+
 
 def setup_logging(debug: bool = False, log_file: Optional[str] = None) -> None:
     """
@@ -65,9 +74,9 @@ def setup_logging(debug: bool = False, log_file: Optional[str] = None) -> None:
         # Fallback to standard logging
         import logging
 
-        log_level = logging.DEBUG if debug else logging.INFO
+        log_level_value = logging.DEBUG if debug else logging.INFO
         logging.basicConfig(
-            level=log_level,
+            level=log_level_value,
             format="%(asctime)s | %(levelname)-8s | %(name)s:%(funcName)s:%(lineno)d - %(message)s",
             handlers=[logging.StreamHandler(sys.stderr)],
         )
@@ -76,12 +85,71 @@ def setup_logging(debug: bool = False, log_file: Optional[str] = None) -> None:
             log_path = Path(log_file)
             log_path.parent.mkdir(parents=True, exist_ok=True)
             file_handler = logging.FileHandler(log_path)
-            file_handler.setFormatter(
-                logging.Formatter("%(asctime)s | %(levelname)-8s | %(name)s:%(funcName)s:%(lineno)d - %(message)s")
-            )
+            file_handler.setLevel(log_level_value)
+            formatter = logging.Formatter("%(asctime)s | %(levelname)-8s | %(name)s:%(funcName)s:%(lineno)d - %(message)s")
+            file_handler.setFormatter(formatter)
             logging.getLogger().addHandler(file_handler)
 
-        logging.info(f"Logging initialized with level: {log_level}")
+
+def setup_enhanced_logging(log_level: str = "INFO", json_output: bool = False, debug: bool = False) -> None:
+    """
+    Configure enhanced enterprise logging with Rich CLI integration and user-type specific output.
+    
+    This function initializes the global enhanced logger that provides:
+    - User-type specific formatting (DEBUG=tech, INFO=standard, WARNING=business, ERROR=all)
+    - Rich CLI integration with beautiful formatting
+    - Structured JSON output option for programmatic use
+    - AWS API tracing for technical users
+    - Business recommendations for warning level
+    - Clear error solutions for all users
+    
+    Args:
+        log_level: Log level (DEBUG, INFO, WARNING, ERROR)
+        json_output: Enable structured JSON output for programmatic use
+        debug: Legacy debug flag for backward compatibility
+    """
+    try:
+        from runbooks.enterprise.logging import configure_enterprise_logging, get_context_logger
+        from runbooks.common.rich_utils import get_context_aware_console
+        
+        # Override level if debug flag is set (backward compatibility)
+        if debug:
+            log_level = "DEBUG"
+            
+        # Get context-aware console for Rich CLI integration
+        try:
+            rich_console = get_context_aware_console()
+        except ImportError:
+            rich_console = None
+            
+        # Configure global enhanced logger
+        logger = configure_enterprise_logging(
+            level=log_level,
+            rich_console=rich_console,
+            json_output=json_output
+        )
+        
+        # Log initialization success with user-type appropriate message
+        if log_level == "DEBUG":
+            logger.debug_tech(
+                "Enhanced logging initialized with Rich CLI integration",
+                aws_api={"service": "logging", "operation": "initialize"},
+                duration=0.001
+            )
+        elif log_level == "INFO":
+            logger.info_standard("CloudOps Runbooks logging initialized")
+        elif log_level == "WARNING":
+            logger.warning_business(
+                "Business-focused logging enabled", 
+                recommendation="Use --log-level INFO for standard operations"
+            )
+        else:
+            logger.error_all("Minimal error-only logging enabled")
+            
+    except ImportError as e:
+        # Fallback to standard logging if enhanced logging not available
+        setup_logging(debug=debug)
+        print(f"Warning: Enhanced logging not available, falling back to standard logging: {e}")
 
 
 def validate_aws_profile(profile: str) -> bool:
@@ -196,9 +264,16 @@ def retry_with_backoff(max_retries: int = 3, backoff_factor: float = 1.0):
 
 __all__ = [
     "setup_logging",
+    "setup_enhanced_logging",
     "validate_aws_profile",
     "ensure_directory",
     "format_size",
     "retry_with_backoff",
     "configure_logger",
+    # Version management
+    "check_pyproject_version",
+    "get_all_module_versions", 
+    "print_version_report",
+    "validate_version_consistency",
+    "VersionDriftError",
 ]

runbooks/utils/version_validator.py

@@ -0,0 +1,241 @@
+"""
+Version Management Validation Utilities
+
+This module provides utilities to detect and prevent version drift across
+the runbooks package and its modules.
+"""
+
+import importlib
+import sys
+import warnings
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+# Avoid circular imports by defining central version directly
+CENTRAL_VERSION = "0.9.3"  # Must match runbooks.__init__.__version__
+
+
+class VersionDriftError(Exception):
+    """Raised when version drift is detected in CI/CD pipeline."""
+    pass
+
+
+def get_all_module_versions() -> Dict[str, str]:
+    """
+    Collect versions from all runbooks modules.
+    
+    Returns:
+        Dict mapping module names to their reported versions
+    """
+    modules = [
+        "runbooks",
+        "runbooks.finops",
+        "runbooks.operate", 
+        "runbooks.security",
+        "runbooks.cfat",
+        "runbooks.inventory",
+        "runbooks.remediation",
+        "runbooks.vpc",
+        "runbooks.sre",
+        "runbooks.cloudops"
+    ]
+    
+    versions = {}
+    
+    for module_name in modules:
+        try:
+            # Import the module
+            module = importlib.import_module(module_name)
+            
+            # Get version
+            if hasattr(module, '__version__'):
+                versions[module_name] = module.__version__
+            else:
+                versions[module_name] = "No version found"
+                
+        except ImportError as e:
+            versions[module_name] = f"Import error: {e}"
+        except Exception as e:
+            versions[module_name] = f"Error: {e}"
+            
+    return versions
+
+
+def check_pyproject_version() -> Tuple[bool, str, str]:
+    """
+    Check if pyproject.toml version matches centralized version.
+    
+    Returns:
+        Tuple of (is_matching, pyproject_version, central_version)
+    """
+    try:
+        from importlib.metadata import version as _pkg_version
+        pyproject_version = _pkg_version("runbooks")
+        return (pyproject_version == CENTRAL_VERSION, pyproject_version, CENTRAL_VERSION)
+    except Exception as e:
+        return (False, f"Error reading pyproject.toml: {e}", CENTRAL_VERSION)
+
+
+def validate_version_consistency(strict: bool = False) -> Dict[str, any]:
+    """
+    Validate version consistency across all modules.
+    
+    Args:
+        strict: If True, raise VersionDriftError on inconsistencies
+        
+    Returns:
+        Dictionary with validation results
+        
+    Raises:
+        VersionDriftError: If strict=True and inconsistencies found
+    """
+    results = {
+        "central_version": CENTRAL_VERSION,
+        "module_versions": get_all_module_versions(),
+        "pyproject_check": check_pyproject_version(),
+        "inconsistencies": [],
+        "all_consistent": True
+    }
+    
+    # Check module versions
+    for module_name, module_version in results["module_versions"].items():
+        if module_name == "runbooks":
+            continue  # Skip root module
+            
+        if isinstance(module_version, str) and not module_version.startswith(("Error:", "No version", "Import error:")):
+            if module_version != CENTRAL_VERSION:
+                inconsistency = {
+                    "module": module_name,
+                    "expected": CENTRAL_VERSION,
+                    "found": module_version,
+                    "type": "module_version_mismatch"
+                }
+                results["inconsistencies"].append(inconsistency)
+                results["all_consistent"] = False
+    
+    # Check pyproject.toml
+    is_matching, pyproject_version, _ = results["pyproject_check"]
+    if not is_matching and not pyproject_version.startswith("Error:"):
+        inconsistency = {
+            "module": "pyproject.toml",
+            "expected": CENTRAL_VERSION,
+            "found": pyproject_version,
+            "type": "pyproject_version_mismatch"
+        }
+        results["inconsistencies"].append(inconsistency)
+        results["all_consistent"] = False
+    
+    # Raise error in strict mode
+    if strict and not results["all_consistent"]:
+        error_msg = f"Version drift detected:\n"
+        for inc in results["inconsistencies"]:
+            error_msg += f"  - {inc['module']}: expected {inc['expected']}, got {inc['found']}\n"
+        raise VersionDriftError(error_msg)
+    
+    return results
+
+
+def print_version_report() -> None:
+    """Print a formatted version consistency report."""
+    try:
+        from rich.console import Console
+        from rich.table import Table
+        from rich.panel import Panel
+        
+        console = Console()
+        validation_results = validate_version_consistency()
+        
+        # Header
+        console.print(Panel(
+            f"[bold blue]Version Management Report[/bold blue]\n"
+            f"Central Version: [green]{validation_results['central_version']}[/green]",
+            title="Runbooks Version Validation"
+        ))
+        
+        # Module versions table
+        table = Table(title="Module Version Status")
+        table.add_column("Module", style="cyan")
+        table.add_column("Version", style="green")
+        table.add_column("Status", style="magenta")
+        
+        for module_name, version in validation_results["module_versions"].items():
+            if isinstance(version, str) and version.startswith(("Error:", "No version", "Import error:")):
+                status = "[red]Error[/red]"
+                version_display = f"[red]{version}[/red]"
+            elif version == validation_results["central_version"]:
+                status = "[green]✓ OK[/green]"
+                version_display = f"[green]{version}[/green]"
+            else:
+                status = "[red]✗ Mismatch[/red]"
+                version_display = f"[red]{version}[/red]"
+                
+            table.add_row(module_name, version_display, status)
+        
+        console.print(table)
+        
+        # Pyproject.toml check
+        is_matching, pyproject_version, central_version = validation_results["pyproject_check"]
+        if is_matching:
+            console.print("[green]✓ pyproject.toml version matches central version[/green]")
+        else:
+            console.print(f"[red]✗ pyproject.toml version mismatch: {pyproject_version} vs {central_version}[/red]")
+        
+        # Overall status
+        if validation_results["all_consistent"]:
+            console.print("\n[bold green]✓ All versions are consistent[/bold green]")
+        else:
+            console.print("\n[bold red]✗ Version inconsistencies detected[/bold red]")
+            for inc in validation_results["inconsistencies"]:
+                console.print(f"  - {inc['module']}: expected {inc['expected']}, got {inc['found']}")
+                
+    except ImportError:
+        # Fallback without Rich
+        validation_results = validate_version_consistency()
+        
+        print(f"=== Version Management Report ===")
+        print(f"Central Version: {validation_results['central_version']}")
+        print()
+        
+        print("Module Versions:")
+        for module_name, version in validation_results["module_versions"].items():
+            status = "OK" if version == validation_results["central_version"] else "MISMATCH"
+            print(f"  {module_name}: {version} ({status})")
+        
+        is_matching, pyproject_version, _ = validation_results["pyproject_check"]
+        pyproject_status = "OK" if is_matching else "MISMATCH"
+        print(f"  pyproject.toml: {pyproject_version} ({pyproject_status})")
+        
+        if validation_results["all_consistent"]:
+            print("\n✓ All versions are consistent")
+        else:
+            print("\n✗ Version inconsistencies detected:")
+            for inc in validation_results["inconsistencies"]:
+                print(f"  - {inc['module']}: expected {inc['expected']}, got {inc['found']}")
+
+
+def cli_main():
+    """CLI entry point for version validation."""
+    import argparse
+    
+    parser = argparse.ArgumentParser(description="Validate runbooks version consistency")
+    parser.add_argument("--strict", action="store_true", 
+                       help="Exit with error code if inconsistencies found")
+    
+    args = parser.parse_args()
+    
+    try:
+        print_version_report()
+        
+        if args.strict:
+            validate_version_consistency(strict=True)
+            
+    except VersionDriftError as e:
+        print(f"\nERROR: {e}")
+        sys.exit(1)
+    except Exception as e:
+        print(f"Unexpected error: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    cli_main()