roadmap-cli 0.1.1__py3-none-any.whl

roadmap/adapters/cli/presentation/issue_presenter.py

@@ -0,0 +1,258 @@
+"""CLI presenter for Issue DTOs."""
+
+from datetime import datetime
+
+from rich.markdown import Markdown
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+from roadmap.adapters.cli.dtos import IssueDTO
+from roadmap.adapters.cli.presentation.base_presenter import BasePresenter
+from roadmap.adapters.cli.presentation.table_builders import create_metadata_table
+from roadmap.adapters.cli.styling import PRIORITY_COLORS, STATUS_COLORS
+
+
+class IssuePresenter(BasePresenter):
+    """Presenter for formatting and displaying Issue DTOs."""
+
+    def render(self, issue_dto: IssueDTO) -> None:
+        """Render an issue DTO in detailed view.
+
+        Args:
+            issue_dto: The IssueDTO to render
+        """
+        # Display header
+        header = self._build_issue_header(issue_dto)
+        self._get_console().print(Panel(header, border_style="cyan"))
+
+        # Display metadata
+        metadata = self._build_metadata_table(issue_dto)
+        self._get_console().print(
+            Panel(metadata, title="📋 Metadata", border_style="blue")
+        )
+
+        # Display timeline
+        timeline = self._build_timeline_table(issue_dto)
+        self._get_console().print(
+            Panel(timeline, title="⏱️  Timeline", border_style="yellow")
+        )
+
+        # Display dependencies if any
+        deps = self._build_dependencies_table(issue_dto)
+        if deps:
+            self._get_console().print(
+                Panel(deps, title="🔗 Dependencies", border_style="magenta")
+            )
+
+        # Display description if available
+        if issue_dto.content:
+            description, acceptance = self._extract_description_and_criteria(
+                issue_dto.content
+            )
+
+            if description:
+                md = Markdown(description)
+                self._get_console().print(
+                    Panel(md, title="📝 Description", border_style="white")
+                )
+
+            if acceptance:
+                md = Markdown(acceptance)
+                self._get_console().print(
+                    Panel(md, title="✅ Acceptance Criteria", border_style="green")
+                )
+        else:
+            self._get_console().print(
+                Panel(
+                    "[dim]No description available[/dim]",
+                    title="📝 Description",
+                    border_style="white",
+                )
+            )
+
+        # Display comments if any
+        if issue_dto.comments:
+            comments_text = self._build_comments_text(issue_dto.comments)
+            self._get_console().print(
+                Panel(
+                    comments_text,
+                    title=f"💬 Comments ({len(issue_dto.comments)})",
+                    border_style="cyan",
+                )
+            )
+
+    def _build_issue_header(self, issue_dto: IssueDTO) -> Text:
+        """Build header text with issue title and metadata.
+
+        Args:
+            issue_dto: The IssueDTO to format
+
+        Returns:
+            Rich Text object with formatted header
+        """
+        status_color = STATUS_COLORS.get(issue_dto.status, "white")
+        priority_color = PRIORITY_COLORS.get(issue_dto.priority, "white")
+
+        header = Text()
+        header.append(f"#{issue_dto.id}", style="bold cyan")
+        header.append(" • ", style="dim")
+        header.append(issue_dto.title, style="bold white")
+        header.append("\n")
+        header.append(f"[{issue_dto.status.upper()}]", style=f"bold {status_color}")
+        header.append(" • ", style="dim")
+        header.append(issue_dto.priority.upper(), style=priority_color)
+        header.append(" • ", style="dim")
+        header.append(issue_dto.issue_type.title(), style="cyan")
+
+        return header
+
+    def _build_metadata_table(self, issue_dto: IssueDTO):
+        """Build metadata table for issue DTO.
+
+        Args:
+            issue_dto: The IssueDTO to format
+
+        Returns:
+            Rich Table with metadata rows
+        """
+        metadata = create_metadata_table()
+
+        metadata.add_row("Assignee", issue_dto.assignee or "Unassigned")
+        metadata.add_row("Milestone", issue_dto.milestone or "None")
+        if issue_dto.created:
+            metadata.add_row("Created", issue_dto.created.strftime("%Y-%m-%d %H:%M"))
+        if issue_dto.updated:
+            metadata.add_row("Updated", issue_dto.updated.strftime("%Y-%m-%d %H:%M"))
+
+        if issue_dto.labels:
+            metadata.add_row("Labels", ", ".join(issue_dto.labels))
+
+        if issue_dto.github_issue:
+            github_id = (
+                f"#{issue_dto.github_issue}"
+                if isinstance(issue_dto.github_issue, int)
+                else str(issue_dto.github_issue)
+            )
+            metadata.add_row("GitHub Issue", github_id)
+
+        return metadata
+
+    def _build_timeline_table(self, issue_dto: IssueDTO):
+        """Build timeline table for issue DTO.
+
+        Args:
+            issue_dto: The IssueDTO to format
+
+        Returns:
+            Rich Table with timeline rows
+        """
+        timeline = create_metadata_table()
+
+        # Display estimated hours
+        if issue_dto.estimated_hours:
+            timeline.add_row("Estimated", f"{issue_dto.estimated_hours:.1f}h")
+        else:
+            timeline.add_row("Estimated", "Not estimated")
+
+        # Display progress
+        if issue_dto.progress_percentage is not None:
+            timeline.add_row("Progress", f"{issue_dto.progress_percentage}%")
+        else:
+            timeline.add_row("Progress", "0%")
+
+        # Display end date if present
+        if isinstance(issue_dto.actual_end_date, datetime):
+            timeline.add_row(
+                "Completed", issue_dto.actual_end_date.strftime("%Y-%m-%d %H:%M")
+            )
+
+        # Display due date if present
+        if isinstance(issue_dto.due_date, datetime):
+            timeline.add_row("Due Date", issue_dto.due_date.strftime("%Y-%m-%d"))
+
+        return timeline
+
+    def _build_dependencies_table(self, issue_dto: IssueDTO):
+        """Build dependencies table if exists.
+
+        Args:
+            issue_dto: The IssueDTO to format
+
+        Returns:
+            Rich Table with dependencies or None if no dependencies
+        """
+        # For now, DTOs don't store dependencies - would need to extend model
+        return None
+
+    def _extract_description_and_criteria(self, content: str) -> tuple[str, str]:
+        """Parse issue content to extract description and acceptance criteria.
+
+        Args:
+            content: The issue content/description text
+
+        Returns:
+            Tuple of (description, acceptance_criteria) strings
+        """
+        content_lines = content.split("\n")
+        description_lines = []
+        acceptance_lines = []
+        in_acceptance = False
+
+        for line in content_lines:
+            if (
+                "## Acceptance Criteria" in line
+                or "## acceptance criteria" in line.lower()
+            ):
+                in_acceptance = True
+                continue
+            elif line.startswith("## ") and in_acceptance:
+                in_acceptance = False
+
+            if in_acceptance:
+                acceptance_lines.append(line)
+            elif not line.startswith("#"):
+                description_lines.append(line)
+
+        description = "\n".join(description_lines).strip()
+        acceptance = "\n".join(acceptance_lines).strip()
+
+        return description, acceptance
+
+    def _build_comments_text(self, comments: list) -> Table:
+        """Build formatted text for displaying comments.
+
+        Args:
+            comments: List of CommentDTO objects
+
+        Returns:
+            Rich Table object with formatted comments
+        """
+        # Create a table for comments
+        table = Table(show_header=False, box=None, padding=(1, 0))
+        table.add_column("Comments", style="white")
+
+        for comment in comments:
+            comment_text = Text()
+            # Author and timestamp
+            author_line = Text()
+            author_line.append(f"@{comment.author}", style="bold magenta")
+            author_line.append(
+                f" · {comment.created_at.strftime('%Y-%m-%d %H:%M')}", style="dim"
+            )
+            if comment.in_reply_to:
+                author_line.append(
+                    f" (in reply to #{comment.in_reply_to})", style="dim italic"
+                )
+            comment_text.append(author_line)
+            comment_text.append("\n")
+
+            # Comment body (using markdown if possible)
+            comment_text.append(comment.body, style="white")
+
+            table.add_row(comment_text)
+            # Add separator between comments
+            if comment != comments[-1]:
+                table.add_row(Text("─" * 60, style="dim"))
+
+        return table

