roadmap-cli 0.1.1__py3-none-any.whl

roadmap/adapters/cli/presentation/core_initialization_presenter.py

@@ -0,0 +1,277 @@
+"""Presenter for core initialization command output."""
+
+from typing import TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from roadmap.core.domain.health import HealthStatus
+
+import click  # type: ignore[import]
+
+
+class CoreInitializationPresenter:
+    """Handles all console output for core initialization commands."""
+
+    def __init__(self):
+        """Initialize presenter."""
+        pass
+
+    # ========== Init Command Output ==========
+
+    def present_initialization_header(self) -> None:
+        """Show initialization header."""
+        click.secho("🚀 Roadmap CLI Initialization", fg="cyan", bold=True)
+        click.echo()
+
+    def present_force_reinitialize_warning(self, name: str) -> None:
+        """Show warning about force re-initialization."""
+        click.secho(
+            f"⚠️  --force specified: removing existing {name}/",
+            fg="yellow",
+        )
+
+    def present_already_initialized_info(self, name: str) -> None:
+        """Show info that roadmap is already initialized."""
+        click.secho(
+            f"ℹ️  Roadmap already initialized in {name}/",
+            fg="cyan",
+        )
+        click.echo(
+            "    Updating configuration while preserving existing data.", err=False
+        )
+        click.echo()
+
+    def present_initialization_error(self, error: str) -> None:
+        """Show initialization error."""
+        click.secho(f"❌ {error}", fg="red", bold=True)
+
+    def present_initialization_tip(self) -> None:
+        """Show helpful tip for initialization errors."""
+        click.secho(
+            "Tip: use --force to reinitialize or --dry-run to preview.",
+            fg="yellow",
+        )
+
+    def present_already_in_progress_error(self) -> None:
+        """Show error that initialization is already in progress."""
+        click.secho(
+            "❌ Initialization already in progress. Try again later.",
+            fg="red",
+            bold=True,
+        )
+
+    def present_creating_structure(self, name: str) -> None:
+        """Show status while creating structure."""
+        click.secho(f"🗂️  Creating roadmap structure in {name}/...", fg="white")
+
+    def present_existing_projects_found(self, count: int) -> None:
+        """Show info about existing projects found."""
+        click.secho(
+            f"\n  💡 {count} projects found. All will be available.",
+            fg="white",
+        )
+
+    def present_project_created(self, project_name: str) -> None:
+        """Show that a project was created."""
+        click.secho(f"✅ Created project: {project_name}", fg="green")
+
+    def present_project_joined(self, project_name: str) -> None:
+        """Show that team member joined existing project."""
+        click.secho(f"✅ Joined existing project: {project_name}", fg="green")
+
+    def present_projects_joined(self, main_project: str, count: int) -> None:
+        """Show that team member joined with multiple projects available."""
+        click.secho(
+            f"✅ Joined {main_project} ({count} projects available)", fg="green"
+        )
+
+    def present_initialization_warning(self, message: str) -> None:
+        """Show warning message after initialization."""
+        click.secho(
+            "⚠️  Initialization completed with warnings; see above.",
+            fg="yellow",
+        )
+
+    def present_initialization_failed(self, error: str) -> None:
+        """Show initialization failure message."""
+        click.secho(f"❌ Failed to initialize roadmap: {error}", fg="red", bold=True)
+
+    # ========== Status Command Output ==========
+
+    def present_status_header(self) -> None:
+        """Show status command header."""
+        click.secho("📊 Roadmap Status Report", fg="cyan", bold=True)
+        click.echo()
+
+    def present_status_section(self, title: str) -> None:
+        """Show status section header."""
+        click.secho(f"\n{title}", fg="cyan", bold=True)
+        click.secho("─" * (len(title)), fg="white")
+
+    def present_status_item(self, label: str, value: str, ok: bool = True) -> None:
+        """Show a status item."""
+        color = "green" if ok else "yellow"
+        icon = "✓" if ok else "⚠"
+        click.secho(f"{icon} {label}: {value}", fg=color)
+
+    def present_status_not_initialized(self) -> None:
+        """Show that roadmap is not initialized."""
+        click.secho("❌ Roadmap not initialized in .roadmap/", fg="red")
+        click.echo("Run 'roadmap init' to get started.")
+
+    # ========== Health Check Output ==========
+
+    def present_health_header(self) -> None:
+        """Show health check header."""
+        click.secho("🏥 Roadmap Health Check", fg="cyan", bold=True)
+        click.echo()
+
+    def present_health_section(self, title: str) -> None:
+        """Show health section header."""
+        click.secho(f"\n{title}", fg="cyan", bold=True)
+        click.secho("─" * (len(title)), fg="white")
+
+    def present_health_check(
+        self, check_name: str, status: Union[str, "HealthStatus"], message: str = ""
+    ) -> None:
+        """Show individual health check result.
+
+        Args:
+            check_name: Name of the health check
+            status: HealthStatus enum value or string
+            message: Optional details about the check
+        """
+        from roadmap.infrastructure.observability.health import HealthStatus
+
+        # Convert status to string if it's an enum
+        status_str = status.name if isinstance(status, HealthStatus) else str(status)
+
+        # Map status to display values
+        status_map = {
+            "HEALTHY": ("✅", "green"),
+            "DEGRADED": ("⚠️", "yellow"),
+            "UNHEALTHY": ("❌", "red"),
+            "healthy": ("✅", "green"),
+            "warning": ("⚠️", "yellow"),
+            "error": ("❌", "red"),
+        }
+
+        icon, color = status_map.get(status_str, ("?", "white"))
+        display_name = check_name.replace("_", " ").title()
+
+        click.secho(f"{icon} {display_name}: {status_str}", fg=color)
+        if message:
+            click.echo(f"  {message}")
+
+    def present_overall_health(self, status: Union[str, "HealthStatus"]) -> None:
+        """Show overall health status.
+
+        Args:
+            status: HealthStatus enum value or string
+        """
+        from roadmap.infrastructure.observability.health import HealthStatus
+
+        # Convert status to string if it's an enum
+        status_str = status.name if isinstance(status, HealthStatus) else str(status)
+
+        status_map = {
+            "HEALTHY": ("✅", "green"),
+            "DEGRADED": ("⚠️", "yellow"),
+            "UNHEALTHY": ("❌", "red"),
+            "healthy": ("✅", "green"),
+            "warning": ("⚠️", "yellow"),
+            "error": ("❌", "red"),
+        }
+
+        icon, color = status_map.get(status_str, ("?", "white"))
+
+        click.echo()
+        click.secho(
+            f"{icon} Overall Status: {status_str}",
+            fg=color,
+            bold=True,
+        )
+
+    def present_health_warning(self, message: str) -> None:
+        """Show health warning."""
+        click.secho(f"⚠️  {message}", fg="yellow")
+
+    # ========== GitHub Integration Output ==========
+
+    def present_github_testing(self) -> None:
+        """Show message while testing GitHub connection."""
+        click.secho("🔍 Testing GitHub connection...", fg="yellow")
+
+    def present_github_credentials_stored(self) -> None:
+        """Show message that credentials were stored."""
+        click.secho("🔒 Credentials stored securely", fg="green")
+
+    def present_github_unavailable(self, reason: str) -> None:
+        """Show GitHub integration unavailable message."""
+        click.secho(
+            f"⚠️  GitHub integration not available: {reason}",
+            fg="yellow",
+        )
+
+    def present_github_setup_failed(self, error: str) -> None:
+        """Show GitHub setup failure."""
+        click.secho(f"❌ GitHub setup failed: {error}", fg="red")
+
+    # ========== Generic Output Methods ==========
+
+    def present_error(self, message: str) -> None:
+        """Show generic error message."""
+        click.secho(f"❌ {message}", fg="red", bold=True)
+
+    def present_warning(self, message: str) -> None:
+        """Show generic warning message."""
+        click.secho(f"⚠️  {message}", fg="yellow")
+
+    def present_info(self, message: str) -> None:
+        """Show generic info message."""
+        click.secho(f"ℹ️  {message}", fg="cyan")
+
+    def present_success(self, message: str) -> None:
+        """Show generic success message."""
+        click.secho(f"✅ {message}", fg="green", bold=True)
+
+    def present_initialization_complete(self, created_new: bool) -> None:
+        """Show initialization completion with next steps.
+
+        Args:
+            created_new: Whether a new roadmap was created or existing was joined
+        """
+        click.echo()
+        if created_new:
+            click.secho("✅ Roadmap initialized successfully!", fg="green", bold=True)
+            click.echo("   📁 Data stored in: .roadmap/")
+        else:
+            click.secho("✅ Initialization complete!", fg="green", bold=True)
+
+        click.echo()
+        click.echo("Next steps:")
+        click.echo('   • roadmap issue create "Your first task"')
+        click.echo('   • roadmap milestone create "v1.0"')
+        click.echo("   • roadmap list")
+        click.echo()
+
+    def present_existing_projects_info(self, project_names: list) -> None:
+        """Show info about existing projects found.
+
+        Args:
+            project_names: List of project names that were found
+        """
+        click.echo()
+        if len(project_names) == 1:
+            click.secho(
+                f"ℹ️  Found existing project: {project_names[0]}",
+                fg="cyan",
+            )
+        else:
+            projects_str = ", ".join(project_names[:3])
+            if len(project_names) > 3:
+                projects_str += f", +{len(project_names) - 3} more"
+            click.secho(
+                f"ℹ️  Found {len(project_names)} projects: {projects_str}",
+                fg="cyan",
+            )
+        click.secho("   Run 'roadmap project list' to see all", fg="white")

