aws-inventory-manager 0.2.0__py3-none-any.whl

src/cost/__init__.py

@@ -0,0 +1,5 @@
+"""Cost analysis module for tracking baseline vs non-baseline costs."""
+
+from typing import List
+
+__all__: List[str] = []

src/cost/analyzer.py

@@ -0,0 +1,226 @@
+"""Cost analyzer for inventory snapshots."""
+
+import logging
+from concurrent.futures import ThreadPoolExecutor
+from datetime import datetime, timedelta
+from typing import Any, Dict, Optional, Set
+
+from ..models.cost_report import CostBreakdown, CostReport
+from ..models.snapshot import Snapshot
+from .explorer import CostExplorerClient
+
+logger = logging.getLogger(__name__)
+
+
+class CostAnalyzer:
+    """Analyze costs for inventory snapshots."""
+
+    def __init__(self, cost_explorer: CostExplorerClient):
+        """Initialize cost analyzer.
+
+        Args:
+            cost_explorer: Cost Explorer client instance
+        """
+        self.cost_explorer = cost_explorer
+
+    def analyze(
+        self,
+        snapshot: Snapshot,
+        start_date: Optional[datetime] = None,
+        end_date: Optional[datetime] = None,
+        granularity: str = "MONTHLY",
+        has_deltas: bool = False,
+        delta_report: Optional[Any] = None,
+    ) -> CostReport:
+        """Analyze costs and separate snapshot resources.
+
+        This implementation uses a simplified heuristic approach:
+        1. Get total costs by service
+        2. Estimate baseline portion based on resource counts in snapshot
+        3. Remaining costs are attributed to non-baseline resources
+
+        Note: For precise cost attribution, AWS would need to provide
+        per-resource cost data, which Cost Explorer doesn't directly expose.
+        This gives a good approximation based on service-level costs.
+
+        Args:
+            snapshot: The baseline snapshot
+            start_date: Start date for cost analysis (default: snapshot date)
+            end_date: End date for cost analysis (default: today)
+            granularity: Cost granularity - DAILY or MONTHLY
+
+        Returns:
+            CostReport with baseline and non-baseline cost breakdown
+        """
+        # Default date range: from snapshot creation to today
+        if not start_date:
+            start_date = snapshot.created_at
+            # Remove timezone for Cost Explorer API (uses dates only, no time)
+            start_date = start_date.replace(tzinfo=None)
+
+        if not end_date:
+            end_date = datetime.now()
+
+        # Ensure both dates are timezone-naive for comparison
+        if hasattr(start_date, "tzinfo") and start_date.tzinfo is not None:
+            start_date = start_date.replace(tzinfo=None)
+        if hasattr(end_date, "tzinfo") and end_date.tzinfo is not None:
+            end_date = end_date.replace(tzinfo=None)
+
+        # Ensure start_date is before end_date
+        # AWS Cost Explorer requires at least 1 day difference
+        if start_date >= end_date:
+            # If dates are the same or inverted, set end_date to start_date + 1 day
+            end_date = start_date + timedelta(days=1)
+
+        logger.debug(f"Analyzing costs from {start_date.strftime('%Y-%m-%d')} " f"to {end_date.strftime('%Y-%m-%d')}")
+
+        # Execute data completeness check and cost retrieval in parallel
+        with ThreadPoolExecutor(max_workers=2) as executor:
+            # Submit both tasks
+            completeness_future = executor.submit(self.cost_explorer.check_data_completeness, end_date)
+            costs_future = executor.submit(self.cost_explorer.get_costs_by_service, start_date, end_date, granularity)
+
+            # Wait for both to complete
+            is_complete, data_through, lag_days = completeness_future.result()
+            service_costs = costs_future.result()
+
+        # If no deltas (no resource changes), ALL costs are baseline
+        if not has_deltas:
+            logger.debug("No resource changes detected - all costs are from snapshot resources")
+            baseline_costs = service_costs.copy()
+            non_baseline_costs: Dict[str, float] = {}
+            baseline_total = sum(baseline_costs.values())
+            non_baseline_total = 0.0
+            total_cost = baseline_total
+            baseline_pct = 100.0
+            non_baseline_pct = 0.0
+        else:
+            # There are deltas - we can't accurately split costs without per-resource pricing
+            # Show total only with a note that we can't split accurately
+            logger.debug("Resource changes detected - showing total costs only")
+            baseline_costs = service_costs.copy()
+            non_baseline_costs = {}
+            baseline_total = sum(baseline_costs.values())
+            non_baseline_total = 0.0
+            total_cost = baseline_total
+            baseline_pct = 100.0
+            non_baseline_pct = 0.0
+            # Note: We could enhance this in the future to track specific resource costs
+            # For now, we show total and list the delta resources separately
+
+        # Create cost breakdowns
+        baseline_breakdown = CostBreakdown(
+            total=baseline_total,
+            by_service=baseline_costs,
+            percentage=baseline_pct,
+        )
+
+        non_baseline_breakdown = CostBreakdown(
+            total=non_baseline_total,
+            by_service=non_baseline_costs,
+            percentage=non_baseline_pct,
+        )
+
+        # Create cost report
+        report = CostReport(
+            generated_at=datetime.now(),
+            baseline_snapshot_name=snapshot.name,
+            period_start=start_date,
+            period_end=end_date,
+            baseline_costs=baseline_breakdown,
+            non_baseline_costs=non_baseline_breakdown,
+            total_cost=total_cost,
+            data_complete=is_complete,
+            data_through=data_through,
+            lag_days=lag_days,
+        )
+
+        logger.info(
+            f"Cost analysis complete: Baseline=${baseline_total:.2f}, "
+            f"Non-baseline=${non_baseline_total:.2f}, Total=${total_cost:.2f}"
+        )
+
+        return report
+
+    def _get_baseline_service_mapping(self, snapshot: Snapshot) -> Set[str]:
+        """Get set of AWS service names that have baseline resources.
+
+        Maps our resource types (e.g., 'AWS::EC2::Instance') to Cost Explorer
+        service names (e.g., 'Amazon Elastic Compute Cloud - Compute').
+
+        Args:
+            snapshot: Baseline snapshot
+
+        Returns:
+            Set of AWS service names from Cost Explorer
+        """
+        # Mapping from our resource types to Cost Explorer service names
+        service_name_map = {
+            "AWS::EC2::Instance": "Amazon Elastic Compute Cloud - Compute",
+            "AWS::EC2::Volume": "Amazon Elastic Compute Cloud - Compute",
+            "AWS::EC2::VPC": "Amazon Elastic Compute Cloud - Compute",
+            "AWS::EC2::SecurityGroup": "Amazon Elastic Compute Cloud - Compute",
+            "AWS::EC2::Subnet": "Amazon Elastic Compute Cloud - Compute",
+            "AWS::EC2::VPCEndpoint::Interface": "Amazon Elastic Compute Cloud - Compute",
+            "AWS::EC2::VPCEndpoint::Gateway": "Amazon Elastic Compute Cloud - Compute",
+            "AWS::Lambda::Function": "AWS Lambda",
+            "AWS::Lambda::LayerVersion": "AWS Lambda",
+            "AWS::S3::Bucket": "Amazon Simple Storage Service",
+            "AWS::RDS::DBInstance": "Amazon Relational Database Service",
+            "AWS::RDS::DBCluster": "Amazon Relational Database Service",
+            "AWS::IAM::Role": "AWS Identity and Access Management",
+            "AWS::IAM::User": "AWS Identity and Access Management",
+            "AWS::IAM::Policy": "AWS Identity and Access Management",
+            "AWS::IAM::Group": "AWS Identity and Access Management",
+            "AWS::CloudWatch::Alarm": "Amazon CloudWatch",
+            "AWS::CloudWatch::CompositeAlarm": "Amazon CloudWatch",
+            "AWS::Logs::LogGroup": "Amazon CloudWatch",
+            "AWS::SNS::Topic": "Amazon Simple Notification Service",
+            "AWS::SQS::Queue": "Amazon Simple Queue Service",
+            "AWS::DynamoDB::Table": "Amazon DynamoDB",
+            "AWS::ElasticLoadBalancing::LoadBalancer": "Elastic Load Balancing",
+            "AWS::ElasticLoadBalancingV2::LoadBalancer::Application": "Elastic Load Balancing",
+            "AWS::ElasticLoadBalancingV2::LoadBalancer::Network": "Elastic Load Balancing",
+            "AWS::ElasticLoadBalancingV2::LoadBalancer::Gateway": "Elastic Load Balancing",
+            "AWS::CloudFormation::Stack": "AWS CloudFormation",
+            "AWS::ApiGateway::RestApi": "Amazon API Gateway",
+            "AWS::ApiGatewayV2::Api::HTTP": "Amazon API Gateway",
+            "AWS::ApiGatewayV2::Api::WebSocket": "Amazon API Gateway",
+            "AWS::Events::EventBus": "Amazon EventBridge",
+            "AWS::Events::Rule": "Amazon EventBridge",
+            "AWS::SecretsManager::Secret": "AWS Secrets Manager",
+            "AWS::KMS::Key": "AWS Key Management Service",
+            "AWS::SSM::Parameter": "AWS Systems Manager",
+            "AWS::SSM::Document": "AWS Systems Manager",
+            "AWS::Route53::HostedZone": "Amazon Route 53",
+            "AWS::ECS::Cluster": "Amazon EC2 Container Service",
+            "AWS::ECS::Service": "Amazon EC2 Container Service",
+            "AWS::ECS::TaskDefinition": "Amazon EC2 Container Service",
+            "AWS::StepFunctions::StateMachine": "AWS Step Functions",
+            "AWS::WAFv2::WebACL::Regional": "AWS WAF",
+            "AWS::WAFv2::WebACL::CloudFront": "AWS WAF",
+            "AWS::EKS::Cluster": "Amazon Elastic Kubernetes Service",
+            "AWS::EKS::Nodegroup": "Amazon Elastic Kubernetes Service",
+            "AWS::EKS::FargateProfile": "Amazon Elastic Kubernetes Service",
+            "AWS::CodePipeline::Pipeline": "AWS CodePipeline",
+            "AWS::CodeBuild::Project": "AWS CodeBuild",
+            "AWS::Backup::BackupPlan": "AWS Backup",
+            "AWS::Backup::BackupVault": "AWS Backup",
+        }
+
+        baseline_services = set()
+
+        # Get unique resource types from snapshot
+        resource_types = set()
+        for resource in snapshot.resources:
+            resource_types.add(resource.resource_type)
+
+        # Map to Cost Explorer service names
+        for resource_type in resource_types:
+            if resource_type in service_name_map:
+                baseline_services.add(service_name_map[resource_type])
+
+        logger.debug(f"Baseline services: {baseline_services}")
+
+        return baseline_services

