claude-mpm 4.10.0__py3-none-any.whl → 4.11.1__py3-none-any.whl

claude_mpm/VERSION

@@ -1 +1 @@
-4.10.0
+4.11.1

claude_mpm/cli/commands/mpm_init.py

@@ -1464,6 +1464,198 @@ preserving valuable project-specific information while refreshing standard secti
             logger.error(f"Initialization failed: {e}")
             return {"status": "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
+        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
+        )
+
+        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": "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": "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": "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
+- **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":
@@ -1500,7 +1692,7 @@ preserving valuable project-specific information while refreshing standard secti
             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(
@@ -1589,7 +1781,9 @@ preserving valuable project-specific information while refreshing standard secti
     required=False,
     default=".",
 )
+@click.pass_context
 def mpm_init(
+    ctx,
     project_type,
     framework,
     force,
@@ -1619,18 +1813,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))
@@ -1668,5 +1871,105 @@ 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"] == "success" or result["status"] == "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"] == "success" or result["status"] == "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"]

claude_mpm/cli/commands/mpm_init_handler.py

@@ -25,6 +25,36 @@ def manage_mpm_init(args):
         # Import the command implementation
         from .mpm_init import MPMInitCommand
 
+        # Handle context subcommands
+        subcommand = getattr(args, "subcommand", None)
+
+        if subcommand in ("context", "resume"):
+            # Show deprecation warning for 'resume'
+            if subcommand == "resume":
+                console.print(
+                    "[yellow]⚠️  Warning: 'resume' is deprecated. Use 'context' instead.[/yellow]"
+                )
+                console.print("[dim]Run: claude-mpm mpm-init context[/dim]\n")
+
+            # Get project path
+            project_path = (
+                Path(args.project_path) if hasattr(args, "project_path") else Path.cwd()
+            )
+
+            # Create command instance
+            command = MPMInitCommand(project_path)
+
+            # Handle context with optional session ID and days
+            result = command.handle_context(
+                session_id=getattr(args, "session_id", None),
+                days=getattr(args, "days", 7),
+            )
+
+            # Return appropriate exit code
+            if result.get("status") in ("success", "context_ready"):
+                return 0
+            return 1
+
         # Handle special flags
         if getattr(args, "list_templates", False):
             # List available templates
@@ -55,7 +85,6 @@ def manage_mpm_init(args):
             "framework": getattr(args, "framework", None),
             "force": getattr(args, "force", False),
             "verbose": getattr(args, "verbose", False),
-            "use_venv": getattr(args, "use_venv", False),
             "ast_analysis": getattr(args, "ast_analysis", True),
             "update_mode": getattr(args, "update", False),
             "review_only": getattr(args, "review", False),

claude_mpm/cli/parsers/mpm_init_parser.py

@@ -31,6 +31,7 @@ def add_mpm_init_subparser(subparsers: Any) -> None:
         epilog=(
             "Examples:\n"
             "  claude-mpm mpm-init                                    # Initialize/update current directory\n"
+            "  claude-mpm mpm-init --catchup                          # Show recent git history for context\n"
             "  claude-mpm mpm-init --review                           # Review project state without changes\n"
             "  claude-mpm mpm-init --update                           # Update existing CLAUDE.md\n"
             "  claude-mpm mpm-init --quick-update                     # Quick update based on recent git activity\n"
@@ -205,5 +206,64 @@ def add_mpm_init_subparser(subparsers: Any) -> None:
         help="Path to project directory (default: current directory)",
     )
 
