roadmap-cli 0.1.1__py3-none-any.whl

roadmap/adapters/cli/milestones/kanban.py

@@ -0,0 +1,123 @@
+"""Milestone kanban board command."""
+
+import click
+
+from roadmap.adapters.cli.cli_command_helpers import require_initialized
+from roadmap.common.console import get_console
+from roadmap.common.formatters import KanbanLayout, KanbanOrganizer
+
+console = get_console()
+
+
+@click.command("kanban")
+@click.argument("milestone_name")
+@click.option("--compact", is_flag=True, help="Compact view with less spacing")
+@click.option("--no-color", is_flag=True, help="Disable color coding")
+@click.pass_context
+@require_initialized
+def milestone_kanban(
+    ctx: click.Context, milestone_name: str, compact: bool, no_color: bool
+):
+    """Display milestone issues in a kanban board layout."""
+    core = ctx.obj["core"]
+
+    try:
+        # Get milestone
+        milestone = core.milestones.get(milestone_name)
+        if not milestone:
+            console.print(
+                f"❌ Milestone '{milestone_name}' not found", style="bold red"
+            )
+            return
+
+        # Get all issues for this milestone
+        all_issues = core.issues.list()
+        milestone_issues = [
+            issue for issue in all_issues if issue.milestone == milestone_name
+        ]
+
+        if not milestone_issues:
+            console.print(
+                f"📋 No issues found for milestone '{milestone_name}'", style="yellow"
+            )
+            console.print(
+                "Create issues with: roadmap issue create 'Issue title' --milestone <milestone>",
+                style="dim",
+            )
+            return
+
+        # Organize into categories
+        categories = KanbanOrganizer.categorize_issues(milestone_issues)
+        columns = KanbanOrganizer.create_column_definitions(categories, no_color)
+
+        # Display kanban board
+        _display_header(milestone, milestone_issues)
+        _display_board(
+            columns,
+            compact,
+            col_width=KanbanLayout.calculate_column_width(len(columns)),
+        )
+        _display_summary(categories)
+
+    except Exception as e:
+        console.print(f"❌ Failed to display kanban board: {e}", style="bold red")
+
+
+def _display_header(milestone, milestone_issues):
+    """Display board header with milestone info."""
+    console.print(f"\n🎯 Kanban Board: {milestone.name}", style="bold blue")
+    console.print(
+        f"📅 Due: {milestone.due_date.strftime('%Y-%m-%d') if milestone.due_date else 'No due date'}"
+    )
+    done_count = sum(1 for i in milestone_issues if i.status.value == "closed")
+    console.print(
+        f"📊 Progress: {done_count}/{len(milestone_issues)} issues completed\n"
+    )
+
+
+def _display_board(columns, compact: bool, col_width: int):
+    """Display the kanban board columns."""
+    # Print column headers
+    header_line = ""
+    separator_line = ""
+    for title, _issues, _style in columns:
+        header_line += f"{title:<{col_width}}"
+        separator_line += "─" * col_width
+
+    console.print(header_line, style="bold")
+    console.print(separator_line, style="dim")
+
+    # Print rows
+    max_issues = max(len(issues) for _, issues, _ in columns) if columns else 0
+    for row in range(max_issues):
+        row_line = ""
+        for _title, issues, _style in columns:
+            if row < len(issues):
+                issue = issues[row]
+                # Format issue card
+                title_space = col_width - 12  # Space for ID and padding
+                display_title = issue.title
+                if len(display_title) > title_space:
+                    display_title = display_title[: title_space - 3] + "..."
+                card_text = f"#{issue.id[:8]} {display_title}"
+                row_line += f"{card_text:<{col_width}}"
+            else:
+                row_line += " " * col_width
+
+        console.print(row_line)
+
+        if not compact:
+            # Add spacing between cards
+            if row < max_issues - 1:
+                console.print("")
+
+
+def _display_summary(categories: dict):
+    """Display summary statistics."""
+    console.print("\n📈 Summary:")
+    console.print(
+        f"   Overdue: {len(categories['overdue'])} | Blocked: {len(categories['blocked'])} | In Progress: {len(categories['in_progress'])}"
+    )
+    console.print(
+        f"   Not Started: {len(categories['not_started'])} | Done: {len(categories['closed'])}"
+    )

