roadmap-cli 0.1.1__py3-none-any.whl

roadmap/adapters/cli/config/commands.py

@@ -0,0 +1,198 @@
+"""Configuration management commands."""
+
+import click
+from structlog import get_logger
+
+from roadmap.common.configuration import ConfigLoader
+from roadmap.common.console import get_console
+
+logger = get_logger()
+console = get_console()
+
+
+@click.group("config")
+def config():
+    """Manage roadmap configuration."""
+
+
+@config.command("view")
+@click.option(
+    "--project",
+    is_flag=True,
+    help="Show project-level config instead of user-level",
+)
+@click.option(
+    "--level",
+    type=click.Choice(["user", "project", "merged"], case_sensitive=False),
+    default="merged",
+    help="Which config level to view (default: merged)",
+)
+def view(project: bool, level: str):
+    """View current configuration."""
+    # Handle legacy --project flag
+    if project:
+        level = "project"
+
+    try:
+        if level == "user":
+            config_obj = ConfigLoader.load_user_config()
+            source = "User-level config (~/.roadmap/config.yaml)"
+        elif level == "project":
+            config_obj = ConfigLoader.load_project_config()
+            source = "Project-level config (.roadmap/config.yaml)"
+        else:  # merged
+            config_obj = ConfigLoader.load_config()
+            source = "Merged configuration (defaults + user + project)"
+
+        if config_obj is None and level != "merged":
+            console.print(f"[yellow]No {level} configuration file found.[/yellow]")
+            return
+
+        console.print(f"\n[bold blue]{source}[/bold blue]")
+        console.print("=" * 60)
+
+        if config_obj:
+            # Pretty-print as YAML-like structure
+            data = config_obj.model_dump(exclude_none=True)
+            _print_config_dict(data, indent=0)
+        else:
+            console.print("[dim]Using all defaults[/dim]")
+
+        console.print()
+
+    except Exception as e:
+        console.print(f"[bold red]Error:[/bold red] {str(e)}", style="bold red")
+        raise click.ClickException(str(e)) from e
+
+
+@config.command("get")
+@click.argument("key")
+def get_cmd(key: str):
+    """Get a configuration value by key (e.g., 'export.directory')."""
+    try:
+        value = ConfigLoader.get_config_value(key)
+        if value is None:
+            console.print(
+                f"[yellow]Configuration key '{key}' not found.[/yellow]",
+                style="yellow",
+            )
+        else:
+            console.print(f"[cyan]{key}[/cyan]: {value}")
+    except Exception as e:
+        console.print(f"[bold red]Error:[/bold red] {str(e)}", style="bold red")
+        raise click.ClickException(str(e)) from e
+
+
+@config.command("set")
+@click.argument("key")
+@click.argument("value")
+@click.option(
+    "--project",
+    is_flag=True,
+    help="Set in project-level config instead of user-level",
+)
+def set_cmd(key: str, value: str, project: bool):
+    """Set a configuration value by key (e.g., 'export.format json')."""
+    try:
+        # Try to parse value as boolean or other types
+        parsed_value = _parse_config_value(value)
+
+        success = ConfigLoader.set_config_value(
+            key, parsed_value, project_level=project
+        )
+
+        if success:
+            level = "project" if project else "user"
+            console.print(
+                f"[green]✓[/green] Set [cyan]{key}[/cyan] = {parsed_value} in {level} config"
+            )
+        else:
+            console.print(f"[red]✗[/red] Failed to set {key}", style="bold red")
+            raise click.ClickException(f"Failed to set {key}")
+
+    except Exception as e:
+        console.print(f"[bold red]Error:[/bold red] {str(e)}", style="bold red")
+        raise click.ClickException(str(e)) from e
+
+
+@config.command("reset")
+@click.option(
+    "--project",
+    is_flag=True,
+    help="Reset project-level config instead of user-level",
+)
+@click.confirmation_option(prompt="Are you sure you want to reset the configuration?")
+def reset(project: bool):
+    """Reset configuration to defaults."""
+    try:
+        if project:
+            path = ConfigLoader.get_project_config_path()
+            path.unlink(missing_ok=True)
+            console.print(
+                "[green]✓[/green] Reset project-level configuration", style="green"
+            )
+        else:
+            path = ConfigLoader.get_user_config_path()
+            path.unlink(missing_ok=True)
+            console.print(
+                "[green]✓[/green] Reset user-level configuration", style="green"
+            )
+    except Exception as e:
+        console.print(f"[bold red]Error:[/bold red] {str(e)}", style="bold red")
+        raise click.ClickException(str(e)) from e
+
+
+def _print_config_dict(data: dict, indent: int = 0):
+    """Pretty-print configuration dictionary.
+
+    Args:
+        data: Dictionary to print
+        indent: Current indentation level
+    """
+    for key, value in data.items():
+        if isinstance(value, dict):
+            console.print(f"{'  ' * indent}[bold]{key}:[/bold]")
+            _print_config_dict(value, indent + 1)
+        else:
+            console.print(f"{'  ' * indent}[cyan]{key}[/cyan]: {value}")
+
+
+def _parse_config_value(value: str):
+    """Parse string value to appropriate Python type.
+
+    Args:
+        value: String value to parse
+
+    Returns:
+        Parsed value (bool, int, float, or str)
+    """
+    # Try boolean
+    if value.lower() in ("true", "yes", "on"):
+        return True
+    if value.lower() in ("false", "no", "off"):
+        return False
+
+    # Try integer
+    try:
+        return int(value)
+    except ValueError as e:
+        logger.debug(
+            "int_conversion_failed",
+            value=value,
+            error=str(e),
+            action="parse_config_value",
+        )
+
+    # Try float
+    try:
+        return float(value)
+    except ValueError as e:
+        logger.debug(
+            "float_conversion_failed",
+            value=value,
+            error=str(e),
+            action="parse_config_value",
+        )
+
+    # Return as string
+    return value

