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

claude_mpm/cli/commands/mpm_init.py

@@ -12,15 +12,15 @@ import contextlib
 import subprocess
 import sys
 from pathlib import Path
-from typing import Dict, List, Optional
+from typing import Any, Dict, List, Optional
 
 import click
 from rich.console import Console
 from rich.panel import Panel
 from rich.progress import Progress, SpinnerColumn, TextColumn
 from rich.prompt import Prompt
-from rich.table import Table
 
+from claude_mpm.core.enums import OperationResult
 from claude_mpm.core.logging_utils import get_logger
 
 # Import new services
@@ -28,6 +28,7 @@ from claude_mpm.services.project.archive_manager import ArchiveManager
 from claude_mpm.services.project.documentation_manager import DocumentationManager
 from claude_mpm.services.project.enhanced_analyzer import EnhancedProjectAnalyzer
 from claude_mpm.services.project.project_organizer import ProjectOrganizer
+from claude_mpm.utils.display_helper import DisplayHelper
 
 logger = get_logger(__name__)
 console = Console()
@@ -46,6 +47,7 @@ class MPMInitCommand:
         self.organizer = ProjectOrganizer(self.project_path)
         self.archive_manager = ArchiveManager(self.project_path)
         self.analyzer = EnhancedProjectAnalyzer(self.project_path)
