roadmap-cli 0.1.1__py3-none-any.whl

roadmap/common/formatters/tables/project_table.py

@@ -0,0 +1,195 @@
+"""Project table formatting and display."""
+
+from typing import TYPE_CHECKING, Any, cast
+
+from roadmap.common.console import get_console
+from roadmap.common.formatters.base_table_formatter import BaseTableFormatter
+from roadmap.common.formatters.tables.column_factory import create_project_columns
+from roadmap.common.models import TableData
+
+if TYPE_CHECKING:
+    pass
+
+
+def _get_console():
+    """Get a fresh console instance for test compatibility."""
+    return get_console()
+
+
+class ProjectTableFormatter(BaseTableFormatter):
+    """Formats projects for display and structured output."""
+
+    def __init__(self):
+        """Initialize project formatter with headers and columns."""
+        super().__init__()
+        self.columns_config = [
+            {"name": "ID", "style": "cyan", "width": 10},
+            {"name": "Name", "style": "white", "width": 25},
+            {"name": "Headline", "style": "white", "width": 30},
+            {"name": "Status", "style": "magenta", "width": 12},
+            {"name": "Priority", "style": "yellow", "width": 10},
+            {"name": "Owner", "style": "green", "width": 15},
+        ]
+
+    def create_table(self) -> Any:
+        """Create a rich table with project columns."""
+        from rich.table import Table
+
+        table = Table(show_header=True, header_style="bold cyan")
+        for col in self.columns_config:
+            table.add_column(col["name"], style=col["style"], width=col["width"])
+        return table
+
+    def add_row(self, table: Any, item) -> None:
+        """Add a single project row to the table.
+
+        Args:
+            table: Rich Table object
+            item: Project object (dict or object) to add
+        """
+        from rich.text import Text
+
+        # Handle both dict and object formats
+        if isinstance(item, dict):
+            project_id = item.get("id", "unknown")[:8]
+            project_name = item.get("name", "Unnamed")
+            project_headline = item.get("headline", "")
+            project_status = item.get("status", "unknown")
+            project_priority = item.get("priority", "medium")
+            project_owner = item.get("owner", "Unassigned")
+        else:
+            # Handle Project object
+            project_id = getattr(item, "id", "unknown")[:8]
+            project_name = getattr(item, "name", "Unnamed")
+            project_headline = getattr(item, "headline", "")
+            raw_status = getattr(item, "status", "unknown")
+            project_status = (
+                str(cast(Any, raw_status).value)
+                if hasattr(raw_status, "value")
+                else str(raw_status)
+            )
+            raw_priority = getattr(item, "priority", "medium")
+            project_priority = (
+                str(cast(Any, raw_priority).value)
+                if hasattr(raw_priority, "value")
+                else str(raw_priority)
+            )
+            project_owner = getattr(item, "owner", "Unassigned")
+
+        table.add_row(
+            Text(project_id, style="cyan"),
+            Text(project_name, style="white"),
+            Text(project_headline or "", style="white"),
+            Text(str(project_status), style="magenta"),
+            Text(str(project_priority), style="yellow"),
+            Text(str(project_owner), style="green"),
+        )
+
+    def get_filter_description(self, items: list) -> str:
+        """Get human-readable description of filtered projects.
+
+        Args:
+            items: List of projects being displayed
+
+        Returns:
+            Description string (e.g., "5 active projects")
+        """
+        count = len(items)
+        return f"🎯 {count} project{'s' if count != 1 else ''}"
+
+    def display_items(self, items: list, filter_description: str = "all") -> None:
+        """Display projects in a formatted table.
+
+        Args:
+            items: List of project objects
+            filter_description: Description of filter applied
+        """
+        if not items:
+            _get_console().print(
+                f"🎯 No {filter_description} projects found.", style="yellow"
+            )
+            _get_console().print(
+                "Create one with: roadmap project create 'Project name'", style="dim"
+            )
+            return
+
+        # Display header with filter info
+        header_text = f"🎯 {len(items)} {filter_description} project{'s' if len(items) != 1 else ''}"
+        _get_console().print(header_text, style="bold cyan")
+        _get_console().print()
+
+        # Rich table display
+        table = self.create_table()
+        for item in items:
+            self.add_row(table, item)
+
+        _get_console().print(table)
+
+    def items_to_table_data(
+        self, items: list, title: str = "Projects", description: str = ""
+    ) -> TableData:
+        """Convert Project list to TableData for structured output.
+
+        Args:
+            items: List of project metadata dictionaries or Project objects.
+            title: Optional table title.
+            description: Optional filter description.
+
+        Returns:
+            TableData object ready for rendering in any format.
+        """
+        columns = create_project_columns()
+
+        rows = []
+        for project in items:
+            # Handle both dict and object formats
+            if isinstance(project, dict):
+                project_id = project.get("id", "unknown")[:8]
+                project_name = project.get("name", "Unnamed")
+                project_status = project.get("status", "unknown")
+                project_priority = project.get("priority", "medium")
+                project_owner = project.get("owner", "Unassigned")
+            else:
+                # Handle Project object
+                project_id = getattr(project, "id", "unknown")[:8]
+                project_name = getattr(project, "name", "Unnamed")
+                raw_status = getattr(project, "status", "unknown")
+                project_status = (
+                    str(cast(Any, raw_status).value)
+                    if hasattr(raw_status, "value")
+                    else str(raw_status)
+                )
+                raw_priority = getattr(project, "priority", "medium")
+                project_priority = (
+                    str(cast(Any, raw_priority).value)
+                    if hasattr(raw_priority, "value")
+                    else str(raw_priority)
+                )
+                project_owner = getattr(project, "owner", "Unassigned")
+
+            rows.append(
+                [
+                    project_id,
+                    project_name,
+                    project_status,
+                    project_priority,
+                    project_owner,
+                ]
+            )
+
+        return TableData(
+            columns=columns,
+            rows=rows,
+            title=title,
+            headline=description,
+            total_count=len(items),
+            returned_count=len(items),
+        )
+
+    # Backward compatibility methods (for existing code that uses static methods)
+    @staticmethod
+    def projects_to_table_data(
+        projects: list, title: str = "Projects", description: str = ""
+    ) -> TableData:
+        """Convert Project list to TableData for structured output (backward compatible)."""
+        return ProjectTableFormatter().items_to_table_data(projects, title, description)

