roadmap-cli 0.1.1__py3-none-any.whl

roadmap/infrastructure/coordination/initialization.py

@@ -0,0 +1,348 @@
+"""Roadmap initialization and setup management.
+
+Handles creation of new roadmap projects, directory structures,
+configuration files, and git integration setup.
+"""
+
+import sqlite3
+from pathlib import Path
+from typing import Optional
+
+from roadmap.adapters.persistence.database_manager import DatabaseError, DatabaseManager
+from roadmap.common.logging import get_logger
+from roadmap.common.security import (
+    create_secure_directory,
+    create_secure_file,
+)
+from roadmap.common.utils.path_utils import build_roadmap_paths
+
+logger = get_logger(__name__)
+
+
+class InitializationManager:
+    """Manages roadmap initialization, configuration, and setup."""
+
+    def __init__(self, root_path: Path, roadmap_dir_name: str = ".roadmap"):
+        """Initialize the manager with paths.
+
+        Args:
+            root_path: Root directory of the project
+            roadmap_dir_name: Name of the roadmap directory (default: .roadmap)
+        """
+        self.root_path = root_path
+        self.roadmap_dir_name = roadmap_dir_name
+
+        # Build all standard roadmap paths
+        paths = build_roadmap_paths(root_path, roadmap_dir_name)
+        self.roadmap_dir = paths["roadmap_dir"]
+        self.issues_dir = paths["issues_dir"]
+        self.milestones_dir = paths["milestones_dir"]
+        self.projects_dir = paths["projects_dir"]
+        self.templates_dir = paths["templates_dir"]
+        self.artifacts_dir = paths["artifacts_dir"]
+        self.config_file = paths["config_file"]
+        self.db_dir = paths["db_dir"]
+
+    def is_initialized(self) -> bool:
+        """Check if roadmap is already initialized."""
+        return self.roadmap_dir.exists() and self.config_file.exists()
+
+    @classmethod
+    def find_existing_roadmap(
+        cls, root_path: Path | None = None, roadmap_dir_name: str = ".roadmap"
+    ) -> Optional["InitializationManager"]:
+        """Find an existing roadmap directory in the current path.
+
+        Searches for roadmap directory and returns a manager instance if found,
+        or None if no roadmap is detected.
+
+        Args:
+            root_path: Root path to search from (defaults to current directory)
+            roadmap_dir_name: Name of the roadmap directory to search for
+
+        Returns:
+            InitializationManager if roadmap found, None otherwise
+        """
+        search_path = root_path or Path.cwd()
+
+        # Common roadmap directory names to search for
+        possible_names = [roadmap_dir_name]
+
+        # Also check for any directory containing the expected structure
+        try:
+            for item in search_path.iterdir():
+                if item.is_dir() and item.name not in possible_names:
+                    possible_names.append(item.name)
+        except (OSError, PermissionError):
+            pass
+
+        # Check each possible directory
+        for dir_name in possible_names:
+            try:
+                potential_manager = cls(
+                    root_path=search_path, roadmap_dir_name=dir_name
+                )
+                if potential_manager.is_initialized():
+                    return potential_manager
+            except (OSError, PermissionError, sqlite3.OperationalError):
+                # Skip directories that can't be accessed
+                continue
+
+        return None
+
+    def initialize(self) -> None:
+        """Initialize a new roadmap in the current directory.
+
+        Raises:
+            ValueError: If roadmap is already initialized
+        """
+        if self.is_initialized():
+            raise ValueError("Roadmap already initialized in this directory")
+
+        # Create directory structure with secure permissions
+        create_secure_directory(self.roadmap_dir, 0o755)
+        create_secure_directory(self.issues_dir, 0o755)
+        create_secure_directory(self.milestones_dir, 0o755)
+        create_secure_directory(self.projects_dir, 0o755)
+        create_secure_directory(self.templates_dir, 0o755)
+        create_secure_directory(self.artifacts_dir, 0o755)
+
+        # Update .gitignore to exclude roadmap local data
+        self._update_gitignore()
+
+        # Create templates
+        self._create_default_templates()
+
+        # Create default config file
+        self._create_default_config()
+
+        # Initialize database file in project-local directory
+        self._initialize_database()
+
+    def _initialize_database(self) -> None:
+        """Create and validate the project-local database file."""
+        try:
+            create_secure_directory(self.db_dir, 0o755)
+            db_path = self.db_dir / "state.db"
+            db_manager = DatabaseManager(db_path=db_path)
+            db_manager.validate_read_write()
+        except (OSError, DatabaseError) as e:
+            logger.error(
+                "database_init_failed",
+                db_path=str(self.db_dir / "state.db"),
+                error=str(e),
+                error_type=type(e).__name__,
+                severity="system_error",
+            )
+            raise RuntimeError(
+                f"Failed to initialize database at {self.db_dir / 'state.db'}: {e}"
+            ) from e
+
+    def _create_default_templates(self) -> None:
+        """Create default templates for issues, milestones, and projects."""
+        # Issue template
+        issue_template = """---
+id: "{{ issue_id }}"
+title: "{{ title }}"
+priority: "medium"
+status: "todo"
+milestone: ""
+labels: []
+github_issue: null
+created: "{{ created_date }}"
+updated: "{{ updated_date }}"
+assignee: ""
+---
+
+# {{ title }}
+
+## Description
+
+Brief description of the issue or feature request.
+
+## Acceptance Criteria
+
+- [ ] Criterion 1
+- [ ] Criterion 2
+- [ ] Criterion 3
+
+## Technical Notes
+
+Any technical details, considerations, or implementation notes.
+
+## Related Issues
+
+- Links to related issues
+- Dependencies
+
+## Additional Context
+
+Any additional context, screenshots, or examples."""
+
+        with create_secure_file(self.templates_dir / "issue.md", "w", 0o644) as f:
+            f.write(issue_template)
+
+        # Milestone template
+        milestone_template = """---
+name: "{{ milestone_name }}"
+description: "{{ description }}"
+due_date: "{{ due_date }}"
+status: "open"
+github_milestone: null
+created: "{{ created_date }}"
+updated: "{{ updated_date }}"
+---
+
+# {{ milestone_name }}
+
+## Description
+
+{{ description }}
+
+## Goals
+
+- [ ] Goal 1
+- [ ] Goal 2
+- [ ] Goal 3
+
+## Success Criteria
+
+Define what success looks like for this milestone.
+
+## Notes
+
+Any additional notes or considerations for this milestone."""
+
+        with create_secure_file(self.templates_dir / "milestone.md", "w", 0o644) as f:
+            f.write(milestone_template)
+
+        # Project template
+        project_template = """---
+id: "{{ project_id }}"
+name: "{{ project_name }}"
+description: "{{ project_description }}"
+status: "planning"
+priority: "medium"
+owner: "{{ project_owner }}"
+start_date: "{{ start_date }}"
+target_end_date: "{{ target_end_date }}"
+actual_end_date: null
+created: "{{ created_date }}"
+updated: "{{ updated_date }}"
+milestones:
+  - "{{ milestone_1 }}"
+  - "{{ milestone_2 }}"
+estimated_hours: {{ estimated_hours }}
+actual_hours: null
+---
+
+# {{ project_name }}
+
+## Project Overview
+
+{{ project_description }}
+
+**Project Owner:** {{ project_owner }}
+**Status:** {{ status }}
+**Timeline:** {{ start_date }} → {{ target_end_date }}
+
+## Objectives
+
+- [ ] Objective 1
+- [ ] Objective 2
+- [ ] Objective 3
+
+## Milestones & Timeline
+
+{% for milestone in milestones %}
+- **{{ milestone }}** - [Link to milestone](../milestones/{{ milestone }}.md)
+{% endfor %}
+
+## Timeline Tracking
+
+- **Start Date:** {{ start_date }}
+- **Target End Date:** {{ target_end_date }}
+- **Actual End Date:** {{ actual_end_date }}
+- **Estimated Hours:** {{ estimated_hours }}
+- **Actual Hours:** {{ actual_hours }}
+
+## Notes
+
+Project notes and additional context.
+
+---
+*Last updated: {{ updated_date }}*"""
+
+        with create_secure_file(self.templates_dir / "project.md", "w", 0o644) as f:
+            f.write(project_template)
+
+    def _create_default_config(self) -> None:
+        """Create default configuration file."""
+        import yaml
+
+        config_data = {
+            "project_name": "My Roadmap",
+            "github": {
+                "owner": None,
+                "repo": None,
+                "enabled": False,
+                "sync_enabled": False,
+                "sync_backend": "github",  # Default to github backend
+                "webhook_secret": None,
+                "sync_settings": {
+                    "bidirectional": True,
+                    "auto_close": True,
+                    "sync_labels": True,
+                    "sync_milestones": True,
+                },
+            },
+            "defaults": {
+                "priority": "medium",
+                "issue_type": "other",
+            },
+            "features": {
+                "github_integration": False,
+                "git_sync": False,
+            },
+        }
+
+        with create_secure_file(self.config_file, "w", 0o644) as f:
+            yaml.dump(config_data, f, default_flow_style=False)
+
+    def _update_gitignore(self) -> None:
+        """Update .gitignore to exclude roadmap local data from version control."""
+        gitignore_path = self.root_path / ".gitignore"
+
+        # Define patterns to ignore
+        roadmap_patterns = [
+            f"{self.roadmap_dir_name}/artifacts/",
+            f"{self.roadmap_dir_name}/backups/",
+            f"{self.roadmap_dir_name}/logs/",
+            f"{self.roadmap_dir_name}/*.tmp",
+            f"{self.roadmap_dir_name}/*.lock",
+        ]
+        gitignore_comment = (
+            "# Roadmap local data (generated exports, backups, logs, temp files)"
+        )
+
+        # Read existing .gitignore if it exists
+        existing_lines = []
+        if gitignore_path.exists():
+            existing_lines = gitignore_path.read_text().splitlines()
+
+        # Check which patterns are already present
+        missing_patterns = []
+        for pattern in roadmap_patterns:
+            if not any(line.strip() == pattern for line in existing_lines):
+                missing_patterns.append(pattern)
+
+        if missing_patterns:
+            # Add missing patterns
+            if existing_lines and not existing_lines[-1].strip() == "":
+                existing_lines.append("")
+
+            existing_lines.append(gitignore_comment)
+            existing_lines.extend(missing_patterns)
+
+            # Write updated .gitignore
+            gitignore_path.write_text("\n".join(existing_lines) + "\n")

