PraisonAI 3.0.0__py3-none-any.whl

praisonai/cli/features/diag.py

@@ -0,0 +1,289 @@
+"""
+Diagnostics export CLI handler for PraisonAI.
+
+Provides diagnostic export functionality:
+- diag export: Bundle logs, traces, config for bug reports
+"""
+
+import argparse
+import json
+import logging
+import os
+import shutil
+import tempfile
+import time
+import zipfile
+from pathlib import Path
+from typing import List
+
+logger = logging.getLogger(__name__)
+
+
+class DiagHandler:
+    """Handler for diag CLI commands."""
+    
+    @staticmethod
+    def setup_subparser(subparsers) -> None:
+        """Set up the diag subcommand parser."""
+        diag_parser = subparsers.add_parser(
+            "diag",
+            help="Diagnostics export",
+            description="Export diagnostic information for bug reports"
+        )
+        
+        diag_subparsers = diag_parser.add_subparsers(dest="diag_command", help="Diag subcommands")
+        
+        # diag export
+        export_parser = diag_subparsers.add_parser("export", help="Export diagnostic bundle")
+        export_parser.add_argument(
+            "-o", "--output",
+            type=str,
+            help="Output path (default: praisonai-diag-{timestamp}.zip)"
+        )
+        export_parser.add_argument(
+            "--include-logs",
+            action="store_true",
+            default=True,
+            help="Include log files (default: true)"
+        )
+        export_parser.add_argument(
+            "--include-config",
+            action="store_true",
+            default=True,
+            help="Include configuration (default: true)"
+        )
+        export_parser.add_argument(
+            "--include-trace",
+            action="store_true",
+            default=True,
+            help="Include recent traces (default: true)"
+        )
+        export_parser.add_argument(
+            "--workspace", "-w",
+            type=str,
+            default=".",
+            help="Workspace root directory"
+        )
+        export_parser.add_argument("--json", action="store_true", help="Output JSON")
+        export_parser.set_defaults(func=DiagHandler.handle_export)
+    
+    @staticmethod
+    def handle_export(args: argparse.Namespace) -> int:
+        """Handle diag export command."""
+        timestamp = int(time.time())
+        output_path = args.output or f"praisonai-diag-{timestamp}.zip"
+        
+        collected_files = []
+        
+        with tempfile.TemporaryDirectory() as tmpdir:
+            tmppath = Path(tmpdir)
+            
+            # Collect system info
+            system_info = DiagHandler._collect_system_info()
+            system_file = tmppath / "system_info.json"
+            with open(system_file, "w") as f:
+                json.dump(system_info, f, indent=2, default=str)
+            collected_files.append("system_info.json")
+            
+            # Collect config
+            if args.include_config:
+                config_files = DiagHandler._collect_config(args.workspace, tmppath)
+                collected_files.extend(config_files)
+            
+            # Collect logs
+            if args.include_logs:
+                log_files = DiagHandler._collect_logs(tmppath)
+                collected_files.extend(log_files)
+            
+            # Collect traces
+            if args.include_trace:
+                trace_files = DiagHandler._collect_traces(args.workspace, tmppath)
+                collected_files.extend(trace_files)
+            
+            # Create zip
+            with zipfile.ZipFile(output_path, 'w', zipfile.ZIP_DEFLATED) as zf:
+                for file in tmppath.rglob("*"):
+                    if file.is_file():
+                        arcname = file.relative_to(tmppath)
+                        zf.write(file, arcname)
+        
+        result = {
+            "action": "export",
+            "output": output_path,
+            "files_collected": collected_files,
+            "count": len(collected_files)
+        }
+        
+        DiagHandler._output_result(result, args.json)
+        return 0
+    
+    @staticmethod
+    def _collect_system_info() -> dict:
+        """Collect system information."""
+        import platform
+        import sys
+        
+        info = {
+            "timestamp": time.time(),
+            "platform": {
+                "system": platform.system(),
+                "release": platform.release(),
+                "version": platform.version(),
+                "machine": platform.machine(),
+                "python_version": sys.version
+            },
+            "praisonai": {}
+        }
+        
+        # Get PraisonAI version
+        try:
+            from praisonai.version import __version__
+            info["praisonai"]["version"] = __version__
+        except ImportError:
+            info["praisonai"]["version"] = "unknown"
+        
+        # Get praisonaiagents version
+        try:
+            import praisonaiagents
+            info["praisonai"]["agents_version"] = getattr(praisonaiagents, '__version__', 'unknown')
+        except ImportError:
+            info["praisonai"]["agents_version"] = "not installed"
+        
+        # Check for optional dependencies
+        info["dependencies"] = {}
+        for dep in ["acp", "litellm", "openai", "anthropic", "google.generativeai"]:
+            try:
+                __import__(dep.split(".")[0])
+                info["dependencies"][dep] = "installed"
+            except ImportError:
+                info["dependencies"][dep] = "not installed"
+        
+        # Environment (redacted)
+        env_keys = [
+            "OPENAI_API_KEY", "ANTHROPIC_API_KEY", "GOOGLE_API_KEY",
+            "PRAISONAI_APPROVAL_MODE", "LOGLEVEL"
+        ]
+        info["environment"] = {}
+        for key in env_keys:
+            value = os.environ.get(key)
+            if value:
+                if "KEY" in key or "SECRET" in key:
+                    info["environment"][key] = f"{value[:4]}...{value[-4:]}" if len(value) > 8 else "***"
+                else:
+                    info["environment"][key] = value
+            else:
+                info["environment"][key] = None
+        
+        return info
+    
+    @staticmethod
+    def _collect_config(workspace: str, tmppath: Path) -> List[str]:
+        """Collect configuration files."""
+        collected = []
+        workspace_path = Path(workspace)
+        config_dir = tmppath / "config"
+        config_dir.mkdir(exist_ok=True)
+        
+        # Look for config files
+        config_patterns = [
+            "agents.yaml",
+            "workflow.yaml",
+            ".praisonai.yaml",
+            ".env.example",  # Not .env to avoid secrets
+            "pyproject.toml",
+        ]
+        
+        for pattern in config_patterns:
+            for file in workspace_path.glob(pattern):
+                if file.is_file():
+                    dest = config_dir / file.name
+                    shutil.copy(file, dest)
+                    collected.append(f"config/{file.name}")
+        
+        return collected
+    
+    @staticmethod
+    def _collect_logs(tmppath: Path) -> List[str]:
+        """Collect log files."""
+        collected = []
+        logs_dir = tmppath / "logs"
+        logs_dir.mkdir(exist_ok=True)
+        
+        # Look for log files in common locations
+        log_locations = [
+            Path.home() / ".praison" / "logs",
+            Path.home() / ".praisonai" / "logs",
+            Path("/var/log/praisonai"),
+        ]
+        
+        for log_dir in log_locations:
+            if log_dir.exists():
+                for log_file in log_dir.glob("*.log"):
+                    if log_file.is_file():
+                        dest = logs_dir / log_file.name
+                        # Only copy last 1000 lines
+                        try:
+                            with open(log_file) as f:
+                                lines = f.readlines()[-1000:]
+                            with open(dest, "w") as f:
+                                f.writelines(lines)
+                            collected.append(f"logs/{log_file.name}")
+                        except Exception:
+                            pass
+        
+        return collected
+    
+    @staticmethod
+    def _collect_traces(workspace: str, tmppath: Path) -> List[str]:
+        """Collect trace files."""
+        collected = []
+        traces_dir = tmppath / "traces"
+        traces_dir.mkdir(exist_ok=True)
+        
+        workspace_path = Path(workspace)
+        
+        # Look for trace files
+        trace_patterns = ["*_trace.json", "praisonai_trace*.json", "*.trace"]
+        
+        for pattern in trace_patterns:
+            for trace_file in workspace_path.glob(pattern):
+                if trace_file.is_file():
+                    dest = traces_dir / trace_file.name
+                    shutil.copy(trace_file, dest)
+                    collected.append(f"traces/{trace_file.name}")
+        
+        return collected
+    
+    @staticmethod
+    def _output_result(result: dict, as_json: bool) -> None:
+        """Output result in appropriate format."""
+        if as_json:
+            print(json.dumps(result, indent=2, default=str))
+        else:
+            print(f"Diagnostic bundle created: {result['output']}")
+            print(f"Files collected: {result['count']}")
+            for f in result['files_collected']:
+                print(f"  - {f}")
+
+
+def run_diag_command(args: List[str]) -> int:
+    """Run diag command from CLI."""
+    parser = argparse.ArgumentParser(prog="praisonai diag")
+    subparsers = parser.add_subparsers(dest="diag_command", help="Diag subcommands")
+    
+    # diag export
+    export_parser = subparsers.add_parser("export", help="Export diagnostic bundle")
+    export_parser.add_argument("-o", "--output", type=str)
+    export_parser.add_argument("--include-logs", action="store_true", default=True)
+    export_parser.add_argument("--include-config", action="store_true", default=True)
+    export_parser.add_argument("--include-trace", action="store_true", default=True)
+    export_parser.add_argument("--workspace", "-w", type=str, default=".")
+    export_parser.add_argument("--json", action="store_true")
+    export_parser.set_defaults(func=DiagHandler.handle_export)
+    
+    parsed = parser.parse_args(args)
+    if hasattr(parsed, 'func'):
+        return parsed.func(parsed)
+    else:
+        parser.print_help()
+        return 0

