PraisonAI 3.0.0__py3-none-any.whl

praisonai/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),
+        )

praisonai/cli/features/doctor/checks/network_checks.py

@@ -0,0 +1,251 @@
+"""
+Network checks for the Doctor CLI module.
+
+Validates network connectivity and configuration.
+"""
+
+import os
+import socket
+
+from ..models import (
+    CheckCategory,
+    CheckResult,
+    CheckStatus,
+    CheckSeverity,
+    DoctorConfig,
+)
+from ..registry import register_check
+
+
+@register_check(
+    id="network_dns",
+    title="DNS Resolution",
+    description="Check DNS resolution",
+    category=CheckCategory.NETWORK,
+    severity=CheckSeverity.MEDIUM,
+    requires_deep=True,
+)
+def check_network_dns(config: DoctorConfig) -> CheckResult:
+    """Check DNS resolution."""
+    test_hosts = [
+        "api.openai.com",
+        "api.anthropic.com",
+        "google.com",
+    ]
+    
+    resolved = []
+    failed = []
+    
+    for host in test_hosts:
+        try:
+            socket.gethostbyname(host)
+            resolved.append(host)
+        except socket.gaierror:
+            failed.append(host)
+    
+    if failed:
+        return CheckResult(
+            id="network_dns",
+            title="DNS Resolution",
+            category=CheckCategory.NETWORK,
+            status=CheckStatus.WARN,
+            message=f"DNS resolution failed for {len(failed)} host(s)",
+            details=f"Failed: {', '.join(failed)}",
+            remediation="Check DNS configuration and network connectivity",
+        )
+    else:
+        return CheckResult(
+            id="network_dns",
+            title="DNS Resolution",
+            category=CheckCategory.NETWORK,
+            status=CheckStatus.PASS,
+            message=f"DNS resolution working ({len(resolved)} hosts tested)",
+        )
+
+
+@register_check(
+    id="network_https",
+    title="HTTPS Connectivity",
+    description="Check HTTPS connectivity to key endpoints",
+    category=CheckCategory.NETWORK,
+    severity=CheckSeverity.MEDIUM,
+    requires_deep=True,
+)
+def check_network_https(config: DoctorConfig) -> CheckResult:
+    """Check HTTPS connectivity to key endpoints."""
+    import urllib.request
+    import urllib.error
+    
+    endpoints = [
+        ("https://api.openai.com/v1/models", "OpenAI"),
+        ("https://api.anthropic.com/v1/messages", "Anthropic"),
+    ]
+    
+    reachable = []
+    unreachable = []
+    
+    for url, name in endpoints:
+        try:
+            req = urllib.request.Request(url, method="HEAD")
+            req.add_header("User-Agent", "PraisonAI-Doctor/1.0")
+            urllib.request.urlopen(req, timeout=5)
+            reachable.append(name)
+        except urllib.error.HTTPError as e:
+            # HTTP errors (401, 403, etc.) mean we reached the server
+            if e.code in (401, 403, 404, 405):
+                reachable.append(name)
+            else:
+                unreachable.append(f"{name} ({e.code})")
+        except Exception as e:
+            unreachable.append(f"{name} ({type(e).__name__})")
+    
+    if unreachable:
+        return CheckResult(
+            id="network_https",
+            title="HTTPS Connectivity",
+            category=CheckCategory.NETWORK,
+            status=CheckStatus.WARN,
+            message=f"Cannot reach {len(unreachable)} endpoint(s)",
+            details=f"Unreachable: {', '.join(unreachable)}",
+            remediation="Check network connectivity and firewall settings",
+        )
+    else:
+        return CheckResult(
+            id="network_https",
+            title="HTTPS Connectivity",
+            category=CheckCategory.NETWORK,
+            status=CheckStatus.PASS,
+            message=f"HTTPS connectivity verified ({len(reachable)} endpoints)",
+        )
+
+
+@register_check(
+    id="network_proxy",
+    title="Proxy Configuration",
+    description="Check proxy environment variables",
+    category=CheckCategory.NETWORK,
+    severity=CheckSeverity.INFO,
+)
+def check_network_proxy(config: DoctorConfig) -> CheckResult:
+    """Check proxy environment variables."""
+    proxy_vars = {
+        "HTTP_PROXY": os.environ.get("HTTP_PROXY") or os.environ.get("http_proxy"),
+        "HTTPS_PROXY": os.environ.get("HTTPS_PROXY") or os.environ.get("https_proxy"),
+        "NO_PROXY": os.environ.get("NO_PROXY") or os.environ.get("no_proxy"),
+    }
+    
+    configured = {k: v for k, v in proxy_vars.items() if v}
+    
+    if configured:
+        # Mask proxy URLs that might contain credentials
+        masked = {}
+        for k, v in configured.items():
+            if "@" in v:
+                # Contains credentials, mask them
+                parts = v.split("@")
+                masked[k] = f"***@{parts[-1]}"
+            else:
+                masked[k] = v
+        
+        return CheckResult(
+            id="network_proxy",
+            title="Proxy Configuration",
+            category=CheckCategory.NETWORK,
+            status=CheckStatus.PASS,
+            message=f"Proxy configured: {', '.join(configured.keys())}",
+            details="; ".join(f"{k}={v}" for k, v in masked.items()),
+        )
+    else:
+        return CheckResult(
+            id="network_proxy",
+            title="Proxy Configuration",
+            category=CheckCategory.NETWORK,
+            status=CheckStatus.SKIP,
+            message="No proxy configured (direct connection)",
+        )
+
+
+@register_check(
+    id="network_ssl",
+    title="SSL Configuration",
+    description="Check SSL/TLS configuration",
+    category=CheckCategory.NETWORK,
+    severity=CheckSeverity.INFO,
+)
+def check_network_ssl(config: DoctorConfig) -> CheckResult:
+    """Check SSL/TLS configuration."""
+    ssl_vars = {
+        "SSL_CERT_FILE": os.environ.get("SSL_CERT_FILE"),
+        "SSL_CERT_DIR": os.environ.get("SSL_CERT_DIR"),
+        "REQUESTS_CA_BUNDLE": os.environ.get("REQUESTS_CA_BUNDLE"),
+        "CURL_CA_BUNDLE": os.environ.get("CURL_CA_BUNDLE"),
+    }
+    
+    configured = {k: v for k, v in ssl_vars.items() if v}
+    
+    # Check for SSL verification disable (security concern)
+    ssl_verify = os.environ.get("PYTHONHTTPSVERIFY", "1")
+    requests_verify = os.environ.get("REQUESTS_SSL_VERIFY", "1")
+    
+    warnings = []
+    if ssl_verify == "0":
+        warnings.append("PYTHONHTTPSVERIFY=0 (SSL verification disabled)")
+    if requests_verify.lower() in ("0", "false"):
+        warnings.append("REQUESTS_SSL_VERIFY disabled")
+    
+    if warnings:
+        return CheckResult(
+            id="network_ssl",
+            title="SSL Configuration",
+            category=CheckCategory.NETWORK,
+            status=CheckStatus.WARN,
+            message="SSL verification disabled",
+            details="; ".join(warnings),
+            remediation="Enable SSL verification for security",
+        )
+    elif configured:
+        return CheckResult(
+            id="network_ssl",
+            title="SSL Configuration",
+            category=CheckCategory.NETWORK,
+            status=CheckStatus.PASS,
+            message=f"Custom SSL config: {', '.join(configured.keys())}",
+        )
+    else:
+        return CheckResult(
+            id="network_ssl",
+            title="SSL Configuration",
+            category=CheckCategory.NETWORK,
+            status=CheckStatus.PASS,
+            message="Using default SSL configuration",
+        )
+
+
+@register_check(
+    id="network_openai_base_url",
+    title="OpenAI Base URL",
+    description="Check OpenAI base URL configuration",
+    category=CheckCategory.NETWORK,
+    severity=CheckSeverity.INFO,
+)
+def check_network_openai_base_url(config: DoctorConfig) -> CheckResult:
+    """Check OpenAI base URL configuration."""
+    base_url = os.environ.get("OPENAI_BASE_URL") or os.environ.get("OPENAI_API_BASE")
+    
+    if base_url:
+        return CheckResult(
+            id="network_openai_base_url",
+            title="OpenAI Base URL",
+            category=CheckCategory.NETWORK,
+            status=CheckStatus.PASS,
+            message=f"Custom OpenAI base URL: {base_url}",
+            details="Using custom endpoint (e.g., Azure, local proxy)",
+        )
+    else:
+        return CheckResult(
+            id="network_openai_base_url",
+            title="OpenAI Base URL",
+            category=CheckCategory.NETWORK,
+            status=CheckStatus.PASS,
+            message="Using default OpenAI endpoint",
+        )