roadmap-cli 0.1.1__py3-none-any.whl

roadmap/adapters/cli/projects/view.py

@@ -0,0 +1,157 @@
+"""View project command."""
+
+import click
+
+from roadmap.adapters.cli.cli_command_helpers import require_initialized
+from roadmap.adapters.cli.mappers import ProjectMapper
+from roadmap.adapters.cli.presentation.project_presenter import ProjectPresenter
+from roadmap.common.console import get_console
+
+
+def _extract_description_and_objectives(content):
+    """Extract description and objectives from project content."""
+    if not content:
+        return None, None
+
+    content_lines = content.split("\n")
+    description_lines = []
+    objectives_lines = []
+    in_objectives = False
+
+    for line in content_lines:
+        if "## Objectives" in line or "## objectives" in line.lower():
+            in_objectives = True
+            continue
+        elif in_objectives and line.startswith("## "):
+            in_objectives = False
+
+        if in_objectives:
+            objectives_lines.append(line)
+        elif not line.startswith("## "):
+            description_lines.append(line)
+
+    description = "\n".join(description_lines).strip() or None
+    objectives = "\n".join(objectives_lines).strip() or None
+
+    return description, objectives
+
+
+def _get_project_or_exit(ctx: click.Context, project_id: str):
+    """Fetch project by ID or exit with a user-facing error message."""
+    core = ctx.obj["core"]
+    project = core.projects.get(project_id)
+    if project:
+        return project
+
+    get_console().print(f"❌ Project '{project_id}' not found.", style="bold red")
+    get_console().print(
+        "\n💡 Tip: Use 'roadmap project list' to see all available projects.",
+        style="dim",
+    )
+    ctx.exit(1)
+
+
+def _build_project_milestone_data(core, project) -> tuple[list | None, dict | None]:
+    """Build milestone list and progress map for a project."""
+    if not project.milestones:
+        return None, None
+
+    all_milestones = core.milestones.list()
+    milestones = [m for m in all_milestones if m.name in project.milestones]
+    milestone_progress = {
+        milestone.name: core.milestones.get_progress(milestone.name)
+        for milestone in milestones
+    }
+    return milestones, milestone_progress
+
+
+def _build_effort_data(project) -> dict[str, float | int | None] | None:
+    """Build effort payload for presenter when estimate/actual values exist."""
+    if not (project.estimated_hours or project.actual_hours):
+        return None
+    return {
+        "estimated": project.estimated_hours,
+        "actual": project.actual_hours,
+    }
+
+
+def _build_comments_text(project) -> str | None:
+    """Build formatted comments text with threaded replies for display."""
+    if not project.comments:
+        return None
+
+    from roadmap.core.services.comment.comment_service import CommentService
+
+    threads = CommentService.build_comment_threads(project.comments)
+    chunks: list[str] = []
+
+    top_level_ids = sorted([key for key in threads.keys() if key is not None])
+    for top_level_id in top_level_ids:
+        for comment in threads.get(top_level_id, []):
+            chunks.append(CommentService.format_comment_for_display(comment, indent=0))
+            for reply in threads.get(comment.id, []):
+                chunks.append(
+                    CommentService.format_comment_for_display(reply, indent=1)
+                )
+            chunks.append("")
+
+    return "\n".join(chunks).rstrip() if chunks else None
+
+
+def _render_objectives_panel(objectives: str | None) -> None:
+    """Render objectives markdown panel when objectives are available."""
+    if not objectives:
+        return
+
+    from rich.markdown import Markdown
+    from rich.panel import Panel
+
+    get_console().print(
+        Panel(Markdown(objectives), title="✅ Objectives", border_style="green")
+    )
+
+
+@click.command("view")
+@click.argument("project_id")
+@click.pass_context
+@require_initialized
+def view_project(ctx: click.Context, project_id: str):
+    """Display detailed information about a specific project.
+
+    Shows complete project details including metadata, milestones,
+    objectives, and description in a formatted view.
+
+    Example:
+        roadmap project view abc123def
+    """
+    core = ctx.obj["core"]
+    project = _get_project_or_exit(ctx, project_id)
+
+    # Convert project to DTO
+    project_dto = ProjectMapper.domain_to_dto(project)
+
+    # Get milestones for display
+    milestones, milestone_progress = _build_project_milestone_data(core, project)
+
+    # Build effort data
+    effort_data = _build_effort_data(project)
+
+    # Extract description and objectives
+    description, objectives = _extract_description_and_objectives(project.content)
+    description_content = description
+
+    # Prepare comments if any
+    comments_text = _build_comments_text(project)
+
+    # Render using presenter
+    presenter = ProjectPresenter()
+    presenter.render(
+        project_dto,
+        milestones=milestones,
+        milestone_progress=milestone_progress,
+        description_content=description_content,
+        comments_text=comments_text,
+        effort_data=effort_data,
+    )
+
+    _render_objectives_panel(objectives)

