claude-mpm 4.7.4__py3-none-any.whl → 4.18.2__py3-none-any.whl

claude_mpm/utils/display_helper.py

@@ -0,0 +1,260 @@
+"""
+Display Helper for Rich Console Output.
+
+WHY: Centralizes display formatting logic to reduce code duplication
+across CLI commands. Provides reusable components for tables, panels,
+reports, and structured output.
+"""
+
+from typing import Any, Dict, List, Tuple
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+
+class DisplayHelper:
+    """Centralized display formatting for Rich console output."""
+
+    def __init__(self, console: Console):
+        """Initialize display helper with console instance."""
+        self.console = console
+
+    def display_separator(self, char: str = "=", width: int = 60) -> None:
+        """Display a separator line."""
+        self.console.print(char * width)
+
+    def display_header(self, title: str, width: int = 60) -> None:
+        """Display a formatted header with separators."""
+        self.display_separator(width=width)
+        self.console.print(f"[bold]{title}[/bold]")
+        self.display_separator(width=width)
+        self.console.print()
+
+    def display_section_title(self, title: str, emoji: str = "") -> None:
+        """Display a section title with optional emoji."""
+        if emoji:
+            self.console.print(f"[bold cyan]{emoji} {title}[/bold cyan]")
+        else:
+            self.console.print(f"[bold cyan]{title}[/bold cyan]")
+
+    def display_key_value_table(
+        self,
+        title: str,
+        data: Dict[str, Any],
+        key_style: str = "cyan",
+        value_style: str = "white",
+    ) -> None:
+        """Display a two-column key-value table."""
+        table = Table(title=title, show_header=True)
+        table.add_column("Property", style=key_style)
+        table.add_column("Value", style=value_style)
+
+        for key, value in data.items():
+            # Handle various value types
+            if isinstance(value, bool):
+                display_value = "✓" if value else "✗"
+            elif isinstance(value, int) and key.lower().find("size") >= 0:
+                display_value = f"{value:,} characters"
+            else:
+                display_value = str(value)
+            table.add_row(key, display_value)
+
+        self.console.print(table)
+
+    def display_list_section(
+        self, title: str, items: List[str], max_items: int = 10, color: str = "white"
+    ) -> None:
+        """Display a titled list of items."""
+        self.console.print(f"\n[bold cyan]{title}[/bold cyan]")
+        for item in items[:max_items]:
+            self.console.print(f"  [{color}]{item}[/{color}]")
+
+    def display_warning_list(self, title: str, items: List[str]) -> None:
+        """Display a list of warning items."""
+        self.console.print(f"\n[yellow]{title}[/yellow]")
+        for item in items:
+            self.console.print(f"  • {item}")
+
+    def display_info_list(self, title: str, items: List[str]) -> None:
+        """Display a list of info items."""
+        self.console.print(f"\n[blue]{title}[/blue]")
+        for item in items[:5]:
+            self.console.print(f"  • {item}")
+
+    def display_metric_row(
+        self, label: str, value: Any, indent: int = 2, warning: bool = False
+    ) -> None:
+        """Display a single metric row with label and value."""
+        indent_str = " " * indent
+        if warning:
+            self.console.print(f"{indent_str}[yellow]{label}: {value}[/yellow]")
+        else:
+            self.console.print(f"{indent_str}{label}: {value}")
+
+    def display_metrics_section(
+        self, title: str, metrics: Dict[str, Any], emoji: str = ""
+    ) -> None:
+        """Display a section with multiple metrics."""
+        self.display_section_title(title, emoji)
+        for label, value in metrics.items():
+            self.display_metric_row(label, value)
+
+    def display_report_section(
+        self,
+        title: str,
+        data: Dict[str, Any],
+        emoji: str = "",
+        show_warnings: bool = True,
+    ) -> None:
+        """Display a generic report section with data and optional warnings."""
+        self.display_section_title(title, emoji)
+
+        for key, value in data.items():
+            if isinstance(value, dict):
+                # Handle nested dictionaries
+                self.console.print(f"  {key}:")
+                for sub_key, sub_value in value.items():
+                    self.console.print(f"    {sub_key}: {sub_value}")
+            elif isinstance(value, list):
+                # Handle lists
+                self.console.print(f"  {key}:")
+                for item in value[:5]:  # Limit to first 5 items
+                    if isinstance(item, dict):
+                        # Handle dict items in list
+                        desc = item.get("description") or str(item)
+                        prefix = "⚠️  " if show_warnings else "•"
+                        self.console.print(f"    {prefix} {desc}")
+                    else:
+                        self.console.print(f"    • {item}")
+            else:
+                # Simple key-value
+                self.console.print(f"  {key}: {value}")
+
+    def display_recommendations(self, recommendations: List[str]) -> None:
+        """Display a recommendations section."""
+        if recommendations:
+            self.display_section_title("💡 Recommendations")
+            for rec in recommendations[:5]:
+                self.console.print(f"  → {rec}")
+
+    def display_documentation_status(
+        self, analysis: Dict, title: str = "Current CLAUDE.md Status"
+    ) -> None:
+        """Display documentation status table."""
+        data = {
+            "Size": analysis.get("size", 0),
+            "Lines": analysis.get("lines", 0),
+            "Sections": len(analysis.get("sections", [])),
+            "Has Priority Index": analysis.get("has_priority_index", False),
+            "Has Priority Markers": analysis.get("has_priority_markers", False),
+        }
+
+        if analysis.get("last_modified"):
+            data["Last Modified"] = analysis["last_modified"]
+
+        self.display_key_value_table(title, data)
+
+        # Display warnings if present
+        if analysis.get("outdated_patterns"):
+            self.display_warning_list(
+                "⚠️  Outdated patterns detected:", analysis["outdated_patterns"]
+            )
+
+        # Display custom sections if present
+        if analysis.get("custom_sections"):
+            self.display_info_list(
+                "[INFO]️  Custom sections found:", analysis["custom_sections"]
+            )
+
+    def display_activity_summary(
+        self, summary: Dict, period: str = "Last 30 days"
+    ) -> None:
+        """Display activity summary metrics."""
+        metrics = {
+            "Total commits": summary.get("total_commits", 0),
+            "Active contributors": summary.get("total_authors", 0),
+            "Files modified": summary.get("files_changed", 0),
+            "Current branch": summary.get("current_branch", "unknown"),
+        }
+
+        self.display_metrics_section(
+            f"📊 Activity Overview ({period.lower()})", metrics
+        )
+
+        if summary.get("has_uncommitted"):
+            self.display_metric_row(
+                "⚠️  Uncommitted changes",
+                f"{summary.get('uncommitted_count', 0)} files",
+                warning=True,
+            )
+
+    def display_commit_list(
+        self, commits: List[Dict], title: str = "📝 Recent Commits (last 10)"
+    ) -> None:
+        """Display a list of commits."""
+        if commits:
+            self.display_section_title(title)
+            for commit in commits[:10]:
+                msg = commit.get("message", "")[:60]
+                hash_val = commit.get("hash", "")
+                author = commit.get("author", "")
+                self.console.print(f"  [{hash_val}] {msg} - {author}")
+
+    def display_file_change_list(
+        self, files: List[Tuple[str, int]], title: str = "🔥 Most Changed Files"
+    ) -> None:
+        """Display a list of changed files with change counts."""
+        if files:
+            self.display_section_title(title)
+            for file_path, changes in files[:10]:
+                self.console.print(f"  {file_path}: {changes} changes")
+
+    def display_branch_list(
+        self,
+        branches: List[str],
+        current_branch: str,
+        title: str = "🌿 Active Branches",
+    ) -> None:
+        """Display a list of branches with current branch marked."""
+        if branches:
+            self.display_section_title(title)
+            for branch in branches:
+                marker = "→" if branch == current_branch else " "
+                self.console.print(f"  {marker} {branch}")
+
+    def display_success_panel(
+        self,
+        title: str,
+        content: str,
+        border_style: str = "green",
+    ) -> None:
+        """Display a success panel with content."""
+        self.console.print(Panel(content, title=title, border_style=border_style))
+
+    def display_info_panel(
+        self,
+        title: str,
+        content: str,
+        border_style: str = "cyan",
+    ) -> None:
+        """Display an info panel with content."""
+        self.console.print(Panel(content, title=title, border_style=border_style))
+
+    def display_files_list(
+        self, title: str, files: List[str], prefix: str = "•"
+    ) -> None:
+        """Display a list of files."""
+        if files:
+            self.console.print(f"[bold]{title}[/bold]")
+            for file in files:
+                self.console.print(f"  {prefix} {file}")
+            self.console.print()
+
+    def display_next_steps(self, steps: List[str]) -> None:
+        """Display next steps list."""
+        if steps:
+            self.console.print("[bold]Next Steps:[/bold]")
+            for step in steps:
+                self.console.print(f"  → {step}")
+            self.console.print()