roadmap/adapters/cli/milestones/list.py

@@ -0,0 +1,87 @@
+"""List milestones command."""
+
+import click
+
+from roadmap.adapters.cli.cli_command_helpers import require_initialized
+from roadmap.adapters.cli.cli_error_handlers import handle_cli_error
+from roadmap.adapters.cli.decorators import with_output_support
+from roadmap.adapters.cli.services.milestone_list_service import MilestoneListService
+from roadmap.common.console import get_console
+from roadmap.common.formatters import MilestoneTableFormatter
+from roadmap.common.logging import verbose_output
+from roadmap.common.models import ColumnType
+
+
+def _get_console():
+    """Get console instance at runtime to respect Click's test environment."""
+    return get_console()
+
+
+@click.command("list")
+@click.option("--overdue", is_flag=True, help="Show only overdue milestones")
+@click.pass_context
+@with_output_support(
+    available_columns=[
+        "name",
+        "description",
+        "status",
+        "due_date",
+        "progress",
+        "estimate",
+    ],
+    column_types={
+        "name": ColumnType.STRING,
+        "description": ColumnType.STRING,
+        "status": ColumnType.ENUM,
+        "due_date": ColumnType.DATE,
+        "progress": ColumnType.STRING,
+        "estimate": ColumnType.STRING,
+    },
+)
+@require_initialized
+@verbose_output
+def list_milestones(ctx: click.Context, overdue: bool):
+    """List all milestones.
+
+    Supports output formatting with --format, --columns, --sort-by, --filter flags.
+    """
+    core = ctx.obj["core"]
+
+    try:
+        # Use MilestoneListService to get and filter milestones
+        service = MilestoneListService(core)
+        milestones_data = service.get_milestones_list_data(overdue_only=overdue)
+
+        # Extract milestone list from service response
+        milestone_list = milestones_data.get("milestones", [])
+
+        # Handle empty result
+        if not milestone_list:
+            _get_console().print("📋 No milestones found.", style="yellow")
+            _get_console().print(
+                "Create one with: roadmap milestone create 'Milestone name' --due-date YYYY-MM-DD",
+                style="dim",
+            )
+            return
+
+        # Convert to TableData for structured output
+        description = "overdue" if overdue else "all"
+        table_data = MilestoneTableFormatter.milestones_to_table_data(
+            milestone_list,
+            title="Milestones",
+            description=description,
+            estimates=milestones_data.get("estimates", {}),
+        )
+
+        return table_data
+
+    except Exception as e:
+        handle_cli_error(
+            error=e,
+            operation="list_milestones",
+            entity_type="milestone",
+            entity_id="all",
+            context={"overdue": overdue},
+            fatal=True,
+        )
+        _get_console().print(f"❌ Error listing milestones: {str(e)}", style="bold red")

roadmap/adapters/cli/milestones/recalculate.py

@@ -0,0 +1,79 @@
+"""Recalculate milestone progress command."""
+
+import click
+
+from roadmap.common.console import get_console
+
+console = get_console()
+
+
+@click.command("recalculate")
+@click.argument("milestone_name", required=False)
+@click.option(
+    "--method",
+    type=click.Choice(["effort_weighted", "count_based"]),
+    default="effort_weighted",
+    help="Calculation method",
+)
+@click.pass_context
+def recalculate_milestone_progress(
+    ctx: click.Context, milestone_name: str, method: str
+):
+    """Recalculate progress for a milestone or all milestones."""
+    core = ctx.obj["core"]
+
+    try:
+        # Import the progress engine
+        from roadmap.common.progress import ProgressCalculationEngine
+
+        # Load all data
+        all_issues = core.issues.list()
+        all_milestones = core.milestones.list()
+
+        # Create progress engine
+        engine = ProgressCalculationEngine(method=method)
+
+        if milestone_name:
+            # Recalculate specific milestone
+            milestone = core.milestones.get(milestone_name)
+            if not milestone:
+                console.print(
+                    f"❌ Milestone '{milestone_name}' not found", style="bold red"
+                )
+                return
+
+            old_progress = milestone.calculated_progress
+            updated = engine.update_milestone_progress(milestone, all_issues)
+
+            if updated:
+                # Save the updated milestone (needs to be implemented properly)
+                console.print(
+                    f"✅ Updated milestone '{milestone_name}':", style="bold green"
+                )
+                console.print(
+                    f"   Progress: {old_progress or 0:.1f}% → {milestone.calculated_progress:.1f}%"
+                )
+                console.print(f"   Status: {milestone.status}")
+                console.print(f"   Method: {method}")
+            else:
+                console.print(
+                    f"ℹ️  Milestone '{milestone_name}' progress unchanged", style="blue"
+                )
+                console.print(
+                    f"   Current progress: {milestone.calculated_progress or 0:.1f}%"
+                )
+        else:
+            # Recalculate all milestones
+            updated_count = 0
+            for milestone in all_milestones:
+                if engine.update_milestone_progress(milestone, all_issues):
+                    updated_count += 1
+
+            console.print("✅ Recalculation complete:", style="bold green")
+            console.print(
+                f"   {updated_count}/{len(all_milestones)} milestones updated"
+            )
+            console.print(f"   Method: {method}")
+
+    except Exception as e:
+        console.print(f"❌ Failed to recalculate progress: {e}", style="bold red")