+    # Add subparsers for context commands
+    subcommands = mpm_init_parser.add_subparsers(
+        dest="subcommand",
+        title="context management",
+        description="Commands for managing project context",
+    )
+
+    # Context subcommand (primary name)
+    context_parser = subcommands.add_parser(
+        "context",
+        help="Provide intelligent context for resuming work",
+        description="Analyze git history to provide context for resuming work",
+        epilog="Note: 'resume' is deprecated, use 'context' instead",
+    )
+    context_parser.add_argument(
+        "--session-id",
+        "-i",
+        type=str,
+        help="Unused (for compatibility) - will be removed in future version",
+    )
+    context_parser.add_argument(
+        "--days",
+        type=int,
+        default=7,
+        help="Number of days of git history to analyze (default: 7)",
+    )
+    context_parser.add_argument(
+        "project_path",
+        nargs="?",
+        default=".",
+        help="Path to project directory (default: current directory)",
+    )
+
+    # Resume subcommand (deprecated alias for backward compatibility)
+    resume_parser = subcommands.add_parser(
+        "resume",
+        help="[DEPRECATED] Use 'context' instead",
+        description="[DEPRECATED] This command is deprecated. Use 'context' instead.\n\n"
+        "Analyze git history to provide context for resuming work",
+    )
+    resume_parser.add_argument(
+        "--session-id",
+        "-i",
+        type=str,
+        help="Unused (for compatibility) - will be removed in future version",
+    )
+    resume_parser.add_argument(
+        "--days",
+        type=int,
+        default=7,
+        help="Number of days of git history to analyze (default: 7)",
+    )
+    resume_parser.add_argument(
+        "project_path",
+        nargs="?",
+        default=".",
+        help="Path to project directory (default: current directory)",
+    )
+
     # Set the command handler
     mpm_init_parser.set_defaults(command="mpm-init")

claude_mpm/commands/mpm-init.md

