roadmap-cli 0.1.1__py3-none-any.whl

roadmap/adapters/cli/issues/sync_status.py

@@ -0,0 +1,374 @@
+"""Sync status command - View sync history and statistics for GitHub-linked issues."""
+
+import sys
+
+import click
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+from roadmap.adapters.cli.cli_command_helpers import ensure_entity_exists
+from roadmap.common.console import get_console
+from roadmap.common.datetime_parser import UnifiedDateTimeParser
+from roadmap.core.services.sync.sync_metadata_service import SyncMetadataService
+
+
+def _get_console():
+    """Get a fresh console instance for test compatibility."""
+    return get_console()
+
+
+console = get_console()
+
+
+def _format_timestamp(iso_str: str) -> str:
+    """Format ISO timestamp to human-readable format."""
+    try:
+        dt = UnifiedDateTimeParser.parse_iso_datetime(iso_str)
+        if dt:
+            return dt.strftime("%Y-%m-%d %H:%M:%S")
+        return iso_str
+    except Exception as e:
+        from roadmap.common.logging import get_logger
+
+        logger = get_logger(__name__)
+        logger.debug(
+            "iso_datetime_format_failed",
+            iso_str=iso_str,
+            error=str(e),
+            action="format_iso_timestamp",
+        )
+        return iso_str
+
+
+def _build_sync_status_header(issue, metadata):
+    """Build header text with issue title and sync status."""
+    header = Text()
+    header.append(f"#{issue.id}", style="bold cyan")
+    header.append(" • ", style="dim")
+    header.append(issue.title, style="bold white")
+    header.append("\n")
+
+    # Add sync status
+    status_color_map = {
+        "success": "green",
+        "conflict": "yellow",
+        "error": "red",
+        "never": "dim",
+    }
+    status_color = status_color_map.get(metadata.last_sync_status, "white")
+    header.append(
+        f"[{metadata.last_sync_status.upper()}]", style=f"bold {status_color}"
+    )
+
+    if metadata.last_sync_time:
+        header.append(" • ", style="dim")
+        header.append(
+            f"Last synced: {_format_timestamp(metadata.last_sync_time)}",
+            style="dim",
+        )
+
+    return header
+
+
+def _build_sync_metadata_table(issue, metadata):
+    """Build metadata table showing sync statistics."""
+    table = Table(show_header=False, box=None, padding=(0, 1))
+
+    if metadata.github_issue_id:
+        table.add_row("GitHub Issue", f"#{metadata.github_issue_id}")
+
+    table.add_row("Total Syncs", str(metadata.sync_count))
+    table.add_row("Successful", str(metadata.successful_syncs))
+
+    if metadata.sync_count > 0:
+        success_rate = metadata.get_success_rate()
+        rate_color = (
+            "green"
+            if success_rate == 100
+            else "yellow"
+            if success_rate >= 75
+            else "red"
+        )
+        table.add_row(
+            "Success Rate", f"[{rate_color}]{success_rate:.1f}%[/{rate_color}]"
+        )
+
+        conflict_count = sum(
+            1 for record in metadata.sync_history if record.conflict_resolution
+        )
+        if conflict_count > 0:
+            table.add_row("Conflicts Resolved", str(conflict_count))
+
+    return table
+
+
+def _build_sync_history_table(records):
+    """Build table showing recent sync history."""
+    table = Table(
+        title="Sync History (Most Recent First)",
+        show_header=True,
+        header_style="bold cyan",
+    )
+
+    table.add_column("Time", style="dim", width=20)
+    table.add_column("Status", width=12)
+    table.add_column("Details", width=30)
+
+    for record in records:
+        time_str = _format_timestamp(record.sync_timestamp)
+
+        # Status
+        if record.success:
+            status_text = "[green]✓ SUCCESS[/green]"
+        elif record.conflict_resolution:
+            status_text = "[yellow]⚠ CONFLICT[/yellow]"
+        else:
+            status_text = "[red]✗ ERROR[/red]"
+
+        # Details
+        details_parts = []
+        if record.local_changes:
+            details_parts.append(f"Local: {len(record.local_changes)} changes")
+        if record.github_changes:
+            details_parts.append(f"GitHub: {len(record.github_changes)} changes")
+        if record.conflict_resolution:
+            details_parts.append(f"Resolved: {record.conflict_resolution}")
+        if record.error_message:
+            # Truncate long error messages
+            error = record.error_message
+            if len(error) > 40:
+                error = error[:37] + "..."
+            details_parts.append(f"Error: {error}")
+
+        details_text = " • ".join(details_parts) if details_parts else "—"
+
+        table.add_row(time_str, status_text, details_text)
+
+    return table
+
+
+def _build_aggregate_stats_table(stats):
+    """Build table showing aggregate statistics across issues."""
+    table = Table(show_header=False, box=None, padding=(0, 1))
+
+    table.add_row("Total Issues", str(stats["total_issues"]))
+    table.add_row("Total Sync Attempts", str(stats["total_sync_attempts"]))
+    table.add_row("Successful Syncs", str(stats["successful_syncs"]))
+
+    if stats["total_sync_attempts"] > 0:
+        rate_color = (
+            "green"
+            if stats["success_rate"] == 100
+            else "yellow"
+            if stats["success_rate"] >= 75
+            else "red"
+        )
+        table.add_row(
+            "Overall Success Rate",
+            f"[{rate_color}]{stats['success_rate']:.1f}%[/{rate_color}]",
+        )
+
+        if stats["total_conflicts"] > 0:
+            conflict_color = (
+                "green"
+                if stats["conflict_rate"] < 5
+                else "yellow"
+                if stats["conflict_rate"] < 20
+                else "red"
+            )
+            table.add_row(
+                "Conflict Rate",
+                f"[{conflict_color}]{stats['conflict_rate']:.1f}%[/{conflict_color}]",
+            )
+
+    table.add_row("Never Synced", str(stats["never_synced"]))
+
+    return table
+
+
+def _handle_sync_statistics(
+    core, console_inst, metadata_service: "SyncMetadataService"
+) -> None:
+    """Display aggregate sync statistics across all GitHub-linked issues."""
+    all_issues = core.issues.all()
+    github_issues = [i for i in all_issues if getattr(i, "github_issue", None)]
+    if not github_issues:
+        console_inst.print("[yellow]⚠️  No GitHub-linked issues found[/yellow]")
+        return
+    stats = metadata_service.get_statistics(github_issues)
+    panel = Panel(
+        _build_aggregate_stats_table(stats),
+        title="[bold cyan]GitHub Sync Statistics[/bold cyan]",
+        expand=False,
+    )
+    console_inst.print(panel)
+
+
+def _handle_all_issues_status(
+    core, console_inst, metadata_service: "SyncMetadataService"
+) -> None:
+    """Display a brief sync-status overview for every GitHub-linked issue."""
+    all_issues = core.issues.all()
+    github_issues = [i for i in all_issues if getattr(i, "github_issue", None)]
+    if not github_issues:
+        console_inst.print("[yellow]⚠️  No GitHub-linked issues found[/yellow]")
+        return
+
+    table = Table(
+        title=f"GitHub Sync Status ({len(github_issues)} issues)",
+        show_header=True,
+        header_style="bold cyan",
+    )
+    table.add_column("Issue ID", style="cyan")
+    table.add_column("GitHub", width=10)
+    table.add_column("Title", width=35)
+    table.add_column("Status", width=12)
+    table.add_column("Last Sync", width=20)
+    table.add_column("Success %", width=12)
+
+    status_color_map = {
+        "success": "green",
+        "conflict": "yellow",
+        "error": "red",
+        "never": "dim",
+    }
+    for issue in github_issues:
+        metadata = metadata_service.get_metadata(issue)
+        status_color = status_color_map.get(metadata.last_sync_status, "white")
+        last_sync = (
+            _format_timestamp(metadata.last_sync_time)
+            if metadata.last_sync_time
+            else "Never"
+        )
+        success_rate = (
+            f"{metadata.get_success_rate():.0f}%" if metadata.sync_count > 0 else "—"
+        )
+        table.add_row(
+            issue.id,
+            f"#{metadata.github_issue_id}",
+            issue.title[:32],
+            f"[{status_color}]{metadata.last_sync_status}[/{status_color}]",
+            last_sync,
+            success_rate,
+        )
+    console_inst.print(table)
+
+
+def _handle_single_issue_status(
+    issue_id: str,
+    show_history: bool,
+    core,
+    console_inst,
+    metadata_service: "SyncMetadataService",
+) -> None:
+    """Display full sync status detail for a single GitHub-linked issue."""
+    if not issue_id:
+        console_inst.print(
+            "[red]❌ Must provide ISSUE_ID or use --all or --statistics[/red]"
+        )
+        sys.exit(1)
+
+    issue = ensure_entity_exists(core.issues, issue_id, "Issue")
+    if not issue:
+        return
+
+    if not getattr(issue, "github_issue", None):
+        console_inst.print(
+            f"[yellow]⚠️  Issue #{issue_id} is not linked to GitHub[/yellow]"
+        )
+        return
+
+    metadata = metadata_service.get_metadata(issue)
+
+    console_inst.print()
+    console_inst.print(Panel(_build_sync_status_header(issue, metadata), expand=False))
+    console_inst.print()
+    console_inst.print(
+        Panel(
+            _build_sync_metadata_table(issue, metadata),
+            title="[bold cyan]Sync Statistics[/bold cyan]",
+            expand=False,
+        )
+    )
+    console_inst.print()
+
+    if metadata.sync_history:
+        history_records = list(reversed(metadata.sync_history))
+        if not show_history:
+            history_records = history_records[:5]
+        console_inst.print(_build_sync_history_table(history_records))
+        if not show_history and len(metadata.sync_history) > 5:
+            console_inst.print(
+                f"\n[dim]... showing last 5 of {len(metadata.sync_history)} syncs. "
+                f"Use --history to see all[/dim]"
+            )
+    else:
+        console_inst.print(
+            Panel(
+                "[dim]No sync history recorded yet[/dim]",
+                title="[bold cyan]Sync History[/bold cyan]",
+                expand=False,
+            )
+        )
+
+    console_inst.print()
+
+
+@click.command(name="sync-status")
+@click.argument("issue_id", default="", required=False)
+@click.option("--history", "show_history", is_flag=True, help="Show full sync history")
+@click.option(
+    "--statistics",
+    "show_statistics",
+    is_flag=True,
+    help="Show aggregate statistics across all issues",
+)
+@click.option(
+    "--all",
+    "show_all_issues",
+    is_flag=True,
+    help="Show sync status for all GitHub-linked issues",
+)
+@click.pass_context
+def sync_status(
+    ctx: click.Context,
+    issue_id: str,
+    show_history: bool,
+    show_statistics: bool,
+    show_all_issues: bool,
+) -> None:
+    """Show sync status and history for GitHub-linked issues.
+
+    Examples:
+        # Show status for a single issue
+        roadmap issue sync-status ISSUE_ID
+
+        # Show full sync history
+        roadmap issue sync-status ISSUE_ID --history
+
+        # Show aggregate statistics
+        roadmap issue sync-status --statistics
+
+        # Show status for all linked issues
+        roadmap issue sync-status --all
+
+    The command displays:
+        - Last sync time and status
+        - Total sync attempts and success rate
+        - Recent sync history with change details
+        - Conflict resolution information
+    """
+    core = ctx.obj
+    console_inst = get_console()
+    metadata_service = SyncMetadataService(core)
+
+    if show_statistics:
+        _handle_sync_statistics(core, console_inst, metadata_service)
+        return
+    if show_all_issues:
+        _handle_all_issues_status(core, console_inst, metadata_service)
+        return
+    _handle_single_issue_status(
+        issue_id, show_history, core, console_inst, metadata_service
+    )

