roadmap-cli 0.1.1__py3-none-any.whl

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

@@ -0,0 +1,162 @@
+"""Fixer for normalizing issue labels to alphabetically sorted order."""
+
+from roadmap.adapters.cli.health.fixer import FixResult, FixSafety, HealthFixer
+
+
+class LabelNormalizationFixer(HealthFixer):
+    """Normalizes issue labels to alphabetically sorted order.
+
+    Safety: SAFE (just reorders labels, no data loss)
+
+    GitHub may return labels in different order than local storage, causing false
+    "needs push" detection during sync. This fixer ensures labels are always
+    stored in alphabetical order for consistency.
+    """
+
+    @property
+    def fix_type(self) -> str:
+        """Return fixer type identifier."""
+        return "label_normalization"
+
+    @property
+    def safety_level(self) -> FixSafety:
+        """Return safety level - SAFE because we're just reordering labels."""
+        return FixSafety.SAFE
+
+    @property
+    def description(self) -> str:
+        """Return fixer description."""
+        return "Normalize issue labels to alphabetical order"
+
+    def scan(self) -> dict:
+        """Scan for issues with unsorted labels.
+
+        Returns:
+            Dict with found, count, message, details
+        """
+        unsorted_issues = self._find_unsorted_labels()
+
+        return {
+            "found": len(unsorted_issues) > 0,
+            "count": len(unsorted_issues),
+            "message": f"Found {len(unsorted_issues)} issue(s) with unsorted labels",
+            "details": [
+                {
+                    "id": iss["id"],
+                    "title": iss["title"],
+                    "current": iss["current_labels"],
+                    "sorted": iss["sorted_labels"],
+                }
+                for iss in unsorted_issues
+            ],
+        }
+
+    def dry_run(self) -> FixResult:
+        """Preview which issues would have labels sorted.
+
+        Returns:
+            FixResult with dry_run=True
+        """
+        unsorted_issues = self._find_unsorted_labels()
+
+        affected = [
+            f"{iss['id']}: {iss['current_labels']} → {iss['sorted_labels']}"
+            for iss in unsorted_issues
+        ]
+
+        return FixResult(
+            fix_type=self.fix_type,
+            success=True,
+            dry_run=True,
+            message=f"Would normalize {len(unsorted_issues)} issue label(s)",
+            affected_items=affected,
+            items_count=len(unsorted_issues),
+            changes_made=0,
+        )
+
+    def apply(self, force: bool = False) -> FixResult:
+        """Sort labels in all issues to alphabetical order.
+
+        Args:
+            force: If True, skip confirmation prompt
+
+        Returns:
+            FixResult with results of applying fixes
+        """
+        unsorted_issues = self._find_unsorted_labels()
+
+        if not unsorted_issues:
+            return FixResult(
+                fix_type=self.fix_type,
+                success=True,
+                dry_run=False,
+                message="No issues found with unsorted labels",
+                affected_items=[],
+                items_count=0,
+                changes_made=0,
+            )
+
+        affected = []
+        changes = 0
+
+        try:
+            for issue_data in unsorted_issues:
+                issue = issue_data["issue"]
+                sorted_labels = issue_data["sorted_labels"]
+
+                # Save the issue with sorted labels via the update API
+                self.core.issues.update(issue.id, labels=sorted_labels)
+
+                affected.append(f"{issue.id} ({len(sorted_labels)} labels sorted)")
+                changes += 1
+
+            return FixResult(
+                fix_type=self.fix_type,
+                success=True,
+                dry_run=False,
+                message=f"Normalized labels in {changes} issue(s)",
+                affected_items=affected,
+                items_count=len(unsorted_issues),
+                changes_made=changes,
+            )
+
+        except Exception as e:
+            return FixResult(
+                fix_type=self.fix_type,
+                success=False,
+                dry_run=False,
+                message=f"Failed to normalize labels: {str(e)}",
+                affected_items=affected,
+                items_count=len(unsorted_issues),
+                changes_made=changes,
+            )
+
+    def _find_unsorted_labels(self) -> list[dict]:
+        """Find all issues with unsorted labels.
+
+        Returns:
+            List of dicts with issue data and label info
+        """
+        unsorted_issues = []
+
+        # Get all local issues including archived
+        all_issues = self.core.issues.list_all_including_archived()
+
+        for issue in all_issues:
+            if not issue.labels:
+                continue
+
+            # Check if labels are sorted
+            sorted_labels = sorted(issue.labels)
+            if issue.labels != sorted_labels:
+                unsorted_issues.append(
+                    {
+                        "id": issue.id,
+                        "issue": issue,
+                        "title": issue.title,
+                        "current_labels": issue.labels,
+                        "sorted_labels": sorted_labels,
+                    }
+                )
+
+        return unsorted_issues

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

