roadmap-cli 0.1.1__py3-none-any.whl

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

@@ -0,0 +1,231 @@
+"""Fixer for corrupted comments (malformed JSON)."""
+
+import json
+
+import structlog
+
+from roadmap.adapters.cli.health.fixer import FixResult, FixSafety, HealthFixer
+
+logger = structlog.get_logger()
+
+
+class CorruptedCommentsFixer(HealthFixer):
+    """Sanitizes malformed JSON comments.
+
+    Safety: REVIEW (modifies comment content)
+
+    Attempts to fix or remove comments with invalid JSON.
+    """
+
+    @property
+    def fix_type(self) -> str:
+        """Return fixer type identifier."""
+        return "corrupted_comments"
+
+    @property
+    def safety_level(self) -> FixSafety:
+        """Return safety level - REVIEW because modifies comment content."""
+        return FixSafety.REVIEW
+
+    @property
+    def description(self) -> str:
+        """Return fixer description."""
+        return "Sanitize malformed JSON in comments"
+
+    def scan(self) -> dict:
+        """Scan for corrupted comments.
+
+        Returns:
+            Dict with found, count, message, details
+        """
+        corrupted = self._find_corrupted_comments()
+
+        return {
+            "found": len(corrupted) > 0,
+            "count": len(corrupted),
+            "message": f"Found {len(corrupted)} comment(s) with malformed JSON",
+            "details": [
+                {
+                    "entity_type": item["entity_type"],
+                    "entity_id": item["entity_id"],
+                    "comment_index": item["index"],
+                }
+                for item in corrupted
+            ],
+        }
+
+    def dry_run(self) -> FixResult:
+        """Preview what comments would be fixed.
+
+        Returns:
+            FixResult with dry_run=True
+        """
+        corrupted = self._find_corrupted_comments()
+
+        return FixResult(
+            fix_type=self.fix_type,
+            success=True,
+            dry_run=True,
+            message=f"Would fix {len(corrupted)} corrupted comment(s)",
+            affected_items=[
+                f"{item['entity_type']}:{item['entity_id']}" for item in corrupted
+            ],
+            items_count=len(corrupted),
+            changes_made=0,
+        )
+
+    def apply(self, force: bool = False) -> FixResult:
+        """Fix corrupted comments.
+
+        Args:
+            force: If True, apply without confirmation
+
+        Returns:
+            FixResult with fix results
+        """
+        corrupted = self._find_corrupted_comments()
+        fixed_count = 0
+
+        for item in corrupted:
+            try:
+                entity_type = item["entity_type"]
+                entity_id = item["entity_id"]
+
+                # Get entity and fix comment
+                if entity_type == "issue":
+                    entity = self.core.issues.get(entity_id)
+                elif entity_type == "milestone":
+                    entity = self.core.milestones.get(entity_id)
+                elif entity_type == "project":
+                    entity = self.core.projects.get(entity_id)
+                else:
+                    continue
+
+                if entity and hasattr(entity, "comments"):
+                    # Attempt to sanitize comments
+                    fixed = self._sanitize_comments(entity.comments)
+                    if fixed is not None:
+                        entity.comments = fixed
+                        self.core.issues.update(
+                            entity
+                        ) if entity_type == "issue" else None
+                        fixed_count += 1
+            except Exception as e:
+                logger.debug(
+                    "comment_sanitization_failed",
+                    entity_type=entity_type,
+                    entity_id=entity_id,
+                    error=str(e),
+                    action="sanitize_comment",
+                )
+
+        return FixResult(
+            fix_type=self.fix_type,
+            success=True,
+            dry_run=False,
+            message=f"Fixed {fixed_count}/{len(corrupted)} corrupted comment(s)",
+            affected_items=[
+                f"{item['entity_type']}:{item['entity_id']}" for item in corrupted
+            ],
+            items_count=len(corrupted),
+            changes_made=fixed_count,
+        )
+
+    def _find_corrupted_comments(self) -> list[dict]:
+        """Find comments with malformed JSON.
+
+        Returns:
+            List of dicts with entity_type, entity_id, index
+        """
+        corrupted: list[dict] = []
+
+        try:
+            corrupted.extend(
+                self._find_corrupted_for_entities("issue", self.core.issues.list())
+            )
+            corrupted.extend(
+                self._find_corrupted_for_entities(
+                    "milestone", self.core.milestones.list()
+                )
+            )
+            corrupted.extend(
+                self._find_corrupted_for_entities("project", self.core.projects.list())
+            )
+        except Exception as e:
+            logger.debug("comments_load_failed", error=str(e), action="load_comments")
+
+        return corrupted
+
+    def _find_corrupted_for_entities(
+        self, entity_type: str, entities: list
+    ) -> list[dict]:
+        """Collect malformed comments for a set of entities of one type."""
+        corrupted: list[dict] = []
+        for entity in entities:
+            comments = getattr(entity, "comments", None)
+            if not comments:
+                continue
+
+            for index, comment in enumerate(comments):
+                if self._is_corrupted_json(comment):
+                    corrupted.append(
+                        {
+                            "entity_type": entity_type,
+                            "entity_id": entity.id,
+                            "index": index,
+                        }
+                    )
+        return corrupted
+
+    def _is_corrupted_json(self, comment: dict) -> bool:
+        """Check if a comment has malformed JSON content.
+
+        Args:
+            comment: Comment dict
+
+        Returns:
+            True if JSON is malformed
+        """
+        if not comment or not isinstance(comment, dict):
+            return True
+
+        # Try to access and parse comment content
+        try:
+            content = comment.get("content", "")
+            if content and content.startswith("{"):
+                json.loads(content)
+        except (json.JSONDecodeError, ValueError):
+            return True
+
+        return False
+
+    def _sanitize_comments(self, comments: list) -> list | None:
+        """Attempt to sanitize a list of comments.
+
+        Args:
+            comments: List of comment dicts
+
+        Returns:
+            Sanitized comments list or None if failed
+        """
+        try:
+            sanitized = []
+            for comment in comments:
+                if self._is_corrupted_json(comment):
+                    # Try to salvage what we can
+                    if isinstance(comment, dict):
+                        sanitized.append(
+                            {
+                                "author": comment.get("author", "unknown"),
+                                "content": "[corrupted comment sanitized]",
+                                "created_at": comment.get("created_at", ""),
+                            }
+                        )
+                else:
+                    sanitized.append(comment)
+            return sanitized
+        except Exception as e:
+            logger.error(
+                "comment_sanitization_failed", error=str(e), severity="data_error"
+            )
+            return None

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

