roadmap-cli 0.1.1__py3-none-any.whl

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

@@ -0,0 +1,162 @@
+"""Fixer for milestone files that fail to parse (invisible to CLI)."""
+
+from pathlib import Path
+
+from structlog import get_logger
+
+from roadmap.adapters.cli.health.fixer import FixResult, FixSafety, HealthFixer
+from roadmap.adapters.persistence.parser.milestone import MilestoneParser
+
+logger = get_logger()
+
+
+class MilestoneParseErrorFixer(HealthFixer):
+    """Detects milestone files that exist on disk but fail to parse.
+
+    Safety: REVIEW (regenerates files from minimal defaults, discarding
+    unrecoverable YAML content)
+
+    A milestone file that fails to parse is silently excluded from
+    ``milestone list`` and ``milestone view``, causing confusing
+    inconsistencies (issues are queryable by milestone name but the
+    milestone itself is "not found").  This fixer surfaces those files
+    so the user is not left guessing why a milestone disappeared.
+
+    The ``apply()`` fix regenerates each broken file with sensible
+    defaults derived from the filename, which replicates the manual
+    workaround of running ``roadmap milestone create``.
+    """
+
+    @property
+    def fix_type(self) -> str:
+        """Return fixer type identifier."""
+        return "milestone_parse_errors"
+
+    @property
+    def safety_level(self) -> FixSafety:
+        """Return safety level - REVIEW because we overwrite files."""
+        return FixSafety.REVIEW
+
+    @property
+    def description(self) -> str:
+        """Return fixer description."""
+        return "Detect milestone files that fail to parse and are invisible to the CLI"
+
+    def scan(self) -> dict:
+        """Scan for milestone files that cannot be parsed.
+
+        Returns:
+            Dict with found, count, message, details
+        """
+        broken = self._find_broken_milestone_files()
+
+        return {
+            "found": len(broken) > 0,
+            "count": len(broken),
+            "message": f"Found {len(broken)} milestone file(s) that fail to parse",
+            "details": broken,
+        }
+
+    def dry_run(self) -> FixResult:
+        """Preview which milestone files would be regenerated.
+
+        Returns:
+            FixResult with dry_run=True
+        """
+        broken = self._find_broken_milestone_files()
+
+        return FixResult(
+            fix_type=self.fix_type,
+            success=True,
+            dry_run=True,
+            message=f"Would regenerate {len(broken)} milestone file(s) from defaults",
+            affected_items=[item["file"] for item in broken],
+            items_count=len(broken),
+            changes_made=0,
+        )
+
+    def apply(self, force: bool = False) -> FixResult:
+        """Regenerate broken milestone files with minimal valid defaults.
+
+        Each broken file is overwritten with a new milestone whose ``name``
+        is derived from the filename stem, preserving the original file
+        location.  This replicates the manual workaround of recreating the
+        milestone via ``roadmap milestone create``.
+
+        Args:
+            force: Ignored (safety handled by REVIEW level and orchestrator).
+
+        Returns:
+            FixResult
+        """
+        broken = self._find_broken_milestone_files()
+        fixed_count = 0
+        failed_items: list[str] = []
+
+        for item in broken:
+            file_path = Path(item["file"])
+            milestone_name = item["name"]
+            try:
+                milestone = self.core.milestones.create(
+                    name=milestone_name,
+                    headline="",
+                )
+                if milestone:
+                    fixed_count += 1
+                else:
+                    failed_items.append(str(file_path))
+            except Exception as e:
+                logger.error(
+                    "milestone_parse_error_fix_failed",
+                    file=str(file_path),
+                    error=str(e),
+                    severity="data_error",
+                )
+                failed_items.append(str(file_path))
+
+        return FixResult(
+            fix_type=self.fix_type,
+            success=len(failed_items) == 0,
+            dry_run=False,
+            message=f"Regenerated {fixed_count}/{len(broken)} broken milestone file(s)",
+            affected_items=[
+                item["file"] for item in broken if item["file"] not in failed_items
+            ],
+            items_count=len(broken),
+            changes_made=fixed_count,
+        )
+
+    def _find_broken_milestone_files(self) -> list[dict]:
+        """Find milestone files that raise exceptions during parsing.
+
+        Returns:
+            List of dicts with 'file', 'name', 'error' keys
+        """
+        broken: list[dict] = []
+
+        try:
+            milestones_dir = Path(".roadmap/milestones").resolve()
+            if not milestones_dir.exists():
+                return broken
+
+            for md_file in sorted(milestones_dir.glob("*.md")):
+                if ".backup" in md_file.name:
+                    continue
+                try:
+                    MilestoneParser.parse_milestone_file(md_file)
+                except Exception as e:
+                    broken.append(
+                        {
+                            "file": str(md_file),
+                            "name": md_file.stem,
+                            "error": f"{type(e).__name__}: {e}",
+                        }
+                    )
+        except Exception as e:
+            logger.error(
+                "find_broken_milestone_files_failed",
+                error=str(e),
+                severity="data_error",
+            )
+
+        return broken

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

