roadmap-cli 0.1.1__py3-none-any.whl

roadmap/adapters/cli/layout.py

@@ -0,0 +1,220 @@
+"""Smart table layout system with responsive formatting.
+
+Automatically detects terminal width and switches to vertical layout
+when horizontal table is too wide.
+"""
+
+import shutil
+from dataclasses import dataclass
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from roadmap.common.models import TableData
+
+
+@dataclass
+class LayoutConfig:
+    """Configuration for smart table layouts."""
+
+    min_column_width: int = 15
+    max_horizontal_width: int = 120
+    vertical_threshold: float = (
+        0.8  # Switch to vertical if table > 80% of terminal width
+    )
+    responsive_enabled: bool = True
+
+
+class SmartTableLayout:
+    """Renders tables with responsive layout based on terminal width."""
+
+    def __init__(self, config: LayoutConfig | None = None):
+        """Initialize layout system.
+
+        Args:
+            config: Layout configuration
+        """
+        self.config = config or LayoutConfig()
+
+    def get_terminal_width(self) -> int:
+        """Get terminal width in columns.
+
+        Returns:
+            Terminal width, defaults to 80 if unable to detect
+        """
+        try:
+            width = shutil.get_terminal_size().columns
+            return max(width, 40)  # Minimum 40 columns
+        except Exception as e:
+            from roadmap.common.logging import get_logger
+
+            logger = get_logger(__name__)
+            logger.debug(
+                "terminal_width_detection_failed",
+                error=str(e),
+                action="get_terminal_width",
+            )
+            return 80  # Default fallback
+
+    def calculate_table_width(self, table_data: TableData) -> int:
+        """Calculate estimated table width based on column headers and data.
+
+        Args:
+            table_data: Table data to measure
+
+        Returns:
+            Estimated table width in columns
+        """
+        if not table_data.columns or not table_data.rows:
+            return 20
+
+        # Estimate based on column headers and sample data
+        total_width = 0
+        max_samples = min(5, len(table_data.rows))
+
+        for i, column in enumerate(table_data.columns):
+            # Start with header width
+            col_width = len(column.display_name) + 2
+
+            # Check sample data for this column
+            for row_idx in range(max_samples):
+                if row_idx < len(table_data.rows) and i < len(table_data.rows[row_idx]):
+                    value = table_data.rows[row_idx][i]
+                    col_width = max(col_width, len(str(value)))
+
+            # Add padding and separators
+            col_width = min(col_width + 2, 30)  # Cap at 30 per column
+            total_width += col_width
+
+        # Add separators and padding
+        total_width += len(table_data.columns) + 4
+
+        return total_width
+
+    def should_use_vertical_layout(self, table_data: TableData) -> bool:
+        """Determine if vertical layout should be used.
+
+        Args:
+            table_data: Table data to evaluate
+
+        Returns:
+            True if vertical layout is recommended
+        """
+        if not self.config.responsive_enabled:
+            return False
+
+        terminal_width = self.get_terminal_width()
+        table_width = self.calculate_table_width(table_data)
+
+        # Use vertical if table would take > threshold of terminal width
+        return table_width > (terminal_width * self.config.vertical_threshold)
+
+    def render_horizontal(self, table_data: TableData) -> Table:
+        """Render table in horizontal layout.
+
+        Args:
+            table_data: Table data to render
+
+        Returns:
+            Rich Table object
+        """
+        table = Table(
+            title=table_data.title,
+            show_header=True,
+            header_style="bold cyan",
+        )
+
+        # Add columns
+        for column in table_data.columns:
+            table.add_column(column.display_name, style=column.display_style or "")
+
+        # Add rows
+        for row in table_data.rows:
+            values = [str(val) if val is not None else "" for val in row]
+            table.add_row(*values)
+
+        return table
+
+    def render_vertical(self, table_data: TableData) -> Panel:
+        """Render table in vertical layout (one field per line).
+
+        Args:
+            table_data: Table data to render
+
+        Returns:
+            Rich Panel with vertical layout
+        """
+        from rich.text import Text
+
+        panels_content = []
+
+        for row_idx, row in enumerate(table_data.rows):
+            # Create header for this row
+            row_header = f"Entry {row_idx + 1}"
+
+            # Build content for this row
+            row_text = Text()
+            row_text.append(row_header + "\n", style="bold cyan")
+
+            for col_idx, column in enumerate(table_data.columns):
+                value = row[col_idx] if col_idx < len(row) else ""
+                row_text.append(f"  {column.display_name}: ", style="bold")
+                row_text.append(f"{value}\n")
+
+            panels_content.append(row_text)
+
+        # Combine all panels
+        combined = Text()
+        for i, text in enumerate(panels_content):
+            combined.append(text)
+            if i < len(panels_content) - 1:
+                combined.append("\n" + "─" * 40 + "\n\n")
+
+        return Panel(
+            combined,
+            title=table_data.title,
+            expand=False,
+        )
+
+    def render(self, table_data: TableData) -> Table | Panel:
+        """Render table with appropriate layout based on terminal width.
+
+        Args:
+            table_data: Table data to render
+
+        Returns:
+            Rich Table or Panel object
+        """
+        if self.should_use_vertical_layout(table_data):
+            return self.render_vertical(table_data)
+        else:
+            return self.render_horizontal(table_data)
+
+    def render_as_string(self, table_data: TableData, width: int | None = None) -> str:
+        """Render table to string representation.
+
+        Useful for testing and non-interactive environments.
+
+        Args:
+            table_data: Table data to render
+            width: Override terminal width
+
+        Returns:
+            String representation of table
+        """
+        # Temporarily override terminal width for testing
+        original_get_width = self.get_terminal_width
+        if width is not None:
+            self.get_terminal_width = lambda: width
+
+        try:
+            renderable = self.render(table_data)
+            from io import StringIO
+
+            string_io = StringIO()
+            temp_console = Console(file=string_io)
+            temp_console.print(renderable)
+            return string_io.getvalue()
+        finally:
+            self.get_terminal_width = original_get_width