+        self.display = DisplayHelper(console)
 
     def initialize_project(
         self,
@@ -53,7 +55,6 @@ class MPMInitCommand:
         framework: Optional[str] = None,
         force: bool = False,
         verbose: bool = False,
-        use_venv: bool = False,
         ast_analysis: bool = True,
         update_mode: bool = False,
         review_only: bool = False,
@@ -62,6 +63,7 @@ class MPMInitCommand:
         skip_archive: bool = False,
         dry_run: bool = False,
         quick_update: bool = False,
+        catchup: bool = False,
         non_interactive: bool = False,
         days: int = 30,
         export: Optional[str] = None,
@@ -74,7 +76,6 @@ class MPMInitCommand:
             framework: Specific framework if applicable
             force: Force initialization even if project already configured
             verbose: Show detailed output
-            use_venv: Force use of venv instead of mamba
             ast_analysis: Enable AST analysis for enhanced documentation
             update_mode: Update existing CLAUDE.md instead of recreating
             review_only: Review project state without making changes
@@ -83,6 +84,7 @@ class MPMInitCommand:
             skip_archive: Skip archiving existing files
             dry_run: Show what would be done without making changes
             quick_update: Perform lightweight update based on recent git activity
+            catchup: Show recent commit history from all branches for PM context
             non_interactive: Non-interactive mode - display report only without prompting
             days: Number of days for git history analysis (7, 14, 30, 60, or 90)
             export: Export report to file (path or "auto" for default location)
@@ -98,6 +100,15 @@ class MPMInitCommand:
             if review_only:
                 return self._run_review_mode()
 
+            if catchup:
+                data = self._catchup()
+                self._display_catchup(data)
+                return {
+                    "status": OperationResult.SUCCESS,
+                    "mode": "catchup",
+                    "catchup_data": data,
+                }
+
             if quick_update:
                 return self._run_quick_update_mode(
                     days=days,
@@ -133,7 +144,7 @@ class MPMInitCommand:
                         return self._run_review_mode()
                     else:
                         return {
-                            "status": "cancelled",
+                            "status": OperationResult.CANCELLED,
                             "message": "Initialization cancelled",
                         }
 
@@ -146,7 +157,7 @@ class MPMInitCommand:
                 pre_check_result = self._run_pre_initialization_checks(
                     organize_files, skip_archive, has_existing
                 )
-                if pre_check_result.get("status") == "error":
+                if pre_check_result.get("status") == OperationResult.ERROR:
                     return pre_check_result
 
             # Build the delegation prompt
@@ -179,9 +190,7 @@ class MPMInitCommand:
                 task = progress.add_task(task_desc, total=None)
 
                 # Run the initialization through subprocess
-                result = self._run_initialization(
-                    prompt, verbose, use_venv, update_mode
-                )
+                result = self._run_initialization(prompt, verbose, update_mode)
 
                 complete_desc = (
                     "[green]✓ Update complete"
@@ -191,7 +200,7 @@ class MPMInitCommand:
                 progress.update(task, description=complete_desc)
 
             # Post-processing for update mode
-            if update_mode and result.get("status") == "success":
+            if update_mode and result.get("status") == OperationResult.SUCCESS:
                 self._handle_update_post_processing()
 
             return result
@@ -199,7 +208,7 @@ class MPMInitCommand:
         except Exception as e:
             logger.error(f"Failed to initialize project: {e}")
             console.print(f"[red]❌ Error: {e}[/red]")
-            return {"status": "error", "message": str(e)}
+            return {"status": OperationResult.ERROR, "message": str(e)}
 
     def _find_claude_mpm_script(self) -> Path:
         """Find the claude-mpm script location."""
@@ -397,17 +406,10 @@ The final CLAUDE.md should be a comprehensive, well-organized guide that any AI
 
         return base_prompt
 
-    def _build_claude_mpm_command(
-        self, verbose: bool, use_venv: bool = False
-    ) -> List[str]:
+    def _build_claude_mpm_command(self, verbose: bool) -> List[str]:
         """Build the claude-mpm run command with appropriate arguments."""
         cmd = [str(self.claude_mpm_script)]
 
-        # Add venv flag if requested or if mamba issues detected
-        # This goes BEFORE the subcommand
-        if use_venv:
-            cmd.append("--use-venv")
-
         # Add top-level flags that go before 'run' subcommand
         cmd.append("--no-check-dependencies")
 
@@ -426,34 +428,7 @@ The final CLAUDE.md should be a comprehensive, well-organized guide that any AI
 
     def _display_documentation_status(self, analysis: Dict) -> None:
         """Display current documentation status."""
-        table = Table(title="Current CLAUDE.md Status", show_header=True)
-        table.add_column("Property", style="cyan")
-        table.add_column("Value", style="white")
-
-        table.add_row("Size", f"{analysis.get('size', 0):,} characters")
-        table.add_row("Lines", str(analysis.get("lines", 0)))
-        table.add_row("Sections", str(len(analysis.get("sections", []))))
-        table.add_row(
-            "Has Priority Index", "✓" if analysis.get("has_priority_index") else "✗"
-        )
-        table.add_row(
-            "Has Priority Markers", "✓" if analysis.get("has_priority_markers") else "✗"
-        )
-
-        if analysis.get("last_modified"):
-            table.add_row("Last Modified", analysis["last_modified"])
-
-        console.print(table)
-
-        if analysis.get("outdated_patterns"):
-            console.print("\n[yellow]⚠️  Outdated patterns detected:[/yellow]")
-            for pattern in analysis["outdated_patterns"]:
-                console.print(f"  • {pattern}")
-
-        if analysis.get("custom_sections"):
-            console.print("\n[blue][INFO]️  Custom sections found:[/blue]")
-            for section in analysis["custom_sections"][:5]:
-                console.print(f"  • {section}")
+        self.display.display_documentation_status(analysis)
 
     def _prompt_update_action(self) -> str:
         """Prompt user for update action."""
@@ -514,7 +489,7 @@ The final CLAUDE.md should be a comprehensive, well-organized guide that any AI
         )
 
         return {
-            "status": "success",
+            "status": OperationResult.SUCCESS,
             "mode": "review",
             "structure_report": structure_report,
             "documentation_analysis": doc_analysis,
@@ -526,29 +501,26 @@ The final CLAUDE.md should be a comprehensive, well-organized guide that any AI
         self, structure: Dict, docs: Dict, git: Optional[Dict], state: Dict
     ) -> None:
         """Display comprehensive review report."""
-        console.print("\n" + "=" * 60)
-        console.print("[bold]PROJECT REVIEW REPORT[/bold]")
-        console.print("=" * 60 + "\n")
+        self.display.display_header("PROJECT REVIEW REPORT")
 
         # Project State
-        console.print("[bold cyan]📊 Project State[/bold cyan]")
-        console.print(f"  Phase: {state.get('phase', 'unknown')}")
+        state_data = {"Phase": state.get("phase", "unknown")}
         if state.get("indicators"):
-            console.print("  Indicators:")
-            for indicator in state["indicators"][:5]:
-                console.print(f"    • {indicator}")
+            state_data["Indicators"] = state["indicators"][:5]
+        self.display.display_report_section("📊 Project State", state_data)
 
         # Structure Report
-        console.print("\n[bold cyan]📁 Project Structure[/bold cyan]")
-        console.print(f"  Existing directories: {len(structure.get('exists', []))}")
-        console.print(f"  Missing directories: {len(structure.get('missing', []))}")
+        structure_data = {
+            "Existing directories": len(structure.get("exists", [])),
+            "Missing directories": len(structure.get("missing", [])),
+        }
         if structure.get("issues"):
-            console.print(f"  Issues found: {len(structure['issues'])}")
-            for issue in structure["issues"][:3]:
-                console.print(f"    ⚠️  {issue['description']}")
+            structure_data["Issues found"] = len(structure["issues"])
+            structure_data["Issues"] = structure["issues"][:3]
+        self.display.display_report_section("📁 Project Structure", structure_data)
 
         # Documentation Report
-        console.print("\n[bold cyan]📚 Documentation Status[/bold cyan]")
+        self.display.display_section_title("📚 Documentation Status")
         if docs.get("exists"):
             console.print(f"  CLAUDE.md: Found ({docs.get('size', 0):,} chars)")
             console.print(f"  Sections: {len(docs.get('sections', []))}")
@@ -560,32 +532,34 @@ The final CLAUDE.md should be a comprehensive, well-organized guide that any AI
 
         # Git Analysis
         if git and git.get("git_available"):
-            console.print("\n[bold cyan]📈 Recent Activity (30 days)[/bold cyan]")
-            console.print(f"  Commits: {len(git.get('recent_commits', []))}")
-            console.print(
-                f"  Authors: {git.get('authors', {}).get('total_authors', 0)}"
-            )
-            console.print(
-                f"  Changed files: {git.get('changed_files', {}).get('total_files', 0)}"
-            )
+            git_metrics = {
+                "Commits": len(git.get("recent_commits", [])),
+                "Authors": git.get("authors", {}).get("total_authors", 0),
+                "Changed files": git.get("changed_files", {}).get("total_files", 0),
+            }
 
             if git.get("branch_info"):
                 branch_info = git["branch_info"]
-                console.print(
-                    f"  Current branch: {branch_info.get('current_branch', 'unknown')}"
+                git_metrics["Current branch"] = branch_info.get(
+                    "current_branch", "unknown"
+                )
+
+            self.display.display_metrics_section(
+                "📈 Recent Activity (30 days)", git_metrics
+            )
+
+            if git.get("branch_info", {}).get("has_uncommitted_changes"):
+                self.display.display_metric_row(
+                    "⚠️  Uncommitted changes",
+                    f"{git['branch_info'].get('uncommitted_files', 0)} files",
+                    warning=True,
                 )
-                if branch_info.get("has_uncommitted_changes"):
-                    console.print(
-                        f"  ⚠️  Uncommitted changes: {branch_info.get('uncommitted_files', 0)} files"
-                    )
 
         # Recommendations
         if state.get("recommendations"):
-            console.print("\n[bold cyan]💡 Recommendations[/bold cyan]")
-            for rec in state["recommendations"][:5]:
-                console.print(f"  → {rec}")
+            self.display.display_recommendations(state["recommendations"])
 
-        console.print("\n" + "=" * 60 + "\n")
+        self.display.display_separator()
 
     def _run_quick_update_mode(
         self,
@@ -607,7 +581,7 @@ The final CLAUDE.md should be a comprehensive, well-organized guide that any AI
                 "[dim]Tip: Use `/mpm-init --review` for non-git projects.[/dim]\n"
             )
             return {
-                "status": "error",
+                "status": OperationResult.ERROR,
                 "message": "Quick update requires a git repository",
             }
 
@@ -620,7 +594,7 @@ The final CLAUDE.md should be a comprehensive, well-organized guide that any AI
                 "[dim]Tip: Use `/mpm-init` to create initial documentation.[/dim]\n"
             )
             return {
-                "status": "error",
+                "status": OperationResult.ERROR,
                 "message": "Quick update requires existing CLAUDE.md",
             }
 
@@ -662,7 +636,7 @@ The final CLAUDE.md should be a comprehensive, well-organized guide that any AI
                 "\n[cyan]ℹ️  Non-interactive mode: Report displayed, no changes made.[/cyan]"
             )
             return {
-                "status": "success",
+                "status": OperationResult.SUCCESS,
                 "mode": "quick_update",
                 "activity_report": activity_report,
                 "changes_made": False,
@@ -690,7 +664,7 @@ The final CLAUDE.md should be a comprehensive, well-organized guide that any AI
             )
 
             return {
-                "status": "success",
+                "status": OperationResult.SUCCESS,
                 "mode": "quick_update",
                 "activity_report": activity_report,
                 "changes_made": True,
@@ -698,13 +672,152 @@ The final CLAUDE.md should be a comprehensive, well-organized guide that any AI
         if choice == "2":
             console.print("\n[cyan]Report generated - no changes made[/cyan]")
             return {
-                "status": "success",
+                "status": OperationResult.SUCCESS,
                 "mode": "quick_update",
                 "activity_report": activity_report,
                 "changes_made": False,
             }
         console.print("\n[yellow]Quick update cancelled[/yellow]")
-        return {"status": "cancelled", "message": "Quick update cancelled"}
+        return {
+            "status": OperationResult.CANCELLED,
+            "message": "Quick update cancelled",
+        }
+
+    def _catchup(self) -> Dict[str, Any]:
+        """Get recent commit history for PM context.
+
+        Returns:
+            Dict containing commit history and contributor stats
+        """
+        from collections import Counter
+        from datetime import datetime
+        from subprocess import run
+
+        try:
+            # Get last 25 commits from all branches with author info
+            result = run(
+                ["git", "log", "--all", "--format=%h|%an|%ai|%s", "-25"],
+                capture_output=True,
+                text=True,
+                check=True,
+                cwd=str(self.project_path),
+            )
+
+            commits = []
+            authors = []
+
+            for line in result.stdout.strip().split("\n"):
+                if not line:
+                    continue
+
+                parts = line.split("|", 3)
+                if len(parts) == 4:
+                    hash_val, author, date_str, message = parts
+
+                    # Parse date
+                    try:
+                        dt = datetime.fromisoformat(date_str.replace(" ", "T", 1))
+                        date_display = dt.strftime("%Y-%m-%d %H:%M")
+                    except Exception:
+                        date_display = date_str[:16]
+
+                    commits.append(
+                        {
+                            "hash": hash_val,
+                            "author": author,
+                            "date": date_display,
+                            "message": message,
+                        }
+                    )
+                    authors.append(author)
+
+            # Calculate contributor stats
+            author_counts = Counter(authors)
+
+            return {
+                "commits": commits,
+                "total_commits": len(commits),
+                "contributors": dict(author_counts),
+                "contributor_count": len(author_counts),
+            }
+
+        except Exception as e:
+            console.print(f"[yellow]Could not retrieve commit history: {e}[/yellow]")
+            return {
+                "commits": [],
+                "total_commits": 0,
+                "contributors": {},
+                "contributor_count": 0,
+                "error": str(e),
+            }
+
+    def _display_catchup(self, data: Dict[str, Any]) -> None:
+        """Display catchup information to console.
+
+        Args:
+            data: Commit history data from _catchup()
+        """
+        from rich.panel import Panel
+        from rich.table import Table
+
+        if data.get("error"):
+            console.print(
+                Panel(
+                    "[yellow]Not a git repository or no commits found[/yellow]",
+                    title="⚠️ Catchup Status",
+                    border_style="yellow",
+                )
+            )
+            return
+
+        # Display contributor summary
+        if data["contributors"]:
+            console.print("\n[bold cyan]👥 Active Contributors[/bold cyan]")
+            for author, count in sorted(
+                data["contributors"].items(), key=lambda x: x[1], reverse=True
+            ):
+                console.print(
+                    f"  • [green]{author}[/green]: {count} commit{'s' if count != 1 else ''}"
+                )
+
+        # Display commit history table
+        if data["commits"]:
+            console.print(
+                f"\n[bold cyan]📝 Last {data['total_commits']} Commits[/bold cyan]"
+            )
+
+            table = Table(
+                show_header=True, header_style="bold magenta", border_style="dim"
+            )
+            table.add_column("#", style="dim", width=3)
+            table.add_column("Hash", style="yellow", width=8)
+            table.add_column("Author", style="green", width=20)
+            table.add_column("Date", style="cyan", width=16)
+            table.add_column("Message", style="white")
+
+            for idx, commit in enumerate(data["commits"], 1):
+                # Truncate message if too long
+                msg = commit["message"]
+                if len(msg) > 80:
+                    msg = msg[:77] + "..."
+
+                # Truncate author if too long
+                author = commit["author"]
+                if len(author) > 18:
+                    author = author[:18] + "..."
+
+                table.add_row(str(idx), commit["hash"], author, commit["date"], msg)
+
+            console.print(table)
+
+        # Display PM recommendations
+        console.print("\n[bold cyan]💡 PM Recommendations[/bold cyan]")
+        console.print(
+            f"  • Total activity: {data['total_commits']} commits from {data['contributor_count']} contributor{'s' if data['contributor_count'] != 1 else ''}"
+        )
+        console.print("  • Review commit messages for recent project context")
+        console.print("  • Identify development patterns and focus areas")
+        console.print("  • Use this context to inform current work priorities\n")
 
     def _generate_activity_report(
         self, git_analysis: Dict, doc_analysis: Dict, days: int = 30
@@ -881,70 +994,49 @@ The final CLAUDE.md should be a comprehensive, well-organized guide that any AI
 
     def _display_activity_report(self, report: Dict) -> None:
         """Display the activity report in a formatted manner."""
-        console.print("\n" + "=" * 60)
-        console.print("[bold]RECENT ACTIVITY SUMMARY[/bold]")
-        console.print("=" * 60 + "\n")
+        self.display.display_header("RECENT ACTIVITY SUMMARY")
 
         summary = report.get("summary", {})
         period = report.get("period", "Last 30 days")
 
         # Summary statistics
-        console.print(f"[bold cyan]📊 Activity Overview ({period.lower()})[/bold cyan]")
-        console.print(f"  Total commits: {summary.get('total_commits', 0)}")
-        console.print(f"  Active contributors: {summary.get('total_authors', 0)}")
-        console.print(f"  Files modified: {summary.get('files_changed', 0)}")
-        console.print(f"  Current branch: {summary.get('current_branch', 'unknown')}")
-
-        if summary.get("has_uncommitted"):
-            console.print(
-                f"  [yellow]⚠️  Uncommitted changes: {summary.get('uncommitted_count', 0)} files[/yellow]"
-            )
+        self.display.display_activity_summary(summary, period)
 
         # Recent commits
         recent_commits = report.get("recent_commits", [])
         if recent_commits:
-            console.print("\n[bold cyan]📝 Recent Commits (last 10)[/bold cyan]")
-            for commit in recent_commits[:10]:
-                console.print(
-                    f"  [{commit['hash']}] {commit['message'][:60]} - {commit['author']}"
-                )
+            self.display.display_commit_list(recent_commits)
 
         # Hot files
         hot_files = report.get("hot_files", [])
         if hot_files:
-            console.print("\n[bold cyan]🔥 Most Changed Files[/bold cyan]")
-            for file_path, changes in hot_files[:10]:
-                console.print(f"  {file_path}: {changes} changes")
+            self.display.display_file_change_list(hot_files)
 
         # Active branches
         branches = report.get("active_branches", [])
+        current_branch = summary.get("current_branch", "unknown")
         if branches:
-            console.print("\n[bold cyan]🌿 Active Branches[/bold cyan]")
-            for branch in branches:
-                marker = "→" if branch == summary.get("current_branch") else " "
-                console.print(f"  {marker} {branch}")
+            self.display.display_branch_list(branches, current_branch)
 
         # Documentation status
         doc_status = report.get("doc_status", {})
         if doc_status:
-            console.print("\n[bold cyan]📚 CLAUDE.md Status[/bold cyan]")
-            console.print(f"  Size: {doc_status.get('size', 0):,} characters")
-            console.print(f"  Lines: {doc_status.get('lines', 0)}")
-            console.print(
-                f"  Priority markers: {'✓' if doc_status.get('has_priority_markers') else '✗'}"
-            )
-            console.print(
-                f"  Last modified: {doc_status.get('last_modified', 'unknown')}"
-            )
+            doc_metrics = {
+                "Size": f"{doc_status.get('size', 0):,} characters",
+                "Lines": doc_status.get("lines", 0),
+                "Priority markers": (
+                    "✓" if doc_status.get("has_priority_markers") else "✗"
+                ),
+                "Last modified": doc_status.get("last_modified", "unknown"),
+            }
+            self.display.display_metrics_section("📚 CLAUDE.md Status", doc_metrics)
 
         # Recommendations
         recommendations = report.get("recommendations", [])
         if recommendations:
-            console.print("\n[bold cyan]💡 Recommendations[/bold cyan]")
-            for rec in recommendations:
-                console.print(f"  → {rec}")
+            self.display.display_recommendations(recommendations)
 
-        console.print("\n" + "=" * 60 + "\n")
+        self.display.display_separator()
 
     def _append_activity_notes(self, claude_md_path: Path, report: Dict) -> None:
         """Append activity notes to CLAUDE.md."""
@@ -1066,7 +1158,7 @@ The final CLAUDE.md should be a comprehensive, well-organized guide that any AI
         console.print("\n[dim]Run without --dry-run to execute these changes.[/dim]\n")
 
         return {
-            "status": "success",
+            "status": OperationResult.SUCCESS,
             "mode": "dry_run",
             "actions_planned": actions_planned,
             "message": "Dry run completed - no changes made",
@@ -1124,7 +1216,7 @@ The final CLAUDE.md should be a comprehensive, well-organized guide that any AI
             console.print()
 
         return {
-            "status": "success",
+            "status": OperationResult.SUCCESS,
             "checks_passed": checks_passed,
             "warnings": warnings,
         }
@@ -1281,7 +1373,6 @@ preserving valuable project-specific information while refreshing standard secti
         self,
         prompt: str,
         verbose: bool,
-        use_venv: bool = False,
         update_mode: bool = False,
     ) -> Dict:
         """Run the initialization through subprocess calling claude-mpm."""
@@ -1297,7 +1388,7 @@ preserving valuable project-specific information while refreshing standard secti
 
             try:
                 # Build the command
-                cmd = self._build_claude_mpm_command(verbose, use_venv)
+                cmd = self._build_claude_mpm_command(verbose)
                 # Add the input file flag
                 cmd.extend(["-i", prompt_file])
 
@@ -1314,30 +1405,6 @@ preserving valuable project-specific information while refreshing standard secti
                     cwd=str(self.project_path),
                     check=False,
                 )
-
-                # Check for environment-specific errors
-                if "libmamba" in result.stderr or "tree-sitter" in result.stderr:
-                    console.print(
-                        "\n[yellow]⚠️  Environment dependency issue detected.[/yellow]"
-                    )
-                    console.print(
-                        "[yellow]Attempting alternative initialization method...[/yellow]\n"
-                    )
-
-                    # Try again with venv flag to bypass mamba
-                    cmd_venv = self._build_claude_mpm_command(verbose, use_venv=True)
-                    cmd_venv.extend(["-i", prompt_file])
-
-                    if verbose:
-                        console.print(f"[dim]Retrying with: {' '.join(cmd_venv)}[/dim]")
-
-                    result = subprocess.run(
-                        cmd_venv,
-                        capture_output=not verbose,
-                        text=True,
-                        cwd=str(self.project_path),
-                        check=False,
-                    )
             finally:
                 # Clean up temporary file
 
@@ -1353,7 +1420,7 @@ preserving valuable project-specific information while refreshing standard secti
             # Check result - be more lenient with return codes
             if result.returncode == 0 or (self.project_path / "CLAUDE.md").exists():
                 response = {
-                    "status": "success",
+                    "status": OperationResult.SUCCESS,
                     "message": "Project initialized successfully",
                     "files_created": [],
                     "files_updated": [],
@@ -1388,19 +1455,10 @@ preserving valuable project-specific information while refreshing standard secti
                 if result.stderr
                 else result.stdout if result.stdout else "Unknown error occurred"
             )
-            # Clean up mamba warnings from error message
-            if "libmamba" in error_msg:
-                lines = error_msg.split("\n")
-                error_lines = [
-                    line
-                    for line in lines
-                    if not line.startswith("warning") and line.strip()
-                ]
-                error_msg = "\n".join(error_lines) if error_lines else error_msg
 
             logger.error(f"claude-mpm run failed: {error_msg}")
             return {
-                "status": "error",
+                "status": OperationResult.ERROR,
                 "message": f"Initialization failed: {error_msg}",
             }
 
@@ -1409,52 +1467,259 @@ preserving valuable project-specific information while refreshing standard secti
             console.print(
                 "[red]Error: claude-mpm command not found. Ensure Claude MPM is properly installed.[/red]"
             )
-            return {"status": "error", "message": "claude-mpm not found"}
+            return {"status": OperationResult.ERROR, "message": "claude-mpm not found"}
         except Exception as e:
             logger.error(f"Initialization failed: {e}")
-            return {"status": "error", "message": str(e)}
+            return {"status": OperationResult.ERROR, "message": str(e)}
+
+    def handle_context(
+        self,
+        session_id: Optional[str] = None,
+        list_sessions: bool = False,
+        days: int = 7,
+    ) -> Dict[str, Any]:
+        """
+        Provide intelligent context for resuming work based on git history.
+
+        Analyzes recent commits to identify:
+        - Active work streams (what was being worked on)
+        - Intent and motivation (why this work)
+        - Risks and blockers
+        - Recommended next actions
+
+        This delegates to Research agent for deep analysis.
+
+        Args:
+            session_id: Unused parameter (for compatibility)
+            list_sessions: Unused parameter (for compatibility)
+            days: Number of days of git history to analyze (default: 7)
+
+        Returns:
+            Dict containing context result
+        """
+        from claude_mpm.utils.git_analyzer import analyze_recent_activity
+
+        # 1. Analyze git history with adaptive window
+        console.print(f"\n🔍 Analyzing last {days} days of git history...\n")
+        git_analysis = analyze_recent_activity(
+            repo_path=str(self.project_path), days=days, max_commits=50, min_commits=25
+        )
+
+        # Show adaptive behavior to user
+        if git_analysis.get("adaptive_mode"):
+            console.print(
+                f"[cyan]ℹ️  Note: Analyzed {git_analysis.get('actual_time_span', 'extended period')} "
+                f"to get meaningful context[/cyan]"
+            )
+            if git_analysis.get("reason"):
+                console.print(f"[dim]    Reason: {git_analysis['reason']}[/dim]\n")
+            else:
+                console.print()
+
+        if git_analysis.get("error"):
+            console.print(
+                f"[yellow]⚠️  Could not analyze git history: {git_analysis['error']}[/yellow]"
+            )
+            console.print(
+                "[dim]Ensure this is a git repository with commit history.[/dim]\n"
+            )
+            return {
+                "status": OperationResult.ERROR,
+                "message": git_analysis["error"],
+            }
+
+        if not git_analysis.get("has_activity"):
+            console.print(
+                f"[yellow]⚠️  No git activity found in the last {days} days.[/yellow]"
+            )
+            console.print("[dim]Try increasing the --days parameter.[/dim]\n")
+            return {
+                "status": OperationResult.ERROR,
+                "message": f"No git activity in last {days} days",
+            }
+
+        # 2. Build Research delegation prompt
+        research_prompt = self._build_research_context_prompt(git_analysis, days)
+
+        # 3. Display prompt for PM to delegate
+        console.print("\n" + "=" * 80)
+        console.print("📋 DELEGATE TO RESEARCH AGENT:")
+        console.print("=" * 80 + "\n")
+        console.print(research_prompt)
+        console.print("\n" + "=" * 80 + "\n")
+
+        return {
+            "status": OperationResult.CONTEXT_READY,
+            "git_analysis": git_analysis,
+            "research_prompt": research_prompt,
+            "recommendation": "PM should delegate this prompt to Research agent",
+        }
+
+    def _build_research_context_prompt(
+        self, git_analysis: Dict[str, Any], days: int
+    ) -> str:
+        """Build structured Research agent delegation prompt from git analysis."""
+
+        # Extract key data
+        commits = git_analysis.get("commits", [])
+        branches = git_analysis.get("branches", [])
+        contributors = git_analysis.get("contributors", {})
+        file_changes = git_analysis.get("file_changes", {})
+
+        # Build prompt following Prompt Engineer's template
+        prompt = f"""# Project Context Analysis Mission
+
+You are Research agent analyzing git history to provide PM with intelligent project context for resuming work.
+
+## Analysis Scope
+- **Time Range**: Last {days} days"""
+
+        # Add adaptive mode note if applicable
+        if git_analysis.get("adaptive_mode"):
+            actual_days = git_analysis.get("actual_time_span", "extended period")
+            prompt += f""" (adaptive: {actual_days} days analyzed)
+- **Note**: {git_analysis.get('reason', 'Analysis window adjusted to ensure meaningful context')}"""
+
+        prompt += f"""
+- **Commits Analyzed**: {len(commits)} commits
+- **Branches**: {', '.join(branches[:5]) if branches else 'main'}
+- **Contributors**: {', '.join(contributors.keys()) if contributors else 'Unknown'}
+
+## Your Mission
+
+Analyze git history to answer these questions for PM:
+
+1. **What was being worked on?** (Active work streams)
+2. **Why was this work happening?** (Intent and motivation)
+3. **What's the natural next step?** (Continuation recommendations)
+4. **What needs attention?** (Risks, stalls, conflicts)
+
+## Git Data Provided
+
+### Recent Commits ({min(len(commits), 10)} most recent):
+"""
+
+        # Add recent commits
+        for commit in commits[:10]:
+            author = commit.get("author", "Unknown")
+            timestamp = commit.get("timestamp", "Unknown date")
+            message = commit.get("message", "No message")
+            files = commit.get("files", [])
+
+            prompt += f"\n- **{timestamp}** by {author}"
+            prompt += f"\n  {message}"
+            prompt += f"\n  Files changed: {len(files)}\n"
+
+        # Add file change summary
+        if file_changes:
+            # Sort by modifications count
+            sorted_files = sorted(
+                file_changes.items(),
+                key=lambda x: x[1].get("modifications", 0),
+                reverse=True,
+            )
+            prompt += "\n### Most Changed Files:\n"
+            for file_path, file_data in sorted_files[:10]:
+                modifications = file_data.get("modifications", 0)
+                file_contributors = file_data.get("contributors", [])
+                prompt += f"- {file_path}: {modifications} changes ({len(file_contributors)} contributor{'s' if len(file_contributors) != 1 else ''})\n"
+
+        # Add contributor summary
+        if contributors:
+            prompt += "\n### Contributors:\n"
+            sorted_contributors = sorted(
+                contributors.items(),
+                key=lambda x: x[1].get("commits", 0),
+                reverse=True,
+            )
+            for name, info in sorted_contributors[:5]:
+                commit_count = info.get("commits", 0)
+                prompt += f"- {name}: {commit_count} commit{'s' if commit_count != 1 else ''}\n"
+
+        # Add analysis instructions
+        prompt += """
+
+## Analysis Instructions
+
+### Phase 1: Work Stream Identification
+Group related commits into thematic work streams. For each stream:
+- **Name**: Infer from commit messages (e.g., "Authentication refactor")
+- **Status**: ongoing/completed/stalled
+- **Commits**: Count of commits in this stream
+- **Intent**: WHY this work (from commit bodies/messages)
+- **Key Files**: Most changed files in this stream
+
+### Phase 2: Risk Detection
+Identify:
+- **Stalled Work**: Work streams with no activity >3 days
+- **Anti-Patterns**: WIP commits, temp commits, debug commits
+- **Documentation Lag**: Code changes without doc updates
+- **Conflicts**: Merge conflicts or divergent branches
+
+### Phase 3: Recommendations
+Based on analysis:
+1. **Primary Focus**: Most active/recent work to continue
+2. **Quick Wins**: Small tasks that could be finished
+3. **Blockers**: Issues preventing progress
+4. **Next Steps**: Logical continuation points
+
+## Output Format
+
+Provide a clear markdown summary with:
+
+1. **Active Work Streams** (What was being worked on)
+2. **Intent Summary** (Why this work matters)
+3. **Risks Detected** (What needs attention)
+4. **Recommended Next Actions** (What to work on)
+
+Keep it concise (<1000 words) but actionable.
+
+## Success Criteria
+- Work streams accurately reflect development themes
+- Intent captures the "why" not just "what"
+- Recommendations are specific and actionable
+- Risks are prioritized by impact
+"""
+
+        return prompt
 
     def _display_results(self, result: Dict, verbose: bool):
         """Display initialization results."""
-        if result["status"] == "success":
+        if result["status"] == OperationResult.SUCCESS:
             console.print("\n[green]✅ Project Initialization Complete![/green]\n")
 
+            # Display files created
             if result.get("files_created"):
-                console.print("[bold]Files Created:[/bold]")
-                for file in result["files_created"]:
-                    console.print(f"  • {file}")
-                console.print()
+                self.display.display_files_list(
+                    "Files Created:", result["files_created"]
+                )
 
+            # Display files updated
             if result.get("files_updated"):
-                console.print("[bold]Files Updated:[/bold]")
-                for file in result["files_updated"]:
-                    console.print(f"  • {file}")
-                console.print()
+                self.display.display_files_list(
+                    "Files Updated:", result["files_updated"]
+                )
 
+            # Display next steps
             if result.get("next_steps"):
-                console.print("[bold]Next Steps:[/bold]")
-                for step in result["next_steps"]:
-                    console.print(f"  → {step}")
-                console.print()
-
-            console.print(
-                Panel(
-                    "[green]Your project is now optimized for Claude Code and Claude MPM![/green]\n\n"
-                    "Key files:\n"
-                    "• [cyan]CLAUDE.md[/cyan] - Main documentation for AI agents\n"
-                    "  - Organized with priority rankings (🔴🟡🟢⚪)\n"
-                    "  - Instructions ranked by importance for AI understanding\n"
-                    "  - Holistic documentation review completed\n"
-                    "• [cyan].claude-mpm/[/cyan] - Configuration and memories\n"
-                    "• [cyan]CODE_STRUCTURE.md[/cyan] - AST-derived architecture documentation (if enabled)\n\n"
-                    "[dim]Run 'claude-mpm run' to start using the optimized setup[/dim]",
-                    title="Success",
-                    border_style="green",
-                )
+                self.display.display_next_steps(result["next_steps"])
+
+            # Display success panel
+            success_content = (
+                "[green]Your project is now optimized for Claude Code and Claude MPM![/green]\n\n"
+                "Key files:\n"
+                "• [cyan]CLAUDE.md[/cyan] - Main documentation for AI agents\n"
+                "  - Organized with priority rankings (🔴🟡🟢⚪)\n"
+                "  - Instructions ranked by importance for AI understanding\n"
+                "  - Holistic documentation review completed\n"
+                "• [cyan].claude-mpm/[/cyan] - Configuration and memories\n"
+                "• [cyan]CODE_STRUCTURE.md[/cyan] - AST-derived architecture documentation (if enabled)\n\n"
+                "[dim]Run 'claude-mpm run' to start using the optimized setup[/dim]"
             )
+            self.display.display_success_panel("Success", success_content)
 
 
-@click.command(name="mpm-init")
+@click.group(name="mpm-init", invoke_without_command=True)
 @click.option(
     "--project-type",
     type=click.Choice(
@@ -1515,6 +1780,11 @@ preserving valuable project-specific information while refreshing standard secti
     is_flag=True,
     help="Perform lightweight update based on recent git activity (default: 30 days)",
 )
+@click.option(
+    "--catchup",
+    is_flag=True,
+    help="Show recent commit history from all branches for PM context",
+)
 @click.option(
     "--non-interactive",
     is_flag=True,
@@ -1538,7 +1808,9 @@ preserving valuable project-specific information while refreshing standard secti
     required=False,
     default=".",
 )
+@click.pass_context
 def mpm_init(
+    ctx,
     project_type,
     framework,
     force,
@@ -1551,6 +1823,7 @@ def mpm_init(
     verbose,
     ast_analysis,
     quick_update,
+    catchup,
     non_interactive,
     days,
     export,
@@ -1567,18 +1840,27 @@ def mpm_init(
     - Optimize for AI agent understanding
     - Perform AST analysis for enhanced developer documentation
 
+    Context Management:
+    - resume: Analyze git history to provide context for resuming work
+    - --catchup: Show recent commit history for PM context
+
     Update Mode:
     When CLAUDE.md exists, the command offers to update rather than recreate,
     preserving custom content while refreshing standard sections.
 
     Examples:
         claude-mpm mpm-init                           # Initialize/update current directory
+        claude-mpm mpm-init --catchup                 # Show recent git history for context
         claude-mpm mpm-init --review                  # Review project state without changes
         claude-mpm mpm-init --update                  # Force update mode
         claude-mpm mpm-init --organize                # Organize misplaced files
         claude-mpm mpm-init --project-type web        # Initialize as web project
         claude-mpm mpm-init /path/to/project --force  # Force reinitialize project
     """
+    # If a subcommand is being invoked, don't run the main command
+    if ctx.invoked_subcommand is not None:
+        return
+
     try:
         # Create command instance
         command = MPMInitCommand(Path(project_path))
@@ -1596,13 +1878,14 @@ def mpm_init(
             preserve_custom=preserve_custom,
             skip_archive=skip_archive,
             quick_update=quick_update,
+            catchup=catchup,
             non_interactive=non_interactive,
             days=days,
             export=export,
         )
 
         # Exit with appropriate code
-        if result["status"] == "success":
+        if result["status"] == OperationResult.SUCCESS:
             sys.exit(0)
         else:
             sys.exit(1)
@@ -1615,5 +1898,111 @@ def mpm_init(
         sys.exit(1)
 
 
+@mpm_init.command(name="context")
+@click.option(
+    "--session-id",
+    "-i",
+    type=str,
+    help="Unused (for compatibility) - will be removed in future version",
+)
+@click.option(
+    "--days",
+    type=int,
+    default=7,
+    help="Number of days of git history to analyze (default: 7)",
+)
+@click.argument(
+    "project_path",
+    type=click.Path(exists=True, file_okay=False, dir_okay=True),
+    required=False,
+    default=".",
+)
+def context_command(session_id, days, project_path):
+    """
+    Provide intelligent context for resuming work based on git history.
+
+    Analyzes recent git history and generates a Research agent delegation
+    prompt for intelligent project context reconstruction.
+
+    Examples:
+        claude-mpm mpm-init context                  # Analyze last 7 days
+        claude-mpm mpm-init context --days 14        # Analyze last 14 days
+        claude-mpm mpm-init context --days 30        # Analyze last 30 days
+
+    Note: 'resume' is deprecated, use 'context' instead.
+    """
+    try:
+        command = MPMInitCommand(Path(project_path))
+
+        result = command.handle_context(session_id=session_id, days=days)
+
+        if (
+            result["status"] == OperationResult.SUCCESS
+            or result["status"] == OperationResult.CONTEXT_READY
+        ):
+            sys.exit(0)
+        else:
+            sys.exit(1)
+
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Context analysis cancelled by user[/yellow]")
+        sys.exit(130)
+    except Exception as e:
+        console.print(f"[red]Context analysis failed: {e}[/red]")
+        sys.exit(1)
+
+
+# Add deprecated 'resume' alias for backward compatibility
+@mpm_init.command(name="resume", hidden=True)
+@click.option(
+    "--session-id",
+    "-i",
+    type=str,
+    help="Unused (for compatibility) - will be removed in future version",
+)
+@click.option(
+    "--days",
+    type=int,
+    default=7,
+    help="Number of days of git history to analyze (default: 7)",
+)
+@click.argument(
+    "project_path",
+    type=click.Path(exists=True, file_okay=False, dir_okay=True),
+    required=False,
+    default=".",
+)
+def resume_session(session_id, days, project_path):
+    """
+    [DEPRECATED] Use 'context' instead.
+
+    This command is deprecated and will be removed in a future version.
+    Please use 'claude-mpm mpm-init context' instead.
+    """
+    console.print(
+        "[yellow]⚠️  Warning: 'resume' is deprecated. Use 'context' instead.[/yellow]"
+    )
+    console.print("[dim]Run: claude-mpm mpm-init context[/dim]\n")
+
+    try:
+        command = MPMInitCommand(Path(project_path))
+        result = command.handle_context(session_id=session_id, days=days)
+
+        if (
+            result["status"] == OperationResult.SUCCESS
+            or result["status"] == OperationResult.CONTEXT_READY
+        ):
+            sys.exit(0)
+        else:
+            sys.exit(1)
+
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Context analysis cancelled by user[/yellow]")
+        sys.exit(130)
+    except Exception as e:
+        console.print(f"[red]Context analysis failed: {e}[/red]")
+        sys.exit(1)
+
+
 # Export for CLI registration
 __all__ = ["mpm_init"]