roadmap/common/formatters/text/__init__.py

@@ -0,0 +1,57 @@
+"""Text module public API."""
+
+from .basic import (
+    _format_table_simple,
+    format_error,
+    format_header,
+    format_info,
+    format_json,
+    format_key_value_pairs,
+    format_list,
+    format_panel,
+    format_success,
+    format_table,
+    format_warning,
+    truncate_text,
+)
+from .display import format_display_list, format_display_pairs
+from .duration import format_count, format_duration
+from .operations import (
+    OperationFormatter,
+    format_entity_details,
+    format_list_items,
+    format_operation_failure,
+    format_operation_success,
+)
+from .status_badges import format_percentage, format_status_badge
+
+__all__ = [
+    # Basic formatting
+    "format_table",
+    "format_panel",
+    "format_header",
+    "format_success",
+    "format_error",
+    "format_warning",
+    "format_info",
+    "format_list",
+    "format_key_value_pairs",
+    "format_json",
+    "truncate_text",
+    "_format_table_simple",
+    # Status and badges
+    "format_status_badge",
+    "format_percentage",
+    # Duration and counts
+    "format_duration",
+    "format_count",
+    # Operations
+    "OperationFormatter",
+    "format_operation_success",
+    "format_operation_failure",
+    "format_entity_details",
+    "format_list_items",
+    # Display
+    "format_display_list",
+    "format_display_pairs",
+]

roadmap/common/formatters/text/basic.py

