praisonai-code 0.0.1__py3-none-any.whl

praisonai_code/cli/features/doctor/checks/mcp_checks.py

@@ -0,0 +1,367 @@
+"""
+MCP (Model Context Protocol) checks for the Doctor CLI module.
+
+Validates MCP server configurations and connectivity.
+"""
+
+import os
+import shutil
+from pathlib import Path
+
+from ..models import (
+    CheckCategory,
+    CheckResult,
+    CheckStatus,
+    CheckSeverity,
+    DoctorConfig,
+)
+from ..registry import register_check
+
+
+def _find_mcp_config() -> dict:
+    """Find MCP configuration files."""
+    # Use canonical MCP paths from praisonaiagents.paths
+    try:
+        from praisonaiagents.paths import get_mcp_dir, get_project_data_dir
+        canonical_mcp_dir = get_mcp_dir()
+        project_mcp_dir = get_project_data_dir() / "mcp"
+        
+        locations = [
+            project_mcp_dir / "config.json",
+            canonical_mcp_dir / "config.json",
+            # Legacy paths for backward compatibility
+            Path.cwd() / ".praison" / "mcp.json",
+            Path.cwd() / ".praison" / "mcp" / "config.json",
+            Path.home() / ".praison" / "mcp.json",
+            Path.home() / ".config" / "praison" / "mcp.json",
+        ]
+    except ImportError:
+        # Fallback to legacy paths if praisonaiagents not available
+        locations = [
+            Path.cwd() / ".praisonai" / "mcp" / "config.json",
+            Path.cwd() / ".praison" / "mcp.json",
+            Path.cwd() / ".praison" / "mcp" / "config.json", 
+            Path.home() / ".praison" / "mcp.json",
+            Path.home() / ".config" / "praison" / "mcp.json",
+        ]
+    
+    for loc in locations:
+        if loc.exists():
+            try:
+                import json
+                with open(loc) as f:
+                    return {"path": str(loc), "config": json.load(f)}
+            except Exception:
+                pass
+    
+    return {}
+
+
+@register_check(
+    id="mcp_config",
+    title="MCP Configuration",
+    description="Check MCP configuration file",
+    category=CheckCategory.MCP,
+    severity=CheckSeverity.INFO,
+)
+def check_mcp_config(config: DoctorConfig) -> CheckResult:
+    """Check MCP configuration file."""
+    mcp_config = _find_mcp_config()
+    
+    if mcp_config:
+        servers = mcp_config.get("config", {}).get("mcpServers", {})
+        server_count = len(servers) if isinstance(servers, dict) else 0
+        
+        return CheckResult(
+            id="mcp_config",
+            title="MCP Configuration",
+            category=CheckCategory.MCP,
+            status=CheckStatus.PASS,
+            message=f"MCP config found with {server_count} server(s)",
+            details=f"Path: {mcp_config['path']}",
+            metadata={"path": mcp_config["path"], "server_count": server_count},
+        )
+    else:
+        return CheckResult(
+            id="mcp_config",
+            title="MCP Configuration",
+            category=CheckCategory.MCP,
+            status=CheckStatus.SKIP,
+            message="No MCP configuration found (optional)",
+            details="Create ~/.praisonai/mcp/config.json to configure MCP servers",
+        )
+
+
+@register_check(
+    id="mcp_npx",
+    title="npx for MCP",
+    description="Check npx availability for MCP servers",
+    category=CheckCategory.MCP,
+    severity=CheckSeverity.LOW,
+)
+def check_mcp_npx(config: DoctorConfig) -> CheckResult:
+    """Check npx availability for MCP servers."""
+    npx_path = shutil.which("npx")
+    
+    if npx_path:
+        return CheckResult(
+            id="mcp_npx",
+            title="npx for MCP",
+            category=CheckCategory.MCP,
+            status=CheckStatus.PASS,
+            message=f"npx available at {npx_path}",
+        )
+    else:
+        return CheckResult(
+            id="mcp_npx",
+            title="npx for MCP",
+            category=CheckCategory.MCP,
+            status=CheckStatus.WARN,
+            message="npx not found (required for most MCP servers)",
+            remediation="Install Node.js to use MCP servers",
+        )
+
+
+@register_check(
+    id="mcp_python",
+    title="Python MCP Support",
+    description="Check Python MCP package availability",
+    category=CheckCategory.MCP,
+    severity=CheckSeverity.LOW,
+)
+def check_mcp_python(config: DoctorConfig) -> CheckResult:
+    """Check Python MCP package availability."""
+    try:
+        import mcp
+        version = getattr(mcp, "__version__", "unknown")
+        return CheckResult(
+            id="mcp_python",
+            title="Python MCP Support",
+            category=CheckCategory.MCP,
+            status=CheckStatus.PASS,
+            message=f"mcp package {version} available",
+        )
+    except ImportError:
+        return CheckResult(
+            id="mcp_python",
+            title="Python MCP Support",
+            category=CheckCategory.MCP,
+            status=CheckStatus.SKIP,
+            message="mcp package not installed (optional)",
+            remediation="Install with: pip install mcp",
+        )
+
+
+@register_check(
+    id="mcp_servers_valid",
+    title="MCP Server Configs Valid",
+    description="Validate MCP server configurations",
+    category=CheckCategory.MCP,
+    severity=CheckSeverity.MEDIUM,
+    dependencies=["mcp_config"],
+)
+def check_mcp_servers_valid(config: DoctorConfig) -> CheckResult:
+    """Validate MCP server configurations."""
+    mcp_config = _find_mcp_config()
+    
+    if not mcp_config:
+        return CheckResult(
+            id="mcp_servers_valid",
+            title="MCP Server Configs Valid",
+            category=CheckCategory.MCP,
+            status=CheckStatus.SKIP,
+            message="No MCP configuration to validate",
+        )
+    
+    servers = mcp_config.get("config", {}).get("mcpServers", {})
+    if not servers:
+        return CheckResult(
+            id="mcp_servers_valid",
+            title="MCP Server Configs Valid",
+            category=CheckCategory.MCP,
+            status=CheckStatus.SKIP,
+            message="No MCP servers configured",
+        )
+    
+    valid = []
+    invalid = []
+    
+    for name, server_config in servers.items():
+        if not isinstance(server_config, dict):
+            invalid.append(f"{name}: invalid config format")
+            continue
+        
+        command = server_config.get("command")
+        if not command:
+            invalid.append(f"{name}: missing 'command'")
+            continue
+        
+        # Check if command executable exists
+        cmd_parts = command.split() if isinstance(command, str) else [command]
+        cmd_exe = cmd_parts[0] if cmd_parts else ""
+        
+        if cmd_exe and shutil.which(cmd_exe):
+            valid.append(name)
+        else:
+            invalid.append(f"{name}: command '{cmd_exe}' not found")
+    
+    if invalid:
+        return CheckResult(
+            id="mcp_servers_valid",
+            title="MCP Server Configs Valid",
+            category=CheckCategory.MCP,
+            status=CheckStatus.WARN,
+            message=f"{len(valid)} valid, {len(invalid)} invalid server(s)",
+            details="; ".join(invalid[:3]) + ("..." if len(invalid) > 3 else ""),
+            metadata={"valid": valid, "invalid": invalid},
+        )
+    else:
+        return CheckResult(
+            id="mcp_servers_valid",
+            title="MCP Server Configs Valid",
+            category=CheckCategory.MCP,
+            status=CheckStatus.PASS,
+            message=f"All {len(valid)} MCP server config(s) valid",
+            metadata={"valid": valid},
+        )
+
+
+@register_check(
+    id="mcp_server_spawn",
+    title="MCP Server Spawn Test",
+    description="Test spawning MCP servers",
+    category=CheckCategory.MCP,
+    severity=CheckSeverity.LOW,
+    requires_deep=True,
+)
+def check_mcp_server_spawn(config: DoctorConfig) -> CheckResult:
+    """Test spawning MCP servers (deep mode only)."""
+    mcp_config = _find_mcp_config()
+    
+    if not mcp_config:
+        return CheckResult(
+            id="mcp_server_spawn",
+            title="MCP Server Spawn Test",
+            category=CheckCategory.MCP,
+            status=CheckStatus.SKIP,
+            message="No MCP configuration to test",
+        )
+    
+    servers = mcp_config.get("config", {}).get("mcpServers", {})
+    if not servers:
+        return CheckResult(
+            id="mcp_server_spawn",
+            title="MCP Server Spawn Test",
+            category=CheckCategory.MCP,
+            status=CheckStatus.SKIP,
+            message="No MCP servers to test",
+        )
+    
+    # Only test first server to avoid long delays
+    test_server = config.name if config.name else list(servers.keys())[0]
+    server_config = servers.get(test_server)
+    
+    if not server_config:
+        return CheckResult(
+            id="mcp_server_spawn",
+            title="MCP Server Spawn Test",
+            category=CheckCategory.MCP,
+            status=CheckStatus.SKIP,
+            message=f"Server '{test_server}' not found",
+        )
+    
+    try:
+        import subprocess
+        
+        command = server_config.get("command", "")
+        args = server_config.get("args", [])
+        
+        if isinstance(command, str):
+            cmd = command.split() + args
+        else:
+            cmd = [command] + args
+        
+        # Try to start the server with a short timeout
+        proc = subprocess.Popen(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            env={**os.environ, **server_config.get("env", {})},
+        )
+        
+        # Wait briefly to see if it starts
+        import time
+        time.sleep(1)
+        
+        if proc.poll() is None:
+            # Process is still running - success
+            proc.terminate()
+            proc.wait(timeout=2)
+            return CheckResult(
+                id="mcp_server_spawn",
+                title="MCP Server Spawn Test",
+                category=CheckCategory.MCP,
+                status=CheckStatus.PASS,
+                message=f"Server '{test_server}' started successfully",
+            )
+        else:
+            # Process exited
+            stderr = proc.stderr.read().decode()[:200] if proc.stderr else ""
+            return CheckResult(
+                id="mcp_server_spawn",
+                title="MCP Server Spawn Test",
+                category=CheckCategory.MCP,
+                status=CheckStatus.WARN,
+                message=f"Server '{test_server}' exited immediately",
+                details=stderr if stderr else "No error output",
+            )
+    
+    except FileNotFoundError as e:
+        return CheckResult(
+            id="mcp_server_spawn",
+            title="MCP Server Spawn Test",
+            category=CheckCategory.MCP,
+            status=CheckStatus.FAIL,
+            message=f"Command not found for '{test_server}'",
+            details=str(e),
+            remediation="Install the required MCP server package",
+        )
+    except Exception as e:
+        return CheckResult(
+            id="mcp_server_spawn",
+            title="MCP Server Spawn Test",
+            category=CheckCategory.MCP,
+            status=CheckStatus.WARN,
+            message=f"Could not test server '{test_server}'",
+            details=str(e)[:200],
+        )
+
+
+@register_check(
+    id="mcp_praisonai_integration",
+    title="PraisonAI MCP Integration",
+    description="Check PraisonAI MCP integration",
+    category=CheckCategory.MCP,
+    severity=CheckSeverity.LOW,
+)
+def check_mcp_praisonai_integration(config: DoctorConfig) -> CheckResult:
+    """Check PraisonAI MCP integration."""
+    try:
+        from praisonaiagents.mcp import MCP
+        return CheckResult(
+            id="mcp_praisonai_integration",
+            title="PraisonAI MCP Integration",
+            category=CheckCategory.MCP,
+            status=CheckStatus.PASS,
+            message="PraisonAI MCP integration available",
+        )
+    except ImportError as e:
+        return CheckResult(
+            id="mcp_praisonai_integration",
+            title="PraisonAI MCP Integration",
+            category=CheckCategory.MCP,
+            status=CheckStatus.SKIP,
+            message="MCP integration not available",
+            details=str(e),
+            remediation="Install with: pip install praisonaiagents[mcp]",
+        )

