roadmap-cli 0.1.1__py3-none-any.whl

roadmap/adapters/cli/crud/entity_builders.py

@@ -0,0 +1,374 @@
+"""Entity-specific builders for CRUD operations.
+
+This module provides builders for each entity type (Issue, Milestone, Project)
+that handle validation and dict building for create/update operations.
+"""
+
+from datetime import datetime
+from typing import Any
+
+from roadmap.common.errors.exceptions import ValidationError
+from roadmap.core.domain import IssueType, Priority
+
+
+class IssueBuilder:
+    """Builder for issue creation and updates."""
+
+    @staticmethod
+    def validate_issue_exists(core: Any, issue_id: str) -> bool:
+        """Check if an issue exists.
+
+        Args:
+            core: The core application context
+            issue_id: Issue ID to check
+
+        Returns:
+            True if issue exists, False otherwise
+        """
+        return core.issues.get(issue_id) is not None
+
+    @staticmethod
+    def validate_priority(priority: str) -> Priority:
+        """Validate and convert priority string.
+
+        Args:
+            priority: Priority string (critical, high, medium, low)
+
+        Returns:
+            Priority enum value
+
+        Raises:
+            ValidationError: If priority is invalid
+        """
+        try:
+            priority_map = {
+                "critical": Priority.CRITICAL,
+                "high": Priority.HIGH,
+                "medium": Priority.MEDIUM,
+                "low": Priority.LOW,
+            }
+            return priority_map[priority.lower()]
+        except KeyError as e:
+            raise ValidationError(
+                domain_message=f"Invalid priority: {priority}",
+                user_message=f"Invalid priority: {priority}. Valid values: critical, high, medium, low",
+            ) from e
+
+    @staticmethod
+    def validate_issue_type(issue_type: str) -> IssueType:
+        """Validate and convert issue type string.
+
+        Args:
+            issue_type: Issue type string (feature, bug, other)
+
+        Returns:
+            IssueType enum value
+
+        Raises:
+            ValidationError: If type is invalid
+        """
+        try:
+            type_map = {
+                "feature": IssueType.FEATURE,
+                "bug": IssueType.BUG,
+                "other": IssueType.OTHER,
+            }
+            return type_map[issue_type.lower()]
+        except KeyError as e:
+            raise ValidationError(
+                domain_message=f"Invalid issue type: {issue_type}",
+                user_message=f"Invalid issue type: {issue_type}. Valid values: feature, bug, other",
+            ) from e
+
+    @staticmethod
+    def build_create_dict(
+        title: str,
+        priority: str | None = None,
+        issue_type: str | None = None,
+        milestone: str | None = None,
+        assignee: str | None = None,
+        labels: list[str] | None = None,
+        estimate: float | None = None,
+        depends_on: list[str] | None = None,
+        blocks: list[str] | None = None,
+        description: str | None = None,
+    ) -> dict[str, Any]:
+        """Build create dictionary for issue.
+
+        Args:
+            title: Issue title (required)
+            priority: Priority level
+            issue_type: Type of issue
+            milestone: Milestone ID to assign
+            assignee: Assignee name/email
+            labels: List of labels
+            estimate: Estimated hours
+            depends_on: Issue IDs this depends on
+            blocks: Issue IDs this blocks
+            description: Markdown content/description
+
+        Returns:
+            Dictionary ready for core.issues.create()
+        """
+        create_dict: dict[str, Any] = {"title": title, "status": "todo"}
+
+        if priority:
+            create_dict["priority"] = IssueBuilder.validate_priority(priority)
+
+        if issue_type:
+            create_dict["issue_type"] = IssueBuilder.validate_issue_type(issue_type)
+
+        if milestone:
+            create_dict["milestone"] = milestone
+
+        if assignee:
+            create_dict["assignee"] = assignee
+
+        if labels:
+            create_dict["labels"] = labels
+
+        if estimate is not None:
+            create_dict["estimated_hours"] = estimate
+
+        if depends_on:
+            create_dict["depends_on"] = depends_on
+
+        if blocks:
+            create_dict["blocks"] = blocks
+
+        if description:
+            create_dict["content"] = description
+
+        return create_dict
+
+    @staticmethod
+    def build_update_dict(
+        title: str | None = None,
+        priority: str | None = None,
+        status: str | None = None,
+        assignee: str | None = None,
+        milestone: str | None = None,
+        description: str | None = None,
+        estimate: float | None = None,
+    ) -> dict[str, Any]:
+        """Build update dictionary for issue.
+
+        Args:
+            title: New title
+            priority: New priority
+            status: New status
+            assignee: New assignee
+            milestone: New milestone
+            description: New description
+            estimate: New estimate
+
+        Returns:
+            Dictionary ready for core.issues.update()
+        """
+        update_dict = {}
+
+        if title is not None:
+            update_dict["title"] = title
+
+        if priority is not None:
+            update_dict["priority"] = IssueBuilder.validate_priority(priority)
+
+        if status is not None:
+            update_dict["status"] = status
+
+        if assignee is not None:
+            update_dict["assignee"] = assignee
+
+        if milestone is not None:
+            update_dict["milestone"] = milestone
+
+        if description is not None:
+            update_dict["content"] = description
+
+        if estimate is not None:
+            update_dict["estimated_hours"] = estimate
+
+        return update_dict
+
+
+class MilestoneBuilder:
+    """Builder for milestone creation and updates."""
+
+    @staticmethod
+    def validate_milestone_exists(core: Any, milestone_id: str) -> bool:
+        """Check if a milestone exists.
+
+        Args:
+            core: The core application context
+            milestone_id: Milestone ID to check
+
+        Returns:
+            True if milestone exists, False otherwise
+        """
+        return core.milestones.get(milestone_id) is not None
+
+    @staticmethod
+    def validate_due_date(due_date: str | None) -> datetime | None:
+        """Validate and parse due date.
+
+        Args:
+            due_date: Due date string (YYYY-MM-DD format)
+
+        Returns:
+            Parsed datetime or None
+
+        Raises:
+            ValidationError: If date format is invalid
+        """
+        if not due_date:
+            return None
+
+        try:
+            return datetime.strptime(due_date, "%Y-%m-%d")
+        except ValueError as e:
+            raise ValidationError(
+                domain_message="Invalid due date format: expected YYYY-MM-DD",
+                user_message=f"Invalid due date format: {due_date}. Expected format: YYYY-MM-DD (example: 2024-12-31)",
+            ) from e
+
+    @staticmethod
+    def build_create_dict(
+        name: str,
+        description: str | None = None,
+        due_date: str | None = None,
+    ) -> dict[str, Any]:
+        """Build create dictionary for milestone.
+
+        Args:
+            name: Milestone name (required)
+            description: Milestone content/description
+            due_date: Due date (YYYY-MM-DD format)
+
+        Returns:
+            Dictionary ready for core.milestones.create()
+        """
+        create_dict: dict[str, Any] = {"name": name, "status": "open"}
+
+        if description:
+            create_dict["headline"] = description
+
+        if due_date:
+            create_dict["due_date"] = MilestoneBuilder.validate_due_date(due_date)
+
+        return create_dict
+
+    @staticmethod
+    def build_update_dict(
+        name: str | None = None,
+        description: str | None = None,
+        due_date: str | None = None,
+        status: str | None = None,
+        project_id: str | None = None,
+    ) -> dict[str, Any]:
+        """Build update dictionary for milestone.
+
+        Args:
+            name: New name
+            description: New content/description
+            due_date: New due date (YYYY-MM-DD format)
+            status: New status
+            project_id: Project ID to assign milestone to
+
+        Returns:
+            Dictionary ready for core.milestones.update()
+        """
+        update_dict = {}
+
+        if name is not None:
+            update_dict["name"] = name
+
+        if description is not None:
+            update_dict["headline"] = description
+
+        if due_date is not None:
+            update_dict["due_date"] = MilestoneBuilder.validate_due_date(due_date)
+
+        if status is not None:
+            update_dict["status"] = status
+
+        if project_id is not None:
+            update_dict["project_id"] = project_id
+
+        return update_dict
+
+
+class ProjectBuilder:
+    """Builder for project creation and updates."""
+
+    @staticmethod
+    def validate_project_exists(core: Any, project_id: str) -> bool:
+        """Check if a project exists.
+
+        Args:
+            core: The core application context
+            project_id: Project ID to check
+
+        Returns:
+            True if project exists, False otherwise
+        """
+        return core.projects.get(project_id) is not None
+
+    @staticmethod
+    def build_create_dict(
+        name: str,
+        description: str | None = None,
+        repository: str | None = None,
+    ) -> dict[str, Any]:
+        """Build create dictionary for project.
+
+        Args:
+            name: Project name (required)
+            description: Project content
+            repository: Repository URL
+
+        Returns:
+            Dictionary ready for core.projects.create()
+        """
+        create_dict = {"name": name, "status": "planning"}
+
+        if description:
+            create_dict["headline"] = description
+
+        if repository:
+            create_dict["repository"] = repository
+
+        return create_dict
+
+    @staticmethod
+    def build_update_dict(
+        name: str | None = None,
+        description: str | None = None,
+        repository: str | None = None,
+        status: str | None = None,
+    ) -> dict[str, Any]:
+        """Build update dictionary for project.
+
+        Args:
+            name: New name
+            description: New description
+            repository: New repository URL
+            status: New status
+
+        Returns:
+            Dictionary ready for core.projects.update()
+        """
+        update_dict = {}
+
+        if name is not None:
+            update_dict["name"] = name
+
+        if description is not None:
+            update_dict["headline"] = description
+
+        if repository is not None:
+            update_dict["repository"] = repository
+
+        if status is not None:
+            update_dict["status"] = status
+
+        return update_dict

