roadmap-cli 0.1.1__py3-none-any.whl

roadmap/presentation/formatters/sync_metrics_formatter.py

@@ -0,0 +1,355 @@
+"""Formatters for displaying sync metrics in the CLI.
+
+This module provides various formatting utilities for presenting sync
+metrics in a user-friendly table format.
+"""
+
+from datetime import UTC, datetime, timedelta
+
+from rich.table import Table
+from rich.text import Text
+
+from roadmap.core.observability.sync_metrics import SyncMetrics
+
+
+def format_duration(seconds: float) -> str:
+    """Format duration in seconds to human-readable string.
+
+    Args:
+        seconds: Duration in seconds
+
+    Returns:
+        Formatted duration string
+    """
+    if seconds < 1:
+        return f"{seconds * 1000:.0f}ms"
+    elif seconds < 60:
+        return f"{seconds:.1f}s"
+    elif seconds < 3600:
+        minutes = seconds / 60
+        return f"{minutes:.1f}m"
+    else:
+        hours = seconds / 3600
+        return f"{hours:.1f}h"
+
+
+def format_count(count: int | float) -> str:
+    """Format count as a readable string.
+
+    Args:
+        count: Number to format
+
+    Returns:
+        Formatted count string
+    """
+    if isinstance(count, float) and count == int(count):
+        count = int(count)
+    return str(count)
+
+
+def format_percentage(value: float, decimals: int = 1) -> str:
+    """Format percentage value.
+
+    Args:
+        value: Value between 0 and 100
+        decimals: Number of decimal places
+
+    Returns:
+        Formatted percentage string
+    """
+    return f"{value:.{decimals}f}%"
+
+
+def _add_dedup_rows(table: Table, metrics: SyncMetrics) -> None:
+    if (
+        metrics.local_issues_before_dedup <= 0
+        and metrics.remote_issues_before_dedup <= 0
+    ):
+        return
+
+    table.add_row("[bold cyan]═══ Deduplication ═══[/bold cyan]", "")
+
+    if metrics.local_issues_before_dedup > 0:
+        table.add_row(
+            "  Local Issues (Before)",
+            format_count(metrics.local_issues_before_dedup),
+        )
+        table.add_row(
+            "  Local Issues (After)",
+            format_count(metrics.local_issues_after_dedup),
+        )
+        if metrics.local_dedup_reduction_pct > 0:
+            table.add_row(
+                "  Local Dedup Reduction",
+                Text(
+                    format_percentage(metrics.local_dedup_reduction_pct),
+                    style="green",
+                ),
+            )
+
+    if metrics.remote_issues_before_dedup > 0:
+        table.add_row(
+            "  Remote Issues (Before)",
+            format_count(metrics.remote_issues_before_dedup),
+        )
+        table.add_row(
+            "  Remote Issues (After)",
+            format_count(metrics.remote_issues_after_dedup),
+        )
+        if metrics.remote_dedup_reduction_pct > 0:
+            table.add_row(
+                "  Remote Dedup Reduction",
+                Text(
+                    format_percentage(metrics.remote_dedup_reduction_pct),
+                    style="green",
+                ),
+            )
+
+
+def _add_sync_ops_rows(table: Table, metrics: SyncMetrics) -> None:
+    if not (
+        metrics.issues_fetched > 0
+        or metrics.issues_pushed > 0
+        or metrics.issues_pulled > 0
+    ):
+        return
+
+    table.add_row("[bold cyan]═══ Sync Operations ═══[/bold cyan]", "")
+
+    if metrics.issues_fetched > 0:
+        table.add_row(
+            "  Issues Fetched",
+            format_count(metrics.issues_fetched),
+        )
+    if metrics.issues_pushed > 0:
+        table.add_row(
+            "  Issues Pushed",
+            format_count(metrics.issues_pushed),
+        )
+    if metrics.issues_pulled > 0:
+        table.add_row(
+            "  Issues Pulled",
+            format_count(metrics.issues_pulled),
+        )
+
+
+def _add_duplicate_rows(table: Table, metrics: SyncMetrics) -> None:
+    if metrics.duplicates_detected <= 0:
+        return
+
+    table.add_row("[bold cyan]═══ Duplicates ═══[/bold cyan]", "")
+    table.add_row(
+        "  Duplicates Detected",
+        Text(format_count(metrics.duplicates_detected), style="yellow"),
+    )
+    if metrics.duplicates_auto_resolved > 0:
+        table.add_row(
+            "  Auto-Resolved",
+            Text(
+                format_count(metrics.duplicates_auto_resolved),
+                style="green",
+            ),
+        )
+    if metrics.duplicates_manual_resolved > 0:
+        table.add_row(
+            "  Manual Resolution",
+            Text(
+                format_count(metrics.duplicates_manual_resolved),
+                style="cyan",
+            ),
+        )
+
+
+def _add_conflict_rows(table: Table, metrics: SyncMetrics) -> None:
+    if metrics.conflicts_detected <= 0:
+        return
+
+    table.add_row("[bold cyan]═══ Conflicts ═══[/bold cyan]", "")
+    table.add_row(
+        "  Conflicts Detected",
+        Text(format_count(metrics.conflicts_detected), style="yellow"),
+    )
+
+
+def _add_link_rows(table: Table, metrics: SyncMetrics) -> None:
+    if metrics.sync_links_created <= 0 and metrics.orphaned_links <= 0:
+        return
+
+    table.add_row("[bold cyan]═══ Sync Links ═══[/bold cyan]", "")
+    if metrics.sync_links_created > 0:
+        table.add_row(
+            "  Links Created",
+            format_count(metrics.sync_links_created),
+        )
+    if metrics.orphaned_links > 0:
+        table.add_row(
+            "  Orphaned Links",
+            Text(
+                format_count(metrics.orphaned_links),
+                style="yellow",
+            ),
+        )
+
+
+def _add_performance_rows(table: Table, metrics: SyncMetrics) -> None:
+    table.add_row("[bold cyan]═══ Performance ═══[/bold cyan]", "")
+    if metrics.cache_hit_rate > 0:
+        table.add_row(
+            "  Cache Hit Rate",
+            Text(
+                format_percentage(metrics.cache_hit_rate * 100),
+                style="green",
+            ),
+        )
+    if metrics.database_query_time > 0:
+        table.add_row(
+            "  DB Query Time",
+            Text(format_duration(metrics.database_query_time), style="yellow"),
+        )
+    if metrics.total_api_calls > 0:
+        table.add_row(
+            "  API Calls",
+            Text(format_count(metrics.total_api_calls), style="cyan"),
+        )
+
+
+def create_metrics_summary_table(metrics: SyncMetrics, verbose: bool = False) -> Table:
+    """Create a summary table of sync metrics.
+
+    Args:
+        metrics: SyncMetrics object to display
+        verbose: Include performance and phase timing details
+
+    Returns:
+        Rich Table with sync summary metrics
+    """
+    table = Table(show_header=False, box=None, padding=(0, 2))
+    table.add_column(style="bold")
+    table.add_column(justify="right", style="cyan")
+
+    table.add_row("[bold cyan]═══ Summary ═══[/bold cyan]", "")
+    table.add_row("Backend", metrics.backend_type or "unknown")
+    table.add_row(
+        "Started",
+        metrics.start_time.strftime("%Y-%m-%d %H:%M"),
+    )
+    table.add_row("Duration", format_duration(metrics.duration_seconds))
+
+    _add_dedup_rows(table, metrics)
+    _add_sync_ops_rows(table, metrics)
+    _add_duplicate_rows(table, metrics)
+    _add_conflict_rows(table, metrics)
+    _add_link_rows(table, metrics)
+
+    if verbose:
+        _add_performance_rows(table, metrics)
+        if metrics.circuit_breaker_state:
+            state_style = (
+                "green"
+                if metrics.circuit_breaker_state == "closed"
+                else "yellow"
+                if metrics.circuit_breaker_state == "half-open"
+                else "red"
+            )
+            table.add_row(
+                "  Circuit Breaker",
+                Text(metrics.circuit_breaker_state, style=state_style),
+            )
+
+        if metrics.fetch_phase_duration > 0:
+            table.add_row(
+                "  Fetch Time",
+                format_duration(metrics.fetch_phase_duration),
+            )
+        if metrics.push_phase_duration > 0:
+            table.add_row(
+                "  Push Time",
+                format_duration(metrics.push_phase_duration),
+            )
+        if metrics.pull_phase_duration > 0:
+            table.add_row(
+                "  Pull Time",
+                format_duration(metrics.pull_phase_duration),
+            )
+        if metrics.analysis_phase_duration > 0:
+            table.add_row(
+                "  Analysis Time",
+                format_duration(metrics.analysis_phase_duration),
+            )
+        if metrics.merge_phase_duration > 0:
+            table.add_row(
+                "  Merge Time",
+                format_duration(metrics.merge_phase_duration),
+            )
+        if metrics.conflict_resolution_duration > 0:
+            table.add_row(
+                "  Conflict Resolution Time",
+                format_duration(metrics.conflict_resolution_duration),
+            )
+    # Errors
+    if metrics.errors_count > 0:
+        table.add_row("[bold cyan]═══ Errors ═══[/bold cyan]", "")
+        table.add_row(
+            "  Error Count",
+            Text(format_count(metrics.errors_count), style="red"),
+        )
+
+    return table
+
+
+def create_metrics_history_table(
+    metrics_list: list[SyncMetrics], limit: int = 10
+) -> Table:
+    """Create a table showing history of sync metrics.
+
+    Args:
+        metrics_list: List of SyncMetrics objects
+        limit: Maximum number of rows to show
+
+    Returns:
+        Rich Table with metrics history
+    """
+    table = Table(
+        show_header=True,
+        header_style="bold cyan",
+        box=None,
+        title="Sync Metrics History",
+    )
+    table.add_column("Time", style="dim")
+    table.add_column("Backend", style="green")
+    table.add_column("Duration", justify="right")
+    table.add_column("Duplicates", justify="right")
+    table.add_column("Conflicts", justify="right")
+    table.add_column("Errors", justify="right")
+
+    # Reverse to show newest first
+    for metrics in reversed(metrics_list[:limit]):
+        created_time = metrics.start_time
+        time_diff = datetime.now(UTC) - created_time
+        time_str = (
+            "just now"
+            if time_diff < timedelta(seconds=60)
+            else (
+                f"{int(time_diff.total_seconds() / 60)}m ago"
+                if time_diff < timedelta(hours=1)
+                else (
+                    f"{int(time_diff.total_seconds() / 3600)}h ago"
+                    if time_diff < timedelta(days=1)
+                    else created_time.strftime("%Y-%m-%d %H:%M")
+                )
+            )
+        )
+
+        error_count = metrics.errors_count
+        error_style = "red" if error_count > 0 else "green"
+
+        table.add_row(
+            time_str,
+            metrics.backend_type,
+            format_duration(metrics.duration_seconds),
+            format_count(metrics.duplicates_detected),
+            format_count(metrics.conflicts_detected),
+            Text(format_count(error_count), style=error_style),
+        )
+
+    return table

