roadmap-cli 0.1.1__py3-none-any.whl

roadmap/core/services/initialization/workflow.py

@@ -0,0 +1,182 @@
+"""Initialization workflow service for roadmap CLI.
+
+Orchestrates the core initialization workflow steps.
+"""
+
+import shutil
+from pathlib import Path
+
+import structlog
+
+from roadmap.common.console import get_console
+from roadmap.common.errors.exceptions import OperationError
+from roadmap.common.security import create_secure_directory
+from roadmap.infrastructure.coordination.core import RoadmapCore
+
+from .utils import InitializationManifest
+
+logger = structlog.get_logger()
+
+console = get_console()
+
+
+class InitializationWorkflow:
+    """Orchestrates the initialization workflow steps."""
+
+    def __init__(self, core: RoadmapCore):
+        """Initialize InitializationWorkflow.
+
+        Args:
+            core: Core roadmap instance.
+        """
+        self.core = core
+
+    def cleanup_existing(self) -> bool:
+        """Remove existing roadmap directory.
+
+        Returns:
+            True if successful, False otherwise
+
+        Raises:
+            OperationError: If removal fails
+        """
+        try:
+            if self.core.roadmap_dir.exists():
+                shutil.rmtree(self.core.roadmap_dir)
+            return True
+        except Exception as e:
+            raise OperationError(
+                operation="remove existing roadmap", reason=str(e)
+            ) from e
+
+    def create_structure(self) -> None:
+        """Create the basic roadmap structure."""
+        self.core.initialize()
+
+    def create_structure_preserve_data(self) -> bool:
+        """Create roadmap structure while preserving existing data.
+
+        If roadmap already exists, creates only missing directories and templates.
+        Returns True if successful, raises OperationError otherwise.
+
+        Raises:
+            OperationError: If creation fails
+        """
+        try:
+            roadmap_dir = self.core.roadmap_dir
+
+            # If directory doesn't exist, just do normal init
+            if not roadmap_dir.exists():
+                self.core.initialize()
+                return True
+
+            # Roadmap exists - create only missing parts
+            # Ensure subdirectories exist
+            for subdir in [
+                self.core.issues_dir,
+                self.core.milestones_dir,
+                self.core.projects_dir,
+                self.core.templates_dir,
+                self.core.artifacts_dir,
+            ]:
+                create_secure_directory(subdir, 0o755)
+
+            # Create templates only if missing
+            self._create_missing_templates()
+
+            # Update .gitignore (safe to call multiple times)
+            self.core._init_manager._update_gitignore()
+
+            return True
+        except Exception as e:
+            raise OperationError(
+                operation="create roadmap structure", reason=str(e)
+            ) from e
+
+    def _create_missing_templates(self) -> None:
+        """Create template files only if they don't exist."""
+        templates_dir = self.core.templates_dir
+
+        # Check if templates already exist
+        if list(templates_dir.glob("*.md")):
+            return  # Templates already exist, skip
+
+        # Otherwise create them via initialization manager
+        self.core._init_manager._create_default_templates()
+
+    def generate_config_file(self, user_name: str | None = None) -> None:
+        """Generate the config file with user information.
+
+        Args:
+            user_name: User name to store in config, auto-detected if None
+        """
+        from roadmap.common.configuration import ConfigManager
+
+        # Auto-detect user if not provided
+        if not user_name:
+            user_name = ConfigManager.auto_detect_user()
+            if not user_name:
+                user_name = "unknown"
+
+        # Auto-detect GitHub info
+        github_owner = ConfigManager.auto_detect_github_username()
+
+        # Create default config
+        config = ConfigManager.create_default_config(
+            user_name=user_name,
+            github_owner=github_owner,
+            github_repo=None,  # User would configure repo separately
+            github_enabled=False,  # Disabled by default
+        )
+
+        # Save config
+        manager = ConfigManager(self.core.config_file)
+        manager.save(config)
+
+    def ensure_gitignore_entry(self) -> None:
+        """Ensure config.yaml is in .gitignore to prevent accidental commits."""
+        gitignore_path = Path.cwd() / ".gitignore"
+        config_entry = ".roadmap/config.yaml"
+        config_entry_with_comment = (
+            ".roadmap/config.yaml  # Local user configuration (not to be shared)"
+        )
+
+        # If .gitignore doesn't exist, create it
+        if not gitignore_path.exists():
+            gitignore_path.write_text(
+                f"{config_entry_with_comment}\n.env.local\n.env.*.local\n"
+            )
+            return
+
+        # Read existing .gitignore
+        content = gitignore_path.read_text()
+
+        # Check if entry already exists (with or without comment)
+        if config_entry in content:
+            return  # Already there
+
+        # Append entry to .gitignore
+        if not content.endswith("\n"):
+            content += "\n"
+
+        content += f"\n{config_entry_with_comment}\n"
+        gitignore_path.write_text(content)
+
+    def record_created_paths(self, manifest: InitializationManifest) -> None:
+        """Record all created paths in the manifest."""
+        manifest.add_path(self.core.roadmap_dir)
+        manifest.add_path(self.core.projects_dir)
+        manifest.add_path(self.core.templates_dir)
+        manifest.add_path(self.core.config_file)
+
+    def rollback_on_error(self) -> None:
+        """Remove created roadmap directory on error."""
+        if self.core.roadmap_dir.exists():
+            try:
+                shutil.rmtree(self.core.roadmap_dir)
+            except Exception as e:
+                logger.debug(
+                    "roadmap_dir_cleanup_failed",
+                    error=str(e),
+                    action="cleanup_roadmap_dir",
+                )

