roadmap-cli 0.1.1__py3-none-any.whl

roadmap/core/services/sync/performance.py

@@ -0,0 +1,263 @@
+"""Performance optimizations for sync operations."""
+
+from __future__ import annotations
+
+import hashlib
+from collections.abc import Callable
+from datetime import UTC, datetime, timedelta
+from functools import wraps
+from typing import TYPE_CHECKING, Any
+
+from structlog import get_logger
+
+if TYPE_CHECKING:
+    from roadmap.core.domain.issue import Issue
+
+logger = get_logger(__name__)
+
+
+class SyncCache:
+    """In-memory cache for sync operation results."""
+
+    def __init__(self, ttl_seconds: int = 300):
+        """Initialize sync cache.
+
+        Args:
+            ttl_seconds: Time-to-live for cached items in seconds (default: 5 minutes)
+        """
+        self.ttl_seconds = ttl_seconds
+        self._cache: dict[str, tuple[Any, datetime]] = {}
+        self._hits = 0
+        self._misses = 0
+
+    def get(self, key: str) -> Any | None:
+        """Get cached value if not expired.
+
+        Args:
+            key: Cache key
+
+        Returns:
+            Cached value or None if not found/expired
+        """
+        if key not in self._cache:
+            self._misses += 1
+            return None
+
+        value, timestamp = self._cache[key]
+        if datetime.now(UTC) - timestamp > timedelta(seconds=self.ttl_seconds):
+            # Expired
+            del self._cache[key]
+            self._misses += 1
+            return None
+
+        self._hits += 1
+        return value
+
+    def set(self, key: str, value: Any) -> None:
+        """Store value in cache.
+
+        Args:
+            key: Cache key
+            value: Value to cache
+        """
+        self._cache[key] = (value, datetime.now(UTC))
+
+    def clear(self) -> None:
+        """Clear all cached items."""
+        self._cache.clear()
+        self._hits = 0
+        self._misses = 0
+
+    def get_stats(self) -> dict[str, int | float]:
+        """Get cache statistics.
+
+        Returns:
+            Dict with hits, misses, and hit rate
+        """
+        total = self._hits + self._misses
+        hit_rate = (self._hits / total * 100.0) if total > 0 else 0.0
+
+        return {
+            "hits": self._hits,
+            "misses": self._misses,
+            "total_requests": total,
+            "hit_rate_percent": round(hit_rate, 2),
+            "cached_items": len(self._cache),
+        }
+
+
+# Global cache instance
+_sync_cache = SyncCache()
+
+
+def get_sync_cache() -> SyncCache:
+    """Get the global sync cache instance.
+
+    Returns:
+        SyncCache instance
+    """
+    return _sync_cache
+
+
+def cache_result(ttl_seconds: int = 300):
+    """Decorator to cache function results.
+
+    Args:
+        ttl_seconds: Time-to-live for cached results
+
+    Returns:
+        Decorator function
+    """
+
+    def decorator(func: Callable) -> Callable:
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            # Generate cache key from function name and arguments
+            key_parts = [func.__name__]
+            key_parts.extend(str(arg) for arg in args)
+            key_parts.extend(f"{k}={v}" for k, v in sorted(kwargs.items()))
+            cache_key = hashlib.sha256(":".join(key_parts).encode()).hexdigest()[:16]
+
+            cache = get_sync_cache()
+            cached_value = cache.get(cache_key)
+
+            if cached_value is not None:
+                logger.debug(
+                    "cache_hit",
+                    function=func.__name__,
+                    key=cache_key,
+                    action="cache_lookup",
+                )
+                return cached_value
+
+            # Cache miss - compute and cache
+            result = func(*args, **kwargs)
+            cache.set(cache_key, result)
+
+            logger.debug(
+                "cache_miss",
+                function=func.__name__,
+                key=cache_key,
+                action="cache_store",
+            )
+
+            return result
+
+        return wrapper
+
+    return decorator
+
+
+class IssueIndexer:
+    """Indexes issues for fast lookup during sync operations."""
+
+    def __init__(self):
+        """Initialize issue indexer."""
+        self._by_id: dict[str, Issue] = {}
+        self._by_github_number: dict[int, Issue] = {}
+        self._by_milestone: dict[str, list[Issue]] = {}
+        self._indexed_at: datetime | None = None
+
+    def index_issues(self, issues: list[Issue]) -> None:
+        """Build indexes for fast lookups.
+
+        Args:
+            issues: List of issues to index
+        """
+        self._by_id.clear()
+        self._by_github_number.clear()
+        self._by_milestone.clear()
+
+        for issue in issues:
+            # Index by ID
+            self._by_id[issue.id] = issue
+
+            # Index by GitHub issue number
+            github_number = issue.remote_ids.get("github")
+            if github_number:
+                self._by_github_number[int(github_number)] = issue
+
+            # Index by milestone
+            if issue.milestone:
+                if issue.milestone not in self._by_milestone:
+                    self._by_milestone[issue.milestone] = []
+                self._by_milestone[issue.milestone].append(issue)
+
+        self._indexed_at = datetime.now(UTC)
+
+        logger.info(
+            "issues_indexed",
+            total_issues=len(issues),
+            by_id=len(self._by_id),
+            by_github=len(self._by_github_number),
+            milestones=len(self._by_milestone),
+            action="index_issues",
+        )
+
+    def get_by_id(self, issue_id: str) -> Issue | None:
+        """Get issue by ID.
+
+        Args:
+            issue_id: Issue ID
+
+        Returns:
+            Issue or None if not found
+        """
+        return self._by_id.get(issue_id)
+
+    def get_by_github_number(self, github_number: int) -> Issue | None:
+        """Get issue by GitHub issue number.
+
+        Args:
+            github_number: GitHub issue number
+
+        Returns:
+            Issue or None if not found
+        """
+        return self._by_github_number.get(github_number)
+
+    def get_by_milestone(self, milestone: str) -> list[Issue]:
+        """Get all issues for a milestone.
+
+        Args:
+            milestone: Milestone name
+
+        Returns:
+            List of issues (empty if none found)
+        """
+        return self._by_milestone.get(milestone, [])
+
+    def is_stale(self, max_age_seconds: int = 300) -> bool:
+        """Check if index is stale and needs rebuilding.
+
+        Args:
+            max_age_seconds: Maximum age in seconds before index is stale
+
+        Returns:
+            True if index should be rebuilt
+        """
+        if self._indexed_at is None:
+            return True
+
+        age = (datetime.now(UTC) - self._indexed_at).total_seconds()
+        return age > max_age_seconds
+
+    def clear(self) -> None:
+        """Clear all indexes."""
+        self._by_id.clear()
+        self._by_github_number.clear()
+        self._by_milestone.clear()
+        self._indexed_at = None
+
+
+# Global indexer instance
+_issue_indexer = IssueIndexer()
+
+
+def get_issue_indexer() -> IssueIndexer:
+    """Get the global issue indexer instance.
+
+    Returns:
+        IssueIndexer instance
+    """
+    return _issue_indexer