roadmap/adapters/cli/issues/unblock.py

@@ -0,0 +1,43 @@
+"""Unblock issue command - thin wrapper around update.
+
+This command is syntactic sugar for: roadmap issue update <ID> --status in-progress
+"""
+
+import click
+
+from roadmap.adapters.cli.cli_command_helpers import require_initialized
+from roadmap.common.cli_errors import handle_cli_errors
+from roadmap.core.domain import Status
+
+from .issue_status_helpers import StatusChangeConfig, apply_status_change
+
+
+@click.command("unblock")
+@click.argument("issue_id")
+@click.option("--reason", "-r", help="Reason for unblocking")
+@click.pass_context
+@handle_cli_errors(command_name="issue unblock")
+@require_initialized
+def unblock_issue(ctx: click.Context, issue_id: str, reason: str):
+    """Unblock an issue by setting status to in-progress.
+
+    Syntactic sugar for: roadmap issue update <ID> --status in-progress
+    """
+    core = ctx.obj["core"]
+
+    def check_is_blocked(issue):
+        """Verify issue is currently blocked before unblocking."""
+        status_val = getattr(issue.status, "value", str(issue.status))
+        if status_val != "blocked":
+            return False, f"Issue is not blocked (current: {status_val})"
+        return True, None
+
+    config = StatusChangeConfig(
+        status=Status.IN_PROGRESS,
+        emoji="✅",
+        title_verb="Unblocked",
+        title_style="bold green",
+        status_display="🔄 In Progress",
+        pre_check=check_is_blocked,
+    )
+    apply_status_change(core, issue_id, config, reason)