@@ -0,0 +1,217 @@
+"""Basic text formatting utilities for terminal display."""
+
+from typing import TYPE_CHECKING, Any, Optional
+
+import structlog
+from rich.text import Text
+
+logger = structlog.get_logger(__name__)
+
+if TYPE_CHECKING:
+    from rich.console import Console
+    from rich.panel import Panel
+
+
+def format_table(
+    title: str,
+    columns: list[str],
+    rows: list[tuple],
+    console_obj: Optional["Console"] = None,
+) -> str:
+    """Format data as a rich table for display.
+
+    Args:
+        title: Table title
+        columns: Column headers
+        rows: List of row tuples
+        console_obj: Optional console instance
+
+    Returns:
+        Formatted table as string
+    """
+    logger.debug(
+        "formatting_table", title=title, col_count=len(columns), row_count=len(rows)
+    )
+    try:
+        from rich.console import Console
+    except ImportError as e:
+        logger.debug("rich_import_failed", error=str(e))
+        # Fallback to simple formatting
+        return _format_table_simple(title, columns, rows)
+
+    if console_obj is None:
+        from rich.console import Console
+
+        console_obj = Console()
+
+    from rich.table import Table
+
+    table = Table(title=title)
+    for col in columns:
+        table.add_column(col)
+
+    for row in rows:
+        table.add_row(*[str(cell) for cell in row])
+
+    return str(table)
+
+
+def _format_table_simple(title: str, columns: list[str], rows: list[tuple]) -> str:
+    """Fallback simple table formatting without rich."""
+    logger.debug(
+        "formatting_table_simple",
+        title=title,
+        col_count=len(columns),
+        row_count=len(rows),
+    )
+    output = [f"\n{title}", "-" * len(title)]
+    output.append(" | ".join(columns))
+    output.append("-" * (sum(len(c) for c in columns) + len(columns) * 3 - 1))
+    for row in rows:
+        output.append(" | ".join(str(cell) for cell in row))
+    return "\n".join(output)
+
+
+def format_panel(
+    content: str,
+    title: str | None = None,
+    expand: bool = False,
+) -> "Panel":
+    """Format content in a rich panel.
+
+    Args:
+        content: Panel content
+        title: Optional panel title
+        expand: Whether to expand to console width
+
+    Returns:
+        Rich Panel object
+    """
+    logger.debug(
+        "formatting_panel", title=title, expand=expand, content_length=len(content)
+    )
+    from rich.panel import Panel
+
+    return Panel(content, title=title, expand=expand)
+
+
+def format_header(text: str, level: int = 1) -> Text:
+    """Format text as a header with styling.
+
+    Args:
+        text: Header text
+        level: Header level (1-3, controls styling)
+
+    Returns:
+        Styled Text object
+    """
+    logger.debug("formatting_header", text=text, level=level)
+    if level == 1:
+        return Text(text, style="bold cyan", justify="center")
+    elif level == 2:
+        return Text(text, style="bold blue")
+    else:
+        return Text(text, style="bold")
+
+
+def format_success(text: str) -> Text:
+    """Format text as a success message."""
+    logger.debug("formatting_success", text=text)
+    return Text(text, style="bold green")
+
+
+def format_error(text: str) -> Text:
+    """Format text as an error message."""
+    logger.debug("formatting_error", text=text)
+    return Text(text, style="bold red")
+
+
+def format_warning(text: str) -> Text:
+    """Format text as a warning message."""
+    logger.debug("formatting_warning", text=text)
+    return Text(text, style="bold yellow")
+
+
+def format_info(text: str) -> Text:
+    """Format text as info message."""
+    logger.debug("formatting_info", text=text)
+    return Text(text, style="bold cyan")
+
+
+def format_list(items: list[str], title: str | None = None) -> str:
+    """Format items as a bulleted list.
+
+    Args:
+        items: List of items to format
+        title: Optional list title
+
+    Returns:
+        Formatted list as string
+    """
+    logger.debug("formatting_list", item_count=len(items), title=title)
+    output = []
+    if title:
+        output.append(f"[bold]{title}[/bold]")
+    for item in items:
+        output.append(f"  • {item}")
+    return "\n".join(output)
+
+
+def format_key_value_pairs(pairs: dict[str, Any], title: str | None = None) -> str:
+    """Format key-value pairs for display.
+
+    Args:
+        pairs: Dictionary of key-value pairs
+        title: Optional title
+
+    Returns:
+        Formatted output as string
+    """
+    logger.debug("formatting_key_value_pairs", pair_count=len(pairs), title=title)
+    output = []
+    if title:
+        output.append(f"[bold]{title}[/bold]")
+
+    max_key_length = max(len(k) for k in pairs.keys()) if pairs else 0
+    for key, value in pairs.items():
+        output.append(f"  {key.ljust(max_key_length)}: {value}")
+
+    return "\n".join(output)
+
+
+def truncate_text(text: str, max_length: int = 50, suffix: str = "...") -> str:
+    """Truncate text to maximum length with optional suffix.
+
+    Args:
+        text: Text to truncate
+        max_length: Maximum length
+        suffix: Suffix to add if truncated
+
+    Returns:
+        Truncated text
+    """
+    logger.debug(
+        "truncating_text",
+        text_length=len(text),
+        max_length=max_length,
+        was_truncated=len(text) > max_length,
+    )
+    if len(text) <= max_length:
+        return text
+    return text[: max_length - len(suffix)] + suffix
+
+
+def format_json(data: Any, indent: int = 2) -> str:
+    """Format data as JSON.
+
+    Args:
+        data: Data to format
+        indent: JSON indentation level
+
+    Returns:
+        Formatted JSON string
+    """
+    logger.debug("formatting_json", data_type=type(data).__name__, indent=indent)
+    import json
+
+    return json.dumps(data, indent=indent, default=str)

