PraisonAI 3.0.0__py3-none-any.whl

praisonai/cli/features/lite.py

@@ -0,0 +1,244 @@
+"""
+Lite Agent Handler for CLI.
+
+Provides access to the lightweight praisonaiagents.lite subpackage.
+Usage: praisonai lite [run|info]
+"""
+
+import os
+from typing import Any, Dict, Tuple
+from .base import FlagHandler
+
+
+class LiteHandler(FlagHandler):
+    """
+    Handler for lite agent commands.
+    
+    The lite subpackage provides a minimal agent framework without heavy
+    dependencies like litellm. Users can bring their own LLM client.
+    
+    Commands:
+        praisonai lite run "prompt"     - Run a lite agent with custom LLM
+        praisonai lite info             - Show lite package info
+        praisonai lite example          - Show example usage
+    """
+    
+    @property
+    def feature_name(self) -> str:
+        return "lite"
+    
+    @property
+    def flag_name(self) -> str:
+        return "lite"
+    
+    @property
+    def flag_help(self) -> str:
+        return "Use lightweight agent without heavy dependencies"
+    
+    def check_dependencies(self) -> Tuple[bool, str]:
+        """Check if lite package is available."""
+        import importlib.util
+        if importlib.util.find_spec("praisonaiagents.lite") is not None:
+            return True, ""
+        return False, "Lite package requires praisonaiagents>=0.5.0"
+    
+    def get_info(self) -> Dict[str, Any]:
+        """
+        Get information about the lite package.
+        
+        Returns:
+            Dict with package info
+        """
+        import importlib.util
+        if importlib.util.find_spec("praisonaiagents.lite") is None:
+            return {
+                "available": False,
+                "error": "praisonaiagents.lite not found"
+            }
+        
+        return {
+            "available": True,
+            "classes": ["LiteAgent", "LiteTask", "LiteToolResult"],
+            "decorators": ["@tool"],
+            "helpers": ["create_openai_llm_fn", "create_anthropic_llm_fn"],
+            "features": [
+                "BYO-LLM (Bring Your Own LLM)",
+                "Thread-safe chat history",
+                "Tool execution",
+                "No litellm dependency",
+                "Minimal memory footprint"
+            ]
+        }
+    
+    def show_example(self) -> str:
+        """
+        Show example usage of lite package.
+        
+        Returns:
+            Example code string
+        """
+        example = '''
+# Example: Using praisonaiagents.lite with custom LLM
+
+from praisonaiagents.lite import LiteAgent, tool
+
+# Define a custom LLM function
+def my_llm(messages):
+    """Your custom LLM implementation."""
+    # Example: Call OpenAI directly
+    import openai
+    client = openai.OpenAI()
+    response = client.chat.completions.create(
+        model="gpt-4o-mini",
+        messages=messages
+    )
+    return response.choices[0].message.content
+
+# Or use the built-in OpenAI adapter
+from praisonaiagents.lite import create_openai_llm_fn
+llm_fn = create_openai_llm_fn(model="gpt-4o-mini")
+
+# Create a lite agent
+agent = LiteAgent(
+    name="MyAgent",
+    llm_fn=llm_fn,
+    instructions="You are a helpful assistant."
+)
+
+# Chat with the agent
+response = agent.chat("Hello!")
+print(response)
+
+# Define and use tools
+@tool
+def add_numbers(a: int, b: int) -> int:
+    """Add two numbers."""
+    return a + b
+
+agent_with_tools = LiteAgent(
+    name="MathAgent",
+    llm_fn=llm_fn,
+    tools=[add_numbers]
+)
+
+# Execute tool directly
+result = agent_with_tools.execute_tool("add_numbers", a=5, b=3)
+print(f"Result: {result.output}")  # Output: 8
+'''
+        return example
+    
+    def run_lite_agent(
+        self,
+        prompt: str,
+        model: str = "gpt-4o-mini",
+        provider: str = "openai"
+    ) -> str:
+        """
+        Run a lite agent with the given prompt.
+        
+        Args:
+            prompt: The prompt to send to the agent
+            model: Model name to use
+            provider: LLM provider (openai, anthropic)
+            
+        Returns:
+            Agent response
+        """
+        try:
+            from praisonaiagents.lite import LiteAgent, create_openai_llm_fn, create_anthropic_llm_fn
+            
+            # Create LLM function based on provider
+            if provider == "openai":
+                if not os.environ.get("OPENAI_API_KEY"):
+                    return "Error: OPENAI_API_KEY not set"
+                llm_fn = create_openai_llm_fn(model=model)
+            elif provider == "anthropic":
+                if not os.environ.get("ANTHROPIC_API_KEY"):
+                    return "Error: ANTHROPIC_API_KEY not set"
+                llm_fn = create_anthropic_llm_fn(model=model)
+            else:
+                return f"Error: Unknown provider '{provider}'. Use 'openai' or 'anthropic'."
+            
+            # Create and run agent
+            agent = LiteAgent(
+                name="LiteCLIAgent",
+                llm_fn=llm_fn,
+                instructions="You are a helpful assistant. Keep responses concise."
+            )
+            
+            return agent.chat(prompt)
+            
+        except ImportError as e:
+            return f"Error: {e}"
+        except Exception as e:
+            return f"Error: {e}"
+    
+    def handle(self, subcommand: str = "info", **kwargs) -> Any:
+        """
+        Handle lite subcommands.
+        
+        Args:
+            subcommand: One of run, info, example
+            **kwargs: Additional options (prompt, model, provider)
+            
+        Returns:
+            Results
+        """
+        if subcommand == "info":
+            info = self.get_info()
+            if info.get("available"):
+                print("praisonaiagents.lite - Lightweight Agent Package")
+                print("=" * 50)
+                print("\nClasses:", ", ".join(info["classes"]))
+                print("Decorators:", ", ".join(info["decorators"]))
+                print("Helpers:", ", ".join(info["helpers"]))
+                print("\nFeatures:")
+                for feature in info["features"]:
+                    print(f"  • {feature}")
+            else:
+                print(f"Lite package not available: {info.get('error')}")
+            return info
+            
+        elif subcommand == "example":
+            example = self.show_example()
+            print(example)
+            return example
+            
+        elif subcommand == "run":
+            prompt = kwargs.get("prompt", "Hello!")
+            model = kwargs.get("model", "gpt-4o-mini")
+            provider = kwargs.get("provider", "openai")
+            
+            response = self.run_lite_agent(prompt, model, provider)
+            print(response)
+            return response
+            
+        else:
+            print(f"Unknown subcommand: {subcommand}")
+            print("Available: info, example, run")
+            return None
+
+
+def run_lite_command(args) -> int:
+    """
+    Run lite command from CLI args.
+    
+    Args:
+        args: Parsed CLI arguments
+        
+    Returns:
+        Exit code (0 for success)
+    """
+    handler = LiteHandler()
+    subcommand = getattr(args, 'lite_command', 'info')
+    
+    kwargs = {}
+    if hasattr(args, 'prompt'):
+        kwargs['prompt'] = args.prompt
+    if hasattr(args, 'model'):
+        kwargs['model'] = args.model
+    if hasattr(args, 'provider'):
+        kwargs['provider'] = args.provider
+    
+    result = handler.handle(subcommand, **kwargs)
+    return 0 if result else 1

