roadmap-cli 0.1.1__py3-none-any.whl

roadmap/adapters/cli/git/hooks_config.py

@@ -0,0 +1,327 @@
+"""Git hooks configuration command - Set up auto-sync behavior."""
+
+from pathlib import Path
+
+import click
+
+from roadmap.adapters.cli.cli_command_helpers import require_initialized
+from roadmap.common.console import get_console
+from roadmap.core.services.git.git_hook_auto_sync_service import (
+    GitHookAutoSyncConfig,
+    GitHookAutoSyncService,
+)
+
+console = get_console()
+
+
+def _any_sync_flag_set(
+    enable_auto_sync: bool,
+    disable_auto_sync: bool,
+    sync_on_commit: bool,
+    no_sync_on_commit: bool,
+    sync_on_checkout: bool,
+    no_sync_on_checkout: bool,
+    sync_on_merge: bool,
+    no_sync_on_merge: bool,
+    confirm: bool | None,
+    force_local: bool,
+    force_github: bool,
+) -> bool:
+    """Return True if any config-changing flag was explicitly provided."""
+    return any(
+        [
+            enable_auto_sync,
+            disable_auto_sync,
+            sync_on_commit,
+            no_sync_on_commit,
+            sync_on_checkout,
+            no_sync_on_checkout,
+            sync_on_merge,
+            no_sync_on_merge,
+            confirm is not None,
+            force_local,
+            force_github,
+        ]
+    )
+
+
+def _build_new_sync_config(
+    current_config: "GitHookAutoSyncConfig",
+    enable_auto_sync: bool,
+    disable_auto_sync: bool,
+    sync_on_commit: bool,
+    no_sync_on_commit: bool,
+    sync_on_checkout: bool,
+    no_sync_on_checkout: bool,
+    sync_on_merge: bool,
+    no_sync_on_merge: bool,
+    confirm: bool | None,
+    force_local: bool,
+    force_github: bool,
+) -> "GitHookAutoSyncConfig":
+    """Build a new config by merging explicit flags onto the existing config."""
+    return GitHookAutoSyncConfig(
+        auto_sync_enabled=(
+            enable_auto_sync
+            or (not disable_auto_sync and current_config.auto_sync_enabled)
+        ),
+        sync_on_commit=(
+            sync_on_commit or (not no_sync_on_commit and current_config.sync_on_commit)
+        ),
+        sync_on_checkout=(
+            sync_on_checkout
+            or (not no_sync_on_checkout and current_config.sync_on_checkout)
+        ),
+        sync_on_merge=(
+            sync_on_merge or (not no_sync_on_merge and current_config.sync_on_merge)
+        ),
+        confirm_before_sync=(
+            confirm if confirm is not None else current_config.confirm_before_sync
+        ),
+        force_local=force_local or current_config.force_local,
+        force_github=force_github or current_config.force_github,
+    )
+
+
+@click.command(name="hooks-config")
+@click.option(
+    "--enable-auto-sync",
+    is_flag=True,
+    help="Enable auto-sync on Git events",
+)
+@click.option(
+    "--disable-auto-sync",
+    is_flag=True,
+    help="Disable all auto-sync on Git events",
+)
+@click.option(
+    "--sync-on-commit",
+    is_flag=True,
+    help="Enable auto-sync after commits",
+)
+@click.option(
+    "--no-sync-on-commit",
+    is_flag=True,
+    help="Disable auto-sync after commits",
+)
+@click.option(
+    "--sync-on-checkout",
+    is_flag=True,
+    help="Enable auto-sync on branch changes",
+)
+@click.option(
+    "--no-sync-on-checkout",
+    is_flag=True,
+    help="Disable auto-sync on branch changes",
+)
+@click.option(
+    "--sync-on-merge",
+    is_flag=True,
+    help="Enable auto-sync on merge operations",
+)
+@click.option(
+    "--no-sync-on-merge",
+    is_flag=True,
+    help="Disable auto-sync on merge operations",
+)
+@click.option(
+    "--confirm/--no-confirm",
+    default=None,
+    help="Require confirmation before syncing",
+)
+@click.option(
+    "--force-local",
+    is_flag=True,
+    help="Resolve conflicts by keeping local changes",
+)
+@click.option(
+    "--force-github",
+    is_flag=True,
+    help="Resolve conflicts by keeping GitHub changes",
+)
+@click.option(
+    "--show",
+    "show_config",
+    is_flag=True,
+    help="Show current configuration",
+)
+@click.pass_context
+@require_initialized
+def hooks_config(
+    ctx: click.Context,
+    enable_auto_sync: bool,
+    disable_auto_sync: bool,
+    sync_on_commit: bool,
+    no_sync_on_commit: bool,
+    sync_on_checkout: bool,
+    no_sync_on_checkout: bool,
+    sync_on_merge: bool,
+    no_sync_on_merge: bool,
+    confirm: bool | None,
+    force_local: bool,
+    force_github: bool,
+    show_config: bool,
+) -> None:
+    """Configure Git hooks auto-sync behavior.
+
+    Examples:
+        # Show current configuration
+        roadmap git hooks-config --show
+
+        # Enable auto-sync on commits with confirmation
+        roadmap git hooks-config --enable-auto-sync --sync-on-commit --confirm
+
+        # Configure force-local resolution for conflicts
+        roadmap git hooks-config --sync-on-commit --force-local
+
+        # Disable auto-sync on checkouts
+        roadmap git hooks-config --no-sync-on-checkout
+
+    Configuration is stored locally in the roadmap project.
+    """
+    core = ctx.obj.get("core") if isinstance(ctx.obj, dict) else ctx.obj
+
+    # Config file path
+    config_path = Path.cwd() / ".roadmap" / "config.json"
+
+    # Initialize service
+    service = GitHookAutoSyncService(core)
+
+    # Load existing config from storage if available
+    service.load_config_from_file(config_path)
+    current_config = service.get_config()
+
+    # Build new config from options
+    new_config = _build_new_sync_config(
+        current_config,
+        enable_auto_sync,
+        disable_auto_sync,
+        sync_on_commit,
+        no_sync_on_commit,
+        sync_on_checkout,
+        no_sync_on_checkout,
+        sync_on_merge,
+        no_sync_on_merge,
+        confirm,
+        force_local,
+        force_github,
+    )
+
+    # Handle conflicts in resolution options
+    if force_local and force_github:
+        console.print("[red]❌ Cannot use both --force-local and --force-github[/red]")
+        ctx.exit(1)
+
+    # Apply new config
+    service.set_config(new_config)
+
+    # Save config to file if any settings changed
+    any_flag = _any_sync_flag_set(
+        enable_auto_sync,
+        disable_auto_sync,
+        sync_on_commit,
+        no_sync_on_commit,
+        sync_on_checkout,
+        no_sync_on_checkout,
+        sync_on_merge,
+        no_sync_on_merge,
+        confirm,
+        force_local,
+        force_github,
+    )
+    if any_flag:
+        if service.save_config_to_file(config_path):
+            console.print("[dim]Config saved to .roadmap/config.json[/dim]")
+
+    # Show configuration
+    if show_config or not any_flag:
+        _display_config(new_config, service)
+    else:
+        console.print("[green]✅ Configuration updated[/green]")
+        _display_config(new_config, service)
+
+
+def _display_config(
+    config: GitHookAutoSyncConfig, service: GitHookAutoSyncService
+) -> None:
+    """Display current auto-sync configuration."""
+    console.print()
+    console.print("[bold cyan]Git Hooks Auto-Sync Configuration[/bold cyan]")
+    console.print()
+
+    # Check if config is persisted
+    config_path = Path.cwd() / ".roadmap" / "config.json"
+    if config_path.exists():
+        console.print(f"[dim]Config file: {config_path}[/dim]")
+        console.print()
+
+    # Master switch
+    master_status = (
+        "[green]✓ ENABLED[/green]"
+        if config.auto_sync_enabled
+        else "[dim]✗ DISABLED[/dim]"
+    )
+    console.print(f"Master Switch:       {master_status}")
+    console.print()
+
+    # Per-event configuration
+    console.print("[bold]Sync Events:[/bold]")
+    _print_setting(
+        "  Commit",
+        config.sync_on_commit and config.auto_sync_enabled,
+    )
+    _print_setting(
+        "  Branch Checkout",
+        config.sync_on_checkout and config.auto_sync_enabled,
+    )
+    _print_setting(
+        "  Merge",
+        config.sync_on_merge and config.auto_sync_enabled,
+    )
+    console.print()
+
+    # Behavior settings
+    console.print("[bold]Behavior:[/bold]")
+    console.print(
+        f"  Confirm Before Sync: {'✓ Yes' if config.confirm_before_sync else '✗ No'}"
+    )
+    console.print()
+
+    # Conflict resolution
+    console.print("[bold]Conflict Resolution:[/bold]")
+    if config.force_local:
+        console.print("  Strategy: [yellow]Force Local (keep local changes)[/yellow]")
+    elif config.force_github:
+        console.print("  Strategy: [yellow]Force GitHub (keep remote changes)[/yellow]")
+    else:
+        console.print(
+            "  Strategy: [dim]None configured (manual resolution required)[/dim]"
+        )
+    console.print()
+
+    # Statistics
+    try:
+        stats = service.get_sync_stats()
+        console.print("[bold]Sync Statistics:[/bold]")
+        console.print(f"  Total Issues:       {stats['total_issues']}")
+        console.print(
+            f"  GitHub-Linked:      {stats['total_issues'] - stats['never_synced']}"
+        )
+        console.print(f"  Never Synced:       {stats['never_synced']}")
+        if stats["total_sync_attempts"] > 0:
+            console.print(f"  Success Rate:       {stats['success_rate']:.1f}%")
+    except Exception as e:
+        from roadmap.common.logging import get_logger
+
+        logger = get_logger(__name__)
+        logger.debug(
+            "sync_stats_display_failed", error=str(e), action="display_sync_stats"
+        )
+
+    console.print()
+
+
+def _print_setting(label: str, enabled: bool) -> None:
+    """Print a configuration setting with status."""
+    status = "[green]✓ ENABLED[/green]" if enabled else "[dim]✗ disabled[/dim]"
+    console.print(f"{label:25} {status}")