@@ -0,0 +1,181 @@
+"""Fixer for normalizing milestone names to safe format in issue metadata."""
+
+from pathlib import Path
+
+from structlog import get_logger
+
+from roadmap.adapters.cli.health.fixer import FixResult, FixSafety, HealthFixer
+
+logger = get_logger()
+
+
+class MilestoneNameNormalizationFixer(HealthFixer):
+    """Normalizes issue milestone metadata to match milestone filenames.
+
+    Safety: SAFE (just normalizes names to match actual milestones)
+
+    Issues may have milestone names like 'v.0.8.0' but milestone files are 'v080.md'.
+    This fixer updates issue metadata to use the safe filename format.
+    """
+
+    @property
+    def fix_type(self) -> str:
+        """Return fixer type identifier."""
+        return "milestone_name_normalization"
+
+    @property
+    def safety_level(self) -> FixSafety:
+        """Return safety level - SAFE because we're just normalizing names."""
+        return FixSafety.SAFE
+
+    @property
+    def description(self) -> str:
+        """Return fixer description."""
+        return "Normalize milestone names to match milestone filenames"
+
+    def scan(self) -> dict:
+        """Scan for issues with non-normalized milestone names.
+
+        Returns:
+            Dict with found, count, message, details
+        """
+        mismatched = self._find_mismatched_milestone_names()
+
+        return {
+            "found": len(mismatched) > 0,
+            "count": len(mismatched),
+            "message": f"Found {len(mismatched)} issue(s) with non-normalized milestone name(s)",
+            "details": [
+                {
+                    "id": iss["id"],
+                    "title": iss["title"],
+                    "current": iss["current_name"],
+                    "should_be": iss["normalized_name"],
+                }
+                for iss in mismatched
+            ],
+        }
+
+    def dry_run(self) -> FixResult:
+        """Preview which issues would be fixed.
+
+        Returns:
+            FixResult with dry_run=True
+        """
+        mismatched = self._find_mismatched_milestone_names()
+
+        affected = [
+            f"{iss['id']} ({iss['current_name']} → {iss['normalized_name']})"
+            for iss in mismatched
+        ]
+
+        return FixResult(
+            fix_type=self.fix_type,
+            success=True,
+            dry_run=True,
+            message=f"Would normalize {len(mismatched)} issue milestone name(s)",
+            affected_items=affected,
+            items_count=len(mismatched),
+            changes_made=0,
+        )
+
+    def apply(self, force: bool = False) -> FixResult:
+        """Normalize milestone names in issue metadata.
+
+        Args:
+            force: Ignored (SAFE fixers apply automatically)
+
+        Returns:
+            FixResult with fix results
+        """
+        _ = force
+        mismatched = self._find_mismatched_milestone_names()
+        fixed_count = 0
+        failed_items = []
+
+        for issue_data in mismatched:
+            try:
+                issue_id = issue_data["id"]
+                normalized_name = issue_data["normalized_name"]
+
+                # Assign to normalized milestone name
+                if self.core.issues.assign_to_milestone(issue_id, normalized_name):
+                    fixed_count += 1
+                else:
+                    failed_items.append(issue_id)
+            except Exception as e:
+                logger.error(
+                    "normalize_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"Normalized {fixed_count}/{len(mismatched)} issue milestone name(s)",
+            affected_items=[
+                iss["id"] for iss in mismatched if iss["id"] not in failed_items
+            ],
+            items_count=len(mismatched),
+            changes_made=fixed_count,
+        )
+
+    def _find_mismatched_milestone_names(self) -> list[dict]:
+        """Find issues where milestone name doesn't match safe filename.
+
+        Returns:
+            List of dicts with id, title, current_name, normalized_name
+        """
+        mismatched = []
+
+        try:
+            milestones_dir = Path(".roadmap/milestones").resolve()
+            if not milestones_dir.exists():
+                return mismatched
+
+            # Build map of display names to safe names
+            safe_name_to_display = {}
+            for f in milestones_dir.glob("*.md"):
+                safe_name = f.stem
+                # Try to find what display name might map to this
+                safe_name_to_display[safe_name] = safe_name
+
+            # Check all issues
+            for issue in self.core.issues.list():
+                if not issue.milestone:
+                    continue
+
+                # Convert issue's milestone to safe name
+                safe_name = "".join(
+                    c for c in issue.milestone if c.isalnum() or c in (" ", "-", "_")
+                ).strip()
+                safe_name = safe_name.replace(" ", "-").lower()
+
+                # Check if milestone file exists with this safe name
+                milestone_file = milestones_dir / f"{safe_name}.md"
+                if not milestone_file.exists():
+                    # Milestone doesn't exist, skip
+                    continue
+
+                # If the safe name differs from the issue's milestone, it needs normalizing
+                if safe_name != issue.milestone:
+                    mismatched.append(
+                        {
+                            "id": issue.id,
+                            "title": issue.title,
+                            "current_name": issue.milestone,
+                            "normalized_name": safe_name,
+                        }
+                    )
+
+        except Exception as e:
+            logger.error(
+                "find_mismatched_milestones_failed", error=str(e), severity="data_error"
+            )
+            return []
+
+        return mismatched

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

