claude-mpm 4.7.3__py3-none-any.whl → 4.7.5__py3-none-any.whl

claude_mpm/cli/commands/mpm_init.py

@@ -19,7 +19,6 @@ 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.logging_utils import get_logger
 
@@ -28,6 +27,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 +46,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,
@@ -61,6 +62,10 @@ class MPMInitCommand:
         preserve_custom: bool = True,
         skip_archive: bool = False,
         dry_run: bool = False,
+        quick_update: bool = False,
+        non_interactive: bool = False,
+        days: int = 30,
+        export: Optional[str] = None,
     ) -> Dict:
         """
         Initialize project with Agentic Coder Optimizer standards.
@@ -78,6 +83,10 @@ class MPMInitCommand:
             preserve_custom: Preserve custom sections when updating
             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
+            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)
 
         Returns:
             Dict containing initialization results
@@ -90,6 +99,13 @@ class MPMInitCommand:
             if review_only:
                 return self._run_review_mode()
 
+            if quick_update:
+                return self._run_quick_update_mode(
+                    days=days,
+                    non_interactive=non_interactive,
+                    export=export,
+                )
+
             if has_existing and not force and not update_mode:
                 # Auto-select update mode if organize_files or dry_run is specified
                 if organize_files or dry_run:
@@ -411,34 +427,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."""
@@ -511,29 +500,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', []))}")
@@ -545,32 +531,426 @@ 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', []))}")
+            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"]
+                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,
+                )
+
+        # Recommendations
+        if state.get("recommendations"):
+            self.display.display_recommendations(state["recommendations"])
+
+        self.display.display_separator()
+
+    def _run_quick_update_mode(
+        self,
+        days: int = 30,
+        non_interactive: bool = False,
+        export: Optional[str] = None,
+    ) -> Dict:
+        """Run quick update mode - lightweight update based on recent git activity."""
+        console.print("\n[bold cyan]⚡ Quick Update Mode[/bold cyan]\n")
+        console.print(
+            f"[dim]Analyzing recent git activity ({days} days) for lightweight documentation update...[/dim]\n"
+        )
+
+        if not self.analyzer.is_git_repo:
             console.print(
-                f"  Authors: {git.get('authors', {}).get('total_authors', 0)}"
+                "[yellow]⚠️  Not a git repository. Quick update requires git.[/yellow]"
             )
             console.print(
-                f"  Changed files: {git.get('changed_files', {}).get('total_files', 0)}"
+                "[dim]Tip: Use `/mpm-init --review` for non-git projects.[/dim]\n"
             )
+            return {
+                "status": "error",
+                "message": "Quick update requires a git repository",
+            }
 
