roadmap-cli 0.1.1__py3-none-any.whl

roadmap/adapters/cli/presentation/project_presenter.py

@@ -0,0 +1,233 @@
+"""CLI presenter for Project DTOs."""
+
+from datetime import datetime
+
+from rich.markdown import Markdown
+from rich.panel import Panel
+from rich.text import Text
+
+from roadmap.adapters.cli.dtos import ProjectDTO
+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 STATUS_COLORS
+
+
+class ProjectPresenter(BasePresenter):
+    """Presenter for formatting and displaying Project DTOs."""
+
+    def render(
+        self,
+        project_dto: ProjectDTO,
+        milestones: list | None = None,
+        milestone_progress: dict | None = None,
+        description_content: str | None = None,
+        comments_text: str | None = None,
+        effort_data: dict | None = None,
+    ) -> None:
+        """Render a project DTO in detailed view.
+
+        Args:
+            project_dto: The ProjectDTO to render
+            milestones: Optional list of milestone objects to display
+            milestone_progress: Optional progress information dict
+            description_content: Optional content with description
+            comments_text: Optional formatted comments text
+            effort_data: Optional dict with 'estimated' and 'actual' hour counts
+        """
+        # Display header
+        header = self._build_project_header(project_dto)
+        self._get_console().print(Panel(header, border_style="cyan"))
+
+        # Display metadata
+        metadata = self._build_metadata_table(project_dto)
+        self._get_console().print(
+            Panel(metadata, title="📋 Details", border_style="blue")
+        )
+
+        # Display effort if provided
+        if effort_data:
+            effort = self._build_effort_table(effort_data)
+            if effort:
+                self._get_console().print(
+                    Panel(effort, title="⏱️ Effort", border_style="yellow")
+                )
+
+        # Display milestones if provided
+        if milestones:
+            self._display_milestones_panel(milestones, milestone_progress)
+
+        # Display description if provided
+        if description_content:
+            md = Markdown(description_content)
+            self._get_console().print(
+                Panel(md, title="📝 Description", border_style="white")
+            )
+
+        # 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: {project_dto.created} • Updated: {project_dto.updated}"
+        )
+        self._get_console().print(f"\n[dim]{metadata_footer}[/dim]")
+
+    def _build_project_header(self, project_dto: ProjectDTO) -> Text:
+        """Build header text with project name and status.
+
+        Args:
+            project_dto: The ProjectDTO to format
+
+        Returns:
+            Rich Text object with formatted header
+        """
+        status_colors = {
+            "planning": "blue",
+            "active": "green",
+            "on-hold": "yellow",
+            "completed": "bold green",
+            "cancelled": "red",
+        }
+        status_color = status_colors.get(project_dto.status, "white")
+
+        header = Text()
+        header.append(project_dto.name, style="bold white")
+        header.append("\n")
+        header.append(f"[{project_dto.status.upper()}]", style=f"bold {status_color}")
+
+        return header
+
+    def _build_metadata_table(self, project_dto: ProjectDTO):
+        """Build metadata table for project DTO.
+
+        Args:
+            project_dto: The ProjectDTO to format
+
+        Returns:
+            Rich Table with metadata rows
+        """
+        metadata = create_metadata_table()
+
+        metadata.add_row("Status", project_dto.status.upper())
+        metadata.add_row("Owner", project_dto.owner or "Unassigned")
+
+        if project_dto.headline:
+            metadata.add_row("Headline", project_dto.headline)
+
+        if isinstance(project_dto.target_end_date, datetime):
+            metadata.add_row(
+                "Target End Date", project_dto.target_end_date.strftime("%Y-%m-%d")
+            )
+        else:
+            metadata.add_row("Target End Date", "Not set")
+
+        if isinstance(project_dto.actual_end_date, datetime):
+            metadata.add_row(
+                "Actual End Date", project_dto.actual_end_date.strftime("%Y-%m-%d")
+            )
+
+        metadata.add_row("Milestones", str(project_dto.milestone_count))
+        metadata.add_row("Issues", str(project_dto.issue_count))
+
+        if isinstance(project_dto.created, datetime):
+            metadata.add_row("Created", project_dto.created.strftime("%Y-%m-%d %H:%M"))
+
+        if isinstance(project_dto.updated, datetime):
+            metadata.add_row("Updated", project_dto.updated.strftime("%Y-%m-%d %H:%M"))
+
+        return metadata
+
+    def _build_effort_table(self, effort_data: dict):
+        """Build effort/hours table if data exists.
+
+        Args:
+            effort_data: Dict with optional 'estimated' and 'actual' keys
+
+        Returns:
+            Rich Table with effort data or None if no data
+        """
+        if not (effort_data.get("estimated") or effort_data.get("actual")):
+            return None
+
+        effort = create_metadata_table()
+
+        if effort_data.get("estimated"):
+            estimated = effort_data["estimated"]
+            if estimated < 8:
+                estimated_display = f"{estimated:.1f}h"
+            else:
+                days = estimated / 8
+                estimated_display = f"{days:.1f}d ({estimated:.1f}h)"
+            effort.add_row("Estimated", estimated_display)
+
+        if effort_data.get("actual"):
+            actual = effort_data["actual"]
+            if actual < 8:
+                actual_display = f"{actual:.1f}h"
+            else:
+                days = actual / 8
+                actual_display = f"{days:.1f}d ({actual:.1f}h)"
+            effort.add_row("Actual", actual_display)
+
+        return effort
+
+    def _display_milestones_panel(
+        self, milestones: list, _progress: dict | None = None
+    ) -> None:
+        """Display milestones in a table panel.
+
+        Args:
+            milestones: List of milestone objects
+            _progress: Optional progress information dict (currently unused)
+        """
+        if not milestones:
+            self._get_console().print(
+                Panel(
+                    "[dim]No milestones assigned to this project[/dim]",
+                    title="🎯 Milestones",
+                    border_style="magenta",
+                )
+            )
+            return
+
+        columns = [
+            ("Name", "white", 25),
+            ("Status", None, 11),
+            ("Due Date", None, 11),
+            ("Progress", None, 10),
+        ]
+        milestones_table = create_list_table(columns)
+
+        for milestone in milestones[:10]:
+            status_color = STATUS_COLORS.get(milestone.status.value, "white")
+            due_date_str = (
+                milestone.due_date.strftime("%Y-%m-%d")
+                if hasattr(milestone.due_date, "strftime")
+                else "Not set"
+            )
+
+            milestones_table.add_row(
+                milestone.name,
+                f"[{status_color}]{milestone.status.value}[/{status_color}]",
+                due_date_str,
+                f"{milestone.progress_percentage}%",
+            )
+
+        title = (
+            f"🎯 Milestones (Showing 10 of {len(milestones)})"
+            if len(milestones) > 10
+            else "🎯 Milestones"
+        )
+        self._get_console().print(
+            Panel(milestones_table, title=title, border_style="magenta")
+        )

