roadmap-cli 0.1.1__py3-none-any.whl

roadmap/adapters/persistence/repositories/project_repository.py

@@ -0,0 +1,168 @@
+"""Repository for project persistence operations."""
+
+from typing import Any
+
+from roadmap.common.errors import OperationType, safe_operation
+from roadmap.common.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+class ProjectRepository:
+    """Handles all project-related database operations."""
+
+    def __init__(self, get_connection, transaction):
+        """Initialize repository with database connection methods.
+
+        Args:
+            get_connection: Callable that returns sqlite3 Connection
+            transaction: Context manager for database transactions
+        """
+        self._get_connection = get_connection
+        self._transaction = transaction
+
+    @safe_operation(OperationType.CREATE, "Project", include_traceback=True)
+    @safe_operation(OperationType.CREATE, "Project", include_traceback=True)
+    def create(self, project_data: dict[str, Any]) -> str:
+        """Create a new project.
+
+        Args:
+            project_data: Dictionary with project fields
+
+        Returns:
+            Project ID
+        """
+        with self._transaction() as conn:
+            conn.execute(
+                """
+                INSERT INTO projects (id, name, description, status, metadata)
+                VALUES (?, ?, ?, ?, ?)
+            """,
+                (
+                    project_data["id"],
+                    project_data["name"],
+                    project_data.get("description"),
+                    project_data.get("status", "active"),
+                    project_data.get("metadata"),
+                ),
+            )
+
+        logger.info("Created project", project_id=project_data["id"])
+        return project_data["id"]
+
+    def get(self, project_id: str) -> dict[str, Any] | None:
+        """Get project by ID.
+
+        Args:
+            project_id: Project identifier
+
+        Returns:
+            Project data or None if not found
+        """
+        conn = self._get_connection()
+        row = conn.execute(
+            "SELECT * FROM projects WHERE id = ?", (project_id,)
+        ).fetchone()
+
+        return dict(row) if row else None
+
+    def list_all(self) -> list[dict[str, Any]]:
+        """List all projects.
+
+        Returns:
+            List of project data dictionaries
+        """
+        conn = self._get_connection()
+        rows = conn.execute(
+            "SELECT * FROM projects ORDER BY created_at DESC"
+        ).fetchall()
+        return [dict(row) for row in rows]
+
+    @safe_operation(OperationType.UPDATE, "Project")
+    @safe_operation(OperationType.UPDATE, "Project")
+    def update(self, project_id: str, updates: dict[str, Any]) -> bool:
+        """Update project.
+
+        Args:
+            project_id: Project identifier
+            updates: Dictionary of fields to update
+
+        Returns:
+            True if successful, False otherwise
+        """
+        if not updates:
+            return False
+
+        set_clause = ", ".join(f"{key} = ?" for key in updates.keys())
+        values = list(updates.values()) + [project_id]
+
+        with self._transaction() as conn:
+            cursor = conn.execute(
+                f"""
+                UPDATE projects SET {set_clause} WHERE id = ?
+            """,
+                values,
+            )
+
+        updated = cursor.rowcount > 0
+        if updated:
+            logger.info(
+                "Updated project", project_id=project_id, updates=list(updates.keys())
+            )
+
+        return updated
+
+    @safe_operation(OperationType.DELETE, "Project", include_traceback=True)
+    @safe_operation(OperationType.DELETE, "Project", include_traceback=True)
+    def delete(self, project_id: str) -> bool:
+        """Delete project and all related data.
+
+        Args:
+            project_id: Project identifier
+
+        Returns:
+            True if successful, False otherwise
+        """
+        with self._transaction() as conn:
+            cursor = conn.execute("DELETE FROM projects WHERE id = ?", (project_id,))
+
+        deleted = cursor.rowcount > 0
+        if deleted:
+            logger.info("Deleted project", project_id=project_id)
+
+        return deleted
+
+    @safe_operation(OperationType.UPDATE, "Project")
+    @safe_operation(OperationType.UPDATE, "Project")
+    def mark_archived(self, project_id: str, archived: bool = True) -> bool:
+        """Mark a project as archived or unarchived.
+
+        Args:
+            project_id: Project identifier
+            archived: True to archive, False to unarchive
+
+        Returns:
+            True if successful, False otherwise
+        """
+        with self._transaction() as conn:
+            if archived:
+                cursor = conn.execute(
+                    "UPDATE projects SET archived = 1, archived_at = CURRENT_TIMESTAMP WHERE id = ?",
+                    (project_id,),
+                )
+            else:
+                cursor = conn.execute(
+                    "UPDATE projects SET archived = 0, archived_at = NULL WHERE id = ?",
+                    (project_id,),
+                )
+
+        updated = cursor.rowcount > 0
+        if updated:
+            action = "archived" if archived else "unarchived"
+            logger.info(
+                "project_status_changed",
+                project_id=project_id,
+                action=action,
+            )
+
+        return updated

