roadmap-cli 0.1.1__py3-none-any.whl

roadmap/adapters/cli/health/fixers/orphaned_issues_fixer.py

@@ -0,0 +1,252 @@
+"""Fixer for orphaned issues (issues not in correct folder based on milestone)."""
+
+import shutil
+from pathlib import Path
+
+from structlog import get_logger
+
+from roadmap.adapters.cli.health.fixer import FixResult, FixSafety, HealthFixer
+from roadmap.core.domain.issue import Status
+
+logger = get_logger()
+
+
+class OrphanedIssuesFixer(HealthFixer):
+    """Moves issues to correct folders based on their milestone assignment.
+
+    Safety: SAFE (moves files based on explicit metadata)
+
+    "Orphaned" = issues in wrong folder (not matching their milestone).
+    Fixes by moving issues to correct folder:
+    - .roadmap/issues/{milestone}/ for open issues
+    - .roadmap/archive/issues/{milestone}/ for closed issues
+    """
+
+    @property
+    def fix_type(self) -> str:
+        """Return fixer type identifier."""
+        return "orphaned_issues"
+
+    @property
+    def safety_level(self) -> FixSafety:
+        """Return safety level - SAFE because we use explicit metadata."""
+        return FixSafety.SAFE
+
+    @property
+    def description(self) -> str:
+        """Return fixer description."""
+        return "Move unassigned/misplaced issues to backlog or correct folders based on milestone assignment"
+
+    def scan(self) -> dict:
+        """Scan for orphaned issues (in wrong folder).
+
+        Returns:
+            Dict with found, count, message, details
+        """
+        misplaced = self._find_misplaced_issues()
+
+        return {
+            "found": len(misplaced) > 0,
+            "count": len(misplaced),
+            "message": f"Found {len(misplaced)} issue(s) in wrong folder",
+            "details": [{"id": iss["id"], "title": iss["title"]} for iss in misplaced],
+        }
+
+    def dry_run(self) -> FixResult:
+        """Preview which issues would be moved.
+
+        Returns:
+            FixResult with dry_run=True
+        """
+        misplaced = self._find_misplaced_issues()
+
+        return FixResult(
+            fix_type=self.fix_type,
+            success=True,
+            dry_run=True,
+            message=f"Would move {len(misplaced)} issue(s) to correct folder(s)",
+            affected_items=[
+                f"{iss['id']} → {iss['target_folder']}" for iss in misplaced
+            ],
+            items_count=len(misplaced),
+            changes_made=0,
+        )
+
+    def apply(self, force: bool = False) -> FixResult:
+        """Move orphaned issues to correct folders.
+
+        Args:
+            force: Ignored (SAFE fixers apply automatically)
+
+        Returns:
+            FixResult with move results
+        """
+        _ = force
+        misplaced = self._find_misplaced_issues()
+        moved_count = 0
+        failed_items = []
+
+        # Ensure backlog folder exists
+        backlog_path = Path(".roadmap/issues/backlog").resolve()
+        backlog_path.mkdir(parents=True, exist_ok=True)
+
+        issues_dir = Path(".roadmap/issues").resolve()
+
+        for issue_data in misplaced:
+            try:
+                issue_id = issue_data["id"]
+                target_folder = Path(issue_data["target_folder"]).resolve()
+                current_folder = Path(issue_data["current_folder"]).resolve()
+
+                # If milestone folder doesn't exist and not already at backlog, move to backlog
+                if not target_folder.exists() and current_folder != backlog_path:
+                    target_folder = backlog_path
+
+                # Ensure target folder exists
+                target_folder.mkdir(parents=True, exist_ok=True)
+
+                # Find the actual issue file
+                issue_file = None
+                if current_folder == issues_dir:
+                    # File is at root level
+                    for f in issues_dir.glob(f"{issue_id}*.md"):
+                        if f.is_file():
+                            issue_file = f
+                            break
+                else:
+                    # File is in a subfolder
+                    for f in current_folder.glob(f"{issue_id}*.md"):
+                        if f.is_file():
+                            issue_file = f
+                            break
+
+                if issue_file:
+                    # Move file to target folder
+                    target_file = target_folder / issue_file.name
+                    shutil.move(str(issue_file), str(target_file))
+                    moved_count += 1
+                else:
+                    failed_items.append(issue_id)
+            except Exception as e:
+                logger.error(
+                    "move_orphaned_issue_failed",
+                    issue_id=issue_data["id"],
+                    error=str(e),
+                    severity="system_error",
+                )
+                failed_items.append(issue_data["id"])
+
+        return FixResult(
+            fix_type=self.fix_type,
+            success=len(failed_items) == 0,
+            dry_run=False,
+            message=f"Moved {moved_count}/{len(misplaced)} issue(s) to correct folder(s)",
+            affected_items=[
+                iss["id"] for iss in misplaced if iss["id"] not in failed_items
+            ],
+            items_count=len(misplaced),
+            changes_made=moved_count,
+        )
+
+    def _find_misplaced_issues(self) -> list[dict]:
+        """Find issues that are in the wrong folder.
+
+        Returns:
+            List of dicts with id, title, current_folder, target_folder, milestone
+        """
+        misplaced = []
+
+        try:
+            issues_dir = Path(".roadmap/issues").resolve()
+            archive_dir = Path(".roadmap/archive/issues").resolve()
+
+            if not issues_dir.exists():
+                return misplaced
+
+            # Scan all issues
+            for issue in self.core.issues.list():
+                # Determine expected folder
+                expected_folder = self._get_expected_folder(issue)
+
+                # Find actual file and its folder
+                actual_folder = self._find_issue_folder(
+                    issue.id, issues_dir, archive_dir
+                )
+
+                # Issue is misplaced if:
+                # 1. It's at root level (actual_folder == issues_dir)
+                # 2. Or it's in wrong folder (actual_folder != expected_folder)
+                if actual_folder:
+                    if actual_folder == issues_dir or actual_folder != expected_folder:
+                        misplaced.append(
+                            {
+                                "id": issue.id,
+                                "title": issue.title,
+                                "milestone": issue.milestone or "(none)",
+                                "current_folder": str(actual_folder),
+                                "target_folder": str(expected_folder),
+                            }
+                        )
+
+        except Exception as e:
+            logger.error(
+                "find_orphaned_issues_failed", error=str(e), severity="data_error"
+            )
+            return []
+
+        return misplaced
+
+    def _get_expected_folder(self, issue) -> Path:
+        """Determine the expected folder for an issue.
+
+        Args:
+            issue: Issue object with milestone and status
+
+        Returns:
+            Path to the expected folder
+        """
+        # Closed issues go to archive
+        base_path = (
+            Path(".roadmap/archive/issues").resolve()
+            if issue.status == Status.CLOSED
+            else Path(".roadmap/issues").resolve()
+        )
+
+        # If no milestone, assign to backlog
+        milestone = issue.milestone or "backlog"
+
+        return base_path / milestone
+
+    def _find_issue_folder(
+        self, issue_id: str, issues_dir: Path, archive_dir: Path
+    ) -> Path | None:
+        """Find the actual folder containing an issue.
+
+        Args:
+            issue_id: Issue ID to find
+            issues_dir: Path to .roadmap/issues
+            archive_dir: Path to .roadmap/archive/issues
+
+        Returns:
+            Path to the folder containing the issue, or None
+        """
+        # Check if file is at root level (loose file)
+        for file in issues_dir.glob(f"{issue_id}*.md"):
+            if file.is_file():
+                return issues_dir  # Return root to indicate it's loose
+
+        # Check main issues directory subfolders
+        for folder in issues_dir.iterdir():
+            if folder.is_dir():
+                for _file in folder.glob(f"{issue_id}*.md"):
+                    return folder
+
+        # Check archive directory
+        archive_dir = Path(".roadmap/archive/issues").resolve()
+        if archive_dir.exists():
+            for folder in archive_dir.iterdir():
+                if folder.is_dir():
+                    for _file in folder.glob(f"{issue_id}*.md"):
+                        return folder
+
+        return None

