roadmap-cli 0.1.1__py3-none-any.whl

roadmap/adapters/persistence/storage/conflicts.py

@@ -0,0 +1,101 @@
+"""Git conflict detection and handling service."""
+
+import json
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from roadmap.common.logging import get_logger
+
+if TYPE_CHECKING:
+    from .state_manager import StateManager
+
+logger = get_logger(__name__)
+
+
+class ConflictService:
+    """Service for detecting and managing git conflicts in .roadmap directory."""
+
+    def __init__(self, state_manager: "StateManager"):
+        """Initialize with reference to state manager.
+
+        Args:
+            state_manager: StateManager instance for accessing sync state
+        """
+        self.state_manager = state_manager
+
+    def check_git_conflicts(self, roadmap_dir: Path | None = None) -> list[str]:
+        """Check for git conflicts in .roadmap directory."""
+        if roadmap_dir is None:
+            roadmap_dir = Path.cwd() / ".roadmap"
+
+        conflict_files = []
+
+        try:
+            if not roadmap_dir.exists():
+                return conflict_files
+
+            # Check for conflict markers in .roadmap files
+            for pattern in ["**/*.md", "**/*.yaml", "**/*.yml"]:
+                for file_path in roadmap_dir.glob(pattern):
+                    try:
+                        with open(file_path, encoding="utf-8") as f:
+                            content = f.read()
+
+                        # Look for git conflict markers
+                        conflict_markers = ["<<<<<<<", "=======", ">>>>>>>"]
+                        if any(marker in content for marker in conflict_markers):
+                            conflict_files.append(
+                                str(file_path.relative_to(Path.cwd()))
+                            )
+
+                    except Exception as e:
+                        logger.warning(
+                            "failed_to_check_conflicts",
+                            error=str(e),
+                            file_path=str(file_path),
+                        )
+
+            if conflict_files:
+                logger.warning(
+                    "git_conflicts_detected",
+                    conflict_count=len(conflict_files),
+                    conflicts=conflict_files,
+                )
+                self.state_manager.set_sync_state("git_conflicts_detected", "true")
+                self.state_manager.set_sync_state(
+                    "conflict_files", json.dumps(conflict_files)
+                )
+            else:
+                self.state_manager.set_sync_state("git_conflicts_detected", "false")
+                self.state_manager.set_sync_state("conflict_files", "[]")
+
+            return conflict_files
+
+        except Exception as e:
+            logger.error(
+                "Failed to check git conflicts", error=str(e), severity="data_error"
+            )
+            return conflict_files
+
+    def has_git_conflicts(self) -> bool:
+        """Check if there are unresolved git conflicts."""
+        try:
+            conflicts_detected = self.state_manager.get_sync_state(
+                "git_conflicts_detected"
+            )
+            return conflicts_detected == "true"
+        except Exception as e:
+            logger.debug("git_conflict_check_failed", error=str(e))
+            # If we can't check, assume no conflicts to avoid blocking operations
+            return False
+
+    def get_conflict_files(self) -> list[str]:
+        """Get list of files with git conflicts."""
+        try:
+            conflict_files_json = self.state_manager.get_sync_state("conflict_files")
+            if conflict_files_json:
+                return json.loads(conflict_files_json)
+            return []
+        except Exception as e:
+            logger.debug("conflict_files_retrieval_failed", error=str(e))
+            return []

roadmap/adapters/persistence/storage/connection_manager.py

