roadmap-cli 0.1.1__py3-none-any.whl

roadmap/adapters/cli/issues/comment.py

@@ -0,0 +1,178 @@
+"""Comment management commands for issues."""
+
+import click
+
+from roadmap.adapters.cli.cli_command_helpers import (
+    ensure_entity_exists,
+    require_initialized,
+)
+from roadmap.common.console import get_console
+from roadmap.common.logging import log_command, verbose_output
+from roadmap.core.services.comment.comment_service import CommentService
+
+
+@click.group("comment")
+def comment_group():
+    """Manage comments on issues."""
+    pass
+
+
+@click.command("add")
+@click.argument("issue_id")
+@click.argument("body")
+@click.option(
+    "--author",
+    "-a",
+    default=None,
+    help="Author of comment (defaults to current user)",
+)
+@click.option(
+    "--reply-to",
+    "-r",
+    type=int,
+    default=None,
+    help="Comment ID this is a reply to",
+)
+@click.pass_context
+@require_initialized
+@verbose_output
+@log_command("issue_comment_add", entity_type="comment", track_duration=True)
+def add_comment(
+    ctx: click.Context,
+    issue_id: str,
+    body: str,
+    author: str | None,
+    reply_to: int | None,
+):
+    """Add a comment to an issue.
+
+    BODY: Comment text (markdown supported)
+
+    Example:
+        roadmap issue comment add abc123 "Great work! This looks good."
+        roadmap issue comment add abc123 "I disagree" --reply-to 12345
+    """
+    core = ctx.obj["core"]
+    console = get_console()
+
+    # Ensure issue exists
+    issue = ensure_entity_exists(core, "issue", issue_id)
+
+    # Resolve author (use provided or default to system user)
+    if not author:
+        import getpass
+
+        author = getpass.getuser()
+
+    # Validate comment body
+    if not body or not body.strip():
+        console.print("❌ Comment body cannot be empty", style="red")
+        return
+
+    # Create the comment
+    try:
+        comment = CommentService.create_comment(
+            author=author,
+            body=body,
+            entity_id=issue.id,
+            in_reply_to=reply_to,
+        )
+    except Exception as e:
+        console.print(f"❌ Failed to create comment: {e}", style="red")
+        return
+
+    # If replying to a comment, validate that comment exists
+    if reply_to is not None:
+        if not any(c.id == reply_to for c in issue.comments):
+            console.print(
+                f"❌ Cannot find comment {reply_to} to reply to",
+                style="red",
+            )
+            return
+
+    # Add comment to issue
+    issue.comments.append(comment)
+
+    # Update the issue
+    try:
+        core.issues.update(issue.id, {"comments": issue.comments})
+        console.print(
+            f"✅ Comment added to issue {issue.id}",
+            style="green",
+        )
+        console.print(f"   By: {comment.author}")
+        console.print(f"   ID: {comment.id}")
+        if reply_to:
+            console.print(f"   Replying to: {reply_to}")
+    except Exception as e:
+        console.print(f"❌ Failed to update issue: {e}", style="red")
+
+
+@click.command("list")
+@click.argument("issue_id")
+@click.option(
+    "--format",
+    "-f",
+    type=click.Choice(["text", "json"]),
+    default="text",
+    help="Output format",
+)
+@click.pass_context
+@require_initialized
+def list_comments(ctx: click.Context, issue_id: str, format: str):
+    """List comments on an issue.
+
+    Example:
+        roadmap issue comment list abc123
+        roadmap issue comment list abc123 --format json
+    """
+    core = ctx.obj["core"]
+    console = get_console()
+
+    # Ensure issue exists
+    issue = ensure_entity_exists(core, "issue", issue_id)
+
+    if not issue.comments:
+        console.print("[dim]No comments yet[/dim]")
+        return
+
+    if format == "json":
+        # Convert comments to JSON-serializable format
+        comments_data = []
+        for comment in issue.comments:
+            comments_data.append(
+                {
+                    "id": comment.id,
+                    "author": comment.author,
+                    "body": comment.body,
+                    "created_at": comment.created_at.isoformat(),
+                    "updated_at": comment.updated_at.isoformat(),
+                    "in_reply_to": comment.in_reply_to,
+                }
+            )
+        console.print_json(data=comments_data)
+    else:
+        # Text format - show comments in thread view
+        threads = CommentService.build_comment_threads(issue.comments)
+
+        # Show top-level comments and their replies
+        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, []):
+                console.print(
+                    CommentService.format_comment_for_display(comment, indent=0)
+                )
+
+                # Show replies to this comment
+                if comment.id in threads:
+                    for reply in threads[comment.id]:
+                        console.print(
+                            CommentService.format_comment_for_display(reply, indent=1)
+                        )
+
+                console.print()  # Blank line between threads
+
+
+# Register commands with group
+comment_group.add_command(add_comment, name="add")
+comment_group.add_command(list_comments, name="list")