roadmap/adapters/cli/presentation/project_status_presenter.py

@@ -0,0 +1,186 @@
+"""Presentation layer for project status display logic.
+
+Handles all user-facing output:
+- Displaying milestone progress
+- Rendering issue status tables
+- Showing roadmap summaries
+- Formatting status information
+"""
+
+from rich.progress import BarColumn, Progress, TextColumn
+from rich.table import Table
+from rich.text import Text
+
+from roadmap.common.console import get_console
+from roadmap.core.domain import Status
+
+
+class MilestoneProgressPresenter:
+    """Presenter for milestone progress display."""
+
+    @staticmethod
+    def show_milestone_header() -> None:
+        """Display milestone section header."""
+        get_console().print("\n🎯 Milestones:", style="bold cyan")
+
+    @staticmethod
+    def show_milestone_progress(milestone_name: str, progress: dict) -> None:
+        """Display progress for a single milestone.
+
+        Args:
+            milestone_name: Name of the milestone
+            progress: Progress dictionary with 'total', 'completed', 'percentage'
+        """
+        console = get_console()
+        console.print(f"\n  {milestone_name}")
+
+        if progress.get("total", 0) > 0:
+            with Progress(
+                TextColumn("[progress.description]{task.description}"),
+                BarColumn(),
+                TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
+                console=console,
+                transient=True,
+            ) as progress_bar:
+                completed = progress.get("completed", 0)
+                total = progress.get("total", 0)
+                progress_bar.add_task(
+                    f"    Progress ({completed}/{total})",
+                    total=total,
+                    completed=completed,
+                )
+        else:
+            console.print("    No issues assigned", style="dim")
+
+    @staticmethod
+    def show_all_milestones(milestones: list, milestone_progress: dict) -> None:
+        """Display all milestones with progress.
+
+        Args:
+            milestones: List of milestone objects
+            milestone_progress: Dictionary mapping milestone name to progress
+        """
+        MilestoneProgressPresenter.show_milestone_header()
+        for milestone in milestones:
+            progress = milestone_progress.get(milestone.name, {})
+            MilestoneProgressPresenter.show_milestone_progress(milestone.name, progress)
+
+
+class IssueStatusPresenter:
+    """Presenter for issue status display."""
+
+    @staticmethod
+    def get_status_style(status: Status) -> str:
+        """Get display style for a status.
+
+        Args:
+            status: Status enum value
+
+        Returns:
+            Rich style string
+        """
+        styles = {
+            Status.TODO: "white",
+            Status.IN_PROGRESS: "yellow",
+            Status.BLOCKED: "red",
+            Status.REVIEW: "blue",
+            Status.CLOSED: "green",
+        }
+        return styles.get(status, "white")
+
+    @staticmethod
+    def show_issue_status_header() -> None:
+        """Display issue status section header."""
+        get_console().print("\n📋 Issues by Status:", style="bold cyan")
+
+    @staticmethod
+    def show_issue_status_table(issue_counts: dict) -> None:
+        """Display table of issue counts by status.
+
+        Args:
+            issue_counts: Dictionary mapping Status enum to count
+        """
+        console = get_console()
+        if not issue_counts or not any(issue_counts.values()):
+            console.print("  No issues found", style="dim")
+            return
+
+        status_table = Table(show_header=False, box=None)
+        status_table.add_column("Status", style="white", width=15)
+        status_table.add_column("Count", style="cyan", width=10)
+
+        for status in Status:
+            count = issue_counts.get(status, 0)
+            if count > 0:  # Only show statuses that have issues
+                style = IssueStatusPresenter.get_status_style(status)
+                status_table.add_row(
+                    Text(f"  {status.value}", style=style),
+                    str(count),
+                )
+
+        console.print(status_table)
+
+    @staticmethod
+    def show_all_issue_statuses(issue_counts: dict) -> None:
+        """Display all issue statuses with counts.
+
+        Args:
+            issue_counts: Dictionary mapping Status enum to count
+        """
+        IssueStatusPresenter.show_issue_status_header()
+        IssueStatusPresenter.show_issue_status_table(issue_counts)
+
+
+class RoadmapStatusPresenter:
+    """Presenter for overall roadmap status."""
+
+    @staticmethod
+    def show_empty_state() -> None:
+        """Display message when no issues or milestones exist."""
+        console = get_console()
+        console.print("\n📝 No issues or milestones found.", style="yellow")
+        console.print("Get started with:")
+        console.print("  roadmap issue create 'My first issue'")
+        console.print("  roadmap milestone create 'My first milestone'")
+
+    @staticmethod
+    def show_status_header() -> None:
+        """Display main status header."""
+        get_console().print("📊 Roadmap Status", style="bold blue")
+
+    @staticmethod
+    def show_roadmap_summary(summary: dict) -> None:
+        """Display comprehensive roadmap summary.
+
+        Args:
+            summary: Dictionary with roadmap summary data
+        """
+        console = get_console()
+        console.print("\n📈 Summary:", style="bold cyan")
+        console.print(
+            f"  Total Issues: {summary.get('total_issues', 0)}", style="white"
+        )
+        console.print(
+            f"  Active Issues: {summary.get('active_issues', 0)}", style="yellow"
+        )
+        blocked = summary.get("blocked_issues", 0)
+        if blocked > 0:
+            console.print(f"  Blocked Issues: {blocked}", style="red")
+        console.print(
+            f"  Total Milestones: {summary.get('total_milestones', 0)}", style="white"
+        )
+        completed = summary.get("completed_milestones", 0)
+        total = summary.get("total_milestones", 0)
+        if total > 0:
+            console.print(f"  Completed Milestones: {completed}/{total}", style="green")
+
+    @staticmethod
+    def show_error(error_message: str) -> None:
+        """Display error message.
+
+        Args:
+            error_message: Error message to display
+        """
+        get_console().print(
+            f"❌ Failed to show status: {error_message}", style="bold red"
+        )