roadmap/core/services/initialization_service.py

@@ -0,0 +1,111 @@
+"""Initialization service for roadmap CLI.
+
+This module handles project initialization workflow including
+project detection, creation, GitHub setup, and validation.
+"""
+
+from pathlib import Path
+from typing import Any
+
+from roadmap.common.logging import get_logger
+from roadmap.common.logging.error_logging import (
+    log_error_with_context,
+)
+from roadmap.common.observability.instrumentation import traced
+from roadmap.core.services.initialization import (
+    InitializationValidator,
+    InitializationWorkflow,
+)
+from roadmap.core.services.project_init.detection import ProjectDetectionService
+from roadmap.infrastructure.coordination.core import RoadmapCore
+
+logger = get_logger(__name__)
+
+
+class ProjectInitializationService:
+    """Orchestrates project initialization workflow."""
+
+    def __init__(self, core: RoadmapCore):
+        """Initialize the service.
+
+        Args:
+            core: RoadmapCore instance for this initialization
+        """
+        self.core = core
+        self.workflow = InitializationWorkflow(core)
+
+    @traced("validate_prerequisites")
+    def validate_prerequisites(self, force: bool = False) -> tuple[bool, str]:
+        """Validate initialization prerequisites.
+
+        Args:
+            force: Whether force re-initialization is requested
+
+        Returns:
+            Tuple of (is_valid, error_message)
+        """
+        lock_path = Path.cwd() / ".roadmap_init.lock"
+        is_valid, error_msg = InitializationValidator.validate_lockfile(lock_path)
+        if not is_valid:
+            return is_valid, error_msg or ""
+
+        is_valid, error_msg = InitializationValidator.check_existing_roadmap(
+            self.core, force
+        )
+        return is_valid, error_msg or ""
+
+    @traced("handle_force_reinitialization")
+    def handle_force_reinitialization(self) -> bool:
+        """Handle force re-initialization when roadmap already exists.
+
+        Returns:
+            True if successful
+        """
+        try:
+            return self.workflow.cleanup_existing()
+        except Exception as e:
+            log_error_with_context(
+                e,
+                operation="cleanup_existing",
+                entity_type="Roadmap",
+            )
+            logger.error(
+                "Failed to cleanup existing roadmap",
+                error=str(e),
+                severity="operational",
+            )
+            return False
+
+    @traced("detect_existing_projects")
+    def detect_existing_projects(self) -> list[dict[str, Any]]:
+        """Detect existing projects in the roadmap.
+
+        Returns:
+            List of project info dictionaries
+        """
+        projects_dir = self.core.roadmap_dir / "projects"
+        return ProjectDetectionService.detect_existing_projects(projects_dir)
+
+    @traced("validate_finalization")
+    def validate_finalization(self, project_info: dict[str, Any] | None = None) -> bool:
+        """Validate the initialized roadmap and finalize.
+
+        Args:
+            project_info: Project info dict if project was created
+
+        Returns:
+            True if validation passes
+        """
+        try:
+            return InitializationValidator.post_init_validate(
+                self.core, self.core.roadmap_dir.name, project_info
+            )
+        except Exception as e:
+            log_error_with_context(
+                e,
+                operation="post_init_validate",
+                entity_type="Roadmap",
+                additional_context={"project_info": project_info},
+            )
+            logger.error("Validation failed", error=str(e), severity="operational")
+            return False

roadmap/core/services/issue/__init__.py

@@ -0,0 +1 @@
+"""Package initialization file."""

roadmap/core/services/issue/assignee_validation_service.py

