roadmap-cli 0.1.1__py3-none-any.whl

roadmap/adapters/cli/milestones/archive_class.py

@@ -0,0 +1,236 @@
+"""MilestoneArchive command implementation using base class."""
+
+import shutil
+from pathlib import Path
+from typing import Any
+
+from roadmap.adapters.cli.crud import BaseArchive, EntityType
+from roadmap.adapters.persistence.parser import MilestoneParser
+
+
+class MilestoneArchive(BaseArchive):
+    """Archive milestone command implementation."""
+
+    entity_type = EntityType.MILESTONE
+
+    def get_entities_to_archive(
+        self, entity_id: str | None = None, all_closed: bool = False, **kwargs
+    ) -> list[Any]:
+        """Get milestones to archive based on criteria.
+
+        Args:
+            entity_id: Specific milestone name to archive
+            all_closed: Archive all closed milestones
+            **kwargs: Additional arguments
+
+        Returns:
+            List of milestones to archive
+        """
+        all_milestones = self.core.milestones.list()
+
+        if entity_id:
+            milestone = self.core.milestones.get(entity_id)
+            return [milestone] if milestone else []
+        elif all_closed:
+            return [m for m in all_milestones if m.status.value == "closed"]
+
+        return []
+
+    def validate_entity_before_archive(
+        self, entity: Any, **kwargs
+    ) -> tuple[bool, str | None]:
+        """Validate milestone before archiving.
+
+        Args:
+            entity: The milestone to validate
+            **kwargs: Additional arguments (e.g., force flag)
+
+        Returns:
+            Tuple of (is_valid, error_message)
+        """
+        # Allow archiving if force flag is set
+        if kwargs.get("force"):
+            return True, None
+
+        if entity.status.value != "closed":
+            return False, f"not closed (status: {entity.status.value})"
+        return True, None
+
+    def find_entity_files(self, entities: list[Any]) -> list[Path]:
+        """Find milestone files for entities.
+
+        Args:
+            entities: List of milestones
+
+        Returns:
+            List of file paths
+        """
+        roadmap_dir = Path.cwd() / ".roadmap"
+        milestones_dir = roadmap_dir / "milestones"
+
+        files = []
+        for entity in entities:
+            # Search for milestone file by name
+            for md_file in milestones_dir.glob("*.md"):
+                try:
+                    milestone = MilestoneParser.parse_milestone_file(md_file)
+                    if milestone.name == entity.name:
+                        files.append(md_file)
+                        break
+                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_milestone_files",
+                    )
+                    continue
+        return files
+
+    def execute(self, entity_id: str | None = None, **kwargs) -> bool:
+        """Execute archive operation.
+
+        Archives milestones by moving files and setting the archived flag.
+
+        Args:
+            entity_id: Optional milestone name
+            **kwargs: Filter options (all_closed, etc.)
+
+        Returns:
+            True if successful
+        """
+        try:
+            entities = self.get_entities_to_archive(entity_id, **kwargs)
+
+            if not entities:
+                self.console.print(
+                    f"No {self.entity_type.value}s to archive",
+                    style="yellow",
+                )
+                return False
+
+            # Validate entities
+            invalid_entities = []
+            for entity in entities:
+                is_valid, error_msg = self.validate_entity_before_archive(
+                    entity, **kwargs
+                )
+                if not is_valid:
+                    invalid_entities.append((entity, error_msg))
+                    self.console.print(
+                        f"⚠️  Cannot archive {entity.name}: {error_msg}",
+                        style="yellow",
+                    )
+
+            if invalid_entities:
+                invalid_entity_names = {entity.name for entity, _ in invalid_entities}
+                entities = [e for e in entities if e.name not in invalid_entity_names]
+                if not entities:
+                    return False
+
+            # Find files
+            files_to_archive = self.find_entity_files(entities)
+
+            if not files_to_archive:
+                self.console.print(
+                    f"Could not find files for {len(entities)} {self.entity_type.value}(s)",
+                    style="yellow",
+                )
+                return False
+
+            # Archive with folder structure preservation
+            from roadmap.adapters.cli.crud.crud_helpers import (
+                display_archive_success,
+                get_archive_dir,
+            )
+
+            archive_dir = get_archive_dir(self.entity_type)
+            archive_dir.mkdir(parents=True, exist_ok=True)
+
+            archived_files = []
+            failed_count = 0
+
+            for file_path in files_to_archive:
+                try:
+                    archive_file = archive_dir / file_path.name
+                    if archive_file.exists():
+                        failed_count += 1
+                        continue
+
+                    # Ensure parent directory exists and use rename (mv) for atomicity
+                    archive_file.parent.mkdir(parents=True, exist_ok=True)
+                    file_path.rename(archive_file)
+                    archived_files.append(archive_file)
+
+                except Exception as e:
+                    self.console.print(
+                        f"⚠️  Failed to archive {file_path.name}: {str(e)}",
+                        style="yellow",
+                    )
+                    failed_count += 1
+
+            # Update state (set archived flag and move associated issues)
+            self.post_archive_hook(archived_files, entities, **kwargs)
+
+            # Display results
+            display_archive_success(
+                self.entity_type,
+                len(archived_files),
+                failed_count,
+                console=self.console,
+            )
+
+            return True
+
+        except Exception as e:
+            self.console.print(
+                f"❌ Archive operation failed: {str(e)}",
+                style="red",
+            )
+            import click
+
+            raise click.ClickException(str(e)) from e
+
+    def post_archive_hook(
+        self, archived_files: list[Path], entities: list[Any], **kwargs
+    ) -> None:
+        """Handle post-archive state updates.
+
+        Moves associated issues folder and sets archived flag.
+
+        Args:
+            archived_files: Files that were archived
+            entities: Entities that were archived
+            **kwargs: Additional arguments
+        """
+        # Move associated issues folder to archive
+        roadmap_dir = Path.cwd() / ".roadmap"
+
+        for entity in entities:
+            issues_dir = roadmap_dir / "issues" / entity.name
+            if issues_dir.exists():
+                archive_issues_dir = roadmap_dir / "archive" / "issues" / entity.name
+                archive_issues_dir.parent.mkdir(parents=True, exist_ok=True)
+
+                try:
+                    shutil.move(str(issues_dir), str(archive_issues_dir))
+                except Exception as e:
+                    self.console.print(
+                        f"⚠️  Warning: Failed to move issues for milestone {entity.name}: {e}",
+                        style="yellow",
+                    )
+
+            # Set archived flag
+            try:
+                self.core.milestones.update_milestone(
+                    name=entity.name,
+                    archived=True,
+                )
+            except Exception as e:
+                self.console.print(
+                    f"⚠️  Warning: Failed to mark milestone {entity.name} as archived: {e}",
+                    style="yellow",
+                )