roadmap/adapters/cli/milestones/restore.py

@@ -0,0 +1,87 @@
+"""Restore milestone command - move archived milestones back to active."""
+
+import click
+
+from roadmap.adapters.cli.cli_command_helpers import require_initialized
+from roadmap.adapters.cli.milestones.restore_class import MilestoneRestore
+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",
+    is_flag=True,
+    help="Restore all archived milestones",
+)
+@click.option(
+    "--dry-run",
+    is_flag=True,
+    help="Preview what would be restored 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_restore", entity_type="milestone", track_duration=True)
+@require_initialized
+def restore_milestone(
+    ctx: click.Context,
+    milestone_name: str | None,
+    all: bool,
+    dry_run: bool,
+    force: bool,
+    verbose: bool,  # noqa: F841
+):
+    """Restore an archived milestone back to active milestones.
+
+    This moves a milestone from .roadmap/archive/milestones/ back to
+    .roadmap/milestones/, making it active again.
+
+    Examples:
+        roadmap milestone restore "v1.0"
+        roadmap milestone restore --all
+        roadmap milestone restore "v1.0" --dry-run
+    """
+    core = ctx.obj["core"]
+    console = get_console()
+
+    restore = MilestoneRestore(core, console)
+
+    if not milestone_name and not all:
+        console.print(
+            "❌ Error: Specify a milestone name or use --all",
+            style="bold red",
+        )
+        ctx.exit(1)
+
+    if milestone_name and all:
+        console.print(
+            "❌ Error: Cannot specify milestone name with --all",
+            style="bold red",
+        )
+        ctx.exit(1)
+
+    try:
+        restore.execute(
+            entity_id=milestone_name,
+            all=all,
+            dry_run=dry_run,
+            force=force,
+        )
+    except Exception as e:
+        console.print(f"❌ Restore operation failed: {str(e)}", style="bold red")
+        ctx.exit(1)

roadmap/adapters/cli/milestones/restore_class.py