claude_mpm/utils/git_analyzer.py

@@ -0,0 +1,407 @@
+"""
+Git history analysis utilities for intelligent context reconstruction.
+
+This module provides utilities to analyze git repository activity for
+context reconstruction and project intelligence. Extracted from the
+session management system to support git-based context approaches.
+"""
+
+import subprocess
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from claude_mpm.core.logging_utils import get_logger
+
+logger = get_logger(__name__)
+
+
+def analyze_recent_activity(
+    repo_path: str = ".", days: int = 7, max_commits: int = 50, min_commits: int = 25
+) -> Dict[str, Any]:
+    """
+    Analyze recent git activity for context reconstruction with adaptive time window.
+
+    Strategy:
+    1. Try to get commits from last {days} days
+    2. If fewer than {min_commits} found, expand window to get {min_commits}
+    3. Never exceed {max_commits} total
+
+    This ensures meaningful context for both high-velocity and low-velocity projects.
+
+    Args:
+        repo_path: Path to the git repository (default: current directory)
+        days: Number of days to look back initially (default: 7)
+        max_commits: Maximum number of commits to analyze (default: 50)
+        min_commits: Minimum commits to retrieve, will expand window if needed (default: 25)
+
+    Returns:
+        Dict containing:
+        - time_range: str - Description of analysis period
+        - commits: List[Dict] - Recent commits with metadata
+        - branches: List[str] - Active branches in the repository
+        - contributors: Dict[str, Dict] - Contributor statistics
+        - file_changes: Dict[str, Dict] - File change statistics
+        - has_activity: bool - Whether any activity was found
+        - adaptive_mode: bool - Whether time window was expanded
+        - actual_time_span: Optional[str] - Actual time span if adaptive mode was used
+        - reason: Optional[str] - Explanation for adaptive mode
+        - error: Optional[str] - Error message if analysis failed
+    """
+    repo_path_obj = Path(repo_path)
+    analysis = {
+        "time_range": f"last {days} days",
+        "commits": [],
+        "branches": [],
+        "contributors": {},
+        "file_changes": {},
+        "has_activity": False,
+        "adaptive_mode": False,
+        "min_commits_target": min_commits,
+    }
+
+    try:
+        # Get all branches
+        result = subprocess.run(
+            ["git", "branch", "-a"],
+            cwd=str(repo_path_obj),
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        branches = [
+            line.strip().replace("* ", "").replace("remotes/origin/", "")
+            for line in result.stdout.strip().split("\n")
+            if line.strip()
+        ]
+        analysis["branches"] = list(set(branches))
+
+        # Step 1: Get commits from specified time window
+        result = subprocess.run(
+            [
+                "git",
+                "log",
+                "--all",
+                f"--since={days} days ago",
+                f"--max-count={max_commits}",
+                "--format=%h|%an|%ae|%ai|%s",
+                "--name-status",
+            ],
+            cwd=str(repo_path_obj),
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+
+        if not result.stdout.strip():
+            return analysis
+
+        analysis["has_activity"] = True
+
+        # Step 2: Count commit lines (lines with pipe separator) to determine if we need adaptive mode
+        temp_commits = []
+        for line in result.stdout.strip().split("\n"):
+            if "|" in line:
+                temp_commits.append(line)
+
+        # Step 3: Check if we need adaptive mode
+        if len(temp_commits) < min_commits:
+            logger.info(
+                f"Only {len(temp_commits)} commits found in last {days} days, "
+                f"expanding to get at least {min_commits} commits"
+            )
+
+            # Get last N commits regardless of date
+            expanded_result = subprocess.run(
+                [
+                    "git",
+                    "log",
+                    "--all",
+                    f"-{min_commits}",
+                    "--format=%h|%an|%ae|%ai|%s",
+                    "--name-status",
+                ],
+                cwd=str(repo_path_obj),
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+
+            if expanded_result.stdout.strip():
+                result = expanded_result
+                analysis["adaptive_mode"] = True
+
+                # Calculate actual time span
+                from datetime import datetime
+
+                commit_lines = [
+                    line for line in result.stdout.strip().split("\n") if "|" in line
+                ]
+                if commit_lines:
+                    # Parse first and last commit dates
+                    try:
+                        first_parts = commit_lines[0].split("|", 4)
+                        last_parts = commit_lines[-1].split("|", 4)
+
+                        if len(first_parts) >= 4 and len(last_parts) >= 4:
+                            # Parse ISO format dates (e.g., "2025-10-20 11:38:20 -0700")
+                            # Extract just the date portion before timezone
+                            first_date_str = first_parts[3].strip()
+                            last_date_str = last_parts[3].strip()
+
+                            # Remove timezone info for parsing
+                            first_date_clean = first_date_str.split(" +")[0].split(
+                                " -"
+                            )[0]
+                            last_date_clean = last_date_str.split(" +")[0].split(" -")[
+                                0
+                            ]
+
+                            # Parse as datetime
+                            first_date = datetime.fromisoformat(
+                                first_date_clean.replace(" ", "T")
+                            )
+                            last_date = datetime.fromisoformat(
+                                last_date_clean.replace(" ", "T")
+                            )
+
+                            days_diff = (first_date - last_date).days
+                            # Handle the case where days_diff might be 0 or 1
+                            if days_diff <= 1:
+                                days_diff = max(days_diff, 1)
+
+                            analysis["actual_time_span"] = str(days_diff)
+
+                            # Provide clear messaging based on the expansion
+                            if days_diff > days:
+                                analysis["reason"] = (
+                                    f"Expanded from {days} days to {days_diff} days "
+                                    f"to reach minimum {min_commits} commits for meaningful context"
+                                )
+                            else:
+                                # High-velocity project: reached min_commits without expanding time window
+                                analysis["reason"] = (
+                                    f"Fetched last {min_commits} commits (spanning {days_diff} days) "
+                                    f"to ensure meaningful context"
+                                )
+                    except Exception as e:
+                        logger.warning(f"Could not calculate actual time span: {e}")
+                        analysis["actual_time_span"] = f">{days} days"
+                        analysis["reason"] = (
+                            f"Expanded beyond {days} days to get minimum {min_commits} commits"
+                        )
+
+        # Parse commit log
+        commits = []
+        current_commit = None
+        file_changes = {}
+
+        for line in result.stdout.strip().split("\n"):
+            if not line.strip():
+                continue
+
+            if "|" in line:
+                # Commit line
+                if current_commit:
+                    commits.append(current_commit)
+
+                parts = line.split("|", 4)
+                if len(parts) == 5:
+                    sha, author, email, timestamp, message = parts
+                    current_commit = {
+                        "sha": sha,
+                        "author": author,
+                        "email": email,
+                        "timestamp": timestamp,
+                        "message": message,
+                        "files": [],
+                    }
+
+                    # Track contributors
+                    if author not in analysis["contributors"]:
+                        analysis["contributors"][author] = {
+                            "email": email,
+                            "commits": 0,
+                        }
+                    analysis["contributors"][author]["commits"] += 1
+            # File change line
+            elif current_commit and "\t" in line:
+                parts = line.split("\t", 1)
+                if len(parts) == 2:
+                    status, file_path = parts
+                    current_commit["files"].append(
+                        {"status": status, "path": file_path}
+                    )
+
+                    # Track file changes
+                    if file_path not in file_changes:
+                        file_changes[file_path] = {
+                            "modifications": 0,
+                            "contributors": set(),
+                        }
+                    file_changes[file_path]["modifications"] += 1
+                    file_changes[file_path]["contributors"].add(
+                        current_commit["author"]
+                    )
+
+        # Add last commit
+        if current_commit:
+            commits.append(current_commit)
+
+        analysis["commits"] = commits
+
+        # Convert file changes to serializable format
+        analysis["file_changes"] = {
+            path: {
+                "modifications": info["modifications"],
+                "contributors": list(info["contributors"]),
+            }
+            for path, info in file_changes.items()
+        }
+
+    except subprocess.CalledProcessError as e:
+        logger.warning(f"Git command failed: {e}")
+        analysis["error"] = f"Git command failed: {e}"
+    except Exception as e:
+        logger.warning(f"Could not analyze recent activity: {e}")
+        analysis["error"] = str(e)
+
+    return analysis
+
+
+def get_current_branch(repo_path: str = ".") -> Optional[str]:
+    """
+    Get the current git branch name.
+
+    Args:
+        repo_path: Path to the git repository (default: current directory)
+
+    Returns:
+        Current branch name or None if not in a git repository
+    """
+    try:
+        result = subprocess.run(
+            ["git", "branch", "--show-current"],
+            cwd=str(Path(repo_path)),
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        return result.stdout.strip()
+    except Exception:
+        return None
+
+
+def get_commits_since(since_sha: str, repo_path: str = ".") -> List[Dict[str, str]]:
+    """
+    Get commits since a specific SHA.
+
+    Args:
+        since_sha: The SHA to get commits after
+        repo_path: Path to the git repository (default: current directory)
+
+    Returns:
+        List of commit dicts with sha, author, timestamp, and message
+    """
+    try:
+        result = subprocess.run(
+            ["git", "log", f"{since_sha}..HEAD", "--format=%h|%an|%ai|%s"],
+            cwd=str(Path(repo_path)),
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+
+        commits = []
+        for line in result.stdout.strip().split("\n"):
+            if not line:
+                continue
+            parts = line.split("|", 3)
+            if len(parts) == 4:
+                sha, author, timestamp, message = parts
+                commits.append(
+                    {
+                        "sha": sha,
+                        "author": author,
+                        "timestamp": timestamp,
+                        "message": message,
+                    }
+                )
+
+        return commits
+
+    except Exception as e:
+        logger.warning(f"Could not get commits: {e}")
+        return []
+
+
+def get_current_status(repo_path: str = ".") -> Dict[str, Any]:
+    """
+    Get current git status.
+
+    Args:
+        repo_path: Path to the git repository (default: current directory)
+
+    Returns:
+        Dict with:
+        - clean: bool - Whether working directory is clean
+        - modified_files: List[str] - Modified files
+        - untracked_files: List[str] - Untracked files
+    """
+    status = {"clean": True, "modified_files": [], "untracked_files": []}
+
+    try:
+        result = subprocess.run(
+            ["git", "status", "--porcelain"],
+            cwd=str(Path(repo_path)),
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+
+        modified_files = []
+        untracked_files = []
+
+        for line in result.stdout.strip().split("\n"):
+            if not line:
+                continue
+            status_code = line[:2]
+            file_path = line[3:]
+
+            if status_code.startswith("??"):
+                untracked_files.append(file_path)
+            else:
+                modified_files.append(file_path)
+
+        status = {
+            "clean": len(modified_files) == 0 and len(untracked_files) == 0,
+            "modified_files": modified_files,
+            "untracked_files": untracked_files,
+        }
+
+    except Exception as e:
+        logger.warning(f"Could not get status: {e}")
+
+    return status
+
+
+def is_git_repository(repo_path: str = ".") -> bool:
+    """
+    Check if the given path is a git repository.
+
+    Args:
+        repo_path: Path to check (default: current directory)
+
+    Returns:
+        True if the path is a git repository, False otherwise
+    """
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "--git-dir"],
+            cwd=str(Path(repo_path)),
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        return result.returncode == 0
+    except Exception:
+        return False