-            if git.get("branch_info"):
-                branch_info = git["branch_info"]
-                console.print(
-                    f"  Current branch: {branch_info.get('current_branch', 'unknown')}"
+        claude_md = self.project_path / "CLAUDE.md"
+        if not claude_md.exists():
+            console.print(
+                "[yellow]⚠️  CLAUDE.md not found. Quick update requires existing documentation.[/yellow]"
+            )
+            console.print(
+                "[dim]Tip: Use `/mpm-init` to create initial documentation.[/dim]\n"
+            )
+            return {
+                "status": "error",
+                "message": "Quick update requires existing CLAUDE.md",
+            }
+
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            console=console,
+        ) as progress:
+            # Analyze git history
+            task = progress.add_task(
+                f"[cyan]Analyzing git history ({days} days)...", total=None
+            )
+            git_analysis = self.analyzer.analyze_git_history(days_back=days)
+            progress.update(task, description="[green]✓ Git analysis complete")
+
+            # Analyze current documentation
+            task = progress.add_task(
+                "[cyan]Checking documentation status...", total=None
+            )
+            doc_analysis = self.doc_manager.analyze_existing_content()
+            progress.update(task, description="[green]✓ Documentation analyzed")
+
+        # Generate activity report
+        activity_report = self._generate_activity_report(
+            git_analysis, doc_analysis, days
+        )
+
+        # Display the report
+        self._display_activity_report(activity_report)
+
+        # Export report if requested
+        if export:
+            export_path = self._export_activity_report(activity_report, export)
+            console.print(f"\n[green]✅ Report exported to: {export_path}[/green]")
+
+        # Handle non-interactive mode
+        if non_interactive:
+            console.print(
+                "\n[cyan]ℹ️  Non-interactive mode: Report displayed, no changes made.[/cyan]"
+            )
+            return {
+                "status": "success",
+                "mode": "quick_update",
+                "activity_report": activity_report,
+                "changes_made": False,
+                "non_interactive": True,
+            }
+
+        # Offer to append activity notes to CLAUDE.md
+        console.print("\n[bold]Update Options:[/bold]")
+        console.print("  [1] Append activity summary to CLAUDE.md")
+        console.print("  [2] Display report only (no changes)")
+        console.print("  [3] Cancel")
+
+        from rich.prompt import Prompt
+
+        choice = Prompt.ask("\nSelect option", choices=["1", "2", "3"], default="2")
+
+        if choice == "1":
+            # Append activity notes
+            self._append_activity_notes(claude_md, activity_report)
+            console.print("\n[green]✅ Activity notes appended to CLAUDE.md[/green]")
+
+            # Archive the update
+            self.archive_manager.auto_archive_before_update(
+                claude_md, update_reason="Quick update - recent activity summary"
+            )
+
+            return {
+                "status": "success",
+                "mode": "quick_update",
+                "activity_report": activity_report,
+                "changes_made": True,
+            }
+        if choice == "2":
+            console.print("\n[cyan]Report generated - no changes made[/cyan]")
+            return {
+                "status": "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"}
+
+    def _generate_activity_report(
+        self, git_analysis: Dict, doc_analysis: Dict, days: int = 30
+    ) -> Dict:
+        """Generate activity report from git analysis and documentation status."""
+        from datetime import datetime, timezone
+
+        report = {
+            "period": f"Last {days} days",
+            "generated_at": datetime.now(timezone.utc).isoformat(),
+            "summary": {},
+            "recommendations": [],
+        }
+
+        # Git activity summary
+        if git_analysis.get("git_available"):
+            recent_commits = git_analysis.get("recent_commits", [])
+            changed_files = git_analysis.get("changed_files", {})
+            authors = git_analysis.get("authors", {})
+            branch_info = git_analysis.get("branch_info", {})
+
+            report["summary"] = {
+                "total_commits": len(recent_commits),
+                "total_authors": authors.get("total_authors", 0),
+                "files_changed": changed_files.get("total_files", 0),
+                "current_branch": branch_info.get("current_branch", "unknown"),
+                "has_uncommitted": branch_info.get("has_uncommitted_changes", False),
+                "uncommitted_count": branch_info.get("uncommitted_files", 0),
+            }
+
+            # Recent commits (last 10)
+            report["recent_commits"] = recent_commits[:10]
+
+            # Most changed files
+            most_changed = changed_files.get("most_changed", {})
+            report["hot_files"] = list(most_changed.items())[:10]
+
+            # Active branches
+            branches = branch_info.get("branches", [])
+            report["active_branches"] = [
+                b for b in branches if not b.startswith("remotes/")
+            ][:5]
+
+            # Generate recommendations
+            if len(recent_commits) > 20:
+                report["recommendations"].append(
+                    "High activity detected - consider updating architecture docs"
                 )
