PraisonAI 3.0.0__py3-none-any.whl

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

@@ -0,0 +1,259 @@
+"""
+Permissions checks for the Doctor CLI module.
+
+Validates filesystem permissions for PraisonAI directories.
+"""
+
+import os
+import tempfile
+from pathlib import Path
+
+from ..models import (
+    CheckCategory,
+    CheckResult,
+    CheckStatus,
+    CheckSeverity,
+    DoctorConfig,
+)
+from ..registry import register_check
+
+
+def _check_dir_writable(path: Path) -> tuple:
+    """Check if a directory is writable."""
+    try:
+        if not path.exists():
+            return False, "does not exist"
+        
+        if not path.is_dir():
+            return False, "not a directory"
+        
+        # Try to create a temp file
+        test_file = path / ".praison_write_test"
+        try:
+            test_file.write_text("test")
+            test_file.unlink()
+            return True, "writable"
+        except PermissionError:
+            return False, "permission denied"
+        except Exception as e:
+            return False, str(e)
+    except Exception as e:
+        return False, str(e)
+
+
+@register_check(
+    id="permissions_home_praison",
+    title="~/.praison Directory",
+    description="Check ~/.praison directory permissions",
+    category=CheckCategory.PERMISSIONS,
+    severity=CheckSeverity.MEDIUM,
+)
+def check_permissions_home_praison(config: DoctorConfig) -> CheckResult:
+    """Check ~/.praison directory permissions."""
+    praison_dir = Path.home() / ".praison"
+    
+    if not praison_dir.exists():
+        # Try to create it
+        try:
+            praison_dir.mkdir(parents=True, exist_ok=True)
+            return CheckResult(
+                id="permissions_home_praison",
+                title="~/.praison Directory",
+                category=CheckCategory.PERMISSIONS,
+                status=CheckStatus.PASS,
+                message="~/.praison created successfully",
+                metadata={"path": str(praison_dir)},
+            )
+        except PermissionError:
+            return CheckResult(
+                id="permissions_home_praison",
+                title="~/.praison Directory",
+                category=CheckCategory.PERMISSIONS,
+                status=CheckStatus.FAIL,
+                message="Cannot create ~/.praison directory",
+                remediation="Check home directory permissions",
+                severity=CheckSeverity.HIGH,
+            )
+    
+    writable, reason = _check_dir_writable(praison_dir)
+    
+    if writable:
+        return CheckResult(
+            id="permissions_home_praison",
+            title="~/.praison Directory",
+            category=CheckCategory.PERMISSIONS,
+            status=CheckStatus.PASS,
+            message=f"~/.praison is writable",
+            metadata={"path": str(praison_dir)},
+        )
+    else:
+        return CheckResult(
+            id="permissions_home_praison",
+            title="~/.praison Directory",
+            category=CheckCategory.PERMISSIONS,
+            status=CheckStatus.FAIL,
+            message=f"~/.praison is not writable: {reason}",
+            remediation="Fix permissions: chmod 755 ~/.praison",
+            severity=CheckSeverity.HIGH,
+        )
+
+
+@register_check(
+    id="permissions_project_praison",
+    title=".praison Directory (Project)",
+    description="Check project .praison directory permissions",
+    category=CheckCategory.PERMISSIONS,
+    severity=CheckSeverity.LOW,
+)
+def check_permissions_project_praison(config: DoctorConfig) -> CheckResult:
+    """Check project .praison directory permissions."""
+    praison_dir = Path.cwd() / ".praison"
+    
+    if not praison_dir.exists():
+        return CheckResult(
+            id="permissions_project_praison",
+            title=".praison Directory (Project)",
+            category=CheckCategory.PERMISSIONS,
+            status=CheckStatus.SKIP,
+            message="No .praison directory in current project",
+        )
+    
+    writable, reason = _check_dir_writable(praison_dir)
+    
+    if writable:
+        return CheckResult(
+            id="permissions_project_praison",
+            title=".praison Directory (Project)",
+            category=CheckCategory.PERMISSIONS,
+            status=CheckStatus.PASS,
+            message=".praison is writable",
+            metadata={"path": str(praison_dir)},
+        )
+    else:
+        return CheckResult(
+            id="permissions_project_praison",
+            title=".praison Directory (Project)",
+            category=CheckCategory.PERMISSIONS,
+            status=CheckStatus.WARN,
+            message=f".praison is not writable: {reason}",
+            remediation="Fix permissions or use ~/.praison instead",
+        )
+
+
+@register_check(
+    id="permissions_temp_dir",
+    title="Temp Directory",
+    description="Check temp directory permissions",
+    category=CheckCategory.PERMISSIONS,
+    severity=CheckSeverity.MEDIUM,
+)
+def check_permissions_temp_dir(config: DoctorConfig) -> CheckResult:
+    """Check temp directory permissions."""
+    temp_dir = Path(tempfile.gettempdir())
+    
+    try:
+        # Try to create a temp file
+        with tempfile.NamedTemporaryFile(delete=True) as f:
+            f.write(b"test")
+        
+        return CheckResult(
+            id="permissions_temp_dir",
+            title="Temp Directory",
+            category=CheckCategory.PERMISSIONS,
+            status=CheckStatus.PASS,
+            message=f"Temp directory writable: {temp_dir}",
+            metadata={"path": str(temp_dir)},
+        )
+    except Exception as e:
+        return CheckResult(
+            id="permissions_temp_dir",
+            title="Temp Directory",
+            category=CheckCategory.PERMISSIONS,
+            status=CheckStatus.FAIL,
+            message=f"Temp directory not writable: {e}",
+            remediation="Check TMPDIR environment variable and permissions",
+            severity=CheckSeverity.HIGH,
+        )
+
+
+@register_check(
+    id="permissions_cwd",
+    title="Current Working Directory",
+    description="Check current directory permissions",
+    category=CheckCategory.PERMISSIONS,
+    severity=CheckSeverity.INFO,
+)
+def check_permissions_cwd(config: DoctorConfig) -> CheckResult:
+    """Check current directory permissions."""
+    cwd = Path.cwd()
+    
+    writable, reason = _check_dir_writable(cwd)
+    
+    if writable:
+        return CheckResult(
+            id="permissions_cwd",
+            title="Current Working Directory",
+            category=CheckCategory.PERMISSIONS,
+            status=CheckStatus.PASS,
+            message=f"Current directory writable: {cwd}",
+        )
+    else:
+        return CheckResult(
+            id="permissions_cwd",
+            title="Current Working Directory",
+            category=CheckCategory.PERMISSIONS,
+            status=CheckStatus.WARN,
+            message=f"Current directory not writable: {reason}",
+            details="Some features may not work without write access",
+        )
+
+
+@register_check(
+    id="permissions_config_dir",
+    title="Config Directory",
+    description="Check ~/.config/praison directory",
+    category=CheckCategory.PERMISSIONS,
+    severity=CheckSeverity.LOW,
+)
+def check_permissions_config_dir(config: DoctorConfig) -> CheckResult:
+    """Check ~/.config/praison directory."""
+    config_dir = Path.home() / ".config" / "praison"
+    
+    if not config_dir.exists():
+        # Check if we can create it
+        try:
+            config_dir.mkdir(parents=True, exist_ok=True)
+            return CheckResult(
+                id="permissions_config_dir",
+                title="Config Directory",
+                category=CheckCategory.PERMISSIONS,
+                status=CheckStatus.PASS,
+                message="~/.config/praison created successfully",
+            )
+        except Exception:
+            return CheckResult(
+                id="permissions_config_dir",
+                title="Config Directory",
+                category=CheckCategory.PERMISSIONS,
+                status=CheckStatus.SKIP,
+                message="~/.config/praison does not exist (will use ~/.praison)",
+            )
+    
+    writable, reason = _check_dir_writable(config_dir)
+    
+    if writable:
+        return CheckResult(
+            id="permissions_config_dir",
+            title="Config Directory",
+            category=CheckCategory.PERMISSIONS,
+            status=CheckStatus.PASS,
+            message="~/.config/praison is writable",
+        )
+    else:
+        return CheckResult(
+            id="permissions_config_dir",
+            title="Config Directory",
+            category=CheckCategory.PERMISSIONS,
+            status=CheckStatus.WARN,
+            message=f"~/.config/praison not writable: {reason}",
+        )

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