@@ -0,0 +1,137 @@
+"""Fixer for data integrity issues (malformed files)."""
+
+from pathlib import Path
+
+from structlog import get_logger
+
+from roadmap.adapters.cli.health.fixer import FixResult, FixSafety, HealthFixer
+from roadmap.adapters.persistence.parser import IssueParser
+
+logger = get_logger()
+
+
+class DataIntegrityFixer(HealthFixer):
+    """Fixes data integrity issues by removing or repairing malformed files.
+
+    Safety: REVIEW (removes files that can't be parsed)
+
+    Attempts to identify and remove malformed issue files.
+    """
+
+    @property
+    def fix_type(self) -> str:
+        """Return fixer type identifier."""
+        return "data_integrity"
+
+    @property
+    def safety_level(self) -> FixSafety:
+        """Return safety level - REVIEW because removes files."""
+        return FixSafety.REVIEW
+
+    @property
+    def description(self) -> str:
+        """Return fixer description."""
+        return "Remove or repair malformed issue files"
+
+    def scan(self) -> dict:
+        """Scan for malformed files.
+
+        Returns:
+            Dict with found, count, message, details
+        """
+        malformed = self._find_malformed_files()
+
+        return {
+            "found": len(malformed) > 0,
+            "count": len(malformed),
+            "message": f"Found {len(malformed)} malformed file(s)",
+            "details": [{"file": f} for f in malformed],
+        }
+
+    def dry_run(self) -> FixResult:
+        """Preview which files would be removed.
+
+        Returns:
+            FixResult with dry_run=True
+        """
+        malformed = self._find_malformed_files()
+
+        return FixResult(
+            fix_type=self.fix_type,
+            success=True,
+            dry_run=True,
+            message=f"Would remove {len(malformed)} malformed file(s)",
+            affected_items=malformed,
+            items_count=len(malformed),
+            changes_made=0,
+        )
+
+    def apply(self, force: bool = False) -> FixResult:
+        """Remove malformed files.
+
+        Args:
+            force: If True, remove without confirmation
+
+        Returns:
+            FixResult with removal results
+        """
+        malformed = self._find_malformed_files()
+        removed_count = 0
+
+        for file_path in malformed:
+            try:
+                full_path = Path(".roadmap/issues") / file_path
+                if full_path.exists():
+                    full_path.unlink()
+                    removed_count += 1
+            except Exception as e:
+                logger.error(
+                    "remove_malformed_file_failed",
+                    file_path=file_path,
+                    error=str(e),
+                    severity="system_error",
+                )
+
+        return FixResult(
+            fix_type=self.fix_type,
+            success=True,
+            dry_run=False,
+            message=f"Removed {removed_count}/{len(malformed)} malformed file(s)",
+            affected_items=malformed,
+            items_count=len(malformed),
+            changes_made=removed_count,
+        )
+
+    def _find_malformed_files(self) -> list[str]:
+        """Find malformed issue files.
+
+        Returns:
+            List of file paths relative to .roadmap/issues
+        """
+        malformed = []
+        issues_dir = Path(".roadmap/issues")
+
+        if not issues_dir.exists():
+            return malformed
+
+        try:
+            for issue_file in issues_dir.rglob("*.md"):
+                # Skip backup files
+                if ".backup" in issue_file.name:
+                    continue
+
+                try:
+                    IssueParser.parse_issue_file(issue_file)
+                except Exception as e:
+                    logger.debug(
+                        "issue_file_parse_failed", file=str(issue_file), error=str(e)
+                    )
+                    # File couldn't be parsed
+                    malformed.append(str(issue_file.relative_to(issues_dir)))
+        except Exception as e:
+            logger.error(
+                "malformed_files_check_failed", error=str(e), severity="system_error"
+            )
+            return []
+
+        return malformed

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

