roadmap-cli 0.1.1__py3-none-any.whl

roadmap/adapters/cli/projects/archive_class.py

@@ -0,0 +1,96 @@
+"""ProjectArchive command implementation using base class."""
+
+from pathlib import Path
+from typing import Any
+
+from roadmap.adapters.cli.crud import BaseArchive, EntityType
+
+
+class ProjectArchive(BaseArchive):
+    """Archive project command implementation."""
+
+    entity_type = EntityType.PROJECT
+
+    def get_entities_to_archive(
+        self, entity_id: str | None = None, **kwargs
+    ) -> list[Any]:
+        """Get projects to archive.
+
+        Args:
+            entity_id: Specific project ID to archive
+            **kwargs: Additional arguments
+
+        Returns:
+            List of projects to archive
+        """
+        if entity_id:
+            project = self.core.projects.get(entity_id)
+            return [project] if project else []
+
+        if kwargs.get("all_closed"):
+            return [
+                project
+                for project in self.core.projects.list()
+                if getattr(project.status, "value", project.status) == "completed"
+            ]
+
+        return []
+
+    def validate_entity_before_archive(
+        self, entity: Any, **kwargs
+    ) -> tuple[bool, str | None]:
+        """Validate project before archiving.
+
+        Args:
+            entity: The project to validate
+            **kwargs: Additional arguments (e.g., force flag)
+
+        Returns:
+            Tuple of (is_valid, error_message)
+        """
+        if kwargs.get("force"):
+            return True, None
+
+        status = getattr(entity.status, "value", entity.status)
+        if status != "completed":
+            return False, f"not completed (status: {status})"
+        return True, None
+
+    def find_entity_files(self, entities: list[Any]) -> list[Path]:
+        """Find project files for entities.
+
+        Args:
+            entities: List of projects
+
+        Returns:
+            List of file paths
+        """
+        roadmap_dir = Path.cwd() / ".roadmap"
+        projects_dir = roadmap_dir / "projects"
+
+        files = []
+        for entity in entities:
+            # Search for project file by ID prefix
+            matching = list(projects_dir.glob(f"{str(entity.id)[:8]}*.md"))
+            if matching:
+                files.append(matching[0])
+        return files
+
+    def post_archive_hook(
+        self, archived_files: list[Path], entities: list[Any], **kwargs
+    ) -> None:
+        """Handle post-archive state updates.
+
+        Args:
+            archived_files: Files that were archived
+            entities: Entities that were archived
+            **kwargs: Additional arguments
+        """
+        for entity in entities:
+            try:
+                self.core.db.mark_project_archived(entity.id, archived=True)
+            except Exception as e:
+                self.console.print(
+                    f"⚠️  Warning: Failed to mark project {entity.id} as archived: {e}",
+                    style="yellow",
+                )

roadmap/adapters/cli/projects/close.py

@@ -0,0 +1,94 @@
+"""Close project command - sets status to closed without archiving."""
+
+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,
+)
+from roadmap.core.domain import ProjectStatus
+
+console = get_console()
+
+
+@click.command("close")
+@click.argument("project_id")
+@click.option("--force", is_flag=True, help="Skip confirmation prompt")
+@click.pass_context
+@require_initialized
+@log_command("project_close", entity_type="project", track_duration=True)
+def close_project(ctx: click.Context, project_id: str, force: bool):
+    """Close a project (sets status to closed).
+
+    This command marks a project as completed while keeping its file active.
+    Use `roadmap project archive` as the separate cleanup step when the
+    project file should move under `.roadmap/archive/projects/`.
+    """
+    core = ctx.obj["core"]
+
+    try:
+        # Check if project exists
+        project = core.projects.get(project_id)
+        if not project:
+            lines = format_operation_failure("Close", project_id, "Project not found")
+            for line in lines:
+                console.print(line, style="bold red")
+            raise click.Abort()
+
+        # Confirm closure
+        if not force:
+            if not click.confirm(f"Close project '{project.name}'?"):
+                console.print("❌ Project close cancelled.", style="yellow")
+                return
+
+        # Close project in database
+        with track_database_operation(
+            "update", "project", entity_id=project_id, warn_threshold_ms=2000
+        ):
+            updated_project = core.projects.update(
+                project_id, status=ProjectStatus.COMPLETED
+            )
+
+        if updated_project:
+            extra_details = {"Status": "Closed"}
+            lines = format_operation_success(
+                emoji="✅",
+                action="Closed",
+                entity_title=updated_project.name,
+                entity_id=project_id,
+                extra_details=extra_details,
+            )
+            for line in lines:
+                console.print(line, style="bold green" if "Closed" in line else "cyan")
+        else:
+            lines = format_operation_failure(
+                action="close",
+                entity_id=project_id,
+                error="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_project",
+            entity_type="project",
+            entity_id=project_id,
+            context={"force": force},
+            fatal=True,
+        )
+        lines = format_operation_failure(
+            action="close",
+            entity_id=project_id,
+            error=str(e),
+        )
+        for line in lines:
+            console.print(line, style="bold red")