@@ -0,0 +1,211 @@
+"""Fixer for issues with invalid milestone references."""
+
+from difflib import get_close_matches
+from pathlib import Path
+
+from structlog import get_logger
+
+from roadmap.adapters.cli.health.fixer import FixResult, FixSafety, HealthFixer
+
+logger = get_logger()
+
+
+class MilestoneValidationFixer(HealthFixer):
+    """Validates that all issue milestones point to existing milestones.
+
+    Safety: REVIEW (may reassign issues to different milestones)
+
+    Issues with invalid milestone references are either:
+    1. Moved to backlog if no similar milestone found
+    2. Updated to closest matching milestone if found
+    """
+
+    @property
+    def fix_type(self) -> str:
+        """Return fixer type identifier."""
+        return "milestone_validation"
+
+    @property
+    def safety_level(self) -> FixSafety:
+        """Return safety level - REVIEW because we may reassign milestones."""
+        return FixSafety.REVIEW
+
+    @property
+    def description(self) -> str:
+        """Return fixer description."""
+        return "Validate and fix invalid milestone references in issues"
+
+    def scan(self) -> dict:
+        """Scan for issues with invalid milestone references.
+
+        Returns:
+            Dict with found, count, message, details
+        """
+        invalid = self._find_invalid_milestones()
+
+        return {
+            "found": len(invalid) > 0,
+            "count": len(invalid),
+            "message": f"Found {len(invalid)} issue(s) with invalid milestone(s)",
+            "details": [
+                {
+                    "id": iss["id"],
+                    "title": iss["title"],
+                    "invalid_milestone": iss["milestone"],
+                }
+                for iss in invalid
+            ],
+        }
+
+    def dry_run(self) -> FixResult:
+        """Preview which issues would be fixed.
+
+        Returns:
+            FixResult with dry_run=True
+        """
+        invalid = self._find_invalid_milestones()
+
+        affected = []
+        for iss in invalid:
+            suggestion = self._get_suggestion(iss["milestone"])
+            if suggestion:
+                affected.append(f"{iss['id']} ({iss['milestone']} → {suggestion})")
+            else:
+                affected.append(f"{iss['id']} ({iss['milestone']} → backlog)")
+
+        return FixResult(
+            fix_type=self.fix_type,
+            success=True,
+            dry_run=True,
+            message=f"Would fix {len(invalid)} issue(s) with invalid milestone(s)",
+            affected_items=affected,
+            items_count=len(invalid),
+            changes_made=0,
+        )
+
+    def apply(self, force: bool = False) -> FixResult:
+        """Fix issues with invalid milestone references.
+
+        Args:
+            force: Ignored (SAFE fixers apply automatically)
+
+        Returns:
+            FixResult with fix results
+        """
+        _ = force
+        invalid = self._find_invalid_milestones()
+        fixed_count = 0
+        failed_items = []
+
+        for issue_data in invalid:
+            try:
+                issue_id = issue_data["id"]
+                old_milestone = issue_data["milestone"]
+
+                # Try to find a suggestion
+                suggestion = self._get_suggestion(old_milestone)
+                if not suggestion:
+                    # No similar milestone, move to backlog
+                    suggestion = "backlog"
+
+                # Assign to suggested milestone
+                if self.core.issues.assign_to_milestone(issue_id, suggestion):
+                    fixed_count += 1
+                else:
+                    failed_items.append(issue_id)
+            except Exception as e:
+                logger.error(
+                    "fix_invalid_milestone_failed",
+                    issue_id=issue_data["id"],
+                    error=str(e),
+                    severity="data_error",
+                )
+                failed_items.append(issue_data["id"])
+
+        return FixResult(
+            fix_type=self.fix_type,
+            success=len(failed_items) == 0,
+            dry_run=False,
+            message=f"Fixed {fixed_count}/{len(invalid)} issue(s) with invalid milestone(s)",
+            affected_items=[
+                iss["id"] for iss in invalid if iss["id"] not in failed_items
+            ],
+            items_count=len(invalid),
+            changes_made=fixed_count,
+        )
+
+    def _find_invalid_milestones(self) -> list[dict]:
+        """Find issues with milestone references that don't exist.
+
+        Returns:
+            List of dicts with id, title, milestone
+        """
+        invalid = []
+
+        try:
+            # Get all available milestone names
+            milestones_dir = Path(".roadmap/milestones").resolve()
+            if not milestones_dir.exists():
+                return invalid
+
+            available_milestones = {f.stem for f in milestones_dir.glob("*.md")}
+
+            # Check all issues
+            for issue in self.core.issues.list():
+                if not issue.milestone:
+                    # No milestone is valid (goes to backlog)
+                    continue
+
+                # "backlog" is a valid pseudo-milestone (no file on disk)
+                if issue.milestone.lower() == "backlog":
+                    continue
+
+                # Convert milestone name to safe filename for comparison
+                safe_name = "".join(
+                    c for c in issue.milestone if c.isalnum() or c in (" ", "-", "_")
+                ).strip()
+                safe_name = safe_name.replace(" ", "-").lower()
+
+                if safe_name not in available_milestones:
+                    invalid.append(
+                        {
+                            "id": issue.id,
+                            "title": issue.title,
+                            "milestone": issue.milestone,
+                        }
+                    )
+
+        except Exception as e:
+            logger.error(
+                "find_invalid_milestones_failed", error=str(e), severity="data_error"
+            )
+            return []
+
+        return invalid
+
+    def _get_suggestion(self, invalid_milestone: str) -> str | None:
+        """Find a suggested milestone for an invalid one.
+
+        Args:
+            invalid_milestone: The invalid milestone name
+
+        Returns:
+            Suggested milestone name, or None if no good match found
+        """
+        try:
+            milestones_dir = Path(".roadmap/milestones").resolve()
+            if not milestones_dir.exists():
+                return None
+
+            available = [f.stem for f in milestones_dir.glob("*.md")]
+
+            # Find close matches
+            matches = get_close_matches(invalid_milestone, available, n=1, cutoff=0.6)
+            return matches[0] if matches else None
+        except Exception as e:
+            logger.debug(
+                "get_milestone_suggestion_failed",
+                milestone=invalid_milestone,
+                error=str(e),
+            )
+            return None

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

