roadmap-cli 0.1.1__py3-none-any.whl

roadmap/infrastructure/observability/health_formatter.py

@@ -0,0 +1,73 @@
+"""Health status formatting and presentation utilities.
+
+Provides health-specific formatting built on top of generic status utilities.
+"""
+
+from collections.abc import Mapping
+
+from roadmap.core.domain.health import HealthStatus
+
+
+class HealthStatusFormatter:
+    """Formats and presents health check results."""
+
+    @staticmethod
+    def summarize_health_checks(
+        checks: Mapping[str, tuple[HealthStatus, str]],
+    ) -> dict[str, int]:
+        """Summarize health check results into status counts.
+
+        Args:
+            checks: Dict mapping check names to (status, message) tuples
+
+        Returns:
+            Dict with counts: {
+                "total": count,
+                "healthy": count,
+                "degraded": count,
+                "unhealthy": count,
+            }
+        """
+        statuses = [status for _, (status, _) in checks.items()]
+
+        total = len(statuses)
+        healthy = sum(1 for s in statuses if s == HealthStatus.HEALTHY)
+        degraded = sum(1 for s in statuses if s == HealthStatus.DEGRADED)
+        unhealthy = sum(1 for s in statuses if s == HealthStatus.UNHEALTHY)
+
+        return {
+            "total": total,
+            "healthy": healthy,
+            "degraded": degraded,
+            "unhealthy": unhealthy,
+        }
+
+    @staticmethod
+    def get_status_color(status: HealthStatus) -> str:
+        """Get terminal color for health status.
+
+        Args:
+            status: HealthStatus to format
+
+        Returns:
+            ANSI color code string
+        """
+        if status == HealthStatus.HEALTHY:
+            return "\033[92m"  # Green
+        elif status == HealthStatus.DEGRADED:
+            return "\033[93m"  # Yellow
+        elif status == HealthStatus.UNHEALTHY:
+            return "\033[91m"  # Red
+        return "\033[0m"  # Reset
+
+    @staticmethod
+    def format_status_display(status: HealthStatus) -> str:
+        """Get human-readable display for health status.
+
+        Args:
+            status: HealthStatus to format
+
+        Returns:
+            Formatted status string
+        """
+        return status.value.upper()

roadmap/infrastructure/observability/specialized_health_checkers.py