roadmap/adapters/cli/mappers.py

@@ -0,0 +1,200 @@
+"""Mappers for converting between domain models and CLI DTOs.
+
+Mappers handle the conversion logic between domain models (internal representation)
+and DTOs (CLI presentation representation). They ensure DTOs don't leak domain
+implementation details.
+"""
+
+from roadmap.adapters.cli.dtos import CommentDTO, IssueDTO, MilestoneDTO, ProjectDTO
+from roadmap.core.domain.issue import Issue
+from roadmap.core.domain.milestone import Milestone
+from roadmap.core.domain.project import Project
+
+
+class IssueMapper:
+    """Maps between Issue domain model and IssueDTO."""
+
+    @staticmethod
+    def domain_to_dto(issue: Issue) -> IssueDTO:
+        """Convert domain Issue to CLI DTO.
+
+        Converts enums to strings and selects only CLI-relevant fields.
+
+        Args:
+            issue: Domain model Issue instance
+
+        Returns:
+            IssueDTO instance ready for CLI display
+        """
+        # Convert comments to DTOs
+        comments = []
+        if hasattr(issue, "comments") and issue.comments:
+            comments = [
+                CommentDTO(
+                    id=comment.id,
+                    author=comment.author,
+                    body=comment.body,
+                    created_at=comment.created_at,
+                    updated_at=comment.updated_at,
+                    in_reply_to=comment.in_reply_to,
+                )
+                for comment in issue.comments
+            ]
+
+        return IssueDTO(
+            id=issue.id,
+            title=issue.title,
+            headline=issue.headline or "",
+            priority=issue.priority.value,  # Convert enum to string
+            status=issue.status.value,  # Convert enum to string
+            issue_type=issue.issue_type.value,  # Convert enum to string
+            assignee=issue.assignee,
+            milestone=issue.milestone,
+            due_date=issue.due_date,
+            estimated_hours=issue.estimated_hours,
+            actual_end_date=issue.actual_end_date,
+            progress_percentage=issue.progress_percentage,
+            created=issue.created,
+            updated=issue.updated,
+            content=issue.content,
+            labels=issue.labels.copy() if issue.labels else [],
+            github_issue=str(issue.github_issue) if issue.github_issue else None,
+            comments=comments,
+        )
+
+    @staticmethod
+    def dto_to_domain(dto: IssueDTO) -> Issue:
+        """Convert CLI DTO to domain Issue.
+
+        Converts string fields back to appropriate enums.
+
+        Args:
+            dto: IssueDTO instance from CLI
+
+        Returns:
+            Domain model Issue instance
+        """
+        from roadmap.common.constants import IssueType, Priority, Status
+
+        return Issue(
+            id=dto.id,
+            title=dto.title,
+            headline=dto.headline or "",
+            priority=Priority(dto.priority),
+            status=Status(dto.status),
+            issue_type=IssueType(dto.issue_type),
+            assignee=dto.assignee,
+            milestone=dto.milestone,
+            due_date=dto.due_date,
+            estimated_hours=dto.estimated_hours,
+            actual_end_date=dto.actual_end_date,
+            progress_percentage=dto.progress_percentage,
+            content=dto.content or "",
+            labels=dto.labels.copy() if dto.labels else [],
+            remote_ids=(
+                {"github": int(dto.github_issue)}
+                if dto.github_issue and dto.github_issue.isdigit()
+                else {}
+            ),
+        )
+
+
+class MilestoneMapper:
+    """Maps between Milestone domain model and MilestoneDTO."""
+
+    @staticmethod
+    def domain_to_dto(milestone: Milestone) -> MilestoneDTO:
+        """Convert domain Milestone to CLI DTO.
+
+        Args:
+            milestone: Domain model Milestone instance
+
+        Returns:
+            MilestoneDTO instance ready for CLI display
+        """
+        return MilestoneDTO(
+            id=milestone.name,  # Use name as ID
+            name=milestone.name,
+            status=milestone.status.value,  # Convert enum to string
+            headline=milestone.headline or "",
+            due_date=milestone.due_date,
+            progress_percentage=milestone.calculated_progress,
+            created=milestone.created,
+            updated=milestone.updated,
+        )
+
+    @staticmethod
+    def dto_to_domain(dto: MilestoneDTO) -> Milestone:
+        """Convert CLI DTO to domain Milestone.
+
+        Args:
+            dto: MilestoneDTO instance from CLI
+
+        Returns:
+            Domain model Milestone instance
+        """
+        from roadmap.common.constants import MilestoneStatus
+
+        return Milestone(
+            name=dto.name,
+            headline=dto.headline or "",
+            status=MilestoneStatus(dto.status),
+            due_date=dto.due_date,
+            content="",
+        )
+
+
+class ProjectMapper:
+    """Maps between Project domain model and ProjectDTO."""
+
+    @staticmethod
+    def domain_to_dto(project: Project) -> ProjectDTO:
+        """Convert domain Project to CLI DTO.
+
+        Args:
+            project: Domain model Project instance
+
+        Returns:
+            ProjectDTO instance ready for CLI display
+        """
+        return ProjectDTO(
+            id=project.id,
+            name=project.name,
+            status=project.status.value,  # Convert enum to string
+            headline=project.headline or "",
+            owner=project.owner,
+            target_end_date=project.target_end_date,
+            actual_end_date=project.actual_end_date,
+            created=project.created,
+            updated=project.updated,
+        )
+
+    @staticmethod
+    def dto_to_domain(dto: ProjectDTO) -> Project:
+        """Convert CLI DTO to domain Project.
+
+        Args:
+            dto: ProjectDTO instance from CLI
+
+        Returns:
+            Domain model Project instance
+        """
+        from roadmap.common.constants import ProjectStatus
+
+        return Project(
+            id=dto.id,
+            name=dto.name,
+            headline=dto.headline or "",
+            status=ProjectStatus(dto.status),
+            content="",
+            owner=dto.owner,
+            target_end_date=dto.target_end_date,
+            actual_end_date=dto.actual_end_date,
+        )
+
+
+__all__ = [
+    "IssueMapper",
+    "MilestoneMapper",
+    "ProjectMapper",
+]