@@ -0,0 +1,135 @@
+"""Fixer for old backup files."""
+
+from datetime import UTC, datetime, timedelta
+from pathlib import Path
+
+from roadmap.adapters.cli.health.fixer import FixResult, FixSafety, HealthFixer
+
+
+class OldBackupsFixer(HealthFixer):
+    """Removes old backup files to free up storage.
+
+    Safety: SAFE (automatically applies)
+
+    Removes backup files older than 90 days.
+    """
+
+    BACKUP_THRESHOLD_DAYS = 90
+
+    @property
+    def fix_type(self) -> str:
+        """Return fixer type identifier."""
+        return "old_backups"
+
+    @property
+    def safety_level(self) -> FixSafety:
+        """Return safety level - SAFE because backups are not primary data."""
+        return FixSafety.SAFE
+
+    @property
+    def description(self) -> str:
+        """Return fixer description."""
+        return f"Delete backup files older than {self.BACKUP_THRESHOLD_DAYS} days"
+
+    def scan(self) -> dict:
+        """Scan for old backup files.
+
+        Returns:
+            Dict with found, count, message, details
+        """
+        old_backups = self._find_old_backups()
+
+        return {
+            "found": len(old_backups) > 0,
+            "count": len(old_backups),
+            "message": f"Found {len(old_backups)} old backup file(s) to clean up",
+            "details": [
+                {"path": str(p), "age_days": self._get_age_days(p)} for p in old_backups
+            ],
+        }
+
+    def dry_run(self) -> FixResult:
+        """Preview which backups would be deleted.
+
+        Returns:
+            FixResult with dry_run=True
+        """
+        old_backups = self._find_old_backups()
+
+        return FixResult(
+            fix_type=self.fix_type,
+            success=True,
+            dry_run=True,
+            message=f"Would delete {len(old_backups)} old backup file(s)",
+            affected_items=[str(p) for p in old_backups],
+            items_count=len(old_backups),
+            changes_made=0,
+        )
+
+    def apply(self, force: bool = False) -> FixResult:
+        """Delete old backup files.
+
+        Args:
+            force: Ignored (SAFE fixers apply automatically)
+
+        Returns:
+            FixResult with results of deletion
+        """
+        _ = force
+        old_backups = self._find_old_backups()
+        deleted_count = 0
+        failed_items = []
+
+        for backup_path in old_backups:
+            try:
+                backup_path.unlink()
+                deleted_count += 1
+            except Exception:
+                failed_items.append(str(backup_path))
+
+        success = len(failed_items) == 0
+
+        return FixResult(
+            fix_type=self.fix_type,
+            success=success,
+            dry_run=False,
+            message=f"Deleted {deleted_count}/{len(old_backups)} old backup file(s)",
+            affected_items=[str(p) for p in old_backups],
+            items_count=len(old_backups),
+            changes_made=deleted_count,
+        )
+
+    def _find_old_backups(self) -> list[Path]:
+        """Find backup files older than threshold.
+
+        Returns:
+            List of Path objects for old backups
+        """
+        old_backups = []
+        backup_dir = Path(".roadmap/backups")
+
+        if not backup_dir.exists():
+            return old_backups
+
+        now = datetime.now(UTC)
+        threshold = now - timedelta(days=self.BACKUP_THRESHOLD_DAYS)
+
+        for backup_file in backup_dir.glob("*.db"):
+            mtime = datetime.fromtimestamp(backup_file.stat().st_mtime)
+            if mtime < threshold:
+                old_backups.append(backup_file)
+
+        return sorted(old_backups)
+
+    def _get_age_days(self, path: Path) -> int:
+        """Get age of file in days.
+
+        Args:
+            path: Path to file
+
+        Returns:
+            Age in days
+        """
+        mtime = datetime.fromtimestamp(path.stat().st_mtime)
+        age = datetime.now(UTC) - mtime
+        return age.days