roadmap/adapters/cli/presentation/table_builders.py

@@ -0,0 +1,95 @@
+"""Table and panel builders for consistent display formatting.
+
+This module provides reusable Rich table and panel construction patterns for entity display:
+- Two-column metadata tables (Key-Value format)
+- Status and progress tables
+- Panel creation with standard borders and styles
+- Custom table styling
+
+Consolidates duplicated table construction logic across view.py files.
+"""
+
+from typing import Any
+
+from rich.panel import Panel  # type: ignore[import-not-found]
+from rich.table import Table  # type: ignore[import-not-found]
+
+# ===== Generic Table Builders =====
+
+
+def create_metadata_table() -> Table:
+    """Create standard 2-column metadata table (Key-Value format).
+
+    Returns:
+        Rich Table configured with standard metadata layout
+    """
+    table = Table(show_header=False, box=None, padding=(0, 2))
+    table.add_column("Key", style="dim")
+    table.add_column("Value")
+    return table
+
+
+def create_list_table(
+    columns: list[tuple[str, str | None, int | None]] | None = None,
+) -> Table:
+    """Create table for list display with custom columns.
+
+    Args:
+        columns: List of (name, style, width) tuples for columns.
+                 If None, creates basic 2-column table.
+
+    Returns:
+        Rich Table configured for list display
+    """
+    table = Table(show_header=True, box=None, padding=(0, 1))
+
+    if columns is None:
+        table.add_column("ID", style="cyan", width=9)
+        table.add_column("Title", style="white")
+    else:
+        for col_name, col_style, col_width in columns:
+            kwargs: dict[str, Any] = {}
+            if col_style:
+                kwargs["style"] = col_style
+            if col_width:
+                kwargs["width"] = col_width
+            table.add_column(col_name, **kwargs)
+
+    return table
+
+
+# ===== Progress Display =====
+
+
+# ===== Panel Creation =====
+
+
+def create_panel(
+    content: Any,
+    title: str | None = None,
+    emoji: str | None = None,
+    border_style: str = "white",
+) -> Panel:
+    """Create standard panel with configurable title and border.
+
+    Args:
+        content: Content to display in panel (Table, Text, Markdown, etc.)
+        title: Optional panel title
+        emoji: Optional emoji to prepend to title
+        border_style: Border color (default: white)
+
+    Returns:
+        Rich Panel
+    """
+    full_title = None
+    if title:
+        full_title = f"{emoji} {title}" if emoji else title
+
+    return Panel(
+        content,
+        title=full_title,
+        border_style=border_style,
+    )
+
+
+# ===== Text Builders =====