@@ -7,6 +7,9 @@ Initialize or intelligently update your project for optimal use with Claude Code
 ```
 /mpm-init                      # Auto-detects and offers update or create
 /mpm-init update               # Lightweight update based on recent git activity
+/mpm-init context              # Intelligent context analysis from git history
+/mpm-init context --days 14    # Analyze last 14 days of git history
+/mpm-init catchup              # Quick commit history display (no analysis)
 /mpm-init --review             # Review project state without changes
 /mpm-init --update             # Full update of existing CLAUDE.md
 /mpm-init --organize           # Organize project structure
@@ -17,7 +20,11 @@ Initialize or intelligently update your project for optimal use with Claude Code
 
 ## Description
 
-This command delegates to the Agentic Coder Optimizer agent to establish clear, single-path project standards for documentation, tooling, and workflows.
+This command has two primary modes:
+- **Project initialization/updates**: Delegates to the Agentic Coder Optimizer agent for documentation, tooling, and workflow setup
+- **Context analysis** (context/catchup): Provides intelligent project context from git history for resuming work
+
+**Note**: The `resume` subcommand is deprecated. Use `context` instead. The `resume` command still works for backward compatibility but will be removed in a future version.
 
 **Quick Update Mode**: Running `/mpm-init update` performs a lightweight update focused on recent git activity. It analyzes recent commits, generates an activity report, and updates documentation with minimal changes. Perfect for quick refreshes after development sprints.
 
@@ -54,6 +61,46 @@ This command delegates to the Agentic Coder Optimizer agent to establish clear,
 - `--no-preserve-custom`: Don't preserve custom sections
 - `--skip-archive`: Skip archiving existing files before updating
 
+## Context Analysis
+
+**Purpose**: Provide intelligent project context for resuming work by analyzing git history.
+
+### Commands
+
+#### `/mpm-init context` (Primary)
+```bash
+/mpm-init context                  # Analyze last 7 days of git history
+/mpm-init context --days 14        # Analyze last 14 days
+```
+
+Analyzes recent git commits to identify:
+- **Active work streams**: What was being worked on (themes from commit patterns)
+- **Intent and motivation**: Why this work matters (from commit messages)
+- **Risks and blockers**: What needs attention (stalled work, conflicts, anti-patterns)
+- **Recommended next actions**: What to work on next (logical continuations)
+
+**How it works**:
+1. Parses git history (default: last 7 days)
+2. PM delegates to Research agent with structured prompt
+3. Research analyzes work streams, intent, risks, recommendations
+4. PM presents intelligent summary for seamless work resumption
+
+**NOT session state**: This does NOT save/restore conversation state like Claude Code. Instead, it reconstructs project context from git history using conventional commits and commit message analysis.
+
+#### `/mpm-init resume` [DEPRECATED]
+Alias for `context`. Use `context` instead.
+
+### `/mpm-init catchup` (Simple Git History)
+```bash
+/mpm-init catchup
+```
+
+Quick display of last 25 commits across all branches. No analysis - just raw git log output with authors and dates. Use this for quick "what happened recently?" checks.
+
+**Distinction**:
+- **catchup**: Quick commit history (instant, no analysis)
+- **context**: Intelligent work resumption (10-30s, deep analysis)
+
 ## What This Command Does
 
 ### Auto-Detection (NEW)
@@ -146,22 +193,52 @@ Fast update based on recent 30-day git activity. Generates activity report and u
 
 **Note**: Typing `/mpm-init update` executes `claude-mpm mpm-init --quick-update` automatically.
 
-### Catchup Mode
+### Context Analysis (Intelligent Resumption)
+
+Get intelligent context for resuming work based on git history analysis:
+
+**Standard Context Analysis:**
+```bash
+/mpm-init context              # Analyze last 7 days (default)
+/mpm-init context --days 14    # Analyze last 14 days
+/mpm-init context --days 30    # Analyze last 30 days
+```
+
+This provides intelligent analysis including:
+- **Work stream identification** from commit patterns
+- **Intent analysis** (why work was done)
+- **Risk detection** (stalled work, conflicts, etc.)
+- **Recommended next actions** for seamless continuation
+
+**How it works:**
+1. Parses git history (7 days default)
+2. PM delegates to Research agent with structured prompt
+3. Research agent provides deep analysis
+4. PM presents intelligent summary
 
-Show recent commit history to provide PM with project context:
+**NOT session state**: This reconstructs context from git history, not saved conversation state.
+
+**Backward Compatibility:**
+```bash
+/mpm-init resume               # Still works but deprecated
+```
+
+The old `resume` command redirects to `context` with a deprecation warning.
+
+### Quick Git History (Catchup)
+
+Display recent commit history without analysis:
 
 ```bash
 /mpm-init catchup
 ```
 
-This displays:
+Shows:
 - Last 25 commits from all branches
-- Author attribution (WHO did WHAT)
-- Temporal context (WHEN)
+- Author attribution and timestamps
 - Contributor activity summary
-- PM recommendations based on commit patterns
 
-Useful for understanding recent development activity and getting PM up to speed on project changes.
+Use this for quick "what happened recently?" checks. For intelligent analysis, use `context` instead.
 
 ### Review Project State
 ```bash
@@ -210,6 +287,49 @@ Quick initialization without code analysis.
 
 This command routes between different modes:
 