roadmap/adapters/cli/milestones/__init__.py

@@ -0,0 +1,52 @@
+"""Milestone commands module.
+
+Provides all milestone management commands:
+- create: Create a new milestone
+- list: List all milestones
+- assign: Assign an issue to a milestone
+- delete: Delete a milestone
+- close: Close a milestone
+- update: Update milestone properties
+- recalculate: Recalculate milestone progress
+- kanban: Display milestone in kanban board layout
+- view: View detailed information about a milestone
+- archive: Archive a milestone to .roadmap/archive/milestones/
+"""
+
+import click
+
+from roadmap.adapters.cli.milestones.archive import archive_milestone
+from roadmap.adapters.cli.milestones.assign import assign_milestone
+from roadmap.adapters.cli.milestones.close import close_milestone
+from roadmap.adapters.cli.milestones.create import create_milestone
+from roadmap.adapters.cli.milestones.delete import delete_milestone
+from roadmap.adapters.cli.milestones.kanban import milestone_kanban
+from roadmap.adapters.cli.milestones.list import list_milestones
+from roadmap.adapters.cli.milestones.recalculate import (
+    recalculate_milestone_progress,
+)
+from roadmap.adapters.cli.milestones.restore import restore_milestone
+from roadmap.adapters.cli.milestones.update import update_milestone
+from roadmap.adapters.cli.milestones.view import view_milestone
+
+
+@click.group()
+def milestone():
+    """Manage milestones."""
+    pass
+
+
+# Register all commands
+milestone.add_command(create_milestone, name="create")
+milestone.add_command(list_milestones, name="list")
+milestone.add_command(assign_milestone, name="assign")
+milestone.add_command(update_milestone, name="update")
+milestone.add_command(delete_milestone, name="delete")
+milestone.add_command(close_milestone, name="close")
+milestone.add_command(recalculate_milestone_progress, name="recalculate")
+milestone.add_command(milestone_kanban, name="kanban")
+milestone.add_command(view_milestone, name="view")
+milestone.add_command(archive_milestone, name="archive")
+milestone.add_command(restore_milestone, name="restore")
+
+__all__ = ["milestone"]