@@ -0,0 +1,79 @@
+"""Connection management for database operations."""
+
+import sqlite3
+from contextlib import contextmanager
+
+from roadmap.common.logging import get_logger
+
+from ..database_manager import DatabaseManager
+
+logger = get_logger(__name__)
+
+
+class ConnectionManager:
+    """Manages database connections and transactions."""
+
+    def __init__(self, db_manager: DatabaseManager):
+        """Initialize connection manager.
+
+        Args:
+            db_manager: DatabaseManager instance handling connection pooling
+        """
+        self._db_manager = db_manager
+        logger.debug("connection_manager_initialized")
+
+    def get_connection(self) -> sqlite3.Connection:
+        """Get thread-local database connection.
+
+        Returns:
+            sqlite3.Connection: Active database connection
+        """
+        return self._db_manager._get_connection()
+
+    @contextmanager
+    def transaction(self):
+        """Context manager for database transactions.
+
+        Yields:
+            Connection context with automatic commit/rollback on exception
+        """
+        with self._db_manager.transaction() as conn:
+            yield conn
+
+    def close(self):
+        """Close all database connections."""
+        logger.debug("Closing database connections")
+        self._db_manager.close()
+
+    def vacuum(self):
+        """Optimize database by vacuuming."""
+        logger.debug("Running database vacuum")
+        self._db_manager.vacuum()
+
+    def is_initialized(self) -> bool:
+        """Check if database is properly initialized.
+
+        Returns:
+            bool: True if database exists and is initialized
+        """
+        result = self._db_manager.is_initialized()
+        logger.debug("Database initialization check", initialized=result)
+        return result
+
+    def database_exists(self) -> bool:
+        """Check if database file exists and has tables.
+
+        Returns:
+            bool: True if database exists with tables
+        """
+        result = self._db_manager.database_exists()
+        logger.debug("Database existence check", exists=result)
+        return result
+
+    def is_safe_for_writes(self) -> tuple[bool, str]:
+        """Check if database is safe for write operations.
+
+        Returns:
+            tuple[bool, str]: (safe, message) indicating if writes are safe
+        """
+        return self._db_manager.is_safe_for_writes()

roadmap/adapters/persistence/storage/issue_storage.py

@@ -0,0 +1,89 @@
+"""Issue storage operations."""
+
+from typing import Any
+
+from roadmap.common.errors import OperationType, safe_operation
+from roadmap.common.logging import get_logger
+
+from ..repositories import IssueRepository
+
+logger = get_logger(__name__)
+
+
+class IssueStorage:
+    """Handles issue CRUD operations."""
+
+    def __init__(self, issue_repo: IssueRepository):
+        """Initialize issue storage.
+
+        Args:
+            issue_repo: IssueRepository instance for data access
+        """
+        self._issue_repo = issue_repo
+        logger.debug("issue_storage_initialized")
+
+    @safe_operation(OperationType.CREATE, "Issue", include_traceback=True)
+    def create(self, issue_data: dict[str, Any]) -> str:
+        """Create a new issue.
+
+        Args:
+            issue_data: Issue data dictionary
+
+        Returns:
+            str: ID of created issue
+        """
+        logger.debug("Creating issue", keys=list(issue_data.keys()))
+        return self._issue_repo.create(issue_data)
+
+    def get(self, issue_id: str) -> dict[str, Any] | None:
+        """Get issue by ID.
+
+        Args:
+            issue_id: Issue identifier
+
+        Returns:
+            dict: Issue data or None if not found
+        """
+        logger.debug("Getting issue", issue_id=issue_id)
+        return self._issue_repo.get(issue_id)
+
+    @safe_operation(OperationType.UPDATE, "Issue", include_traceback=True)
+    def update(self, issue_id: str, updates: dict[str, Any]) -> bool:
+        """Update issue.
+
+        Args:
+            issue_id: Issue identifier
+            updates: Dictionary of fields to update
+
+        Returns:
+            bool: True if update successful
+        """
+        logger.debug("Updating issue", issue_id=issue_id, keys=list(updates.keys()))
+        return self._issue_repo.update(issue_id, updates)
+
+    @safe_operation(OperationType.DELETE, "Issue", include_traceback=True)
+    def delete(self, issue_id: str) -> bool:
+        """Delete issue.
+
+        Args:
+            issue_id: Issue identifier
+
+        Returns:
+            bool: True if deletion successful
+        """
+        logger.debug("Deleting issue", issue_id=issue_id)
+        return self._issue_repo.delete(issue_id)
+
+    @safe_operation(OperationType.UPDATE, "Issue")
+    def mark_archived(self, issue_id: str, archived: bool = True) -> bool:
+        """Mark an issue as archived or unarchived.
+
+        Args:
+            issue_id: Issue identifier
+            archived: Whether to archive (True) or unarchive (False)
+
+        Returns:
+            bool: True if operation successful
+        """
+        logger.debug("Marking issue archived", issue_id=issue_id, archived=archived)
+        return self._issue_repo.mark_archived(issue_id, archived)