roadmap/adapters/persistence/repositories/remote_link_repository.py

@@ -0,0 +1,355 @@
+"""Repository for managing issue-to-backend remote ID mappings.
+
+Provides fast lookups and mutations for remote backend IDs stored in the
+issue_remote_links database table. This enables efficient sync operations
+without scanning YAML files.
+"""
+
+from roadmap.common.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+class RemoteLinkRepository:
+    """Handles issue remote link database operations.
+
+    Provides CRUD operations for tracking which issues are linked to
+    which remote backend IDs (e.g., GitHub issue numbers, GitLab MRs, etc).
+    """
+
+    def __init__(self, get_connection, transaction):
+        """Initialize repository with database connection methods.
+
+        Args:
+            get_connection: Callable that returns sqlite3 Connection
+            transaction: Context manager for database transactions
+        """
+        self._get_connection = get_connection
+        self._transaction = transaction
+
+    def link_issue(
+        self, issue_uuid: str, backend_name: str, remote_id: str | int
+    ) -> bool:
+        """Link an issue to a remote backend ID.
+
+        Args:
+            issue_uuid: Local issue UUID
+            backend_name: Backend name (e.g., 'github', 'gitlab')
+            remote_id: Remote ID in that backend (string or int)
+
+        Returns:
+            True if link created/updated, False if error
+        """
+        try:
+            remote_id_str = str(remote_id)
+            with self._transaction() as conn:
+                conn.execute(
+                    """
+                    INSERT OR REPLACE INTO issue_remote_links
+                    (issue_uuid, backend_name, remote_id)
+                    VALUES (?, ?, ?)
+                """,
+                    (issue_uuid, backend_name, remote_id_str),
+                )
+            logger.debug(
+                "Linked issue to remote backend",
+                issue_uuid=issue_uuid,
+                backend_name=backend_name,
+                remote_id=remote_id_str,
+            )
+            return True
+        except Exception as e:
+            logger.warning(
+                "Failed to link issue",
+                issue_uuid=issue_uuid,
+                backend_name=backend_name,
+                remote_id=str(remote_id),
+                error_type=type(e).__name__,
+                error_message=str(e),
+                error_details=repr(e),
+                severity="operational",
+            )
+            return False
+
+    def unlink_issue(self, issue_uuid: str, backend_name: str) -> bool:
+        """Unlink an issue from a remote backend.
+
+        Args:
+            issue_uuid: Local issue UUID
+            backend_name: Backend name
+
+        Returns:
+            True if unlinked, False if error or not found
+        """
+        try:
+            with self._transaction() as conn:
+                cursor = conn.execute(
+                    """
+                    DELETE FROM issue_remote_links
+                    WHERE issue_uuid = ? AND backend_name = ?
+                """,
+                    (issue_uuid, backend_name),
+                )
+            if cursor.rowcount > 0:
+                logger.debug(
+                    "Unlinked issue from remote backend",
+                    issue_uuid=issue_uuid,
+                    backend_name=backend_name,
+                )
+                return True
+            return False
+        except Exception as e:
+            logger.warning(
+                "Failed to unlink issue",
+                issue_uuid=issue_uuid,
+                backend_name=backend_name,
+                error_type=type(e).__name__,
+                error_message=str(e),
+                severity="operational",
+            )
+            return False
+
+    def get_remote_id(self, issue_uuid: str, backend_name: str) -> str | int | None:
+        """Get the remote ID for an issue on a specific backend.
+
+        Args:
+            issue_uuid: Local issue UUID
+            backend_name: Backend name (e.g., 'github')
+
+        Returns:
+            Remote ID (as string) or None if not linked
+        """
+        try:
+            conn = self._get_connection()
+            row = conn.execute(
+                """
+                SELECT remote_id FROM issue_remote_links
+                WHERE issue_uuid = ? AND backend_name = ?
+            """,
+                (issue_uuid, backend_name),
+            ).fetchone()
+            if row:
+                # Try to convert to int if it looks like one
+                remote_id = row["remote_id"]
+                try:
+                    return int(remote_id)
+                except (ValueError, TypeError):
+                    return remote_id
+            return None
+        except Exception as e:
+            logger.warning(
+                "Failed to get remote ID",
+                issue_uuid=issue_uuid,
+                backend_name=backend_name,
+                error_type=type(e).__name__,
+                error_message=str(e),
+                severity="operational",
+            )
+            return None
+
+    def get_issue_uuid(self, backend_name: str, remote_id: str | int) -> str | None:
+        """Reverse lookup: get local issue UUID from remote backend ID.
+
+        Args:
+            backend_name: Backend name (e.g., 'github')
+            remote_id: Remote ID in that backend
+
+        Returns:
+            Issue UUID or None if not found
+        """
+        try:
+            remote_id_str = str(remote_id)
+            conn = self._get_connection()
+            row = conn.execute(
+                """
+                SELECT issue_uuid FROM issue_remote_links
+                WHERE backend_name = ? AND remote_id = ?
+            """,
+                (backend_name, remote_id_str),
+            ).fetchone()
+            if row:
+                return row["issue_uuid"]
+            return None
+        except Exception as e:
+            logger.warning(
+                "Failed to get issue UUID",
+                backend_name=backend_name,
+                remote_id=str(remote_id),
+                error_type=type(e).__name__,
+                error_message=str(e),
+            )
+            return None
+
+    def get_all_links_for_issue(self, issue_uuid: str) -> dict[str, str | int]:
+        """Get all remote links for an issue (all backends).
+
+        Args:
+            issue_uuid: Local issue UUID
+
+        Returns:
+            Dict mapping backend_name -> remote_id
+        """
+        try:
+            conn = self._get_connection()
+            rows = conn.execute(
+                """
+                SELECT backend_name, remote_id FROM issue_remote_links
+                WHERE issue_uuid = ?
+            """,
+                (issue_uuid,),
+            ).fetchall()
+            result = {}
+            for row in rows:
+                backend_name = row["backend_name"]
+                remote_id_str = row["remote_id"]
+                # Try to convert to int if it looks like one
+                try:
+                    result[backend_name] = int(remote_id_str)
+                except (ValueError, TypeError):
+                    result[backend_name] = remote_id_str
+            return result
+        except Exception as e:
+            logger.warning(
+                "Failed to get all links for issue",
+                issue_uuid=issue_uuid,
+                error_type=type(e).__name__,
+                error_message=str(e),
+            )
+            return {}
+
+    def get_all_links_for_backend(self, backend_name: str) -> dict[str, str | int]:
+        """Get all remote links for a specific backend.
+
+        Args:
+            backend_name: Backend name (e.g., 'github')
+
+        Returns:
+            Dict mapping issue_uuid -> remote_id
+        """
+        try:
+            conn = self._get_connection()
+            rows = conn.execute(
+                """
+                SELECT issue_uuid, remote_id FROM issue_remote_links
+                WHERE backend_name = ?
+            """,
+                (backend_name,),
+            ).fetchall()
+            result = {}
+            for row in rows:
+                issue_uuid = row["issue_uuid"]
+                remote_id_str = row["remote_id"]
+                # Try to convert to int if it looks like one
+                try:
+                    result[issue_uuid] = int(remote_id_str)
+                except (ValueError, TypeError):
+                    result[issue_uuid] = remote_id_str
+            return result
+        except Exception as e:
+            logger.warning(
+                "Failed to get all links for backend",
+                backend_name=backend_name,
+                error_type=type(e).__name__,
+                error_message=str(e),
+            )
+            return {}
+
+    def validate_link(
+        self, issue_uuid: str, backend_name: str, remote_id: str | int
+    ) -> bool:
+        """Check if a link is valid (exists and matches remote_id).
+
+        Args:
+            issue_uuid: Local issue UUID
+            backend_name: Backend name
+            remote_id: Expected remote ID
+
+        Returns:
+            True if link exists and matches, False otherwise
+        """
+        try:
+            existing_id = self.get_remote_id(issue_uuid, backend_name)
+            if existing_id is None:
+                return False
+            # Compare as strings to handle int/str variations
+            return str(existing_id) == str(remote_id)
+        except Exception as e:
+            logger.warning(
+                "Failed to validate link",
+                issue_uuid=issue_uuid,
+                backend_name=backend_name,
+                error_type=type(e).__name__,
+                error_message=str(e),
+            )
+            return False
+
+    def bulk_import_from_yaml(
+        self, issues_with_remote_ids: dict[str, dict[str, str | int]]
+    ) -> int:
+        """Bulk import remote links from Issue objects with remote_ids.
+
+        This is typically called during initialization to sync existing
+        remote_ids from YAML files into the database.
+
+        Args:
+            issues_with_remote_ids: Dict mapping issue_uuid -> dict of backend_name -> remote_id
+
+        Returns:
+            Number of links successfully imported
+        """
+        count = 0
+        try:
+            with self._transaction() as conn:
+                for issue_uuid, remote_ids_dict in issues_with_remote_ids.items():
+                    if not remote_ids_dict:
+                        continue
+                    for backend_name, remote_id in remote_ids_dict.items():
+                        try:
+                            remote_id_str = str(remote_id)
+                            conn.execute(
+                                """
+                                INSERT OR IGNORE INTO issue_remote_links
+                                (issue_uuid, backend_name, remote_id)
+                                VALUES (?, ?, ?)
+                            """,
+                                (issue_uuid, backend_name, remote_id_str),
+                            )
+                            count += 1
+                        except Exception as e:
+                            logger.debug(
+                                "Failed to import link",
+                                issue_uuid=issue_uuid,
+                                backend_name=backend_name,
+                                remote_id=remote_id_str,
+                                error_type=type(e).__name__,
+                                error_message=str(e),
+                            )
+            logger.info("Bulk imported remote links", count=count)
+            return count
+        except Exception as e:
+            logger.error(
+                "Bulk import of remote links failed",
+                count_imported=count,
+                error_type=type(e).__name__,
+                error_message=str(e),
+            )
+            return count
+
+    def clear_all(self) -> bool:
+        """Clear all remote links (useful for resetting/testing).
+
+        Returns:
+            True if successful, False if error
+        """
+        try:
+            with self._transaction() as conn:
+                conn.execute("DELETE FROM issue_remote_links")
+            logger.info("Cleared all remote links")
+            return True
+        except Exception as e:
+            logger.error(
+                "Failed to clear all remote links",
+                error_type=type(e).__name__,
+                error_message=str(e),
+            )
+            return False