roadmap/adapters/cli/presentation/milestone_list_presenter.py

@@ -0,0 +1,135 @@
+"""Presentation layer for milestone list command.
+
+Handles all display logic related to:
+- Rendering milestone tables
+- Formatting milestone data
+- Styling milestone information
+- Empty state handling
+"""
+
+from rich.table import Table
+
+from roadmap.common.console import get_console
+from roadmap.common.logging import get_logger
+
+console = get_console()
+logger = get_logger(__name__)
+
+
+class MilestoneTablePresenter:
+    """Presenter for rendering milestone data in table format."""
+
+    @staticmethod
+    def display_milestone_table(
+        milestones: list,
+        progress: dict,
+        estimates: dict,
+        get_due_date_status_fn,
+    ) -> None:
+        """Display milestones in a formatted Rich table.
+
+        Args:
+            milestones: List of milestone objects
+            progress: Dictionary mapping milestone names to progress dicts
+            estimates: Dictionary mapping milestone names to estimate strings
+            get_due_date_status_fn: Function to get due date string and styling
+        """
+        try:
+            table = Table(show_header=True, header_style="bold magenta")
+            table.add_column("Name", style="cyan")
+            table.add_column("Description", style="white")
+            table.add_column("Due Date", style="yellow", width=12)
+            table.add_column("Status", style="green", width=10)
+            table.add_column("Progress", style="blue", width=12)
+            table.add_column("Estimate", style="green", width=10)
+
+            for ms in milestones:
+                # Get progress
+                ms_progress = progress.get(ms.name, {})
+                progress_text = (
+                    f"{ms_progress.get('completed', 0)}/{ms_progress.get('total', 0)}"
+                )
+
+                # Get estimate
+                estimate_text = estimates.get(ms.name, "-")
+
+                # Format due date with styling
+                due_date_text, style = get_due_date_status_fn(ms)
+                if style:
+                    due_date_text = f"[{style}]{due_date_text}[/{style}]"
+
+                # Add row to table
+                table.add_row(
+                    ms.name,
+                    ms.content or "-",
+                    due_date_text,
+                    ms.status.value,
+                    progress_text,
+                    estimate_text,
+                )
+
+            console.print(table)
+        except Exception as e:
+            logger.error(
+                "failed_to_display_milestone_table",
+                error=str(e),
+                severity="operational",
+            )
+            console.print("❌ Failed to display milestone table", style="bold red")
+
+
+class MilestoneListPresenter:
+    """Presenter for milestone list display."""
+
+    @staticmethod
+    def show_empty_state() -> None:
+        """Display empty state when no milestones found."""
+        console.print("📋 No milestones found.", style="yellow")
+        console.print(
+            "Create one with: roadmap milestone create 'Milestone name'",
+            style="dim",
+        )
+
+    @staticmethod
+    def show_no_upcoming_milestones() -> None:
+        """Display message when no upcoming milestones with due dates found."""
+        console.print("📋 No upcoming milestones with due dates found.", style="yellow")
+        console.print(
+            "Create one with: roadmap milestone create 'Milestone name' --due-date YYYY-MM-DD",
+            style="dim",
+        )
+
+    @staticmethod
+    def show_milestones_list(
+        milestones_data: dict,
+        get_due_date_status_fn,
+    ) -> None:
+        """Display list of milestones.
+
+        Args:
+            milestones_data: Dictionary with milestones, progress, estimates, etc.
+            get_due_date_status_fn: Function to get due date string and styling
+        """
+        if not milestones_data["has_data"]:
+            MilestoneListPresenter.show_empty_state()
+            return
+
+        # Display table
+        MilestoneTablePresenter.display_milestone_table(
+            milestones_data["milestones"],
+            milestones_data["progress"],
+            milestones_data["estimates"],
+            get_due_date_status_fn,
+        )
+
+    @staticmethod
+    def show_error(error_msg: str) -> None:
+        """Display error message.
+
+        Args:
+            error_msg: Error message to display
+        """
+        console.print(
+            f"❌ Failed to list milestones: {error_msg}",
+            style="bold red",
+        )

