runbooks 1.1.3__py3-none-any.whl → 1.1.5__py3-none-any.whl

runbooks/finops/dashboard_router.py

@@ -1,922 +0,0 @@
-#!/usr/bin/env python3
-"""
-FinOps Dashboard Router - Enterprise Use-Case Detection & Routing
-
-This module provides intelligent routing between different dashboard types based on
-AWS profile configuration and use-case detection, implementing the architectural
-enhancement requested for improved user experience and functionality.
-
-Features:
-- Smart single vs multi-account detection
-- Use-case specific dashboard routing
-- Non-breaking backward compatibility
-- Enhanced column value implementations
-- Rich CLI integration (mandatory enterprise standard)
-
-Author: CloudOps Runbooks Team
-Version: 0.8.0
-"""
-
-import argparse
-import os
-from typing import Any, Dict, List, Optional, Tuple
-
-import boto3
-from rich.console import Console
-
-from ..common.rich_utils import (
-    STATUS_INDICATORS,
-    console,
-    print_header,
-    print_info,
-    print_success,
-    print_warning,
-)
-from .aws_client import convert_accounts_to_profiles, get_account_id, get_aws_profiles, get_organization_accounts
-from runbooks.common.profile_utils import get_profile_for_operation
-
-# Rich CLI integration (mandatory)
-rich_console = console
-
-
-class DashboardRouter:
-    """
-    Intelligent dashboard router for enterprise FinOps use-cases.
-
-    Routes requests to appropriate dashboard implementations based on:
-    - Profile configuration (single vs multi-account)
-    - User preferences (explicit mode selection)
-    - Account access patterns
-    - Use-case detection logic
-    """
-
-    def __init__(self, console: Optional[Console] = None):
-        self.console = console or rich_console
-        self.aws_profiles = get_aws_profiles()
-
-    def detect_use_case(self, args: argparse.Namespace) -> Tuple[str, Dict[str, Any]]:
-        """
-        Intelligent use-case detection for optimal dashboard routing.
-
-        Detection Logic Priority (ENHANCED - Organizations API Integration):
-        1. --all flag with Organizations API discovery (NEW)
-        2. Explicit --mode parameter (user override)
-        3. Multi-profile detection (--profiles with 2+)
-        4. Single profile specified = ALWAYS single_account (CRITICAL FIX)
-        5. Environment-based cross-account detection (only when no explicit profile)
-
-        Args:
-            args: Command line arguments from FinOps CLI
-
-        Returns:
-            Tuple of (use_case, routing_config) where:
-            - use_case: 'single_account' or 'multi_account' or 'organization_wide'
-            - routing_config: Configuration dict for the selected dashboard
-        """
-        routing_config = {
-            "profiles_to_analyze": [],
-            "account_context": "unknown",
-            "optimization_focus": "balanced",
-            "detection_confidence": "low",
-            "organization_accounts": [],
-        }
-
-        # Priority 1: --all flag with Organizations API discovery (NEW)
-        if hasattr(args, "all") and args.all:
-            print_info("🔍 --all flag detected: Enabling Organizations API discovery")
-
-            # Get base profile for Organizations API access
-            base_profile = args.profile if hasattr(args, "profile") and args.profile != "default" else "default"
-
-            try:
-                import boto3
-
-                session = boto3.Session(profile_name=base_profile)
-
-                # Discover all organization accounts
-                org_accounts = get_organization_accounts(session, base_profile)
-
-                if org_accounts:
-                    # Successfully discovered accounts via Organizations API
-                    # CRITICAL FIX: Handle new return format with account metadata
-                    profiles_to_analyze, account_metadata = convert_accounts_to_profiles(org_accounts, base_profile)
-
-                    routing_config["organization_accounts"] = org_accounts
-                    routing_config["profiles_to_analyze"] = profiles_to_analyze
-                    routing_config["account_metadata"] = account_metadata  # Preserve inactive account info
-                    routing_config["account_context"] = "organization_wide"
-                    routing_config["optimization_focus"] = "account"
-                    routing_config["detection_confidence"] = "high"
-                    routing_config["base_profile"] = base_profile
-
-                    active_count = len([acc for acc in org_accounts if acc.get("status") == "ACTIVE"])
-                    inactive_count = len(org_accounts) - active_count
-                    print_success(
-                        f"Organizations API: Discovered {len(org_accounts)} accounts for analysis ({active_count} active, {inactive_count} inactive)"
-                    )
-                    return "organization_wide", routing_config
-
-                else:
-                    # Organizations API failed, fall back to single account mode
-                    print_warning("Organizations API discovery failed, falling back to single account mode")
-                    routing_config["profiles_to_analyze"] = [base_profile]
-                    routing_config["account_context"] = "single"
-                    routing_config["optimization_focus"] = "service"
-                    routing_config["detection_confidence"] = "medium"
-                    return "single_account", routing_config
-
-            except Exception as e:
-                print_warning(f"--all flag processing failed: {str(e)[:50]}")
-                # Graceful fallback to single account
-                base_profile = args.profile if hasattr(args, "profile") and args.profile != "default" else "default"
-                routing_config["profiles_to_analyze"] = [base_profile]
-                routing_config["account_context"] = "single"
-                routing_config["optimization_focus"] = "service"
-                routing_config["detection_confidence"] = "low"
-                return "single_account", routing_config
-
-        # Priority 2: Explicit mode override
-        if hasattr(args, "mode") and args.mode:
-            use_case = args.mode
-            routing_config["detection_confidence"] = "explicit"
-            routing_config["optimization_focus"] = "service" if use_case == "single_account" else "account"
-            print_info(f"Dashboard mode explicitly set: {use_case}")
-            return use_case, routing_config
-
-        # Priority 3: Multi-profile parameter detection with deduplication
-        profiles_specified = []
-
-        # Process --profiles parameter first
-        if hasattr(args, "profiles") and args.profiles:
-            for profile_item in args.profiles:
-                if "," in profile_item:
-                    # Handle comma-separated within --profiles parameter
-                    profiles_specified.extend([p.strip() for p in profile_item.split(",") if p.strip()])
-                else:
-                    profiles_specified.append(profile_item.strip())
-            print_info(f"Found --profiles parameter: {args.profiles} → {len(profiles_specified)} profiles")
-
-        # Process --profile parameter (avoid duplicates)
-        if hasattr(args, "profile") and args.profile and args.profile != "default":
-            if "," in args.profile:
-                # Handle comma-separated profiles in single --profile parameter
-                comma_profiles = [p.strip() for p in args.profile.split(",") if p.strip()]
-                for profile in comma_profiles:
-                    if profile not in profiles_specified:  # Deduplicate
-                        profiles_specified.append(profile)
-                print_info(f"Found comma-separated --profile: {args.profile} → {len(comma_profiles)} additional")
-            else:
-                if args.profile not in profiles_specified:  # Deduplicate
-                    profiles_specified.append(args.profile)
-                    print_info(f"Added single --profile: {args.profile}")
-
-        # Remove any empty strings and deduplicate
-        profiles_specified = list(dict.fromkeys([p for p in profiles_specified if p and p.strip()]))
-
-        if len(profiles_specified) > 1:
-            print_info(f"Clean multi-profile list: {profiles_specified} ({len(profiles_specified)} unique profiles)")
-            routing_config["profiles_to_analyze"] = profiles_specified
-            routing_config["account_context"] = "multi"
-            routing_config["optimization_focus"] = "account"
-            routing_config["detection_confidence"] = "high"
-            return "multi_account", routing_config
-
-        # Priority 4: CRITICAL FIX - Single profile specified = single_account mode
-        if len(profiles_specified) == 1:
-            routing_config["account_context"] = "single"
-            routing_config["optimization_focus"] = "service"
-            routing_config["detection_confidence"] = "high"
-            routing_config["profiles_to_analyze"] = profiles_specified
-            print_info(f"Single profile specified: {profiles_specified[0]} → single_account mode")
-            return "single_account", routing_config
-
-        # Priority 5: Environment-based detection (only when no explicit profile)
-        if self._detect_cross_account_capability(None):
-            routing_config["account_context"] = "cross_account_capable"
-            routing_config["optimization_focus"] = "account"
-            routing_config["detection_confidence"] = "medium"
-            print_info("Cross-account environment detected (no explicit profile)")
-            return "multi_account", routing_config
-
-        # Priority 6: Default fallback
-        routing_config["account_context"] = "single"
-        routing_config["optimization_focus"] = "service"
-        routing_config["detection_confidence"] = "medium"
-        routing_config["profiles_to_analyze"] = ["default"]
-        print_info("Single account default mode selected (service-focused analysis)")
-        return "single_account", routing_config
-
-    def _detect_cross_account_capability(self, profile: Optional[str]) -> bool:
-        """
-        Detect if the profile has cross-account access capabilities.
-
-        CRITICAL: This method should only be called when NO explicit profile is specified.
-        Single profile commands should NEVER reach this method due to Priority 3 fix.
-
-        Detection Methods:
-        1. Environment variable configuration (BILLING_PROFILE, MANAGEMENT_PROFILE)
-        2. Profile naming patterns (admin, billing, management)
-        3. Quick account access test (if feasible)
-
-        Args:
-            profile: AWS profile to test (should be None for environment detection)
-
-        Returns:
-            bool: True if cross-account capability detected
-        """
-        try:
-            # CRITICAL: Only check environment when no explicit profile specified
-            if profile is None:
-                # Method 1: Environment variable detection (only when profile=None)
-                env_profiles = [
-                    os.getenv("BILLING_PROFILE"),
-                    os.getenv("MANAGEMENT_PROFILE"),
-                    os.getenv("CENTRALISED_OPS_PROFILE"),
-                ]
-                if any(env_profiles):
-                    print_info("Multi-profile environment variables detected (no explicit profile)")
-                    return True
-
-            # Method 2: Profile naming pattern analysis
-            if profile:
-                cross_account_indicators = ["admin", "billing", "management", "centralised", "master", "org"]
-                profile_lower = profile.lower()
-                if any(indicator in profile_lower for indicator in cross_account_indicators):
-                    print_info(f"Cross-account naming pattern detected in profile: {profile}")
-                    return True
-
-            # Method 3: Quick capability test (lightweight)
-            if profile:
-                try:
-                    # Test if we can access multiple operation types
-                    billing_profile = get_profile_for_operation("billing", profile)
-                    management_profile = get_profile_for_operation("management", profile)
-                    operational_profile = get_profile_for_operation("operational", profile)
-
-                    # If different profiles are resolved, we have multi-profile capability
-                    profiles_used = {billing_profile, management_profile, operational_profile}
-                    if len(profiles_used) > 1:
-                        print_info("Multi-profile operation capability confirmed")
-                        return True
-
-                except Exception as e:
-                    # Graceful fallback - don't fail the detection
-                    print_warning(f"Profile capability test failed: {str(e)[:50]}")
-
-            return False
-
-        except Exception as e:
-            print_warning(f"Cross-account detection failed: {str(e)[:50]}")
-            return False
-
-    def route_dashboard_request(self, args: argparse.Namespace) -> int:
-        """
-        Route dashboard request to appropriate implementation.
-
-        This is the main entry point that replaces the monolithic dashboard approach
-        with intelligent routing to specialized dashboard implementations.
-
-        Args:
-            args: Command line arguments
-
-        Returns:
-            int: Exit code (0 for success, 1 for failure)
-        """
-        try:
-            print_header("FinOps Dashboard Router", "1.1.1")
-
-            # Detect use-case and route appropriately
-            use_case, routing_config = self.detect_use_case(args)
-
-            # Display routing decision
-            self._display_routing_decision(use_case, routing_config)
-
-            if use_case == "single_account":
-                return self._route_to_single_dashboard(args, routing_config)
-            elif use_case == "multi_account":
-                return self._route_to_multi_dashboard(args, routing_config)
-            elif use_case == "organization_wide":
-                return self._route_to_organization_dashboard(args, routing_config)
-            else:
-                print_warning(f"Unknown use case: {use_case}, falling back to original dashboard")
-                return self._route_to_original_dashboard(args)
-
-        except Exception as e:
-            self.console.print(f"[error]❌ Dashboard routing failed: {str(e)}[/]")
-            return 1
-
-    def _display_routing_decision(self, use_case: str, config: Dict[str, Any]) -> None:
-        """Display the routing decision with Rich formatting."""
-        confidence_icon = STATUS_INDICATORS.get(
-            "success"
-            if config["detection_confidence"] == "high"
-            else "warning"
-            if config["detection_confidence"] == "medium"
-            else "info"
-        )
-
-        self.console.print(f"\n[info]{confidence_icon} Use Case Detected:[/] [highlight]{use_case}[/]")
-        self.console.print(f"[dim]• Account Context: {config['account_context']}[/]")
-        self.console.print(f"[dim]• Optimization Focus: {config['optimization_focus']}[/]")
-        self.console.print(f"[dim]• Detection Confidence: {config['detection_confidence']}[/]\n")
-
-    def _route_to_single_dashboard(self, args: argparse.Namespace, config: Dict[str, Any]) -> int:
-        """Route to single-account service-focused dashboard."""
-        try:
-            from .single_dashboard import SingleAccountDashboard
-
-            dashboard = SingleAccountDashboard(console=self.console)
-            return dashboard.run_dashboard(args, config)
-
-        except Exception as e:
-            print_warning(f"Single dashboard import failed ({str(e)[:30]}), implementing direct service-per-row")
-            return self._run_direct_service_dashboard(args, config)
-
-    def _route_to_multi_dashboard(self, args: argparse.Namespace, config: Dict[str, Any]) -> int:
-        """Route to multi-account account-focused dashboard."""
-        try:
-            from .multi_dashboard import MultiAccountDashboard
-
-            dashboard = MultiAccountDashboard(console=self.console)
-            return dashboard.run_dashboard(args, config)
-
-        except ImportError as e:
-            print_warning(f"Multi dashboard import failed: {str(e)[:50]}, using enhanced runner")
-            return self._route_to_enhanced_dashboard(args)
-        except Exception as e:
-            print_warning(f"Multi dashboard failed: {str(e)[:50]}, using enhanced runner")
-            return self._route_to_enhanced_dashboard(args)
-
-    def _route_to_organization_dashboard(self, args: argparse.Namespace, config: Dict[str, Any]) -> int:
-        """
-        Route to organization-wide dashboard with Organizations API discovered accounts.
-
-        This method handles the --all flag functionality by processing all discovered
-        organization accounts and routing to the appropriate multi-account dashboard.
-
-        Args:
-            args: Command line arguments
-            config: Routing config containing organization_accounts data
-
-        Returns:
-            int: Exit code (0 for success, 1 for failure)
-        """
-        try:
-            print_info("🏢 Routing to organization-wide dashboard")
-
-            # Extract organization data from config
-            org_accounts = config.get("organization_accounts", [])
-            base_profile = config.get("base_profile", "default")
-
-            if not org_accounts:
-                print_warning("No organization accounts found, falling back to single account")
-                return self._route_to_single_dashboard(args, config)
-
-            # Display organization summary for user confirmation
-            self.console.print(f"\n[info]🏢 Organization Analysis Scope:[/]")
-            self.console.print(f"[dim]• Base Profile: {base_profile}[/]")
-            self.console.print(f"[dim]• Total Accounts: {len(org_accounts)}[/]")
-            self.console.print(f"[dim]• Analysis Type: Multi-account 10-column dashboard[/]")
-
-            # Show account summary (first 10 accounts for display)
-            display_accounts = org_accounts[:10]
-            for i, account in enumerate(display_accounts, 1):
-                account_name = account["name"][:30] + "..." if len(account["name"]) > 30 else account["name"]
-                self.console.print(f"[dim]  {i:2d}. {account['id']} - {account_name}[/]")
-
-            if len(org_accounts) > 10:
-                self.console.print(f"[dim]  ... and {len(org_accounts) - 10} more accounts[/]\n")
-            else:
-                self.console.print()
-
-            # Try to route to multi-account dashboard with organization context
-            try:
-                from .multi_dashboard import MultiAccountDashboard
-
-                # Update config to indicate organization-wide context
-                org_config = config.copy()
-                org_config["analysis_scope"] = "organization"
-                org_config["account_discovery_method"] = "organizations_api"
-
-                dashboard = MultiAccountDashboard(console=self.console)
-                return dashboard.run_dashboard(args, org_config)
-
-            except ImportError:
-                print_warning("Multi-account dashboard unavailable, using enhanced dashboard with organization context")
-                return self._route_to_enhanced_organization_dashboard(args, config)
-
-        except Exception as e:
-            print_warning(f"Organization dashboard routing failed: {str(e)[:50]}")
-            return self._route_to_enhanced_dashboard(args)
-
-    def _route_to_enhanced_organization_dashboard(self, args: argparse.Namespace, config: Dict[str, Any]) -> int:
-        """
-        Enhanced dashboard implementation for organization-wide analysis.
-
-        This provides fallback functionality when the dedicated multi-account dashboard
-        is not available, using the enhanced dashboard runner with organization context.
-        """
-        try:
-            from .enhanced_dashboard_runner import EnhancedFinOpsDashboard
-
-            print_info("Using enhanced dashboard with organization-wide context")
-
-            # Get organization accounts for processing
-            org_accounts = config.get("organization_accounts", [])
-            base_profile = config.get("base_profile", "default")
-
-            # Create enhanced dashboard with organization context
-            dashboard = EnhancedFinOpsDashboard(console=self.console)
-
-            # Set organization context for the dashboard
-            dashboard.organization_accounts = org_accounts
-            dashboard.base_profile = base_profile
-            dashboard.analysis_scope = "organization"
-
-            print_success(f"Configured enhanced dashboard for {len(org_accounts)} organization accounts")
-
-            # Run comprehensive analysis with organization scope
-            return dashboard.run_comprehensive_audit()
-
-        except ImportError as e:
-            print_warning(f"Enhanced dashboard unavailable: {str(e)[:30]}")
-            return self._create_organization_summary_table(args, config)
-        except Exception as e:
-            print_warning(f"Enhanced organization dashboard failed: {str(e)[:50]}")
-            return self._create_organization_summary_table(args, config)
-
-    def _create_organization_summary_table(self, args: argparse.Namespace, config: Dict[str, Any]) -> int:
-        """
-        Create a summary table for organization-wide accounts when full dashboard is unavailable.
-
-        This provides basic organization account information in a clean table format,
-        fulfilling the user's requirement for the --all flag functionality.
-        """
-        from rich import box
-        from rich.table import Table
-
-        try:
-            print_info("Creating organization summary table (dashboard fallback)")
-
-            org_accounts = config.get("organization_accounts", [])
-            base_profile = config.get("base_profile", "default")
-
-            # Create organization accounts summary table
-            table = Table(
-                title=f"🏢 Organization Accounts - Discovered via Organizations API",
-                box=box.DOUBLE_EDGE,
-                border_style="bright_cyan",
-                title_style="bold white on blue",
-                header_style="bold cyan",
-                show_lines=True,
-                caption=f"[dim]Base Profile: {base_profile} | Discovery Method: Organizations API | Total: {len(org_accounts)} accounts[/]",
-            )
-
-            # Add columns for organization account info
-            table.add_column("#", justify="right", style="dim", width=4)
-            table.add_column("Account ID", style="bold white", width=15)
-            table.add_column("Account Name", style="cyan", width=40)
-            table.add_column("Status", style="green", width=10)
-            table.add_column("Email", style="dim", width=30)
-
-            # Add account rows
-            for i, account in enumerate(org_accounts, 1):
-                table.add_row(
-                    str(i),
-                    account["id"],
-                    account["name"][:38] + "..." if len(account["name"]) > 38 else account["name"],
-                    account["status"],
-                    account["email"][:28] + "..." if len(account["email"]) > 28 else account["email"],
-                )
-
-            self.console.print(table)
-
-            # Provide next steps guidance
-            from rich.panel import Panel
-
-            next_steps = f"""
-[highlight]Organization Discovery Complete[/]
-
-✅ Successfully discovered {len(org_accounts)} accounts via Organizations API
-✅ Base profile '{base_profile}' has organization-wide access
-✅ All accounts are ACTIVE status and ready for analysis
-
-[bold]Next Steps:[/]
-• Use multi-account dashboards for detailed cost analysis
-• Set up cross-account roles for comprehensive FinOps operations  
-• Review account naming and tagging standards for better organization
-
-[bold]Command Examples:[/]
-• runbooks finops --all --profile {base_profile}  # This command
-• runbooks finops --profile {base_profile},{org_accounts[0]["id"] if org_accounts else "account2"}  # Explicit accounts
-• runbooks inventory collect --all --profile {base_profile}  # Organization-wide inventory
-            """
-
-            self.console.print(Panel(next_steps.strip(), title="📊 Organizations API Success", style="info"))
-
-            print_success(f"Organization summary completed: {len(org_accounts)} accounts discovered")
-            return 0
-
-        except Exception as e:
-            print_warning(f"Organization summary table failed: {str(e)[:50]}")
-            return 1
-
-    def _route_to_enhanced_dashboard(self, args: argparse.Namespace) -> int:
-        """Route to enhanced dashboard runner (transitional)."""
-        try:
-            from .enhanced_dashboard_runner import EnhancedFinOpsDashboard
-
-            dashboard = EnhancedFinOpsDashboard()
-            return dashboard.run_comprehensive_audit()
-
-        except Exception as e:
-            print_warning(f"Enhanced dashboard unavailable: {str(e)[:50]}")
-            return self._route_to_original_dashboard(args)
-
-    def _route_to_original_dashboard(self, args: argparse.Namespace) -> int:
-        """Fallback to original dashboard (backward compatibility)."""
-        from .dashboard_runner import run_dashboard
-
-        print_info("Using original dashboard implementation (backward compatibility)")
-        return run_dashboard(args)
-
-    def _run_direct_service_dashboard(self, args: argparse.Namespace, config: Dict[str, Any]) -> int:
-        """
-        Direct service-per-row dashboard implementation.
-
-        Provides the service-focused layout that users are requesting:
-        - Column 1: AWS Services (not account profile)
-        - TOP 10 services + Others summary (≤11 lines)
-        - Service-specific optimization recommendations
-        - Smooth progress tracking (no 0%→100% jumps)
-        """
-        try:
-            print_header("Service-Per-Row Dashboard", "1.1.1")
-            print_info("🎯 Focus: TOP 10 Services with optimization insights")
-
-            # Get profile for analysis
-            profile = args.profile if hasattr(args, "profile") and args.profile else "default"
-
-            # Create service-focused table with real AWS data integration
-            return self._create_service_per_row_table(profile, args)
-
-        except Exception as e:
-            print_warning(f"Direct service dashboard failed: {str(e)[:50]}")
-            return self._route_to_original_dashboard(args)
-
-    def _create_service_per_row_table(self, profile: str, args: argparse.Namespace) -> int:
-        """Create the actual service-per-row table format users are requesting."""
-        from rich import box
-        from rich.table import Table
-
-        try:
-            from .cost_processor import filter_analytical_services, get_cost_data
-        except ImportError:
-            get_cost_data = None
-            filter_analytical_services = None
-        from .aws_client import get_account_id
-
-        try:
-            # Get account information
-            session = boto3.Session(profile_name=profile)
-            account_id = get_account_id(session) or "Unknown"
-
-            print_success(f"Creating service-per-row table for account {account_id}")
-
-            # Create the service-focused table with enhanced styling (USER REQUIREMENT FULFILLED)
-            table = Table(
-                title=f"🎯 FinOps Service Analysis - Account {account_id}",
-                box=box.DOUBLE_EDGE,  # Strong border style
-                border_style="bright_cyan",  # Colored boundaries (USER REQUESTED)
-                title_style="bold white on blue",  # Header emphasis
-                header_style="bold cyan",  # Header styling
-                show_lines=True,  # Row separators
-                row_styles=["", "dim"],  # Alternating row colors
-                caption="[dim]Service-per-row layout • TOP 10 + Others • Rich CLI styling with colored boundaries[/]",
-                caption_style="italic bright_black",
-            )
-
-            # Enhanced columns with Rich CLI styling (ENTERPRISE STANDARDS)
-            table.add_column("Service", style="bold bright_white", width=20, no_wrap=True)
-            table.add_column("Last", justify="right", style="dim white", width=12)
-            table.add_column("Current", justify="right", style="bold green", width=12)
-            table.add_column("Trend", justify="center", style="bold", width=16)
-            table.add_column("Optimization Opportunities", style="cyan", width=36)
-
-            # Get actual cost data (or use placeholder if Cost Explorer blocked)
-            cost_data = self._get_service_cost_data(session, profile)
-
-            # Add service rows (TOP 10 + Others as requested)
-            services_added = 0
-            for service_name, service_data in cost_data.items():
-                if services_added >= 10:  # TOP 10 limit
-                    break
-
-                current_cost = service_data.get("current", 0)
-                last_cost = service_data.get("previous", 0)
-                trend = self._calculate_trend(current_cost, last_cost)
-                optimization = self._get_service_optimization(service_name, current_cost, last_cost)
-
-                table.add_row(service_name, f"${current_cost:.2f}", f"${last_cost:.2f}", trend, optimization)
-                services_added += 1
-
-            # Add "Others" summary row if there are remaining services
-            remaining_services = list(cost_data.keys())[10:]
-            if remaining_services:
-                other_current = sum(cost_data[svc].get("current", 0) for svc in remaining_services)
-                other_previous = sum(cost_data[svc].get("previous", 0) for svc in remaining_services)
-                other_trend = self._calculate_trend(other_current, other_previous)
-
-                table.add_row(
-                    f"[dim]Others ({len(remaining_services)} services)[/]",
-                    f"${other_current:.2f}",
-                    f"${other_previous:.2f}",
-                    other_trend,
-                    f"[dim]Review {len(remaining_services)} services individually for optimization[/]",
-                    style="dim",
-                )
-
-            self.console.print(table)
-
-            # Summary with enhanced trend analysis
-            total_current = sum(data.get("current", 0) for data in cost_data.values())
-            total_previous = sum(data.get("previous", 0) for data in cost_data.values())
-            
-            # Use enhanced trend calculation for summary
-            from .cost_processor import calculate_trend_with_context
-            total_trend_display = calculate_trend_with_context(total_current, total_previous)
-
-            summary_text = f"""
-[highlight]Service Analysis Summary[/]
-• Profile: {profile}
-• Account: {account_id}
-• Total Current: ${total_current:.2f}
-• Total Previous: ${total_previous:.2f}
-• Overall Trend: {total_trend_display}
-• Top Optimization: {"Review highest cost services for savings opportunities" if total_current > 100 else "Continue monitoring usage patterns"}
-            """
-
-            from rich.panel import Panel
-
-            self.console.print(Panel(summary_text.strip(), title="📊 Analysis Summary", style="info"))
-
-            # Export to markdown if requested (dashboard_router version)
-            should_export_markdown = False
-
-            # Check if markdown export was requested via --export-markdown flag
-            if hasattr(args, "export_markdown") and getattr(args, "export_markdown", False):
-                should_export_markdown = True
-
-            # Check if markdown export was requested via --report-type markdown
-            if hasattr(args, "report_type") and args.report_type:
-                if isinstance(args.report_type, list) and "markdown" in args.report_type:
-                    should_export_markdown = True
-                elif isinstance(args.report_type, str) and "markdown" in args.report_type:
-                    should_export_markdown = True
-
-            if should_export_markdown:
-                self._export_service_table_to_markdown(
-                    sorted_services,
-                    cost_data,
-                    profile,
-                    account_id,
-                    total_current,
-                    total_previous,
-                    total_trend_pct,
-                    args,
-                )
-
-            print_success("Service-per-row analysis completed successfully")
-            return 0
-
-        except Exception as e:
-            print_warning(f"Service table creation failed: {str(e)[:50]}")
-            return 1
-
-    def _get_service_cost_data(self, session: boto3.Session, profile: str) -> Dict[str, Dict[str, float]]:
-        """Get service cost data with fallback to estimated costs if Cost Explorer blocked."""
-        try:
-            from .cost_processor import filter_analytical_services, get_cost_data
-        except ImportError:
-            get_cost_data = None
-            filter_analytical_services = None
-
-        if get_cost_data:
-            try:
-                # Try to get real cost data first
-                cost_data = get_cost_data(session, None, None, profile_name=profile)
-                services_data = cost_data.get("costs_by_service", {})
-
-                # Convert to the expected format
-                result = {}
-                for service, current_cost in services_data.items():
-                    result[service] = {
-                        "current": current_cost,
-                        "previous": current_cost * 1.1,  # Approximate previous month
-                    }
-
-                if result:
-                    return dict(sorted(result.items(), key=lambda x: x[1]["current"], reverse=True))
-
-            except Exception as e:
-                print_warning(f"Cost Explorer unavailable ({str(e)[:30]}), using service estimates")
-        else:
-            print_warning("Cost data unavailable (import failed), using service estimates")
-
-        # Fallback: Create realistic service cost estimates for demonstration
-        # Note: Tax excluded per user requirements for analytical focus
-        return {
-            "AWS Glue": {"current": 75.19, "previous": 82.50},
-            "Security Hub": {"current": 3.65, "previous": 4.20},
-            "Amazon S3": {"current": 2.12, "previous": 2.40},
-            "CloudWatch": {"current": 1.85, "previous": 2.10},
-            "Config": {"current": 1.26, "previous": 1.45},
-            "Secrets Manager": {"current": 0.71, "previous": 0.80},
-            "DynamoDB": {"current": 0.58, "previous": 0.65},
-            "SQS": {"current": 0.35, "previous": 0.40},
-            "Payment Crypto": {"current": 0.15, "previous": 0.18},
-            "Lambda": {"current": 0.08, "previous": 0.12},
-            "CloudTrail": {"current": 0.05, "previous": 0.08},
-        }
-
-    def _calculate_trend(self, current: float, previous: float, 
-                        current_days: Optional[int] = None, 
-                        previous_days: Optional[int] = None) -> str:
-        """
-        Calculate and format enhanced trend indicator with Rich styling and partial period detection.
-        
-        MATHEMATICAL FIX: Now includes partial period detection to avoid misleading trend calculations.
-        """
-        from .cost_processor import calculate_trend_with_context
-        
-        # Use the enhanced trend calculation with partial period detection
-        trend_text = calculate_trend_with_context(current, previous, current_days, previous_days)
-        
-        # Apply Rich styling to the trend text
-        if "⚠️" in trend_text:
-            return f"[yellow]{trend_text}[/]"
-        elif "New spend" in trend_text:
-            return f"[bright_black]{trend_text}[/]"
-        elif "No change" in trend_text:
-            return f"[dim]{trend_text}[/]"
-        elif "↑" in trend_text:
-            # Determine intensity based on percentage
-            if "significant increase" in trend_text:
-                return f"[bold red]{trend_text}[/]"
-            else:
-                return f"[red]{trend_text}[/]"
-        elif "↓" in trend_text:
-            if "significant decrease" in trend_text:
-                return f"[bold green]{trend_text}[/]"
-            else:
-                return f"[green]{trend_text}[/]"
-        elif "→" in trend_text:
-            return f"[bright_black]{trend_text}[/]"
-        else:
-            return f"[dim]{trend_text}[/]"
-
-    def _get_service_optimization(self, service: str, current: float, previous: float) -> str:
-        """Get service-specific optimization recommendations."""
-        service_lower = service.lower()
-
-        if "glue" in service_lower and current > 50:
-            return "[yellow]Review job frequency & data processing efficiency[/]"
-        elif "tax" in service_lower:
-            return "[dim]Regulatory requirement - no optimization available[/]"
-        elif "security hub" in service_lower:
-            return "[green]Monitor finding resolution & compliance score[/]"
-        elif "s3" in service_lower and current > 2:
-            return "[yellow]Review storage classes: Standard → IA/Glacier[/]"
-        elif "cloudwatch" in service_lower:
-            return "[green]Optimize log retention & custom metrics[/]"
-        elif "config" in service_lower:
-            return "[green]Review configuration rules efficiency[/]"
-        elif "secrets" in service_lower:
-            return "[green]Optimize secret rotation & access patterns[/]"
-        elif "dynamodb" in service_lower:
-            return "[green]Evaluate on-demand vs provisioned capacity[/]"
-        elif "sqs" in service_lower:
-            return "[green]Monitor message patterns & dead letter queues[/]"
-        else:
-            return "[green]Monitor usage patterns & optimization opportunities[/]"
-
-    def _export_service_table_to_markdown(
-        self, sorted_services, cost_data, profile, account_id, total_current, total_previous, total_trend_pct, args
-    ):
-        """Export service-per-row table to properly formatted markdown file."""
-        import os
-        from datetime import datetime
-
-        try:
-            # Prepare file path with proper directory creation
-            output_dir = args.dir if hasattr(args, "dir") and args.dir else "./exports"
-            os.makedirs(output_dir, exist_ok=True)  # Ensure directory exists
-            report_name = args.report_name if hasattr(args, "report_name") and args.report_name else "service_analysis"
-            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-            file_path = os.path.join(output_dir, f"{report_name}_{timestamp}.md")
-
-            # Generate markdown content with properly aligned pipes
-            lines = []
-            lines.append("# Service-Per-Row FinOps Analysis")
-            lines.append("")
-            lines.append(f"**Generated:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
-            lines.append(f"**Profile:** {profile}")
-            lines.append(f"**Account:** {account_id}")
-            lines.append("")
-            lines.append("## Service Cost Breakdown")
-            lines.append("")
-
-            # Create GitHub-compatible markdown table with pipe separators
-            lines.append("| Service | Last Month | Current Month | Trend | Optimization Opportunities |")
-            lines.append("|---------|------------|---------------|-------|----------------------------|")
-
-            # Add TOP 10 services with proper formatting
-            for i, (service, data) in enumerate(sorted_services[:10]):
-                current = data.get("current", 0)
-                previous = data.get("previous", 0)
-                trend_pct = ((current - previous) / previous * 100) if previous > 0 else 0
-                trend_icon = "⬆️" if trend_pct > 0 else "⬇️" if trend_pct < 0 else "➡️"
-
-                # Clean optimization text (remove Rich formatting for markdown)
-                optimization = self._get_service_optimization(service, current, previous)
-                optimization_clean = optimization.replace("[yellow]", "").replace("[dim]", "").replace("[/]", "")
-                optimization_clean = optimization_clean.replace("[green]", "").replace("[red]", "")
-
-                # Format row for GitHub-compatible table
-                service_name = service.replace("|", "\\|")  # Escape pipes in service names
-                optimization_clean = optimization_clean.replace("|", "\\|")  # Escape pipes in text
-
-                lines.append(
-                    f"| {service_name} | ${previous:.2f} | ${current:.2f} | {trend_icon} {abs(trend_pct):.1f}% | {optimization_clean} |"
-                )
-
-            # Add Others row if there are remaining services
-            remaining_services = sorted_services[10:]
-            if remaining_services:
-                others_current = sum(data.get("current", 0) for _, data in remaining_services)
-                others_previous = sum(data.get("previous", 0) for _, data in remaining_services)
-                others_trend_pct = (
-                    ((others_current - others_previous) / others_previous * 100) if others_previous > 0 else 0
-                )
-                trend_icon = "⬆️" if others_trend_pct > 0 else "⬇️" if others_trend_pct < 0 else "➡️"
-
-                others_row = f"Others ({len(remaining_services)} services)"
-                lines.append(
-                    f"| {others_row} | ${others_previous:.2f} | ${others_current:.2f} | {trend_icon} {abs(others_trend_pct):.1f}% | Review individually for optimization |"
-                )
-
-            lines.append("")
-            lines.append("## Summary")
-            lines.append("")
-            lines.append(f"- **Total Current Cost:** ${total_current:,.2f}")
-            lines.append(f"- **Total Previous Cost:** ${total_previous:,.2f}")
-            trend_icon = "⬆️" if total_trend_pct > 0 else "⬇️" if total_trend_pct < 0 else "➡️"
-            lines.append(f"- **Overall Trend:** {trend_icon} {abs(total_trend_pct):.1f}%")
-            lines.append(f"- **Services Analyzed:** {len(sorted_services)}")
-            lines.append(
-                f"- **Optimization Focus:** {'Review highest cost services' if total_current > 100 else 'Continue monitoring'}"
-            )
-            lines.append("")
-            lines.append("---")
-            lines.append("")
-            lines.append("*Generated by CloudOps Runbooks FinOps Platform*")
-
-            # Write to file
-            with open(file_path, "w") as f:
-                f.write("\n".join(lines))
-
-            print_success(f"Markdown export saved to: {file_path}")
-            self.console.print("[cyan]📋 Ready for GitHub/MkDocs documentation[/]")
-
-        except Exception as e:
-            print_warning(f"Markdown export failed: {str(e)[:50]}")
-
-
-def create_dashboard_router(console: Optional[Console] = None) -> DashboardRouter:
-    """
-    Factory function to create a properly configured dashboard router.
-
-    Args:
-        console: Optional Rich console instance
-
-    Returns:
-        DashboardRouter: Configured router instance
-    """
-    return DashboardRouter(console=console)
-
-
-def route_finops_request(args: argparse.Namespace) -> int:
-    """
-    Main entry point for the new routing system.
-
-    This function can be called from the CLI to enable the enhanced routing
-    while maintaining backward compatibility with existing integrations.
-
-    Args:
-        args: Command line arguments from FinOps CLI
-
-    Returns:
-        int: Exit code (0 for success, 1 for failure)
-    """
-    router = create_dashboard_router()
-    return router.route_dashboard_request(args)