roadmap/adapters/cli/issues/create.py

@@ -0,0 +1,162 @@
+"""Create issue command."""
+
+import click
+
+from roadmap.adapters.cli.cli_command_helpers import require_initialized
+from roadmap.adapters.cli.crud import BaseCreate, EntityType
+from roadmap.adapters.cli.crud.entity_builders import IssueBuilder
+from roadmap.common.logging import (
+    log_command,
+    verbose_output,
+)
+from roadmap.common.models import IssueCreateParams, IssueGitParams
+
+
+class IssueCreate(BaseCreate):
+    """Create issue command implementation."""
+
+    entity_type = EntityType.ISSUE
+
+    def build_entity_dict(self, title: str, **kwargs) -> dict:
+        """Build entity dictionary for issue creation."""
+        from roadmap.core.services import IssueCreationService
+
+        # Resolve and validate assignee (with auto-detection from Git)
+        assignee = kwargs.get("assignee")
+        service = IssueCreationService(self.core)
+        assignee = service.resolve_and_validate_assignee(assignee, auto_detect=True)
+
+        return IssueBuilder.build_create_dict(
+            title=title,
+            priority=kwargs.get("priority"),
+            issue_type=kwargs.get("issue_type"),
+            milestone=kwargs.get("milestone"),
+            assignee=assignee,
+            labels=list(kwargs.get("labels", [])),
+            estimate=kwargs.get("estimate"),
+            depends_on=list(kwargs.get("depends_on", [])),
+            blocks=list(kwargs.get("blocks", [])),
+            description=kwargs.get("content"),
+        )
+
+    def _display_success(self, entity) -> None:
+        """Display success message using presenter."""
+        # Use detailed service display which includes assignee, priority, etc.
+        from roadmap.core.services import IssueCreationService
+
+        service = IssueCreationService(self.core)
+        service.format_created_issue_display(
+            entity, milestone=getattr(entity, "milestone", None)
+        )
+
+    def post_create_hook(self, entity, **kwargs) -> None:
+        """Handle post-creation tasks like Git branch creation."""
+        if kwargs.get("git_branch"):
+            from roadmap.core.services import IssueCreationService
+
+            service = IssueCreationService(self.core)
+            service.create_branch_for_issue(
+                entity,
+                kwargs.get("branch_name"),
+                kwargs.get("checkout", True),
+                kwargs.get("force", False),
+            )
+
+
+@click.command("create")
+@click.option("--title", required=True, help="Issue title")
+@click.option(
+    "--priority",
+    "-p",
+    type=click.Choice(["critical", "high", "medium", "low"]),
+    default="medium",
+    help="Issue priority",
+)
+@click.option(
+    "--type",
+    "-t",
+    "issue_type",
+    type=click.Choice(["feature", "bug", "other"]),
+    default="other",
+    help="Issue type",
+)
+@click.option("--milestone", "-m", help="Assign to milestone")
+@click.option("--assignee", "-a", help="Assign to team member")
+@click.option("--labels", "-l", multiple=True, help="Add labels")
+@click.option(
+    "--estimate", "-e", type=float, help="Estimated time to complete (in hours)"
+)
+@click.option("--depends-on", multiple=True, help="Issue IDs this depends on")
+@click.option("--blocks", multiple=True, help="Issue IDs this blocks")
+@click.option("--content", "-d", help="Markdown content/description of the issue")
+@click.option("--git-branch", is_flag=True, help="Create a Git branch for this issue")
+@click.option(
+    "--checkout/--no-checkout",
+    default=True,
+    help="Checkout the branch after creation (with --git-branch)",
+)
+@click.option("--branch-name", default=None, help="Override suggested branch name")
+@click.option(
+    "--force", is_flag=True, help="Force branch creation even if working tree is dirty"
+)
+@click.pass_context
+@verbose_output
+@log_command("issue_create", entity_type="issue", track_duration=True)
+@require_initialized
+def create_issue(
+    ctx: click.Context,
+    title: str,
+    priority: str,
+    issue_type: str,
+    milestone: str,
+    assignee: str,
+    labels: tuple,
+    estimate: float,
+    depends_on: tuple,
+    blocks: tuple,
+    content: str,
+    git_branch: bool,
+    checkout: bool,
+    branch_name: str,
+    force: bool,
+):
+    """Create a new issue."""
+    core = ctx.obj["core"]
+    creator = IssueCreate(core)
+
+    # Create structured parameter objects
+    issue_params = IssueCreateParams(
+        title=title,
+        priority=priority,
+        issue_type=issue_type,
+        milestone=milestone,
+        assignee=assignee,
+        labels=labels,
+        estimate=estimate,
+        depends_on=depends_on,
+        blocks=blocks,
+        content=content,
+    )
+    git_params = IssueGitParams(
+        git_branch=git_branch,
+        checkout=checkout,
+        branch_name=branch_name,
+        force=force,
+    )
+
+    creator.execute(
+        title=issue_params.title,
+        priority=issue_params.priority,
+        issue_type=issue_params.issue_type,
+        milestone=issue_params.milestone,
+        assignee=issue_params.assignee,
+        labels=issue_params.labels,
+        estimate=issue_params.estimate,
+        depends_on=issue_params.depends_on,
+        blocks=issue_params.blocks,
+        content=issue_params.content,
+        git_branch=git_params.git_branch,
+        checkout=git_params.checkout,
+        branch_name=git_params.branch_name,
+        force=git_params.force,
+    )

