roadmap-cli 0.1.1__py3-none-any.whl

roadmap/adapters/persistence/storage/sync_state_storage.py

@@ -0,0 +1,207 @@
+"""Sync state and file synchronization operations."""
+
+from pathlib import Path
+from typing import Any
+
+from roadmap.common.errors import OperationType, safe_operation
+from roadmap.common.logging import get_logger
+
+from ..file_synchronizer import FileSynchronizer
+from ..repositories import SyncStateRepository
+
+logger = get_logger(__name__)
+
+
+class SyncStateStorage:
+    """Handles sync state tracking and file synchronization operations."""
+
+    def __init__(
+        self,
+        sync_state_repo: SyncStateRepository,
+        file_synchronizer: FileSynchronizer,
+    ):
+        """Initialize sync state storage.
+
+        Args:
+            sync_state_repo: SyncStateRepository instance for sync state persistence
+            file_synchronizer: FileSynchronizer instance for file operations
+        """
+        self._sync_state_repo = sync_state_repo
+        self._file_synchronizer = file_synchronizer
+        logger.debug("sync_state_storage_initialized")
+
+    # Sync state operations
+    def get_sync_state(self, key: str) -> str | None:
+        """Get sync state value.
+
+        Args:
+            key: State key identifier
+
+        Returns:
+            str: State value or None if not found
+        """
+        logger.debug("Getting sync state", key=key)
+        return self._sync_state_repo.get(key)
+
+    def set_sync_state(self, key: str, value: str):
+        """Set sync state value.
+
+        Args:
+            key: State key identifier
+            value: State value to store
+        """
+        logger.debug("Setting sync state", key=key, value_length=len(value))
+        self._sync_state_repo.set(key, value)
+
+    # File sync operations
+    def get_file_sync_status(self, file_path: str) -> dict[str, Any] | None:
+        """Get sync status for a file.
+
+        Args:
+            file_path: Path to file
+
+        Returns:
+            dict: Sync status data or None if not found
+        """
+        logger.debug("Getting file sync status", file_path=file_path)
+        return self._file_synchronizer.get_file_sync_status(file_path)
+
+    @safe_operation(OperationType.UPDATE, "FileSync")
+    def update_file_sync_status(
+        self, file_path: str, content_hash: str, file_size: int, last_modified: Any
+    ):
+        """Update sync status for a file.
+
+        Args:
+            file_path: Path to file
+            content_hash: Hash of file content
+            file_size: Size of file in bytes
+            last_modified: Last modification timestamp
+        """
+        logger.debug(
+            "Updating file sync status", file_path=file_path, file_size=file_size
+        )
+        self._file_synchronizer.update_file_sync_status(
+            file_path, content_hash, file_size, last_modified
+        )
+
+    def has_file_changed(self, file_path: Path) -> bool:
+        """Check if file has changed since last sync.
+
+        Args:
+            file_path: Path to file
+
+        Returns:
+            bool: True if file has changed
+        """
+        result = self._file_synchronizer.has_file_changed(file_path)
+        logger.debug("File change check", file_path=str(file_path), changed=result)
+        return result
+
+    @safe_operation(OperationType.SYNC, "Directory", retryable=True, max_retries=2)
+    def sync_directory_incremental(self, roadmap_dir: Path) -> dict[str, Any]:
+        """Incrementally sync .roadmap directory to database.
+
+        Args:
+            roadmap_dir: Path to .roadmap directory
+
+        Returns:
+            dict: Sync results with files_synced count
+        """
+        logger.info("Incremental sync started", roadmap_dir=str(roadmap_dir))
+        result = self._file_synchronizer.sync_directory_incremental(roadmap_dir)
+        logger.info(
+            "Incremental sync completed",
+            roadmap_dir=str(roadmap_dir),
+            files_synced=result.get("files_synced", 0),
+        )
+        return result
+
+    @safe_operation(OperationType.SYNC, "Directory", retryable=True, max_retries=2)
+    def full_rebuild_from_git(self, roadmap_dir: Path) -> dict[str, Any]:
+        """Full rebuild of database from git files.
+
+        Args:
+            roadmap_dir: Path to .roadmap directory
+
+        Returns:
+            dict: Rebuild results with files_processed count
+        """
+        logger.info("Full rebuild from git started", roadmap_dir=str(roadmap_dir))
+        result = self._file_synchronizer.full_rebuild_from_git(roadmap_dir)
+        logger.info(
+            "Full rebuild completed",
+            roadmap_dir=str(roadmap_dir),
+            files_processed=result.get("files_processed", 0),
+        )
+        return result
+
+    def should_do_full_rebuild(self, roadmap_dir: Path, threshold: int = 50) -> bool:
+        """Determine if full rebuild is needed vs incremental sync.
+
+        Args:
+            roadmap_dir: Path to .roadmap directory
+            threshold: Number of changed files before full rebuild recommended
+
+        Returns:
+            bool: True if full rebuild is recommended
+        """
+        result = self._file_synchronizer.should_do_full_rebuild(roadmap_dir, threshold)
+        logger.debug("Full rebuild check", roadmap_dir=str(roadmap_dir), result=result)
+        return result
+
+    @safe_operation(OperationType.SYNC, "Directory")
+    def smart_sync(self, roadmap_dir: Path | None = None) -> dict[str, Any]:
+        """Smart sync that chooses between incremental and full rebuild.
+
+        Args:
+            roadmap_dir: Path to .roadmap directory. Defaults to .roadmap in cwd
+
+        Returns:
+            dict: Sync results
+        """
+        if roadmap_dir is None:
+            roadmap_dir = Path.cwd() / ".roadmap"
+
+        logger.info("Smart sync started", roadmap_dir=str(roadmap_dir))
+
+        try:
+            if self.should_do_full_rebuild(roadmap_dir):
+                logger.info("Choosing full rebuild", roadmap_dir=str(roadmap_dir))
+                result = self.full_rebuild_from_git(roadmap_dir)
+            else:
+                logger.info("Choosing incremental sync", roadmap_dir=str(roadmap_dir))
+                result = self.sync_directory_incremental(roadmap_dir)
+
+            logger.info(
+                "Smart sync completed",
+                roadmap_dir=str(roadmap_dir),
+                result_keys=list(result.keys()),
+            )
+            return result
+
+        except Exception as e:
+            logger.error(
+                "Smart sync failed",
+                roadmap_dir=str(roadmap_dir),
+                error=str(e),
+                error_type=type(e).__name__,
+            )
+            return {"error": str(e), "files_failed": 1}
+
+    # File changes checking - needs state manager context
+    def has_file_changes(self, state_manager) -> bool:
+        """Check if .roadmap/ files have changes since last sync.
+
+        Args:
+            state_manager: StateManager instance for database access
+
+        Returns:
+            bool: True if changes detected
+        """
+        from .queries import QueryService
+
+        logger.debug("Checking file changes")
+        result = QueryService(state_manager).has_file_changes()
+        logger.debug("File changes check completed", has_changes=result)
+        return result