roadmap/adapters/persistence/storage/milestone_storage.py

@@ -0,0 +1,80 @@
+"""Milestone storage operations."""
+
+from typing import Any
+
+from roadmap.common.errors import OperationType, safe_operation
+from roadmap.common.logging import get_logger
+
+from ..repositories import MilestoneRepository
+
+logger = get_logger(__name__)
+
+
+class MilestoneStorage:
+    """Handles milestone CRUD operations."""
+
+    def __init__(self, milestone_repo: MilestoneRepository):
+        """Initialize milestone storage.
+
+        Args:
+            milestone_repo: MilestoneRepository instance for data access
+        """
+        self._milestone_repo = milestone_repo
+        logger.debug("milestone_storage_initialized")
+
+    @safe_operation(OperationType.CREATE, "Milestone", include_traceback=True)
+    def create(self, milestone_data: dict[str, Any]) -> str:
+        """Create a new milestone.
+
+        Args:
+            milestone_data: Milestone data dictionary
+
+        Returns:
+            str: ID of created milestone
+        """
+        logger.debug("Creating milestone", keys=list(milestone_data.keys()))
+        return self._milestone_repo.create(milestone_data)
+
+    def get(self, milestone_id: str) -> dict[str, Any] | None:
+        """Get milestone by ID.
+
+        Args:
+            milestone_id: Milestone identifier
+
+        Returns:
+            dict: Milestone data or None if not found
+        """
+        logger.debug("Getting milestone", milestone_id=milestone_id)
+        return self._milestone_repo.get(milestone_id)
+
+    @safe_operation(OperationType.UPDATE, "Milestone", include_traceback=True)
+    def update(self, milestone_id: str, updates: dict[str, Any]) -> bool:
+        """Update milestone.
+
+        Args:
+            milestone_id: Milestone identifier
+            updates: Dictionary of fields to update
+
+        Returns:
+            bool: True if update successful
+        """
+        logger.debug(
+            "Updating milestone", milestone_id=milestone_id, keys=list(updates.keys())
+        )
+        return self._milestone_repo.update(milestone_id, updates)
+
+    @safe_operation(OperationType.UPDATE, "Milestone")
+    def mark_archived(self, milestone_id: str, archived: bool = True) -> bool:
+        """Mark a milestone as archived or unarchived.
+
+        Args:
+            milestone_id: Milestone identifier
+            archived: Whether to archive (True) or unarchive (False)
+
+        Returns:
+            bool: True if operation successful
+        """
+        logger.debug(
+            "Marking milestone archived", milestone_id=milestone_id, archived=archived
+        )
+        return self._milestone_repo.mark_archived(milestone_id, archived)

roadmap/adapters/persistence/storage/project_storage.py

