claude-mpm 4.1.26__py3-none-any.whl → 4.24.0__py3-none-any.whl

claude_mpm/cli/startup_logging.py

@@ -14,11 +14,12 @@ DESIGN DECISIONS:
 - Capture all startup logs to timestamped files for analysis
 """
 
+import asyncio
 import logging
 import shutil
 import subprocess
 import sys
-from datetime import datetime
+from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Dict, Optional
 
@@ -69,7 +70,7 @@ def log_memory_stats(logger=None, prefix="Memory Usage"):
                     f"{prefix}: RSS={rss_mb:.1f}MB, System={memory_percent:.1f}%"
                 )
                 return {"rss_mb": rss_mb, "vms_mb": None, "percent": memory_percent}
-            except:
+            except Exception:
                 logger.info(f"{prefix}: RSS={rss_mb:.1f}MB")
                 return {"rss_mb": rss_mb, "vms_mb": None, "percent": None}
         else:
@@ -82,7 +83,7 @@ def log_memory_stats(logger=None, prefix="Memory Usage"):
                     f"System={memory_percent:.1f}%"
                 )
                 return {"rss_mb": rss_mb, "vms_mb": vms_mb, "percent": memory_percent}
-            except:
+            except Exception:
                 logger.info(f"{prefix}: RSS={rss_mb:.1f}MB, VMS={vms_mb:.1f}MB")
                 return {"rss_mb": rss_mb, "vms_mb": vms_mb, "percent": None}
 
@@ -114,12 +115,10 @@ class StartupStatusLogger:
             if mcp_executable:
                 self.logger.info(f"MCP Server: Installed at {mcp_executable}")
 
-                # Try to get version
+                # Try to get version (only log if version is found)
                 version = self._get_mcp_version(mcp_executable)
                 if version:
                     self.logger.info(f"MCP Server: Version {version}")
-                else:
-                    self.logger.info("MCP Server: Version unknown")
             else:
                 self.logger.info("MCP Server: Not found in PATH")
 
@@ -304,7 +303,7 @@ class StartupStatusLogger:
 
             import json
 
-            with open(claude_json_path) as f:
+            with claude_json_path.open() as f:
                 config = json.load(f)
 
             result["found"] = True
@@ -339,14 +338,27 @@ class StartupStatusLogger:
 
     def _check_socketio_dependencies(self) -> Dict[str, Any]:
         """Check if Socket.IO dependencies are available."""
+        import importlib.util
+
         result = {"available": False, "error": None}
 
         try:
-            import aiohttp
-            import engineio
-            import socketio
+            # Check for socketio dependencies without importing them
+            aiohttp_spec = importlib.util.find_spec("aiohttp")
+            engineio_spec = importlib.util.find_spec("engineio")
+            socketio_spec = importlib.util.find_spec("socketio")
 
-            result["available"] = True
+            if aiohttp_spec and engineio_spec and socketio_spec:
+                result["available"] = True
+            else:
+                missing = []
+                if not aiohttp_spec:
+                    missing.append("aiohttp")
+                if not engineio_spec:
+                    missing.append("engineio")
+                if not socketio_spec:
+                    missing.append("socketio")
+                result["error"] = f"Missing dependencies: {', '.join(missing)}"
         except ImportError as e:
             result["error"] = f"Missing dependencies: {e}"
         except Exception as e:
@@ -493,7 +505,7 @@ def setup_startup_logging(project_root: Optional[Path] = None) -> Path:
     log_dir.mkdir(parents=True, exist_ok=True)
 
     # Generate timestamp for log file
-    timestamp = datetime.now().strftime("%Y-%m-%d-%H-%M-%S")
+    timestamp = datetime.now(timezone.utc).strftime("%Y-%m-%d-%H-%M-%S")
     log_file = log_dir / f"startup-{timestamp}.log"
 
     # Create file handler with detailed formatting
@@ -516,7 +528,7 @@ def setup_startup_logging(project_root: Optional[Path] = None) -> Path:
     # Log startup header
     logger = get_logger("startup")
     logger.info("=" * 60)
-    logger.info(f"Claude MPM Startup - {datetime.now().isoformat()}")
+    logger.info(f"Claude MPM Startup - {datetime.now(timezone.utc).isoformat()}")
     logger.info(f"Log file: {log_file}")
     logger.info("=" * 60)
 
@@ -619,6 +631,156 @@ def cleanup_old_startup_logs(
         return deleted_count
 
 
+async def trigger_vector_search_indexing(project_root: Optional[Path] = None) -> None:
+    """
+    Trigger mcp-vector-search indexing in the background.
+
+    This function attempts to start the mcp-vector-search indexing process
+    asynchronously so it doesn't block startup. If the service is not available,
+    it fails silently.
+
+    Args:
+        project_root: Root directory for the project (defaults to cwd)
+    """
+    logger = get_logger("cli")
+
+    if project_root is None:
+        project_root = Path.cwd()
+
+    try:
+        # Check if mcp-vector-search is available
+        from ..services.mcp_config_manager import MCPConfigManager
+
+        manager = MCPConfigManager()
+        vector_search_path = manager.detect_service_path("mcp-vector-search")
+
+        if not vector_search_path:
+            logger.debug("mcp-vector-search not found, skipping indexing")
+            return
+
+        # Build the command based on the service configuration
+        if "python" in vector_search_path:
+            # Using Python interpreter directly
+            cmd = [
+                vector_search_path,
+                "-m",
+                "mcp_vector_search.cli",
+                "index",
+                str(project_root),
+            ]
+        else:
+            # Using installed binary
+            cmd = [vector_search_path, "index", str(project_root)]
+
+        logger.info(
+            "MCP Vector Search: Starting background indexing for improved code search"
+        )
+
+        # Start the indexing process in the background
+        # We use subprocess.Popen instead of run to avoid blocking
+        process = await asyncio.create_subprocess_exec(
+            *cmd,
+            stdout=asyncio.subprocess.DEVNULL,
+            stderr=asyncio.subprocess.DEVNULL,
+            cwd=str(project_root),
+        )
+
+        # Store PID for logging
+        pid = process.pid
+        logger.debug(f"MCP Vector Search: Indexing process started (PID: {pid})")
+
+        # Don't wait for completion - let it run independently in the background
+        # We don't need to track its completion, so we can safely detach
+
+    except ImportError:
+        logger.debug(
+            "MCP config manager not available, skipping vector search indexing"
+        )
+    except Exception as e:
+        # Don't let indexing failures prevent startup
+        logger.debug(f"Failed to start vector search indexing: {e}")
+
+
+def start_vector_search_indexing(project_root: Optional[Path] = None) -> None:
+    """
+    Synchronous wrapper to trigger vector search indexing.
+
+    This creates a new event loop if needed to run the async indexing function.
+    Falls back to subprocess.Popen if async fails.
+
+    Args:
+        project_root: Root directory for the project (defaults to cwd)
+    """
+    logger = get_logger("cli")
+
+    try:
+        # Try to get the current event loop
+        loop = asyncio.get_running_loop()
+        # If we're in an event loop, create a task (fire-and-forget)
+        _task = loop.create_task(trigger_vector_search_indexing(project_root))
+        # Fire-and-forget: task will complete in background
+    except RuntimeError:
+        # No event loop running - use subprocess directly to avoid event loop lifecycle issues
+        # The async approach with asyncio.run() creates and closes a loop which causes
+        # warnings when subprocesses are still running
+        logger.debug("No event loop running, using subprocess approach")
+        _start_vector_search_subprocess(project_root)
+
+
+def _start_vector_search_subprocess(project_root: Optional[Path] = None) -> None:
+    """
+    Fallback method to start vector search indexing using subprocess.Popen.
+
+    Args:
+        project_root: Root directory for the project (defaults to cwd)
+    """
+    logger = get_logger("cli")
+
+    if project_root is None:
+        project_root = Path.cwd()
+
+    try:
+        from ..services.mcp_config_manager import MCPConfigManager
+
+        manager = MCPConfigManager()
+        vector_search_path = manager.detect_service_path("mcp-vector-search")
+
+        if not vector_search_path:
+            logger.debug("mcp-vector-search not found, skipping indexing")
+            return
+
+        # Build the command
+        if "python" in vector_search_path:
+            cmd = [
+                vector_search_path,
+                "-m",
+                "mcp_vector_search.cli",
+                "index",
+                str(project_root),
+            ]
+        else:
+            cmd = [vector_search_path, "index", str(project_root)]
+
+        logger.info(
+            "MCP Vector Search: Starting background indexing for improved code search"
+        )
+
+        # Start the indexing process in the background
+        process = subprocess.Popen(
+            cmd,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            cwd=str(project_root),
+        )
+
+        logger.debug(
+            f"MCP Vector Search: Indexing process started (PID: {process.pid})"
+        )
+
+    except Exception as e:
+        logger.debug(f"Failed to start vector search indexing: {e}")
+
+
 def get_latest_startup_log(project_root: Optional[Path] = None) -> Optional[Path]:
     """
     Get the path to the most recent startup log file.