roadmap/adapters/cli/console_exports.py

@@ -0,0 +1,10 @@
+"""Utility functions for CLI operations.
+
+This module re-exports core utilities from roadmap.common to maintain
+backward compatibility with existing CLI code.
+"""
+
+# Re-export console utilities from common module to avoid duplication
+from roadmap.common.console import get_console, is_testing_environment
+
+__all__ = ["get_console", "is_testing_environment"]

roadmap/adapters/cli/core.py

@@ -0,0 +1,26 @@
+"""Core CLI commands: init and status.
+
+These are the fundamental commands needed to get started with Roadmap.
+"""
+
+import click
+
+from roadmap.adapters.cli.init import init
+from roadmap.adapters.cli.status import health, status
+from roadmap.common.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+@click.group()
+@click.pass_context
+def core(ctx: click.Context) -> None:
+    """Core roadmap commands for initialization and status."""
+    if ctx.obj is None:
+        ctx.obj = {}
+
+
+# Register commands
+core.add_command(init)
+core.add_command(status)
+core.add_command(health)

roadmap/adapters/cli/crud/__init__.py

@@ -0,0 +1,47 @@
+"""CRUD operations base classes and shared utilities.
+
+This module provides:
+- Base classes for Create, Update, Delete, Archive, Restore operations
+- Shared CRUD helpers and utilities
+- Entity-specific builders and validators
+- Template method pattern for extensible CRUD implementations
+"""
+
+from roadmap.adapters.cli.crud.base_archive import BaseArchive
+from roadmap.adapters.cli.crud.base_create import BaseCreate
+from roadmap.adapters.cli.crud.base_delete import BaseDelete
+from roadmap.adapters.cli.crud.base_restore import BaseRestore
+from roadmap.adapters.cli.crud.base_update import BaseUpdate
+from roadmap.adapters.cli.crud.crud_helpers import (
+    CRUDOperation,
+    EntityType,
+    collect_archive_files,
+    display_archive_success,
+    display_restore_success,
+    format_entity_id,
+    format_entity_title,
+    get_active_dir,
+    get_archive_dir,
+    validate_entity_exists,
+)
+
+__all__ = [
+    # Enums
+    "EntityType",
+    "CRUDOperation",
+    # Base classes
+    "BaseCreate",
+    "BaseUpdate",
+    "BaseDelete",
+    "BaseArchive",
+    "BaseRestore",
+    # Helpers
+    "validate_entity_exists",
+    "format_entity_title",
+    "format_entity_id",
+    "collect_archive_files",
+    "get_archive_dir",
+    "get_active_dir",
+    "display_archive_success",
+    "display_restore_success",
+]