roadmap/adapters/cli/data/__init__.py

@@ -0,0 +1,8 @@
+"""Data export and reporting commands.
+
+Commands for exporting and managing data.
+"""
+
+from .commands import data
+
+__all__ = ["data"]

roadmap/adapters/cli/data/commands.py

@@ -0,0 +1,149 @@
+"""Data management commands for export and reporting."""
+
+import click
+
+from roadmap.common.console import get_console
+from roadmap.common.logging import verbose_output
+from roadmap.core.domain import Issue
+
+console = get_console()
+
+
+def _serialize_issue(issue: Issue) -> dict:
+    """Convert an Issue model to a JSON-serializable dict."""
+    # Use pydantic's dict but convert datetimes to isoformat strings
+    d = issue.model_dump()
+    for k, v in d.items():
+        if hasattr(v, "isoformat"):
+            try:
+                d[k] = v.isoformat()
+            except Exception:
+                d[k] = str(v)
+    return d
+
+
+@click.group()
+def data():
+    """Export, import, and analyze roadmap data."""
+    pass
+
+
+@data.command("export")
+@click.option(
+    "--format",
+    type=click.Choice(["json", "csv", "markdown"]),
+    default="json",
+    help="Export format",
+)
+@click.option("--output", "-o", help="Output file path")
+@click.option("--filter", help="Filter criteria (simple key=value)")
+@click.pass_context
+@verbose_output
+def export(ctx: click.Context, format: str, output: str, filter: str):
+    """Export roadmap issues to JSON, CSV or Markdown.
+
+    The --filter argument supports a simple key=value filter (e.g. assignee=alice).
+    """
+    console.print(f"📊 Exporting issues in {format} format...", style="bold blue")
+
+    # Get core and issues
+    core = _get_core(ctx)
+    if not core or not core.is_initialized():
+        console.print(
+            "❌ Roadmap not initialized. Run 'roadmap init' first or run this command inside a roadmap.",
+            style="bold red",
+        )
+        return
+
+    issues = _load_and_filter_issues(core, filter)
+    if not issues:
+        console.print("ℹ️  No issues to export.", style="yellow")
+        return
+
+    # Format and output
+    _export_and_write(issues, format, output)
+
+
+def _get_core(ctx: click.Context):
+    """Get RoadmapCore from context or discover existing roadmap."""
+    try:
+        core = ctx.obj.get("core") if ctx.obj else None
+    except Exception:
+        core = None
+
+    if core is None:
+        try:
+            from roadmap.infrastructure.coordination.core import RoadmapCore
+
+            core = RoadmapCore.find_existing_roadmap()
+        except Exception:
+            core = None
+
+    return core
+
+
+def _load_and_filter_issues(core, filter_str: str):
+    """Load issues and apply filter if provided."""
+    try:
+        issues = core.issues.list()
+    except Exception as e:
+        console.print(f"❌ Failed to list issues: {e}", style="bold red")
+        return []
+
+    if filter_str:
+        try:
+            key, val = filter_str.split("=", 1)
+            key = key.strip()
+            val = val.strip()
+            issues = [
+                i for i in issues if str(getattr(i, key, "")).lower() == val.lower()
+            ]
+        except Exception:
+            console.print("⚠️  Unable to parse filter, ignoring.", style="yellow")
+
+    return issues
+
+
+def _export_and_write(issues, format_type: str, output_path: str):
+    """Format issues and write to file or stdout."""
+    from roadmap.common.formatters import IssueExporter
+
+    try:
+        if format_type == "json":
+            out_text = IssueExporter.to_json(issues, _serialize_issue)
+        elif format_type == "csv":
+            out_text = IssueExporter.to_csv(issues, _serialize_issue)
+        else:  # markdown
+            out_text = IssueExporter.to_markdown(issues)
+
+        # Write to file or print
+        if output_path:
+            with open(output_path, "w", encoding="utf-8") as f:
+                f.write(out_text)
+            console.print(
+                f"✅ Exported {len(issues)} issues to {output_path}", style="bold green"
+            )
+        else:
+            console.print(out_text)
+
+    except Exception as e:
+        console.print(f"❌ Failed to export issues: {e}", style="bold red")
+
+
+@data.command("generate-report")
+@click.option(
+    "--type",
+    type=click.Choice(["summary", "detailed", "analytics"]),
+    default="summary",
+    help="Report type",
+)
+@click.option("--output", "-o", help="Output file path")
+@click.pass_context
+@verbose_output
+def generate_report(ctx: click.Context, type: str, output: str):
+    """Generate detailed reports and analytics."""
+    console.print(f"📈 Generating {type} report...", style="bold blue")
+    # Implementation would go here
+    console.print(
+        "✅ Report generation functionality will be implemented", style="green"
+    )