praisonai/cli/features/doctor/__init__.py

@@ -0,0 +1,63 @@
+"""
+Doctor CLI module for PraisonAI.
+
+Provides comprehensive health checks, diagnostics, and validation for the PraisonAI ecosystem.
+
+Commands:
+    praisonai doctor              - Run fast default checks
+    praisonai doctor env          - Environment and API key validation
+    praisonai doctor config       - Configuration file validation
+    praisonai doctor tools        - Tool availability checks
+    praisonai doctor db           - Database connectivity checks
+    praisonai doctor mcp          - MCP server validation
+    praisonai doctor obs          - Observability provider checks
+    praisonai doctor skills       - Agent skills validation
+    praisonai doctor memory       - Memory/session storage checks
+    praisonai doctor permissions  - Filesystem permission checks
+    praisonai doctor network      - Network connectivity checks
+    praisonai doctor performance  - Import time analysis
+    praisonai doctor ci           - CI-optimized checks
+    praisonai doctor selftest     - Minimal agent dry-run
+"""
+
+__version__ = "1.0.0"
+
+__all__ = [
+    "DoctorHandler",
+    "DoctorEngine",
+    "CheckResult",
+    "CheckStatus",
+    "DoctorReport",
+    "CheckRegistry",
+    "TextFormatter",
+    "JsonFormatter",
+]
+
+
+def __getattr__(name: str):
+    """Lazy load doctor components to minimize import overhead."""
+    if name == "DoctorHandler":
+        from .handler import DoctorHandler
+        return DoctorHandler
+    elif name == "DoctorEngine":
+        from .engine import DoctorEngine
+        return DoctorEngine
+    elif name == "CheckResult":
+        from .models import CheckResult
+        return CheckResult
+    elif name == "CheckStatus":
+        from .models import CheckStatus
+        return CheckStatus
+    elif name == "DoctorReport":
+        from .models import DoctorReport
+        return DoctorReport
+    elif name == "CheckRegistry":
+        from .registry import CheckRegistry
+        return CheckRegistry
+    elif name == "TextFormatter":
+        from .formatters import TextFormatter
+        return TextFormatter
+    elif name == "JsonFormatter":
+        from .formatters import JsonFormatter
+        return JsonFormatter
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

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