@@ -0,0 +1,188 @@
+"""Specialized health checkers split from HealthCheck class.
+
+Organizes health checks by domain concern:
+- DirectoryHealthChecker: File system structure checks
+- DataHealthChecker: Database and data integrity checks
+- EntityHealthChecker: Business entity validation checks
+"""
+
+from roadmap.core.domain.health import HealthStatus
+
+
+class DirectoryHealthChecker:
+    """Checks health of directory structure and files."""
+
+    @staticmethod
+    def check_roadmap_directory() -> tuple[HealthStatus, str]:
+        """Check if .roadmap directory exists and is accessible."""
+        from roadmap.core.services.health.infrastructure_validator_service import (
+            RoadmapDirectoryValidator,
+        )
+
+        status_str, message = RoadmapDirectoryValidator.check()
+        return HealthStatus(status_str), message
+
+    @staticmethod
+    def check_state_file() -> tuple[HealthStatus, str]:
+        """Check if state database exists and is readable."""
+        from roadmap.core.services.health.infrastructure_validator_service import (
+            StateFileValidator,
+        )
+
+        status_str, message = StateFileValidator.check()
+        return HealthStatus(status_str), message
+
+    @staticmethod
+    def check_issues_directory() -> tuple[HealthStatus, str]:
+        """Check if issues directory exists and is accessible."""
+        from roadmap.core.services.health.infrastructure_validator_service import (
+            IssuesDirectoryValidator,
+        )
+
+        status_str, message = IssuesDirectoryValidator.check()
+        return HealthStatus(status_str), message
+
+    @staticmethod
+    def check_milestones_directory() -> tuple[HealthStatus, str]:
+        """Check if milestones directory exists and is accessible."""
+        from roadmap.core.services.health.infrastructure_validator_service import (
+            MilestonesDirectoryValidator,
+        )
+
+        status_str, message = MilestonesDirectoryValidator.check()
+        return HealthStatus(status_str), message
+
+    @staticmethod
+    def check_folder_structure(core) -> tuple[HealthStatus, str]:
+        """Check if issues are in correct milestone folders."""
+        from roadmap.core.services.health.data_integrity_validator_service import (
+            FolderStructureValidator,
+        )
+
+        status_str, message = FolderStructureValidator.check()
+        return HealthStatus(status_str), message
+
+    @staticmethod
+    def check_old_backups() -> tuple[HealthStatus, str]:
+        """Check for old backup files that could be cleaned up."""
+        from roadmap.core.services.health.data_integrity_validator_service import (
+            BackupValidator,
+        )
+
+        status_str, message = BackupValidator.check_old_backups()
+        return HealthStatus(status_str), message
+
+
+class DataHealthChecker:
+    """Checks health of data integrity and database."""
+
+    @staticmethod
+    def check_git_repository() -> tuple[HealthStatus, str]:
+        """Check if Git repository exists and is accessible."""
+        from roadmap.core.services.health.infrastructure_validator_service import (
+            GitRepositoryValidator,
+        )
+
+        status_str, message = GitRepositoryValidator.check()
+        return HealthStatus(status_str), message
+
+    @staticmethod
+    def check_database_integrity() -> tuple[HealthStatus, str]:
+        """Check SQLite database integrity."""
+        from roadmap.core.services.health.infrastructure_validator_service import (
+            DatabaseIntegrityValidator,
+        )
+
+        status_str, message = DatabaseIntegrityValidator.check()
+        return HealthStatus(status_str), message
+
+    @staticmethod
+    def check_data_integrity() -> tuple[HealthStatus, str]:
+        """Run comprehensive data integrity checks."""
+        from roadmap.core.services.health.data_integrity_validator_service import (
+            DataIntegrityValidator,
+        )
+
+        status_str, message = DataIntegrityValidator.check_data_integrity()
+        return HealthStatus(status_str), message
+
+
+class EntityHealthChecker:
+    """Checks health of business entities (issues, milestones)."""
+
+    @staticmethod
+    def check_duplicate_issues(core) -> tuple[HealthStatus, str]:
+        """Check for duplicate issues."""
+        from roadmap.core.services.health.data_integrity_validator_service import (
+            DuplicateIssuesValidator,
+        )
+
+        status_str, message = DuplicateIssuesValidator.check()
+        return HealthStatus(status_str), message
+
+    @staticmethod
+    def check_archivable_issues(core) -> tuple[HealthStatus, str]:
+        """Check for closed issues that could be archived."""
+        from roadmap.core.services.health.data_integrity_validator_service import (
+            ArchivableIssuesValidator,
+        )
+
+        status_str, message = ArchivableIssuesValidator.check_archivable_issues(core)
+        return HealthStatus(status_str), message
+
+    @staticmethod
+    def check_archivable_milestones(core) -> tuple[HealthStatus, str]:
+        """Check for closed milestones that could be archived."""
+        from roadmap.core.services.health.data_integrity_validator_service import (
+            ArchivableMilestonesValidator,
+        )
+
+        status_str, message = ArchivableMilestonesValidator.check_archivable_milestones(
+            core
+        )
+        return HealthStatus(status_str), message
+
+    @staticmethod
+    def check_orphaned_issues(core) -> tuple[HealthStatus, str]:
+        """Check for issues not assigned to any milestone."""
+        from roadmap.core.services.health.data_integrity_validator_service import (
+            OrphanedIssuesValidator,
+        )
+
+        status_str, message = OrphanedIssuesValidator.check_orphaned_issues(core)
+        return HealthStatus(status_str), message
+
+    @staticmethod
+    def check_orphaned_milestones(core) -> tuple[HealthStatus, str]:
+        """Check for empty milestones with no issues."""
+        from roadmap.core.services.health.data_integrity_validator_service import (
+            OrphanedMilestonesValidator,
+        )
+
+        status_str, message = OrphanedMilestonesValidator.check()
+        return HealthStatus(status_str), message
+
+    @staticmethod
+    def check_duplicate_milestones(core) -> tuple[HealthStatus, str]:
+        """Check for duplicate milestone names."""
+        from roadmap.core.services.health.data_integrity_validator_service import (
+            DuplicateMilestonesValidator,
+        )
+
+        status_str, message = DuplicateMilestonesValidator.check()
+        return HealthStatus(status_str), message
+
+    @staticmethod
+    def check_unlinked_issues(core) -> tuple[HealthStatus, str]:
+        """Check for remote issues not linked to local issues."""
+        # Note: UnlinkedIssuesValidator may not exist - skip if not available
+        try:
+            from roadmap.core.services.health.data_integrity_validator_service import (
+                UnlinkedIssuesValidator,  # type: ignore[attr-defined]
+            )
+
+            status_str, message = UnlinkedIssuesValidator.check_unlinked_issues(core)
+        except (ImportError, AttributeError):
+            # If validator not available, skip this check
+            return HealthStatus.HEALTHY, "Unlinked issues check skipped"
+        return HealthStatus(status_str), message

roadmap/infrastructure/persistence_gateway.py