praisonai/cli/features/lsp_cli.py

@@ -0,0 +1,225 @@
+"""
+LSP CLI handler for PraisonAI.
+
+Provides LSP service lifecycle commands:
+- lsp start: Start LSP server(s)
+- lsp stop: Stop LSP server(s)
+- lsp status: Show status
+- lsp logs: Show recent logs
+"""
+
+import argparse
+import asyncio
+import json
+import logging
+from typing import List
+
+logger = logging.getLogger(__name__)
+
+
+class LSPHandler:
+    """Handler for LSP CLI commands."""
+    
+    @staticmethod
+    def setup_subparser(subparsers) -> None:
+        """Set up the lsp subcommand parser."""
+        lsp_parser = subparsers.add_parser(
+            "lsp",
+            help="LSP service lifecycle management",
+            description="Manage Language Server Protocol servers"
+        )
+        
+        lsp_subparsers = lsp_parser.add_subparsers(dest="lsp_command", help="LSP subcommands")
+        
+        # lsp start
+        start_parser = lsp_subparsers.add_parser("start", help="Start LSP server(s)")
+        start_parser.add_argument(
+            "--language", "-l",
+            type=str,
+            help="Language to start (default: auto-detect)"
+        )
+        start_parser.add_argument(
+            "--workspace", "-w",
+            type=str,
+            default=".",
+            help="Workspace root directory"
+        )
+        start_parser.add_argument("--json", action="store_true", help="Output JSON")
+        start_parser.set_defaults(func=LSPHandler.handle_start)
+        
+        # lsp stop
+        stop_parser = lsp_subparsers.add_parser("stop", help="Stop LSP server(s)")
+        stop_parser.add_argument("--json", action="store_true", help="Output JSON")
+        stop_parser.set_defaults(func=LSPHandler.handle_stop)
+        
+        # lsp status
+        status_parser = lsp_subparsers.add_parser("status", help="Show LSP status")
+        status_parser.add_argument(
+            "--workspace", "-w",
+            type=str,
+            default=".",
+            help="Workspace root directory"
+        )
+        status_parser.add_argument("--json", action="store_true", help="Output JSON")
+        status_parser.set_defaults(func=LSPHandler.handle_status)
+        
+        # lsp logs
+        logs_parser = lsp_subparsers.add_parser("logs", help="Show recent logs")
+        logs_parser.add_argument(
+            "--tail", "-n",
+            type=int,
+            default=50,
+            help="Number of lines to show"
+        )
+        logs_parser.add_argument("--json", action="store_true", help="Output JSON")
+        logs_parser.set_defaults(func=LSPHandler.handle_logs)
+    
+    @staticmethod
+    def handle_start(args: argparse.Namespace) -> int:
+        """Handle lsp start command."""
+        return asyncio.run(LSPHandler._run_start(args))
+    
+    @staticmethod
+    async def _run_start(args: argparse.Namespace) -> int:
+        """Start LSP server."""
+        from .interactive_runtime import create_runtime
+        
+        runtime = create_runtime(
+            workspace=args.workspace,
+            lsp=True,
+            acp=False
+        )
+        
+        try:
+            await runtime.start()
+            
+            result = {
+                "action": "start",
+                "lsp_ready": runtime.lsp_ready,
+                "lsp_status": runtime._lsp_state.status.value,
+                "workspace": args.workspace,
+                "language": getattr(args, 'language', None) or "auto-detected"
+            }
+            
+            if runtime._lsp_state.error:
+                result["error"] = runtime._lsp_state.error
+            
+            LSPHandler._output_result(result, args.json)
+            
+            # Keep running if started successfully
+            if runtime.lsp_ready:
+                if not args.json:
+                    print("\nLSP server running. Press Ctrl+C to stop.")
+                try:
+                    while True:
+                        await asyncio.sleep(1)
+                except KeyboardInterrupt:
+                    pass
+            
+            return 0 if runtime.lsp_ready else 1
+            
+        finally:
+            await runtime.stop()
+    
+    @staticmethod
+    def handle_stop(args: argparse.Namespace) -> int:
+        """Handle lsp stop command."""
+        result = {
+            "action": "stop",
+            "message": "LSP servers stopped"
+        }
+        LSPHandler._output_result(result, args.json)
+        return 0
+    
+    @staticmethod
+    def handle_status(args: argparse.Namespace) -> int:
+        """Handle lsp status command."""
+        return asyncio.run(LSPHandler._run_status(args))
+    
+    @staticmethod
+    async def _run_status(args: argparse.Namespace) -> int:
+        """Check LSP status."""
+        from .interactive_runtime import create_runtime
+        
+        runtime = create_runtime(
+            workspace=args.workspace,
+            lsp=True,
+            acp=False
+        )
+        
+        try:
+            await runtime.start()
+            
+            result = {
+                "lsp_enabled": True,
+                "lsp_ready": runtime.lsp_ready,
+                "lsp_status": runtime._lsp_state.status.value,
+                "workspace": args.workspace
+            }
+            
+            if runtime._lsp_state.error:
+                result["error"] = runtime._lsp_state.error
+            
+            LSPHandler._output_result(result, args.json)
+            return 0 if runtime.lsp_ready else 1
+            
+        finally:
+            await runtime.stop()
+    
+    @staticmethod
+    def handle_logs(args: argparse.Namespace) -> int:
+        """Handle lsp logs command."""
+        result = {
+            "action": "logs",
+            "tail": args.tail,
+            "logs": [],
+            "message": "LSP logging not yet implemented"
+        }
+        LSPHandler._output_result(result, args.json)
+        return 0
+    
+    @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:
+            for key, value in result.items():
+                print(f"{key}: {value}")
+
+
+def run_lsp_command(args: List[str]) -> int:
+    """Run lsp command from CLI."""
+    parser = argparse.ArgumentParser(prog="praisonai lsp")
+    subparsers = parser.add_subparsers(dest="lsp_command", help="LSP subcommands")
+    
+    # lsp start
+    start_parser = subparsers.add_parser("start", help="Start LSP server(s)")
+    start_parser.add_argument("--language", "-l", type=str)
+    start_parser.add_argument("--workspace", "-w", type=str, default=".")
+    start_parser.add_argument("--json", action="store_true")
+    start_parser.set_defaults(func=LSPHandler.handle_start)
+    
+    # lsp stop
+    stop_parser = subparsers.add_parser("stop", help="Stop LSP server(s)")
+    stop_parser.add_argument("--json", action="store_true")
+    stop_parser.set_defaults(func=LSPHandler.handle_stop)
+    
+    # lsp status
+    status_parser = subparsers.add_parser("status", help="Show LSP status")
+    status_parser.add_argument("--workspace", "-w", type=str, default=".")
+    status_parser.add_argument("--json", action="store_true")
+    status_parser.set_defaults(func=LSPHandler.handle_status)
+    
+    # lsp logs
+    logs_parser = subparsers.add_parser("logs", help="Show recent logs")
+    logs_parser.add_argument("--tail", "-n", type=int, default=50)
+    logs_parser.add_argument("--json", action="store_true")
+    logs_parser.set_defaults(func=LSPHandler.handle_logs)
+    
+    parsed = parser.parse_args(args)
+    if hasattr(parsed, 'func'):
+        return parsed.func(parsed)
+    else:
+        parser.print_help()
+        return 0

