roadmap-cli 0.1.1__py3-none-any.whl

roadmap/core/services/baseline/baseline_builder_progress.py

@@ -0,0 +1,274 @@
+"""Enhanced baseline building with progress display.
+
+This module provides progress bar integration for sync state rebuilding,
+allowing users to see real-time feedback during optimization phases.
+"""
+
+from datetime import UTC, datetime
+from pathlib import Path
+from time import time
+
+from structlog import get_logger
+
+from roadmap.core.services.baseline.optimized_baseline_builder import (
+    CachedBaselineState,
+    OptimizedBaselineBuilder,
+)
+from roadmap.core.services.sync.sync_state import SyncState
+
+logger = get_logger(__name__)
+
+
+class ProgressTrackingBaselineBuilder:
+    """Wraps OptimizedBaselineBuilder with progress bar support.
+
+    Provides real-time feedback during baseline rebuilding operations,
+    showing which phase is active (detection, rebuilding, merging).
+    """
+
+    def __init__(
+        self,
+        issues_dir: Path,
+        show_progress: bool = True,
+    ):
+        """Initialize with progress tracking.
+
+        Args:
+            issues_dir: Path to issues directory
+            show_progress: Whether to show progress bars
+        """
+        self.builder = OptimizedBaselineBuilder(issues_dir)
+        self.show_progress = show_progress
+        self._progress = None
+        self._current_task = None
+
+    def set_progress_context(self, progress) -> None:
+        """Set progress context from rich.progress.Progress.
+
+        Args:
+            progress: Progress instance from rich library
+        """
+        self._progress = progress
+        self.builder.set_progress_context(progress)
+
+    def _log_phase(self, phase: str, details: dict | None = None) -> None:
+        """Log phase transition with progress.
+
+        Args:
+            phase: Name of phase
+            details: Optional details dict
+        """
+        logger.info(
+            "baseline_rebuild_phase",
+            phase=phase,
+            **(details or {}),
+        )
+
+    def rebuild_with_progress(
+        self,
+        all_issue_files: list[Path],
+        cached_state: SyncState | None,
+        git_ref: str = "HEAD~1",
+    ) -> tuple[dict[str, Path] | None, list[str] | None, CachedBaselineState]:
+        """Rebuild baseline with progress tracking.
+
+        Args:
+            all_issue_files: All current issue file paths
+            cached_state: Previous sync state (if any)
+            git_ref: Git reference for change detection
+
+        Returns:
+            Tuple of (issues_to_update, deleted_issues, metrics)
+            - issues_to_update: {issue_id: path} dict for issues to rebuild
+            - deleted_issues: [issue_id] list of deleted issues
+            - metrics: CachedBaselineState with rebuild stats
+        """
+        start_time = time()
+
+        try:
+            # Phase 1: Determine rebuild strategy
+            self._log_phase(
+                "Determining rebuild strategy",
+                {"cached": cached_state is not None},
+            )
+
+            should_full = self.builder.should_rebuild_all(
+                cached_state,
+                time_since_last_sync=None,
+            )
+
+            if should_full:
+                return self._rebuild_full_with_progress(all_issue_files, start_time)
+            elif cached_state is not None:
+                return self._rebuild_incremental_with_progress(
+                    all_issue_files, cached_state, git_ref, start_time
+                )
+            else:
+                # No cached state and not full rebuild - treat as full
+                return self._rebuild_full_with_progress(all_issue_files, start_time)
+
+        except Exception as e:
+            logger.error(
+                "baseline_rebuild_error",
+                error=str(e),
+                error_type=type(e).__name__,
+                severity="system_error",
+            )
+            # Return empty rebuild (will fall back to default)
+            return (
+                None,
+                None,
+                CachedBaselineState(
+                    SyncState(last_sync_time=datetime.now(UTC), base_issues={}),
+                    from_cache=False,
+                    rebuilt_issues=0,
+                    reused_issues=0,
+                    rebuild_time_ms=time() - start_time,
+                ),
+            )
+
+    def _rebuild_full_with_progress(
+        self,
+        all_issue_files: list[Path],
+        start_time: float,
+    ) -> tuple[dict[str, Path], list[str], CachedBaselineState]:
+        """Full rebuild with progress display.
+
+        Args:
+            all_issue_files: All files
+            start_time: Rebuild start time
+
+        Returns:
+            Tuple of (issues_to_update, [], metrics)
+        """
+        self._log_phase("Full rebuild", {"issue_count": len(all_issue_files)})
+
+        # All issues need rebuilding
+        issues_to_update = {}
+        for idx, file_path in enumerate(all_issue_files):
+            relative = str(file_path.relative_to(self.builder.issues_dir))
+            issue_id = self.builder.extract_issue_id_from_path(relative)
+            if issue_id:
+                issues_to_update[issue_id] = file_path
+
+            # Log progress every 10 items
+            if (idx + 1) % 10 == 0 or idx == 0:
+                self._log_phase(
+                    f"Preparing rebuild ({idx + 1}/{len(all_issue_files)})",
+                    {"prepared": idx + 1},
+                )
+
+        rebuild_time_ms = (time() - start_time) * 1000
+
+        self._log_phase(
+            f"Full rebuild ready ({len(issues_to_update)} issues)",
+            {"rebuild_time_ms": f"{rebuild_time_ms:.1f}"},
+        )
+
+        return (
+            issues_to_update,
+            [],
+            CachedBaselineState(
+                SyncState(
+                    last_sync_time=datetime.now(UTC),
+                    base_issues={},
+                ),
+                from_cache=False,
+                rebuilt_issues=len(issues_to_update),
+                reused_issues=0,
+                rebuild_time_ms=rebuild_time_ms,
+            ),
+        )
+
+    def _rebuild_incremental_with_progress(
+        self,
+        all_issue_files: list[Path],
+        cached_state: SyncState,
+        git_ref: str,
+        start_time: float,
+    ) -> tuple[dict[str, Path], list[str], CachedBaselineState]:
+        """Incremental rebuild with progress display.
+
+        Args:
+            all_issue_files: All files
+            cached_state: Previous state
+            git_ref: Git reference
+            start_time: Rebuild start time
+
+        Returns:
+            Tuple of (issues_to_update, deleted_issues, metrics)
+        """
+        self._log_phase("Detecting file changes", {"git_ref": git_ref})
+
+        # Phase 2: Get changed files
+        changed_files = self.builder.get_changed_issue_files(git_ref)
+        self._log_phase(
+            "File changes detected",
+            {"changed_count": len(changed_files)},
+        )
+
+        # Phase 3: Determine which issues need updates
+        self._log_phase(
+            f"Analyzing {len(all_issue_files)} issues",
+            {"cached_count": len(cached_state.base_issues)},
+        )
+
+        issues_to_update, deleted_issues = self.builder.get_incremental_update_issues(
+            all_issue_files, changed_files, cached_state
+        )
+
+        rebuild_time_ms = (time() - start_time) * 1000
+        reused_count = len(cached_state.base_issues) - len(issues_to_update)
+
+        self._log_phase(
+            "Rebuild analysis complete",
+            {
+                "rebuild_count": len(issues_to_update),
+                "reused_count": reused_count,
+                "deleted_count": len(deleted_issues),
+                "rebuild_time_ms": f"{rebuild_time_ms:.1f}",
+            },
+        )
+
+        return (
+            issues_to_update,
+            deleted_issues,
+            CachedBaselineState(
+                SyncState(
+                    last_sync_time=cached_state.last_sync_time,
+                    base_issues=cached_state.base_issues,
+                ),
+                from_cache=False,
+                rebuilt_issues=len(issues_to_update),
+                reused_issues=reused_count,
+                rebuild_time_ms=rebuild_time_ms,
+            ),
+        )
+
+
+def create_progress_builder(
+    issues_dir: Path,
+    show_progress: bool = True,
+) -> ProgressTrackingBaselineBuilder | None:
+    """Create a progress-enabled baseline builder.
+
+    Args:
+        issues_dir: Path to issues directory
+        show_progress: Whether to show progress
+
+    Returns:
+        ProgressTrackingBaselineBuilder or None if progress not supported
+
+    Example:
+        >>> from rich.progress import Progress
+        >>> builder = create_progress_builder(Path("roadmap/issues"))
+        >>> with Progress() as progress:
+        ...     builder.set_progress_context(progress)
+        ...     updates, deleted, metrics = builder.rebuild_with_progress(files, state)
+        ...     print(metrics.to_dict())
+    """
+    if not show_progress:
+        logger.debug("progress_bars_disabled")
+        return None
+
+    return ProgressTrackingBaselineBuilder(issues_dir, show_progress)