roadmap/adapters/cli/issues/unlink.py

@@ -0,0 +1,104 @@
+"""Unlink GitHub issue 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.common.console import get_console
+from roadmap.common.formatters.text.operations import (
+    format_operation_failure,
+    format_operation_success,
+)
+from roadmap.common.logging import (
+    log_command,
+    track_database_operation,
+)
+
+console = get_console()
+
+
+@click.command("unlink-github")
+@click.argument("issue_id")
+@click.pass_context
+@log_command("issue_unlink", entity_type="issue", track_duration=True)
+@require_initialized
+def unlink_github_issue(ctx: click.Context, issue_id: str) -> None:
+    """Remove GitHub link from a local issue.
+
+    Args:
+        ctx: Click context with core object
+        issue_id: ID of the local issue to unlink
+    """
+    core = ctx.obj["core"]
+
+    try:
+        # Get the issue
+        issue = core.issues.get(issue_id)
+        if not issue:
+            lines = format_operation_failure(
+                action="unlink",
+                entity_id=issue_id,
+                error="Issue not found",
+            )
+            for line in lines:
+                console.print(line, style="bold red")
+            return
+
+        # Check if issue is linked
+        if issue.github_issue is None:
+            console.print(
+                f"⚠️  Issue '{issue_id}' is not linked to GitHub",
+                style="yellow",
+            )
+            return
+
+        # Store the GitHub ID for display
+        github_id = issue.github_issue
+
+        # Remove the link
+        with track_database_operation(
+            "update", "issue", entity_id=issue_id, warn_threshold_ms=2000
+        ):
+            updated_issue = core.issues.update(issue_id, github_issue=None)
+
+        if updated_issue:
+            extra_details = {
+                "GitHub Issue": f"#{github_id}",
+                "Local Issue": issue_id,
+            }
+            lines = format_operation_success(
+                emoji="✅",
+                action="Unlinked",
+                entity_title=updated_issue.title,
+                entity_id=issue_id,
+                extra_details=extra_details,
+            )
+            for line in lines:
+                console.print(
+                    line, style="bold green" if "Unlinked" in line else "cyan"
+                )
+        else:
+            lines = format_operation_failure(
+                action="unlink",
+                entity_id=issue_id,
+                error="Failed to update issue",
+            )
+            for line in lines:
+                console.print(line, style="bold red")
+
+    except Exception as e:
+        handle_cli_error(
+            error=e,
+            operation="unlink_github_issue",
+            entity_type="issue",
+            entity_id=issue_id,
+            context={},
+            fatal=True,
+        )
+        lines = format_operation_failure(
+            action="unlink",
+            entity_id=issue_id,
+            error=str(e),
+        )
+        for line in lines:
+            console.print(line, style="bold red")

roadmap/adapters/cli/issues/update.py

@@ -0,0 +1,120 @@
+"""Update issue 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 IssueBuilder
+from roadmap.adapters.cli.presentation.crud_presenter import UpdatePresenter
+from roadmap.common.logging import (
+    log_command,
+)
+from roadmap.common.models import IssueUpdateParams
+
+
+class IssueUpdate(BaseUpdate):
+    """Update issue command implementation."""
+
+    entity_type = EntityType.ISSUE
+
+    def __init__(self, core):
+        """Initialize IssueUpdate."""
+        super().__init__(core)
+        self._current_update_dict = {}
+        self._current_reason = None
+
+    def build_update_dict(self, entity_id: str, **kwargs) -> dict:
+        """Build update dictionary for issue."""
+        return IssueBuilder.build_update_dict(
+            title=kwargs.get("title"),
+            priority=kwargs.get("priority"),
+            status=kwargs.get("status"),
+            assignee=kwargs.get("assignee"),
+            milestone=kwargs.get("milestone"),
+            description=kwargs.get("description"),
+            estimate=kwargs.get("estimate"),
+        )
+
+    def execute(self, entity_id: str, **kwargs):
+        """Execute update and display results using proper formatter.
+
+        Overrides parent to store update_dict and reason for display.
+        """
+        # Store for use in _display_success
+        self._current_update_dict = self.build_update_dict(
+            entity_id=entity_id, **kwargs
+        )
+        self._current_reason = kwargs.get("reason")
+
+        # Call parent execute which will call _display_success
+        return super().execute(entity_id=entity_id, **kwargs)
+
+    def _display_success(self, entity) -> None:
+        """Display success message using presenter."""
+        presenter = UpdatePresenter()
+        presenter.render(entity, self._current_update_dict)
+
+
+@click.command("update")
+@click.argument("issue_id")
+@click.option("--title", help="Update issue title")
+@click.option(
+    "--priority",
+    "-p",
+    type=click.Choice(["critical", "high", "medium", "low"]),
+    help="Update priority",
+)
+@click.option(
+    "--status",
+    "-s",
+    type=click.Choice(["todo", "in-progress", "blocked", "review", "closed"]),
+    help="Update status",
+)
+@click.option("--assignee", "-a", help="Update assignee")
+@click.option("--milestone", "-m", help="Update milestone")
+@click.option("--description", "-d", help="Update description")
+@click.option("--estimate", "-e", type=float, help="Update estimated time (in hours)")
+@click.option("--reason", "-r", help="Reason for the update")
+@click.pass_context
+@log_command("issue_update", entity_type="issue", track_duration=True)
+@require_initialized
+def update_issue(
+    ctx: click.Context,
+    issue_id: str,
+    title: str,
+    priority: str,
+    status: str,
+    assignee: str,
+    milestone: str,
+    description: str,
+    estimate: float,
+    reason: str,
+):
+    """Update an existing issue."""
+    core = ctx.obj["core"]
+    updater = IssueUpdate(core)
+
+    # Create structured parameter object
+    params = IssueUpdateParams(
+        issue_id=issue_id,
+        title=title,
+        priority=priority,
+        status=status,
+        assignee=assignee,
+        milestone=milestone,
+        content=description,
+        estimate=estimate,
+        reason=reason,
+    )
+
+    updater.execute(
+        entity_id=params.issue_id,
+        title=params.title,
+        priority=params.priority,
+        status=params.status,
+        assignee=params.assignee,
+        milestone=params.milestone,
+        content=params.content,
+        estimate=params.estimate,
+        reason=params.reason,
+    )

roadmap/adapters/cli/issues/view.py

@@ -0,0 +1,36 @@
+"""View issue command."""
+
+import click
+
+from roadmap.adapters.cli.cli_command_helpers import (
+    ensure_entity_exists,
+    require_initialized,
+)
+from roadmap.adapters.cli.mappers import IssueMapper
+from roadmap.adapters.cli.presentation.issue_presenter import IssuePresenter
+
+
+@click.command("view")
+@click.argument("issue_id")
+@click.pass_context
+@require_initialized
+def view_issue(ctx: click.Context, issue_id: str):
+    """Display detailed information about a specific issue.
+
+    Shows complete issue details including metadata, timeline, description,
+    and acceptance criteria in a formatted view.
+
+    Example:
+        roadmap issue view abc123def
+    """
+    core = ctx.obj["core"]
+
+    # Retrieve the domain issue from the repository
+    issue = ensure_entity_exists(core, "issue", issue_id)
+
+    # Convert domain issue to DTO for presentation
+    issue_dto = IssueMapper.domain_to_dto(issue)
+
+    # Use presenter to render the issue
+    presenter = IssuePresenter()
+    presenter.render(issue_dto)