roadmap/adapters/cli/presentation/crud_presenter.py

@@ -0,0 +1,134 @@
+"""Presenter for CRUD operation results.
+
+This presenter handles displaying results of create, update, delete, archive,
+and restore operations. It shows a brief success message with key entity details.
+"""
+
+from typing import Any
+
+from roadmap.adapters.cli.presentation.base_presenter import BasePresenter
+
+
+def _infer_entity_type(entity: Any) -> str:
+    """Infer entity type from class name or attributes.
+
+    Handles both real objects and mocks used in tests.
+
+    Args:
+        entity: The entity object
+
+    Returns:
+        Entity type string (Issue, Project, Milestone, Entity)
+    """
+    class_name = entity.__class__.__name__
+
+    # Handle mocks in tests
+    if class_name == "Mock":
+        # Try to infer from entity attributes
+        if hasattr(entity, "priority") and hasattr(entity, "issue_type"):
+            return "Issue"
+        elif hasattr(entity, "repository"):
+            return "Project"
+        elif hasattr(entity, "start_date") or hasattr(entity, "end_date"):
+            return "Milestone"
+        return "Entity"
+
+    return class_name
+
+
+def _get_entity_id(entity: Any) -> str:
+    """Extract entity ID."""
+    if hasattr(entity, "id"):
+        return str(entity.id)
+    if hasattr(entity, "entity_id"):
+        return str(entity.entity_id)
+    return "unknown"
+
+
+def _get_entity_title(entity: Any) -> str:
+    """Extract entity title/name."""
+    if hasattr(entity, "name"):
+        return entity.name
+    if hasattr(entity, "title"):
+        return entity.title
+    if hasattr(entity, "summary"):
+        return entity.summary
+    return "Untitled"
+
+
+class CreatePresenter(BasePresenter):
+    """Presenter for create operation results."""
+
+    def render(self, entity: Any) -> None:
+        """Render created entity summary.
+
+        Args:
+            entity: The created entity object
+        """
+        console = self._get_console()
+        entity_type = _infer_entity_type(entity)
+        entity_id = _get_entity_id(entity)
+        title = _get_entity_title(entity)
+
+        console.print(
+            f"✅ Created {entity_type.lower()}: {title} [{entity_id}]",
+            style="green",
+        )
+
+
+class UpdatePresenter(BasePresenter):
+    """Presenter for update operation results."""
+
+    def render(self, entity: Any, _updates: dict[str, Any] | None = None) -> None:
+        """Render updated entity summary.
+
+        Args:
+            entity: The updated entity object
+            _updates: Optional dict of fields that were updated
+        """
+        console = self._get_console()
+        entity_type = _infer_entity_type(entity)
+        entity_id = _get_entity_id(entity)
+        title = _get_entity_title(entity)
+
+        console.print(
+            f"✅ Updated {entity_type.lower()}: {title} [{entity_id}]",
+            style="green",
+        )
+
+        # Display updated fields if provided
+        if _updates:
+            for field, value in _updates.items():
+                if value is not None and field != "id":  # Skip id field
+                    if field == "estimated_hours" and value is not None:
+                        # Format estimate as "Xh" or "Xd"
+                        hours = float(value)
+                        days = hours / 8.0
+                        if days >= 1:
+                            console.print(f"   estimate: {days:.1f}d", style="cyan")
+                        else:
+                            console.print(f"   estimate: {hours:.1f}h", style="cyan")
+                    else:
+                        # Format the field name nicely
+                        display_field = field.replace("_", " ").title()
+                        console.print(f"   {display_field}: {value}", style="cyan")
+
+
+class DeletePresenter(BasePresenter):
+    """Presenter for delete operation results."""
+
+    def render(self, entity: Any) -> None:
+        """Render deleted entity summary.
+
+        Args:
+            entity: The deleted entity object
+        """
+        console = self._get_console()
+        entity_type = _infer_entity_type(entity)
+        entity_id = _get_entity_id(entity)
+        title = _get_entity_title(entity)
+
+        console.print(
+            f"✅ Deleted {entity_type.lower()}: {title} [{entity_id}]",
+            style="green",
+        )