roadmap/core/services/baseline/baseline_retriever.py

@@ -0,0 +1,63 @@
+"""Baseline snapshot retrieval from remote sources."""
+
+from typing import Any
+
+import structlog
+
+BaselineSnapshot = dict[str, Any]
+
+logger = structlog.get_logger()
+
+
+class BaselineRetriever:
+    """Retrieve the current sync baseline from available stores.
+
+    Prefers `core.db.get_sync_baseline()` when available, then a provided
+    `db_session.get_sync_baseline()`. If neither is present, returns an
+    empty baseline snapshot.
+    """
+
+    @staticmethod
+    def get_current_baseline(
+        core: Any = None, db_session: Any = None
+    ) -> BaselineSnapshot:
+        """Get the current sync baseline from available stores.
+
+        Tries multiple sources in order: core.db, db_session, or empty dict.
+
+        Args:
+            core: Optional core instance with db attribute.
+            db_session: Optional database session.
+
+        Returns:
+            Baseline snapshot dictionary.
+        """
+        if (
+            core is not None
+            and getattr(core, "db", None)
+            and hasattr(core.db, "get_sync_baseline")
+        ):
+            try:
+                return core.db.get_sync_baseline() or {}
+            except Exception as e:
+                logger.debug(
+                    "get_sync_baseline_failed",
+                    operation="get_sync_baseline",
+                    error=str(e),
+                    action="Using fallback empty dict",
+                )
+                return {}
+
+        if db_session is not None and hasattr(db_session, "get_sync_baseline"):
+            try:
+                return db_session.get_sync_baseline() or {}
+            except Exception as e:
+                logger.debug(
+                    "get_sync_baseline_db_failed",
+                    operation="get_sync_baseline_db_session",
+                    error=str(e),
+                    action="Using empty baseline",
+                )
+                return {}
+
+        return {}