roadmap/adapters/cli/milestones/archive.py

@@ -0,0 +1,125 @@
+"""Archive milestone command - move closed milestones to archive."""
+
+import click
+
+from roadmap.adapters.cli.cli_command_helpers import require_initialized
+from roadmap.adapters.cli.milestones.archive_class import MilestoneArchive
+from roadmap.common.console import get_console
+from roadmap.common.logging import (
+    log_command,
+    verbose_output,
+)
+
+
+@click.command()
+@click.argument("milestone_name", required=False)
+@click.option(
+    "--all-closed",
+    is_flag=True,
+    help="Archive all closed milestones",
+)
+@click.option(
+    "--list",
+    "list_archived",
+    is_flag=True,
+    help="List archived milestones",
+)
+@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("milestone_archive", entity_type="milestone", track_duration=True)
+@require_initialized
+def archive_milestone(
+    ctx: click.Context,
+    milestone_name: str | None,
+    all_closed: bool,
+    list_archived: bool,
+    dry_run: bool,
+    force: bool,
+    verbose: bool,  # noqa: F841
+):
+    """Archive a milestone by moving it to .roadmap/archive/milestones/.
+
+    This is a non-destructive operation that preserves milestone data while
+    cleaning up the active workspace.
+
+    Examples:
+        roadmap milestone archive "v1.0"
+        roadmap milestone archive --all-closed
+        roadmap milestone archive --list
+    """
+    core = ctx.obj["core"]
+    console = get_console()
+
+    archive = MilestoneArchive(core, console)
+
+    if list_archived:
+        from pathlib import Path
+
+        from roadmap.adapters.persistence.parser import MilestoneParser
+
+        roadmap_dir = Path.cwd() / ".roadmap"
+        archive_dir = roadmap_dir / "archive" / "milestones"
+
+        if not archive_dir.exists():
+            console.print("📋 No archived milestones.", style="yellow")
+            return
+
+        archived_files = list(archive_dir.glob("*.md"))
+        if not archived_files:
+            console.print("📋 No archived milestones.", style="yellow")
+            return
+
+        console.print("\n📦 Archived Milestones:\n", style="bold blue")
+        for file_path in sorted(archived_files):
+            try:
+                milestone = MilestoneParser.parse_milestone_file(file_path)
+                console.print(
+                    f"  • {milestone.name} ({milestone.status.value})", style="cyan"
+                )
+            except Exception:
+                console.print(
+                    f"  • {file_path.name} (error reading file)", style="yellow"
+                )
+        return
+
+    # Validate arguments
+    if not milestone_name and not all_closed:
+        console.print(
+            "❌ Error: Specify a milestone name or use --all-closed",
+            style="bold red",
+        )
+        ctx.exit(1)
+
+    if milestone_name and all_closed:
+        console.print(
+            "❌ Error: Specify only one of: milestone name or --all-closed",
+            style="bold red",
+        )
+        ctx.exit(1)
+
+    try:
+        archive.execute(
+            entity_id=milestone_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)