roadmap-cli 0.1.1__py3-none-any.whl

roadmap/adapters/cli/today.py

@@ -0,0 +1,52 @@
+"""Today command - daily workflow summary."""
+
+import click
+
+from roadmap.adapters.cli.cli_command_helpers import require_initialized
+from roadmap.adapters.cli.presentation.daily_summary_presenter import (
+    DailySummaryPresenter,
+)
+from roadmap.adapters.cli.services.daily_summary_service import DailySummaryService
+from roadmap.common.console import get_console
+from roadmap.common.logging import verbose_output
+
+console = get_console()
+
+
+@click.command("today")
+@click.option("--verbose", "-v", is_flag=True, help="Show verbose output")
+@click.pass_context
+@require_initialized
+@verbose_output
+def today(ctx: click.Context, verbose: bool = False):  # noqa: F841
+    """Show your daily workflow summary for the upcoming milestone.
+
+    Displays your assigned issues for the next upcoming milestone:
+    - Current in-progress issues assigned to you
+    - Overdue issues
+    - High-priority tasks to start
+    - Today's completed work
+
+    Only shows issues assigned to you in the upcoming milestone.
+
+    Example:
+        roadmap today
+    """
+    core = ctx.obj["core"]
+
+    try:
+        # Use service to get daily summary data
+        service = DailySummaryService(core)
+        data = service.get_daily_summary_data()
+
+        # Use presenter to render the data
+        presenter = DailySummaryPresenter()
+        presenter.render(data)
+
+    except ValueError as e:
+        console.print(f"❌ {e}", style="bold red")
+    except Exception as e:
+        console.print(f"❌ Failed to generate daily summary: {e}", style="bold red")
+        import traceback
+
+        console.print(traceback.format_exc(), style="dim")

roadmap/adapters/cli/utils/click_options.py

@@ -0,0 +1,38 @@
+"""Shared Click option definitions for CLI commands."""
+
+import click
+
+
+def verbose_option(f):
+    """Add --verbose / -v flag to a command."""
+    return click.option(
+        "--verbose",
+        "-v",
+        is_flag=True,
+        help="Show detailed debug information and all health check logs",
+    )(f)
+
+
+def format_option(f):
+    """Add --format / -f option to a command."""
+    return click.option(
+        "--format",
+        "-f",
+        type=click.Choice(["plain", "json"], case_sensitive=False),
+        default="plain",
+        help="Output format (default: plain text)",
+    )(f)
+
+
+def details_option(f):
+    """Add --details flag to a command."""
+    return click.option(
+        "--details",
+        is_flag=True,
+        help="Show detailed recommendations and fix commands for each check",
+    )(f)
+
+
+def health_check_options(f):
+    """Add all health check options (--verbose, --details, --format) to a command."""
+    return verbose_option(details_option(format_option(f)))

roadmap/adapters/git/__init__.py

@@ -0,0 +1 @@
+"""Git repository operations and utilities."""

roadmap/adapters/git/git.py