roadmap/core/services/sync/sync_change_computer.py

@@ -0,0 +1,211 @@
+"""Helpers to compute changes between baseline and local/remote states.
+
+Extracted from `SyncStateComparator` to keep comparison logic testable
+and allow the comparator to delegate responsibility.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import structlog
+
+logger = structlog.get_logger()
+
+
+def _convert_enum_field(field_name: str, value: Any) -> Any:
+    """Convert string enum values to enum types for status/priority fields.
+
+    Args:
+        field_name: Name of field ("status", "priority", etc.)
+        value: Value to potentially convert
+
+    Returns:
+        Converted enum value, or original value if conversion fails/not applicable
+    """
+    if not isinstance(value, str) or value is None:
+        return value
+
+    if field_name == "status":
+        try:
+            from roadmap.common.constants import Status
+
+            try:
+                return Status(value).value
+            except (ValueError, KeyError):
+                return Status(value.lower()).value
+        except Exception as e:
+            logger.debug(
+                "enum_conversion_failed",
+                operation="convert_enum_field",
+                field="status",
+                provided_value=value,
+                error=str(e),
+                action="Using fallback value",
+            )
+            return value
+
+    if field_name == "priority":
+        try:
+            from roadmap.common.constants import Priority
+
+            try:
+                return Priority(value).value
+            except (ValueError, KeyError):
+                return Priority(value.lower()).value
+        except Exception as e:
+            logger.debug(
+                "enum_conversion_failed",
+                operation="convert_enum_field",
+                field="priority",
+                provided_value=value,
+                error=str(e),
+                action="Using fallback value",
+            )
+            return value
+
+    return value
+
+
+def compute_changes(
+    baseline: Any | None,
+    local: Any,
+    *,
+    logger: Any | None = None,
+) -> dict[str, Any]:
+    """Compute what changed between baseline and local issue.
+
+    This mirrors the behavior from the original comparator implementation.
+    """
+    changes: dict[str, Any] = {}
+
+    field_map = {
+        "status": (
+            "status",
+            lambda x: x.status.value if hasattr(x.status, "value") else str(x.status),
+        ),
+        "assignee": ("assignee", lambda x: x.assignee),
+        "content": ("content", lambda x: x.content),
+        "labels": ("labels", lambda x: sorted(x.labels or [])),
+    }
+
+    for field_name, (baseline_attr, local_getter) in field_map.items():
+        try:
+            baseline_value = getattr(baseline, baseline_attr, None)
+            local_value = local_getter(local)
+
+            if baseline_value != local_value:
+                changes[field_name] = {"from": baseline_value, "to": local_value}
+                if logger is not None:
+                    try:
+                        logger.debug(
+                            "field_changed_detected",
+                            source="local",
+                            field=field_name,
+                            baseline=baseline_value,
+                            current=local_value,
+                        )
+                    except Exception as logging_error:
+                        logger.error(
+                            "logger_failed",
+                            operation="compute_changes (debug logging)",
+                            error=str(logging_error),
+                        )
+        except Exception as e:
+            if logger is not None:
+                try:
+                    logger.warning(
+                        "field_change_detection_error",
+                        source="local",
+                        field=field_name,
+                        error=str(e),
+                    )
+                except Exception as logging_error:
+                    logger.error(
+                        "logger_failed",
+                        operation="compute_changes (warning logging)",
+                        error=str(logging_error),
+                    )
+            continue
+
+    return changes
+
+
+def compute_changes_remote(
+    baseline: Any | None,
+    remote: Any,
+    *,
+    logger: Any | None = None,
+) -> dict[str, Any]:
+    """Compute what changed between baseline and remote issue.
+
+    Accepts either dict-like or object remote representations.
+    """
+    changes: dict[str, Any] = {}
+
+    def get_remote_field(field_name: str, default: Any = None) -> Any:
+        if isinstance(remote, dict):
+            return remote.get(field_name, default)
+        return getattr(remote, field_name, default)
+
+    field_map = {
+        "status": ("status", lambda: get_remote_field("status")),
+        "assignee": ("assignee", lambda: get_remote_field("assignee")),
+        "content": (
+            "content",
+            lambda: (
+                get_remote_field("content") or get_remote_field("description") or ""
+            ),
+        ),
+        "labels": (
+            "labels",
+            lambda: (
+                sorted(get_remote_field("labels", []))
+                if get_remote_field("labels")
+                else []
+            ),
+        ),
+    }
+
+    for field_name, (baseline_attr, remote_getter) in field_map.items():
+        try:
+            baseline_value = getattr(baseline, baseline_attr, None)
+            remote_value = remote_getter()
+
+            # Convert enum strings to types
+            remote_value = _convert_enum_field(field_name, remote_value)
+
+            if baseline_value != remote_value:
+                changes[field_name] = {"from": baseline_value, "to": remote_value}
+                if logger is not None:
+                    try:
+                        logger.debug(
+                            "field_changed_detected",
+                            source="remote",
+                            field=field_name,
+                            baseline=baseline_value,
+                            current=remote_value,
+                        )
+                    except Exception as logging_error:
+                        logger.error(
+                            "logger_failed",
+                            operation="compute_changes_remote (debug logging)",
+                            error=str(logging_error),
+                        )
+        except Exception as e:
+            if logger is not None:
+                try:
+                    logger.warning(
+                        "field_change_detection_error_remote",
+                        field=field_name,
+                        error=str(e),
+                    )
+                except Exception as logging_error:
+                    logger.error(
+                        "logger_failed",
+                        operation="compute_changes_remote (warning logging)",
+                        error=str(logging_error),
+                    )
+            continue
+
+    return changes