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

runbooks/finops/single_dashboard.py

@@ -1,1113 +0,0 @@
-#!/usr/bin/env python3
-"""
-Single Account Dashboard - Service-Focused FinOps Analysis
-
-This module provides service-focused cost analysis for single AWS accounts,
-optimized for technical users who need detailed service-level insights and
-optimization opportunities within a single account context.
-
-Features:
-- TOP 10 configurable service analysis
-- Service utilization metrics and optimization opportunities
-- Enhanced column values (Last Month trends, Budget Status)
-- Rich CLI presentation (mandatory enterprise standard)
-- Real AWS data integration (no mock data)
-- Performance optimized for <15s execution
-
-Author: CloudOps Runbooks Team
-Version: 0.8.0
-"""
-
-import argparse
-import os
-from datetime import datetime, timedelta
-from typing import Any, Dict, List, Optional, Tuple
-
-import boto3
-from rich import box
-from rich.console import Console
-from rich.panel import Panel
-from rich.progress import BarColumn, Progress, SpinnerColumn, TaskProgressColumn, TextColumn, TimeElapsedColumn
-from rich.table import Column, Table
-
-from ..common.context_logger import create_context_logger, get_context_console
-from ..common.rich_utils import (
-    STATUS_INDICATORS,
-    create_progress_bar,
-    create_table,
-    format_cost,
-    print_error,
-    print_header,
-    print_info,
-    print_success,
-    print_warning,
-)
-from ..common.rich_utils import (
-    console as rich_console,
-)
-from .account_resolver import get_account_resolver
-from .aws_client import get_accessible_regions, get_account_id, get_budgets
-from .budget_integration import EnhancedBudgetAnalyzer
-from .cost_processor import (
-    export_to_csv,
-    export_to_json,
-    filter_analytical_services,
-    get_cost_data,
-    process_service_costs,
-)
-from runbooks.common.profile_utils import (
-    create_cost_session,
-    create_management_session,
-    create_operational_session,
-)
-from .enhanced_progress import EnhancedProgressTracker, OptimizedProgressTracker
-from .helpers import export_cost_dashboard_to_pdf
-
-# Embedded MCP Integration for Cross-Validation (Enterprise Accuracy Standards)
-try:
-    from .embedded_mcp_validator import EmbeddedMCPValidator, validate_finops_results_with_embedded_mcp
-    EMBEDDED_MCP_AVAILABLE = True
-    print_info("Enterprise accuracy validation enabled - Embedded MCP validator loaded successfully")
-except ImportError:
-    EMBEDDED_MCP_AVAILABLE = False
-    print_warning("Cross-validation unavailable - Embedded MCP validation module not found")
-from .service_mapping import get_service_display_name
-
-
-class SingleAccountDashboard:
-    """
-    Service-focused dashboard for single AWS account cost analysis.
-
-    Optimized for technical users who need:
-    - Detailed service-level cost breakdown
-    - Service utilization patterns
-    - Optimization recommendations per service
-    - Trend analysis for cost management
-    """
-
-    def __init__(self, console: Optional[Console] = None):
-        self.console = console or rich_console
-        self.context_logger = create_context_logger("finops.single_dashboard")
-        self.context_console = get_context_console()
-
-        # Sprint 2 Enhancement: Use OptimizedProgressTracker for 82% caching efficiency
-        self.progress_tracker = OptimizedProgressTracker(self.console, enable_message_caching=True)
-        self.budget_analyzer = EnhancedBudgetAnalyzer(self.console)
-        self.account_resolver = None  # Will be initialized with management profile
-
-    def run_dashboard(self, args: argparse.Namespace, config: Dict[str, Any]) -> int:
-        """
-        Main entry point for single account service-focused dashboard.
-
-        Args:
-            args: Command line arguments
-            config: Routing configuration from dashboard router
-
-        Returns:
-            int: Exit code (0 for success, 1 for failure)
-        """
-        try:
-            print_header("Single Account Service Dashboard", "1.1.1")
-
-            # Configuration display (context-aware)
-            top_services = getattr(args, "top_services", 10)
-
-            self.context_logger.info(
-                f"Service-focused analysis configured for TOP {top_services} services",
-                technical_detail="Optimizing for service-level insights for technical teams",
-            )
-
-            # Show detailed configuration only for CLI users
-            if self.context_console.config.show_technical_details:
-                print_info(f"🎯 Analysis Focus: TOP {top_services} Services")
-                print_info("• Optimization Target: Service-level insights")
-                print_info("• User Profile: Technical teams\n")
-
-            # Get profile for analysis
-            profile = self._determine_analysis_profile(args)
-
-            # Validate profile access
-            if not self._validate_profile_access(profile):
-                return 1
-
-            # Run service-focused analysis
-            return self._execute_service_analysis(profile, args, top_services)
-
-        except Exception as e:
-            print_error(f"Single account dashboard failed: {str(e)}")
-            return 1
-
-    def _determine_analysis_profile(self, args: argparse.Namespace) -> str:
-        """Determine which profile to use for analysis."""
-        if hasattr(args, "profile") and args.profile and args.profile != "default":
-            return args.profile
-        elif hasattr(args, "profiles") and args.profiles:
-            return args.profiles[0]  # Use first profile
-        else:
-            return "default"
-
-    def _validate_profile_access(self, profile: str) -> bool:
-        """Validate that the profile has necessary access."""
-        try:
-            # Test basic access
-            session = boto3.Session(profile_name=profile)
-            sts = session.client("sts")
-            identity = sts.get_caller_identity()
-
-            account_id = identity["Account"]
-            print_success(f"Profile validation successful: {profile} -> {account_id}")
-            return True
-
-        except Exception as e:
-            print_error(f"Profile validation failed: {str(e)}")
-            return False
-
-    def _execute_service_analysis(self, profile: str, args: argparse.Namespace, top_services: int) -> int:
-        """Execute the service-focused cost analysis."""
-        try:
-            # Initialize sessions
-            cost_session = create_cost_session(profile)
-            mgmt_session = create_management_session(profile)
-            ops_session = create_operational_session(profile)
-
-            # Initialize account resolver for readable account names
-            management_profile = os.getenv("MANAGEMENT_PROFILE") or profile
-            self.account_resolver = get_account_resolver(management_profile)
-
-            # Get basic account information
-            account_id = get_account_id(mgmt_session) or "Unknown"
-
-            with self.progress_tracker.create_enhanced_progress("service_analysis", 100) as progress:
-                # Phase 1: Cost data collection (0-30%)
-                progress.start_operation("Initializing service analysis...")
-
-                try:
-                    progress.update_step("Collecting current cost data...", 15)
-                    cost_data = get_cost_data(
-                        cost_session,
-                        getattr(args, "time_range", None),
-                        getattr(args, "tag", None),
-                        profile_name=profile,
-                    )
-
-                    progress.update_step("Processing service cost breakdown...", 25)
-                    # Get enhanced cost breakdown
-                    service_costs, service_cost_data = process_service_costs(cost_data)
-
-                    progress.update_step("Analyzing cost trends...", 35)
-                    # Get last month data for trend analysis
-                    last_month_data = self._get_last_month_trends(cost_session, profile)
-
-                except Exception as e:
-                    print_warning(f"Cost data collection failed: {str(e)[:50]}")
-                    progress.update_step("Using fallback data due to API issues...", 30)
-                    # Continue with limited data
-                    cost_data = {"current_month": 0, "last_month": 0, "costs_by_service": {}}
-                    service_costs = []
-                    last_month_data = {}
-
-                # Phase 2: Enhanced budget analysis (40-70%)
-                try:
-                    progress.update_step("Collecting budget information...", 45)
-                    budget_data = get_budgets(cost_session)
-
-                    progress.update_step("Analyzing service utilization patterns...", 60)
-                    # Service utilization analysis
-                    utilization_data = self._analyze_service_utilization(ops_session, cost_data)
-
-                    progress.update_step("Generating optimization recommendations...", 75)
-                    # Simulate processing time for optimization analysis
-                    import time
-
-                    time.sleep(0.5)  # Brief processing simulation for smooth progress
-
-                except Exception as e:
-                    print_warning(f"Budget/utilization analysis failed: {str(e)[:50]}")
-                    progress.update_step("Using basic analysis due to API limitations...", 65)
-                    budget_data = []
-                    utilization_data = {}
-
-                # Phase 3: Table generation and formatting (80-100%)
-                progress.update_step("Preparing service-focused table...", 85)
-                # Brief pause for table preparation
-                import time
-
-                time.sleep(0.3)
-
-                progress.update_step("Formatting optimization recommendations...", 95)
-                # Final formatting step
-
-                progress.complete_operation("Service analysis completed successfully")
-
-            # Create and display the service-focused table
-            self._display_service_focused_table(
-                account_id=account_id,
-                profile=profile,
-                cost_data=cost_data,
-                service_costs=service_costs,
-                last_month_data=last_month_data,
-                budget_data=budget_data,
-                utilization_data=utilization_data,
-                top_services=top_services,
-            )
-
-            # Export if requested
-            if hasattr(args, "report_name") and args.report_name:
-                self._export_service_analysis(args, cost_data, service_costs, account_id)
-
-            # Export to markdown if requested
-            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:
-                # Prepare service data for markdown export with Tax filtering
-                current_services = cost_data.get("costs_by_service", {})
-                previous_services = last_month_data.get("costs_by_service", {})  # Use already collected data
-                quarterly_services = last_month_data.get("quarterly_costs_by_service", {})  # Add quarterly data
-
-                # Apply same Tax filtering for consistent markdown export
-                filtered_current_services = filter_analytical_services(current_services)
-                filtered_previous_services = filter_analytical_services(previous_services)
-                filtered_quarterly_services = filter_analytical_services(quarterly_services)
-
-                all_services_sorted = sorted(filtered_current_services.items(), key=lambda x: x[1], reverse=True)
-
-                # Calculate totals for markdown export with quarterly context
-                total_current = cost_data.get("current_month", 0)
-                total_previous = cost_data.get("last_month", 0)
-                total_quarterly = sum(filtered_quarterly_services.values())
-                total_trend_pct = ((total_current - total_previous) / total_previous * 100) if total_previous > 0 else 0
-
-                self._export_service_table_to_markdown(
-                    all_services_sorted,
-                    filtered_current_services,
-                    filtered_previous_services,
-                    filtered_quarterly_services,
-                    profile,
-                    account_id,
-                    total_current,
-                    total_previous,
-                    total_quarterly,
-                    total_trend_pct,
-                    args,
-                )
-
-            print_success(f"Service analysis completed for account {account_id}")
-
-            # Export functionality - Add PDF/CSV/JSON support to enhanced router
-            # Get service data for export (recreate since it's scoped to display function)
-            current_services = cost_data.get("costs_by_service", {})
-            filtered_services = filter_analytical_services(current_services)
-            service_list = sorted(filtered_services.items(), key=lambda x: x[1], reverse=True)
-            self._handle_exports(args, profile, account_id, service_list, cost_data, last_month_data)
-
-            # MCP Cross-Validation for Enterprise Accuracy Standards (>=99.5%)
-            # Note: User explicitly requested real MCP validation after discovering fabricated accuracy claims
-            validate_flag = getattr(args, 'validate', False)
-            if validate_flag or EMBEDDED_MCP_AVAILABLE:
-                if EMBEDDED_MCP_AVAILABLE:
-                    self._run_embedded_mcp_validation([profile], cost_data, service_list, args)
-                else:
-                    print_warning("MCP validation requested but not available - check MCP server configuration")
-
-            # Sprint 2 Enhancement: Display performance metrics for enterprise audit compliance
-            self._display_sprint2_performance_metrics()
-
-            return 0
-
-        except Exception as e:
-            print_error(f"Service analysis execution failed: {str(e)}")
-            return 1
-
-    def _get_last_month_trends(self, cost_session: boto3.Session, profile: str) -> Dict[str, Any]:
-        """
-        Get accurate trend data using equal-period comparisons with quarterly context.
-        
-        MATHEMATICAL FIX: Replaces the previous implementation that used 60-day time ranges
-        which created unequal period comparisons (e.g., 2 days vs 31 days).
-        
-        Now uses month-to-date vs same period from previous month for accurate trends,
-        enhanced with quarterly data for strategic financial intelligence.
-        """
-        try:
-            # Use the corrected get_cost_data function without time_range parameter
-            # This will use the enhanced logic for equal-period comparisons
-            corrected_trend_data = get_cost_data(cost_session, None, None, profile_name=profile)
-            
-            # ENHANCEMENT: Add quarterly cost data for strategic context
-            from .cost_processor import get_quarterly_cost_data
-            quarterly_costs = get_quarterly_cost_data(cost_session, profile_name=profile)
-            
-            # Integrate quarterly data into trend data structure
-            corrected_trend_data["quarterly_costs_by_service"] = quarterly_costs
-            
-            # Enhanced trend analysis context with MCP validation awareness
-            if "period_metadata" in corrected_trend_data:
-                metadata = corrected_trend_data["period_metadata"]
-                current_days = metadata.get("current_days", 0)
-                previous_days = metadata.get("previous_days", 0)
-                days_difference = metadata.get("days_difference", abs(current_days - previous_days))
-                reliability = metadata.get("trend_reliability", "unknown")
-                alignment_strategy = metadata.get("period_alignment_strategy", "standard")
-                
-                # ENHANCED LOGIC: Reduce warnings when using intelligent period alignment
-                if metadata.get("is_partial_comparison", False):
-                    if alignment_strategy == "equal_days":
-                        # Equal-day comparison reduces the severity of partial period concerns
-                        print_info(f"🔄 Enhanced period alignment: {current_days} vs {previous_days} days (equal-day strategy)")
-                        if reliability in ["high", "medium_with_validation_support"]:
-                            print_success(f"✅ Trend reliability: {reliability} (enhanced alignment)")
-                        else:
-                            print_info(f"Trend reliability: {reliability}")
-                    else:
-                        # Standard partial period warning for traditional comparisons
-                        print_warning(f"⚠️ Partial period comparison: {current_days} vs {previous_days} days")
-                        print_info(f"Trend reliability: {reliability}")
-                        
-                    # Add context for very small differences
-                    if days_difference <= 5:
-                        print_info(f"💡 Small period difference ({days_difference} days) - trends should be reliable")
-                else:
-                    print_success(f"✅ Equal period comparison: {current_days} vs {previous_days} days")
-            
-            return corrected_trend_data
-            
-        except Exception as e:
-            print_warning(f"Enhanced trend data collection failed: {str(e)[:50]}")
-            # Return basic structure to prevent downstream errors
-            return {
-                "current_month": 0,
-                "last_month": 0,
-                "costs_by_service": {},
-                "quarterly_costs_by_service": {},  # Added for quarterly intelligence
-                "period_metadata": {
-                    "current_days": 0,
-                    "previous_days": 0,
-                    "is_partial_comparison": True,
-                    "trend_reliability": "unavailable"
-                }
-            }
-
-    def _analyze_service_utilization(self, ops_session: boto3.Session, cost_data: Dict[str, Any]) -> Dict[str, Any]:
-        """Analyze service utilization patterns for optimization opportunities."""
-        utilization_data = {}
-
-        try:
-            # Basic service utilization patterns (can be expanded)
-            services_with_costs = cost_data.get("costs_by_service", {})
-
-            for service, cost in services_with_costs.items():
-                utilization_data[service] = {
-                    "cost": cost,
-                    "optimization_potential": "Medium",  # Placeholder - can be enhanced
-                    "utilization_score": 75,  # Placeholder - can be enhanced with CloudWatch
-                    "recommendation": self._get_service_recommendation(service, cost),
-                }
-
-        except Exception as e:
-            print_warning(f"Utilization analysis failed: {str(e)[:30]}")
-
-        return utilization_data
-
-    def _get_service_recommendation(self, service: str, cost: float) -> str:
-        """Get optimization recommendation for a service based on cost patterns."""
-        if cost == 0:
-            return "No usage detected"
-        elif "ec2" in service.lower():
-            return "Review instance sizing"
-        elif "s3" in service.lower():
-            return "Check storage classes"
-        elif "rds" in service.lower():
-            return "Evaluate instance types"
-        else:
-            return "Monitor usage patterns"
-
-    def _get_enhanced_service_recommendation(self, service: str, current_cost: float, previous_cost: float) -> str:
-        """Get enhanced service-specific optimization recommendations with trend awareness."""
-        if current_cost == 0:
-            return "[dim]No current usage - consider resource cleanup[/]"
-
-        # Calculate cost trend for context-aware recommendations
-        trend_factor = 1.0
-        if previous_cost > 0:
-            trend_factor = current_cost / previous_cost
-
-        service_lower = service.lower()
-
-        if "ec2" in service_lower or "compute" in service_lower:
-            if trend_factor > 1.2:
-                return "[red]High growth: review scaling policies & rightsizing[/]"
-            elif current_cost > 1000:
-                return "[yellow]Significant cost: analyze Reserved Instance opportunities[/]"
-            else:
-                return "[green]Monitor CPU utilization & consider spot instances[/]"
-
-        elif "s3" in service_lower or "storage" in service_lower:
-            if trend_factor > 1.3:
-                return "[red]Storage growth: implement lifecycle policies[/]"
-            elif current_cost > 500:
-                return "[yellow]Review storage classes: Standard → IA/Glacier[/]"
-            else:
-                return "[green]Optimize object lifecycle & access patterns[/]"
-
-        elif "rds" in service_lower or "database" in service_lower:
-            if current_cost > 1500:
-                return "[yellow]High DB costs: evaluate instance types & Reserved[/]"
-            else:
-                return "[green]Monitor connections & consider read replicas[/]"
-
-        elif "lambda" in service_lower or "serverless" in service_lower:
-            if trend_factor > 1.5:
-                return "[red]Function invocations increasing: optimize runtime[/]"
-            else:
-                return "[green]Review memory allocation & execution time[/]"
-
-        elif "glue" in service_lower:
-            if current_cost > 75:
-                return "[yellow]Review job frequency & data processing efficiency[/]"
-            else:
-                return "[green]Monitor ETL job performance & scheduling[/]"
-
-        elif "tax" in service_lower:
-            return "[dim]Regulatory requirement - no optimization available[/]"
-
-        elif "cloudwatch" in service_lower or "monitoring" in service_lower:
-            if current_cost > 100:
-                return "[yellow]High monitoring costs: review log retention[/]"
-            else:
-                return "[green]Optimize custom metrics & log groups[/]"
-
-        elif "nat" in service_lower or "gateway" in service_lower:
-            if current_cost > 200:
-                return "[yellow]High NAT costs: consider VPC endpoints[/]"
-            else:
-                return "[green]Monitor data transfer patterns[/]"
-
-        else:
-            # Generic recommendations based on cost level
-            if current_cost > 1000:
-                return f"[yellow]High cost service: detailed analysis recommended[/]"
-            elif trend_factor > 1.3:
-                return f"[red]Growing cost: investigate usage increase[/]"
-            else:
-                return f"[green]Monitor usage patterns & optimization opportunities[/]"
-
-    def _display_service_focused_table(
-        self,
-        account_id: str,
-        profile: str,
-        cost_data: Dict[str, Any],
-        service_costs: List[str],
-        last_month_data: Dict[str, Any],
-        budget_data: List[Dict[str, Any]],
-        utilization_data: Dict[str, Any],
-        top_services: int,
-    ) -> None:
-        """Display the service-focused analysis table."""
-
-        # Create enhanced table for service analysis (service-per-row layout)
-        # Get readable account name for display
-        if self.account_resolver and account_id != "Unknown":
-            account_name = self.account_resolver.get_account_name(account_id)
-            if account_name and account_name != account_id:
-                account_display = f"{account_name} ({account_id})"
-                account_caption = f"Account: {account_name}"
-            else:
-                account_display = account_id
-                account_caption = f"Account ID: {account_id}"
-        else:
-            account_display = account_id
-            account_caption = f"Profile: {profile}"
-
-        table = Table(
-            Column("Service", style="resource", width=20),
-            Column("Current Cost", justify="right", style="cost", width=15),
-            Column("Last Month", justify="right", width=12),
-            Column("Last Quarter", justify="right", width=12),
-            Column("Trend", justify="center", width=16),
-            Column("Optimization Opportunities", width=35),
-            title=f"🎯 TOP {top_services} Services Analysis - {account_display}",
-            box=box.ROUNDED,
-            show_lines=True,
-            style="bright_cyan",
-            caption=f"[dim]Service-focused analysis with quarterly intelligence • {account_caption} • Each row represents one service[/]",
-        )
-
-        # Get current, previous, and quarterly service costs
-        current_services = cost_data.get("costs_by_service", {})
-        previous_services = last_month_data.get("costs_by_service", {})
-        quarterly_services = last_month_data.get("quarterly_costs_by_service", {})
-
-        # WIP.md requirement: Exclude "Tax" service as it provides no analytical insights
-        # Use centralized filtering function for consistency across all dashboards
-        filtered_current_services = filter_analytical_services(current_services)
-        filtered_previous_services = filter_analytical_services(previous_services)
-        filtered_quarterly_services = filter_analytical_services(quarterly_services)
-
-        # Create comprehensive service list from current, previous, and quarterly periods
-        # This ensures services appear even when current costs are $0 but historical costs existed
-        all_service_names = set(filtered_current_services.keys()) | set(filtered_previous_services.keys()) | set(filtered_quarterly_services.keys())
-        
-        # Build service data with current, previous, and quarterly costs for intelligent sorting
-        service_data = []
-        for service_name in all_service_names:
-            current_cost = filtered_current_services.get(service_name, 0.0)
-            previous_cost = filtered_previous_services.get(service_name, 0.0)
-            quarterly_cost = filtered_quarterly_services.get(service_name, 0.0)
-            
-            # Sort by max(current_cost, previous_cost, quarterly_cost) to show most relevant services first
-            # This ensures services with historical significance appear prominently
-            max_cost = max(current_cost, previous_cost, quarterly_cost)
-            service_data.append((service_name, current_cost, previous_cost, quarterly_cost, max_cost))
-        
-        # Sort by maximum cost across current, previous, and quarterly periods
-        all_services = sorted(service_data, key=lambda x: x[4], reverse=True)
-        top_services_list = all_services[:top_services]
-        remaining_services = all_services[top_services:]
-
-        # Add individual service rows
-        for service, current_cost, previous_cost, quarterly_cost, _ in top_services_list:
-
-            # Calculate trend using quarterly-enhanced intelligence
-            from .cost_processor import calculate_quarterly_enhanced_trend
-            
-            # Get period metadata for intelligent trend analysis
-            period_metadata = last_month_data.get("period_metadata", {})
-            current_days = period_metadata.get("current_days")
-            previous_days = period_metadata.get("previous_days")
-            
-            # Use quarterly-enhanced trend calculation with strategic context
-            trend_display = calculate_quarterly_enhanced_trend(
-                current_cost, 
-                previous_cost, 
-                quarterly_cost,
-                current_days, 
-                previous_days
-            )
-            
-            # Apply Rich formatting to the trend display
-            if "⚠️" in trend_display:
-                trend_display = f"[yellow]{trend_display}[/]"
-            elif "↑" in trend_display:
-                trend_display = f"[red]{trend_display}[/]"
-            elif "↓" in trend_display:
-                trend_display = f"[green]{trend_display}[/]"
-            elif "→" in trend_display:
-                trend_display = f"[yellow]{trend_display}[/]"
-            else:
-                trend_display = f"[dim]{trend_display}[/]"
-
-            # Enhanced service-specific optimization recommendations
-            optimization_rec = self._get_enhanced_service_recommendation(service, current_cost, previous_cost)
-
-            # Use standardized service name mapping (RDS, S3, CloudWatch, etc.)
-            display_name = get_service_display_name(service)
-
-            table.add_row(
-                display_name, format_cost(current_cost), format_cost(previous_cost), format_cost(quarterly_cost), trend_display, optimization_rec
-            )
-
-        # Add "Other Services" summary row if there are remaining services
-        if remaining_services:
-            other_current = sum(current_cost for _, current_cost, _, _, _ in remaining_services)
-            other_previous = sum(previous_cost for _, _, previous_cost, _, _ in remaining_services)
-            other_quarterly = sum(quarterly_cost for _, _, _, quarterly_cost, _ in remaining_services)
-
-            # Use quarterly-enhanced trend calculation for "Other Services" as well
-            other_trend = calculate_quarterly_enhanced_trend(
-                other_current,
-                other_previous,
-                other_quarterly,
-                current_days,
-                previous_days
-            )
-            
-            # Apply Rich formatting
-            if "⚠️" in other_trend:
-                other_trend = f"[yellow]{other_trend}[/]"
-            elif "↑" in other_trend:
-                other_trend = f"[red]{other_trend}[/]"
-            elif "↓" in other_trend:
-                other_trend = f"[green]{other_trend}[/]"
-            elif "→" in other_trend:
-                other_trend = f"[yellow]{other_trend}[/]"
-            else:
-                other_trend = f"[dim]{other_trend}[/]"
-
-            other_optimization = (
-                f"[dim]{len(remaining_services)} services: review individually for optimization opportunities[/]"
-            )
-
-            # Add separator line for "Other Services"
-            table.add_row(
-                "[dim]Other Services[/]",
-                format_cost(other_current),
-                format_cost(other_previous),
-                format_cost(other_quarterly),
-                other_trend,
-                other_optimization,
-                style="dim",
-            )
-
-        rich_console.print(table)
-
-        # Summary panel (using filtered services for consistent analysis)
-        total_current = sum(filtered_current_services.values())
-        total_previous = sum(filtered_previous_services.values())
-        total_quarterly = sum(filtered_quarterly_services.values())
-        
-        # Use quarterly-enhanced trend calculation for total trend as well
-        total_trend_display = calculate_quarterly_enhanced_trend(
-            total_current,
-            total_previous,
-            total_quarterly,
-            current_days,
-            previous_days
-        )
-
-        # Use readable account name in summary
-        if self.account_resolver and account_id != "Unknown":
-            account_name = self.account_resolver.get_account_name(account_id)
-            if account_name and account_name != account_id:
-                account_summary_line = f"• Account: {account_name} ({account_id})"
-            else:
-                account_summary_line = f"• Account ID: {account_id}"
-        else:
-            account_summary_line = f"• Profile: {profile}"
-
-        # Add period information to summary for transparency
-        period_info = ""
-        if period_metadata.get("is_partial_comparison", False):
-            period_info = f"\n• Period Comparison: {current_days} vs {previous_days} days (partial month)"
-        else:
-            period_info = f"\n• Period Comparison: {current_days} vs {previous_days} days (equal periods)"
-        
-        summary_text = f"""
-[highlight]Account Summary[/]
-{account_summary_line}
-• Total Current: {format_cost(total_current)}
-• Total Previous: {format_cost(total_previous)}
-• Total Quarterly: {format_cost(total_quarterly)}
-• Overall Trend: {total_trend_display}
-• Services Analyzed: {len(all_services)}{period_info}
-        """
-
-        rich_console.print(Panel(summary_text.strip(), title="📊 Analysis Summary", style="info"))
-
-    def _export_service_analysis(
-        self, args: argparse.Namespace, cost_data: Dict[str, Any], service_costs: List[str], account_id: str
-    ) -> None:
-        """Export service analysis results."""
-        try:
-            if hasattr(args, "report_type") and args.report_type:
-                export_data = [
-                    {
-                        "account_id": account_id,
-                        "service_costs": cost_data.get("costs_by_service", {}),
-                        "total_current": cost_data.get("current_month", 0),
-                        "total_previous": cost_data.get("last_month", 0),
-                        "analysis_type": "service_focused",
-                    }
-                ]
-
-                for report_type in args.report_type:
-                    if report_type == "json":
-                        json_path = export_to_json(export_data, args.report_name, getattr(args, "dir", None))
-                        if json_path:
-                            print_success(f"Service analysis exported to JSON: {json_path}")
-                    elif report_type == "csv":
-                        csv_path = export_to_csv(export_data, args.report_name, getattr(args, "dir", None))
-                        if csv_path:
-                            print_success(f"Service analysis exported to CSV: {csv_path}")
-
-        except Exception as e:
-            print_warning(f"Export failed: {str(e)[:50]}")
-
-    def _export_service_table_to_markdown(
-        self,
-        sorted_services,
-        current_services,
-        previous_services,
-        quarterly_services,
-        profile,
-        account_id,
-        total_current,
-        total_previous,
-        total_quarterly,
-        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("")
-            # Use readable account name in markdown export
-            if self.account_resolver and account_id != "Unknown":
-                account_name = self.account_resolver.get_account_name(account_id)
-                if account_name and account_name != account_id:
-                    account_line = f"**Account:** {account_name} ({account_id})"
-                else:
-                    account_line = f"**Account ID:** {account_id}"
-            else:
-                account_line = f"**Profile:** {profile}"
-
-            lines.append(f"**Generated:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
-            lines.append(account_line)
-            lines.append("")
-            lines.append("## Service Cost Breakdown")
-            lines.append("")
-
-            # Create GitHub-compatible markdown table with quarterly intelligence
-            lines.append("| Service | Current Cost | Last Month | Last Quarter | Trend | Optimization Opportunities |")
-            lines.append("| --- | ---: | ---: | ---: | :---: | --- |")  # GitHub-compliant alignment with quarterly column
-
-            # Add TOP 10 services with quarterly context
-            for i, (service_name, current_cost) in enumerate(sorted_services[:10]):
-                previous_cost = previous_services.get(service_name, 0)
-                quarterly_cost = quarterly_services.get(service_name, 0)
-                trend_pct = ((current_cost - previous_cost) / previous_cost * 100) if previous_cost > 0 else 0
-                trend_icon = "⬆️" if trend_pct > 0 else "⬇️" if trend_pct < 0 else "➡️"
-
-                # Generate optimization recommendation with quarterly context
-                optimization = self._get_service_optimization(service_name, current_cost, previous_cost)
-
-                # Format row for GitHub-compatible table with quarterly data
-                service_name_clean = service_name.replace("|", "\\|")  # Escape pipes in service names
-                optimization_clean = optimization.replace("|", "\\|")  # Escape pipes in text
-
-                lines.append(
-                    f"| {service_name_clean} | ${current_cost:.2f} | ${previous_cost:.2f} | ${quarterly_cost:.2f} | {trend_icon} {abs(trend_pct):.1f}% | {optimization_clean} |"
-                )
-
-            # Add Others row with quarterly context if there are remaining services
-            remaining_services = sorted_services[10:]
-            if remaining_services:
-                others_current = sum(current_cost for _, current_cost in remaining_services)
-                others_previous = sum(previous_services.get(service_name, 0) for service_name, _ in remaining_services)
-                others_quarterly = sum(quarterly_services.get(service_name, 0) for service_name, _ 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_current:.2f} | ${others_previous:.2f} | ${others_quarterly:.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}")
-            lines.append(f"- **Total Quarterly Cost:** ${total_quarterly:,.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}")
-            print_info("📋 Ready for GitHub/MkDocs documentation")
-
-        except Exception as e:
-            print_warning(f"Markdown export failed: {str(e)[:50]}")
-
-    def _get_service_optimization(self, service, current, previous):
-        """Get optimization recommendation for a service."""
-        service_lower = service.lower()
-
-        # Generate optimization recommendations based on service type and cost
-        if current > 10000:  # High cost services
-            if "rds" in service_lower or "database" in service_lower:
-                return "High DB costs: evaluate instance types & Reserved Instances"
-            elif "ec2" in service_lower:
-                return "Significant cost: analyze Reserved Instance opportunities"
-            else:
-                return "High cost service: detailed analysis recommended"
-        elif current > 1000:  # Medium cost services
-            if "lambda" in service_lower:
-                return "Review memory allocation & execution time"
-            elif "cloudwatch" in service_lower:
-                return "High monitoring costs: review log retention"
-            elif "s3" in service_lower:
-                return "Review storage classes: Standard → IA/Glacier"
-            else:
-                return "Monitor usage patterns & optimization opportunities"
-        else:  # Lower cost services
-            return "Continue monitoring for optimization opportunities"
-    
-    def _handle_exports(self, args: argparse.Namespace, profile: str, account_id: str, 
-                       services_data, cost_data, last_month_data) -> None:
-        """Handle all export formats for enhanced router."""
-        if not (hasattr(args, 'report_name') and args.report_name and 
-                hasattr(args, 'report_type') and args.report_type):
-            return
-            
-        print_info("📊 Processing export requests...")
-        
-        # Convert service data to ProfileData format compatible with existing export functions
-        from .types import ProfileData
-        
-        try:
-            # Create ProfileData compatible structure with dual-metric foundation
-            export_data = [ProfileData(
-                profile_name=profile,
-                account_id=account_id,
-                current_month=cost_data.get("current_month", 0),  # Primary: UnblendedCost
-                current_month_formatted=f"${cost_data.get('current_month', 0):,.2f}",
-                previous_month=cost_data.get("last_month", 0),  # Primary: UnblendedCost
-                previous_month_formatted=f"${cost_data.get('last_month', 0):,.2f}",
-                # Dual-metric architecture foundation (to be implemented)
-                current_month_amortized=None,  # Secondary: AmortizedCost
-                previous_month_amortized=None,  # Secondary: AmortizedCost  
-                current_month_amortized_formatted=None,
-                previous_month_amortized_formatted=None,
-                metric_context="technical",  # Default to technical context (UnblendedCost)
-                service_costs=[],  # Service costs in simplified format
-                service_costs_formatted=[f"${cost:.2f}" for _, cost in services_data[:10]],
-                budget_info=[],
-                ec2_summary={},
-                ec2_summary_formatted=[],
-                success=True,
-                error=None,
-                current_period_name="Current Month",
-                previous_period_name="Previous Month",
-                percent_change_in_total_cost=None
-            )]
-            
-            # Process each requested export type
-            export_count = 0
-            for report_type in args.report_type:
-                if report_type == "pdf":
-                    print_info("Generating PDF export...")
-                    pdf_path = export_cost_dashboard_to_pdf(
-                        export_data,
-                        args.report_name,
-                        getattr(args, 'dir', None),
-                        previous_period_dates="Previous Month",
-                        current_period_dates="Current Month"
-                    )
-                    if pdf_path:
-                        print_success(f"PDF export completed: {pdf_path}")
-                        export_count += 1
-                    else:
-                        print_error("PDF export failed")
-                        
-                elif report_type == "csv":
-                    print_info("Generating CSV export...")
-                    from .cost_processor import export_to_csv
-                    csv_path = export_to_csv(
-                        export_data,
-                        args.report_name,
-                        getattr(args, 'dir', None),
-                        previous_period_dates="Previous Month", 
-                        current_period_dates="Current Month"
-                    )
-                    if csv_path:
-                        print_success(f"CSV export completed: {csv_path}")
-                        export_count += 1
-                        
-                elif report_type == "json":
-                    print_info("Generating JSON export...")
-                    from .cost_processor import export_to_json
-                    json_path = export_to_json(export_data, args.report_name, getattr(args, 'dir', None))
-                    if json_path:
-                        print_success(f"JSON export completed: {json_path}")
-                        export_count += 1
-                        
-                elif report_type == "markdown":
-                    print_info("Generating Markdown export...")
-                    # Use existing markdown export functionality
-                    self._export_service_table_to_markdown(
-                        services_data[:10], {}, {},  # Simplified data structure
-                        profile, account_id, 
-                        cost_data.get("current_month", 0),
-                        cost_data.get("last_month", 0),
-                        0, args  # Simplified trend calculation
-                    )
-                    export_count += 1
-                        
-            if export_count > 0:
-                print_success(f"{export_count} exports completed successfully")
-            else:
-                print_warning("No exports were generated")
-                
-        except Exception as e:
-            print_error(f"Export failed: {str(e)}")
-            import traceback
-            self.console.print(f"[red]Details: {traceback.format_exc()}[/]")
-
-    def _run_embedded_mcp_validation(self, profiles: List[str], cost_data: Dict[str, Any], 
-                                   service_list: List[Tuple[str, float]], args: argparse.Namespace) -> None:
-        """
-        Run embedded MCP cross-validation for single account dashboard with real-time AWS API comparison.
-        
-        This addresses the user's critical feedback about fabricated accuracy claims by providing
-        genuine MCP validation with actual AWS Cost Explorer API cross-validation.
-        """
-        try:
-            self.console.print(f"\n[bright_cyan]🔍 Embedded MCP Cross-Validation: Enterprise Accuracy Check[/]")
-            self.console.print(f"[dim]Validating single account with direct AWS API integration[/]")
-
-            # Prepare runbooks data in format expected by MCP validator
-            runbooks_data = {
-                profiles[0]: {
-                    "total_cost": cost_data.get("current_month", 0),
-                    "services": dict(service_list) if service_list else {},
-                    "profile": profiles[0],
-                }
-            }
-
-            # Run embedded validation
-            validator = EmbeddedMCPValidator(profiles=profiles, console=self.console)
-            validation_results = validator.validate_cost_data(runbooks_data)
-
-            # Enhanced results display with detailed variance information (same as dashboard_runner.py)
-            overall_accuracy = validation_results.get("total_accuracy", 0)
-            profiles_validated = validation_results.get("profiles_validated", 0)
-            passed = validation_results.get("passed_validation", False)
-            profile_results = validation_results.get("profile_results", [])
-
-            self.console.print(f"\n[bright_cyan]🔍 MCP Cross-Validation Results:[/]")
-            
-            # Display detailed per-profile results
-            for profile_result in profile_results:
-                profile_name = profile_result.get("profile", "Unknown")[:30]
-                runbooks_cost = profile_result.get("runbooks_cost", 0)
-                aws_cost = profile_result.get("aws_api_cost", 0)
-                accuracy = profile_result.get("accuracy_percent", 0)
-                cost_diff = profile_result.get("cost_difference", 0)
-                
-                if profile_result.get("error"):
-                    self.console.print(f"├── {profile_name}: [red]❌ Error: {profile_result['error']}[/]")
-                else:
-                    variance_pct = 100 - accuracy if accuracy > 0 else 100
-                    self.console.print(f"├── {profile_name}:")
-                    self.console.print(f"│   ├── Runbooks Cost: ${runbooks_cost:,.2f}")
-                    self.console.print(f"│   ├── MCP API Cost: ${aws_cost:,.2f}")
-                    self.console.print(f"│   ├── Variance: ${cost_diff:,.2f} ({variance_pct:.2f}%)")
-                    
-                    if accuracy >= 99.5:
-                        self.console.print(f"│   └── Status: [green]✅ {accuracy:.2f}% accuracy[/]")
-                    elif accuracy >= 95.0:
-                        self.console.print(f"│   └── Status: [yellow]⚠️  {accuracy:.2f}% accuracy[/]")
-                    else:
-                        self.console.print(f"│   └── Status: [red]❌ {accuracy:.2f}% accuracy[/]")
-            
-            # Overall summary
-            if passed:
-                self.console.print(f"└── [bright_green]✅ MCP Validation PASSED: {overall_accuracy:.2f}% overall accuracy[/]")
-                self.console.print(f"    [green]🏢 Enterprise compliance: {profiles_validated}/{len(profiles)} profiles validated[/]")
-            else:
-                self.console.print(f"└── [bright_yellow]⚠️ MCP Validation: {overall_accuracy:.2f}% overall accuracy[/]")
-                self.console.print(f"    [yellow]📊 Enterprise target: ≥99.5% accuracy required for compliance[/]")
-
-            # Save validation report
-            import json
-            import os
-            from datetime import datetime
-            
-            validation_file = (
-                f"artifacts/validation/embedded_mcp_validation_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
-            )
-            os.makedirs(os.path.dirname(validation_file), exist_ok=True)
-            
-            with open(validation_file, "w") as f:
-                json.dump(validation_results, f, indent=2, default=str)
-            
-            self.console.print(f"[cyan]📋 Validation report saved: {validation_file}[/]")
-
-        except Exception as e:
-            self.console.print(f"[red]❌ Embedded MCP validation failed: {str(e)[:100]}[/]")
-            self.console.print(f"[dim]Continuing with standard FinOps analysis[/]")
-
-    def _display_sprint2_performance_metrics(self) -> None:
-        """
-        Display Sprint 2 performance metrics for enterprise audit compliance.
-
-        Shows:
-        - Progress message caching efficiency (82% target)
-        - Console operation reduction achievements
-        - Enterprise audit trail summary
-        """
-        try:
-            # Get progress tracker metrics
-            audit_summary = self.progress_tracker.get_audit_summary()
-
-            # Create performance metrics panel
-            metrics_content = f"""[dim]Progress Message Caching:[/dim]
-• Cache Efficiency: {audit_summary['cache_efficiency']:.1f}%
-• Target Achievement: {'✅ Met' if audit_summary['efficiency_achieved'] else '⚠️ Pending'} (Target: {audit_summary['target_efficiency']}%)
-• Cache Operations: {audit_summary['cache_hits']} hits, {audit_summary['cache_misses']} misses
-
-[dim]Enterprise Audit Compliance:[/dim]
-• Session ID: {audit_summary['session_id']}
-• Total Operations: {audit_summary['total_operations']}
-• Audit Trail Length: {audit_summary['audit_trail_count']}
-
-[dim]Sprint 2 Achievements:[/dim]
-• Message caching system operational
-• Business context enhancement integrated
-• Enterprise audit trail generation active
-• Performance targets tracking enabled"""
-
-            metrics_panel = Panel(
-                metrics_content,
-                title="[bold cyan]📊 Sprint 2 Performance Metrics[/bold cyan]",
-                border_style="cyan",
-                padding=(1, 2)
-            )
-
-            self.console.print(f"\n{metrics_panel}")
-
-            # Log metrics for enterprise reporting
-            metrics_details = (
-                f"Cache efficiency: {audit_summary['cache_efficiency']:.1f}%, "
-                f"Target achieved: {audit_summary['efficiency_achieved']}, "
-                f"Session operations: {audit_summary['total_operations']}"
-            )
-            self.context_logger.info(
-                "Sprint 2 performance metrics displayed",
-                technical_detail=metrics_details
-            )
-
-        except Exception as e:
-            # Graceful degradation - don't fail the main dashboard
-            print_warning(f"Sprint 2 metrics display failed: {str(e)[:50]}")
-
-
-def create_single_dashboard(console: Optional[Console] = None) -> SingleAccountDashboard:
-    """Factory function to create single account dashboard."""
-    return SingleAccountDashboard(console=console)