src/cost/explorer.py

@@ -0,0 +1,209 @@
+"""Cost Explorer integration for retrieving cost data."""
+
+import logging
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional, Tuple
+
+import boto3
+from botocore.exceptions import ClientError
+
+logger = logging.getLogger(__name__)
+
+
+class CostExplorerClient:
+    """Wrapper for AWS Cost Explorer API."""
+
+    def __init__(self, profile_name: Optional[str] = None):
+        """Initialize Cost Explorer client.
+
+        Args:
+            profile_name: AWS profile name (optional)
+        """
+        if profile_name:
+            session = boto3.Session(profile_name=profile_name)
+            self.client = session.client("ce", region_name="us-east-1")  # Cost Explorer is global
+        else:
+            self.client = boto3.client("ce", region_name="us-east-1")
+
+    def get_cost_and_usage(
+        self,
+        start_date: datetime,
+        end_date: datetime,
+        granularity: str = "MONTHLY",
+        metrics: Optional[List[str]] = None,
+        group_by: Optional[List[Dict[str, str]]] = None,
+        filter_expression: Optional[Dict] = None,
+    ) -> Dict:
+        """Get cost and usage data from Cost Explorer.
+
+        Args:
+            start_date: Start date for cost data (inclusive)
+            end_date: End date for cost data (exclusive)
+            granularity: Time granularity - DAILY or MONTHLY
+            metrics: Cost metrics to retrieve (default: UnblendedCost)
+            group_by: Dimensions to group by (e.g., SERVICE, REGION)
+            filter_expression: Filter to apply to cost data
+
+        Returns:
+            Cost and usage data from Cost Explorer API
+
+        Raises:
+            CostExplorerError: If Cost Explorer is not enabled or API call fails
+        """
+        if metrics is None:
+            metrics = ["UnblendedCost"]
+
+        try:
+            params = {
+                "TimePeriod": {
+                    "Start": start_date.strftime("%Y-%m-%d"),
+                    "End": end_date.strftime("%Y-%m-%d"),
+                },
+                "Granularity": granularity,
+                "Metrics": metrics,
+            }
+
+            if group_by:
+                params["GroupBy"] = group_by  # type: ignore[assignment]
+
+            if filter_expression:
+                params["Filter"] = filter_expression
+
+            logger.info(
+                f"Retrieving cost data from {start_date.strftime('%Y-%m-%d')} " f"to {end_date.strftime('%Y-%m-%d')}"
+            )
+
+            response = self.client.get_cost_and_usage(**params)
+
+            logger.info(f"Retrieved {len(response.get('ResultsByTime', []))} time periods")
+
+            return response  # type: ignore[return-value]
+
+        except ClientError as e:
+            error_code = e.response.get("Error", {}).get("Code", "Unknown")
+
+            if error_code == "AccessDeniedException":
+                raise CostExplorerError(
+                    "Access denied to Cost Explorer. Ensure your IAM user/role has the "
+                    "'ce:GetCostAndUsage' permission."
+                )
+            elif error_code == "DataUnavailableException":
+                raise CostExplorerError(
+                    "Cost data is not yet available for the specified time period. "
+                    "Cost Explorer data typically has a 24-48 hour delay."
+                )
+            else:
+                raise CostExplorerError(f"Cost Explorer API error: {e}")
+
+        except Exception as e:
+            logger.error(f"Unexpected error retrieving cost data: {e}")
+            raise CostExplorerError(f"Failed to retrieve cost data: {e}")
+
+    def get_costs_by_service(
+        self,
+        start_date: datetime,
+        end_date: datetime,
+        granularity: str = "MONTHLY",
+    ) -> Dict[str, float]:
+        """Get total costs grouped by AWS service.
+
+        Args:
+            start_date: Start date for cost data
+            end_date: End date for cost data
+            granularity: Time granularity
+
+        Returns:
+            Dictionary mapping service name to total cost
+        """
+        response = self.get_cost_and_usage(
+            start_date=start_date,
+            end_date=end_date,
+            granularity=granularity,
+            group_by=[{"Type": "DIMENSION", "Key": "SERVICE"}],
+        )
+
+        service_costs: Dict[str, float] = {}
+
+        for time_period in response.get("ResultsByTime", []):
+            for group in time_period.get("Groups", []):
+                service_name = group["Keys"][0]
+                cost = float(group["Metrics"]["UnblendedCost"]["Amount"])
+
+                if service_name in service_costs:
+                    service_costs[service_name] += cost
+                else:
+                    service_costs[service_name] = cost
+
+        return service_costs
+
+    def get_total_cost(
+        self,
+        start_date: datetime,
+        end_date: datetime,
+    ) -> float:
+        """Get total cost for the specified period.
+
+        Args:
+            start_date: Start date for cost data
+            end_date: End date for cost data
+
+        Returns:
+            Total cost amount
+        """
+        response = self.get_cost_and_usage(
+            start_date=start_date,
+            end_date=end_date,
+            granularity="MONTHLY",
+        )
+
+        total_cost = 0.0
+
+        for time_period in response.get("ResultsByTime", []):
+            cost = float(time_period["Total"]["UnblendedCost"]["Amount"])
+            total_cost += cost
+
+        return total_cost
+
+    def check_data_completeness(
+        self,
+        end_date: datetime,
+    ) -> Tuple[bool, Optional[datetime], int]:
+        """Check if cost data is complete up to the specified date.
+
+        Cost Explorer typically has a 24-48 hour delay in data availability.
+
+        Args:
+            end_date: The date to check data completeness for
+
+        Returns:
+            Tuple of (is_complete, data_available_through, lag_days)
+        """
+        # Cost Explorer data typically lags 1-2 days
+        today = datetime.now().date()
+        end_date_only = end_date.date()
+
+        # Calculate lag
+        lag_days = (today - end_date_only).days
+
+        # Data is considered incomplete if less than 2 days old
+        is_complete = lag_days >= 2
+
+        # Estimate data available through date
+        if lag_days < 2:
+            data_available_through = datetime.combine(today - timedelta(days=2), datetime.min.time())
+        else:
+            data_available_through = end_date
+
+        logger.info(
+            f"Cost data completeness: {'Complete' if is_complete else 'Incomplete'}, "
+            f"available through {data_available_through.strftime('%Y-%m-%d')}, "
+            f"lag: {lag_days} days"
+        )
+
+        return is_complete, data_available_through, lag_days
+
+
+class CostExplorerError(Exception):
+    """Exception raised for Cost Explorer errors."""
+
+    pass