roadmap/adapters/persistence/sync_metrics_repository.py

@@ -0,0 +1,342 @@
+"""Repository for persisting and querying sync metrics.
+
+This module provides database persistence for sync operation metrics,
+allowing historical tracking and analysis of sync operations.
+"""
+
+import json
+import uuid
+from datetime import UTC, datetime, timedelta
+from typing import Any
+
+from roadmap.adapters.persistence.database_manager import DatabaseManager
+from roadmap.common.logging import get_logger
+from roadmap.core.observability.sync_metrics import SyncMetrics
+
+logger = get_logger(__name__)
+
+
+class SyncMetricsRepository:
+    """Repository for sync metrics persistence and queries."""
+
+    def __init__(self, db_manager: DatabaseManager):
+        """Initialize the repository.
+
+        Args:
+            db_manager: DatabaseManager instance for database access
+        """
+        self.db_manager = db_manager
+
+    def save(self, metrics: SyncMetrics) -> bool:
+        """Save sync metrics to database.
+
+        Args:
+            metrics: SyncMetrics object to persist
+
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            record_id = str(uuid.uuid4())
+            metrics_dict = metrics.to_dict()
+            metrics_json = json.dumps(metrics_dict)
+
+            with self.db_manager.transaction() as conn:
+                conn.execute(
+                    """
+                    INSERT INTO sync_metrics (
+                        id,
+                        operation_id,
+                        backend_type,
+                        duration_seconds,
+                        metrics_json,
+                        created_at
+                    ) VALUES (?, ?, ?, ?, ?, ?)
+                    """,
+                    (
+                        record_id,
+                        metrics.operation_id,
+                        metrics.backend_type,
+                        metrics.duration_seconds,
+                        metrics_json,
+                        datetime.now(UTC).isoformat(),
+                    ),
+                )
+
+            logger.info(
+                "sync_metrics_saved",
+                operation_id=metrics.operation_id,
+                backend_type=metrics.backend_type,
+                duration_seconds=metrics.duration_seconds,
+            )
+            return True
+
+        except Exception as e:
+            logger.error(
+                "sync_metrics_save_failed",
+                error=str(e),
+                operation_id=metrics.operation_id,
+                severity="operational",
+            )
+            return False
+
+    def get_latest(self, backend_type: str | None = None) -> SyncMetrics | None:
+        """Get the most recent sync metrics.
+
+        Args:
+            backend_type: Optional filter by backend type
+
+        Returns:
+            SyncMetrics if found, None otherwise
+        """
+        try:
+            conn = self.db_manager._get_connection()
+
+            query = "SELECT metrics_json FROM sync_metrics"
+            params = []
+
+            if backend_type:
+                query += " WHERE backend_type = ?"
+                params.append(backend_type)
+
+            query += " ORDER BY created_at DESC LIMIT 1"
+
+            cursor = conn.execute(query, params)
+            row = cursor.fetchone()
+
+            if not row:
+                return None
+
+            metrics_dict = json.loads(row[0])
+            return self._dict_to_metrics(metrics_dict)
+
+        except Exception as e:
+            logger.error(
+                "sync_metrics_get_latest_failed",
+                error=str(e),
+                backend_type=backend_type,
+                severity="operational",
+            )
+            return None
+
+    def list_by_date(
+        self, backend_type: str | None = None, days: int = 7
+    ) -> list[SyncMetrics]:
+        """List sync metrics from the last N days.
+
+        Args:
+            backend_type: Optional filter by backend type
+            days: Number of days to look back (default: 7)
+
+        Returns:
+            List of SyncMetrics objects
+        """
+        try:
+            conn = self.db_manager._get_connection()
+            cutoff_date = (datetime.now(UTC) - timedelta(days=days)).isoformat()
+
+            query = "SELECT metrics_json FROM sync_metrics WHERE created_at >= ?"
+            params = [cutoff_date]
+
+            if backend_type:
+                query += " AND backend_type = ?"
+                params.append(backend_type)
+
+            query += " ORDER BY created_at DESC"
+
+            cursor = conn.execute(query, params)
+            rows = cursor.fetchall()
+
+            metrics_list = []
+            for row in rows:
+                try:
+                    metrics_dict = json.loads(row[0])
+                    metrics = self._dict_to_metrics(metrics_dict)
+                    metrics_list.append(metrics)
+                except Exception as e:
+                    logger.warning(
+                        "sync_metrics_deserialization_failed",
+                        error=str(e),
+                        severity="operational",
+                    )
+
+            return metrics_list
+
+        except Exception as e:
+            logger.error(
+                "sync_metrics_list_by_date_failed",
+                error=str(e),
+                backend_type=backend_type,
+                days=days,
+                severity="operational",
+            )
+            return []
+
+    def get_by_operation_id(self, operation_id: str) -> SyncMetrics | None:
+        """Get metrics for a specific operation ID.
+
+        Args:
+            operation_id: The operation ID to look up
+
+        Returns:
+            SyncMetrics if found, None otherwise
+        """
+        try:
+            conn = self.db_manager._get_connection()
+
+            cursor = conn.execute(
+                "SELECT metrics_json FROM sync_metrics WHERE operation_id = ? LIMIT 1",
+                (operation_id,),
+            )
+            row = cursor.fetchone()
+
+            if not row:
+                return None
+
+            metrics_dict = json.loads(row[0])
+            return self._dict_to_metrics(metrics_dict)
+
+        except Exception as e:
+            logger.error(
+                "sync_metrics_get_by_operation_id_failed",
+                error=str(e),
+                operation_id=operation_id,
+                severity="operational",
+            )
+            return None
+
+    def get_statistics(
+        self, backend_type: str | None = None, days: int = 30
+    ) -> dict[str, Any]:
+        """Get aggregate statistics for sync metrics.
+
+        Args:
+            backend_type: Optional filter by backend type
+            days: Number of days to analyze (default: 30)
+
+        Returns:
+            Dictionary with statistics
+        """
+        try:
+            conn = self.db_manager._get_connection()
+            cutoff_date = (datetime.now(UTC) - timedelta(days=days)).isoformat()
+
+            query = "SELECT metrics_json FROM sync_metrics WHERE created_at >= ?"
+            params = [cutoff_date]
+
+            if backend_type:
+                query += " AND backend_type = ?"
+                params.append(backend_type)
+
+            cursor = conn.execute(query, params)
+            rows = cursor.fetchall()
+
+            if not rows:
+                return {
+                    "total_syncs": 0,
+                    "avg_duration_seconds": 0.0,
+                    "total_duplicates_detected": 0,
+                    "total_conflicts_detected": 0,
+                    "total_errors": 0,
+                }
+
+            total_duration = 0.0
+            total_duplicates = 0
+            total_conflicts = 0
+            total_errors = 0
+            total_syncs = 0
+
+            for row in rows:
+                try:
+                    metrics_dict = json.loads(row[0])
+                    total_duration += metrics_dict.get("duration_seconds", 0.0)
+                    total_duplicates += metrics_dict.get("duplicates_detected", 0)
+                    total_conflicts += metrics_dict.get("conflicts_detected", 0)
+                    total_errors += metrics_dict.get("errors_count", 0)
+                    total_syncs += 1
+                except Exception as e:
+                    logger.warning(
+                        "sync_metrics_stats_parse_failed",
+                        error=str(e),
+                        severity="operational",
+                    )
+
+            return {
+                "total_syncs": total_syncs,
+                "avg_duration_seconds": (
+                    total_duration / total_syncs if total_syncs > 0 else 0.0
+                ),
+                "total_duplicates_detected": total_duplicates,
+                "total_conflicts_detected": total_conflicts,
+                "total_errors": total_errors,
+                "backends": backend_type or "all",
+                "period_days": days,
+            }
+
+        except Exception as e:
+            logger.error(
+                "sync_metrics_get_statistics_failed",
+                error=str(e),
+                backend_type=backend_type,
+                days=days,
+                severity="operational",
+            )
+            return {}
+
+    def delete_old_metrics(self, days: int = 90) -> int:
+        """Delete metrics older than N days.
+
+        Args:
+            days: Number of days to keep (default: 90)
+
+        Returns:
+            Number of records deleted
+        """
+        try:
+            cutoff_date = (datetime.now(UTC) - timedelta(days=days)).isoformat()
+
+            with self.db_manager.transaction() as conn:
+                cursor = conn.execute(
+                    "DELETE FROM sync_metrics WHERE created_at < ?",
+                    (cutoff_date,),
+                )
+                deleted_count = cursor.rowcount
+
+            logger.info(
+                "sync_metrics_old_records_deleted",
+                deleted_count=deleted_count,
+                days=days,
+            )
+            return deleted_count
+
+        except Exception as e:
+            logger.error(
+                "sync_metrics_delete_old_failed",
+                error=str(e),
+                days=days,
+                severity="operational",
+            )
+            return 0
+
+    @staticmethod
+    def _dict_to_metrics(metrics_dict: dict[str, Any]) -> SyncMetrics:
+        """Convert dictionary back to SyncMetrics object.
+
+        Args:
+            metrics_dict: Dictionary from metrics_json
+
+        Returns:
+            SyncMetrics object
+        """
+        # Extract main fields
+        metrics = SyncMetrics(
+            operation_id=metrics_dict.get("operation_id", ""),
+            backend_type=metrics_dict.get("backend_type", ""),
+        )
+
+        # Set all tracked fields from dictionary
+        for key, value in metrics_dict.items():
+            if hasattr(metrics, key):
+                setattr(metrics, key, value)
+
+        return metrics