roadmap/adapters/cli/milestones/assign.py

@@ -0,0 +1,62 @@
+"""Assign issue to milestone 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("assign")
+@click.argument("issue_id")
+@click.argument("milestone_name")
+@click.pass_context
+@require_initialized
+@log_command("milestone_assign", entity_type="milestone", track_duration=True)
+def assign_milestone(ctx: click.Context, issue_id: str, milestone_name: str):
+    """Assign an issue to a milestone."""
+    core = ctx.obj["core"]
+
+    try:
+        with track_database_operation("update", "milestone", warn_threshold_ms=2000):
+            success = core.issues.assign_to_milestone(issue_id, milestone_name)
+
+        if success:
+            extra_details = {"Milestone": milestone_name}
+            lines = format_operation_success(
+                "✅", "Assigned", "", issue_id, None, extra_details
+            )
+            for line in lines:
+                console.print(line, style="green")
+        else:
+            lines = format_operation_failure(
+                "Assign", issue_id, "Issue or milestone not found"
+            )
+            for line in lines:
+                console.print(line, style="bold red")
+            raise click.Abort()
+    except click.Abort:
+        raise
+    except Exception as e:
+        handle_cli_error(
+            error=e,
+            operation="milestone_assign",
+            entity_type="milestone",
+            entity_id=milestone_name,
+            context={"issue_id": issue_id, "milestone_name": milestone_name},
+            fatal=True,
+        )
+        lines = format_operation_failure("Assign", issue_id, str(e))
+        for line in lines:
+            console.print(line, style="bold red")
+        raise click.Abort() from e

roadmap/adapters/cli/milestones/close.py

@@ -0,0 +1,177 @@
+"""Close milestone command.
+
+SEMANTICS:
+- Close: Changes status to 'closed', keeps files in place (no file movement), archived=false
+- Archive: Moves files to archive directory AND sets archived=true flag (signals sync to delete remotely)
+
+This separation allows for flexible status management without workspace reorganization.
+"""
+
+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()
+
+
+def _display_open_issues(milestone_name: str, open_issues: list) -> None:
+    """Display open issues in milestone and provide guidance.
+
+    Args:
+        milestone_name: Name of milestone
+        open_issues: List of open issues
+    """
+    console.print(
+        f"\n⚠️  Cannot close milestone: {len(open_issues)} open issue(s) remain",
+        style="bold yellow",
+    )
+    console.print(f"\n📋 Open issues in '{milestone_name}':", style="cyan")
+
+    for issue in open_issues[:10]:  # Show first 10
+        console.print(
+            f"   • {issue.id[:8]} - {issue.title} [{issue.status.value}]",
+            style="dim",
+        )
+
+    if len(open_issues) > 10:
+        console.print(f"   ... and {len(open_issues) - 10} more", style="dim")
+
+    console.print(
+        "\n💡 Options to proceed:",
+        style="cyan",
+    )
+    console.print(
+        "   1. Close the open issues: roadmap issue close <issue_id>",
+        style="dim",
+    )
+    console.print(
+        "   2. Migrate to backlog: roadmap issue update <issue_id> --milestone ''",
+        style="dim",
+    )
+    console.print(
+        "   3. Move to a different milestone: roadmap issue update <issue_id> --milestone 'New Milestone'",
+        style="dim",
+    )
+    console.print(
+        f"   4. Use --force to close anyway (not recommended): roadmap milestone close '{milestone_name}' --force",
+        style="dim",
+    )
+
+
+def _confirm_milestone_close(
+    milestone_name: str, total_issues: int, force: bool
+) -> bool:
+    """Confirm milestone closure with user.
+
+    Args:
+        milestone_name: Name of milestone
+        total_issues: Total number of issues
+        force: Skip confirmation if True
+
+    Returns:
+        True if user confirmed or force is True
+    """
+    if force:
+        return True
+
+    return click.confirm(
+        f"Close milestone '{milestone_name}'? All {total_issues} issue(s) are completed."
+    )
+
+
+def _close_milestone_in_db(core, milestone_name: str) -> bool:
+    """Close milestone in database.
+
+    Args:
+        core: RoadmapCore instance
+        milestone_name: Name of milestone
+
+    Returns:
+        True if successful
+    """
+    from roadmap.core.domain import MilestoneStatus
+
+    with track_database_operation("update", "milestone"):
+        return core.milestones.update(milestone_name, status=MilestoneStatus.CLOSED)
+
+
+@click.command("close")
+@click.argument("milestone_name")
+@click.option("--force", is_flag=True, help="Skip confirmation prompt")
+@click.pass_context
+@require_initialized
+@log_command("milestone_close", entity_type="milestone", track_duration=True)
+def close_milestone(ctx: click.Context, milestone_name: str, force: bool):
+    """Close a milestone.
+
+    Validates that all issues in the milestone are closed before allowing closure.
+    If there are open issues, provides guidance on migration options.
+    """
+    core = ctx.obj["core"]
+
+    try:
+        # Check if milestone exists
+        milestone = core.milestones.get(milestone_name)
+        if not milestone:
+            lines = format_operation_failure(
+                "Close", milestone_name, "Milestone not found"
+            )
+            for line in lines:
+                console.print(line, style="bold red")
+            raise click.Abort()
+
+        # Get all issues in this milestone
+        all_issues = core.issues.list(milestone=milestone_name)
+
+        # Filter for open issues (not closed)
+        open_issues = [issue for issue in all_issues if issue.status.value != "closed"]
+
+        # If there are open issues, provide guidance and return
+        if open_issues:
+            _display_open_issues(milestone_name, open_issues)
+            return
+
+        # All issues are closed, confirm and proceed
+        if not _confirm_milestone_close(milestone_name, len(all_issues), force):
+            console.print("❌ Milestone close cancelled.", style="yellow")
+            return
+
+        # Close milestone in database
+        success = _close_milestone_in_db(core, milestone_name)
+
+        if success:
+            extra_details = {"Completed issues": str(len(all_issues))}
+            lines = format_operation_success(
+                "✅", "Closed", milestone_name, "", None, extra_details
+            )
+            for line in lines:
+                console.print(line, style="green")
+        else:
+            lines = format_operation_failure(
+                "Close", milestone_name, "Failed to update status"
+            )
+            for line in lines:
+                console.print(line, style="bold red")
+
+    except Exception as e:
+        handle_cli_error(
+            error=e,
+            operation="close_milestone",
+            entity_type="milestone",
+            entity_id=milestone_name,
+            context={"force": force},
+            fatal=True,
+        )
+        lines = format_operation_failure("Close", milestone_name, str(e))
+        for line in lines:
+            console.print(line, style="bold red")

roadmap/adapters/cli/milestones/create.py

@@ -0,0 +1,131 @@
+"""Create milestone command."""
+
+import re
+
+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 MilestoneBuilder
+from roadmap.common.logging import (
+    log_command,
+    verbose_output,
+)
+
+
+def _validate_milestone_name(name: str) -> tuple[bool, str | None]:
+    """Validate milestone name against naming conventions.
+
+    Args:
+        name: The milestone name to validate
+
+    Returns:
+        Tuple of (is_valid, error_message)
+    """
+    # Check for invalid characters
+    if not re.match(r"^[a-zA-Z0-9_\-\.]+$", name):
+        return (
+            False,
+            "Milestone name contains invalid characters. Use only: letters, numbers, hyphens, underscores, dots",
+        )
+
+    # Check for version patterns with dots (should use hyphens instead)
+    if re.match(r"^v\d+\.\d+", name):  # e.g., v1.0., v1.0.2, v2.0
+        suggested = name.replace(".", "-")
+        return (
+            False,
+            f"Version milestones should use hyphens, not dots.\n"
+            f"  Current:  {name}\n"
+            f"  Suggested: {suggested}",
+        )
+
+    # Valid milestone name
+    return True, None
+
+
+class MilestoneCreate(BaseCreate):
+    """Create milestone command implementation."""
+
+    entity_type = EntityType.MILESTONE
+
+    def build_entity_dict(self, title: str, **kwargs) -> dict:
+        """Build entity dictionary for milestone creation."""
+        create_dict = MilestoneBuilder.build_create_dict(
+            name=title,
+            description=kwargs.get("description"),
+            due_date=kwargs.get("due_date"),
+        )
+
+        # Add project_id if provided or auto-detected
+        if kwargs.get("project_id"):
+            create_dict["project_id"] = kwargs.get("project_id")
+
+        return create_dict
+
+
+@click.command("create")
+@click.option("--title", "-t", required=True, help="Milestone title")
+@click.option("--description", "-d", default="", help="Milestone description")
+@click.option("--due-date", help="Due date for milestone (YYYY-MM-DD format)")
+@click.option("--project", "-p", default=None, help="Project ID to assign milestone to")
+@click.pass_context
+@require_initialized
+@verbose_output
+@log_command("milestone_create", entity_type="milestone", track_duration=True)
+def create_milestone(
+    ctx: click.Context,
+    title: str,
+    description: str,
+    due_date: str,
+    project: str | None,
+):
+    """Create a new milestone."""
+    # Validate milestone name against naming conventions
+    is_valid, error_msg = _validate_milestone_name(title)
+    if not is_valid:
+        if error_msg is None:
+            error_msg = "Invalid milestone name"
+        raise click.ClickException(error_msg)
+
+    core = ctx.obj["core"]
+    creator = MilestoneCreate(core)
+
+    # Auto-detect project if not provided
+    project_id = project
+    if not project_id:
+        from roadmap.common.configuration import ConfigManager
+
+        # Try to get default project from config
+        config_manager = ConfigManager(core.config_file)
+        config = config_manager.load()
+
+        if config.behavior.default_project_id:
+            project_id = config.behavior.default_project_id
+            click.echo(
+                f"ℹ️  Assigning milestone to default project: {project_id}", err=False
+            )
+        else:
+            # Check how many projects exist
+            all_projects = list(core.projects.list())
+            if all_projects:
+                # Projects exist but no default - need clarification
+                if len(all_projects) > 1:
+                    raise click.ClickException(
+                        f"Multiple projects found ({len(all_projects)}). Please specify project with --project flag.\n"
+                        f"Available projects: {', '.join(p.id for p in all_projects)}"
+                    )
+                else:
+                    # Auto-assign to the only project
+                    project_id = all_projects[0].id
+                    click.echo(
+                        f"ℹ️  Assigning milestone to project: {all_projects[0].name} ({project_id})",
+                        err=False,
+                    )
+            # If no projects exist, that's OK - milestone can be created without a project
+
+    creator.execute(
+        title=title,
+        description=description,
+        due_date=due_date,
+        project_id=project_id,
+    )

roadmap/adapters/cli/milestones/delete.py

@@ -0,0 +1,27 @@
+"""Delete milestone 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 MilestoneDelete(BaseDelete):
+    """Delete milestone command implementation."""
+
+    entity_type = EntityType.MILESTONE
+
+
+@click.command("delete")
+@click.argument("milestone_id")
+@click.option("--yes", "-y", is_flag=True, help="Skip confirmation prompt")
+@click.pass_context
+@require_initialized
+@log_command("milestone_delete", entity_type="milestone", track_duration=True)
+def delete_milestone(ctx: click.Context, milestone_id: str, yes: bool):
+    """Delete a milestone."""
+    core = ctx.obj["core"]
+    deleter = MilestoneDelete(core)
+
+    deleter.execute(entity_id=milestone_id, force=yes)