@@ -667,6 +829,10 @@ def log_startup_status(monitor_mode: bool = False, websocket_port: int = 8765) -
         # Log monitor setup status
         status_logger.log_monitor_setup_status(monitor_mode, websocket_port)
 
+        # Trigger vector search indexing in the background after MCP is configured
+        # This will run asynchronously and not block startup
+        start_vector_search_indexing()
+
     except Exception as e:
         # Don't let logging failures prevent startup
         logger = get_logger("cli")

claude_mpm/cli/utils.py

@@ -6,9 +6,10 @@ Centralizing these functions reduces code duplication and provides a single plac
 for common CLI operations.
 """
 
+import difflib
 import sys
 from pathlib import Path
-from typing import Optional
+from typing import List, Optional
 
 from ..core.logger import get_logger
 
@@ -106,7 +107,7 @@ def get_agent_versions_display() -> Optional[str]:
                     base_version_tuple
                 )
                 output_lines.append(f"\n  Base Agent Version:  {base_version_str}")
-        except:
+        except Exception:
             pass
 
         # Check for agents needing migration
@@ -207,3 +208,53 @@ def ensure_directories() -> None:
         # Continue even if initialization fails
         # The individual commands will handle missing directories as needed
         pass
+
+
+def suggest_similar_commands(
+    invalid_command: str,
+    valid_commands: List[str],
+    cutoff: float = 0.6,
+    max_suggestions: int = 3,
+) -> Optional[str]:
+    """
+    Suggest similar commands for an invalid command using fuzzy matching.
+
+    WHY: Helps users quickly identify typos and discover correct command names
+    by suggesting the most similar valid commands. Uses stdlib difflib for
+    zero-dependency fuzzy matching.
+
+    DESIGN DECISION: Using difflib.get_close_matches provides good results for
+    typos and partial matches while being simple and lightweight (no external deps).
+
+    Args:
+        invalid_command: The invalid command the user typed
+        valid_commands: List of valid commands to match against
+        cutoff: Similarity threshold (0.0-1.0), default 0.6
+        max_suggestions: Maximum number of suggestions to return, default 3
+
+    Returns:
+        Formatted suggestion string or None if no good matches found
+
+    Examples:
+        >>> suggest_similar_commands("tickts", ["tickets", "run", "agents"])
+        "Did you mean 'tickets'?"
+
+        >>> suggest_similar_commands("mem", ["memory", "monitor", "mcp"])
+        "Did you mean one of these?\n  memory\n  monitor\n  mcp"
+
+        >>> suggest_similar_commands("xyz", ["tickets", "run"])
+        None  # No good matches
+    """
+    # Use difflib to find close matches
+    matches = difflib.get_close_matches(
+        invalid_command, valid_commands, n=max_suggestions, cutoff=cutoff
+    )
+
+    if not matches:
+        return None
+
+    # Format suggestion message
+    if len(matches) == 1:
+        return f"Did you mean '{matches[0]}'?"
+    suggestions = "\n  ".join(matches)
+    return f"Did you mean one of these?\n  {suggestions}"

claude_mpm/commands/mpm-agents-detect.md

@@ -0,0 +1,168 @@
+# Detect project toolchain and frameworks
+
+Scan your project to detect programming languages, frameworks, tools, and configurations.
+
+## Usage
+
+```
+/mpm-agents-detect
+```
+
+## Description
+
+This command scans your project directory to automatically detect:
+- Programming languages and their versions
+- Web frameworks and libraries
+- Testing tools and frameworks
+- Build tools and bundlers
+- Package managers
+- Deployment configurations
+
+This is useful for understanding what Claude MPM can detect in your project before running auto-configuration.
+
+## Implementation
+
+When you run `/mpm-agents-detect`, the PM will execute:
+```bash
+claude-mpm agents detect
+```
+
+This performs a comprehensive scan of your project looking for:
+- Package manifests (package.json, requirements.txt, Cargo.toml, go.mod, pom.xml)
+- Framework-specific files (next.config.js, fastapi imports, etc.)
+- Test configurations (pytest.ini, jest.config.js, playwright.config.ts)
+- Build configurations (vite.config.js, webpack.config.js, tsconfig.json)
+- Deployment files (Dockerfile, vercel.json, railway.json)
+
+## Expected Output
+
+```
+🔍 Project Toolchain Detection
+================================
+
+Languages:
+  ✓ Python 3.11.5
+  ✓ Node.js 20.10.0
+  ✓ TypeScript 5.3.2
+
+Frameworks:
+  ✓ FastAPI 0.104.0
+  ✓ React 18.2.0
+  ✓ Next.js 14.0.4
+
+Testing:
+  ✓ pytest 7.4.3
+  ✓ Jest 29.7.0
+  ✓ Playwright 1.40.0
+
+Build Tools:
+  ✓ Vite 5.0.0
+  ✓ TypeScript Compiler
+
+Package Managers:
+  ✓ poetry (Python)
+  ✓ npm (Node.js)
+
+Deployment:
+  ✓ Docker (Dockerfile found)
+  ✓ Vercel (vercel.json found)
+  ✓ PM2 (ecosystem.config.js found)
+
+Configuration Files Detected:
+  - pyproject.toml
+  - package.json
+  - tsconfig.json
+  - next.config.js
+  - pytest.ini
+  - jest.config.js
+  - playwright.config.ts
+  - Dockerfile
+  - vercel.json
+
+Summary:
+  Full-stack project with Python backend (FastAPI) and
+  React/Next.js frontend, comprehensive testing setup,
+  and multiple deployment targets.
+```
+
+## What Gets Detected
+
+### Language Detection
+- **Python**: Looks for .py files, requirements.txt, pyproject.toml, setup.py
+- **JavaScript/TypeScript**: Looks for .js/.ts files, package.json, tsconfig.json
+- **Rust**: Looks for Cargo.toml, .rs files
+- **Go**: Looks for go.mod, .go files
+- **Java**: Looks for pom.xml, build.gradle, .java files
+
+### Framework Detection
+**Python:**
+- FastAPI (imports, decorator patterns)
+- Flask (imports, app patterns)
+- Django (settings.py, manage.py)
+
+**JavaScript/TypeScript:**
+- Next.js (next.config.js, pages/ or app/ directory)
+- React (package.json dependencies, JSX usage)
+- Vue (vue.config.js, .vue files)
+- Express (imports, app patterns)
+- Nest.js (nest-cli.json, decorators)
+
+### Testing Detection
+- pytest (pytest.ini, conftest.py)
+- unittest (test_*.py patterns)
+- Jest (jest.config.js)
+- Vitest (vitest.config.js)
+- Playwright (playwright.config.ts)
+- Cypress (cypress.json)
+
+### Build Tool Detection
+- Vite (vite.config.js/ts)
+- Webpack (webpack.config.js)
+- Rollup (rollup.config.js)
+- esbuild (esbuild configuration)
+- Turbopack (next.config.js with turbopack)
+
+### Deployment Detection
+- Docker (Dockerfile, docker-compose.yml)
+- Vercel (vercel.json, .vercel directory)
+- Railway (railway.json, railway.toml)
+- PM2 (ecosystem.config.js)
+- Kubernetes (k8s/, kubernetes/ directories)
+
+## Use Cases
+
+1. **Before Auto-Configuration**: Run this to see what will be detected
+2. **Troubleshooting**: Verify that your project setup is being recognized correctly
+3. **Documentation**: Generate a summary of your project's tech stack
+4. **Planning**: Understand what agents might be recommended
+
+## Tips
+
+1. **Run from project root**: Detection works best from your project's root directory
+2. **Check detection accuracy**: Verify detected versions match your actual setup
+3. **Missing detections**: If something isn't detected, you can still deploy agents manually
+4. **Configuration files**: Detection relies on standard configuration files being present
+
+## Common Issues
+
+**Nothing detected?**
+- Make sure you're in the project root directory
+- Check that you have standard configuration files (package.json, requirements.txt, etc.)
+- Some projects may need manual agent deployment
+
+**Wrong versions detected?**
+- Detection shows what's configured in manifest files
+- Actual runtime versions may differ
+- This doesn't affect agent functionality
+
+**Framework not detected?**
+- Some frameworks are harder to detect automatically
+- You can still use auto-configure and manually select agents
+- Or deploy specific agents manually with `/mpm-agents deploy <name>`
+
+## Related Commands
+
+- `/mpm-agents-recommend` - See agent recommendations based on detection
+- `/mpm-auto-configure` - Automatically configure agents based on detection
+- `/mpm-agents` - Manually manage agents
+- `/mpm-help auto-configure` - Learn about auto-configuration