roadmap/adapters/cli/crud/base_archive.py

@@ -0,0 +1,208 @@
+"""Base class for archive operations across all entity types."""
+
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Any
+
+import click
+
+from roadmap.adapters.cli.crud.crud_helpers import (
+    EntityType,
+    display_archive_success,
+    get_active_dir,
+    get_archive_dir,
+)
+from roadmap.common.console import get_console
+
+
+class BaseArchive(ABC):
+    """Abstract base class for entity archive commands using Template Method pattern.
+
+    Subclasses must implement:
+    - entity_type: The EntityType this archives
+    - get_entities_to_archive(): Determine what entities to archive based on filters
+    - post_archive_hook(): Update database and handle entity-specific logic
+
+    Subclasses may override:
+    - validate_entity_before_archive(): Custom validation before archiving
+    - find_entity_files(): Custom file finding logic (default: filesystem search)
+
+    This class handles the overall archive workflow:
+    1. Determine entities to archive (via get_entities_to_archive)
+    2. Find corresponding files
+    3. Move files to archive
+    4. Update state via post_archive_hook
+    5. Display results
+    """
+
+    entity_type: EntityType
+
+    def __init__(self, core: Any, console: Any = None) -> None:
+        """Initialize archive command.
+
+        Args:
+            core: The core application context
+            console: Optional console for output (uses default if not provided)
+        """
+        self.core = core
+        self.console = console or get_console()
+
+    @abstractmethod
+    def get_entities_to_archive(
+        self, entity_id: str | None = None, **filters
+    ) -> list[Any]:
+        """Determine which entities should be archived.
+
+        Args:
+            entity_id: Optional specific entity ID to archive
+            **filters: Entity-specific filter criteria (e.g., all_closed, orphaned)
+
+        Returns:
+            List of entities to archive
+        """
+
+    @abstractmethod
+    def post_archive_hook(
+        self, archived_files: list[Path], entities: list[Any], **kwargs
+    ) -> None:
+        """Handle entity-specific state updates after archiving.
+
+        Override to update database, send notifications, etc.
+
+        Args:
+            archived_files: List of files that were archived
+            entities: List of entities that were archived
+            **kwargs: Original CLI arguments
+        """
+
+    def validate_entity_before_archive(
+        self, entity: Any, **kwargs
+    ) -> tuple[bool, str | None]:
+        """Validate entity before archiving.
+
+        Allows subclasses to add entity-specific validation rules.
+
+        Args:
+            entity: The entity being considered for archive
+            **kwargs: Original CLI arguments (e.g., force flag)
+
+        Returns:
+            Tuple of (is_valid, error_message_or_none)
+        """
+        return True, None
+
+    def find_entity_files(self, entities: list[Any]) -> list[Path]:
+        """Find file paths corresponding to entities.
+
+        Override if entity-to-file mapping is non-standard.
+
+        Args:
+            entities: List of entities to find files for
+
+        Returns:
+            List of file paths
+        """
+        active_dir = get_active_dir(self.entity_type)
+        files = []
+        for entity in entities:
+            # Search by entity ID prefix
+            matching = list(active_dir.rglob(f"{str(entity.id)[:8]}*.md"))
+            if matching:
+                files.append(matching[0])
+        return files
+
+    def execute(self, entity_id: str | None = None, **kwargs) -> bool:
+        """Execute archive operation (Template Method).
+
+        Args:
+            entity_id: Optional specific entity ID to archive
+            **kwargs: Entity-specific filters and options
+
+        Returns:
+            True if archive succeeded
+        """
+        try:
+            # Step 1: Determine which entities to archive
+            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
+
+            # Step 2: 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))
+
+            if invalid_entities:
+                for entity, error_msg in invalid_entities:
+                    self.console.print(
+                        f"⚠️  Cannot archive {entity.id}: {error_msg}",
+                        style="yellow",
+                    )
+                # Continue with valid entities if any
+                entities = [e for e in entities if (e, None) not in invalid_entities]
+                if not entities:
+                    return False
+
+            # Step 3: Find corresponding 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
+
+            # Step 4: Move files to archive
+            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
+
+                    archive_file.write_text(file_path.read_text())
+                    file_path.unlink()
+                    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
+
+            # Step 5: Update state via hook
+            self.post_archive_hook(archived_files, entities, **kwargs)
+
+            # Step 6: 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",
+            )
+            raise click.ClickException(str(e)) from e

