claude-mpm 4.9.0__py3-none-any.whl → 4.11.0__py3-none-any.whl

claude_mpm/cli/commands/search.py

@@ -16,8 +16,7 @@ from rich.panel import Panel
 from rich.syntax import Syntax
 from rich.table import Table
 
-from claude_mpm.cli.utils import handle_async_errors
-from claude_mpm.services.service_container import get_service_container
+from claude_mpm.services.core.service_container import get_global_container
 
 console = Console()
 
@@ -27,8 +26,9 @@ class MCPSearchInterface:
 
     def __init__(self):
         """Initialize the search interface."""
-        self.container = get_service_container()
+        self.container = get_global_container()
         self.mcp_gateway = None
+        self.vector_search_available = False
 
     async def initialize(self):
         """Initialize the MCP gateway connection."""
@@ -39,10 +39,127 @@ class MCPSearchInterface:
             if not self.mcp_gateway:
                 self.mcp_gateway = MCPGatewayService()
                 await self.mcp_gateway.initialize()
+
+            # Check if vector search is available
+            self.vector_search_available = await self._check_vector_search_available()
+
         except Exception as e:
             console.print(f"[red]Failed to initialize MCP gateway: {e}[/red]")
             raise
 
+    async def _check_vector_search_available(self) -> bool:
+        """Check if mcp-vector-search is available and offer installation if not."""
+        import importlib.util
+
+        # Check if package is installed
+        spec = importlib.util.find_spec("mcp_vector_search")
+        if spec is not None:
+            return True
+
+        # Package not found - offer installation
+        console.print("\n[yellow]⚠️  mcp-vector-search not found[/yellow]")
+        console.print("This package enables semantic code search (optional feature).")
+        console.print("\nInstallation options:")
+        console.print("  1. Install via pip (recommended for this project)")
+        console.print("  2. Install via pipx (isolated, system-wide)")
+        console.print("  3. Skip (use traditional grep/glob instead)")
+
+        try:
+            choice = input("\nChoose option (1/2/3) [3]: ").strip() or "3"
+
+            if choice == "1":
+                return await self._install_via_pip()
+            if choice == "2":
+                return await self._install_via_pipx()
+            console.print(
+                "[dim]Continuing with fallback search methods (grep/glob)[/dim]"
+            )
+            return False
+
+        except (EOFError, KeyboardInterrupt):
+            console.print("\n[dim]Installation cancelled, using fallback methods[/dim]")
+            return False
+
+    async def _install_via_pip(self) -> bool:
+        """Install mcp-vector-search via pip."""
+        import subprocess
+
+        try:
+            console.print("\n[cyan]📦 Installing mcp-vector-search via pip...[/cyan]")
+            result = subprocess.run(
+                [sys.executable, "-m", "pip", "install", "mcp-vector-search"],
+                capture_output=True,
+                text=True,
+                timeout=120,
+                check=False,
+            )
+
+            if result.returncode == 0:
+                console.print(
+                    "[green]✓ Successfully installed mcp-vector-search[/green]"
+                )
+                return True
+
+            error_msg = result.stderr.strip() if result.stderr else "Unknown error"
+            console.print(f"[red]✗ Installation failed: {error_msg}[/red]")
+            return False
+
+        except subprocess.TimeoutExpired:
+            console.print("[red]✗ Installation timed out[/red]")
+            return False
+        except Exception as e:
+            console.print(f"[red]✗ Installation error: {e}[/red]")
+            return False
+
+    async def _install_via_pipx(self) -> bool:
+        """Install mcp-vector-search via pipx."""
+        import subprocess
+
+        try:
+            # Check if pipx is available
+            pipx_check = subprocess.run(
+                ["pipx", "--version"],
+                capture_output=True,
+                text=True,
+                timeout=5,
+                check=False,
+            )
+
+            if pipx_check.returncode != 0:
+                console.print("[red]✗ pipx is not installed[/red]")
+                console.print("Install pipx first: python -m pip install pipx")
+                return False
+
+            console.print("\n[cyan]📦 Installing mcp-vector-search via pipx...[/cyan]")
+            result = subprocess.run(
+                ["pipx", "install", "mcp-vector-search"],
+                capture_output=True,
+                text=True,
+                timeout=120,
+                check=False,
+            )
+
+            if result.returncode == 0:
+                console.print(
+                    "[green]✓ Successfully installed mcp-vector-search[/green]"
+                )
+                return True
+
+            error_msg = result.stderr.strip() if result.stderr else "Unknown error"
+            console.print(f"[red]✗ Installation failed: {error_msg}[/red]")
+            return False
+
+        except FileNotFoundError:
+            console.print("[red]✗ pipx command not found[/red]")
+            console.print("Install pipx first: python -m pip install pipx")
+            return False
+        except subprocess.TimeoutExpired:
+            console.print("[red]✗ Installation timed out[/red]")
+            return False
+        except Exception as e:
+            console.print(f"[red]✗ Installation error: {e}[/red]")
+            return False
+
     async def search_code(
         self,
         query: str,
@@ -125,6 +242,12 @@ class MCPSearchInterface:
         if not self.mcp_gateway:
             await self.initialize()
 
+        # Check if vector search is available
+        if not self.vector_search_available:
+            return {
+                "error": "mcp-vector-search is not available. Use traditional grep/glob tools instead, or run command again to install."
+            }
+
         try:
             return await self.mcp_gateway.call_tool(tool_name, params)
         except Exception as e:
@@ -196,7 +319,6 @@ def display_search_results(results: Dict[str, Any], output_format: str = "rich")
 @click.option("--focus", multiple=True, help="Focus areas (with --context)")
 @click.option("--force", is_flag=True, help="Force reindexing (with --index)")
 @click.option("--json", "output_json", is_flag=True, help="Output results as JSON")
-@handle_async_errors
 async def search_command(
     query: Optional[str],
     similar: Optional[str],
@@ -228,8 +350,24 @@ async def search_command(
     output_format = "json" if output_json else "rich"
 
     try:
+        # Show first-time usage tips if vector search is available
+        if search.vector_search_available and not (index or status):
+            console.print(
+                "\n[dim]💡 Tip: Vector search provides semantic code understanding.[/dim]"
+            )
+            console.print(
+                "[dim]   Run with --index first to index your project.[/dim]\n"
+            )
+
         # Handle different operation modes
         if index:
+            if not search.vector_search_available:
+                console.print("[red]✗ mcp-vector-search is required for indexing[/red]")
+                console.print(
+                    "[dim]Install it or use traditional grep/glob for search[/dim]"
+                )
+                sys.exit(1)
+
             console.print("[cyan]Indexing project...[/cyan]")
             result = await search.index_project(
                 force=force, file_extensions=list(extensions) if extensions else None
@@ -239,10 +377,23 @@ async def search_command(
             display_search_results(result, output_format)
 
         elif status:
+            if not search.vector_search_available:
+                console.print(
+                    "[red]✗ mcp-vector-search is required for status check[/red]"
+                )
+                console.print("[dim]Install it to use vector search features[/dim]")
+                sys.exit(1)
+
             result = await search.get_status()
             display_search_results(result, output_format)
 
         elif similar:
+            if not search.vector_search_available:
+                console.print("[yellow]⚠️  Vector search not available[/yellow]")
+                console.print("[dim]Similarity search requires mcp-vector-search[/dim]")
+                console.print("[dim]Falling back to basic file search...[/dim]")
+                sys.exit(1)
+
             result = await search.search_similar(
                 file_path=similar,
                 function_name=function,
@@ -252,6 +403,12 @@ async def search_command(
             display_search_results(result, output_format)
 
         elif context:
+            if not search.vector_search_available:
+                console.print("[yellow]⚠️  Vector search not available[/yellow]")
+                console.print("[dim]Context search requires mcp-vector-search[/dim]")
+                console.print("[dim]Try using grep for text-based search instead[/dim]")
+                sys.exit(1)
+
             result = await search.search_context(
                 description=context,
                 focus_areas=list(focus) if focus else None,
@@ -260,6 +417,15 @@ async def search_command(
             display_search_results(result, output_format)
 
         elif query:
+            if not search.vector_search_available:
+                console.print("[yellow]⚠️  Vector search not available[/yellow]")
+                console.print("[dim]Code search requires mcp-vector-search[/dim]")
+                console.print(
+                    "\n[cyan]Alternative: Use grep for pattern matching:[/cyan]"
+                )
+                console.print(f"  grep -r '{query}' .")
+                sys.exit(1)
+
             result = await search.search_code(
                 query=query,
                 limit=limit,

claude_mpm/cli/commands/session_pause_manager.py

@@ -0,0 +1,389 @@
+"""
+Session Pause Manager - Captures and saves session state for later resumption.
+
+This module provides functionality to pause a Claude MPM session by capturing:
+- Conversation context and progress
+- Git repository state
+- Todo list status
+- Working directory changes
+
+The saved state enables seamless session resumption with full context.
+"""
+
+import subprocess
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from rich.console import Console
+from rich.panel import Panel
+
+from claude_mpm.core.logging_utils import get_logger
+from claude_mpm.storage.state_storage import StateStorage
+
+logger = get_logger(__name__)
+console = Console()
+
+
+class SessionPauseManager:
+    """Manages pausing and saving session state."""
+
+    def __init__(self, project_path: Path):
+        """Initialize Session Pause Manager.
+
+        Args:
+            project_path: Path to the project directory
+        """
+        self.project_path = project_path
+        self.session_dir = project_path / ".claude-mpm" / "sessions" / "pause"
+        self.storage = StateStorage()
+
+    def pause_session(
+        self,
+        conversation_summary: Optional[str] = None,
+        accomplishments: Optional[List[str]] = None,
+        next_steps: Optional[List[str]] = None,
+        todos_active: Optional[List[Dict[str, str]]] = None,
+        todos_completed: Optional[List[Dict[str, str]]] = None,
+    ) -> Dict[str, Any]:
+        """Pause the current session and save state.
+
+        Args:
+            conversation_summary: Summary of what was being worked on
+            accomplishments: List of things accomplished in this session
+            next_steps: List of next steps to continue work
+            todos_active: Active todo items
+            todos_completed: Completed todo items
+
+        Returns:
+            Dict containing pause result with session_file path
+        """
+        try:
+            # Ensure session directory exists
+            self.session_dir.mkdir(parents=True, exist_ok=True)
+
+            # Generate session ID
+            timestamp = datetime.now(timezone.utc)
+            session_id = f"session-{timestamp.strftime('%Y%m%d-%H%M%S')}"
+
+            # Capture git context
+            git_context = self._capture_git_context()
+
+            # Build session state
+            session_state = {
+                "session_id": session_id,
+                "paused_at": timestamp.isoformat(),
+                "conversation": {
+                    "summary": conversation_summary
+                    or "Session paused - context not provided",
+                    "accomplishments": accomplishments or [],
+                    "next_steps": next_steps or [],
+                },
+                "git_context": git_context,
+                "todos": {
+                    "active": todos_active or [],
+                    "completed": todos_completed or [],
+                },
+                "version": self._get_version(),
+                "build": self._get_build_number(),
+                "project_path": str(self.project_path),
+            }
+
+            # Save session state to file
+            session_file = self.session_dir / f"{session_id}.json"
+            success = self.storage.write_json(
+                session_state, session_file, atomic=True, compress=False
+            )
+
+            if not success:
+                return {
+                    "status": "error",
+                    "message": "Failed to write session state file",
+                }
+
+            # Create git commit with session state
+            commit_success = self._create_pause_commit(session_id, conversation_summary)
+
+            # Display success message
+            self._display_pause_success(session_id, session_file, commit_success)
+
+            return {
+                "status": "success",
+                "session_id": session_id,
+                "session_file": str(session_file),
+                "git_commit_created": commit_success,
+                "message": f"Session paused: {session_id}",
+            }
+
+        except Exception as e:
+            logger.error(f"Failed to pause session: {e}")
+            return {"status": "error", "message": str(e)}
+
+    def _capture_git_context(self) -> Dict[str, Any]:
+        """Capture current git repository state.
+
+        Returns:
+            Dict containing git context information
+        """
+        git_context: Dict[str, Any] = {
+            "is_git_repo": False,
+            "branch": None,
+            "recent_commits": [],
+            "status": {"clean": True, "modified_files": [], "untracked_files": []},
+        }
+
+        try:
+            # Check if git repo
+            result = subprocess.run(
+                ["git", "rev-parse", "--git-dir"],
+                cwd=str(self.project_path),
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+
+            if result.returncode != 0:
+                return git_context
+
+            git_context["is_git_repo"] = True
+
+            # Get current branch
+            result = subprocess.run(
+                ["git", "branch", "--show-current"],
+                cwd=str(self.project_path),
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+            git_context["branch"] = result.stdout.strip()
+
+            # Get recent commits (last 10)
+            result = subprocess.run(
+                ["git", "log", "--format=%h|%an|%ai|%s", "-10"],
+                cwd=str(self.project_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_str, message = parts
+                    commits.append(
+                        {
+                            "sha": sha,
+                            "author": author,
+                            "timestamp": timestamp_str,
+                            "message": message,
+                        }
+                    )
+            git_context["recent_commits"] = commits
+
+            # Get status
+            result = subprocess.run(
+                ["git", "status", "--porcelain"],
+                cwd=str(self.project_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)
+
+            git_context["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 capture git context: {e}")
+
+        return git_context
+
+    def _get_version(self) -> str:
+        """Get Claude MPM version.
+
+        Returns:
+            Version string or "unknown"
+        """
+        try:
+            version_file = Path(__file__).parent.parent.parent.parent.parent / "VERSION"
+            if version_file.exists():
+                return version_file.read_text().strip()
+        except Exception:
+            pass
+        return "unknown"
+
+    def _get_build_number(self) -> str:
+        """Get Claude MPM build number.
+
+        Returns:
+            Build number string or "unknown"
+        """
+        try:
+            build_file = (
+                Path(__file__).parent.parent.parent.parent.parent / "BUILD_NUMBER"
+            )
+            if build_file.exists():
+                return build_file.read_text().strip()
+        except Exception:
+            pass
+        return "unknown"
+
+    def _create_pause_commit(self, session_id: str, summary: Optional[str]) -> bool:
+        """Create git commit with session pause information.
+
+        Args:
+            session_id: The session identifier
+            summary: Optional summary of what was being worked on
+
+        Returns:
+            True if commit was created successfully
+        """
+        try:
+            # Check if we're in a git repo
+            result = subprocess.run(
+                ["git", "rev-parse", "--git-dir"],
+                cwd=str(self.project_path),
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+
+            if result.returncode != 0:
+                logger.debug("Not a git repository, skipping commit")
+                return False
+
+            # Add session files to git
+            subprocess.run(
+                ["git", "add", ".claude-mpm/sessions/pause/"],
+                cwd=str(self.project_path),
+                capture_output=True,
+                check=False,
+            )
+
+            # Check if there are changes to commit
+            result = subprocess.run(
+                ["git", "diff", "--cached", "--quiet"],
+                cwd=str(self.project_path),
+                check=False,
+            )
+
+            if result.returncode == 0:
+                logger.debug("No changes to commit")
+                return False
+
+            # Build commit message
+            timestamp = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S UTC")
+            context = summary or "Session paused"
+
+            commit_message = f"""session: pause at {timestamp}
+
+Session ID: {session_id}
+Context: {context}
+
+🤖👥 Generated with [Claude MPM](https://github.com/bobmatnyc/claude-mpm)
+
+Co-Authored-By: Claude <noreply@anthropic.com>"""
+
+            # Create commit
+            result = subprocess.run(
+                ["git", "commit", "-m", commit_message],
+                cwd=str(self.project_path),
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+
+            if result.returncode == 0:
+                logger.info(f"Created pause commit for session {session_id}")
+                return True
+            logger.warning(f"Could not create commit: {result.stderr}")
+            return False
+
+        except Exception as e:
+            logger.warning(f"Could not create pause commit: {e}")
+            return False
+
+    def _display_pause_success(
+        self, session_id: str, session_file: Path, commit_created: bool
+    ) -> None:
+        """Display success message for paused session.
+
+        Args:
+            session_id: The session identifier
+            session_file: Path to the session state file
+            commit_created: Whether git commit was created
+        """
+        console.print()
+        console.print(
+            Panel(
+                f"[bold green]Session Paused Successfully[/bold green]\n\n"
+                f"[cyan]Session ID:[/cyan] {session_id}\n"
+                f"[cyan]State saved:[/cyan] {session_file}\n"
+                f"[cyan]Git commit:[/cyan] {'✓ Created' if commit_created else '✗ Not created (no git repo or no changes)'}\n\n"
+                f"[dim]To resume this session later, run:[/dim]\n"
+                f"[yellow]  claude-mpm mpm-init pause resume[/yellow]",
+                title="🔴 Session Pause",
+                border_style="green",
+            )
+        )
+        console.print()
+
+    def list_paused_sessions(self) -> List[Dict[str, Any]]:
+        """List all paused sessions.
+
+        Returns:
+            List of session information dicts
+        """
+        if not self.session_dir.exists():
+            return []
+
+        sessions = []
+        for session_file in sorted(self.session_dir.glob("session-*.json")):
+            try:
+                state = self.storage.read_json(session_file)
+                if state:
+                    sessions.append(
+                        {
+                            "session_id": state.get("session_id"),
+                            "paused_at": state.get("paused_at"),
+                            "summary": state.get("conversation", {}).get("summary"),
+                            "file_path": str(session_file),
+                        }
+                    )
+            except Exception as e:
+                logger.warning(f"Could not read session file {session_file}: {e}")
+
+        return sessions
+
+    def get_latest_session(self) -> Optional[Dict[str, Any]]:
+        """Get the most recent paused session.
+
+        Returns:
+            Session state dict or None if no sessions found
+        """
+        sessions = self.list_paused_sessions()
+        if not sessions:
+            return None
+
+        # Return the most recent (last in sorted list)
+        latest_file = Path(sessions[-1]["file_path"])
+        return self.storage.read_json(latest_file)