@@ -0,0 +1,322 @@
+"""
+Selftest checks for the Doctor CLI module.
+
+Performs minimal agent dry-run to validate the system.
+"""
+
+import os
+
+from ..models import (
+    CheckCategory,
+    CheckResult,
+    CheckStatus,
+    CheckSeverity,
+    DoctorConfig,
+)
+from ..registry import register_check
+
+
+@register_check(
+    id="selftest_agent_import",
+    title="Agent Import",
+    description="Check Agent class can be imported",
+    category=CheckCategory.SELFTEST,
+    severity=CheckSeverity.HIGH,
+)
+def check_selftest_agent_import(config: DoctorConfig) -> CheckResult:
+    """Check Agent class can be imported."""
+    try:
+        from praisonaiagents import Agent
+        return CheckResult(
+            id="selftest_agent_import",
+            title="Agent Import",
+            category=CheckCategory.SELFTEST,
+            status=CheckStatus.PASS,
+            message="Agent class imported successfully",
+        )
+    except ImportError as e:
+        return CheckResult(
+            id="selftest_agent_import",
+            title="Agent Import",
+            category=CheckCategory.SELFTEST,
+            status=CheckStatus.FAIL,
+            message=f"Cannot import Agent: {e}",
+            remediation="Ensure praisonaiagents is properly installed",
+            severity=CheckSeverity.CRITICAL,
+        )
+
+
+@register_check(
+    id="selftest_agent_create",
+    title="Agent Creation",
+    description="Check Agent can be instantiated",
+    category=CheckCategory.SELFTEST,
+    severity=CheckSeverity.HIGH,
+    dependencies=["selftest_agent_import"],
+)
+def check_selftest_agent_create(config: DoctorConfig) -> CheckResult:
+    """Check Agent can be instantiated."""
+    try:
+        from praisonaiagents import Agent
+        
+        # Create a minimal agent without making API calls
+        agent = Agent(
+            name="DoctorTestAgent",
+            instructions="You are a test agent.",
+            llm="gpt-4o-mini",  # Default model
+            verbose=False,
+        )
+        
+        return CheckResult(
+            id="selftest_agent_create",
+            title="Agent Creation",
+            category=CheckCategory.SELFTEST,
+            status=CheckStatus.PASS,
+            message="Agent instantiated successfully",
+            metadata={"agent_name": agent.name},
+        )
+    except Exception as e:
+        return CheckResult(
+            id="selftest_agent_create",
+            title="Agent Creation",
+            category=CheckCategory.SELFTEST,
+            status=CheckStatus.FAIL,
+            message=f"Agent creation failed: {type(e).__name__}",
+            details=str(e)[:200],
+            remediation="Check configuration and dependencies",
+            severity=CheckSeverity.HIGH,
+        )
+
+
+@register_check(
+    id="selftest_llm_config",
+    title="LLM Configuration",
+    description="Check LLM configuration is valid",
+    category=CheckCategory.SELFTEST,
+    severity=CheckSeverity.MEDIUM,
+)
+def check_selftest_llm_config(config: DoctorConfig) -> CheckResult:
+    """Check LLM configuration is valid."""
+    # Check for API key
+    openai_key = os.environ.get("OPENAI_API_KEY")
+    anthropic_key = os.environ.get("ANTHROPIC_API_KEY")
+    google_key = os.environ.get("GOOGLE_API_KEY") or os.environ.get("GEMINI_API_KEY")
+    ollama_host = os.environ.get("OLLAMA_HOST")
+    
+    providers = []
+    if openai_key:
+        providers.append("OpenAI")
+    if anthropic_key:
+        providers.append("Anthropic")
+    if google_key:
+        providers.append("Google")
+    if ollama_host:
+        providers.append("Ollama")
+    
+    if providers:
+        return CheckResult(
+            id="selftest_llm_config",
+            title="LLM Configuration",
+            category=CheckCategory.SELFTEST,
+            status=CheckStatus.PASS,
+            message=f"LLM provider(s) configured: {', '.join(providers)}",
+            metadata={"providers": providers},
+        )
+    else:
+        return CheckResult(
+            id="selftest_llm_config",
+            title="LLM Configuration",
+            category=CheckCategory.SELFTEST,
+            status=CheckStatus.FAIL,
+            message="No LLM provider configured",
+            remediation="Set OPENAI_API_KEY or another provider's API key",
+            severity=CheckSeverity.HIGH,
+        )
+
+
+@register_check(
+    id="selftest_mock_chat",
+    title="Mock Chat Test",
+    description="Test agent chat with mock response",
+    category=CheckCategory.SELFTEST,
+    severity=CheckSeverity.MEDIUM,
+    requires_deep=True,
+)
+def check_selftest_mock_chat(config: DoctorConfig) -> CheckResult:
+    """Test agent chat with mock response (no API call)."""
+    if not config.mock and not config.live:
+        # Default to mock in deep mode
+        config.mock = True
+    
+    if config.live:
+        return CheckResult(
+            id="selftest_mock_chat",
+            title="Mock Chat Test",
+            category=CheckCategory.SELFTEST,
+            status=CheckStatus.SKIP,
+            message="Skipped (--live mode uses live API)",
+        )
+    
+    try:
+        # Test basic agent functionality without making API calls
+        from praisonaiagents import Agent
+        
+        agent = Agent(
+            name="MockTestAgent",
+            instructions="You are a test agent. Always respond with 'OK'.",
+            llm="gpt-4o-mini",
+            verbose=False,
+        )
+        
+        # Verify agent is properly configured
+        if hasattr(agent, 'name') and hasattr(agent, 'instructions'):
+            return CheckResult(
+                id="selftest_mock_chat",
+                title="Mock Chat Test",
+                category=CheckCategory.SELFTEST,
+                status=CheckStatus.PASS,
+                message="Agent mock test passed",
+            )
+        else:
+            return CheckResult(
+                id="selftest_mock_chat",
+                title="Mock Chat Test",
+                category=CheckCategory.SELFTEST,
+                status=CheckStatus.FAIL,
+                message="Agent missing expected attributes",
+            )
+    except Exception as e:
+        return CheckResult(
+            id="selftest_mock_chat",
+            title="Mock Chat Test",
+            category=CheckCategory.SELFTEST,
+            status=CheckStatus.FAIL,
+            message=f"Mock test failed: {type(e).__name__}",
+            details=str(e)[:200],
+        )
+
+
+@register_check(
+    id="selftest_live_chat",
+    title="Live Chat Test",
+    description="Test agent chat with live API call",
+    category=CheckCategory.SELFTEST,
+    severity=CheckSeverity.LOW,
+    requires_deep=True,
+)
+def check_selftest_live_chat(config: DoctorConfig) -> CheckResult:
+    """Test agent chat with live API call."""
+    if not config.live:
+        return CheckResult(
+            id="selftest_live_chat",
+            title="Live Chat Test",
+            category=CheckCategory.SELFTEST,
+            status=CheckStatus.SKIP,
+            message="Skipped (use --live to enable)",
+        )
+    
+    # Check for API key first
+    if not os.environ.get("OPENAI_API_KEY"):
+        return CheckResult(
+            id="selftest_live_chat",
+            title="Live Chat Test",
+            category=CheckCategory.SELFTEST,
+            status=CheckStatus.SKIP,
+            message="Skipped (OPENAI_API_KEY not set)",
+        )
+    
+    try:
+        from praisonaiagents import Agent
+        
+        model = config.model or "gpt-4o-mini"
+        
+        agent = Agent(
+            name="LiveTestAgent",
+            instructions="You are a test agent. Respond with exactly: 'Doctor test OK'",
+            llm=model,
+            verbose=False,
+        )
+        
+        # Make a simple API call
+        response = agent.chat("Say hello")
+        
+        if response:
+            return CheckResult(
+                id="selftest_live_chat",
+                title="Live Chat Test",
+                category=CheckCategory.SELFTEST,
+                status=CheckStatus.PASS,
+                message=f"Live API call successful (model: {model})",
+                metadata={"model": model, "response_length": len(str(response))},
+            )
+        else:
+            return CheckResult(
+                id="selftest_live_chat",
+                title="Live Chat Test",
+                category=CheckCategory.SELFTEST,
+                status=CheckStatus.FAIL,
+                message="Live API call returned empty response",
+            )
+    except Exception as e:
+        return CheckResult(
+            id="selftest_live_chat",
+            title="Live Chat Test",
+            category=CheckCategory.SELFTEST,
+            status=CheckStatus.FAIL,
+            message=f"Live API call failed: {type(e).__name__}",
+            details=str(e)[:200],
+            remediation="Check API key and network connectivity",
+        )
+
+
+@register_check(
+    id="selftest_tools_wiring",
+    title="Tools Wiring",
+    description="Check tools can be wired to agent",
+    category=CheckCategory.SELFTEST,
+    severity=CheckSeverity.LOW,
+)
+def check_selftest_tools_wiring(config: DoctorConfig) -> CheckResult:
+    """Check tools can be wired to agent."""
+    try:
+        from praisonaiagents import Agent
+        
+        # Define a simple test tool
+        def test_tool(x: str) -> str:
+            """A test tool that echoes input."""
+            return f"Echo: {x}"
+        
+        agent = Agent(
+            name="ToolTestAgent",
+            instructions="You are a test agent with tools.",
+            tools=[test_tool],
+            llm="gpt-4o-mini",
+            verbose=False,
+        )
+        
+        # Check tools are registered
+        if hasattr(agent, 'tools') or hasattr(agent, '_tools'):
+            return CheckResult(
+                id="selftest_tools_wiring",
+                title="Tools Wiring",
+                category=CheckCategory.SELFTEST,
+                status=CheckStatus.PASS,
+                message="Tools wired to agent successfully",
+            )
+        else:
+            return CheckResult(
+                id="selftest_tools_wiring",
+                title="Tools Wiring",
+                category=CheckCategory.SELFTEST,
+                status=CheckStatus.WARN,
+                message="Tools wiring could not be verified",
+            )
+    except Exception as e:
+        return CheckResult(
+            id="selftest_tools_wiring",
+            title="Tools Wiring",
+            category=CheckCategory.SELFTEST,
+            status=CheckStatus.FAIL,
+            message=f"Tools wiring failed: {type(e).__name__}",
+            details=str(e)[:200],
+        )