src/cost/reporter.py

@@ -0,0 +1,237 @@
+"""Cost report formatting and display."""
+
+from typing import Optional
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from ..models.cost_report import CostReport
+
+
+class CostReporter:
+    """Format and display cost reports."""
+
+    def __init__(self, console: Optional[Console] = None):
+        """Initialize cost reporter.
+
+        Args:
+            console: Rich console instance (creates new one if not provided)
+        """
+        self.console = console or Console()
+
+    def display(self, report: CostReport, show_services: bool = True, has_deltas: bool = False) -> None:
+        """Display cost report to console.
+
+        Args:
+            report: CostReport to display
+            show_services: Whether to show service-level breakdown
+            has_deltas: Whether there are resource changes (deltas)
+        """
+        # Header
+        self.console.print()
+        self.console.print(
+            Panel(
+                f"[bold]Cost Analysis Report[/bold]\n"
+                f"Snapshot: {report.baseline_snapshot_name}\n"
+                f"Period: {report.period_start.strftime('%Y-%m-%d')} to {report.period_end.strftime('%Y-%m-%d')}\n"
+                f"Generated: {report.generated_at.strftime('%Y-%m-%d %H:%M:%S UTC')}",
+                style="cyan",
+            )
+        )
+        self.console.print()
+
+        # Data completeness warning
+        if not report.data_complete and report.data_through:
+            self.console.print(
+                f"⚠️  [yellow]Note: Cost data has {report.lag_days} day lag. "
+                f"Data available through {report.data_through.strftime('%Y-%m-%d')}[/yellow]\n"
+            )
+
+        # If no deltas, show simplified view
+        if not has_deltas:
+            self.console.print(
+                "✓ [green]No resource changes detected - all costs are from snapshot resources[/green]\n"
+            )
+            self._display_snapshot_costs(report)
+        else:
+            # Summary table with baseline/non-baseline split
+            self._display_summary(report)
+
+        # Service breakdown
+        if show_services and report.baseline_costs.by_service:
+            self.console.print()
+            self._display_service_breakdown(report, has_deltas)
+
+    def _display_snapshot_costs(self, report: CostReport) -> None:
+        """Display snapshot costs (no splitting since there are no changes)."""
+        table = Table(title="Snapshot Costs", show_header=True, header_style="bold cyan")
+        table.add_column("Total Cost", justify="right", style="bold green", width=20)
+        table.add_row(f"${report.baseline_costs.total:,.2f}")
+        self.console.print(table)
+
+    def _display_summary(self, report: CostReport) -> None:
+        """Display cost summary."""
+        table = Table(title="Cost Summary", show_header=True, header_style="bold magenta")
+        table.add_column("Category", style="cyan", width=25)
+        table.add_column("Amount (USD)", justify="right", style="green", width=15)
+        table.add_column("Percentage", justify="right", width=12)
+        table.add_column("Visual", width=30)
+
+        # Baseline costs
+        baseline_bar = self._create_progress_bar(report.baseline_percentage, color="blue")
+        table.add_row(
+            '💰 Baseline ("Dial Tone")',
+            f"${report.baseline_costs.total:,.2f}",
+            f"{report.baseline_percentage:.1f}%",
+            baseline_bar,
+        )
+
+        # Non-baseline costs
+        non_baseline_bar = self._create_progress_bar(report.non_baseline_percentage, color="yellow")
+        table.add_row(
+            "📊 Non-Baseline (Projects)",
+            f"${report.non_baseline_costs.total:,.2f}",
+            f"{report.non_baseline_percentage:.1f}%",
+            non_baseline_bar,
+        )
+
+        # Separator
+        table.add_row("━" * 25, "━" * 15, "━" * 12, "━" * 30, style="dim")
+
+        # Total
+        table.add_row("[bold]Total", f"[bold]${report.total_cost:,.2f}", "[bold]100.0%", "")
+
+        self.console.print(table)
+
+    def _display_service_breakdown(self, report: CostReport, has_deltas: bool = False) -> None:
+        """Display service-level cost breakdown."""
+        # Get top services
+        top_baseline = report.get_top_services(limit=10, baseline=True)
+
+        if top_baseline:
+            title = "Costs by Service" if not has_deltas else "Top Baseline Services"
+            self.console.print(f"[bold cyan]{title}:[/bold cyan]")
+            baseline_table = Table(show_header=True, box=None, padding=(0, 2))
+            baseline_table.add_column("Service", style="white")
+            baseline_table.add_column("Cost", justify="right", style="green")
+            baseline_table.add_column("% of Total", justify="right", style="dim")
+
+            for service, cost in top_baseline.items():
+                pct = (cost / report.baseline_costs.total * 100) if report.baseline_costs.total > 0 else 0
+                baseline_table.add_row(self._shorten_service_name(service), f"${cost:,.2f}", f"{pct:.1f}%")
+
+            self.console.print(baseline_table)
+            self.console.print()
+
+        # Only show non-baseline section if there are actual deltas
+        if has_deltas:
+            top_non_baseline = report.get_top_services(limit=5, baseline=False)
+            if top_non_baseline:
+                self.console.print("[bold yellow]Top Non-Baseline Services:[/bold yellow]")
+                non_baseline_table = Table(show_header=True, box=None, padding=(0, 2))
+                non_baseline_table.add_column("Service", style="white")
+                non_baseline_table.add_column("Cost", justify="right", style="green")
+                non_baseline_table.add_column("% of Non-Baseline", justify="right", style="dim")
+
+                for service, cost in top_non_baseline.items():
+                    pct = (cost / report.non_baseline_costs.total * 100) if report.non_baseline_costs.total > 0 else 0
+                    non_baseline_table.add_row(self._shorten_service_name(service), f"${cost:,.2f}", f"{pct:.1f}%")
+
+                self.console.print(non_baseline_table)
+
+    def _create_progress_bar(self, percentage: float, color: str = "green") -> str:
+        """Create a text-based progress bar.
+
+        Args:
+            percentage: Percentage value (0-100)
+            color: Color for the bar
+
+        Returns:
+            Formatted progress bar string
+        """
+        width = 20
+        filled = int((percentage / 100) * width)
+        bar = "█" * filled + "░" * (width - filled)
+        return f"[{color}]{bar}[/{color}]"
+
+    def _shorten_service_name(self, service_name: str) -> str:
+        """Shorten AWS service names for display.
+
+        Args:
+            service_name: Full AWS service name
+
+        Returns:
+            Shortened service name
+        """
+        # Common abbreviations
+        replacements = {
+            "Amazon Elastic Compute Cloud - Compute": "EC2",
+            "Amazon Simple Storage Service": "S3",
+            "AWS Lambda": "Lambda",
+            "Amazon Relational Database Service": "RDS",
+            "AWS Identity and Access Management": "IAM",
+            "Amazon Virtual Private Cloud": "VPC",
+            "Amazon CloudWatch": "CloudWatch",
+            "Amazon Simple Notification Service": "SNS",
+            "Amazon Simple Queue Service": "SQS",
+            "Amazon DynamoDB": "DynamoDB",
+        }
+
+        return replacements.get(service_name, service_name)
+
+    def export_json(self, report: CostReport, filepath: str) -> None:
+        """Export cost report to JSON file.
+
+        Args:
+            report: CostReport to export
+            filepath: Destination file path
+        """
+        from ..utils.export import export_to_json
+
+        export_to_json(report.to_dict(), filepath)
+        self.console.print(f"[green]✓ Cost report exported to {filepath}[/green]")
+
+    def export_csv(self, report: CostReport, filepath: str) -> None:
+        """Export cost report to CSV file.
+
+        Args:
+            report: CostReport to export
+            filepath: Destination file path
+        """
+        from ..utils.export import export_to_csv
+
+        # Flatten into rows - one row per service
+        rows = []
+
+        # Baseline services
+        for service, cost in report.baseline_costs.by_service.items():
+            pct = (cost / report.baseline_costs.total * 100) if report.baseline_costs.total > 0 else 0
+            rows.append(
+                {
+                    "category": "baseline",
+                    "service": service,
+                    "cost": cost,
+                    "percentage_of_category": pct,
+                    "percentage_of_total": (cost / report.total_cost * 100) if report.total_cost > 0 else 0,
+                }
+            )
+
+        # Non-baseline services
+        for service, cost in report.non_baseline_costs.by_service.items():
+            pct = (cost / report.non_baseline_costs.total * 100) if report.non_baseline_costs.total > 0 else 0
+            rows.append(
+                {
+                    "category": "non_baseline",
+                    "service": service,
+                    "cost": cost,
+                    "percentage_of_category": pct,
+                    "percentage_of_total": (cost / report.total_cost * 100) if report.total_cost > 0 else 0,
+                }
+            )
+
+        if rows:
+            export_to_csv(rows, filepath)
+            self.console.print(f"[green]✓ Cost report exported to {filepath}[/green]")
+        else:
+            self.console.print("[yellow]⚠ No cost data to export[/yellow]")

src/delta/__init__.py

@@ -0,0 +1,5 @@
+"""Delta tracking module for comparing snapshots to current state."""
+
+from typing import List
+
+__all__: List[str] = []