roadmap/adapters/cli/issues/delete.py

@@ -0,0 +1,31 @@
+"""Delete issue command."""
+
+import click
+
+from roadmap.adapters.cli.cli_command_helpers import require_initialized
+from roadmap.adapters.cli.crud import BaseDelete, EntityType
+from roadmap.common.logging import log_command
+
+
+class IssueDelete(BaseDelete):
+    """Delete issue command implementation."""
+
+    entity_type = EntityType.ISSUE
+
+
+@click.command("delete")
+@click.argument("issue_id")
+@click.option("--yes", "-y", is_flag=True, help="Skip confirmation prompt")
+@click.pass_context
+@log_command("issue_delete", entity_type="issue", track_duration=True)
+@require_initialized
+def delete_issue(
+    ctx: click.Context,
+    issue_id: str,
+    yes: bool,
+):
+    """Delete an issue."""
+    core = ctx.obj["core"]
+    deleter = IssueDelete(core)
+
+    deleter.execute(entity_id=issue_id, force=yes)

roadmap/adapters/cli/issues/deps.py

@@ -0,0 +1,161 @@
+"""Dependencies command group."""
+
+import click
+
+from roadmap.adapters.cli.cli_command_helpers import (
+    ensure_entity_exists,
+    require_initialized,
+)
+from roadmap.adapters.cli.cli_error_handlers import handle_cli_error
+from roadmap.common.console import get_console
+
+console = get_console()
+
+
+@click.group("deps")
+def deps():
+    """Manage issue dependencies."""
+    pass
+
+
+@deps.command("add")
+@click.argument("issue_id")
+@click.argument("dependency_id")
+@click.pass_context
+@require_initialized
+def add_dependency(ctx: click.Context, issue_id: str, dependency_id: str):
+    """Add a dependency to an issue."""
+    core = ctx.obj["core"]
+
+    try:
+        # Get the issue
+        issue = ensure_entity_exists(core, "issue", issue_id)
+
+        # Check if dependency issue exists
+        dependency_issue = ensure_entity_exists(core, "issue", dependency_id)
+
+        # Add dependency
+        current_deps = issue.depends_on or []
+        if dependency_id not in current_deps:
+            current_deps.append(dependency_id)
+            core.issues.update(issue_id, depends_on=current_deps)
+            console.print(
+                f"✅ Added dependency: {dependency_issue.title}", style="bold green"
+            )
+            console.print(
+                f"   {issue.title} now depends on {dependency_issue.title}", style="dim"
+            )
+        else:
+            console.print("⚠️ Dependency already exists", style="yellow")
+
+    except Exception as e:
+        handle_cli_error(
+            error=e,
+            operation="add_dependency",
+            entity_type="issue",
+            entity_id=issue_id,
+            context={"dependency_id": dependency_id},
+            fatal=True,
+        )
+        console.print(f"❌ Failed to add dependency: {e}", style="bold red")
+
+
+@deps.command("remove")
+@click.argument("issue_id")
+@click.argument("dependency_id")
+@click.pass_context
+@require_initialized
+def remove_dependency(ctx: click.Context, issue_id: str, dependency_id: str):
+    """Remove a dependency from an issue."""
+    core = ctx.obj["core"]
+
+    try:
+        issue = ensure_entity_exists(core, "issue", issue_id)
+
+        current_deps = list(issue.depends_on or [])
+        if dependency_id not in current_deps:
+            console.print(
+                f"⚠️ Dependency '{dependency_id}' not found on issue {issue_id}",
+                style="yellow",
+            )
+            return
+
+        updated_deps = [dep for dep in current_deps if dep != dependency_id]
+        core.issues.update(issue_id, depends_on=updated_deps)
+
+        console.print(
+            f"✅ Removed dependency: {dependency_id}",
+            style="bold green",
+        )
+        console.print(
+            f"   {issue.title} no longer depends on {dependency_id}", style="dim"
+        )
+
+    except Exception as e:
+        handle_cli_error(
+            error=e,
+            operation="remove_dependency",
+            entity_type="issue",
+            entity_id=issue_id,
+            context={"dependency_id": dependency_id},
+            fatal=True,
+        )
+        console.print(f"❌ Failed to remove dependency: {e}", style="bold red")
+
+
+@deps.command("update")
+@click.argument("issue_id")
+@click.argument("old_dependency_id")
+@click.argument("new_dependency_id")
+@click.pass_context
+@require_initialized
+def update_dependency(
+    ctx: click.Context,
+    issue_id: str,
+    old_dependency_id: str,
+    new_dependency_id: str,
+):
+    """Replace one dependency with another on an issue."""
+    core = ctx.obj["core"]
+
+    try:
+        issue = ensure_entity_exists(core, "issue", issue_id)
+        ensure_entity_exists(core, "issue", new_dependency_id)
+
+        current_deps = list(issue.depends_on or [])
+        if old_dependency_id not in current_deps:
+            console.print(
+                (f"⚠️ Dependency '{old_dependency_id}' not found on issue {issue_id}"),
+                style="yellow",
+            )
+            return
+
+        if new_dependency_id in current_deps and new_dependency_id != old_dependency_id:
+            updated_deps = [dep for dep in current_deps if dep != old_dependency_id]
+        else:
+            updated_deps = [
+                (new_dependency_id if dep == old_dependency_id else dep)
+                for dep in current_deps
+            ]
+
+        core.issues.update(issue_id, depends_on=updated_deps)
+
+        console.print(
+            f"✅ Updated dependency: {old_dependency_id} → {new_dependency_id}",
+            style="bold green",
+        )
+        console.print(f"   {issue.title} dependency updated successfully", style="dim")
+
+    except Exception as e:
+        handle_cli_error(
+            error=e,
+            operation="update_dependency",
+            entity_type="issue",
+            entity_id=issue_id,
+            context={
+                "old_dependency_id": old_dependency_id,
+                "new_dependency_id": new_dependency_id,
+            },
+            fatal=True,
+        )
+        console.print(f"❌ Failed to update dependency: {e}", style="bold red")