roadmap/adapters/cli/projects/__init__.py

@@ -0,0 +1,42 @@
+"""Project commands module.
+
+Provides all project management commands:
+- create: Create a new project
+- list: List all projects with optional filtering
+- delete: Delete a project
+- view: View detailed information about a project
+- update: Update project properties
+- close: Close a completed project
+- archive: Archive a completed project
+- restore: Restore an archived project
+"""
+
+import click
+
+from roadmap.adapters.cli.projects.archive import archive_project
+from roadmap.adapters.cli.projects.close import close_project
+from roadmap.adapters.cli.projects.create import create_project
+from roadmap.adapters.cli.projects.delete import delete_project
+from roadmap.adapters.cli.projects.list import list_projects
+from roadmap.adapters.cli.projects.restore import restore_project
+from roadmap.adapters.cli.projects.update import update_project
+from roadmap.adapters.cli.projects.view import view_project
+
+
+@click.group()
+def project():
+    """Manage projects (top-level planning documents)."""
+    pass
+
+
+# Register all commands
+project.add_command(create_project, name="create")
+project.add_command(list_projects, name="list")
+project.add_command(update_project, name="update")
+project.add_command(delete_project, name="delete")
+project.add_command(view_project, name="view")
+project.add_command(close_project, name="close")
+project.add_command(archive_project, name="archive")
+project.add_command(restore_project, name="restore")
+
+__all__ = ["project"]