@@ -0,0 +1,24 @@
+"""
+Doctor checks package.
+
+Contains all individual check implementations organized by category.
+"""
+
+# Import all check modules to register them
+def register_all_checks():
+    """Register all doctor checks."""
+    from . import env_checks
+    from . import config_checks
+    from . import tools_checks
+    from . import db_checks
+    from . import mcp_checks
+    from . import obs_checks
+    from . import skills_checks
+    from . import memory_checks
+    from . import permissions_checks
+    from . import network_checks
+    from . import performance_checks
+    from . import selftest_checks
+    from . import serve_checks
+    from . import lsp_checks
+    from . import acp_checks

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

@@ -0,0 +1,240 @@
+"""
+ACP health checks for PraisonAI Doctor.
+"""
+
+import asyncio
+import logging
+
+from ..models import CheckCategory, CheckResult, CheckStatus
+from ..registry import register_check
+
+logger = logging.getLogger(__name__)
+
+
+@register_check(
+    id="acp_module",
+    title="ACP Module Available",
+    category=CheckCategory.TOOLS,
+    description="Check if ACP module is installed"
+)
+def check_acp_module() -> CheckResult:
+    """Check if ACP module is available."""
+    try:
+        import importlib.util
+        spec = importlib.util.find_spec("praisonai.acp")
+        
+        if spec is not None:
+            return CheckResult(
+                status=CheckStatus.PASS,
+                message="ACP module is available",
+                details={"module": "praisonai.acp"}
+            )
+        else:
+            return CheckResult(
+                status=CheckStatus.WARN,
+                message="ACP module not found",
+                details={"hint": "ACP module should be part of praisonai package"}
+            )
+    except Exception as e:
+        return CheckResult(
+            status=CheckStatus.FAIL,
+            message=f"Error checking ACP module: {e}",
+            details={"error": str(e)}
+        )
+
+
+@register_check(
+    id="acp_sdk",
+    title="ACP SDK Available",
+    category=CheckCategory.TOOLS,
+    description="Check if agent-client-protocol SDK is installed"
+)
+def check_acp_sdk() -> CheckResult:
+    """Check if ACP SDK is available."""
+    try:
+        import importlib.util
+        spec = importlib.util.find_spec("acp")
+        
+        if spec is not None:
+            return CheckResult(
+                status=CheckStatus.PASS,
+                message="ACP SDK (agent-client-protocol) is installed",
+                details={"package": "agent-client-protocol"}
+            )
+        else:
+            return CheckResult(
+                status=CheckStatus.INFO,
+                message="ACP SDK not installed (optional)",
+                details={"hint": "Install with: pip install agent-client-protocol"}
+            )
+    except Exception as e:
+        return CheckResult(
+            status=CheckStatus.FAIL,
+            message=f"Error checking ACP SDK: {e}",
+            details={"error": str(e)}
+        )
+
+
+@register_check(
+    id="acp_server",
+    title="ACP Server Import",
+    category=CheckCategory.TOOLS,
+    description="Check if ACP server can be imported"
+)
+def check_acp_server() -> CheckResult:
+    """Check if ACP server can be imported."""
+    try:
+        from praisonai.acp import ACPServer  # noqa: F401
+        
+        return CheckResult(
+            status=CheckStatus.PASS,
+            message="ACP server can be imported",
+            details={"class": "ACPServer"}
+        )
+    except ImportError as e:
+        return CheckResult(
+            status=CheckStatus.WARN,
+            message=f"ACP server import failed: {e}",
+            details={"error": str(e)}
+        )
+    except Exception as e:
+        return CheckResult(
+            status=CheckStatus.FAIL,
+            message=f"Error importing ACP server: {e}",
+            details={"error": str(e)}
+        )
+
+
+@register_check(
+    id="acp_config",
+    title="ACP Configuration",
+    category=CheckCategory.CONFIG,
+    description="Check ACP configuration"
+)
+def check_acp_config() -> CheckResult:
+    """Check ACP configuration."""
+    import os
+    
+    config = {
+        "approval_mode": os.environ.get("PRAISONAI_APPROVAL_MODE", "manual"),
+        "allow_write": os.environ.get("PRAISONAI_ALLOW_WRITE", "false"),
+        "allow_shell": os.environ.get("PRAISONAI_ALLOW_SHELL", "false"),
+    }
+    
+    return CheckResult(
+        status=CheckStatus.PASS,
+        message=f"ACP configured with approval_mode={config['approval_mode']}",
+        details=config
+    )
+
+
+@register_check(
+    id="acp_runtime",
+    title="ACP Runtime Check",
+    category=CheckCategory.TOOLS,
+    description="Check if ACP runtime can start",
+    requires_deep=True
+)
+def check_acp_runtime() -> CheckResult:
+    """Check if ACP runtime can start."""
+    try:
+        from praisonai.cli.features.interactive_runtime import create_runtime
+        
+        async def _check():
+            runtime = create_runtime(
+                workspace=".",
+                lsp=False,
+                acp=True
+            )
+            try:
+                await runtime.start()
+                ready = runtime.acp_ready
+                error = runtime._acp_state.error
+                read_only = runtime.read_only
+                return ready, error, read_only
+            finally:
+                await runtime.stop()
+        
+        ready, error, read_only = asyncio.run(_check())
+        
+        if ready:
+            return CheckResult(
+                status=CheckStatus.PASS,
+                message="ACP runtime started successfully",
+                details={"ready": True, "read_only": read_only}
+            )
+        else:
+            return CheckResult(
+                status=CheckStatus.WARN,
+                message=f"ACP runtime failed to start: {error}",
+                details={"ready": False, "error": error, "read_only": read_only}
+            )
+            
+    except Exception as e:
+        return CheckResult(
+            status=CheckStatus.FAIL,
+            message=f"ACP runtime check failed: {e}",
+            details={"error": str(e)}
+        )
+
+
+@register_check(
+    id="interactive_runtime",
+    title="Interactive Runtime Check",
+    category=CheckCategory.TOOLS,
+    description="Check if full interactive runtime can start",
+    requires_deep=True
+)
+def check_interactive_runtime() -> CheckResult:
+    """Check if full interactive runtime can start."""
+    try:
+        from praisonai.cli.features.interactive_runtime import create_runtime
+        
+        async def _check():
+            runtime = create_runtime(
+                workspace=".",
+                lsp=True,
+                acp=True
+            )
+            try:
+                await runtime.start()
+                status = runtime.get_status()
+                return status
+            finally:
+                await runtime.stop()
+        
+        status = asyncio.run(_check())
+        
+        lsp_ready = status.get("lsp", {}).get("ready", False)
+        acp_ready = status.get("acp", {}).get("ready", False)
+        
+        if lsp_ready and acp_ready:
+            return CheckResult(
+                status=CheckStatus.PASS,
+                message="Interactive runtime fully operational",
+                details=status
+            )
+        elif lsp_ready or acp_ready:
+            return CheckResult(
+                status=CheckStatus.WARN,
+                message="Interactive runtime partially operational",
+                details=status
+            )
+        else:
+            return CheckResult(
+                status=CheckStatus.FAIL,
+                message="Interactive runtime failed to start",
+                details=status
+            )
+            
+    except Exception as e:
+        return CheckResult(
+            status=CheckStatus.FAIL,
+            message=f"Interactive runtime check failed: {e}",
+            details={"error": str(e)}
+        )
+
+
+def register_acp_checks():
+    """Register all ACP checks."""
+    pass