roadmap-cli 0.1.1__py3-none-any.whl

roadmap/adapters/cli/services/export_manager.py

@@ -0,0 +1,268 @@
+"""Export management service for handling data exports with config integration."""
+
+import json
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+from structlog import get_logger
+
+from roadmap.common.configuration import ConfigLoader
+from roadmap.common.console import get_console
+
+logger = get_logger()
+console = get_console()
+
+
+class ExportManager:
+    """Manages data exports using configuration system for defaults and locations."""
+
+    def __init__(self, project_root: Path | None = None):
+        """Initialize export manager.
+
+        Args:
+            project_root: Project root directory (defaults to cwd)
+        """
+        self.project_root = project_root or Path.cwd()
+        self.config = ConfigLoader.load_config(self.project_root)
+
+    def get_export_dir(self) -> Path:
+        """Get the export directory, creating it if needed.
+
+        Returns:
+            Path to export directory
+        """
+        export_dir = self.config.export.directory
+
+        # Handle relative vs absolute paths
+        if export_dir.startswith("/"):
+            # Absolute path
+            path = Path(export_dir)
+        else:
+            # Relative to project root
+            path = self.project_root / export_dir
+
+        # Create directory if it doesn't exist
+        path.mkdir(parents=True, exist_ok=True)
+
+        # Add to .gitignore if configured
+        if self.config.export.auto_gitignore:
+            self._add_to_gitignore(path)
+
+        return path
+
+    def _add_to_gitignore(self, path: Path) -> None:
+        """Add export directory to .gitignore if not already there.
+
+        Args:
+            path: Path to add to gitignore
+        """
+        gitignore_path = self.project_root / ".gitignore"
+
+        # Make path relative for .gitignore
+        try:
+            rel_path = path.relative_to(self.project_root)
+        except ValueError:
+            # Path is absolute, can't make it relative
+            rel_path = path
+
+        # Read existing gitignore
+        if gitignore_path.exists():
+            content = gitignore_path.read_text()
+        else:
+            content = ""
+
+        # Check if already present
+        gitignore_entry = str(rel_path) + "/"
+        if gitignore_entry in content:
+            return  # Already there
+
+        # Add to gitignore
+        if content and not content.endswith("\n"):
+            content += "\n"
+
+        content += f"{gitignore_entry}\n"
+        gitignore_path.write_text(content)
+        logger.info("added_to_gitignore", path=str(rel_path))
+
+    def generate_export_filename(self, entity_type: str, format_type: str) -> str:
+        """Generate a timestamped export filename.
+
+        Args:
+            entity_type: Type of entity being exported (issues, milestones, projects)
+            format_type: Export format (json, csv, markdown)
+
+        Returns:
+            Filename with timestamp
+        """
+        timestamp = datetime.now(UTC).strftime("%Y-%m-%d-%H%M%S")
+        return f"{entity_type}-{timestamp}.{format_type}"
+
+    def get_export_path(self, entity_type: str, format_type: str | None = None) -> Path:
+        """Get full export path with auto-generated filename.
+
+        Args:
+            entity_type: Type of entity being exported
+            format_type: Export format (uses config default if not specified)
+
+        Returns:
+            Full path to export file
+        """
+        if format_type is None:
+            format_type = self.config.export.format
+
+        export_dir = self.get_export_dir()
+        filename = self.generate_export_filename(entity_type, format_type)
+        return export_dir / filename
+
+    def export_json(self, data: Any, output_path: Path | None = None) -> str:
+        """Export data as JSON.
+
+        Args:
+            data: Data to export (usually list or dict)
+            output_path: Optional custom output path
+
+        Returns:
+            JSON string
+        """
+        if isinstance(data, list):
+            # Convert objects to dicts if needed
+            serializable = [
+                item.model_dump() if hasattr(item, "model_dump") else item
+                for item in data
+            ]
+        else:
+            serializable = data.model_dump() if hasattr(data, "model_dump") else data
+
+        json_str = json.dumps(serializable, indent=2, default=str)
+
+        if output_path:
+            output_path.parent.mkdir(parents=True, exist_ok=True)
+            output_path.write_text(json_str)
+            logger.info("exported_json", path=str(output_path))
+
+        return json_str
+
+    def export_csv(self, data: list[Any], output_path: Path | None = None) -> str:
+        """Export data as CSV.
+
+        Args:
+            data: List of objects to export
+            output_path: Optional custom output path
+
+        Returns:
+            CSV string
+        """
+        if not data:
+            csv_str = ""
+        else:
+            import csv
+            from io import StringIO
+
+            # Get headers from first item
+            first_item = data[0]
+            if hasattr(first_item, "model_dump"):
+                headers = first_item.model_dump().keys()
+                rows = [item.model_dump() for item in data]
+            else:
+                headers = first_item.keys() if isinstance(first_item, dict) else []
+                rows = data
+
+            # Write CSV
+            output = StringIO()
+            writer = csv.DictWriter(output, fieldnames=headers)
+            writer.writeheader()
+            writer.writerows(rows)
+            csv_str = output.getvalue()
+
+        if output_path:
+            output_path.parent.mkdir(parents=True, exist_ok=True)
+            output_path.write_text(csv_str)
+            logger.info("exported_csv", path=str(output_path))
+
+        return csv_str
+
+    def export_markdown(self, data: list[Any], output_path: Path | None = None) -> str:
+        """Export data as Markdown table.
+
+        Args:
+            data: List of objects to export
+            output_path: Optional custom output path
+
+        Returns:
+            Markdown string
+        """
+        if not data:
+            md_str = ""
+        else:
+            # Get headers from first item
+            first_item = data[0]
+            if hasattr(first_item, "model_dump"):
+                headers = list(first_item.model_dump().keys())
+                rows = [item.model_dump() for item in data]
+            else:
+                headers = (
+                    list(first_item.keys()) if isinstance(first_item, dict) else []
+                )
+                rows = data
+
+            # Build markdown table
+            md_lines = [
+                "| " + " | ".join(headers) + " |",
+                "| " + " | ".join(["---"] * len(headers)) + " |",
+            ]
+
+            for row in rows:
+                values = [
+                    str(row.get(h, "")) if isinstance(row, dict) else ""
+                    for h in headers
+                ]
+                md_lines.append("| " + " | ".join(values) + " |")
+
+            md_str = "\n".join(md_lines)
+
+        if output_path:
+            output_path.parent.mkdir(parents=True, exist_ok=True)
+            output_path.write_text(md_str)
+            logger.info("exported_markdown", path=str(output_path))
+
+        return md_str
+
+    def export_data(
+        self,
+        data: Any,
+        entity_type: str,
+        format_type: str | None = None,
+        output_path: Path | None = None,
+    ) -> tuple[str, Path]:
+        """Export data in specified format.
+
+        Args:
+            data: Data to export
+            entity_type: Type of entity being exported
+            format_type: Export format (uses config default if not specified)
+            output_path: Optional custom output path
+
+        Returns:
+            Tuple of (exported_content, file_path)
+        """
+        if format_type is None:
+            format_type = self.config.export.format
+
+        if output_path is None:
+            output_path = self.get_export_path(entity_type, format_type)
+
+        if format_type == "json":
+            content = self.export_json(data, output_path)
+        elif format_type == "csv":
+            content = self.export_csv(
+                data if isinstance(data, list) else [data], output_path
+            )
+        elif format_type == "markdown":
+            content = self.export_markdown(
+                data if isinstance(data, list) else [data], output_path
+            )
+        else:
+            raise ValueError(f"Unsupported export format: {format_type}")
+
+        return content, output_path