-                if branch_info.get("has_uncommitted_changes"):
-                    console.print(
-                        f"  ⚠️  Uncommitted changes: {branch_info.get('uncommitted_files', 0)} files"
-                    )
+
+            if changed_files.get("total_files", 0) > 50:
+                report["recommendations"].append(
+                    "Many files changed - review CLAUDE.md for accuracy"
+                )
+
+            if branch_info.get("has_uncommitted_changes"):
+                report["recommendations"].append(
+                    "Uncommitted changes detected - commit before updating docs"
+                )
+
+            # Check for documentation changes
+            doc_changes = git_analysis.get("documentation_changes", {})
+            if not doc_changes.get("has_recent_doc_changes"):
+                report["recommendations"].append(
+                    "No recent doc updates - CLAUDE.md may be outdated"
+                )
+
+        # Documentation freshness
+        if doc_analysis.get("exists"):
+            report["doc_status"] = {
+                "size": doc_analysis.get("size", 0),
+                "lines": doc_analysis.get("lines", 0),
+                "has_priority_index": doc_analysis.get("has_priority_index", False),
+                "has_priority_markers": doc_analysis.get("has_priority_markers", False),
+                "last_modified": doc_analysis.get("last_modified", "unknown"),
+            }
+
+            if not doc_analysis.get("has_priority_markers"):
+                report["recommendations"].append(
+                    "Add priority markers (🔴🟡🟢⚪) to CLAUDE.md"
+                )
+
+        return report
+
+    def _export_activity_report(self, report: Dict, export_path: str) -> Path:
+        """Export activity report to a markdown file."""
+        from datetime import datetime, timezone
+        from pathlib import Path
+
+        # Determine export path
+        if export_path == "auto":
+            # Generate default path with timestamp
+            timestamp = datetime.now(timezone.utc).strftime("%Y%m%d-%H%M%S")
+            reports_dir = self.project_path / "docs" / "reports"
+            reports_dir.mkdir(parents=True, exist_ok=True)
+            file_path = reports_dir / f"activity-report-{timestamp}.md"
+        else:
+            # Use provided path
+            file_path = Path(export_path)
+            if not file_path.is_absolute():
+                file_path = self.project_path / file_path
+            # Create parent directory if needed
+            file_path.parent.mkdir(parents=True, exist_ok=True)
+
+        # Generate markdown content
+        summary = report.get("summary", {})
+        timestamp = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S")
+
+        content = f"""# Activity Report
+
+**Generated**: {timestamp}
+**Analysis Period**: {report.get('period', 'Last 30 days')}
+
+## Summary
+
+- **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')}
+"""
+
+        if summary.get("has_uncommitted"):
+            content += f"- **⚠️  Uncommitted Changes**: {summary.get('uncommitted_count', 0)} files\n"
+
+        # Recent commits
+        recent_commits = report.get("recent_commits", [])
+        if recent_commits:
+            content += "\n## Recent Commits\n\n"
+            for commit in recent_commits[:10]:
+                content += (
+                    f"- `{commit['hash']}` {commit['message']} - {commit['author']}\n"
+                )
+
+        # Hot files
+        hot_files = report.get("hot_files", [])
+        if hot_files:
+            content += "\n## Most Changed Files\n\n"
+            for hot_file_path, changes in hot_files[:10]:
+                content += f"- `{hot_file_path}`: {changes} changes\n"
+
+        # Active branches
+        branches = report.get("active_branches", [])
+        if branches:
+            content += "\n## Active Branches\n\n"
+            for branch in branches:
+                marker = "→" if branch == summary.get("current_branch") else " "
+                content += f"{marker} {branch}\n"
+
+        # Documentation status
+        doc_status = report.get("doc_status", {})
+        if doc_status:
+            content += "\n## CLAUDE.md Status\n\n"
+            content += f"- **Size**: {doc_status.get('size', 0):,} characters\n"
+            content += f"- **Lines**: {doc_status.get('lines', 0)}\n"
+            content += f"- **Priority Markers**: {'✓' if doc_status.get('has_priority_markers') else '✗'}\n"
+            content += (
+                f"- **Last Modified**: {doc_status.get('last_modified', 'unknown')}\n"
+            )
 
         # Recommendations