roadmap/settings.py

@@ -0,0 +1,345 @@
+"""Configuration management for roadmap CLI application.
+
+This module provides environment-aware configuration using dynaconf,
+supporting multiple environments (development, testing, production) and
+various configuration sources (files, environment variables, etc.).
+"""
+
+from pathlib import Path
+from typing import Any
+
+from dynaconf import Dynaconf, Validator  # type: ignore[import-not-found]
+
+from .common.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+def get_config_paths() -> dict[str, Path]:
+    """Get standard configuration file paths."""
+    home_config_dir = Path.home() / ".roadmap"
+    home_config_dir.mkdir(exist_ok=True)
+
+    return {
+        "global_config": home_config_dir / "settings.toml",
+        "global_secrets": home_config_dir / "secrets.toml",
+        "local_config": Path.cwd() / ".roadmap" / "settings.toml",
+        "local_secrets": Path.cwd() / ".roadmap" / "secrets.toml",
+    }
+
+
+# Configuration schema with validation
+_validators = [
+    # Database settings
+    Validator("database.path", default="~/.roadmap/roadmap.db"),
+    Validator("database.timeout", default=30.0, gte=1.0),
+    Validator("database.backup_count", default=5, gte=0),
+    # Logging settings
+    Validator(
+        "logging.level",
+        default="INFO",
+        is_in=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
+    ),
+    Validator("logging.to_file", default=True, is_type_of=bool),
+    Validator("logging.log_dir", default="~/.roadmap/logs"),
+    Validator("logging.max_file_size", default="10MB"),
+    Validator("logging.backup_count", default=5, gte=0),
+    Validator("logging.retention_days", default=90, gte=1),
+    Validator("logging.archive_old_logs", default=True, is_type_of=bool),
+    # Git settings
+    Validator("git.auto_sync", default=True, is_type_of=bool),
+    Validator("git.hooks_enabled", default=True, is_type_of=bool),
+    Validator("git.default_branch", default="main"),
+    # GitHub integration (optional)
+    Validator("github.enabled", default=False, is_type_of=bool),
+    Validator("github.token", default=""),
+    Validator("github.repo", default=""),
+    Validator("github.sync_labels", default=True, is_type_of=bool),
+    # CLI settings
+    Validator("cli.default_editor", default="nano"),
+    Validator("cli.pager", default="less"),
+    Validator(
+        "cli.output_format", default="table", is_in=["table", "json", "yaml", "csv"]
+    ),
+    Validator("cli.color", default=True, is_type_of=bool),
+    # Project defaults
+    Validator("defaults.issue_type", default="task"),
+    Validator("defaults.priority", default="medium"),
+    Validator("defaults.status", default="open"),
+    # Performance settings
+    Validator("performance.cache_enabled", default=True, is_type_of=bool),
+    Validator("performance.cache_size", default="100MB"),
+    Validator("performance.cache_ttl", default=3600, gte=0),
+    # Export settings
+    Validator(
+        "export.default_format", default="csv", is_in=["csv", "json", "markdown"]
+    ),
+    Validator("export.include_metadata", default=False, is_type_of=bool),
+    Validator("export.date_format", default="%Y-%m-%d"),
+    # Sync settings - duplicate detection
+    Validator("sync.enable_duplicate_detection", default=True, is_type_of=bool),
+    Validator("sync.duplicate_title_threshold", default=0.90, gte=0.0, lte=1.0),
+    Validator("sync.duplicate_content_threshold", default=0.85, gte=0.0, lte=1.0),
+    Validator("sync.duplicate_auto_resolve_threshold", default=0.95, gte=0.0, lte=1.0),
+    # GitHub API rate limiting
+    Validator("github.api_batch_delay_seconds", default=1.0, gte=0.1),
+]
+
+# Initialize dynaconf with our configuration
+config_paths = get_config_paths()
+
+settings = Dynaconf(
+    # Configuration file locations (in priority order)
+    settings_files=[
+        str(config_paths["global_config"]),
+        str(config_paths["local_config"]),
+    ],
+    # Secrets file locations
+    secrets=[
+        str(config_paths["global_secrets"]),
+        str(config_paths["local_secrets"]),
+    ],
+    # Environment variables
+    envvar_prefix="ROADMAP",
+    # Environment-specific settings
+    environments=True,
+    env_switcher="ROADMAP_ENV",
+    # Validation
+    validators=_validators,
+    # Additional settings
+    load_dotenv=True,
+    dotenv_path=".env",
+    merge_enabled=True,
+    # Default environment
+    default_env="development",
+)
+
+
+def get_settings() -> Dynaconf:
+    """Get the global settings object."""
+    return settings
+
+
+def validate_config() -> bool:
+    """Validate the current configuration."""
+    try:
+        settings.validators.validate_all()
+        logger.info("Configuration validation passed")
+        return True
+    except Exception as e:
+        logger.error(
+            "Configuration validation failed",
+            error=str(e),
+            severity="config_error",
+        )
+        return False
+
+
+def create_default_config(force: bool = False) -> bool:
+    """Create default configuration files.
+
+    Args:
+        force: Overwrite existing configuration files
+
+    Returns:
+        True if configuration was created successfully
+    """
+    config_paths = get_config_paths()
+
+    # Default global configuration
+    global_config_content = """# Roadmap CLI Global Configuration
+
+[default]
+# Database settings
+[default.database]
+path = "~/.roadmap/roadmap.db"
+timeout = 30.0
+backup_count = 5
+
+# Logging settings
+[default.logging]
+level = "INFO"
+to_file = true
+log_dir = "~/.roadmap/logs"
+max_file_size = "10MB"
+backup_count = 5
+
+# Git settings
+[default.git]
+auto_sync = true
+hooks_enabled = true
+default_branch = "main"
+
+# GitHub integration (optional)
+[default.github]
+enabled = false
+sync_labels = true
+
+# CLI settings
+[default.cli]
+default_editor = "nano"
+pager = "less"
+output_format = "table"
+color = true
+
+# Project defaults
+[default.defaults]
+issue_type = "task"
+priority = "medium"
+status = "open"
+
+# Performance settings
+[default.performance]
+cache_enabled = true
+cache_size = "100MB"
+cache_ttl = 3600
+
+# Export settings
+[default.export]
+default_format = "csv"
+include_metadata = false
+date_format = "%Y-%m-%d"
+
+# Development environment overrides
+[development]
+[development.logging]
+level = "DEBUG"
+
+# Testing environment overrides
+[testing]
+[testing.database]
+path = ":memory:"
+[testing.logging]
+level = "WARNING"
+to_file = false
+
+# Production environment overrides
+[production]
+[production.logging]
+level = "INFO"
+[production.performance]
+cache_size = "500MB"
+"""
+
+    # Default secrets template
+    secrets_content = """# Roadmap CLI Secrets Configuration
+# Store sensitive information here
+
+[default]
+# GitHub token (if using GitHub integration)
+[default.github]
+token = ""
+
+# Custom API keys or tokens
+[default.api_keys]
+# example_service = "your-api-key-here"
+"""
+
+    try:
+        # Create global config if it doesn't exist or force is True
+        global_config_path = config_paths["global_config"]
+        if not global_config_path.exists() or force:
+            global_config_path.write_text(global_config_content)
+            logger.info("Created global configuration", path=str(global_config_path))
+
+        # Create secrets template if it doesn't exist or force is True
+        global_secrets_path = config_paths["global_secrets"]
+        if not global_secrets_path.exists() or force:
+            global_secrets_path.write_text(secrets_content)
+            global_secrets_path.chmod(0o600)  # Secure permissions
+            logger.info("Created secrets configuration", path=str(global_secrets_path))
+
+        return True
+
+    except Exception as e:
+        logger.error(
+            "Failed to create default configuration",
+            error=str(e),
+            severity="config_error",
+        )
+        return False
+
+
+def get_database_path() -> Path:
+    """Get the configured database path."""
+    db_path = settings.database.path
+    if db_path.startswith("~"):
+        db_path = Path(db_path).expanduser()
+    else:
+        db_path = Path(db_path)
+
+    return db_path
+
+
+def get_log_directory() -> Path:
+    """Get the configured log directory."""
+    log_dir = settings.logging.log_dir
+    if log_dir.startswith("~"):
+        log_dir = Path(log_dir).expanduser()
+    else:
+        log_dir = Path(log_dir)
+
+    return log_dir
+
+
+def is_github_enabled() -> bool:
+    """Check if GitHub integration is enabled."""
+    return settings.github.enabled and bool(settings.github.token)
+
+
+def get_github_config() -> dict[str, Any]:
+    """Get GitHub configuration."""
+    return {
+        "enabled": settings.github.enabled,
+        "token": settings.github.token,
+        "repo": settings.github.repo,
+        "sync_labels": settings.github.sync_labels,
+    }
+
+
+def get_export_settings() -> dict[str, Any]:
+    """Get export settings."""
+    return {
+        "default_format": settings.export.default_format,
+        "include_metadata": settings.export.include_metadata,
+        "date_format": settings.export.date_format,
+    }
+
+
+def switch_environment(env_name: str) -> bool:
+    """Switch to a different environment.
+
+    Args:
+        env_name: Environment name (development, testing, production)
+
+    Returns:
+        True if environment was switched successfully
+    """
+    try:
+        import os
+
+        os.environ["ROADMAP_ENV"] = env_name
+        settings.setenv(env_name)
+        logger.info("Switched environment", environment=env_name)
+        return True
+    except Exception as e:
+        logger.error(
+            "Failed to switch environment",
+            environment=env_name,
+            error=str(e),
+            severity="config_error",
+        )
+        return False
+
+
+# Initialize default configuration on module import
+try:
+    validate_config()
+    logger.debug("Configuration loaded successfully")
+except Exception as e:
+    logger.warning(
+        "Configuration validation failed, creating defaults",
+        error=str(e),
+        severity="config_error",
+    )
+    create_default_config()