@@ -0,0 +1,99 @@
+"""MilestoneRestore command implementation using base class."""
+
+import shutil
+from pathlib import Path
+
+from roadmap.adapters.cli.crud import BaseRestore, EntityType
+from roadmap.adapters.persistence.parser import MilestoneParser
+
+
+class MilestoneRestore(BaseRestore):
+    """Restore milestone command implementation."""
+
+    entity_type = EntityType.MILESTONE
+
+    def get_archived_files_to_restore(
+        self,
+        entity_id: str | None = None,
+        **filters,  # noqa: ARG001
+    ) -> list[Path]:
+        """Get archived milestone files to restore.
+
+        Args:
+            entity_id: Specific milestone name to restore
+            **filters: Additional filter criteria
+
+        Returns:
+            List of archived file paths
+        """
+        from roadmap.adapters.cli.crud.crud_helpers import get_archive_dir
+
+        archive_dir = get_archive_dir(self.entity_type)
+
+        if not archive_dir.exists():
+            return []
+
+        if entity_id:
+            # Find specific milestone file by name
+            for md_file in archive_dir.glob("*.md"):
+                try:
+                    milestone = MilestoneParser.parse_milestone_file(md_file)
+                    if milestone.name == entity_id:
+                        return [md_file]
+                except Exception as e:
+                    from roadmap.common.logging import get_logger
+
+                    logger = get_logger(__name__)
+                    logger.debug(
+                        "milestone_parse_failed",
+                        file=str(md_file),
+                        error=str(e),
+                        action="find_restore_files",
+                    )
+                    continue
+            return []
+        else:
+            # Return all archived milestones
+            return list(archive_dir.glob("*.md"))
+
+    def post_restore_hook(self, restored_files: list[Path], **kwargs) -> None:
+        """Handle post-restore state updates.
+
+        Args:
+            restored_files: Files that were restored
+            **kwargs: Additional arguments
+        """
+        # Move associated issues folder back from archive
+        roadmap_dir = Path.cwd() / ".roadmap"
+
+        for file_path in restored_files:
+            try:
+                milestone = MilestoneParser.parse_milestone_file(file_path)
+                milestone_name = milestone.name
+
+                archive_issues_dir = roadmap_dir / "archive" / "issues" / milestone_name
+                if archive_issues_dir.exists():
+                    active_issues_dir = roadmap_dir / "issues" / milestone_name
+                    active_issues_dir.parent.mkdir(parents=True, exist_ok=True)
+
+                    try:
+                        shutil.move(str(archive_issues_dir), str(active_issues_dir))
+                    except Exception as e:
+                        self.console.print(
+                            f"⚠️  Warning: Failed to restore issues for milestone {milestone_name}: {e}",
+                            style="yellow",
+                        )
+
+                # Update database
+                try:
+                    self.core.db.mark_milestone_archived(milestone_name, archived=False)
+                except Exception as e:
+                    self.console.print(
+                        f"⚠️  Warning: Failed to update restoration status for {milestone_name}: {e}",
+                        style="yellow",
+                    )
+            except Exception as e:
+                self.console.print(
+                    f"⚠️  Failed to process milestone file {file_path.name}: {e}",
+                    style="yellow",
+                )

roadmap/adapters/cli/milestones/update.py

@@ -0,0 +1,61 @@
+"""Update milestone command."""
+
+import click
+
+from roadmap.adapters.cli.cli_command_helpers import require_initialized
+from roadmap.adapters.cli.crud import BaseUpdate, EntityType
+from roadmap.adapters.cli.crud.entity_builders import MilestoneBuilder
+from roadmap.common.logging import log_command
+
+
+class MilestoneUpdate(BaseUpdate):
+    """Update milestone command implementation."""
+
+    entity_type = EntityType.MILESTONE
+
+    def build_update_dict(self, entity_id: str, **kwargs) -> dict:
+        """Build update dictionary for milestone."""
+        return MilestoneBuilder.build_update_dict(
+            name=kwargs.get("name"),
+            description=kwargs.get("description"),
+            due_date=kwargs.get("due_date"),
+            status=kwargs.get("status"),
+            project_id=kwargs.get("project"),
+        )
+
+
+@click.command("update")
+@click.argument("milestone_id")
+@click.option("--name", help="Update milestone name")
+@click.option("--description", "-d", help="Update milestone description")
+@click.option("--due-date", help="Update due date (YYYY-MM-DD format)")
+@click.option(
+    "--status",
+    type=click.Choice(["open", "closed"]),
+    help="Set milestone status (open|closed)",
+)
+@click.option("--project", "-p", default=None, help="Project ID to assign milestone to")
+@click.pass_context
+@require_initialized
+@log_command("milestone_update", entity_type="milestone", track_duration=True)
+def update_milestone(
+    ctx: click.Context,
+    milestone_id: str,
+    name: str,
+    description: str,
+    due_date: str,
+    status: str,
+    project: str,
+):
+    """Update an existing milestone."""
+    core = ctx.obj["core"]
+    updater = MilestoneUpdate(core)
+
+    updater.execute(
+        entity_id=milestone_id,
+        name=name,
+        description=description,
+        due_date=due_date,
+        status=status,
+        project=project,
+    )

roadmap/adapters/cli/milestones/view.py