-        if state.get("recommendations"):
-            console.print("\n[bold cyan]💡 Recommendations[/bold cyan]")
-            for rec in state["recommendations"][:5]:
-                console.print(f"  → {rec}")
+        recommendations = report.get("recommendations", [])
+        if recommendations:
+            content += "\n## Recommendations\n\n"
+            for rec in recommendations:
+                content += f"- {rec}\n"
+
+        content += (
+            "\n---\n\n*Generated by Claude MPM `/mpm-init --quick-update --export`*\n"
+        )
+
+        # Write to file
+        file_path.write_text(content, encoding="utf-8")
+
+        return file_path
+
+    def _display_activity_report(self, report: Dict) -> None:
+        """Display the activity report in a formatted manner."""
+        self.display.display_header("RECENT ACTIVITY SUMMARY")
+
+        summary = report.get("summary", {})
+        period = report.get("period", "Last 30 days")
+
+        # Summary statistics
+        self.display.display_activity_summary(summary, period)
+
+        # Recent commits
+        recent_commits = report.get("recent_commits", [])
+        if recent_commits:
+            self.display.display_commit_list(recent_commits)
+
+        # Hot files
+        hot_files = report.get("hot_files", [])
+        if hot_files:
+            self.display.display_file_change_list(hot_files)
+
+        # Active branches
+        branches = report.get("active_branches", [])
+        current_branch = summary.get("current_branch", "unknown")
+        if branches:
+            self.display.display_branch_list(branches, current_branch)
+
+        # Documentation status
+        doc_status = report.get("doc_status", {})
+        if doc_status:
+            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:
+            self.display.display_recommendations(recommendations)
+
+        self.display.display_separator()
+
+    def _append_activity_notes(self, claude_md_path: Path, report: Dict) -> None:
+        """Append activity notes to CLAUDE.md."""
+        from datetime import datetime, timezone
+
+        # Generate activity summary section
+        summary = report.get("summary", {})
+        timestamp = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S")
+
+        activity_section = f"""
+
+---
+
+## 📈 Recent Activity Summary
+
+**Last Updated**: {timestamp}
+**Analysis Period**: {report.get('period', 'Last 30 days')}
+
+### Activity Metrics
+- **Commits**: {summary.get('total_commits', 0)}
+- **Contributors**: {summary.get('total_authors', 0)}
+- **Files Changed**: {summary.get('files_changed', 0)}
+- **Current Branch**: {summary.get('current_branch', 'unknown')}
+"""
+
+        if summary.get("has_uncommitted"):
+            activity_section += f"- **⚠️  Uncommitted Changes**: {summary.get('uncommitted_count', 0)} files\n"
+
+        # Add recent commits
+        recent_commits = report.get("recent_commits", [])
+        if recent_commits:
+            activity_section += "\n### Recent Commits\n"
+            for commit in recent_commits[:5]:
+                activity_section += f"- `{commit['hash']}` {commit['message'][:60]} ({commit['author']})\n"
+
+        # Add hot files
+        hot_files = report.get("hot_files", [])
+        if hot_files:
+            activity_section += "\n### Most Active Files\n"
+            for file_path, changes in hot_files[:5]:
+                activity_section += f"- `{file_path}`: {changes} changes\n"
 
-        console.print("\n" + "=" * 60 + "\n")
+        # Add recommendations
+        recommendations = report.get("recommendations", [])
+        if recommendations:
+            activity_section += "\n### 💡 Recommendations\n"
+            for rec in recommendations:
+                activity_section += f"- {rec}\n"
+
+        activity_section += "\n---\n"
+
+        # Append to file
+        with open(claude_md_path, "a", encoding="utf-8") as f:
+            f.write(activity_section)
 
     def _run_dry_run_mode(self, organize_files: bool, has_existing: bool) -> Dict:
         """Run dry-run mode to show what would be done without making changes."""
@@ -991,39 +1371,35 @@ preserving valuable project-specific information while refreshing standard secti
         if result["status"] == "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")
@@ -1082,6 +1458,28 @@ preserving valuable project-specific information while refreshing standard secti
     default=True,
     help="Enable/disable AST analysis for enhanced documentation (default: enabled)",
 )
+@click.option(
+    "--quick-update",
+    is_flag=True,
+    help="Perform lightweight update based on recent git activity (default: 30 days)",
+)
+@click.option(
+    "--non-interactive",
+    is_flag=True,
+    help="Non-interactive mode - display report only without prompting (use with --quick-update)",
+)
+@click.option(
+    "--days",
+    type=int,
+    default=30,
+    help="Number of days for git history analysis in quick update mode (default: 30)",
+)
+@click.option(
+    "--export",
+    type=str,
+    default=None,
+    help="Export activity report to file (default: docs/reports/activity-report-{timestamp}.md)",
+)
 @click.argument(
     "project_path",
     type=click.Path(exists=True, file_okay=False, dir_okay=True),
@@ -1100,6 +1498,10 @@ def mpm_init(
     skip_archive,
     verbose,
     ast_analysis,
+    quick_update,
+    non_interactive,
+    days,
+    export,
     project_path,
 ):
     """
@@ -1141,6 +1543,10 @@ def mpm_init(
             organize_files=organize,
             preserve_custom=preserve_custom,
             skip_archive=skip_archive,
+            quick_update=quick_update,
+            non_interactive=non_interactive,
+            days=days,
+            export=export,
         )
 
         # Exit with appropriate code