praisonai_code/cli/features/doctor/checks/memory_checks.py

@@ -0,0 +1,268 @@
+"""
+Memory checks for the Doctor CLI module.
+
+Validates memory/session storage and integrity.
+"""
+
+import os
+from pathlib import Path
+
+from ..models import (
+    CheckCategory,
+    CheckResult,
+    CheckStatus,
+    CheckSeverity,
+    DoctorConfig,
+)
+from ..registry import register_check
+
+
+def _find_memory_dirs() -> list:
+    """Find memory storage directories."""
+    locations = [
+        Path.cwd() / ".praison" / "memory",
+        Path.cwd() / ".praison" / "sessions",
+        Path.home() / ".praison" / "memory",
+        Path.home() / ".praison" / "sessions",
+        Path.home() / ".config" / "praison" / "memory",
+    ]
+    
+    found = []
+    for loc in locations:
+        if loc.exists() and loc.is_dir():
+            found.append(str(loc))
+    
+    return found
+
+
+@register_check(
+    id="memory_dirs",
+    title="Memory Directories",
+    description="Check memory storage directories",
+    category=CheckCategory.MEMORY,
+    severity=CheckSeverity.INFO,
+)
+def check_memory_dirs(config: DoctorConfig) -> CheckResult:
+    """Check memory storage directories."""
+    dirs = _find_memory_dirs()
+    
+    if dirs:
+        return CheckResult(
+            id="memory_dirs",
+            title="Memory Directories",
+            category=CheckCategory.MEMORY,
+            status=CheckStatus.PASS,
+            message=f"Found {len(dirs)} memory directory(ies)",
+            details=", ".join(dirs),
+            metadata={"directories": dirs},
+        )
+    else:
+        return CheckResult(
+            id="memory_dirs",
+            title="Memory Directories",
+            category=CheckCategory.MEMORY,
+            status=CheckStatus.SKIP,
+            message="No memory directories found (will be created on first use)",
+        )
+
+
+@register_check(
+    id="memory_files",
+    title="Memory Files",
+    description="Check memory file integrity",
+    category=CheckCategory.MEMORY,
+    severity=CheckSeverity.MEDIUM,
+    dependencies=["memory_dirs"],
+)
+def check_memory_files(config: DoctorConfig) -> CheckResult:
+    """Check memory file integrity."""
+    dirs = _find_memory_dirs()
+    
+    if not dirs:
+        return CheckResult(
+            id="memory_files",
+            title="Memory Files",
+            category=CheckCategory.MEMORY,
+            status=CheckStatus.SKIP,
+            message="No memory directories to check",
+        )
+    
+    valid_files = 0
+    corrupt_files = []
+    total_size = 0
+    
+    for dir_path in dirs:
+        memory_dir = Path(dir_path)
+        for file_path in memory_dir.rglob("*.json"):
+            try:
+                import json
+                with open(file_path) as f:
+                    json.load(f)
+                valid_files += 1
+                total_size += file_path.stat().st_size
+            except json.JSONDecodeError:
+                corrupt_files.append(str(file_path))
+            except Exception:
+                pass
+    
+    if corrupt_files:
+        return CheckResult(
+            id="memory_files",
+            title="Memory Files",
+            category=CheckCategory.MEMORY,
+            status=CheckStatus.WARN,
+            message=f"{len(corrupt_files)} corrupt file(s) found",
+            details="; ".join(corrupt_files[:3]) + ("..." if len(corrupt_files) > 3 else ""),
+            remediation="Remove or repair corrupt memory files",
+            metadata={"valid": valid_files, "corrupt": corrupt_files},
+        )
+    elif valid_files > 0:
+        size_kb = total_size / 1024
+        return CheckResult(
+            id="memory_files",
+            title="Memory Files",
+            category=CheckCategory.MEMORY,
+            status=CheckStatus.PASS,
+            message=f"{valid_files} valid memory file(s) ({size_kb:.1f} KB)",
+            metadata={"valid_count": valid_files, "total_size_bytes": total_size},
+        )
+    else:
+        return CheckResult(
+            id="memory_files",
+            title="Memory Files",
+            category=CheckCategory.MEMORY,
+            status=CheckStatus.SKIP,
+            message="No memory files found",
+        )
+
+
+@register_check(
+    id="memory_sessions",
+    title="Session Storage",
+    description="Check session storage",
+    category=CheckCategory.MEMORY,
+    severity=CheckSeverity.INFO,
+)
+def check_memory_sessions(config: DoctorConfig) -> CheckResult:
+    """Check session storage."""
+    session_dirs = [
+        Path.cwd() / ".praison" / "sessions",
+        Path.home() / ".praison" / "sessions",
+    ]
+    
+    sessions = []
+    for dir_path in session_dirs:
+        if dir_path.exists():
+            for item in dir_path.iterdir():
+                if item.is_dir() or item.suffix == ".json":
+                    sessions.append(item.name)
+    
+    if sessions:
+        return CheckResult(
+            id="memory_sessions",
+            title="Session Storage",
+            category=CheckCategory.MEMORY,
+            status=CheckStatus.PASS,
+            message=f"Found {len(sessions)} saved session(s)",
+            metadata={"sessions": sessions[:10]},
+        )
+    else:
+        return CheckResult(
+            id="memory_sessions",
+            title="Session Storage",
+            category=CheckCategory.MEMORY,
+            status=CheckStatus.SKIP,
+            message="No saved sessions found",
+        )
+
+
+@register_check(
+    id="memory_chromadb",
+    title="ChromaDB Memory",
+    description="Check ChromaDB vector memory",
+    category=CheckCategory.MEMORY,
+    severity=CheckSeverity.LOW,
+)
+def check_memory_chromadb(config: DoctorConfig) -> CheckResult:
+    """Check ChromaDB vector memory."""
+    chroma_dirs = [
+        Path.cwd() / ".praison" / "chroma",
+        Path.cwd() / "chroma_db",
+        Path.home() / ".praison" / "chroma",
+    ]
+    
+    found = None
+    for dir_path in chroma_dirs:
+        if dir_path.exists():
+            found = dir_path
+            break
+    
+    if found:
+        try:
+            import chromadb
+            # Try to open the database
+            client = chromadb.PersistentClient(path=str(found))
+            collections = client.list_collections()
+            return CheckResult(
+                id="memory_chromadb",
+                title="ChromaDB Memory",
+                category=CheckCategory.MEMORY,
+                status=CheckStatus.PASS,
+                message=f"ChromaDB found with {len(collections)} collection(s)",
+                metadata={"path": str(found), "collections": len(collections)},
+            )
+        except ImportError:
+            return CheckResult(
+                id="memory_chromadb",
+                title="ChromaDB Memory",
+                category=CheckCategory.MEMORY,
+                status=CheckStatus.WARN,
+                message="ChromaDB directory found but chromadb not installed",
+                remediation="Install with: pip install chromadb",
+            )
+        except Exception as e:
+            return CheckResult(
+                id="memory_chromadb",
+                title="ChromaDB Memory",
+                category=CheckCategory.MEMORY,
+                status=CheckStatus.WARN,
+                message=f"ChromaDB found but cannot open: {type(e).__name__}",
+                details=str(e)[:200],
+            )
+    else:
+        return CheckResult(
+            id="memory_chromadb",
+            title="ChromaDB Memory",
+            category=CheckCategory.MEMORY,
+            status=CheckStatus.SKIP,
+            message="No ChromaDB storage found (optional)",
+        )
+
+
+@register_check(
+    id="memory_praisonai_module",
+    title="PraisonAI Memory Module",
+    description="Check PraisonAI memory module",
+    category=CheckCategory.MEMORY,
+    severity=CheckSeverity.LOW,
+)
+def check_memory_praisonai_module(config: DoctorConfig) -> CheckResult:
+    """Check PraisonAI memory module."""
+    try:
+        from praisonaiagents.memory import FileMemory, Memory
+        return CheckResult(
+            id="memory_praisonai_module",
+            title="PraisonAI Memory Module",
+            category=CheckCategory.MEMORY,
+            status=CheckStatus.PASS,
+            message="Memory modules available (FileMemory, Memory)",
+        )
+    except ImportError as e:
+        return CheckResult(
+            id="memory_praisonai_module",
+            title="PraisonAI Memory Module",
+            category=CheckCategory.MEMORY,
+            status=CheckStatus.WARN,
+            message="Memory module import failed",
+            details=str(e),
+        )