roadmap/adapters/cli/git/status_display.py

@@ -0,0 +1,158 @@
+"""Display helper for git status command."""
+
+from typing import Any
+
+from rich.console import Console
+
+
+class GitStatusDisplay:
+    """Handles display of git status information."""
+
+    def __init__(self, console: Console):
+        """Initialize with a console for output.
+
+        Args:
+            console: Rich console instance for formatted output
+        """
+        self.console = console
+
+    def show_not_git_repo(self) -> None:
+        """Display message when not in a git repository."""
+        self.console.print("📁 Not in a Git repository", style="yellow")
+
+    def show_header(self) -> None:
+        """Display the status header."""
+        self.console.print("🔍 Git Repository Status", style="bold blue")
+        self.console.print()
+
+    def show_repository_info(self, git_context: dict[str, Any]) -> None:
+        """Display repository origin and GitHub information.
+
+        Args:
+            git_context: Dictionary containing git context information
+        """
+        if git_context.get("origin_url"):
+            self.console.print(f"📍 Origin: {git_context['origin_url']}", style="cyan")
+
+        if git_context.get("github_owner") and git_context.get("github_repo"):
+            self.console.print(
+                f"🐙 GitHub: {git_context['github_owner']}/{git_context['github_repo']}",
+                style="cyan",
+            )
+
+    def show_current_branch(self, git_context: dict[str, Any]) -> None:
+        """Display current branch and linked issue information.
+
+        Args:
+            git_context: Dictionary containing git context information
+        """
+        if not git_context.get("current_branch"):
+            return
+
+        self.console.print(
+            f"🌿 Current branch: {git_context['current_branch']}", style="green"
+        )
+
+        linked_issue = git_context.get("linked_issue")
+        if linked_issue:
+            self._show_linked_issue_details(linked_issue)
+        else:
+            self.console.print("   💡 No linked issue found", style="dim")
+
+    def _show_linked_issue_details(self, linked_issue: dict[str, Any]) -> None:
+        """Display details of the linked issue.
+
+        Args:
+            linked_issue: Dictionary containing linked issue information
+        """
+        self.console.print("🔗 Linked issue:", style="bold")
+        self.console.print(f"   📋 {linked_issue['title']}", style="cyan")
+        self.console.print(f"   🆔 {linked_issue['id']}", style="dim")
+        self.console.print(f"   📊 Status: {linked_issue['status']}", style="yellow")
+
+        priority_style = "red" if linked_issue["priority"] == "critical" else "yellow"
+        self.console.print(
+            f"   ⚡ Priority: {linked_issue['priority']}", style=priority_style
+        )
+
+    def show_branch_issue_links(
+        self, branch_issues: dict[str, list[str]], current_branch: str, core: Any
+    ) -> None:
+        """Display all branch-issue mappings.
+
+        Args:
+            branch_issues: Dictionary mapping branches to issue IDs
+            current_branch: Name of the current branch
+            core: RoadmapCore instance for fetching issue details
+        """
+        if not branch_issues:
+            return
+
+        self.console.print("\n🌿 Branch-Issue Links:", style="bold")
+
+        for branch, issue_ids in branch_issues.items():
+            for issue_id in issue_ids:
+                issue = core.issues.get(issue_id)
+                if issue:
+                    self._show_branch_issue_link(branch, issue, current_branch)
+
+    def _show_branch_issue_link(
+        self, branch: str, issue: Any, current_branch: str
+    ) -> None:
+        """Display a single branch-issue link.
+
+        Args:
+            branch: Branch name
+            issue: Issue object
+            current_branch: Name of the current branch
+        """
+        marker = "👉" if branch == current_branch else "  "
+        title = issue.title[:50]
+        if len(issue.title) > 50:
+            title += "..."
+
+        self.console.print(f"{marker} {branch} → {title}", style="cyan")
+
+    def show_recent_commits(self, core: Any) -> None:
+        """Display recent commits with roadmap references.
+
+        Args:
+            core: RoadmapCore instance for fetching commit information
+        """
+        if not core.git.is_git_repository():
+            return
+
+        recent_commits = core.git.get_recent_commits(count=5)
+        roadmap_commits = [c for c in recent_commits if c.extract_roadmap_references()]
+
+        if not roadmap_commits:
+            return
+
+        self.console.print("\n📝 Recent Roadmap Commits:", style="bold")
+
+        for commit in roadmap_commits[:3]:
+            self._show_commit_details(commit)
+
+    def _show_commit_details(self, commit: Any) -> None:
+        """Display details of a single commit.
+
+        Args:
+            commit: Commit object with message and references
+        """
+        message = commit.message[:60]
+        if len(commit.message) > 60:
+            message += "..."
+
+        self.console.print(f"   {commit.short_hash} {message}", style="dim")
+
+        refs = commit.extract_roadmap_references()
+        if refs:
+            self.console.print(f"     🔗 References: {', '.join(refs)}", style="cyan")
+
+    def show_error(self, error: Exception) -> None:
+        """Display an error message.
+
+        Args:
+            error: Exception that occurred
+        """
+        self.console.print(f"❌ Failed to get Git status: {error}", style="bold red")