roadmap/adapters/cli/health/formatter.py

@@ -0,0 +1,250 @@
+"""Health check result formatters for various output formats.
+
+Supports:
+- Plain text: Human-readable with status icons
+- Plain text with details: Includes recommendations and fix commands
+- JSON: Hierarchical structure with all details
+- JSON simple: Flat structure for tool integration
+"""
+
+import json
+from collections.abc import Mapping
+
+import click
+
+from roadmap.adapters.cli.health.enhancer import HealthCheckDetail, HealthCheckEnhancer
+from roadmap.core.domain.health import HealthStatus
+from roadmap.infrastructure.observability.health import HealthCheck
+
+
+class HealthCheckFormatter:
+    """Formats health check results in various output styles."""
+
+    # Status display mappings
+    STATUS_ICONS = {
+        HealthStatus.HEALTHY: "✅",
+        HealthStatus.DEGRADED: "⚠️",
+        HealthStatus.UNHEALTHY: "❌",
+    }
+
+    STATUS_COLORS = {
+        HealthStatus.HEALTHY: "green",
+        HealthStatus.DEGRADED: "yellow",
+        HealthStatus.UNHEALTHY: "red",
+    }
+
+    def __init__(self, core=None):
+        """Initialize formatter.
+
+        Args:
+            core: Optional core instance for entity lookups
+        """
+        self.core = core
+        self.enhancer = HealthCheckEnhancer(core)
+
+    def format_plain(
+        self,
+        checks: Mapping[str, tuple[HealthStatus, str]],
+        details: bool = False,
+    ) -> str:
+        """Format checks as plain text.
+
+        Args:
+            checks: Dict of check results from run_all_checks()
+            details: If True, include recommendations and fix commands
+
+        Returns:
+            Formatted plain text string
+        """
+        lines = []
+
+        # Format each check
+        for check_name, (status, message) in checks.items():
+            display_name = check_name.replace("_", " ").title()
+            icon = self.STATUS_ICONS.get(status, "?")
+
+            lines.append(f"{icon} {display_name}: {status.value.upper()}")
+            if message:
+                lines.append(f"  {message}")
+
+            # Add details if requested
+            if details:
+                enhanced = self.enhancer.enhance_check_result(
+                    check_name, status, message
+                )
+                self._append_details(lines, enhanced)
+
+            lines.append("")
+
+        # Add overall status
+        overall_status = HealthCheck.get_overall_status(checks)
+        overall_icon = self.STATUS_ICONS.get(overall_status, "?")
+        overall_color = self.STATUS_COLORS.get(overall_status, "white")
+
+        lines.append("─" * 40)
+        click.secho(
+            f"{overall_icon} Overall Status: {overall_status.value.upper()}",
+            fg=overall_color,
+            bold=True,
+        )
+
+        return "\n".join(lines)
+
+    def format_json(
+        self,
+        checks: Mapping[str, tuple[HealthStatus, str]],
+        details: bool = False,
+        hierarchical: bool = True,
+    ) -> str:
+        """Format checks as JSON.
+
+        Args:
+            checks: Dict of check results from run_all_checks()
+            details: If True, include detailed information
+            hierarchical: If True, use nested structure; else flat
+
+        Returns:
+            JSON string
+        """
+        if hierarchical and details:
+            return self._format_json_hierarchical(checks)
+        elif hierarchical:
+            return self._format_json_hierarchical_simple(checks)
+        else:
+            return self._format_json_flat(checks, details)
+
+    def _format_json_hierarchical(
+        self, checks: Mapping[str, tuple[HealthStatus, str]]
+    ) -> str:
+        """Format as hierarchical JSON with full details."""
+        enhanced_checks = self.enhancer.enhance_all_checks(checks)
+
+        # Group by status
+        by_status = {
+            HealthStatus.HEALTHY: [],
+            HealthStatus.DEGRADED: [],
+            HealthStatus.UNHEALTHY: [],
+        }
+
+        for _, enhanced in enhanced_checks.items():
+            by_status[enhanced.status].append(enhanced)
+
+        # Build hierarchical structure
+        output = {
+            "metadata": {
+                "total_checks": len(checks),
+                "healthy": len(by_status[HealthStatus.HEALTHY]),
+                "degraded": len(by_status[HealthStatus.DEGRADED]),
+                "unhealthy": len(by_status[HealthStatus.UNHEALTHY]),
+                "overall_status": HealthCheck.get_overall_status(checks).value.upper(),
+            },
+            "checks": {
+                "healthy": [c.to_dict() for c in by_status[HealthStatus.HEALTHY]],
+                "degraded": [c.to_dict() for c in by_status[HealthStatus.DEGRADED]],
+                "unhealthy": [c.to_dict() for c in by_status[HealthStatus.UNHEALTHY]],
+            },
+            "next_steps": self._get_next_steps(enhanced_checks),
+        }
+
+        return json.dumps(output, indent=2, default=str)
+
+    def _format_json_hierarchical_simple(
+        self, checks: Mapping[str, tuple[HealthStatus, str]]
+    ) -> str:
+        """Format as hierarchical JSON without details."""
+        # Group by status
+        by_status = {
+            HealthStatus.HEALTHY: [],
+            HealthStatus.DEGRADED: [],
+            HealthStatus.UNHEALTHY: [],
+        }
+
+        for check_name, (status, message) in checks.items():
+            by_status[status].append(
+                {
+                    "check": check_name,
+                    "status": status.value.upper(),
+                    "message": message,
+                }
+            )
+
+        output = {
+            "metadata": {
+                "total_checks": len(checks),
+                "healthy": len(by_status[HealthStatus.HEALTHY]),
+                "degraded": len(by_status[HealthStatus.DEGRADED]),
+                "unhealthy": len(by_status[HealthStatus.UNHEALTHY]),
+                "overall_status": HealthCheck.get_overall_status(checks).value.upper(),
+            },
+            "checks": {
+                "healthy": by_status[HealthStatus.HEALTHY],
+                "degraded": by_status[HealthStatus.DEGRADED],
+                "unhealthy": by_status[HealthStatus.UNHEALTHY],
+            },
+        }
+
+        return json.dumps(output, indent=2, default=str)
+
+    def _format_json_flat(
+        self, checks: Mapping[str, tuple[HealthStatus, str]], details: bool = False
+    ) -> str:
+        """Format as flat JSON."""
+        output = {
+            "checks": {},
+            "overall_status": HealthCheck.get_overall_status(checks).value.upper(),
+        }
+
+        for check_name, (status, message) in checks.items():
+            check_data = {
+                "status": status.value.upper(),
+                "message": message,
+            }
+
+            if details:
+                enhanced = self.enhancer.enhance_check_result(
+                    check_name, status, message
+                )
+                check_data.update(enhanced.to_dict())
+
+            output["checks"][check_name] = check_data
+
+        return json.dumps(output, indent=2, default=str)
+
+    def _append_details(self, lines: list, detail: HealthCheckDetail) -> None:
+        """Append detailed information to output lines."""
+        if detail.recommendations:
+            lines.append("  Recommendations:")
+            for rec in detail.recommendations:
+                lines.append(f"    • {rec}")
+
+        if detail.fix_commands:
+            lines.append("  Fix Commands:")
+            for cmd_info in detail.fix_commands:
+                lines.append(f"    • {cmd_info['description']}")
+                lines.append(f"      {cmd_info['command']}")
+
+    def _get_next_steps(
+        self, enhanced_checks: dict[str, HealthCheckDetail]
+    ) -> list[str]:
+        """Determine recommended next steps based on check results."""
+        next_steps = []
+
+        for enhanced in enhanced_checks.values():
+            if enhanced.status == HealthStatus.UNHEALTHY:
+                if enhanced.fix_commands:
+                    next_steps.append(f"Run: {enhanced.fix_commands[0]['command']}")
+                break
+
+        if not next_steps:
+            # Check for degraded items
+            for enhanced in enhanced_checks.values():
+                if enhanced.status == HealthStatus.DEGRADED:
+                    if enhanced.fix_commands:
+                        next_steps.append(
+                            f"Consider: {enhanced.fix_commands[0]['command']}"
+                        )
+
+        if not next_steps:
+            next_steps.append("All systems healthy! Run 'roadmap health' regularly.")
+
+        return next_steps