@@ -0,0 +1,142 @@
+"""View milestone command."""
+
+import click
+
+from roadmap.adapters.cli.cli_command_helpers import require_initialized
+from roadmap.adapters.cli.mappers import MilestoneMapper
+from roadmap.adapters.cli.presentation.milestone_presenter import MilestonePresenter
+from roadmap.common.console import get_console
+
+
+def _filter_milestone_issues(issues, status_filters, priority_filters, only_open):
+    """Filter milestone issues by status, priority, and open status."""
+    if not (status_filters or priority_filters or only_open):
+        return issues
+
+    status_lower = tuple(s.lower() for s in status_filters) if status_filters else ()
+    priority_lower = (
+        tuple(p.lower() for p in priority_filters) if priority_filters else ()
+    )
+
+    def matches_filters(issue):
+        if status_lower and issue.status.value not in status_lower:
+            return False
+        if priority_lower and issue.priority.value not in priority_lower:
+            return False
+        if only_open and issue.status.value == "closed":
+            return False
+        return True
+
+    return [issue for issue in issues if matches_filters(issue)]
+
+
+@click.command("view")
+@click.argument("milestone_name")
+@click.option(
+    "--status",
+    type=click.Choice(
+        ["todo", "in-progress", "blocked", "review", "closed"], case_sensitive=False
+    ),
+    multiple=True,
+    help="Filter issues by status (can specify multiple times)",
+)
+@click.option(
+    "--priority",
+    type=click.Choice(["critical", "high", "medium", "low"], case_sensitive=False),
+    multiple=True,
+    help="Filter issues by priority (can specify multiple times)",
+)
+@click.option(
+    "--only-open",
+    is_flag=True,
+    help="Show only open issues (excludes closed)",
+)
+@click.pass_context
+@require_initialized
+def view_milestone(
+    ctx: click.Context,
+    milestone_name: str,
+    status: tuple,
+    priority: tuple,
+    only_open: bool,
+):
+    """Display detailed information about a specific milestone.
+
+    Shows complete milestone details including progress, statistics,
+    issues breakdown, description, and goals in a formatted view.
+
+    Use --status and --priority to filter which issues are displayed.
+
+    Examples:
+        roadmap milestone view v.0.5.0
+        roadmap milestone view v.0.5.0 --status todo --status in-progress
+        roadmap milestone view v.0.5.0 --priority high --priority critical
+        roadmap milestone view v.0.5.0 --only-open
+    """
+    core = ctx.obj["core"]
+
+    milestone = core.milestones.get(milestone_name)
+    if not milestone:
+        get_console().print(
+            f"❌ Milestone '{milestone_name}' not found.", style="bold red"
+        )
+        get_console().print(
+            "\n💡 Tip: Use 'roadmap milestone list' to see all available milestones.",
+            style="dim",
+        )
+        ctx.exit(1)
+
+    # Convert milestone to DTO
+    milestone_dto = MilestoneMapper.domain_to_dto(milestone)
+
+    # Get milestone issues and filter
+    all_issues = core.issues.list()
+    milestone_issues = milestone.get_issues(all_issues)
+    milestone_issues = _filter_milestone_issues(
+        milestone_issues, status, priority, only_open
+    )
+
+    # Get progress data
+    progress_data = core.milestones.get_progress(milestone_name)
+
+    # Extract description and goals
+    description_content = milestone.content if milestone.content else None
+
+    # Prepare comments if any
+    comments_text = None
+    if milestone.comments:
+        from roadmap.core.services.comment.comment_service import CommentService
+
+        threads = CommentService.build_comment_threads(milestone.comments)
+        comment_text = ""
+
+        top_level_ids = [k for k in threads.keys() if k is not None]
+        for top_level_id in sorted(top_level_ids):
+            for comment in threads.get(top_level_id, []):
+                comment_text += (
+                    CommentService.format_comment_for_display(comment, indent=0) + "\n"
+                )
+
+                if comment.id in threads:
+                    for reply in threads[comment.id]:
+                        comment_text += (
+                            CommentService.format_comment_for_display(reply, indent=1)
+                            + "\n"
+                        )
+
+                comment_text += "\n"
+
+        comments_text = comment_text.rstrip()
+
+    # Render using presenter
+    presenter = MilestonePresenter()
+    presenter.render(
+        milestone_dto,
+        issues=milestone_issues if milestone_issues else None,
+        progress_data=progress_data,
+        description_content=description_content,
+        comments_text=comments_text,
+    )
+
+    # Display file info
+    get_console().print(f"[dim]File: .roadmap/milestones/{milestone.name}.md[/dim]")