roadmap/adapters/persistence/repositories/sync_state_repository.py

@@ -0,0 +1,66 @@
+"""Repository for sync state persistence operations."""
+
+from roadmap.common.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+class SyncStateRepository:
+    """Handles all sync state database operations."""
+
+    def __init__(self, get_connection, transaction):
+        """Initialize repository with database connection methods.
+
+        Args:
+            get_connection: Callable that returns sqlite3 Connection
+            transaction: Context manager for database transactions
+        """
+        self._get_connection = get_connection
+        self._transaction = transaction
+
+    def get(self, key: str) -> str | None:
+        """Get sync state value by key.
+
+        Args:
+            key: State key
+
+        Returns:
+            State value or None if not found
+        """
+        conn = self._get_connection()
+        row = conn.execute(
+            "SELECT value FROM sync_metadata WHERE key = ?", (key,)
+        ).fetchone()
+        return row["value"] if row else None
+
+    def set(self, key: str, value: str) -> None:
+        """Set sync state value.
+
+        Args:
+            key: State key
+            value: State value
+        """
+        with self._transaction() as conn:
+            conn.execute(
+                """
+                INSERT OR REPLACE INTO sync_metadata (key, value) VALUES (?, ?)
+            """,
+                (key, value),
+            )
+        logger.debug("Set sync state", key=key)
+
+    def delete(self, key: str) -> None:
+        """Delete sync state value.
+
+        Args:
+            key: State key
+        """
+        with self._transaction() as conn:
+            conn.execute("DELETE FROM sync_metadata WHERE key = ?", (key,))
+        logger.debug("Deleted sync state", key=key)
+
+    def clear_all(self) -> None:
+        """Clear all sync state values."""
+        with self._transaction() as conn:
+            conn.execute("DELETE FROM sync_metadata")
+        logger.info("Cleared all sync state")