@@ -0,0 +1,208 @@
+"""Git integration module for enhanced Git workflow support."""
+
+import re
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+from roadmap.core.domain import Issue
+
+
+@dataclass
+class GitCommit:
+    """Represents a Git commit with roadmap-relevant information."""
+
+    hash: str
+    author: str
+    date: datetime
+    message: str
+    files_changed: list[str]
+    insertions: int = 0
+    deletions: int = 0
+
+    @property
+    def short_hash(self) -> str:
+        """Get short commit hash."""
+        return self.hash[:8]
+
+    def extract_roadmap_references(self) -> list[str]:
+        """Extract roadmap issue references from commit message."""
+        # Enhanced patterns to support multiple formats:
+        # 1. [roadmap:issue-id] or [closes roadmap:issue-id] (existing)
+        # 2. fixes #issue-id, closes #issue-id (GitHub/GitLab style)
+        # 3. resolves #issue-id, resolve #issue-id
+        # 4. addresses #issue-id, refs #issue-id
+        # Issue IDs can be hex or alphanumeric
+        patterns = [
+            # Original roadmap: patterns
+            r"\[roadmap:([a-zA-Z0-9]{8,})\]",
+            r"\[closes roadmap:([a-zA-Z0-9]{8,})\]",
+            r"\[fixes roadmap:([a-zA-Z0-9]{8,})\]",
+            r"roadmap:([a-zA-Z0-9]{8,})",
+            # GitHub/GitLab style patterns
+            r"\b(?:fix|fixes|fixed|close|closes|closed|resolve|resolves|resolved)\s+#([a-zA-Z0-9]{8,})\b",
+            r"\b(?:addresses?|refs?)\s+#([a-zA-Z0-9]{8,})\b",
+            # Simple # references
+            r"#([a-f0-9]{8})\b",  # Hex issue IDs only for this pattern to avoid false positives
+        ]
+
+        references = []
+        for pattern in patterns:
+            matches = re.findall(pattern, self.message, re.IGNORECASE)
+            references.extend(matches)
+
+        return list(set(references))  # Remove duplicates
+
+    def extract_progress_info(self) -> float | None:
+        """Extract progress percentage from commit message."""
+        # Pattern: [progress:25%] or [progress:25]
+        patterns = [
+            r"\[progress:(\d+)%?\]",
+            r"progress:(\d+)%?",
+        ]
+
+        for pattern in patterns:
+            match = re.search(pattern, self.message, re.IGNORECASE)
+            if match:
+                return float(match.group(1))
+
+        return None
+
+
+@dataclass
+class GitBranch:
+    """Represents a Git branch with roadmap integration info."""
+
+    name: str
+    current: bool = False
+    remote: str | None = None
+    last_commit: str | None = None
+
+    def extract_issue_id(self) -> str | None:
+        """Extract issue ID from branch name patterns."""
+        # Common patterns:
+        # feature/issue-abc12345-description
+        # bugfix/abc12345-fix-login
+        # abc12345-new-feature
+        patterns = [
+            r"(?:feature|bugfix|hotfix)/(?:issue-)?([a-f0-9]{8})",
+            r"^([a-f0-9]{8})-",
+            r"/([a-f0-9]{8})-",
+        ]
+
+        for pattern in patterns:
+            match = re.search(pattern, self.name, re.IGNORECASE)
+            if match:
+                return match.group(1)
+
+        return None
+
+    def suggests_issue_type(self) -> str | None:
+        """Suggest issue type based on branch name."""
+        if self.name.startswith(("feature/", "feat/")):
+            return "feature"
+        elif self.name.startswith(("bugfix/", "bug/", "fix/")):
+            return "bug"
+        elif self.name.startswith(("hotfix/", "urgent/")):
+            return "hotfix"
+        elif self.name.startswith(("docs/", "doc/")):
+            return "documentation"
+        elif self.name.startswith(("test/", "tests/")):
+            return "testing"
+
+        return None
+
+
+class GitIntegration:
+    """Orchestrator for Git integration functionality.
+
+    Coordinates branch management, commit analysis, and repository operations.
+    Delegates to focused manager classes for each responsibility.
+    """
+
+    def __init__(self, repo_path: Path | None = None, config: object | None = None):
+        """Initialize Git integration orchestrator."""
+        from roadmap.adapters.git.git_branch_manager import GitBranchManager
+        from roadmap.adapters.git.git_command_executor import GitCommandExecutor
+        from roadmap.adapters.git.git_commit_analyzer import GitCommitAnalyzer
+        from roadmap.adapters.git.git_repository_info import GitRepositoryInfo
+
+        self.repo_path = repo_path or Path.cwd()
+        self.config = config
+
+        # Initialize managers
+        self.executor = GitCommandExecutor(repo_path)
+        self.branch_manager = GitBranchManager(repo_path, config)
+        self.commit_analyzer = GitCommitAnalyzer(repo_path)
+        self.repo_info = GitRepositoryInfo(repo_path)
+
+    def is_git_repository(self) -> bool:
+        """Check if current directory is in a Git repository."""
+        return self.executor.is_git_repository()
+
+    def get_current_user(self) -> str | None:
+        """Get current Git user name."""
+        return self.repo_info.get_current_user()
+
+    def get_current_email(self) -> str | None:
+        """Get current Git user email."""
+        return self.repo_info.get_current_email()
+
+    def get_current_branch(self) -> GitBranch | None:
+        """Get information about the current branch."""
+        return self.branch_manager.get_current_branch()
+
+    def get_all_branches(self) -> list[GitBranch]:
+        """Get all local branches."""
+        return self.branch_manager.get_all_branches()
+
+    def get_recent_commits(
+        self, count: int = 10, since: str | None = None
+    ) -> list[GitCommit]:
+        """Get recent commits with detailed information."""
+        return self.commit_analyzer.get_recent_commits(count, since)
+
+    def get_commits_for_issue(
+        self, issue_id: str, since: str | None = None
+    ) -> list[GitCommit]:
+        """Get all commits that reference a specific issue."""
+        return self.commit_analyzer.get_commits_for_issue(issue_id, since)
+
+    def suggest_branch_name(self, issue: Issue) -> str:
+        """Suggest a branch name based on issue information."""
+        return self.branch_manager.suggest_branch_name(issue)
+
+    def create_branch_for_issue(
+        self, issue: Issue, checkout: bool = True, force: bool = False
+    ) -> bool:
+        """Create a new branch for an issue."""
+        return self.branch_manager.create_branch_for_issue(issue, checkout, force)
+
+    def auto_create_issue_from_branch(
+        self, roadmap_core, branch_name: str | None = None
+    ) -> str | None:
+        """Automatically create an issue from a branch name if one doesn't exist."""
+        return self.branch_manager.auto_create_issue_from_branch(
+            roadmap_core, branch_name
+        )
+
+    def get_repository_info(self) -> dict[str, Any]:
+        """Get general repository information."""
+        return self.repo_info.get_repository_info()
+
+    def parse_commit_message_for_updates(self, commit: GitCommit) -> dict[str, Any]:
+        """Parse commit message for roadmap updates."""
+        return self.commit_analyzer.parse_commit_message_for_updates(commit)
+
+    def auto_update_issues_from_commits(
+        self, roadmap_core, commits: list[GitCommit] | None = None
+    ) -> dict[str, list[str]]:
+        """Automatically update issues based on commit messages."""
+        return self.commit_analyzer.auto_update_issues_from_commits(
+            roadmap_core, commits
+        )
+
+    def get_branch_linked_issues(self, branch_name: str) -> list[str]:
+        """Get issue IDs linked to a specific branch."""
+        return self.branch_manager.get_branch_linked_issues(branch_name)