roadmap/adapters/cli/health/__init__.py

@@ -0,0 +1,8 @@
+"""Health commands for roadmap.
+
+Provides health scanning and diagnostics for entities.
+"""
+
+from roadmap.adapters.cli.health.scan import scan
+
+__all__ = ["scan"]

roadmap/adapters/cli/health/db_integrity.py

@@ -0,0 +1,204 @@
+"""Database integrity check command.
+
+Checks that local issue files align with database state and baseline.
+"""
+
+from __future__ import annotations
+
+import sqlite3
+
+import click
+from structlog import get_logger
+
+from roadmap.adapters.cli.cli_command_helpers import require_initialized
+from roadmap.adapters.cli.utils.click_options import health_check_options
+from roadmap.adapters.persistence.parser.issue import IssueParser
+
+logger = get_logger(__name__)
+
+
+def _collect_local_issue_ids(issues_dir) -> tuple[set[str], list[tuple[str, str]]]:
+    local_ids: set[str] = set()
+    parse_errors: list[tuple[str, str]] = []
+    for file_path in issues_dir.glob("**/*.md"):
+        try:
+            issue = IssueParser.parse_issue_file(file_path)
+        except Exception as exc:
+            parse_errors.append((str(file_path), str(exc)))
+            continue
+        issue_id = getattr(issue, "id", None)
+        if issue_id:
+            local_ids.add(str(issue_id))
+    return local_ids, parse_errors
+
+
+def _load_db_state(db_path) -> tuple[set[str], set[str], int] | None:
+    try:
+        conn = sqlite3.connect(str(db_path))
+        conn.row_factory = sqlite3.Row
+        db_ids = {row["id"] for row in conn.execute("SELECT id FROM issues").fetchall()}
+        baseline_ids = {
+            row["issue_id"]
+            for row in conn.execute("SELECT issue_id FROM sync_base_state").fetchall()
+        }
+        remote_links_count = conn.execute(
+            "SELECT COUNT(*) FROM issue_remote_links"
+        ).fetchone()[0]
+        conn.close()
+        return db_ids, baseline_ids, remote_links_count
+    except Exception as exc:
+        logger.warning(
+            "db_integrity_query_failed",
+            error=str(exc),
+            error_type=type(exc).__name__,
+            severity="operational",
+        )
+        return None
+
+
+def _build_report(
+    local_ids: set[str],
+    db_ids: set[str],
+    baseline_ids: set[str],
+    remote_links_count: int,
+    parse_errors: list[tuple[str, str]],
+) -> dict:
+    missing_in_db = sorted(local_ids - db_ids)
+    extra_in_db = sorted(db_ids - local_ids)
+    baseline_missing_issue = sorted(baseline_ids - db_ids)
+    issue_missing_baseline = sorted(db_ids - baseline_ids)
+
+    return {
+        "local_issue_files": len(local_ids),
+        "db_issues": len(db_ids),
+        "sync_base_state": len(baseline_ids),
+        "remote_links": remote_links_count,
+        "missing_in_db": len(missing_in_db),
+        "extra_in_db": len(extra_in_db),
+        "baseline_missing_issue": len(baseline_missing_issue),
+        "issue_missing_baseline": len(issue_missing_baseline),
+        "missing_in_db_ids": missing_in_db,
+        "extra_in_db_ids": extra_in_db,
+        "baseline_missing_issue_ids": baseline_missing_issue,
+        "issue_missing_baseline_ids": issue_missing_baseline,
+        "parse_errors": parse_errors,
+    }
+
+
+def _print_plain_report(report: dict, show_ids: bool, limit: int) -> None:
+    click.echo("DB Integrity Report")
+    click.echo(f"local_issue_files: {report['local_issue_files']}")
+    click.echo(f"db_issues: {report['db_issues']}")
+    click.echo(f"sync_base_state: {report['sync_base_state']}")
+    click.echo(f"remote_links: {report['remote_links']}")
+    click.echo(f"missing_in_db: {report['missing_in_db']}")
+    click.echo(f"extra_in_db: {report['extra_in_db']}")
+    click.echo(f"baseline_missing_issue: {report['baseline_missing_issue']}")
+    click.echo(f"issue_missing_baseline: {report['issue_missing_baseline']}")
+    click.echo(f"parse_errors: {len(report['parse_errors'])}")
+
+    if show_ids and limit > 0:
+        if report["missing_in_db_ids"]:
+            click.echo("missing_in_db_ids:")
+            for issue_id in report["missing_in_db_ids"][:limit]:
+                click.echo(f"  {issue_id}")
+        if report["extra_in_db_ids"]:
+            click.echo("extra_in_db_ids:")
+            for issue_id in report["extra_in_db_ids"][:limit]:
+                click.echo(f"  {issue_id}")
+        if report["baseline_missing_issue_ids"]:
+            click.echo("baseline_missing_issue_ids:")
+            for issue_id in report["baseline_missing_issue_ids"][:limit]:
+                click.echo(f"  {issue_id}")
+        if report["issue_missing_baseline_ids"]:
+            click.echo("issue_missing_baseline_ids:")
+            for issue_id in report["issue_missing_baseline_ids"][:limit]:
+                click.echo(f"  {issue_id}")
+        if report["parse_errors"]:
+            click.echo("parse_errors:")
+            for path, error in report["parse_errors"][:limit]:
+                click.echo(f"  {path}: {error}")
+
+
+@click.command(name="db-integrity")
+@health_check_options
+@click.option(
+    "--show-ids",
+    is_flag=True,
+    help="Show missing/extra ids (limited by --limit)",
+)
+@click.option(
+    "--json",
+    "json_output",
+    is_flag=True,
+    help="Output results as JSON",
+)
+@click.option(
+    "--limit",
+    type=int,
+    default=20,
+    show_default=True,
+    help="Max ids to display when using --show-ids",
+)
+@click.pass_context
+@require_initialized
+def db_integrity(
+    ctx: click.Context,
+    show_ids: bool,
+    json_output: bool,
+    limit: int,
+    verbose: bool,
+    details: bool,
+    format: str,
+) -> None:
+    """Check database integrity against local issue files."""
+    core = ctx.obj["core"]
+    issues_dir = core.roadmap_dir / "issues"
+    db_path = core.db_dir / "state.db"
+
+    if not issues_dir.exists():
+        click.echo("No issues directory found.")
+        return
+
+    if not db_path.exists():
+        click.echo("Database not found.")
+        return
+
+    local_ids, parse_errors = _collect_local_issue_ids(issues_dir)
+    db_state = _load_db_state(db_path)
+    if db_state is None:
+        click.echo("Failed to read database state.")
+        return
+    db_ids, baseline_ids, remote_links_count = db_state
+    report = _build_report(
+        local_ids,
+        db_ids,
+        baseline_ids,
+        remote_links_count,
+        parse_errors,
+    )
+
+    if json_output:
+        import json
+
+        if show_ids and limit > 0:
+            report["missing_in_db_ids"] = report["missing_in_db_ids"][:limit]
+            report["extra_in_db_ids"] = report["extra_in_db_ids"][:limit]
+            report["baseline_missing_issue_ids"] = report["baseline_missing_issue_ids"][
+                :limit
+            ]
+            report["issue_missing_baseline_ids"] = report["issue_missing_baseline_ids"][
+                :limit
+            ]
+            report["parse_errors"] = [
+                {"path": path, "error": error}
+                for path, error in report["parse_errors"][:limit]
+            ]
+        else:
+            report["parse_errors"] = [
+                {"path": path, "error": error} for path, error in report["parse_errors"]
+            ]
+        click.echo(json.dumps(report, indent=2))
+        return
+
+    _print_plain_report(report, show_ids, limit)