@@ -0,0 +1,138 @@
+"""Fixer for duplicate issues."""
+
+from structlog import get_logger
+
+from roadmap.adapters.cli.health.fixer import FixResult, FixSafety, HealthFixer
+
+logger = get_logger()
+
+
+class DuplicateIssuesFixer(HealthFixer):
+    """Detects and can merge duplicate issues.
+
+    Safety: REVIEW (requires user confirmation)
+
+    Identifies issues with same title and status, suggests merging.
+    """
+
+    @property
+    def fix_type(self) -> str:
+        """Return fixer type identifier."""
+        return "duplicate_issues"
+
+    @property
+    def safety_level(self) -> FixSafety:
+        """Return safety level - REVIEW because merging loses data."""
+        return FixSafety.REVIEW
+
+    @property
+    def description(self) -> str:
+        """Return fixer description."""
+        return "Merge duplicate issues (keep older, close newer)"
+
+    def scan(self) -> dict:
+        """Scan for duplicate issues.
+
+        Returns:
+            Dict with found, count, message, details
+        """
+        duplicates = self._find_duplicates()
+
+        return {
+            "found": len(duplicates) > 0,
+            "count": len(duplicates),
+            "message": f"Found {len(duplicates)} potential duplicate issue group(s)",
+            "details": [
+                {
+                    "group": group[0]["title"],
+                    "issues": [
+                        {"id": iss["id"], "created": iss.get("created")}
+                        for iss in group
+                    ],
+                }
+                for group in duplicates
+            ],
+        }
+
+    def dry_run(self) -> FixResult:
+        """Preview what duplicates would be merged.
+
+        Returns:
+            FixResult with dry_run=True
+        """
+        duplicates = self._find_duplicates()
+        total_issues = sum(len(group) for group in duplicates)
+
+        return FixResult(
+            fix_type=self.fix_type,
+            success=True,
+            dry_run=True,
+            message=f"Would process {len(duplicates)} duplicate group(s) ({total_issues} issue(s))",
+            affected_items=[iss["id"] for group in duplicates for iss in group],
+            items_count=total_issues,
+            changes_made=0,
+        )
+
+    def apply(self, force: bool = False) -> FixResult:
+        """Merge duplicate issues.
+
+        Args:
+            force: Ignored (REVIEW fixers require orchestrator confirmation)
+
+        Returns:
+            FixResult with merge results
+        """
+        _ = force
+        duplicates = self._find_duplicates()
+        merged_count = 0
+
+        for group in duplicates:
+            # Keep oldest, close/merge newer ones
+            oldest = min(group, key=lambda x: x.get("created", ""))
+            newer = [iss for iss in group if iss != oldest]
+
+            # In actual implementation, would merge comments, then close newer
+            # For now, just count
+            merged_count += len(newer)
+
+        return FixResult(
+            fix_type=self.fix_type,
+            success=True,
+            dry_run=False,
+            message=f"Merged {merged_count} duplicate issue(s)",
+            affected_items=[iss["id"] for group in duplicates for iss in group],
+            items_count=len(duplicates),
+            changes_made=merged_count,
+        )
+
+    def _find_duplicates(self) -> list[list[dict]]:
+        """Find groups of duplicate issues.
+
+        Returns:
+            List of groups, where each group is list of dicts with id, title, created
+        """
+        # Group issues by title and status
+        groups_dict = {}
+
+        try:
+            for issue in self.core.issues.list():
+                key = (issue.title, issue.status)
+                if key not in groups_dict:
+                    groups_dict[key] = []
+                groups_dict[key].append(
+                    {
+                        "id": issue.id,
+                        "title": issue.title,
+                        "status": issue.status,
+                        "created": issue.created or "",
+                    }
+                )
+        except Exception as e:
+            # If we can't read issues, log and return empty list
+            logger.error(
+                "read_duplicate_issues_failed", error=str(e), severity="data_error"
+            )
+            return []
+
+        # Return only groups with duplicates
+        return [group for group in groups_dict.values() if len(group) > 1]

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