roadmap/adapters/cli/services/__init__.py

@@ -0,0 +1 @@
+"""CLI services package."""

roadmap/adapters/cli/services/daily_summary_service.py

@@ -0,0 +1,313 @@
+"""Daily summary service for the 'today' command.
+
+Provides business logic for generating daily workflow summaries,
+including user identification, milestone selection, issue categorization,
+and data aggregation for display.
+"""
+
+import os
+from datetime import UTC, datetime
+from typing import Any
+
+from roadmap.common.constants import MilestoneStatus, Status
+from roadmap.common.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+class DailySummaryService:
+    """Service for generating daily workflow summaries.
+
+    Handles all business logic for the 'today' command, including:
+    - User identity resolution from config or environment
+    - Upcoming milestone selection
+    - Issue categorization and filtering
+    - Data aggregation for display
+    """
+
+    def __init__(self, core):
+        """Initialize daily summary service.
+
+        Args:
+            core: RoadmapCore instance for accessing data
+        """
+        self.core = core
+
+    def get_current_user(self) -> str | None:
+        """Get current user from config or environment.
+
+        Returns:
+            Current user name or None if not found
+        """
+        # Get user identity from config (single source of truth)
+        current_user = self.core.team.get_current_user()
+
+        if not current_user:
+            # Fallback to environment for testing
+            current_user = os.getenv("ROADMAP_USER")
+
+        return current_user
+
+    def get_upcoming_milestone(self) -> Any | None:
+        """Get the next upcoming milestone.
+
+        Filters open milestones and returns the one with the earliest due date.
+
+        Returns:
+            Milestone object or None if no open milestones exist
+        """
+        milestones = self.core.milestones.list()
+
+        # Filter open milestones and sort by due date
+        open_milestones = [m for m in milestones if m.status == MilestoneStatus.OPEN]
+
+        if not open_milestones:
+            return None
+
+        # Sort by due date (None dates last), get the first with a due date
+        sorted_milestones = sorted(
+            open_milestones,
+            key=lambda m: (m.due_date is None, m.due_date or datetime.max),
+        )
+
+        return sorted_milestones[0] if sorted_milestones else None
+
+    def _get_in_progress_issues(self, issues: list) -> list:
+        """Get issues currently in progress.
+
+        Args:
+            issues: List of issues to filter
+
+        Returns:
+            List of in-progress issues
+        """
+        return [i for i in issues if i.status == Status.IN_PROGRESS]
+
+    def _get_overdue_issues(self, issues: list) -> list:
+        """Get overdue issues that haven't been closed.
+
+        Args:
+            issues: List of issues to filter
+
+        Returns:
+            List of overdue issues
+        """
+        overdue = []
+        now = datetime.now(UTC)
+        for i in issues:
+            if not i.due_date or i.status == Status.CLOSED:
+                continue
+
+            due = i.due_date
+            if isinstance(due, datetime):
+                if due.tzinfo:
+                    due_aware = due.astimezone(UTC)
+                else:
+                    due_aware = due.replace(tzinfo=UTC)
+            else:
+                due_aware = datetime.fromisoformat(str(due)).replace(tzinfo=UTC)
+
+            if due_aware < now:
+                overdue.append(i)
+
+        return overdue
+
+    def _get_blocked_issues(self, issues: list) -> list:
+        """Get blocked issues.
+
+        Args:
+            issues: List of issues to filter
+
+        Returns:
+            List of blocked issues
+        """
+        return [i for i in issues if i.status == Status.BLOCKED]
+
+    def _get_high_priority_todos(self, issues: list) -> list:
+        """Get high-priority TODO issues (top 3).
+
+        Args:
+            issues: List of issues to filter
+
+        Returns:
+            List of up to 3 high-priority TODO issues
+        """
+        candidates = [
+            i
+            for i in issues
+            if i.status == Status.TODO and i.priority.value in ["critical", "high"]
+        ]
+
+        if not candidates:
+            return []
+
+        # Prioritize issues that unblock the largest downstream dependency chain.
+        # This helps "today" surface critical path blockers before standalone work.
+        active_issues = [i for i in issues if i.status != Status.CLOSED]
+        dependents_map: dict[str, list[str]] = {}
+        for issue in active_issues:
+            for dep_id in issue.depends_on or []:
+                dependents_map.setdefault(dep_id, []).append(issue.id)
+
+        depth_cache: dict[str, int] = {}
+
+        def dependency_depth(issue_id: str, visiting: set[str] | None = None) -> int:
+            if issue_id in depth_cache:
+                return depth_cache[issue_id]
+
+            visiting = visiting or set()
+            if issue_id in visiting:
+                # Cycle guard: don't recurse indefinitely; treat as no extra depth.
+                return 0
+
+            visiting.add(issue_id)
+            children = dependents_map.get(issue_id, [])
+            if not children:
+                depth = 0
+            else:
+                depth = 1 + max(dependency_depth(child, visiting) for child in children)
+            visiting.remove(issue_id)
+
+            depth_cache[issue_id] = depth
+            return depth
+
+        def sort_key(issue):
+            depth = dependency_depth(issue.id)
+            direct_dependents = len(dependents_map.get(issue.id, []))
+            critical_rank = 0 if issue.priority.value == "critical" else 1
+            return (-depth, -direct_dependents, critical_rank, issue.id)
+
+        return sorted(candidates, key=sort_key)[:3]
+
+    def _get_completed_today_issues(self, issues: list) -> list:
+        """Get issues closed today.
+
+        Args:
+            issues: List of issues to filter
+
+        Returns:
+            List of issues closed today
+        """
+        today = datetime.now(UTC).date()
+        return [
+            i
+            for i in issues
+            if i.status == Status.CLOSED
+            and i.actual_end_date
+            and i.actual_end_date.date() == today
+        ]
+
+    def categorize_issues(self, issues: list, current_user: str) -> dict[str, list]:
+        """Categorize issues by status and urgency.
+
+        Args:
+            issues: List of issues to categorize
+            current_user: Current user name for filtering
+
+        Returns:
+            Dictionary with keys: in_progress, overdue, blocked, todo_high_priority, completed_today
+        """
+        return {
+            "in_progress": self._get_in_progress_issues(issues),
+            "overdue": self._get_overdue_issues(issues),
+            "blocked": self._get_blocked_issues(issues),
+            "todo_high_priority": self._get_high_priority_todos(issues),
+            "completed_today": self._get_completed_today_issues(issues),
+        }
+
+    def get_daily_summary_data(self) -> dict[str, Any]:
+        """Get complete daily summary data.
+
+        Validates user and milestone, filters issues, categorizes them,
+        and returns all data needed for display.
+
+        Returns:
+            Dictionary with keys: current_user, milestone, issues (dict of categories)
+
+        Raises:
+            ValueError: If user not found or no upcoming milestones
+        """
+        # Get user identity
+        current_user = self.get_current_user()
+        if not current_user:
+            raise ValueError(
+                "No user configured. Initialize with 'roadmap init' or set ROADMAP_USER."
+            )
+
+        logger.debug("Current user", user=current_user)
+
+        # Get upcoming milestone
+        upcoming_milestone = self.get_upcoming_milestone()
+        if not upcoming_milestone:
+            raise ValueError("No upcoming milestones found.")
+
+        logger.debug("Upcoming milestone", milestone=upcoming_milestone.name)
+
+        # Get all issues
+        all_issues = self.core.issues.list()
+
+        # Filter: assigned to current user AND in upcoming milestone
+        my_milestone_issues = [
+            i
+            for i in all_issues
+            if i.assignee == current_user and i.milestone == upcoming_milestone.name
+        ]
+
+        if not my_milestone_issues:
+            logger.info(
+                "No issues assigned to user in upcoming milestone", user=current_user
+            )
+            return {
+                "current_user": current_user,
+                "milestone": upcoming_milestone,
+                "issues": {
+                    "in_progress": [],
+                    "overdue": [],
+                    "blocked": [],
+                    "todo_high_priority": [],
+                    "completed_today": [],
+                },
+                "has_issues": False,
+            }
+
+        # Categorize issues
+        categorized = self.categorize_issues(my_milestone_issues, current_user)
+
+        logger.info(
+            "Daily summary data prepared",
+            user=current_user,
+            milestone=upcoming_milestone.name,
+            in_progress=len(categorized["in_progress"]),
+            overdue=len(categorized["overdue"]),
+            blocked=len(categorized["blocked"]),
+            todo_high_priority=len(categorized["todo_high_priority"]),
+            completed_today=len(categorized["completed_today"]),
+        )
+
+        return {
+            "current_user": current_user,
+            "milestone": upcoming_milestone,
+            "issues": categorized,
+            "has_issues": True,
+        }
+
+    def get_next_action_suggestion(self, data: dict[str, Any]) -> str | None:
+        """Get helpful suggestion for next action based on data.
+
+        Args:
+            data: Dictionary from get_daily_summary_data()
+
+        Returns:
+            Suggestion string or None if no action recommended
+        """
+        issues = data["issues"]
+
+        if not issues["in_progress"] and issues["todo_high_priority"]:
+            issue = issues["todo_high_priority"][0]
+            return f"Start work on an issue with: roadmap issue start {issue.id}"
+
+        if issues["overdue"]:
+            issue = issues["overdue"][0]
+            return f"View overdue issue details with: roadmap issue view {issue.id}"
+
+        return None