roadmap/infrastructure/coordination/issue_coordinator.py

@@ -0,0 +1,154 @@
+"""Issue Coordinator - Coordinates issue-related operations.
+
+Extracted from RoadmapCore to reduce god object complexity.
+Provides a focused API for all issue-related concerns.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from roadmap.core.domain import IssueType, Priority, Status
+from roadmap.infrastructure.coordination.issue_operations import IssueOperations
+
+if TYPE_CHECKING:
+    from roadmap.core.domain import Issue
+    from roadmap.infrastructure.coordination.core import RoadmapCore
+
+
+class IssueCoordinator:
+    """Coordinates all issue-related operations."""
+
+    def __init__(self, issue_ops: IssueOperations, core: RoadmapCore | None = None):
+        """Initialize coordinator with issue operations manager.
+
+        Args:
+            issue_ops: IssueOperations instance
+            core: RoadmapCore instance for initialization checks
+        """
+        self._ops = issue_ops
+        self._core = core
+
+    # CRUD Operations
+    def create(
+        self,
+        title: str,
+        priority: Priority = Priority.MEDIUM,
+        issue_type: IssueType = IssueType.OTHER,
+        milestone: str | None = None,
+        labels: list[str] | None = None,
+        assignee: str | None = None,
+        estimated_hours: float | None = None,
+        depends_on: list[str] | None = None,
+        blocks: list[str] | None = None,
+        status: str | None = None,
+        content: str | None = None,
+    ) -> Issue:
+        """Create a new issue."""
+        return self._ops.create_issue(
+            title=title,
+            priority=priority,
+            issue_type=issue_type,
+            milestone=milestone,
+            labels=labels,
+            assignee=assignee,
+            estimated_hours=estimated_hours,
+            depends_on=depends_on,
+            blocks=blocks,
+            status=status,
+            content=content,
+        )
+
+    def list(
+        self,
+        milestone: str | None = None,
+        status: Status | None = None,
+        priority: Priority | None = None,
+        issue_type: IssueType | None = None,
+        assignee: str | None = None,
+    ) -> list[Issue]:
+        """List issues with optional filtering."""
+        return self._ops.list_issues(
+            milestone=milestone,
+            status=status,
+            priority=priority,
+            issue_type=issue_type,
+            assignee=assignee,
+        )
+
+    def list_all_including_archived(self) -> list[Issue]:
+        """List all issues including archived ones.
+
+        Used by sync operations that need to compare both active and archived issues.
+
+        Returns:
+            List of all Issue objects (both active and archived)
+        """
+        return self._ops.list_all_including_archived()
+
+    def get(self, issue_id: str) -> Issue | None:
+        """Get a specific issue by ID."""
+        return self._ops.get_issue(issue_id)
+
+    def update(self, issue_id: str, **updates) -> Issue | None:
+        """Update an existing issue."""
+        return self._ops.update_issue(issue_id, **updates)
+
+    def delete(self, issue_id: str) -> bool:
+        """Delete an issue."""
+        return self._ops.delete_issue(issue_id)
+
+    # Milestone-related queries
+    def get_backlog(self) -> list[Issue]:
+        """Get all issues not assigned to any milestone (backlog)."""
+        return self._ops.get_backlog_issues()
+
+    def get_by_milestone(self, milestone_name: str) -> list[Issue]:
+        """Get all issues assigned to a specific milestone."""
+        return self._ops.get_milestone_issues(milestone_name)
+
+    def get_grouped_by_milestone(self) -> dict[str, list[Issue]]:
+        """Get all issues grouped by milestone, including backlog."""
+        return self._ops.get_issues_by_milestone()
+
+    def move_to_milestone(self, issue_id: str, milestone_name: str | None) -> bool:
+        """Move an issue to a milestone or to backlog if milestone_name is None."""
+        return self._ops.move_issue_to_milestone(issue_id, milestone_name)
+
+    def assign_to_milestone(self, issue_id: str, milestone_name: str) -> bool:
+        """Assign an issue to a milestone."""
+        return self._ops.assign_issue_to_milestone(issue_id, milestone_name)
+
+    def batch_assign_to_milestone(
+        self,
+        issue_ids: list[str],
+        milestone_name: str,
+        preloaded_issues: list | None = None,
+    ) -> tuple[int, int]:
+        """Batch assign multiple issues to a milestone in a single pass.
+
+        Args:
+            issue_ids: List of issue IDs to assign
+            milestone_name: The milestone name to assign to
+            preloaded_issues: Optional pre-loaded list of issues (avoids filesystem scan)
+
+        Returns:
+            Tuple of (successful_count, failed_count)
+        """
+        return self._ops.batch_assign_to_milestone(
+            issue_ids, milestone_name, preloaded_issues
+        )
+
+    def get_similar_milestone_names(
+        self, milestone_name: str, max_results: int = 3
+    ) -> list[str]:
+        """Find milestone names similar to the given name.
+
+        Args:
+            milestone_name: The milestone name to find similar matches for
+            max_results: Maximum number of suggestions to return
+
+        Returns:
+            List of similar milestone names found
+        """
+        return self._ops.get_similar_milestone_names(milestone_name, max_results)