roadmap/common/formatters/text/display.py

@@ -0,0 +1,42 @@
+"""Display formatting utilities for lists and panels."""
+
+from typing import Any
+
+
+def format_display_list(items: list[str], title: str | None = None) -> str:
+    """Format items as a bulleted list.
+
+    Args:
+        items: List of items to format
+        title: Optional list title
+
+    Returns:
+        Formatted list as string
+    """
+    output = []
+    if title:
+        output.append(f"[bold]{title}[/bold]")
+    for item in items:
+        output.append(f"  • {item}")
+    return "\n".join(output)
+
+
+def format_display_pairs(pairs: dict[str, Any], title: str | None = None) -> str:
+    """Format key-value pairs for display.
+
+    Args:
+        pairs: Dictionary of key-value pairs
+        title: Optional title
+
+    Returns:
+        Formatted output as string
+    """
+    output = []
+    if title:
+        output.append(f"[bold]{title}[/bold]")
+
+    max_key_length = max(len(k) for k in pairs.keys()) if pairs else 0
+    for key, value in pairs.items():
+        output.append(f"  {key.ljust(max_key_length)}: {value}")
+
+    return "\n".join(output)

roadmap/common/formatters/text/duration.py

@@ -0,0 +1,36 @@
+"""Duration and count formatting utilities."""
+
+
+def format_duration(seconds: float) -> str:
+    """Format duration in seconds to human-readable format.
+
+    Args:
+        seconds: Duration in seconds
+
+    Returns:
+        Formatted duration string
+    """
+    if seconds < 60:
+        return f"{int(seconds)}s"
+    elif seconds < 3600:
+        minutes = seconds / 60
+        return f"{minutes:.1f}m"
+    else:
+        hours = seconds / 3600
+        return f"{hours:.1f}h"
+
+
+def format_count(count: int, singular: str, plural: str | None = None) -> str:
+    """Format a count with proper singular/plural form.
+
+    Args:
+        count: The count
+        singular: Singular form
+        plural: Plural form (defaults to singular + 's')
+
+    Returns:
+        Formatted count string
+    """
+    if plural is None:
+        plural = f"{singular}s"
+    return f"{count} {singular if count == 1 else plural}"