roadmap/adapters/cli/projects/archive.py

@@ -0,0 +1,127 @@
+"""Archive project command - move completed projects to archive."""
+
+import click
+
+from roadmap.adapters.cli.cli_command_helpers import require_initialized
+from roadmap.adapters.cli.projects.archive_class import ProjectArchive
+from roadmap.common.console import get_console
+from roadmap.common.logging import (
+    log_command,
+    verbose_output,
+)
+
+
+@click.command()
+@click.argument("project_name", required=False)
+@click.option(
+    "--all-closed",
+    is_flag=True,
+    help="Archive all closed projects",
+)
+@click.option(
+    "--list",
+    "list_archived",
+    is_flag=True,
+    help="List archived projects",
+)
+@click.option(
+    "--dry-run",
+    is_flag=True,
+    help="Preview what would be archived without actually doing it",
+)
+@click.option(
+    "--force",
+    is_flag=True,
+    help="Skip confirmation prompt",
+)
+@click.option(
+    "--verbose",
+    "-v",
+    is_flag=True,
+    help="Show detailed debug information",
+)
+@click.pass_context
+@verbose_output
+@log_command("project_archive", entity_type="project", track_duration=True)
+@require_initialized
+def archive_project(
+    ctx: click.Context,
+    project_name: str | None,
+    all_closed: bool,
+    list_archived: bool,
+    dry_run: bool,
+    force: bool,
+    verbose: bool,  # noqa: F841
+):
+    """Archive a project by moving it to .roadmap/archive/projects/.
+
+    This is a non-destructive operation that preserves project data while
+    cleaning up the active workspace.
+
+    Examples:
+        roadmap project archive "Project Name"
+        roadmap project archive --all-closed
+        roadmap project archive --list
+    """
+    core = ctx.obj["core"]
+    console = get_console()
+
+    archive = ProjectArchive(core, console)
+
+    if list_archived:
+        from pathlib import Path
+
+        from roadmap.adapters.cli.crud.crud_helpers import (
+            EntityType,
+            collect_archive_files,
+        )
+        from roadmap.adapters.persistence.parser import ProjectParser
+
+        roadmap_dir = Path.cwd() / ".roadmap"
+        archive_dir = roadmap_dir / "archive" / "projects"
+
+        if not archive_dir.exists():
+            console.print("📋 No archived projects.", style="yellow")
+            return
+
+        archived_files = collect_archive_files(archive_dir, EntityType.PROJECT)
+        if not archived_files:
+            console.print("📋 No archived projects.", style="yellow")
+            return
+
+        console.print("\n📦 Archived Projects:\n", style="bold blue")
+        for file_path in sorted(archived_files):
+            try:
+                project = ProjectParser.parse_project_file(file_path)
+                console.print(f"  • {project.name} ({project.status})", style="cyan")
+            except Exception:
+                console.print(
+                    f"  • {file_path.name} (error reading file)", style="yellow"
+                )
+        return
+
+    # Validate arguments
+    if not project_name and not all_closed:
+        console.print(
+            "❌ Error: Specify a project name or use --all-closed",
+            style="bold red",
+        )
+        ctx.exit(1)
+
+    if project_name and all_closed:
+        console.print(
+            "❌ Error: Specify only one of: project name or --all-closed",
+            style="bold red",
+        )
+        ctx.exit(1)
+
+    try:
+        archive.execute(
+            entity_id=project_name,
+            all_closed=all_closed,
+            dry_run=dry_run,
+            force=force,
+        )
+    except Exception as e:
+        console.print(f"❌ Archive operation failed: {str(e)}", style="bold red")
+        ctx.exit(1)