roadmap/core/services/baseline/baseline_selector.py

@@ -0,0 +1,248 @@
+"""Interactive baseline selection utility for team onboarding.
+
+Provides guidance and interactive selection for teams creating their
+initial baseline during first sync. Ensures explicit, informed choices
+about the agreed-upon starting state.
+"""
+
+from enum import StrEnum
+from typing import Any
+
+from structlog import get_logger
+
+logger = get_logger()
+
+
+class BaselineStrategy(StrEnum):
+    """Strategy for creating initial baseline."""
+
+    LOCAL = "local"
+    """Use local state as baseline - local code is source of truth."""
+
+    REMOTE = "remote"
+    """Use remote state as baseline - remote system is source of truth."""
+
+    INTERACTIVE = "interactive"
+    """Let user choose per-issue which state to use as baseline."""
+
+
+class BaselineSelectionResult:
+    """Result of baseline selection for one or more issues."""
+
+    def __init__(
+        self,
+        strategy: BaselineStrategy,
+        selected_issues: dict[str, str] | None = None,
+    ):
+        """Initialize result.
+
+        Args:
+            strategy: The strategy chosen (LOCAL, REMOTE, or INTERACTIVE)
+            selected_issues: For INTERACTIVE, dict of issue_id -> "local" or "remote"
+        """
+        self.strategy = strategy
+        self.selected_issues = selected_issues or {}
+
+    def get_baseline_for_issue(
+        self,
+        issue_id: str,
+        local_issue: Any,
+        remote_issue: Any,
+    ) -> Any:
+        """Get the issue state to use as baseline.
+
+        Args:
+            issue_id: The issue ID
+            local_issue: The local issue object
+            remote_issue: The remote issue object
+
+        Returns:
+            The issue object/dict to use as baseline
+        """
+        if self.strategy == BaselineStrategy.LOCAL:
+            return local_issue
+        elif self.strategy == BaselineStrategy.REMOTE:
+            return remote_issue
+        elif self.strategy == BaselineStrategy.INTERACTIVE:
+            choice = self.selected_issues.get(issue_id, "local")
+            return local_issue if choice == "local" else remote_issue
+
+        return local_issue  # Default to local
+
+
+class InteractiveBaselineSelector:
+    """Guides teams through baseline selection during first sync."""
+
+    def __init__(self, console_output_fn=None):
+        """Initialize selector.
+
+        Args:
+            console_output_fn: Function to use for output (for testing)
+        """
+        self.console_output_fn = console_output_fn or self._default_output
+        self.logger = get_logger()
+
+    def _default_output(self, message: str):
+        """Output message to console."""
+        print(message)
+
+    def prompt_baseline_strategy(self) -> BaselineStrategy:
+        """Prompt team to choose baseline strategy.
+
+        Returns:
+            Selected BaselineStrategy
+        """
+        self.logger.info("baseline_strategy_prompt")
+
+        self.console_output_fn("\n" + "=" * 60)
+        self.console_output_fn("BASELINE SELECTION - First Sync Configuration")
+        self.console_output_fn("=" * 60)
+        self.console_output_fn(
+            """
+This is your first sync. We need to establish the agreed-upon baseline state
+that both local and remote systems accept as the starting point.
+
+Choose one of these strategies:
+
+1. LOCAL - Use your local code as the baseline
+   Use this if: Local code is your source of truth
+   Effect: Remote will pull all local changes
+   Risk: May overwrite remote-only changes
+
+2. REMOTE - Use the remote system as the baseline
+   Use this if: Remote system is your source of truth
+   Effect: Local will pull all remote changes
+   Risk: May overwrite local-only changes
+
+3. INTERACTIVE - Choose per-issue which is the baseline
+   Use this if: Different issues have different sources of truth
+   Effect: You'll be asked for each changed issue
+   Risk: Most time-consuming but most flexible
+"""
+        )
+
+        while True:
+            choice = input("\nEnter your choice (1, 2, or 3): ").strip()
+            if choice == "1":
+                self.console_output_fn("✓ Selected: LOCAL baseline strategy")
+                self.logger.info("baseline_strategy_selected", strategy="local")
+                return BaselineStrategy.LOCAL
+            elif choice == "2":
+                self.console_output_fn("✓ Selected: REMOTE baseline strategy")
+                self.logger.info("baseline_strategy_selected", strategy="remote")
+                return BaselineStrategy.REMOTE
+            elif choice == "3":
+                self.console_output_fn("✓ Selected: INTERACTIVE baseline strategy")
+                self.logger.info("baseline_strategy_selected", strategy="interactive")
+                return BaselineStrategy.INTERACTIVE
+            else:
+                self.console_output_fn("Invalid choice. Please enter 1, 2, or 3.")
+
+    def prompt_interactive_selections(
+        self,
+        issues_with_changes: list[dict[str, Any]],
+    ) -> dict[str, str]:
+        """Prompt user to select baseline for each changed issue.
+
+        Args:
+            issues_with_changes: List of issues with dicts containing:
+                - issue_id: str
+                - title: str
+                - local_changes: dict or None
+                - remote_changes: dict or None
+
+        Returns:
+            Dict of issue_id -> "local" or "remote"
+        """
+        self.logger.info(
+            "interactive_baseline_selection_start",
+            issue_count=len(issues_with_changes),
+        )
+
+        selections = {}
+
+        self.console_output_fn("\n" + "=" * 60)
+        self.console_output_fn("INTERACTIVE BASELINE SELECTION")
+        self.console_output_fn("=" * 60)
+        self.console_output_fn(
+            f"\nFor each of {len(issues_with_changes)} changed issues, "
+            "choose which is the baseline:\n"
+        )
+
+        for idx, issue in enumerate(issues_with_changes, 1):
+            issue_id = issue.get("issue_id", "unknown")
+            title = issue.get("title", "Untitled")
+            local_changes = issue.get("local_changes", {})
+            remote_changes = issue.get("remote_changes", {})
+
+            self.console_output_fn(f"\n[{idx}/{len(issues_with_changes)}] {title}")
+            self.console_output_fn(f"    ID: {issue_id}")
+
+            if local_changes:
+                self.console_output_fn(f"    Local changes: {local_changes}")
+            if remote_changes:
+                self.console_output_fn(f"    Remote changes: {remote_changes}")
+
+            choice = None
+            while choice is None:
+                response = (
+                    input("\n    Use LOCAL or REMOTE as baseline? (L/R): ")
+                    .strip()
+                    .upper()
+                )
+                if response in ("L", "LOCAL"):
+                    choice = "local"
+                    self.console_output_fn("    → Using LOCAL as baseline")
+                elif response in ("R", "REMOTE"):
+                    choice = "remote"
+                    self.console_output_fn("    → Using REMOTE as baseline")
+                else:
+                    self.console_output_fn("    Invalid choice. Enter L or R.")
+
+            selections[issue_id] = choice
+            self.logger.debug(
+                "interactive_baseline_selected",
+                issue_id=issue_id,
+                choice=choice,
+            )
+
+        self.console_output_fn("\n✓ Baseline selection complete\n")
+        self.logger.info(
+            "interactive_baseline_selection_complete",
+            selections=selections,
+        )
+
+        return selections
+
+    def select_baseline(
+        self,
+        issues_with_changes: list[dict[str, Any]] | None = None,
+        strategy: BaselineStrategy | None = None,
+    ) -> BaselineSelectionResult:
+        """Guide complete baseline selection process.
+
+        Args:
+            issues_with_changes: Issues with changes (for interactive mode)
+            strategy: Override strategy (for testing/automation)
+
+        Returns:
+            BaselineSelectionResult with strategy and selections
+        """
+        self.logger.info("baseline_selection_start")
+
+        # Get strategy if not provided
+        if strategy is None:
+            strategy = self.prompt_baseline_strategy()
+
+        # Get specific selections if interactive
+        selected_issues = {}
+        if strategy == BaselineStrategy.INTERACTIVE and issues_with_changes:
+            selected_issues = self.prompt_interactive_selections(issues_with_changes)
+
+        result = BaselineSelectionResult(
+            strategy=strategy,
+            selected_issues=selected_issues,
+        )
+
+        self.logger.info("baseline_selection_complete", strategy=strategy.value)
+        return result