@@ -0,0 +1,102 @@
+"""Project storage operations."""
+
+from typing import Any
+
+from roadmap.common.errors import OperationType, safe_operation
+from roadmap.common.logging import get_logger
+
+from ..repositories import ProjectRepository
+
+logger = get_logger(__name__)
+
+
+class ProjectStorage:
+    """Handles project CRUD operations."""
+
+    def __init__(self, project_repo: ProjectRepository):
+        """Initialize project storage.
+
+        Args:
+            project_repo: ProjectRepository instance for data access
+        """
+        self._project_repo = project_repo
+        logger.debug("project_storage_initialized")
+
+    @safe_operation(OperationType.CREATE, "Project", include_traceback=True)
+    def create(self, project_data: dict[str, Any]) -> str:
+        """Create a new project.
+
+        Args:
+            project_data: Project data dictionary
+
+        Returns:
+            str: ID of created project
+        """
+        logger.debug("Creating project", keys=list(project_data.keys()))
+        return self._project_repo.create(project_data)
+
+    def get(self, project_id: str) -> dict[str, Any] | None:
+        """Get project by ID.
+
+        Args:
+            project_id: Project identifier
+
+        Returns:
+            dict: Project data or None if not found
+        """
+        logger.debug("Getting project", project_id=project_id)
+        return self._project_repo.get(project_id)
+
+    def list_all(self) -> list[dict[str, Any]]:
+        """List all projects.
+
+        Returns:
+            list: List of project data dictionaries
+        """
+        logger.debug("Listing all projects")
+        return self._project_repo.list_all()
+
+    @safe_operation(OperationType.UPDATE, "Project", include_traceback=True)
+    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:
+            bool: True if update successful
+        """
+        logger.debug(
+            "Updating project", project_id=project_id, keys=list(updates.keys())
+        )
+        return self._project_repo.update(project_id, updates)
+
+    @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:
+            bool: True if deletion successful
+        """
+        logger.debug("Deleting project", project_id=project_id)
+        return self._project_repo.delete(project_id)
+
+    @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: Whether to archive (True) or unarchive (False)
+
+        Returns:
+            bool: True if operation successful
+        """
+        logger.debug(
+            "Marking project archived", project_id=project_id, archived=archived
+        )
+        return self._project_repo.mark_archived(project_id, archived)

roadmap/adapters/persistence/storage/queries.py

@@ -0,0 +1,227 @@
+"""Database query service for aggregations and complex queries."""
+
+import hashlib
+import json
+from typing import TYPE_CHECKING, Any
+
+from roadmap.common.logging import get_logger
+
+if TYPE_CHECKING:
+    from .state_manager import StateManager
+
+logger = get_logger(__name__)
+
+
+class QueryService:
+    """Service for executing complex database queries and aggregations."""
+
+    def __init__(self, state_manager: "StateManager"):
+        """Initialize with reference to state manager.
+
+        Args:
+            state_manager: StateManager instance for database access
+        """
+        self.state_manager = state_manager
+
+    def has_file_changes(self) -> bool:
+        """Check if .roadmap/ files have changes since last sync."""
+        try:
+            # Get roadmap directory from database path
+            roadmap_dir = self.state_manager.db_path.parent
+
+            # Check for Markdown files with YAML frontmatter in relevant directories
+            md_files = []
+            for subdir in ["issues", "milestones", "projects"]:
+                subdir_path = roadmap_dir / subdir
+                if subdir_path.exists():
+                    md_files.extend(subdir_path.rglob("*.md"))
+
+            if not md_files:
+                return False
+
+            # Check each file against stored hash
+            with self.state_manager.transaction() as conn:
+                for file_path in md_files:
+                    if not file_path.exists():
+                        continue
+
+                    # Calculate current hash
+                    current_hash = hashlib.sha256(file_path.read_bytes()).hexdigest()
+
+                    # Get stored hash
+                    result = conn.execute(
+                        "SELECT content_hash FROM file_sync_state WHERE file_path = ?",
+                        (str(file_path.relative_to(roadmap_dir)),),
+                    ).fetchone()
+
+                    if not result or result[0] != current_hash:
+                        # File is new or changed
+                        return True
+
+            return False
+
+        except Exception as e:
+            logger.warning(
+                "Error checking file changes", error=str(e), severity="operational"
+            )
+            # If we can't check, assume changes exist to be safe
+            return True
+
+    def get_all_issues(self) -> list[dict[str, Any]]:
+        """Get all issues from database."""
+        try:
+            with self.state_manager.transaction() as conn:
+                results = conn.execute("""
+                    SELECT i.id, i.title, i.status, i.priority, i.issue_type,
+                           i.assignee, i.estimate_hours, i.due_date,
+                           i.project_id, i.milestone_id, i.metadata,
+                           m.title as milestone_name, p.name as project_name
+                    FROM issues i
+                    LEFT JOIN milestones m ON i.milestone_id = m.id
+                    LEFT JOIN projects p ON i.project_id = p.id
+                    ORDER BY i.title
+                """).fetchall()
+
+                issues = []
+                for row in results:
+                    issue = {
+                        "id": row[0],
+                        "title": row[1],
+                        "status": row[2],
+                        "priority": row[3],
+                        "type": row[4],
+                        "assignee": row[5],
+                        "estimate_hours": row[6],
+                        "due_date": row[7],
+                        "project_id": row[8],
+                        "milestone_id": row[9],
+                        "milestone_name": row[11],
+                        "project_name": row[12],
+                    }
+
+                    # Parse metadata
+                    if row[10]:
+                        try:
+                            metadata = json.loads(row[10])
+                            issue.update(metadata)
+                        except json.JSONDecodeError:
+                            logger.warning(
+                                "failed_to_parse_issue_metadata", severity="data_error"
+                            )
+
+                    issues.append(issue)
+
+                return issues
+
+        except Exception as e:
+            logger.error(
+                "Failed to get issues", error=str(e), severity="infrastructure"
+            )
+            return []
+
+    def get_all_milestones(self) -> list[dict[str, Any]]:
+        """Get all milestones from database."""
+        try:
+            with self.state_manager.transaction() as conn:
+                results = conn.execute("""
+                    SELECT m.id, m.title, m.description, m.status, m.due_date,
+                           m.progress_percentage, m.project_id, m.metadata,
+                           p.name as project_name
+                    FROM milestones m
+                    LEFT JOIN projects p ON m.project_id = p.id
+                    ORDER BY m.title
+                """).fetchall()
+
+                milestones = []
+                for row in results:
+                    milestone = {
+                        "id": row[0],
+                        "name": row[1],  # Use 'name' for compatibility
+                        "title": row[1],
+                        "description": row[2],
+                        "status": row[3],
+                        "due_date": row[4],
+                        "progress_percentage": row[5],
+                        "project_id": row[6],
+                        "project_name": row[8],
+                    }
+
+                    # Parse metadata
+                    if row[7]:
+                        try:
+                            metadata = json.loads(row[7])
+                            milestone.update(metadata)
+                        except json.JSONDecodeError:
+                            logger.warning(
+                                "failed_to_parse_milestone_metadata",
+                                severity="data_error",
+                            )
+
+                    milestones.append(milestone)
+
+                return milestones
+
+        except Exception as e:
+            logger.error(
+                "Failed to get milestones", error=str(e), severity="infrastructure"
+            )
+            return []
+
+    def get_milestone_progress(self, milestone_name: str) -> dict[str, int]:
+        """Get progress stats for a milestone."""
+        try:
+            with self.state_manager.transaction() as conn:
+                # Get milestone ID first
+                milestone_result = conn.execute(
+                    "SELECT id FROM milestones WHERE title = ?", (milestone_name,)
+                ).fetchone()
+
+                if not milestone_result:
+                    return {"total": 0, "completed": 0}
+
+                milestone_id = milestone_result[0]
+
+                # Count total and done issues for this milestone
+                total_result = conn.execute(
+                    "SELECT COUNT(*) FROM issues WHERE milestone_id = ?",
+                    (milestone_id,),
+                ).fetchone()
+
+                completed_result = conn.execute(
+                    "SELECT COUNT(*) FROM issues WHERE milestone_id = ? AND status = 'closed'",
+                    (milestone_id,),
+                ).fetchone()
+
+                return {
+                    "total": total_result[0] if total_result else 0,
+                    "completed": completed_result[0] if completed_result else 0,
+                }
+
+        except Exception as e:
+            logger.error(
+                "failed_to_get_milestone_progress",
+                error=str(e),
+                milestone_name=milestone_name,
+            )
+            return {"total": 0, "completed": 0}
+
+    def get_issues_by_status(self) -> dict[str, int]:
+        """Get issue counts by status."""
+        try:
+            with self.state_manager.transaction() as conn:
+                results = conn.execute("""
+                    SELECT status, COUNT(*)
+                    FROM issues
+                    GROUP BY status
+                    ORDER BY status
+                """).fetchall()
+
+                return {row[0]: row[1] for row in results}
+
+        except Exception as e:
+            logger.error(
+                "Failed to get issues by status",
+                error=str(e),
+                severity="infrastructure",
+            )
+            return {}