roadmap/adapters/persistence/storage/__init__.py

@@ -0,0 +1,36 @@
+"""Storage layer with modularized state management.
+
+Organizes large query and conflict operations into separate service files:
+- state_manager.py: Main StateManager facade (290 LOC after refactor)
+- connection_manager.py: Database connection and transaction management (60 LOC)
+- project_storage.py: Project CRUD operations (80 LOC)
+- milestone_storage.py: Milestone CRUD operations (70 LOC)
+- issue_storage.py: Issue CRUD operations (80 LOC)
+- sync_state_storage.py: Sync state and file synchronization (180 LOC)
+- queries.py: Complex database queries and aggregations (190 LOC)
+- conflicts.py: Git conflict detection and handling (80 LOC)
+"""
+
+from .connection_manager import ConnectionManager
+from .issue_storage import IssueStorage
+from .milestone_storage import MilestoneStorage
+from .project_storage import ProjectStorage
+from .state_manager import (
+    DatabaseError,
+    StateManager,
+    get_state_manager,
+    initialize_state_manager,
+)
+from .sync_state_storage import SyncStateStorage
+
+__all__ = [
+    "ConnectionManager",
+    "DatabaseError",
+    "IssueStorage",
+    "MilestoneStorage",
+    "ProjectStorage",
+    "StateManager",
+    "SyncStateStorage",
+    "get_state_manager",
+    "initialize_state_manager",
+]