@@ -0,0 +1,244 @@
+"""Fixer for milestone naming convention compliance.
+
+This fixer ensures that:
+1. Issue milestone values use actual milestone filenames (safe names)
+2. No display name variants (v.0.8.0) are used instead of safe names (v080)
+3. All naming is consistent across the system
+"""
+
+from pathlib import Path
+
+from structlog import get_logger
+
+from roadmap.adapters.cli.health.fixer import FixResult, FixSafety, HealthFixer
+
+logger = get_logger()
+
+
+class MilestoneNamingComplianceFixer(HealthFixer):
+    """Fixes milestone names to match actual milestone filenames.
+
+    Converts display names like "v.0.8.0", "Future (Post-v1.0)" to their
+    actual safe milestone names like "v080", "future-post-v10".
+    """
+
+    DISPLAY_TO_SAFE_MILESTONE = {
+        "v.0.7.0": "v070",
+        "v.0.8.0": "v080",
+        "v.0.9.0": "v090",
+        "v.1.0.0": "v100",
+        "v.0.8": "v080",
+        "v0.8": "v080",
+        "v0.8.0": "v080",
+        "v.0.7": "v070",
+        "v0.7": "v070",
+        "v.0.9": "v090",
+        "v0.9": "v090",
+        "v.1.0": "v100",
+        "v1.0": "v100",
+        "Future (Post-v1.0)": "future-post-v10",
+        "Development": "backlog",
+    }
+
+    def __init__(self, core):
+        """Initialize fixer with core instance."""
+        super().__init__(core)
+        self.logger = logger
+
+    @property
+    def fix_type(self) -> str:
+        """Return fixer type identifier."""
+        return "milestone_naming_compliance"
+
+    @property
+    def safety_level(self) -> FixSafety:
+        """Return safety level - SAFE because we fix to actual milestone names."""
+        return FixSafety.SAFE
+
+    @property
+    def description(self) -> str:
+        """Return fixer description."""
+        return "Fix milestone naming to match actual milestone filenames"
+
+    def scan(self) -> dict:
+        """Scan for issues with non-compliant milestone names.
+
+        Returns:
+            Dict with found, count, message, details
+        """
+        non_compliant = self._find_non_compliant_milestones()
+
+        return {
+            "found": len(non_compliant) > 0,
+            "count": len(non_compliant),
+            "message": f"Found {len(non_compliant)} issue(s) with non-compliant milestone name(s)",
+            "details": [
+                {
+                    "id": iss["id"],
+                    "title": iss["title"],
+                    "current": iss["current_milestone"],
+                    "should_be": iss["safe_milestone"],
+                }
+                for iss in non_compliant
+            ],
+        }
+
+    def dry_run(self) -> FixResult:
+        """Preview which issues would be fixed.
+
+        Returns:
+            FixResult with dry_run=True
+        """
+        non_compliant = self._find_non_compliant_milestones()
+
+        affected = []
+        for iss in non_compliant:
+            affected.append(
+                f"{iss['id']} ({iss['current_milestone']} → {iss['safe_milestone']})"
+            )
+
+        return FixResult(
+            fix_type=self.fix_type,
+            success=True,
+            dry_run=True,
+            message=f"Would fix {len(non_compliant)} issue(s) with non-compliant milestone name(s)",
+            affected_items=affected,
+            items_count=len(non_compliant),
+            changes_made=0,
+        )
+
+    def apply(self, force: bool = False) -> FixResult:
+        """Apply milestone naming compliance fixes.
+
+        Args:
+            force: Not used for SAFE fixers
+
+        Returns:
+            FixResult with fix details
+        """
+        non_compliant = self._find_non_compliant_milestones()
+
+        if not non_compliant:
+            return FixResult(
+                fix_type=self.fix_type,
+                success=True,
+                dry_run=False,
+                message="No non-compliant milestone names found",
+                items_count=0,
+                changes_made=0,
+            )
+
+        affected = []
+        fixed = 0
+        failed = 0
+
+        for iss in non_compliant:
+            try:
+                # Update the issue file directly
+                file_path = Path(iss["file"])
+                content = file_path.read_text(encoding="utf-8")
+
+                # Replace milestone value
+                old_line = f"milestone: {iss['current_milestone']}"
+                new_line = f"milestone: {iss['safe_milestone']}"
+
+                updated_content = content.replace(old_line, new_line, 1)
+                file_path.write_text(updated_content, encoding="utf-8")
+
+                affected.append(
+                    f"{iss['id']} ({iss['current_milestone']} → {iss['safe_milestone']})"
+                )
+                fixed += 1
+            except Exception as e:
+                self.logger.error(f"Failed to fix milestone for {iss['id']}: {e}")
+                failed += 1
+
+        return FixResult(
+            fix_type=self.fix_type,
+            success=failed == 0,
+            dry_run=False,
+            message=f"Fixed {fixed} issue(s) with non-compliant milestone name(s)",
+            affected_items=affected,
+            items_count=len(non_compliant),
+            changes_made=fixed,
+        )
+
+    def _find_non_compliant_milestones(self) -> list[dict]:
+        """Find all issues with non-compliant milestone names.
+
+        Returns:
+            List of issue dicts with: id, title, current_milestone, safe_milestone
+        """
+        issues: list[dict] = []
+        issues_dir = Path(".roadmap/issues").resolve()
+        milestones_dir = Path(".roadmap/milestones").resolve()
+
+        # Get all actual milestone files (safe names)
+        actual_milestones = self._load_actual_milestones(milestones_dir)
+
+        if not issues_dir.exists():
+            return issues
+
+        for issue_file in issues_dir.rglob("*.md"):
+            if issue_file.name.startswith("."):
+                continue
+
+            content = issue_file.read_text(encoding="utf-8")
+            current_milestone, title = self._parse_issue_frontmatter(content)
+
+            if not current_milestone:
+                continue
+
+            if current_milestone in actual_milestones:
+                continue
+
+            safe_milestone = self._resolve_safe_milestone(
+                current_milestone,
+                actual_milestones,
+            )
+
+            if safe_milestone != current_milestone:
+                issues.append(
+                    {
+                        "id": issue_file.stem.split("-")[0],
+                        "title": title or issue_file.stem,
+                        "file": str(issue_file),
+                        "current_milestone": current_milestone,
+                        "safe_milestone": safe_milestone,
+                    }
+                )
+
+        return issues
+
+    def _load_actual_milestones(self, milestones_dir: Path) -> set[str]:
+        """Load safe milestone names from milestone filenames."""
+        if not milestones_dir.exists():
+            return set()
+        return {milestone_file.stem for milestone_file in milestones_dir.glob("*.md")}
+
+    def _parse_issue_frontmatter(self, content: str) -> tuple[str | None, str | None]:
+        """Extract milestone and title values from issue file frontmatter lines."""
+        current_milestone = None
+        title = None
+        for line in content.split("\n"):
+            if line.startswith("milestone:"):
+                current_milestone = line.replace("milestone:", "").strip()
+            elif line.startswith("title:"):
+                title = line.replace("title:", "").strip().strip("'\"")
+        return current_milestone, title
+
+    def _resolve_safe_milestone(
+        self,
+        current_milestone: str,
+        actual_milestones: set[str],
+    ) -> str:
+        """Resolve a milestone value to a safe milestone name."""
+        if not current_milestone or current_milestone.isspace():
+            return "backlog"
+
+        safe_milestone = self.DISPLAY_TO_SAFE_MILESTONE.get(
+            current_milestone, "backlog"
+        )
+        if safe_milestone not in actual_milestones:
+            return "backlog"
+        return safe_milestone