roadmap/adapters/cli/issues/issue_status_helpers.py

@@ -0,0 +1,111 @@
+"""Generic helper for status change commands (block, unblock, close, start, etc.).
+
+This module provides a unified pattern for syntactic sugar commands that update
+issue status. Each command defines a StatusChangeConfig and calls apply_status_change()
+to handle validation, updates, and user feedback consistently.
+"""
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+
+import click
+
+from roadmap.common.console import get_console
+from roadmap.common.formatters.text.operations import (
+    format_operation_failure,
+    format_operation_success,
+)
+from roadmap.core.domain import Status
+
+if TYPE_CHECKING:
+    from roadmap.infrastructure.coordination.core import RoadmapCore  # noqa: F401
+
+console = get_console()
+
+
+@dataclass
+class StatusChangeConfig:
+    """Configuration for a status change command.
+
+    Attributes:
+        status: Target Status value
+        emoji: Emoji to display in success message
+        title_verb: Verb describing the action ("Blocked", "Unblocked", "Closed")
+        title_style: Rich style for title line ("bold red", "bold green", etc.)
+        status_display: String to show in status output ("🚫 Blocked", "🔄 In Progress", etc.)
+        pre_check: Optional validation function that returns (is_valid: bool, error_msg: str | None)
+    """
+
+    status: Status
+    emoji: str
+    title_verb: str
+    title_style: str
+    status_display: str
+    pre_check: Callable[[Any], tuple[bool, str | None]] | None = None
+
+
+def apply_status_change(
+    core: "RoadmapCore",
+    issue_id: str,
+    config: StatusChangeConfig,
+    reason: str | None = None,
+) -> None:
+    """Apply a status change to an issue with consistent feedback.
+
+    This function:
+    1. Ensures the issue exists
+    2. Runs optional pre-checks (e.g., "is issue already blocked?")
+    3. Updates the issue status
+    4. Displays consistent success/failure feedback
+    5. Raises click.Abort on failure
+
+    Args:
+        core: Core application object with issues manager
+        issue_id: ID of issue to update
+        config: StatusChangeConfig defining behavior
+        reason: Optional reason for the change (displayed in feedback)
+
+    Raises:
+        click.Abort: If issue doesn't exist or update fails
+    """
+    from roadmap.adapters.cli.cli_command_helpers import ensure_entity_exists
+
+    # Ensure issue exists
+    issue = ensure_entity_exists(core, "issue", issue_id)
+
+    # Run pre-check if configured (e.g., "is issue already blocked?")
+    if config.pre_check:
+        is_valid, error_msg = config.pre_check(issue)
+        if not is_valid:
+            console.print(f"[yellow]⚠️  {error_msg}[/yellow]")
+            return
+
+    # Update status
+    updated = core.issues.update(issue_id, status=config.status)
+
+    if updated:
+        # Build extra details for display
+        extra_details = {"Status": config.status_display}
+
+        # Use formatter for consistent output
+        lines = format_operation_success(
+            emoji=config.emoji,
+            action=config.title_verb,
+            entity_title=updated.title,
+            entity_id=issue_id,
+            reason=reason,
+            extra_details=extra_details,
+        )
+        for line in lines:
+            console.print(line, style=config.title_style)
+    else:
+        # Failure feedback
+        lines = format_operation_failure(
+            action=config.title_verb.lower(),
+            entity_id=issue_id,
+            error="Failed to update status",
+        )
+        for line in lines:
+            console.print(line, style="bold red")
+        raise click.Abort()