@@ -0,0 +1,164 @@
+"""Persistence Gateway - Mediates Core services' access to persistence adapters.
+
+This gateway abstracts away direct imports from roadmap.adapters.persistence,
+allowing Core services to request persistence operations without violating
+layer boundaries.
+
+The gateway provides:
+- YAML file parsing (issues, milestones, projects)
+- File persistence (save operations)
+- Storage access (StateManager for database-level operations)
+
+All imports from roadmap.adapters.persistence are localized to this module.
+"""
+
+from pathlib import Path
+from typing import Any
+
+from roadmap.core.domain.issue import Issue
+from roadmap.core.domain.milestone import Milestone
+from roadmap.core.domain.project import Project
+
+
+class PersistenceGateway:
+    """Mediates Core layer access to persistence adapters."""
+
+    @staticmethod
+    def parse_issue_file(file_path: Path) -> Issue:
+        """Parse an issue YAML file and return Issue domain object.
+
+        Args:
+            file_path: Path to the issue YAML file.
+
+        Returns:
+            Parsed Issue domain object.
+        """
+        from roadmap.adapters.persistence.parser.issue import IssueParser
+
+        return IssueParser.parse_issue_file(file_path)
+
+    @staticmethod
+    def save_issue_file(issue: Issue, file_path: Path) -> None:
+        """Save an Issue domain object to YAML file.
+
+        Args:
+            issue: Issue domain object to save.
+            file_path: Path to save the issue YAML file.
+        """
+        from roadmap.adapters.persistence.parser.issue import IssueParser
+
+        IssueParser.save_issue_file(issue, file_path)
+
+    @staticmethod
+    def load_sync_metadata(file_path: Path) -> dict | None:
+        """Load sync metadata from issue file.
+
+        Args:
+            file_path: Path to the issue YAML file.
+
+        Returns:
+            Dictionary of sync metadata or None if not present.
+        """
+        from roadmap.adapters.persistence.parser.issue import IssueParser
+
+        return IssueParser.load_sync_metadata(file_path)
+
+    @staticmethod
+    def update_issue_sync_metadata(file_path: Path, sync_metadata: dict) -> None:
+        """Update sync metadata in issue file.
+
+        Args:
+            file_path: Path to the issue YAML file.
+            sync_metadata: Dictionary of sync metadata to update.
+        """
+        from roadmap.adapters.persistence.parser.issue import IssueParser
+
+        IssueParser.update_issue_sync_metadata(file_path, sync_metadata)
+
+    @staticmethod
+    def parse_milestone_file(file_path: Path) -> Milestone:
+        """Parse a milestone YAML file and return Milestone domain object.
+
+        Args:
+            file_path: Path to the milestone YAML file.
+
+        Returns:
+            Parsed Milestone domain object.
+        """
+        from roadmap.adapters.persistence.parser import MilestoneParser
+
+        return MilestoneParser.parse_milestone_file(file_path)
+
+    @staticmethod
+    def save_milestone_file(milestone: Milestone, file_path: Path) -> None:
+        """Save a Milestone domain object to YAML file.
+
+        Args:
+            milestone: Milestone domain object to save.
+            file_path: Path to save the milestone YAML file.
+        """
+        from roadmap.adapters.persistence.parser import MilestoneParser
+
+        return MilestoneParser.save_milestone_file(milestone, file_path)
+
+    @staticmethod
+    def parse_project_file(file_path: Path) -> Project:
+        """Parse a project YAML file and return Project domain object.
+
+        Args:
+            file_path: Path to the project YAML file.
+
+        Returns:
+            Parsed Project domain object.
+        """
+        from roadmap.adapters.persistence.parser import ProjectParser
+
+        return ProjectParser.parse_project_file(file_path)
+
+    @staticmethod
+    def parse_frontmatter(content: str) -> tuple[dict[str, Any], str]:
+        """Parse YAML frontmatter from content.
+
+        Args:
+            content: Raw content with frontmatter.
+
+        Returns:
+            Tuple of (frontmatter dict, remaining content).
+        """
+        from roadmap.adapters.persistence.parser.frontmatter import (
+            FrontmatterParser,
+        )
+
+        return FrontmatterParser.parse_content(content)
+
+    @staticmethod
+    def get_state_manager() -> Any:
+        """Get the StateManager for database-level operations.
+
+        Returns:
+            StateManager instance from persistence adapter.
+        """
+        from roadmap.adapters.persistence.storage import StateManager
+        from roadmap.common.utils.path_utils import build_roadmap_paths
+
+        db_dir = build_roadmap_paths(Path.cwd())["db_dir"]
+        db_path = db_dir / "state.db"
+
+        return StateManager(db_path=db_path)
+
+    @staticmethod
+    def get_changed_files_since_commit(ref: str = "HEAD~1", cwd: str = ".") -> set[str]:
+        """Get files changed since a git reference.
+
+        Args:
+            ref: Git reference (commit, branch, tag).
+            cwd: Working directory for git commands.
+
+        Returns:
+            Set of file paths that changed.
+        """
+        from roadmap.adapters.persistence.git_history import (
+            get_changed_files_since_commit,
+        )
+
+        return get_changed_files_since_commit(ref, cwd)

roadmap/infrastructure/security/__init__.py

@@ -0,0 +1 @@
+"""Security utilities and credential management."""