roadmap-cli 0.1.1__py3-none-any.whl

roadmap/adapters/git/hook_registry.py

@@ -0,0 +1,97 @@
+"""Hook registry and detection for Git hooks."""
+
+from pathlib import Path
+from typing import Any
+
+from structlog import get_logger
+
+logger = get_logger()
+
+
+class HookRegistry:
+    """Registry and metadata for available Git hooks."""
+
+    AVAILABLE_HOOKS = ["post-commit", "pre-push", "post-merge", "post-checkout"]
+
+    @classmethod
+    def get_available_hooks(cls) -> list[str]:
+        """Get list of all available hook names."""
+        return cls.AVAILABLE_HOOKS.copy()
+
+    @classmethod
+    def is_valid_hook(cls, hook_name: str) -> bool:
+        """Check if hook name is valid."""
+        return hook_name in cls.AVAILABLE_HOOKS
+
+    @classmethod
+    def validate_hooks(cls, hooks: list[str] | None) -> list[str]:
+        """Validate and filter hook list.
+
+        Args:
+            hooks: List of hook names to validate
+
+        Returns:
+            Validated list of hook names
+        """
+        if hooks is None:
+            return cls.get_available_hooks()
+        return [h for h in hooks if cls.is_valid_hook(h)]
+
+
+class HookStatus:
+    """Utility for checking hook installation status."""
+
+    @staticmethod
+    def get_hook_file(hook_name: str, hooks_dir: Path) -> Path:
+        """Get the file path for a hook."""
+        return hooks_dir / hook_name
+
+    @staticmethod
+    def is_hook_installed(hook_file: Path) -> bool:
+        """Check if hook file exists and is readable."""
+        if not hook_file.exists():
+            return False
+        try:
+            hook_file.read_text()
+            return True
+        except Exception as e:
+            logger.error(
+                "hook_install_check_failed", error=str(e), severity="operational"
+            )
+            return False
+
+    @staticmethod
+    def is_roadmap_hook(hook_file: Path) -> bool:
+        """Check if hook file is a roadmap hook."""
+        if not hook_file.exists():
+            return False
+        try:
+            content = hook_file.read_text()
+            return "roadmap-hook" in content
+        except Exception as e:
+            logger.error(
+                "hook_content_check_failed", error=str(e), severity="operational"
+            )
+            return False
+
+    @staticmethod
+    def is_executable(hook_file: Path) -> bool:
+        """Check if hook file is executable."""
+        if not hook_file.exists():
+            return False
+        try:
+            return bool(hook_file.stat().st_mode & 0o111)
+        except Exception as e:
+            logger.debug("hook_executable_check_failed", error=str(e))
+            return False
+
+    @staticmethod
+    def get_status_dict(hook_name: str, hook_file: Path) -> dict[str, Any]:
+        """Get complete status dictionary for a hook."""
+        return {
+            "installed": HookStatus.is_hook_installed(hook_file),
+            "is_roadmap_hook": HookStatus.is_roadmap_hook(hook_file),
+            "executable": HookStatus.is_executable(hook_file),
+            "file_exists": hook_file.exists(),
+            "file_path": str(hook_file) if hook_file.exists() else None,
+        }

roadmap/adapters/git/hook_script_generator.py

@@ -0,0 +1,58 @@
+"""Hook script generation for Git hooks."""
+
+import shutil
+
+
+class HookContentGenerator:
+    """Generates content for Git hook bash scripts."""
+
+    BASH_TEMPLATE = """#!/bin/bash
+# roadmap-hook: {hook_name}
+# Auto-generated Git hook for roadmap integration
+
+# Get the directory of this script
+HOOK_DIR="$(cd "$(dirname "${{BASH_SOURCE[0]}}")" && pwd)"
+REPO_ROOT="$(cd "$HOOK_DIR/../.." && pwd)"
+
+# Change to repository root
+cd "$REPO_ROOT"
+
+# Execute roadmap hook handler
+{python_exec} << 'PYTHON_HOOK_EOF'
+import sys
+sys.path.insert(0, '.')
+try:
+    from roadmap.adapters.git.git_hooks_manager import GitHookManager
+    from roadmap.infrastructure.coordination.core import RoadmapCore
+    core = RoadmapCore()
+    hook_manager = GitHookManager(core)
+    getattr(hook_manager, "{handler_name}")()
+except Exception as e:
+    # Silent fail to avoid breaking Git operations
+    pass
+PYTHON_HOOK_EOF
+"""
+
+    @staticmethod
+    def get_python_executable() -> str:
+        """Get the path to Python executable."""
+        return shutil.which("python") or shutil.which("python3") or "python"
+
+    @classmethod
+    def generate(cls, hook_name: str) -> str:
+        """Generate hook script content for given hook name.
+
+        Args:
+            hook_name: Name of the hook (e.g., 'post-commit')
+
+        Returns:
+            Complete bash script content for the hook
+        """
+        handler_name = hook_name.replace("-", "_")
+        python_exec = cls.get_python_executable()
+
+        return cls.BASH_TEMPLATE.format(
+            hook_name=hook_name,
+            handler_name=handler_name,
+            python_exec=python_exec,
+        )