@@ -0,0 +1,312 @@
+"""Assignee validation strategies for RoadmapCore."""
+
+from typing import Any, Protocol
+
+from roadmap.common.logging.error_logging import (
+    log_error_with_context,
+    log_validation_error,
+)
+from roadmap.common.observability.instrumentation import traced
+
+
+class AssigneeValidationResult:
+    """Result of assignee validation."""
+
+    def __init__(self, is_valid: bool, message: str = "", canonical_id: str = ""):
+        """Initialize validation result.
+
+        Args:
+            is_valid: Whether the assignee is valid
+            message: Error message if invalid, or warning message
+            canonical_id: Canonical ID if valid
+        """
+        self.is_valid = is_valid
+        self.message = message
+        self.canonical_id = canonical_id
+
+
+class GitHubBackend(Protocol):
+    """Protocol for GitHub-based validation backends.
+
+    Abstracts GitHub validation away from core logic.
+    """
+
+    def validate(self, assignee: str) -> tuple[bool, str, str]:
+        """Validate assignee against GitHub.
+
+        Args:
+            assignee: Username to validate
+
+        Returns:
+            Tuple of (is_valid, error_message, canonical_id)
+        """
+        ...
+
+
+class IdentitySystemValidator:
+    """Validates assignees using the identity management system."""
+
+    def __init__(self, root_path: str | Any):
+        """Initialize with roadmap root path.
+
+        Args:
+            root_path: Path to roadmap root directory
+        """
+        self.root_path = root_path
+
+    def validate(self, assignee: str) -> AssigneeValidationResult:
+        """Validate assignee using identity management system.
+
+        Args:
+            assignee: Username to validate
+
+        Returns:
+            Validation result with canonical ID if successful
+        """
+        # Identity system not available - return special marker
+        return AssigneeValidationResult(
+            is_valid=False, message="", canonical_id="identity-unavailable"
+        )
+
+    def get_validation_mode(self) -> str:
+        """Get the configured validation mode.
+
+        Returns:
+            Validation mode string (e.g., 'hybrid', 'local-only', 'github-only')
+        """
+        return "local-only"
+
+
+class LocalValidator:
+    """Validates assignees using basic local rules."""
+
+    @traced("validate_assignee_local")
+    def validate(self, assignee: str) -> AssigneeValidationResult:
+        """Validate assignee using basic local rules.
+
+        Args:
+            assignee: Username to validate
+
+        Returns:
+            Validation result
+        """
+        # Basic validation for local usage
+        if len(assignee) >= 2 and not any(char in assignee for char in "<>{}[]()"):
+            return AssigneeValidationResult(is_valid=True, canonical_id=assignee)
+        else:
+            error = ValueError(f"'{assignee}' is not a valid assignee name")
+            log_validation_error(
+                error,
+                entity_type="Assignee",
+                field_name="assignee",
+                proposed_value=assignee,
+            )
+            return AssigneeValidationResult(
+                is_valid=False, message=f"'{assignee}' is not a valid assignee name"
+            )
+
+
+class AssigneeValidationStrategy:
+    """Orchestrates assignee validation using multiple strategies."""
+
+    def __init__(
+        self,
+        root_path: str | Any,
+        github_config: tuple[str, str, str] | None = None,
+        cached_members: set[str] | list[str] | None = None,
+    ):
+        """Initialize validation strategy.
+
+        Args:
+            root_path: Path to roadmap root directory
+            github_config: Optional tuple of (token, owner, repo) for GitHub validation
+            cached_members: Optional cached team members for performance
+        """
+        self.root_path = root_path
+        self.github_config = github_config
+        self.cached_members = cached_members
+
+        self.identity_validator = IdentitySystemValidator(root_path)
+        self.local_validator = LocalValidator()
+
+    def _validate_empty(self, assignee: str) -> tuple[bool, str, str] | None:
+        """Check if assignee is empty."""
+        if not assignee or not assignee.strip():
+            return False, "Assignee cannot be empty", ""
+        return None
+
+    def _try_identity_validation(self, assignee: str) -> tuple[bool, str, str] | None:
+        """Try validating with identity system."""
+        identity_result = self.identity_validator.validate(assignee)
+        if identity_result.is_valid:
+            return True, "", identity_result.canonical_id
+        return None
+
+    def _try_identity_unavailable_path(
+        self, assignee: str, identity_result
+    ) -> tuple[bool, str, str] | None:
+        """Handle case where identity system is unavailable."""
+        if identity_result.canonical_id != "identity-unavailable":
+            return None
+
+        if self.github_config:
+            token, owner, repo = self.github_config
+            if token and owner and repo:
+                github_result = self._validate_with_github(assignee)
+                if github_result.is_valid:
+                    return True, "", github_result.canonical_id
+                else:
+                    return False, github_result.message, ""
+
+        local_result = self.local_validator.validate(assignee)
+        if local_result.is_valid:
+            return True, "", local_result.canonical_id
+        else:
+            return False, local_result.message, ""
+
+    def _try_identity_failed_path(self, assignee: str, validation_mode: str):
+        """Try fallback validation when identity system failed."""
+        if self._should_use_github_validation(validation_mode):
+            github_result = self._validate_with_github(assignee)
+            if github_result.is_valid:
+                return True, "", github_result.canonical_id
+            elif validation_mode == "github-only":
+                return False, github_result.message, ""
+
+        if self._should_use_local_validation(validation_mode):
+            local_result = self.local_validator.validate(assignee)
+            if local_result.is_valid:
+                return True, "", local_result.canonical_id
+            else:
+                return False, local_result.message, ""
+
+        return None
+
+    @traced("validate_assignee_strategy")
+    def validate(self, assignee: str) -> tuple[bool, str, str]:
+        """Validate assignee using appropriate strategy.
+
+        Args:
+            assignee: Username to validate
+
+        Returns:
+            Tuple of (is_valid, error_message, canonical_id)
+        """
+        try:
+            # Check for empty assignee
+            empty_result = self._validate_empty(assignee)
+            if empty_result is not None:
+                is_valid, message, _ = empty_result
+                if not is_valid:
+                    log_validation_error(
+                        ValueError(message),
+                        entity_type="Assignee",
+                        field_name="assignee",
+                        proposed_value=assignee,
+                    )
+                return empty_result
+
+            assignee = assignee.strip()
+
+            # Try identity system first
+            identity_result = self.identity_validator.validate(assignee)
+            identity_valid = self._try_identity_validation(assignee)
+            if identity_valid is not None:
+                return identity_valid
+
+            # Handle identity unavailable case
+            identity_unavailable_result = self._try_identity_unavailable_path(
+                assignee, identity_result
+            )
+            if identity_unavailable_result is not None:
+                return identity_unavailable_result
+
+            # Identity system is available but validation failed
+            validation_mode = identity_result.canonical_id or "local-only"
+
+            # Try fallback validation paths
+            fallback_result = self._try_identity_failed_path(assignee, validation_mode)
+            if fallback_result is not None:
+                return fallback_result
+
+            # No fallback available, return identity system result
+            if not identity_result.is_valid:
+                log_validation_error(
+                    ValueError(identity_result.message),
+                    entity_type="Assignee",
+                    field_name="assignee",
+                    proposed_value=assignee,
+                )
+            return False, identity_result.message, ""
+        except Exception as e:
+            log_error_with_context(
+                e,
+                operation="validate_assignee",
+                entity_type="Assignee",
+                additional_context={"assignee": assignee},
+            )
+            raise
+
+    def _should_use_github_validation(self, validation_mode: str) -> bool:
+        """Check if GitHub validation should be attempted.
+
+        Args:
+            validation_mode: Current validation mode
+
+        Returns:
+            True if GitHub validation should be used
+        """
+        if not self.github_config:
+            return False
+
+        token, owner, repo = self.github_config
+        if not (token and owner and repo):
+            return False
+
+        return validation_mode in ["hybrid", "github-only"]
+
+    def _should_use_local_validation(self, validation_mode: str) -> bool:
+        """Check if local validation should be attempted.
+
+        Args:
+            validation_mode: Current validation mode
+
+        Returns:
+            True if local validation should be used
+        """
+        # Use local validation if GitHub is not configured
+        if not self.github_config:
+            return validation_mode in ["local-only", "hybrid"]
+
+        token, owner, repo = self.github_config
+        if not (token and owner and repo):
+            return validation_mode in ["local-only", "hybrid"]
+
+        return False
+
+    @traced("validate_assignee_github")
+    def _validate_with_github(self, assignee: str) -> AssigneeValidationResult:
+        """Validate using GitHub.
+
+        Args:
+            assignee: Username to validate
+
+        Returns:
+            Validation result
+        """
+        if not self.github_config:
+            return AssigneeValidationResult(
+                is_valid=False, message="GitHub not configured"
+            )
+
+        token, owner, repo = self.github_config
+        # Import here to avoid hard dependency on infrastructure
+        from roadmap.infrastructure.validation.github_validator import (
+            GitHubAssigneeValidator,
+        )
+
+        github_validator = GitHubAssigneeValidator(
+            token, owner, repo, self.cached_members
+        )
+        result = github_validator.validate(assignee)
+        return result