praisonai-code 0.0.1__py3-none-any.whl

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

@@ -0,0 +1,220 @@
+"""
+Runtime configuration migration checks.
+
+Checks for legacy cli_backend configuration and provides migration to
+the new model-scoped runtime configuration.
+"""
+
+import os
+import yaml
+import json
+import shutil
+import copy
+from pathlib import Path
+from typing import Dict, List, Optional, Union
+from datetime import datetime
+
+from ..models import CheckCategory, CheckResult, CheckStatus, CheckSeverity, DoctorConfig
+from ..registry import register_check
+
+
+def _find_config_file(config_file: Optional[str] = None) -> Optional[Path]:
+    """Find the configuration file to check."""
+    if config_file:
+        path = Path(config_file)
+        return path if path.exists() else None
+    
+    # Search for common config files
+    current_dir = Path.cwd()
+    for filename in ["agents.yaml", "agents.yml", "config.yaml", "config.yml"]:
+        path = current_dir / filename
+        if path.exists():
+            return path
+    
+    return None
+
+
+def _load_config(config_path: Path) -> Dict:
+    """Load configuration from YAML file."""
+    try:
+        with open(config_path, 'r', encoding='utf-8') as f:
+            return yaml.safe_load(f) or {}
+    except Exception as e:
+        raise ValueError(f"Failed to load config file: {e}")
+
+
+def _save_config(config_path: Path, config: Dict, create_backup: bool = True) -> str:
+    """Save configuration to YAML file with optional backup."""
+    backup_info = ""
+    
+    # Serialize first to ensure it's valid YAML
+    try:
+        yaml_content = yaml.dump(config, default_flow_style=False, sort_keys=False, indent=2)
+    except Exception as e:
+        raise ValueError(f"Failed to serialize configuration to YAML: {e}")
+    
+    if create_backup:
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        backup_path = config_path.with_name(f"{config_path.stem}.backup.{timestamp}.yaml")
+        shutil.copy2(config_path, backup_path)
+        backup_info = f" (backup: {backup_path.name})"
+    
+    with open(config_path, 'w', encoding='utf-8') as f:
+        f.write(yaml_content)
+    
+    return backup_info
+
+
+@register_check(
+    id="runtime.config_migration",
+    title="Runtime Configuration Migration",
+    description="Check for legacy cli_backend configuration and migrate to model-scoped runtime",
+    category=CheckCategory.RUNTIME
+)
+def check_runtime_config_migration(config: DoctorConfig) -> CheckResult:
+    """
+    Check for legacy cli_backend configuration and provide migration path.
+    
+    Args:
+        config: DoctorConfig instance with fix and execute flags
+    """
+    try:
+        config_path = _find_config_file(config.config_file)
+        
+        # If user specified a file and it doesn't exist, return ERROR
+        if config.config_file and not config_path:
+            return CheckResult(
+                id="runtime.config_file_found",
+                title="Configuration File Check",
+                category=CheckCategory.RUNTIME,
+                status=CheckStatus.ERROR,
+                message=f"Specified configuration file not found: {config.config_file}",
+                severity=CheckSeverity.HIGH
+            )
+        elif not config_path:
+            return CheckResult(
+                id="runtime.config_file_found",
+                title="Configuration File Check",
+                category=CheckCategory.RUNTIME,
+                status=CheckStatus.SKIP,
+                message="No configuration file found to check",
+                details="Searched for: agents.yaml, agents.yml, config.yaml, config.yml in current directory",
+                severity=CheckSeverity.INFO
+            )
+        
+        # Load configuration
+        try:
+            yaml_config = _load_config(config_path)
+        except ValueError as e:
+            return CheckResult(
+                id="runtime.config_load",
+                title="Configuration Load",
+                category=CheckCategory.RUNTIME,
+                status=CheckStatus.ERROR,
+                message=f"Failed to load configuration file: {e}",
+                severity=CheckSeverity.HIGH
+            )
+        
+        # Import the migration functionality from praisonaiagents
+        try:
+            from praisonaiagents.runtime import collect_findings, apply_fixes
+        except ImportError as e:
+            return CheckResult(
+                id="runtime.config_migration",
+                title="Runtime Configuration Migration",
+                category=CheckCategory.RUNTIME,
+                status=CheckStatus.ERROR,
+                message=f"Could not import migration tools: {e}",
+                details="Ensure praisonaiagents is installed: pip install praisonaiagents",
+                severity=CheckSeverity.HIGH
+            )
+        
+        # Collect findings from all registered rules
+        findings = collect_findings(yaml_config)
+        
+        if not findings:
+            return CheckResult(
+                id="runtime.config_migration",
+                title="Runtime Configuration Migration",
+                category=CheckCategory.RUNTIME,
+                status=CheckStatus.PASS,
+                message=f"Configuration is up to date: {config_path.name}",
+                details="No legacy cli_backend fields found",
+                severity=CheckSeverity.INFO
+            )
+        
+        # Prepare details about findings
+        details = []
+        for finding in findings:
+            details.append(f"• {finding.description}")
+            if finding.details:
+                details.append(f"  {finding.details}")
+        
+        # If not fixing, just report findings
+        if not config.fix:
+            return CheckResult(
+                id="runtime.config_migration",
+                title="Runtime Configuration Migration",
+                category=CheckCategory.RUNTIME,
+                status=CheckStatus.WARN,
+                message=f"Found {len(findings)} legacy configuration(s) in {config_path.name}",
+                details="\n".join(details),
+                severity=CheckSeverity.MEDIUM,
+                fix_suggestion="Run 'praisonai doctor runtime --fix' to migrate automatically"
+            )
+        
+        # Apply fixes (dry-run or execute)
+        try:
+            migrated_config = apply_fixes(yaml_config)
+            
+            # Show what would be changed
+            if config.fix and not config.execute:
+                # Dry-run mode
+                preview = []
+                preview.append(f"Would migrate {len(findings)} legacy configuration(s):")
+                preview.extend(details)
+                preview.append("\nTo apply changes, run with --fix --execute")
+                
+                return CheckResult(
+                    id="runtime.config_migration",
+                    title="Runtime Configuration Migration (Dry-Run)",
+                    category=CheckCategory.RUNTIME,
+                    status=CheckStatus.INFO,
+                    message=f"Preview of changes for {config_path.name}",
+                    details="\n".join(preview),
+                    severity=CheckSeverity.INFO
+                )
+            
+            # Execute the migration
+            if config.fix and config.execute:
+                backup_info = _save_config(config_path, migrated_config)
+                
+                return CheckResult(
+                    id="runtime.config_migration",
+                    title="Runtime Configuration Migration",
+                    category=CheckCategory.RUNTIME,
+                    status=CheckStatus.PASS,
+                    message=f"Successfully migrated {len(findings)} legacy configuration(s)",
+                    details=f"Updated: {config_path.name}{backup_info}",
+                    severity=CheckSeverity.INFO
+                )
+            
+        except Exception as e:
+            return CheckResult(
+                id="runtime.config_migration",
+                title="Runtime Configuration Migration",
+                category=CheckCategory.RUNTIME,
+                status=CheckStatus.ERROR,
+                message=f"Failed to apply migration: {e}",
+                severity=CheckSeverity.HIGH
+            )
+    
+    except Exception as e:
+        return CheckResult(
+            id="runtime.config_migration",
+            title="Runtime Configuration Migration",
+            category=CheckCategory.RUNTIME,
+            status=CheckStatus.ERROR,
+            message=f"Runtime migration check failed: {e}",
+            severity=CheckSeverity.HIGH
+        )

praisonai_code/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
+            output="minimal",
+        )
+        
+        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",
+            output="minimal",
+        )
+        
+        # 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,
+            output="minimal",
+        )
+        
+        # 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",
+            output="minimal",
+        )
+        
+        # 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],
+        )