roadmap/adapters/git/sync_monitor.py

@@ -0,0 +1,409 @@
+"""GitSyncMonitor - Detect and sync file changes to database cache."""
+
+from pathlib import Path
+from typing import Any
+
+from roadmap.adapters.git.git_command_executor import GitCommandExecutor
+from roadmap.common.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+class GitSyncMonitor:
+    """Detects file changes via git diff and syncs them to database cache.
+
+    This class enables cheap change detection:
+    - Uses `git diff --name-only` for millisecond change detection
+    - Tracks last synced commit to avoid redundant work
+    - Filters changes to only .roadmap/issues/ files
+    - Syncs only changed files to database (vs filesystem scan)
+
+    Typical usage:
+        monitor = GitSyncMonitor(repo_path, state_manager)
+        changes = monitor.detect_changes()
+        if changes:
+            monitor.sync_to_database(changes)
+
+    This enables:
+    - `roadmap list`: git diff (50ms) + DB query (5ms) = 55ms total
+    - Instead of: filesystem scan (1000ms) + parse (500ms) = 1500ms total
+    """
+
+    def __init__(self, repo_path: Path | None = None, state_manager: Any | None = None):
+        """Initialize GitSyncMonitor.
+
+        Args:
+            repo_path: Path to git repository root
+            state_manager: StateManager for database operations (optional for Phase 1)
+        """
+        self.repo_path = repo_path or Path.cwd()
+        self.state_manager = state_manager
+        self.git_executor = GitCommandExecutor(self.repo_path)
+
+        # Cache last known commit to avoid re-checking
+        self._cached_last_synced_commit: str | None = None
+        self._cached_current_commit: str | None = None
+
+    def detect_changes(self) -> dict[str, str]:
+        """Detect changes since last sync.
+
+        Uses `git diff --name-only` for fast change detection.
+
+        Returns:
+            Dictionary mapping file paths to change types:
+            - "modified": File exists and changed
+            - "added": New file
+            - "deleted": File was removed
+            - Empty dict if no changes detected
+
+        Example:
+            {
+                ".roadmap/issues/issue-123.yaml": "modified",
+                ".roadmap/issues/issue-456.yaml": "added",
+                ".roadmap/issues/issue-789.yaml": "deleted",
+            }
+        """
+        try:
+            # Check if we're in a git repo
+            if not self.git_executor.is_git_repository():
+                logger.debug("Not in a git repository, skipping git sync")
+                return {}
+
+            # Get current commit
+            current_commit = self._get_current_commit()
+            if not current_commit:
+                logger.debug("Unable to get current commit")
+                return {}
+
+            # Get last synced commit
+            last_synced = self._get_last_synced_commit()
+            if last_synced == current_commit:
+                logger.debug(
+                    "Already synced to current commit",
+                    current=current_commit[:8],
+                )
+                return {}
+
+            # Get changed files
+            changes = self._get_changed_files(last_synced)
+            logger.debug(
+                "Detected file changes",
+                current=current_commit[:8],
+                previous=last_synced[:8] if last_synced else "none",
+                change_count=len(changes),
+            )
+
+            return changes
+
+        except Exception as e:
+            logger.error(
+                "Error detecting changes",
+                error=str(e),
+                error_type=type(e).__name__,
+                severity="system_error",
+            )
+            return {}
+
+    def sync_to_database(self, changes: dict[str, str]) -> bool:
+        """Sync detected changes to database cache.
+
+        This syncs remote_ids from changed YAML files to the database cache,
+        enabling fast O(1) lookups during sync operations instead of scanning
+        all YAML files.
+
+        Args:
+            changes: Dictionary of changes from detect_changes()
+
+        Returns:
+            True if sync successful, False otherwise
+        """
+        if not changes:
+            logger.debug("No changes to sync")
+            return True
+
+        if not self.state_manager:
+            logger.warning("State manager not configured, skipping database sync")
+            return False
+
+        try:
+            logger.debug("Syncing changes to database", change_count=len(changes))
+
+            # Sync remote_ids from changed files to database
+            from roadmap.adapters.persistence.parser import IssueParser
+
+            if self.state_manager.remote_links:
+                synced_count = 0
+                for file_path, change_type in changes.items():
+                    try:
+                        if change_type == "deleted":
+                            # For deleted files, we can't read them, so skip
+                            continue
+
+                        # Load issue from file using IssueParser
+                        file_path_obj = Path(file_path)
+                        if not file_path_obj.is_absolute():
+                            # Make path absolute relative to repo root
+                            file_path_obj = self.repo_path / file_path_obj
+
+                        if not file_path_obj.exists():
+                            continue
+
+                        issue = IssueParser.parse_issue_file(file_path_obj)
+                        if issue and issue.remote_ids:
+                            # Sync remote_ids to database
+                            for backend_name, remote_id in issue.remote_ids.items():
+                                if self.state_manager.remote_links.link_issue(
+                                    issue.id, backend_name, remote_id
+                                ):
+                                    synced_count += 1
+                    except Exception as e:
+                        logger.warning(
+                            "Failed to sync remote_ids for file",
+                            file_path=file_path,
+                            error=str(e),
+                        )
+
+                if synced_count > 0:
+                    logger.debug(
+                        "Synced remote_ids to database",
+                        synced_count=synced_count,
+                    )
+
+            # Update last synced commit
+            self._save_last_synced_commit()
+
+            logger.debug("Sync to database complete")
+            return True
+
+        except Exception as e:
+            logger.error(
+                "Error syncing to database",
+                error=str(e),
+                error_type=type(e).__name__,
+                severity="system_error",
+            )
+            return False
+
+    def _get_changed_files(self, base_commit: str | None = None) -> dict[str, str]:
+        """Get list of changed files since base commit.
+
+        Args:
+            base_commit: Commit SHA to compare against. If None, uses initial commit.
+
+        Returns:
+            Dictionary mapping file paths to change types
+        """
+        changes: dict[str, str] = {}
+
+        try:
+            # If no base commit (first sync), get all issues files
+            if not base_commit:
+                return self._get_all_issues_files()
+
+            # Get changed files between base and current
+            changed_files = self.git_executor.run(
+                ["diff", "--name-status", base_commit, "HEAD"]
+            )
+
+            if not changed_files:
+                return {}
+
+            # Parse git diff output
+            # Format: M\tpath/to/file (Modified)
+            #         A\tpath/to/file (Added)
+            #         D\tpath/to/file (Deleted)
+            for line in changed_files.split("\n"):
+                if not line.strip():
+                    continue
+
+                parts = line.split("\t", 1)
+                if len(parts) != 2:
+                    continue
+
+                status, path = parts
+                path = path.strip()
+
+                # Only track .roadmap/issues/ changes
+                if not self._is_issues_file(path):
+                    continue
+
+                # Map git status to our status
+                status_map = {"M": "modified", "A": "added", "D": "deleted"}
+                changes[path] = status_map.get(status, "modified")
+
+            return changes
+
+        except Exception as e:
+            logger.error(
+                "Error getting changed files",
+                error=str(e),
+                error_type=type(e).__name__,
+                severity="system_error",
+            )
+            return {}
+
+    def _get_all_issues_files(self) -> dict[str, str]:
+        """Get all issues files for initial sync.
+
+        Returns:
+            Dictionary mapping all issue files to "added" status
+        """
+        all_files: dict[str, str] = {}
+
+        try:
+            # Use git ls-files to get all tracked files
+            git_files = self.git_executor.run(["ls-files"])
+            if not git_files:
+                return {}
+
+            for path in git_files.split("\n"):
+                path = path.strip()
+                if self._is_issues_file(path):
+                    all_files[path] = "added"
+
+            logger.debug(
+                "Found all issues files for initial sync",
+                file_count=len(all_files),
+            )
+
+            return all_files
+
+        except Exception as e:
+            logger.error(
+                "Error getting all issues files",
+                error=str(e),
+                error_type=type(e).__name__,
+            )
+            return {}
+
+    def _is_issues_file(self, path: str) -> bool:
+        """Check if path is a .roadmap/issues/ file.
+
+        Args:
+            path: File path to check
+
+        Returns:
+            True if file is in .roadmap/issues/ or .roadmap/archive/issues/
+        """
+        return ".roadmap/issues/" in path or ".roadmap/archive/issues/" in path
+
+    def _get_current_commit(self) -> str | None:
+        """Get the current HEAD commit SHA.
+
+        Returns:
+            Commit SHA, or None if not in a valid git state
+        """
+        if self._cached_current_commit:
+            return self._cached_current_commit
+
+        try:
+            commit = self.git_executor.run(["rev-parse", "HEAD"])
+            self._cached_current_commit = commit
+            return commit
+        except Exception as e:
+            logger.error(
+                "Error getting current commit",
+                error=str(e),
+                error_type=type(e).__name__,
+                severity="system_error",
+            )
+            return None
+
+    def _get_last_synced_commit(self) -> str | None:
+        """Get the last commit we synced to database.
+
+        Returns:
+            Commit SHA, or None if never synced
+        """
+        if self._cached_last_synced_commit is not None:
+            return self._cached_last_synced_commit
+
+        try:
+            # Read from database sync_metadata table
+            if self.state_manager:
+                conn = self.state_manager._get_connection()
+                cursor = conn.cursor()
+                cursor.execute(
+                    "SELECT value FROM sync_metadata WHERE key = ?",
+                    ("last_synced_commit",),
+                )
+                row = cursor.fetchone()
+                if row:
+                    commit = row[0]
+                    self._cached_last_synced_commit = commit
+                    return commit
+
+            # No previous sync
+            self._cached_last_synced_commit = None
+            return None
+
+        except Exception as e:
+            logger.error(
+                "Error getting last synced commit",
+                error=str(e),
+                severity="system_error",
+                error_type=type(e).__name__,
+            )
+            return None
+
+    def _save_last_synced_commit(self) -> bool:
+        """Save current commit as the last synced commit.
+
+        Returns:
+            True if save successful
+        """
+        try:
+            current_commit = self._get_current_commit()
+            if not current_commit:
+                logger.error("Cannot save last synced commit: no current commit")
+                return False
+
+            # Write to database sync_metadata table
+            if not self.state_manager:
+                logger.warning("State manager not configured, cannot save sync commit")
+                return False
+
+            conn = self.state_manager._get_connection()
+            cursor = conn.cursor()
+
+            # Try to update first, then insert if not found
+            cursor.execute(
+                "UPDATE sync_metadata SET value = ?, updated_at = CURRENT_TIMESTAMP WHERE key = ?",
+                (current_commit, "last_synced_commit"),
+            )
+
+            # If no rows were updated, insert new row
+            if cursor.rowcount == 0:
+                cursor.execute(
+                    "INSERT INTO sync_metadata (key, value, updated_at) VALUES (?, ?, CURRENT_TIMESTAMP)",
+                    ("last_synced_commit", current_commit),
+                )
+
+            conn.commit()
+
+            # Update cache
+            self._cached_last_synced_commit = current_commit
+
+            logger.debug(
+                "Saved last synced commit",
+                commit=current_commit[:8],
+            )
+
+            return True
+
+        except Exception as e:
+            logger.error(
+                "Error saving last synced commit",
+                error=str(e),
+                error_type=type(e).__name__,
+                severity="system_error",
+            )
+            return False
+
+    def clear_cache(self) -> None:
+        """Clear internal commit caches.
+
+        Useful for testing or forcing a fresh check.
+        """
+        self._cached_last_synced_commit = None
+        self._cached_current_commit = None