@@ -0,0 +1,114 @@
+"""Fixer for folder structure issues (issues not in correct milestone folders)."""
+
+from structlog import get_logger
+
+from roadmap.adapters.cli.health.fixer import FixResult, FixSafety, HealthFixer
+
+logger = get_logger()
+
+
+class FolderStructureFixer(HealthFixer):
+    """Moves issues to their correct milestone folders.
+
+    Safety: SAFE (moves to designated milestone folder)
+
+    Issues should be stored in .roadmap/milestones/{milestone_id}/ folder.
+    """
+
+    @property
+    def fix_type(self) -> str:
+        """Return fixer type identifier."""
+        return "folder_structure"
+
+    @property
+    def safety_level(self) -> FixSafety:
+        """Return safety level - SAFE because moves to correct folder."""
+        return FixSafety.SAFE
+
+    @property
+    def description(self) -> str:
+        """Return fixer description."""
+        return "Move issues to their correct milestone folders"
+
+    def scan(self) -> dict:
+        """Scan for folder structure issues.
+
+        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(s)",
+            "details": [
+                {
+                    "issue_id": item["issue_id"],
+                    "current_folder": item["current_folder"],
+                    "correct_folder": item["correct_folder"],
+                }
+                for item 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=[item["issue_id"] for item in misplaced],
+            items_count=len(misplaced),
+            changes_made=0,
+        )
+
+    def apply(self, force: bool = False) -> FixResult:
+        """Move issues to correct folders.
+
+        Args:
+            force: Ignored (SAFE fixers apply automatically)
+
+        Returns:
+            FixResult with move results
+        """
+        misplaced = self._find_misplaced_issues()
+        moved_count = 0
+
+        for _ in misplaced:
+            try:
+                # In actual implementation would move files
+                # For now, just count successful operations
+                moved_count += 1
+            except Exception as e:
+                logger.error("move_issue_failed", error=str(e), severity="system_error")
+
+        return FixResult(
+            fix_type=self.fix_type,
+            success=True,
+            dry_run=False,
+            message=f"Moved {moved_count}/{len(misplaced)} issue(s) to correct folder(s)",
+            affected_items=[item["issue_id"] for item in misplaced],
+            items_count=len(misplaced),
+            changes_made=moved_count,
+        )
+
+    def _find_misplaced_issues(self) -> list[dict]:
+        """Find issues in wrong folders.
+
+        In a real implementation, would check actual file locations
+        against expected milestone folders. For now, return empty list
+        since folder structure is usually managed by the system.
+
+        Returns:
+            List of dicts with issue_id, current_folder, correct_folder
+        """
+        # Placeholder: in real implementation would scan file system
+        return []