roadmap/adapters/cli/projects/create.py

@@ -0,0 +1,50 @@
+"""Create project 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 ProjectBuilder
+from roadmap.common.logging import (
+    log_command,
+    verbose_output,
+)
+
+
+class ProjectCreate(BaseCreate):
+    """Create project command implementation."""
+
+    entity_type = EntityType.PROJECT
+
+    def build_entity_dict(self, title: str, **kwargs) -> dict:
+        """Build entity dictionary for project creation."""
+        return ProjectBuilder.build_create_dict(
+            name=title,
+            description=kwargs.get("description"),
+            repository=kwargs.get("repository"),
+        )
+
+
+@click.command("create")
+@click.option("--title", "-t", required=True, help="Project title")
+@click.option("--description", "-d", help="Project description")
+@click.option("--repository", "-r", help="Repository URL")
+@click.pass_context
+@require_initialized
+@verbose_output
+@log_command("project_create", entity_type="project", track_duration=True)
+def create_project(
+    ctx: click.Context,
+    title: str,
+    description: str,
+    repository: str,
+):
+    """Create a new project."""
+    core = ctx.obj["core"]
+    creator = ProjectCreate(core)
+
+    creator.execute(
+        title=title,
+        description=description,
+        repository=repository,
+    )

roadmap/adapters/cli/projects/delete.py

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

roadmap/adapters/cli/projects/list.py

@@ -0,0 +1,227 @@
+"""List projects command."""
+
+from datetime import UTC
+
+import click
+
+from roadmap.adapters.cli.cli_error_handlers import handle_cli_error
+from roadmap.adapters.cli.decorators import with_output_support
+from roadmap.common.console import get_console
+from roadmap.common.datetime_parser import UnifiedDateTimeParser
+from roadmap.common.formatters import ProjectTableFormatter
+from roadmap.common.logging import verbose_output
+from roadmap.common.models import ColumnType
+
+console = get_console()
+
+
+def _parse_project_metadata(file_path) -> dict | None:
+    """Parse project metadata from markdown file."""
+    try:
+        content = file_path.read_text()
+        if not content.startswith("---"):
+            return None
+
+        yaml_end = content.find("---", 3)
+        if yaml_end == -1:
+            return None
+
+        import yaml
+
+        yaml_content = content[3:yaml_end]
+        metadata = yaml.safe_load(yaml_content)
+
+        # Add ID from frontmatter if present, or extract from filename
+        if isinstance(metadata, dict) and not metadata.get("id"):
+            # Extract ID from filename (format: {id}-{name}.md)
+            filename_stem = file_path.stem
+            if "-" in filename_stem:
+                metadata["id"] = filename_stem.split("-", 1)[0]
+
+        return metadata if isinstance(metadata, dict) else None
+    except Exception as e:
+        from roadmap.common.logging import get_logger
+
+        logger = get_logger(__name__)
+        logger.debug(
+            "project_metadata_parse_failed",
+            error=str(e),
+            action="parse_project_metadata",
+        )
+        return None
+
+
+def _apply_status_filter(metadata, status):
+    """Check if project matches status filter."""
+    if not status:
+        return True
+    return metadata.get("status") == status
+
+
+def _apply_owner_filter(metadata, owner):
+    """Check if project matches owner filter."""
+    if not owner:
+        return True
+    return metadata.get("owner") == owner
+
+
+def _apply_priority_filter(metadata, priority):
+    """Check if project matches priority filter."""
+    if not priority:
+        return True
+    return metadata.get("priority") == priority
+
+
+def _apply_overdue_filter(metadata):
+    """Check if project is overdue."""
+    from datetime import datetime
+
+    target_end = metadata.get("target_end_date")
+    if not target_end:
+        return False
+
+    try:
+        if isinstance(target_end, str):
+            end_date = UnifiedDateTimeParser.parse_iso_datetime(target_end)
+            if not end_date:
+                return False
+        else:
+            end_date = target_end
+
+        end_date = end_date.replace(tzinfo=None) if end_date.tzinfo else end_date
+        now = datetime.now(UTC)
+
+        project_status = metadata.get("status", "")
+        if project_status in ["completed", "cancelled"]:
+            return False
+
+        return end_date < now
+    except (ValueError, AttributeError):
+        return False
+
+
+def _filter_projects(projects, status, owner, priority, overdue):
+    """Apply all filters to project list."""
+    filtered = []
+
+    for metadata in projects:
+        if not _apply_status_filter(metadata, status):
+            continue
+        if not _apply_owner_filter(metadata, owner):
+            continue
+        if not _apply_priority_filter(metadata, priority):
+            continue
+        if overdue and not _apply_overdue_filter(metadata):
+            continue
+
+        filtered.append(metadata)
+
+    return filtered
+
+
+@click.command("list")
+@click.option(
+    "--status",
+    type=click.Choice(["planning", "active", "on-hold", "completed", "cancelled"]),
+    help="Filter by status",
+)
+@click.option(
+    "--owner",
+    help="Filter by owner",
+)
+@click.option(
+    "--priority",
+    type=click.Choice(["critical", "high", "medium", "low"]),
+    help="Filter by priority",
+)
+@click.option(
+    "--overdue", is_flag=True, help="Show only overdue projects (past target end date)"
+)
+@click.option("--verbose", "-v", is_flag=True, help="Show verbose output")
+@click.pass_context
+@with_output_support(
+    available_columns=["id", "name", "status", "priority", "owner"],
+    column_types={
+        "id": ColumnType.STRING,
+        "name": ColumnType.STRING,
+        "status": ColumnType.ENUM,
+        "priority": ColumnType.ENUM,
+        "owner": ColumnType.STRING,
+    },
+)
+@verbose_output
+def list_projects(
+    ctx: click.Context,
+    status: str | None,
+    owner: str | None,
+    priority: str | None,
+    overdue: bool,
+    verbose: bool,  # noqa: F841 - Used by @verbose_output decorator
+):
+    """List all projects with optional filtering.
+
+    Supports output formatting with --format, --columns, --sort-by, --filter flags.
+    """
+    core = ctx.obj["core"]
+
+    try:
+        projects_dir = core.roadmap_dir / "projects"
+
+        if not projects_dir.exists():
+            console.print(
+                "No projects found. Create one with 'roadmap project create'",
+                style="yellow",
+            )
+            return
+
+        # Get all project files
+        project_files = list(projects_dir.rglob("*.md"))
+
+        if not project_files:
+            console.print(
+                "No projects found. Create one with 'roadmap project create'",
+                style="yellow",
+            )
+            return
+
+        # Parse all projects
+        project_metadatas = []
+        for file_path in project_files:
+            metadata = _parse_project_metadata(file_path)
+            if metadata:
+                project_metadatas.append(metadata)
+            else:
+                console.print(f"⚠️  Error reading {file_path.name}", style="yellow")
+
+        # Apply filters
+        filtered = _filter_projects(project_metadatas, status, owner, priority, overdue)
+
+        if not filtered:
+            console.print("No projects match the specified filters.", style="yellow")
+            return
+
+        # Convert to TableData for structured output
+        description = "filtered" if any([status, owner, priority, overdue]) else "all"
+        table_data = ProjectTableFormatter.projects_to_table_data(
+            filtered,
+            title="Projects",
+            description=description,
+        )
+
+        return table_data
+
+    except Exception as e:
+        handle_cli_error(
+            error=e,
+            operation="list_projects",
+            entity_type="project",
+            entity_id="all",
+            context={
+                "status": status,
+                "owner": owner,
+                "priority": priority,
+                "overdue": overdue,
+            },
+            fatal=True,
+        )
+        console.print(f"❌ Failed to list projects: {e}", style="bold red")

roadmap/adapters/cli/projects/restore.py

@@ -0,0 +1,87 @@
+"""Restore project command - move archived projects back to active."""
+
+import click
+
+from roadmap.adapters.cli.cli_command_helpers import require_initialized
+from roadmap.adapters.cli.projects.restore_class import ProjectRestore
+from roadmap.common.console import get_console
+from roadmap.common.logging import (
+    log_command,
+    verbose_output,
+)
+
+
+@click.command()
+@click.argument("project_name", required=False)
+@click.option(
+    "--all",
+    is_flag=True,
+    help="Restore all archived projects",
+)
+@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("project_restore", entity_type="project", track_duration=True)
+@require_initialized
+def restore_project(
+    ctx: click.Context,
+    project_name: str | None,
+    all: bool,
+    dry_run: bool,
+    force: bool,
+    verbose: bool,  # noqa: F841
+):
+    """Restore an archived project back to active projects.
+
+    This moves a project from .roadmap/archive/projects/ back to
+    .roadmap/projects/, making it active again.
+
+    Examples:
+        roadmap project restore "Project Name"
+        roadmap project restore --all
+        roadmap project restore "Project Name" --dry-run
+    """
+    core = ctx.obj["core"]
+    console = get_console()
+
+    restore = ProjectRestore(core, console)
+
+    if not project_name and not all:
+        console.print(
+            "❌ Error: Specify a project name or use --all",
+            style="bold red",
+        )
+        ctx.exit(1)
+
+    if project_name and all:
+        console.print(
+            "❌ Error: Cannot specify project name with --all",
+            style="bold red",
+        )
+        ctx.exit(1)
+
+    try:
+        restore.execute(
+            entity_id=project_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/projects/restore_class.py

@@ -0,0 +1,56 @@
+"""ProjectRestore command implementation using base class."""
+
+from pathlib import Path
+
+from roadmap.adapters.cli.crud import BaseRestore, EntityType
+
+
+class ProjectRestore(BaseRestore):
+    """Restore project command implementation."""
+
+    entity_type = EntityType.PROJECT
+
+    def get_archived_files_to_restore(
+        self, entity_id: str | None = None, **filters
+    ) -> list[Path]:
+        """Get archived project files to restore.
+
+        Args:
+            entity_id: Specific project ID 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 project file by ID prefix
+            matching = list(archive_dir.rglob(f"{entity_id[:8]}*.md"))
+            return matching if matching else []
+        else:
+            # Return all archived projects
+            return list(archive_dir.rglob("*.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
+        """
+        for file_path in restored_files:
+            try:
+                # Extract project ID from filename
+                project_id = file_path.stem.split("-")[0]
+                self.core.db.mark_project_archived(project_id, archived=False)
+            except Exception as e:
+                self.console.print(
+                    f"⚠️  Warning: Failed to update restoration status for {file_path.name}: {e}",
+                    style="yellow",
+                )

roadmap/adapters/cli/projects/update.py

@@ -0,0 +1,57 @@
+"""Update project 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 ProjectBuilder
+from roadmap.common.logging import log_command
+
+
+class ProjectUpdate(BaseUpdate):
+    """Update project command implementation."""
+
+    entity_type = EntityType.PROJECT
+
+    def build_update_dict(self, entity_id: str, **kwargs) -> dict:
+        """Build update dictionary for project."""
+        return ProjectBuilder.build_update_dict(
+            name=kwargs.get("name"),
+            description=kwargs.get("description"),
+            repository=kwargs.get("repository"),
+            status=kwargs.get("status"),
+        )
+
+
+@click.command("update")
+@click.argument("project_id")
+@click.option("--name", help="Update project name")
+@click.option("--description", "-d", help="Update project description")
+@click.option("--repository", "-r", help="Update repository URL")
+@click.option(
+    "--status",
+    type=click.Choice(["active", "inactive", "completed"]),
+    help="Update project status",
+)
+@click.pass_context
+@require_initialized
+@log_command("project_update", entity_type="project", track_duration=True)
+def update_project(
+    ctx: click.Context,
+    project_id: str,
+    name: str,
+    description: str,
+    repository: str,
+    status: str,
+):
+    """Update an existing project."""
+    core = ctx.obj["core"]
+    updater = ProjectUpdate(core)
+
+    updater.execute(
+        entity_id=project_id,
+        name=name,
+        description=description,
+        repository=repository,
+        status=status,
+    )