roadmap/adapters/cli/services/milestone_list_service.py

@@ -0,0 +1,266 @@
+"""Service layer for milestone list command.
+
+Handles all business logic related to:
+- Filtering milestones (overdue, open/closed, etc.)
+- Computing milestone progress
+- Calculating time estimates
+- Aggregating milestone data
+"""
+
+from datetime import UTC, datetime
+
+from roadmap.common.logging import get_logger
+from roadmap.infrastructure.coordination.core import RoadmapCore
+
+logger = get_logger(__name__)
+
+
+class MilestoneFilterService:
+    """Service for filtering and selecting milestones."""
+
+    @staticmethod
+    def filter_overdue_milestones(milestones: list) -> list:
+        """Filter to only overdue milestones.
+
+        Args:
+            milestones: List of milestone objects
+
+        Returns:
+            List of overdue milestones (past due date, status='open')
+        """
+        try:
+            now = datetime.now(UTC).replace(tzinfo=None)
+            filtered = []
+
+            for ms in milestones:
+                if ms.due_date:
+                    ms_due_date = (
+                        ms.due_date.replace(tzinfo=None)
+                        if ms.due_date.tzinfo
+                        else ms.due_date
+                    )
+                    if ms_due_date < now and ms.status.value == "open":
+                        filtered.append(ms)
+
+            return filtered
+        except Exception as e:
+            logger.error(
+                "failed_to_filter_overdue", error=str(e), severity="operational"
+            )
+            return []
+
+    @staticmethod
+    def filter_milestones(milestones: list, overdue_only: bool = False) -> list:
+        """Filter milestones based on criteria.
+
+        Args:
+            milestones: List of milestone objects
+            overdue_only: If True, only return overdue milestones
+
+        Returns:
+            Filtered list of milestones
+        """
+        if overdue_only:
+            return MilestoneFilterService.filter_overdue_milestones(milestones)
+        return milestones
+
+
+class MilestoneProgressService:
+    """Service for computing milestone progress."""
+
+    @staticmethod
+    def get_milestone_progress(core: RoadmapCore, milestone_name: str) -> dict:
+        """Get progress for a specific milestone.
+
+        Args:
+            core: RoadmapCore instance
+            milestone_name: Name of the milestone
+
+        Returns:
+            Dictionary with progress data:
+            {
+                'total': total issues,
+                'completed': completed issues,
+                'percentage': completion percentage,
+            }
+        """
+        try:
+            progress = core.milestones.get_progress(milestone_name)
+            return {
+                "total": progress.get("total", 0),
+                "completed": progress.get("completed", 0),
+                "percentage": (
+                    (progress.get("completed", 0) / progress.get("total", 1)) * 100
+                    if progress.get("total", 0) > 0
+                    else 0
+                ),
+            }
+        except Exception as e:
+            logger.error(
+                "failed_to_get_milestone_progress",
+                milestone=milestone_name,
+                error=str(e),
+                severity="operational",
+            )
+            return {"total": 0, "completed": 0, "percentage": 0}
+
+    @staticmethod
+    def get_all_milestones_progress(core: RoadmapCore, milestones: list) -> dict:
+        """Get progress for all milestones.
+
+        Args:
+            core: RoadmapCore instance
+            milestones: List of milestone objects
+
+        Returns:
+            Dictionary mapping milestone name to progress dict
+        """
+        progress_data = {}
+        for ms in milestones:
+            progress_data[ms.name] = MilestoneProgressService.get_milestone_progress(
+                core, ms.name
+            )
+        return progress_data
+
+
+class MilestoneTimeEstimateService:
+    """Service for calculating time estimates."""
+
+    @staticmethod
+    def get_milestone_time_estimate(milestone, all_issues: list) -> str:
+        """Get time estimate display string for a milestone.
+
+        Args:
+            milestone: Milestone object
+            all_issues: List of all issues in roadmap
+
+        Returns:
+            Formatted time estimate string (e.g., "32 hours", "N/A")
+        """
+        try:
+            estimate = milestone.get_estimated_time_display(all_issues)
+            return estimate if estimate else "-"
+        except Exception as e:
+            logger.error(
+                "failed_to_get_time_estimate",
+                milestone=milestone.name,
+                severity="operational",
+                error=str(e),
+            )
+            return "-"
+
+
+class MilestoneListService:
+    """Service for gathering and processing milestone list data."""
+
+    def __init__(self, core: RoadmapCore):
+        """Initialize milestone list service.
+
+        Args:
+            core: RoadmapCore instance
+        """
+        self.core = core
+
+    def get_milestones_list_data(self, overdue_only: bool = False) -> dict:
+        """Get all data needed for milestone list display.
+
+        Args:
+            overdue_only: If True, only return overdue milestones
+
+        Returns:
+            Dictionary with milestone list data:
+            {
+                'milestones': list of milestone objects,
+                'progress': dict mapping milestone name to progress,
+                'estimates': dict mapping milestone name to estimate,
+                'has_data': bool indicating if there are milestones,
+                'count': number of milestones,
+            }
+        """
+        try:
+            # Get milestones
+            milestones = self.core.milestones.list()
+
+            # Apply filters
+            milestones = MilestoneFilterService.filter_milestones(
+                milestones, overdue_only=overdue_only
+            )
+
+            # Get all issues for estimates
+            all_issues = self.core.issues.list()
+
+            # Compute progress for each milestone
+            progress = MilestoneProgressService.get_all_milestones_progress(
+                self.core, milestones
+            )
+
+            # Compute time estimates
+            estimates = {}
+            for ms in milestones:
+                estimates[ms.name] = (
+                    MilestoneTimeEstimateService.get_milestone_time_estimate(
+                        ms, all_issues
+                    )
+                )
+
+            return {
+                "milestones": milestones,
+                "progress": progress,
+                "estimates": estimates,
+                "has_data": bool(milestones),
+                "count": len(milestones),
+            }
+        except Exception as e:
+            logger.error(
+                "failed_to_get_milestones_list_data",
+                severity="operational",
+                error=str(e),
+            )
+            return {
+                "milestones": [],
+                "progress": {},
+                "estimates": {},
+                "has_data": False,
+                "count": 0,
+            }
+
+    def get_milestone_due_date_status(self, milestone) -> tuple[str, str | None]:
+        """Get due date string and styling for a milestone.
+
+        Args:
+            milestone: Milestone object
+
+        Returns:
+            Tuple of (due_date_string, style_markup or None)
+            - style_markup is None for no special styling
+            - style_markup is "bold red" for overdue
+            - style_markup is "yellow" for due within 7 days
+        """
+        if not milestone.due_date:
+            return ("-", None)
+
+        try:
+            now = datetime.now(UTC).replace(tzinfo=None)
+            ms_due_date = (
+                milestone.due_date.replace(tzinfo=None)
+                if milestone.due_date.tzinfo
+                else milestone.due_date
+            )
+
+            due_date_text = ms_due_date.strftime("%Y-%m-%d")
+
+            # Determine styling based on due date and status
+            if ms_due_date < now and milestone.status.value == "open":
+                return (due_date_text, "bold red")
+            elif (ms_due_date - now).days <= 7 and milestone.status.value == "open":
+                return (due_date_text, "yellow")
+
+            return (due_date_text, None)
+        except Exception as e:
+            logger.error(
+                "failed_to_get_due_date_status",
+                milestone=milestone.name,
+                severity="operational",
+                error=str(e),
+            )
+            return ("-", None)

roadmap/adapters/cli/services/project_initialization_service.py

@@ -0,0 +1,29 @@
+"""Project Initialization Service - Backward Compatibility Facade.
+
+DEPRECATED: This module is maintained for backward compatibility.
+Use roadmap.core.services.project_init package instead.
+
+New structure:
+- roadmap.core.services.project_init.detection - ProjectDetectionService
+- roadmap.core.services.project_init.context_detection - ProjectContextDetectionService
+- roadmap.core.services.project_init.template - ProjectTemplateService
+- roadmap.core.services.project_init.creation - ProjectCreationService
+"""
+
+from roadmap.adapters.persistence.parser import ProjectParser
+from roadmap.core.services.project_init import (
+    ProjectContextDetectionService,
+    ProjectCreationService,
+    ProjectDetectionService,
+    ProjectTemplateService,
+)
+from roadmap.infrastructure.coordination.core import RoadmapCore
+
+__all__ = [
+    "ProjectDetectionService",
+    "ProjectContextDetectionService",
+    "ProjectTemplateService",
+    "ProjectCreationService",
+    "ProjectParser",
+    "RoadmapCore",
+]