roadmap/adapters/git/git_branch_manager.py

@@ -0,0 +1,400 @@
+"""Git branch management and issue linking."""
+
+import re
+from pathlib import Path
+
+from structlog import get_logger
+
+from roadmap.adapters.git.git import GitBranch
+from roadmap.adapters.git.git_command_executor import GitCommandExecutor
+
+logger = get_logger()
+
+
+class GitBranchManager:
+    """Manages Git branches and links them to roadmap issues."""
+
+    def __init__(self, repo_path: Path | None = None, config: object | None = None):
+        """Initialize branch manager."""
+        self.executor = GitCommandExecutor(repo_path)
+        self.repo_path = repo_path or Path.cwd()
+        self.config = config
+
+    def get_current_branch(self) -> GitBranch | None:
+        """Get information about the current branch."""
+        branch_name = self.executor.run(["rev-parse", "--abbrev-ref", "HEAD"])
+        if not branch_name or branch_name == "HEAD":
+            return None
+
+        # Get remote tracking branch
+        remote = self.executor.run(
+            ["rev-parse", "--abbrev-ref", f"{branch_name}@{{upstream}}"]
+        )
+
+        # Get last commit
+        last_commit = self.executor.run(["rev-parse", "HEAD"])
+
+        return GitBranch(
+            name=branch_name, current=True, remote=remote, last_commit=last_commit
+        )
+
+    def get_all_branches(self) -> list[GitBranch]:
+        """Get all local branches."""
+        output = self.executor.run(["branch", "--format=%(refname:short)|%(HEAD)"])
+        if not output:
+            return []
+
+        branches = []
+        for line in output.split("\n"):
+            if "|" not in line:
+                continue
+
+            name, head_marker = line.split("|", 1)
+            is_current = head_marker.strip() == "*"
+
+            branches.append(GitBranch(name=name.strip(), current=is_current))
+
+        return branches
+
+    def _generate_title_slug(self, title: str) -> str:
+        """Generate slug from issue title.
+
+        Args:
+            title: Issue title to slugify
+
+        Returns:
+            Slug suitable for branch name
+        """
+        title_slug = re.sub(r"[^a-zA-Z0-9\s-]", "", title.lower())
+        title_slug = re.sub(r"\s+", "-", title_slug)
+        return title_slug[:40]  # Limit length
+
+    def _determine_prefix(self, issue) -> str:
+        """Determine branch prefix based on issue type/priority.
+
+        Args:
+            issue: Issue to inspect
+
+        Returns:
+            Prefix for branch name
+        """
+        prefix = "feature"
+        if hasattr(issue, "issue_type"):
+            if issue.issue_type == "bug":
+                prefix = "bugfix"
+            elif issue.issue_type == "documentation":
+                prefix = "docs"
+        elif issue.priority.value == "critical":
+            prefix = "hotfix"
+        return prefix
+
+    def _get_branch_template(self) -> str | None:
+        """Get branch name template from config.
+
+        Returns:
+            Template string or None
+        """
+        try:
+            if self.config:
+                defaults = getattr(self.config, "defaults", None)
+                if defaults and hasattr(defaults, "get"):
+                    return defaults.get("branch_name_template")
+        except Exception as e:
+            logger.debug("get_branch_name_template_failed", error=str(e))
+        return None
+
+    def _format_branch_name(
+        self, issue_id: int, slug: str, prefix: str, template: str | None
+    ) -> str:
+        """Format branch name using template or defaults.
+
+        Args:
+            issue_id: Issue ID
+            slug: Title slug
+            prefix: Branch prefix
+            template: Template string or None
+
+        Returns:
+            Formatted branch name
+        """
+        if template:
+            try:
+                return template.format(id=issue_id, slug=slug, prefix=prefix)
+            except Exception as e:
+                logger.debug(
+                    "format_branch_name_template_failed",
+                    template=template,
+                    error=str(e),
+                    severity="operational",
+                )
+
+        return f"{prefix}/{issue_id}-{slug}"
+
+    def suggest_branch_name(self, issue) -> str:
+        """Suggest a branch name based on issue information."""
+        title_slug = self._generate_title_slug(issue.title)
+        prefix = self._determine_prefix(issue)
+        template = self._get_branch_template()
+        return self._format_branch_name(issue.id, title_slug, prefix, template)
+
+    def _check_working_tree_clean(self, force: bool) -> bool:
+        """Check if working tree has uncommitted changes.
+
+        Args:
+            force: Skip dirty working tree check
+
+        Returns:
+            True if working tree is clean or force is True
+        """
+        if force:
+            return True
+
+        status_output = self.executor.run(["status", "--porcelain"]) or ""
+        status_lines = [line for line in status_output.splitlines() if line.strip()]
+        has_substantive_changes = any(
+            not line.startswith("??") for line in status_lines
+        )
+        return not has_substantive_changes
+
+    def _branch_already_exists(self, branch_name: str) -> bool:
+        """Check if branch already exists.
+
+        Args:
+            branch_name: Name of branch to check
+
+        Returns:
+            True if branch exists
+        """
+        existing = self.executor.run(["rev-parse", "--verify", branch_name])
+        if not existing:
+            existing = self.executor.run(
+                ["rev-parse", "--verify", f"refs/heads/{branch_name}"]
+            )
+        return existing is not None
+
+    def _handle_existing_branch(self, branch_name: str, checkout: bool) -> bool:
+        """Handle existing branch (checkout or skip).
+
+        Args:
+            branch_name: Name of existing branch
+            checkout: Whether to checkout the branch
+
+        Returns:
+            True if operation succeeded
+        """
+        if checkout:
+            co = self.executor.run(["checkout", branch_name])
+            return co is not None
+        else:
+            return True
+
+    def _get_current_branch(self) -> str | None:
+        """Get current branch name.
+
+        Returns:
+            Current branch name or None
+        """
+        return self.executor.run(["rev-parse", "--abbrev-ref", "HEAD"]) or None
+
+    def _create_and_checkout_branch(self, branch_name: str, checkout: bool) -> bool:
+        """Create new branch and optionally return to previous branch.
+
+        Args:
+            branch_name: Name of new branch
+            checkout: Whether to stay on new branch
+
+        Returns:
+            True if successful
+        """
+        current_branch = self._get_current_branch()
+
+        result = self.executor.run(["checkout", "-b", branch_name])
+        if result is None:
+            return False
+
+        if not checkout:
+            if current_branch:
+                self.executor.run(["checkout", current_branch])
+
+        return True
+
+    def create_branch_for_issue(
+        self, issue, checkout: bool = True, force: bool = False
+    ) -> bool:
+        """Create a new branch for an issue.
+
+        Args:
+            issue: Issue object with id and title
+            checkout: Whether to checkout the new branch
+            force: Skip dirty working tree check
+
+        Returns:
+            True if successful, False otherwise
+        """
+        if not self.executor.is_git_repository():
+            return False
+
+        branch_name = self.suggest_branch_name(issue)
+
+        if not self._check_working_tree_clean(force):
+            return False
+
+        if self._branch_already_exists(branch_name):
+            return self._handle_existing_branch(branch_name, checkout)
+
+        return self._create_and_checkout_branch(branch_name, checkout)
+
+    def _check_existing_issue_for_branch(
+        self, branch_name: str, roadmap_core
+    ) -> str | None:
+        """Check if branch already has associated issue.
+
+        Args:
+            branch_name: Branch name
+            roadmap_core: RoadmapCore instance
+
+        Returns:
+            None if no existing issue
+        """
+        branch = GitBranch(branch_name)
+        existing_issue_id = branch.extract_issue_id()
+        if existing_issue_id and roadmap_core.issues.get(existing_issue_id):
+            return existing_issue_id
+        return None
+
+    def _build_auto_created_issue_data(
+        self, branch_name: str, roadmap_core
+    ) -> dict | None:
+        """Build issue data from branch name.
+
+        Args:
+            branch_name: Branch name
+            roadmap_core: RoadmapCore instance
+
+        Returns:
+            Issue data dict or None if can't extract
+        """
+        branch = GitBranch(branch_name)
+        issue_type = branch.suggests_issue_type() or "feature"
+        title = self._extract_title_from_branch_name(branch_name)
+        if not title:
+            return None
+
+        assignee = self._get_current_user(roadmap_core) or "Unknown"
+        content = f"Auto-created from branch: `{branch_name}`\n\nThis issue was automatically created when switching to the branch `{branch_name}`."
+
+        issue_data = {
+            "title": title,
+            "content": content,
+            "assignee": assignee,
+            "priority": "medium",
+            "status": "in_progress",
+        }
+
+        if hasattr(roadmap_core.issues, "create_with_type"):
+            issue_data["issue_type"] = issue_type
+
+        return issue_data
+
+    def auto_create_issue_from_branch(
+        self, roadmap_core, branch_name: str | None = None
+    ) -> str | None:
+        """Automatically create an issue from a branch name if one doesn't exist.
+
+        Args:
+            roadmap_core: RoadmapCore instance for issue operations
+            branch_name: Branch name to analyze. If None, uses current branch.
+
+        Returns:
+            Issue ID if created, None if not created or already exists
+        """
+        if branch_name is None:
+            current_branch = self.get_current_branch()
+            if not current_branch:
+                return None
+            branch_name = current_branch.name
+
+        # Don't create issues for main branches
+        if branch_name in ["main", "master", "develop", "dev"]:
+            return None
+
+        # Check if issue already exists
+        if self._check_existing_issue_for_branch(branch_name, roadmap_core):
+            return None
+
+        # Build issue data
+        issue_data = self._build_auto_created_issue_data(branch_name, roadmap_core)
+        if not issue_data:
+            return None
+
+        # Create the issue
+        try:
+            issue = roadmap_core.issues.create(**issue_data)
+            return issue.id
+        except Exception as e:
+            logger.error(
+                "auto_issue_creation_failed", error=str(e), severity="operational"
+            )
+            return None
+
+    def _extract_title_from_branch_name(self, branch_name: str) -> str | None:
+        """Extract a readable title from a branch name."""
+        # Remove common prefixes
+        name = branch_name
+        prefixes = [
+            "feature/",
+            "bugfix/",
+            "hotfix/",
+            "docs/",
+            "test/",
+            "feat/",
+            "bug/",
+            "fix/",
+        ]
+        for prefix in prefixes:
+            if name.startswith(prefix):
+                name = name[len(prefix) :]
+                break
+
+        # Remove issue ID if present
+        name = re.sub(r"^[a-f0-9]{8}-", "", name)
+        name = re.sub(r"^issue-[a-f0-9]{8}-", "", name)
+
+        # Replace hyphens/underscores with spaces and title case
+        name = re.sub(r"[-_]", " ", name)
+        name = name.strip()
+
+        if not name:
+            return None
+
+        # Title case
+        words = name.split()
+        title_words = []
+        for word in words:
+            if len(word) > 3:  # Title case for longer words
+                title_words.append(word.capitalize())
+            else:  # Keep short words lowercase unless first word
+                title_words.append(word.lower() if title_words else word.capitalize())
+
+        return " ".join(title_words)
+
+    def _get_current_user(self, roadmap_core) -> str | None:
+        """Get current Git user name."""
+        return self.executor.run(["config", "user.name"])
+
+    def get_branch_linked_issues(self, branch_name: str) -> list[str]:
+        """Get issue IDs linked to a specific branch."""
+        try:
+            # Create a GitBranch object and extract issue ID
+            branch = GitBranch(branch_name)
+            issue_id = branch.extract_issue_id()
+
+            if issue_id:
+                return [issue_id]
+            else:
+                return []
+        except Exception as e:
+            logger.debug(
+                "branch_issue_extraction_failed", branch_name=branch_name, error=str(e)
+            )
+            return []