+### Context Analysis Commands
+
+**IMPORTANT**: Context analysis commands (`/mpm-init context`, `/mpm-init catchup`) have distinct behaviors:
+
+**`/mpm-init context` - Delegates to PM**:
+```bash
+claude-mpm mpm-init context --days 7
+```
+
+This command delegates work to the PM framework:
+1. Parses git history (7 days default)
+2. PM constructs structured Research delegation prompt
+3. PM presents prompt for Research agent to analyze
+4. Research identifies work streams, intent, risks, recommendations
+5. PM synthesizes for user
+
+This is intelligent analysis requiring Research agent expertise.
+
+**How the PM delegates to Research:**
+The PM creates a delegation prompt that asks Research to analyze:
+- **Work Stream Identification**: Groups related commits into themes
+- **Intent Analysis**: Infers why work was done from commit messages
+- **Risk Detection**: Identifies stalled work, conflicts, and blockers
+- **Recommended Actions**: Suggests logical next steps for continuation
+
+**`/mpm-init catchup` - Direct CLI execution**:
+```bash
+claude-mpm mpm-init catchup
+```
+
+This executes directly via CLI without agent delegation:
+- Displays last 25 commits from all branches
+- Shows authors, dates, commit messages
+- Instant output (no analysis)
+
+This is a simple git log display utility.
+
+---
+
+### Project Initialization/Update Commands
+
+**IMPORTANT**: Standard initialization and update commands delegate to the Agentic Coder Optimizer agent.
+
 **Quick Update Mode** (`/mpm-init update`):
 ```bash
 claude-mpm mpm-init --quick-update
@@ -268,12 +388,20 @@ The command delegates to the Agentic Coder Optimizer agent which:
 ## Notes
 
 - **Quick Update vs Full Update**: Use `/mpm-init update` for fast activity-based updates (30 days), or `/mpm-init --update` for comprehensive doc refresh
+- **Context Analysis**: Use `/mpm-init context` to analyze git history and get intelligent resumption context from Research agent
+- **Quick History**: Use `/mpm-init catchup` for instant commit history display without analysis
+- **Deprecation Notice**: The `resume` command is deprecated. Use `context` instead. The old command still works but shows a warning.
 - **Smart Mode**: Automatically detects existing CLAUDE.md and offers update vs recreate
 - **Safe Updates**: Previous versions always archived before updating
 - **Custom Content**: Your project-specific sections are preserved by default
-- **Git Integration**: Analyzes recent commits to understand project evolution
+- **Git Integration**: Analyzes recent commits to understand project evolution and provide work context
+- **Backward Compatibility**: All existing `resume` commands redirect to `context` with deprecation warning
 - **Argument Processing**: The slash command processes the `update` argument and routes to `--quick-update` flag
-- The command uses the Agentic Coder Optimizer agent for implementation
+- **Agent Delegation**:
+  - Project initialization and updates use the Agentic Coder Optimizer agent
+  - Context analysis (`context`) delegates to PM, who coordinates with Research agent
+  - Simple git history (`catchup`) executes directly via CLI without agent delegation
+- **NOT Session State**: Context analysis reconstructs project understanding from git history, not saved conversation state
 - AST analysis is enabled by default for comprehensive documentation
 - Priority rankings help AI agents focus on critical instructions first
 - The holistic review ensures documentation quality and completeness

claude_mpm/storage/state_storage.py

@@ -86,7 +86,7 @@ class StateStorage:
             return True
 
         except Exception as e:
-            self.logger.error(f"Failed to write JSON to {file_path}: {e}")
+            logger.error(f"Failed to write JSON to {file_path}: {e}")
             self.error_count += 1
             return False
 
@@ -106,7 +106,7 @@ class StateStorage:
             file_path = Path(file_path)
 
             if not file_path.exists():
-                self.logger.debug(f"File not found: {file_path}")
+                logger.debug(f"File not found: {file_path}")
                 return None
 
             # Auto-detect compression
@@ -125,7 +125,7 @@ class StateStorage:
             return data
 
         except Exception as e:
-            self.logger.error(f"Failed to read JSON from {file_path}: {e}")
+            logger.error(f"Failed to read JSON from {file_path}: {e}")
             self.error_count += 1
             return None
 
@@ -166,7 +166,7 @@ class StateStorage:
             return True
 
         except Exception as e:
-            self.logger.error(f"Failed to write pickle to {file_path}: {e}")
+            logger.error(f"Failed to write pickle to {file_path}: {e}")
             self.error_count += 1
             return False
 
@@ -186,7 +186,7 @@ class StateStorage:
             file_path = Path(file_path)
 
             if not file_path.exists():
-                self.logger.debug(f"File not found: {file_path}")
+                logger.debug(f"File not found: {file_path}")
                 return None
 
             # Auto-detect compression
@@ -205,7 +205,7 @@ class StateStorage:
             return data
 
         except Exception as e:
-            self.logger.error(f"Failed to read pickle from {file_path}: {e}")
+            logger.error(f"Failed to read pickle from {file_path}: {e}")
             self.error_count += 1
             return None
 
@@ -262,7 +262,7 @@ class StateStorage:
                 Path(temp_path).replace(file_path)
 
                 self.write_count += 1
-                self.logger.debug(f"Atomic write successful: {file_path}")
+                logger.debug(f"Atomic write successful: {file_path}")
                 return True
 
             finally:
@@ -271,7 +271,7 @@ class StateStorage:
                     Path(temp_path).unlink()
 
         except Exception as e:
-            self.logger.error(f"Atomic write failed for {file_path}: {e}")
+            logger.error(f"Atomic write failed for {file_path}: {e}")
             self.error_count += 1
             return False
 
@@ -339,7 +339,7 @@ class StateStorage:
                 f.write(checksum)
 
         except Exception as e:
-            self.logger.warning(f"Could not add checksum: {e}")
+            logger.warning(f"Could not add checksum: {e}")
 
     def verify_checksum(self, file_path: Union[str, Path]) -> bool:
         """Verify file checksum for integrity.
@@ -370,13 +370,13 @@ class StateStorage:
             actual = hasher.hexdigest()
 
             if actual != expected:
-                self.logger.error(f"Checksum mismatch for {file_path}")
+                logger.error(f"Checksum mismatch for {file_path}")
                 return False
 
             return True
 
         except Exception as e:
-            self.logger.warning(f"Could not verify checksum: {e}")
+            logger.warning(f"Could not verify checksum: {e}")
             return True  # Assume valid if can't verify
 
     def cleanup_temp_files(self) -> int:
@@ -396,7 +396,7 @@ class StateStorage:
                     if age > 3600:
                         temp_file.unlink()
                         cleaned += 1
-                        self.logger.debug(f"Cleaned up temp file: {temp_file}")
+                        logger.debug(f"Cleaned up temp file: {temp_file}")
                 except Exception:
                     pass
 
@@ -408,12 +408,12 @@ class StateStorage:
                     cleaned += 1
 
             if cleaned > 0:
-                self.logger.info(f"Cleaned up {cleaned} temporary files")
+                logger.info(f"Cleaned up {cleaned} temporary files")
 
             return cleaned
 
         except Exception as e:
-            self.logger.error(f"Error cleaning up temp files: {e}")
+            logger.error(f"Error cleaning up temp files: {e}")
             return 0
 
     def get_storage_info(self) -> Dict[str, Any]:
@@ -447,7 +447,7 @@ class StateStorage:
             }
 
         except Exception as e:
-            self.logger.error(f"Error getting storage info: {e}")
+            logger.error(f"Error getting storage info: {e}")
             return {"storage_directory": str(self.storage_dir), "error": str(e)}
 
 

claude_mpm/utils/git_analyzer.py

@@ -0,0 +1,305 @@
+"""
+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
+) -> Dict[str, Any]:
+    """
+    Analyze recent git activity for context reconstruction.
+
+    This function analyzes git history to provide comprehensive context about
+    recent project activity including commits, contributors, file changes,
+    and branch activity.
+
+    Args:
+        repo_path: Path to the git repository (default: current directory)
+        days: Number of days to look back (default: 7)
+        max_commits: Maximum number of commits to analyze (default: 50)
+
+    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
+        - 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,
+    }
+
+    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))
+
+        # Get recent commits from all branches
+        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
+
+        # 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

{claude_mpm-4.10.0.dist-info → claude_mpm-4.11.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-mpm
-Version: 4.10.0
+Version: 4.11.1
 Summary: Claude Multi-Agent Project Manager - Orchestrate Claude with agent delegation and ticket tracking
 Author-email: Bob Matsuoka <bob@matsuoka.com>
 Maintainer: Claude MPM Team

{claude_mpm-4.10.0.dist-info → claude_mpm-4.11.1.dist-info}/RECORD

@@ -1,5 +1,5 @@
 claude_mpm/BUILD_NUMBER,sha256=9JfxhnDtr-8l3kCP2U5TVXSErptHoga8m7XA8zqgGOc,4
-claude_mpm/VERSION,sha256=9StPgaDGDNmI-MzJoDM-IGtffkHdD1KGxqtfe_LVM18,7
+claude_mpm/VERSION,sha256=-pg3IRz2ArU7tcZ-4AUcxOirJEkowIcnQL1C8A2FelI,7
 claude_mpm/__init__.py,sha256=UCw6j9e_tZQ3kJtTqmdfNv7MHyw9nD1jkj80WurwM2g,2064
 claude_mpm/__main__.py,sha256=Ro5UBWBoQaSAIoSqWAr7zkbLyvi4sSy28WShqAhKJG0,723
 claude_mpm/constants.py,sha256=sLjJF6Kw7H4V9WWeaEYltM-77TgXqzEMX5vx4ukM5-0,5977
@@ -100,8 +100,8 @@ claude_mpm/cli/commands/mcp_setup_external.py,sha256=hfBHkaioNa0JRDhahNEc8agyrUw
 claude_mpm/cli/commands/mcp_tool_commands.py,sha256=q17GzlFT3JiLTrDqwPO2tz1-fKmPO5QU449syTnKTz4,1283
 claude_mpm/cli/commands/memory.py,sha256=O4T5HGL-Ob_QPt2dZHQvoOrVohnaDKrBjyngq1Mcv1w,26185
 claude_mpm/cli/commands/monitor.py,sha256=Fjb68hf3dEwTFek2LV8Nh6iU0qEkY7qYlOn32IwNaNg,9566
-claude_mpm/cli/commands/mpm_init.py,sha256=OtdJMsFn7E9Ck56wWPrCvqw6j5dsN_VI098C3bteitc,63888
-claude_mpm/cli/commands/mpm_init_handler.py,sha256=b1CSwZYJ89wMorKzPOKS-RVxOKR2kT9yv9KQLvKkd2U,3532
+claude_mpm/cli/commands/mpm_init.py,sha256=oNEF_hwpu7LCvj06vqXbmVJpXm7yo4ebODyQcZN52nM,74346
+claude_mpm/cli/commands/mpm_init_handler.py,sha256=FZRoo_zfEakLc_W1G_ej_bhxtaU6ybngyBP5GLxaKD4,4583
 claude_mpm/cli/commands/run.py,sha256=PB2H55piOPTy4yo4OBgbUCjMlcz9K79wbwpxQVc9m5Q,48225
 claude_mpm/cli/commands/search.py,sha256=alv6udvKcn-xkqeBlLuPRvfSDV1yxEX4n9mjjRT5uLM,16581
 claude_mpm/cli/commands/tickets.py,sha256=kl2dklTBnG3Y4jUUJ_PcEVsTx4CtVJfkGWboWBx_mQM,21234
@@ -123,7 +123,7 @@ claude_mpm/cli/parsers/debug_parser.py,sha256=F7MZdmiXiPfiIPMv21ZUqB2cMT8Ho1LDmp
 claude_mpm/cli/parsers/mcp_parser.py,sha256=2j6ULhdu55Z2k_-Gu2QxIsFoTQFbDCEMSGePXSuPoQQ,6532
 claude_mpm/cli/parsers/memory_parser.py,sha256=ZwCDxJEgp-w03L-1tZsWTgisiwamP42s424bA5bvDJc,4760
 claude_mpm/cli/parsers/monitor_parser.py,sha256=PeoznSi_5Bw6THK_Espl8M20o6dKvvBSmFzAbovkaFQ,4920
-claude_mpm/cli/parsers/mpm_init_parser.py,sha256=aGMwrHs7acB61sNDI0M7gf23yGDV4Q7b7iX7XnWC0yQ,7658
+claude_mpm/cli/parsers/mpm_init_parser.py,sha256=EVyHc7KYpsyxhomZAUnlGS6kq43ix2wjrHLiM5Gf34E,9684
 claude_mpm/cli/parsers/run_parser.py,sha256=cs34qNonFZG8uYxTYEt0rXi2LcPz3pw8D8hxiywih6w,4927
 claude_mpm/cli/parsers/search_parser.py,sha256=L8-65kndg-zutSKpzj-eCvTNkeySCZ-WlSHdhk7pEak,6916
 claude_mpm/cli/parsers/tickets_parser.py,sha256=FYl-VNH7PrZzfZUCcjnf6F7g6JXnL8YDxwrmR5svIcg,6966
@@ -141,7 +141,7 @@ claude_mpm/commands/mpm-agents.md,sha256=JnYPJ-eWvIEEtiCB6iPu182P2xDBRvU3ArVXQ7h
 claude_mpm/commands/mpm-config.md,sha256=79Eb-srRpEVV3HCHDHZc8SKec6_LVP6HbXDEVkZKLgw,2929
 claude_mpm/commands/mpm-doctor.md,sha256=ut5LhFKVRw-2ecjMSPsnaTiRuFXa6Q9t-Wgl3CCnQvk,590
 claude_mpm/commands/mpm-help.md,sha256=zfhpE0Fd-wW5zWmYYAMRMT-xYK8saqbw-HXRD7csJHI,2850
-claude_mpm/commands/mpm-init.md,sha256=5Jqb99qqJ_hQ_41lGmyTyDUhm7V7wQiLCYvksd3tZEo,10696
+claude_mpm/commands/mpm-init.md,sha256=wwYHkToq8U5ALdhu8bDPygqAsKZ77aMaai7ZJC3oBqU,16054
 claude_mpm/commands/mpm-monitor.md,sha256=onTHf9Yac1KkdZdENtY2Q5jyw0A-vZLYgoKkPCtZLUY,12193
 claude_mpm/commands/mpm-organize.md,sha256=T-ysjhwgfW9irjUj02vuY_1jeMdabO_zxcShyjmqsiM,10153
 claude_mpm/commands/mpm-status.md,sha256=oaM4ybL4ffp55nkT9F0mp_5H4tF-wX9mbqK-LEKEqUU,1919
@@ -766,7 +766,7 @@ claude_mpm/services/version_control/version_parser.py,sha256=DbNncYZKKy9--ZUCO9g
 claude_mpm/services/visualization/__init__.py,sha256=cTtWxRi07rSLXQKVZa7SKZsYfj6nRouw7HVO85Towfg,401
 claude_mpm/services/visualization/mermaid_generator.py,sha256=6QGgXtMg_N9rKeRn8wYs3IxuWGKdDVAwFMFWKfIw9s4,34277
 claude_mpm/storage/__init__.py,sha256=DXnmee6iGqC6ctFLW7_Ty1cVCjYDFuCMkwO4EV0i25k,274
-claude_mpm/storage/state_storage.py,sha256=YCkqifFbv-lm6zzb53WOoArKJDVsLlSgvAM3FoRwhz8,16886
+claude_mpm/storage/state_storage.py,sha256=6jEZ4z35MjtAuTTUdqETTy4_dbMMK8EN_C2kVa62PjY,16811
 claude_mpm/tools/__init__.py,sha256=T3GuCYNAHtjVcKCeivY674PaDm48WX96AriQfTKUknY,347
 claude_mpm/tools/__main__.py,sha256=MtpJoWA2HEmRE_XDsSjjto6DND7Ft0MZoiY4ivNHh5A,5714
 claude_mpm/tools/code_tree_analyzer.py,sha256=BBkEuSVHd_P1jBlxpBfzsLqUyT01rid3r2_cQCBeGyQ,64818
@@ -787,6 +787,7 @@ claude_mpm/utils/environment_context.py,sha256=mCnRJqQLTyaAv-7M4bp9N9WqVgfSQb5xb
 claude_mpm/utils/error_handler.py,sha256=RWL7DnXttJKCgYhevUm9XlMC33rEhX2CXo1IiCtwV4g,7969
 claude_mpm/utils/file_utils.py,sha256=pv3MEKLsn4WIOra5JoHnCm_FaJbNcKMuS3EKuXAWyLc,7859
 claude_mpm/utils/framework_detection.py,sha256=dCY-N0HzuYS9KBg1BjDw8mJnNb22JqmKBoodjTMzd5w,1183
+claude_mpm/utils/git_analyzer.py,sha256=JZwahnhgPXsITRnq7jJBNK4or82bZjazQI-VGyXocP4,9323
 claude_mpm/utils/import_migration_example.py,sha256=sKlV-apfkHDJzzez6uubHXjx91YF_5HPuzu2sLs_U0E,989
 claude_mpm/utils/imports.py,sha256=IGcW0W6V-2jTmkVlO-l0Zodo3LRA3zkaumD9J2qn7dE,6654
 claude_mpm/utils/log_cleanup.py,sha256=1d8K1V2uOFPGJJKFOk6E_AMj22sifAibOg-VQyGooWo,22301
@@ -797,9 +798,9 @@ claude_mpm/utils/subprocess_utils.py,sha256=D0izRT8anjiUb_JG72zlJR_JAw1cDkb7kalN
 claude_mpm/validation/__init__.py,sha256=YZhwE3mhit-lslvRLuwfX82xJ_k4haZeKmh4IWaVwtk,156
 claude_mpm/validation/agent_validator.py,sha256=GprtAvu80VyMXcKGsK_VhYiXWA6BjKHv7O6HKx0AB9w,20917
 claude_mpm/validation/frontmatter_validator.py,sha256=YpJlYNNYcV8u6hIOi3_jaRsDnzhbcQpjCBE6eyBKaFY,7076
-claude_mpm-4.10.0.dist-info/licenses/LICENSE,sha256=lpaivOlPuBZW1ds05uQLJJswy8Rp_HMNieJEbFlqvLk,1072
-claude_mpm-4.10.0.dist-info/METADATA,sha256=k0Zv4w5f9JRyt9zBPKr0C1Np9CetMfRascM9u-26Tgo,17967
-claude_mpm-4.10.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-claude_mpm-4.10.0.dist-info/entry_points.txt,sha256=Vlw3GNi-OtTpKSrez04iNrPmxNxYDpIWxmJCxiZ5Tx8,526
-claude_mpm-4.10.0.dist-info/top_level.txt,sha256=1nUg3FEaBySgm8t-s54jK5zoPnu3_eY6EP6IOlekyHA,11
-claude_mpm-4.10.0.dist-info/RECORD,,
+claude_mpm-4.11.1.dist-info/licenses/LICENSE,sha256=lpaivOlPuBZW1ds05uQLJJswy8Rp_HMNieJEbFlqvLk,1072
+claude_mpm-4.11.1.dist-info/METADATA,sha256=Wgt4BuOeYfVIUCmhtlUQwLKtCF4RAC_AEnw1W0_5pmI,17967
+claude_mpm-4.11.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+claude_mpm-4.11.1.dist-info/entry_points.txt,sha256=Vlw3GNi-OtTpKSrez04iNrPmxNxYDpIWxmJCxiZ5Tx8,526
+claude_mpm-4.11.1.dist-info/top_level.txt,sha256=1nUg3FEaBySgm8t-s54jK5zoPnu3_eY6EP6IOlekyHA,11
+claude_mpm-4.11.1.dist-info/RECORD,,