roadmap/adapters/cli/crud/base_create.py

@@ -0,0 +1,154 @@
+"""Base class for create operations across all entity types."""
+
+from abc import ABC, abstractmethod
+from typing import Any
+
+from roadmap.adapters.cli.crud.crud_helpers import EntityType
+from roadmap.adapters.cli.crud.crud_utils import (
+    create_entity_by_type,
+    get_entity_id,
+    get_entity_title,
+)
+from roadmap.adapters.cli.presentation.crud_presenter import CreatePresenter
+from roadmap.common.console import get_console
+from roadmap.common.errors.exceptions import ValidationError
+from roadmap.common.logging import log_audit_event
+
+
+class BaseCreate(ABC):
+    """Abstract base class for entity creation commands.
+
+    Subclasses implement:
+    - entity_type: The EntityType this creates
+    - build_entity_dict(): Convert CLI args to entity dict
+    - post_create_hook(): Optional hook after creation (default: no-op)
+
+    Uses Template Method pattern for extensibility.
+    """
+
+    entity_type: EntityType
+
+    def __init__(self, core: Any, console: Any = None) -> None:
+        """Initialize create command.
+
+        Args:
+            core: The core application context
+            console: Optional console for output (uses default if not provided)
+        """
+        self.core = core
+        self.console = console or get_console()
+
+    @abstractmethod
+    def build_entity_dict(self, **kwargs) -> dict[str, Any]:
+        """Convert CLI arguments to entity dictionary.
+
+        Args:
+            **kwargs: All click option values
+
+        Returns:
+            Dictionary of entity fields to create
+
+        Raises:
+            ValidationError: If arguments are invalid
+        """
+        ...
+
+    def post_create_hook(self, entity: Any, **kwargs) -> None:  # noqa: B027
+        """Handle entity creation completion with optional custom logic.
+
+        Override to handle:
+        - Git branch creation
+        - Milestone assignments
+        - Custom notifications
+
+        Args:
+            entity: The created entity
+            **kwargs: Original CLI arguments
+        """
+        ...
+
+    def execute(self, title: str, **kwargs) -> Any | None:
+        """Execute the create operation.
+
+        Args:
+            title: Entity title/name
+            **kwargs: All other CLI arguments
+
+        Returns:
+            Created entity, or None if creation failed
+        """
+        try:
+            # Build entity from arguments
+            entity_dict = self.build_entity_dict(title=title, **kwargs)
+
+            # Create via appropriate service
+            entity = self._create_entity(entity_dict)
+            if entity is None:
+                return None
+
+            # Run post-creation hooks
+            self.post_create_hook(entity, **kwargs)
+
+            # Log audit event for successful creation
+            entity_id = self._get_id(entity)
+            log_audit_event(
+                action="create",
+                entity_type=self.entity_type.value,
+                entity_id=entity_id,
+                after=entity_dict,
+            )
+
+            # Display success
+            self._display_success(entity)
+
+            return entity
+
+        except ValidationError:
+            # ValidationError will be handled by centralized CLI exception handler
+            # which formats it and directs to stderr
+            raise
+        except Exception:
+            # Other exceptions will also be handled by centralized handler
+            raise
+
+    def _create_entity(self, entity_dict: dict[str, Any]) -> Any | None:
+        """Create entity via appropriate service.
+
+        Args:
+            entity_dict: Dictionary of entity fields
+
+        Returns:
+            Created entity or None if failed
+        """
+        return create_entity_by_type(self.core, self.entity_type, entity_dict)
+
+    def _display_success(self, entity: Any) -> None:
+        """Display success message using presenter.
+
+        Args:
+            entity: The created entity
+        """
+        presenter = CreatePresenter()
+        presenter.render(entity)
+
+    def _get_title(self, entity: Any) -> str:
+        """Get entity title/name.
+
+        Args:
+            entity: The entity object
+
+        Returns:
+            Title or name string
+        """
+        return get_entity_title(entity)
+
+    def _get_id(self, entity: Any) -> str:
+        """Get entity ID.
+
+        Args:
+            entity: The entity object
+
+        Returns:
+            Entity ID string
+        """
+        return get_entity_id(entity)