praisonai/cli/features/mcp.py

@@ -0,0 +1,169 @@
+"""
+MCP Handler for CLI.
+
+Provides Model Context Protocol server integration.
+Usage: praisonai "prompt" --mcp "npx -y @modelcontextprotocol/server-filesystem ."
+"""
+
+import shlex
+from typing import Any, Dict, Tuple, List
+from .base import FlagHandler
+
+
+class MCPHandler(FlagHandler):
+    """
+    Handler for --mcp flag.
+    
+    Integrates MCP (Model Context Protocol) servers as tools for agents.
+    
+    Example:
+        praisonai "List files" --mcp "npx -y @modelcontextprotocol/server-filesystem ."
+        praisonai "Search web" --mcp "npx -y @modelcontextprotocol/server-brave-search" --mcp-env "BRAVE_API_KEY=xxx"
+    """
+    
+    @property
+    def feature_name(self) -> str:
+        return "mcp"
+    
+    @property
+    def flag_name(self) -> str:
+        return "mcp"
+    
+    @property
+    def flag_help(self) -> str:
+        return "MCP server command (e.g., 'npx -y @modelcontextprotocol/server-filesystem .')"
+    
+    def check_dependencies(self) -> Tuple[bool, str]:
+        """Check if MCP is available."""
+        try:
+            import importlib.util
+            if importlib.util.find_spec("praisonaiagents") is not None:
+                # Check if MCP module is available
+                from praisonaiagents import MCP
+                if MCP is not None:
+                    return True, ""
+            return False, "MCP requires praisonaiagents with MCP support"
+        except ImportError:
+            return False, "praisonaiagents not installed. Install with: pip install praisonaiagents"
+    
+    def parse_mcp_command(self, command: str, env_vars: str = None) -> Tuple[str, List[str], Dict[str, str]]:
+        """
+        Parse MCP command string into command, args, and environment.
+        
+        Args:
+            command: Full MCP command string
+            env_vars: Optional comma-separated environment variables (KEY=value,KEY2=value2)
+            
+        Returns:
+            Tuple of (command, args, env_dict)
+        """
+        # Parse command using shell-like splitting
+        parts = shlex.split(command)
+        if not parts:
+            return "", [], {}
+        
+        cmd = parts[0]
+        args = parts[1:] if len(parts) > 1 else []
+        
+        # Parse environment variables
+        env = {}
+        if env_vars:
+            for pair in env_vars.split(','):
+                if '=' in pair:
+                    key, value = pair.split('=', 1)
+                    env[key.strip()] = value.strip()
+        
+        return cmd, args, env
+    
+    def create_mcp_tools(self, command: str, env_vars: str = None, timeout: int = 30) -> Any:
+        """
+        Create MCP tools from command.
+        
+        Args:
+            command: MCP server command
+            env_vars: Optional environment variables
+            timeout: Connection timeout in seconds
+            
+        Returns:
+            MCP instance or None if unavailable
+        """
+        available, msg = self.check_dependencies()
+        if not available:
+            self.print_status(msg, "error")
+            return None
+        
+        from praisonaiagents import MCP
+        
+        cmd, args, env = self.parse_mcp_command(command, env_vars)
+        
+        if not cmd:
+            self.print_status("Invalid MCP command", "error")
+            return None
+        
+        try:
+            mcp = MCP(
+                command=cmd,
+                args=args,
+                env=env if env else None,
+                timeout=timeout
+            )
+            self.print_status(f"🔌 MCP server connected: {cmd}", "success")
+            return mcp
+        except Exception as e:
+            self.print_status(f"Failed to connect to MCP server: {e}", "error")
+            return None
+    
+    def apply_to_agent_config(self, config: Dict[str, Any], flag_value: Any) -> Dict[str, Any]:
+        """
+        Apply MCP configuration to agent config.
+        
+        Args:
+            config: Agent configuration dictionary
+            flag_value: MCP command string or dict with command and env
+            
+        Returns:
+            Modified configuration with MCP tools
+        """
+        if not flag_value:
+            return config
+        
+        # Handle both string and dict formats
+        if isinstance(flag_value, str):
+            mcp = self.create_mcp_tools(flag_value)
+        elif isinstance(flag_value, dict):
+            mcp = self.create_mcp_tools(
+                flag_value.get('command', ''),
+                flag_value.get('env', ''),
+                flag_value.get('timeout', 30)
+            )
+        else:
+            return config
+        
+        if mcp:
+            # Add MCP tools to existing tools
+            existing_tools = config.get('tools', [])
+            if isinstance(existing_tools, list):
+                existing_tools.extend(list(mcp))
+            else:
+                existing_tools = list(mcp)
+            config['tools'] = existing_tools
+            config['_mcp_instance'] = mcp  # Store for cleanup
+        
+        return config
+    
+    def execute(self, command: str = None, env_vars: str = None, **kwargs) -> Any:
+        """
+        Execute MCP setup.
+        
+        Args:
+            command: MCP server command
+            env_vars: Environment variables
+            
+        Returns:
+            MCP instance or None
+        """
+        if not command:
+            self.print_status("No MCP command provided", "error")
+            return None
+        
+        return self.create_mcp_tools(command, env_vars)