roadmap/adapters/cli/presentation/milestone_presenter.py

@@ -0,0 +1,297 @@
+"""CLI presenter for Milestone DTOs."""
+
+from datetime import UTC, datetime
+
+from rich.markdown import Markdown
+from rich.panel import Panel
+from rich.text import Text
+
+from roadmap.adapters.cli.dtos import MilestoneDTO
+from roadmap.adapters.cli.presentation.base_presenter import BasePresenter
+from roadmap.adapters.cli.presentation.table_builders import (
+    create_list_table,
+    create_metadata_table,
+)
+from roadmap.adapters.cli.styling import PRIORITY_COLORS, STATUS_COLORS
+
+
+class MilestonePresenter(BasePresenter):
+    """Presenter for formatting and displaying Milestone DTOs."""
+
+    def render(
+        self,
+        milestone_dto: MilestoneDTO,
+        issues: list | None = None,
+        progress_data: dict | None = None,
+        description_content: str | None = None,
+        comments_text: str | None = None,
+    ) -> None:
+        """Render a milestone DTO in detailed view.
+
+        Args:
+            milestone_dto: The MilestoneDTO to render
+            issues: Optional list of issues to display
+            progress_data: Optional progress information dict with 'completed' and 'total' keys
+            description_content: Optional content with description and goals
+            comments_text: Optional formatted comments text
+        """
+        # Display header
+        header = self._build_milestone_header(milestone_dto)
+        self._get_console().print(Panel(header, border_style="cyan"))
+
+        # Display progress if provided
+        if progress_data:
+            self._display_progress_panel(progress_data)
+
+        # Display metadata
+        metadata = self._build_metadata_table(milestone_dto)
+        self._get_console().print(
+            Panel(metadata, title="📈 Statistics", border_style="blue")
+        )
+
+        # Display issues if provided
+        if issues is not None:
+            self._display_issues_panel(milestone_dto.name, issues)
+
+        # Display description and goals if provided
+        if description_content:
+            self._display_description_and_goals(description_content)
+
+        # Display comments if provided
+        if comments_text:
+            self._get_console().print(
+                Panel(
+                    comments_text,
+                    title="💬 Comments",
+                    border_style="cyan",
+                )
+            )
+
+        # Display metadata footer
+        metadata_footer = (
+            f"Created: {milestone_dto.created} • Updated: {milestone_dto.updated}"
+        )
+        self._get_console().print(f"\n[dim]{metadata_footer}[/dim]")
+
+    def _build_milestone_header(self, milestone_dto: MilestoneDTO) -> Text:
+        """Build header text with milestone name and status.
+
+        Args:
+            milestone_dto: The MilestoneDTO to format
+
+        Returns:
+            Rich Text object with formatted header
+        """
+        status_color = "green" if milestone_dto.status == "closed" else "yellow"
+
+        header = Text()
+        header.append(milestone_dto.name, style="bold cyan")
+        header.append("\n")
+        header.append(f"[{milestone_dto.status.upper()}]", style=f"bold {status_color}")
+
+        # Add due date if present
+        if milestone_dto.due_date:
+            due_date_str = (
+                milestone_dto.due_date.strftime("%Y-%m-%d")
+                if hasattr(milestone_dto.due_date, "strftime")
+                else milestone_dto.due_date
+            )
+            now = datetime.now(UTC)
+
+            due_date_obj = (
+                milestone_dto.due_date
+                if hasattr(milestone_dto.due_date, "replace")
+                else datetime.fromisoformat(str(milestone_dto.due_date))
+            )
+
+            # Normalize due date to an aware datetime in UTC so comparisons
+            # between now (UTC-aware) and the due date are consistent.
+            if isinstance(due_date_obj, datetime):
+                if due_date_obj.tzinfo:
+                    due_date_aware = due_date_obj.astimezone(UTC)
+                else:
+                    due_date_aware = due_date_obj.replace(tzinfo=UTC)
+            else:
+                due_date_aware = datetime.fromisoformat(str(due_date_obj)).replace(
+                    tzinfo=UTC
+                )
+
+            is_overdue = due_date_aware < now and milestone_dto.status == "open"
+
+            header.append(" • ", style="dim")
+            if is_overdue:
+                days_overdue = (now - due_date_aware).days
+                header.append(f"⚠️  OVERDUE by {days_overdue} days", style="bold red")
+                header.append(f" (Due: {due_date_str})", style="red")
+            else:
+                header.append(f"Due: {due_date_str}", style="white")
+
+        return header
+
+    def _build_metadata_table(self, milestone_dto: MilestoneDTO):
+        """Build metadata table for milestone DTO.
+
+        Args:
+            milestone_dto: The MilestoneDTO to format
+
+        Returns:
+            Rich Table with metadata rows
+        """
+        metadata = create_metadata_table()
+
+        metadata.add_row("Status", milestone_dto.status.upper())
+
+        if isinstance(milestone_dto.due_date, datetime):
+            metadata.add_row("Due Date", milestone_dto.due_date.strftime("%Y-%m-%d"))
+        else:
+            metadata.add_row("Due Date", "Not set")
+
+        if milestone_dto.headline:
+            metadata.add_row("Headline", milestone_dto.headline)
+
+        metadata.add_row("Progress", f"{milestone_dto.progress_percentage}%")
+        metadata.add_row(
+            "Issues",
+            f"{milestone_dto.completed_count}/{milestone_dto.issue_count}",
+        )
+
+        if isinstance(milestone_dto.created, datetime):
+            metadata.add_row(
+                "Created", milestone_dto.created.strftime("%Y-%m-%d %H:%M")
+            )
+
+        if isinstance(milestone_dto.updated, datetime):
+            metadata.add_row(
+                "Updated", milestone_dto.updated.strftime("%Y-%m-%d %H:%M")
+            )
+
+        return metadata
+
+    def _display_progress_panel(self, progress_data: dict) -> None:
+        """Display milestone progress as a panel.
+
+        Args:
+            progress_data: Dict with 'completed' and 'total' keys
+        """
+        completed = progress_data.get("completed", 0)
+        total = progress_data.get("total", 0)
+        percentage = (completed / total * 100) if total > 0 else 0
+
+        progress_table = create_metadata_table()
+        progress_table.add_row("Issues Complete", f"{completed}/{total}")
+        progress_table.add_row("Percentage", f"{percentage:.1f}%")
+
+        self._get_console().print(
+            Panel(
+                progress_table,
+                title="📊 Progress",
+                border_style="green" if percentage > 50 else "yellow",
+            )
+        )
+
+    def _display_issues_panel(self, milestone_name: str, issues: list) -> None:
+        """Display issues in a table panel.
+
+        Args:
+            milestone_name: Milestone name used in follow-up guidance
+            issues: List of issue objects with status, priority, etc.
+        """
+        if not issues:
+            self._get_console().print(
+                Panel(
+                    "[dim]No issues assigned to this milestone[/dim]",
+                    title="📋 Issues",
+                    border_style="magenta",
+                )
+            )
+            return
+
+        columns = [
+            ("ID", "cyan", 9),
+            ("Title", "white", 20),
+            ("Status", None, 11),
+            ("Priority", None, 9),
+            ("Assignee", None, 12),
+            ("Progress", None, 10),
+            ("Estimate", None, 10),
+        ]
+        issues_table = create_list_table(columns)
+
+        for issue in issues[:10]:
+            status_color = STATUS_COLORS.get(issue.status.value, "white")
+            priority_color = PRIORITY_COLORS.get(issue.priority.value, "white")
+            assignee_display = (
+                issue.assignee if issue.assignee else "[dim]Unassigned[/dim]"
+            )
+
+            issues_table.add_row(
+                issue.id,
+                issue.title[:50] + "..." if len(issue.title) > 50 else issue.title,
+                f"[{status_color}]{issue.status.value}[/{status_color}]",
+                f"[{priority_color}]{issue.priority.value}[/{priority_color}]",
+                assignee_display,
+                issue.progress_display,
+                issue.estimated_time_display,
+            )
+
+        title = (
+            f"📋 Issues (First 10 of {len(issues)})"
+            if len(issues) > 10
+            else "📋 Issues"
+        )
+        self._get_console().print(
+            Panel(issues_table, title=title, border_style="magenta")
+        )
+
+        if len(issues) > 10:
+            self._get_console().print(
+                "[dim]Showing first 10 issues in milestone view. "
+                f"Use 'roadmap issue list -m {milestone_name}' to see all issues.[/dim]"
+            )
+
+    def _display_description_and_goals(self, content: str) -> None:
+        """Display description and goals sections from content.
+
+        Args:
+            content: Raw content with markdown sections
+        """
+        description, goals = self._extract_description_and_goals(content)
+
+        if description:
+            md = Markdown(description)
+            self._get_console().print(
+                Panel(md, title="📝 Description", border_style="white")
+            )
+
+        if goals:
+            md = Markdown(goals)
+            self._get_console().print(Panel(md, title="🎯 Goals", border_style="green"))
+
+    @staticmethod
+    def _extract_description_and_goals(content: str) -> tuple[str, str]:
+        """Parse content to extract description and goals sections.
+
+        Args:
+            content: Raw content string with markdown sections
+
+        Returns:
+            Tuple of (description, goals) strings
+        """
+        content_lines = content.split("\n")
+        description_lines = []
+        goals_lines = []
+        in_goals = False
+
+        for line in content_lines:
+            if "## Goals" in line or "## goals" in line.lower():
+                in_goals = True
+                continue
+            elif line.startswith("## ") and in_goals:
+                in_goals = False
+
+            if in_goals:
+                goals_lines.append(line)
+            elif not line.startswith("#"):
+                description_lines.append(line)
+
+        return "\n".join(description_lines).strip(), "\n".join(goals_lines).strip()