roadmap/adapters/cli/presentation/daily_summary_presenter.py

@@ -0,0 +1,266 @@
+"""Daily summary presenter for formatting and rendering output.
+
+Handles all display formatting for the daily summary, including
+table rendering and output styling.
+"""
+
+from datetime import UTC, datetime
+
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+from roadmap.adapters.cli.presentation.base_presenter import BasePresenter
+from roadmap.common.console import get_console
+
+console = get_console()
+
+
+class DailySummaryPresenter(BasePresenter):
+    """Presenter for daily summary output.
+
+    Handles formatting and rendering of daily summary data
+    including tables, panels, and styling.
+    """
+
+    def render(self, data: dict) -> None:
+        """Render complete daily summary to console.
+
+        Args:
+            data: Dictionary from DailySummaryService.get_daily_summary_data()
+        """
+        if not data["has_issues"]:
+            milestone = data["milestone"]
+            console.print(
+                f"✅ No issues assigned to you in [bold]{milestone.name}[/bold]",
+                style="green",
+            )
+            return
+
+        # Render header
+        self._render_header(data)
+
+        # Render sections
+        issues = data["issues"]
+        self._render_in_progress(issues["in_progress"])
+        self._render_overdue(issues["overdue"])
+        self._render_blocked(issues["blocked"])
+        self._render_up_next(issues["todo_high_priority"])
+        self._render_completed_today(issues["completed_today"])
+
+        # Render summary and tips
+        self._render_summary(issues)
+        self._render_tips(data)
+
+    @staticmethod
+    def _render_header(data: dict) -> None:
+        """Render daily summary header with user and milestone info."""
+        current_user = data["current_user"]
+        milestone = data["milestone"]
+
+        header = Text()
+        header.append("Daily Summary - ", style="dim")
+        header.append(current_user, style="bold cyan")
+        header.append("\nMilestone: ", style="dim")
+        header.append(milestone.name, style="bold yellow")
+
+        if milestone.due_date:
+            header.append(
+                f" (due {milestone.due_date.strftime('%Y-%m-%d')})",
+                style="dim",
+            )
+
+        header.append(f"\n{datetime.now(UTC).strftime('%A, %B %d, %Y')}", style="dim")
+
+        console.print(Panel(header, border_style="cyan"))
+
+    @staticmethod
+    def _render_in_progress(issues: list) -> None:
+        """Render in-progress issues section."""
+        if issues:
+            progress_table = Table(
+                show_header=True,
+                header_style="bold yellow",
+                title="🚀 In Progress",
+                title_style="bold yellow",
+            )
+            progress_table.add_column("ID", style="cyan", width=10)
+            progress_table.add_column("Title", style="white")
+            progress_table.add_column("Progress", width=12)
+            progress_table.add_column("Priority", width=10)
+
+            for issue in issues:
+                progress_table.add_row(
+                    issue.id,
+                    issue.title[:60] + "..." if len(issue.title) > 60 else issue.title,
+                    issue.progress_display,
+                    issue.priority.value,
+                )
+
+            console.print(progress_table)
+            console.print()
+        else:
+            console.print(
+                Panel(
+                    "[dim]No issues currently in progress[/dim]",
+                    title="🚀 In Progress",
+                    title_align="left",
+                    border_style="yellow",
+                )
+            )
+            console.print()
+
+    @staticmethod
+    def _render_overdue(issues: list) -> None:
+        """Render overdue issues section."""
+        if issues:
+            overdue_table = Table(
+                show_header=True,
+                header_style="bold red",
+                title="⚠️  Overdue",
+                title_style="bold red",
+            )
+            overdue_table.add_column("ID", style="cyan", width=10)
+            overdue_table.add_column("Title", style="white")
+            overdue_table.add_column("Due Date", width=12, style="red")
+            overdue_table.add_column("Priority", width=10)
+
+            for issue in issues:
+                due_date_obj = issue.due_date
+                # Normalize issue due_date to UTC-aware datetime
+                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
+                    )
+
+                days_overdue = (datetime.now(UTC) - due_date_aware).days
+                overdue_table.add_row(
+                    issue.id,
+                    issue.title[:50] + "..." if len(issue.title) > 50 else issue.title,
+                    f"{due_date_aware.strftime('%Y-%m-%d')} ({days_overdue}d)",
+                    issue.priority.value,
+                )
+
+            console.print(overdue_table)
+            console.print()
+
+    @staticmethod
+    def _render_blocked(issues: list) -> None:
+        """Render blocked issues section."""
+        if issues:
+            blocked_table = Table(
+                show_header=True,
+                header_style="bold red",
+                title="🚫 Blocked",
+                title_style="bold red",
+            )
+            blocked_table.add_column("ID", style="cyan", width=10)
+            blocked_table.add_column("Title", style="white")
+            blocked_table.add_column("Priority", width=10)
+
+            for issue in issues:
+                blocked_table.add_row(
+                    issue.id,
+                    issue.title[:60] + "..." if len(issue.title) > 60 else issue.title,
+                    issue.priority.value,
+                )
+
+            console.print(blocked_table)
+            console.print()
+
+    @staticmethod
+    def _render_up_next(issues: list) -> None:
+        """Render up next (high priority todos) section."""
+        if issues:
+            next_table = Table(
+                show_header=True,
+                header_style="bold blue",
+                title="📋 Up Next (High Priority)",
+                title_style="bold blue",
+            )
+            next_table.add_column("ID", style="cyan", width=10)
+            next_table.add_column("Title", style="white")
+            next_table.add_column("Priority", width=10)
+            next_table.add_column("Estimate", width=10)
+
+            for issue in issues:
+                priority_color = (
+                    "bold red" if issue.priority.value == "critical" else "red"
+                )
+                next_table.add_row(
+                    issue.id,
+                    issue.title[:55] + "..." if len(issue.title) > 55 else issue.title,
+                    f"[{priority_color}]{issue.priority.value}[/{priority_color}]",
+                    issue.estimated_time_display,
+                )
+
+            console.print(next_table)
+            console.print()
+
+    @staticmethod
+    def _render_completed_today(issues: list) -> None:
+        """Render completed today section."""
+        if issues:
+            done_table = Table(
+                show_header=True,
+                header_style="bold green",
+                title="✅ Completed Today",
+                title_style="bold green",
+            )
+            done_table.add_column("ID", style="cyan", width=10)
+            done_table.add_column("Title", style="white")
+            done_table.add_column("Completed", width=12)
+
+            for issue in issues:
+                done_table.add_row(
+                    issue.id,
+                    issue.title[:60] + "..." if len(issue.title) > 60 else issue.title,
+                    issue.actual_end_date.strftime("%H:%M"),
+                )
+
+            console.print(done_table)
+            console.print()
+
+    @staticmethod
+    def _render_summary(issues: dict) -> None:
+        """Render summary footer with counters."""
+        summary = Text()
+        summary.append("\n📊 Summary: ", style="bold")
+        summary.append(f"{len(issues['in_progress'])} in progress", style="yellow")
+        summary.append(" • ", style="dim")
+
+        overdue_style = "red" if issues["overdue"] else "dim"
+        summary.append(f"{len(issues['overdue'])} overdue", style=overdue_style)
+        summary.append(" • ", style="dim")
+
+        blocked_style = "red" if issues["blocked"] else "dim"
+        summary.append(f"{len(issues['blocked'])} blocked", style=blocked_style)
+        summary.append(" • ", style="dim")
+        summary.append(
+            f"{len(issues['completed_today'])} completed today", style="green"
+        )
+
+        console.print(summary)
+
+    @staticmethod
+    def _render_tips(data: dict) -> None:
+        """Render helpful tips based on data."""
+        issues = data["issues"]
+
+        if not issues["in_progress"] and issues["todo_high_priority"]:
+            issue = issues["todo_high_priority"][0]
+            console.print(
+                f"\n💡 Tip: Start work on an issue with: [cyan]roadmap issue start {issue.id}[/cyan]",
+                style="dim",
+            )
+        elif issues["overdue"]:
+            issue = issues["overdue"][0]
+            console.print(
+                f"\n💡 Tip: View overdue issue details with: [cyan]roadmap issue view {issue.id}[/cyan]",
+                style="dim",
+            )