PraisonAI 3.0.0__py3-none-any.whl

praisonai/integrations/codex_cli.py

@@ -0,0 +1,255 @@
+"""
+OpenAI Codex CLI Integration.
+
+Provides integration with OpenAI's Codex CLI for AI-powered coding tasks.
+
+Features:
+- Non-interactive execution with `codex exec`
+- Full auto mode for file modifications
+- Sandbox modes for security
+- JSON streaming output
+- Structured output with schemas
+
+Usage:
+    from praisonai.integrations import CodexCLIIntegration
+    
+    # Create integration
+    codex = CodexCLIIntegration(workspace="/path/to/project")
+    
+    # Execute a coding task
+    result = await codex.execute("Fix the authentication bug")
+    
+    # Execute with full auto (allows file modifications)
+    codex_auto = CodexCLIIntegration(full_auto=True)
+    result = await codex_auto.execute("Refactor the module")
+    
+    # Use as agent tool
+    tool = codex.as_tool()
+"""
+
+import json
+import os
+from typing import AsyncIterator, Dict, Any, Optional, List
+
+from .base import BaseCLIIntegration
+
+
+class CodexCLIIntegration(BaseCLIIntegration):
+    """
+    Integration with OpenAI's Codex CLI.
+    
+    Attributes:
+        full_auto: Whether to allow file modifications
+        sandbox: Sandbox mode ("default", "danger-full-access")
+        json_output: Whether to use JSON streaming output
+        output_schema: Path to JSON schema for structured output
+    """
+    
+    def __init__(
+        self,
+        workspace: str = ".",
+        timeout: int = 300,
+        full_auto: bool = False,
+        sandbox: str = "default",
+        json_output: bool = False,
+        output_schema: Optional[str] = None,
+        output_file: Optional[str] = None,
+    ):
+        """
+        Initialize Codex CLI integration.
+        
+        Args:
+            workspace: Working directory for CLI execution
+            timeout: Timeout in seconds for CLI execution
+            full_auto: Whether to allow file modifications (--full-auto)
+            sandbox: Sandbox mode ("default", "danger-full-access")
+            json_output: Whether to use JSON streaming output (--json)
+            output_schema: Path to JSON schema for structured output
+            output_file: Path to save the final output (-o)
+        """
+        super().__init__(workspace=workspace, timeout=timeout)
+        
+        self.full_auto = full_auto
+        self.sandbox = sandbox
+        self.json_output = json_output
+        self.output_schema = output_schema
+        self.output_file = output_file
+    
+    @property
+    def cli_command(self) -> str:
+        """Return the CLI command name."""
+        return "codex"
+    
+    def _build_command(self, task: str, **options) -> List[str]:
+        """
+        Build the Codex CLI command.
+        
+        Args:
+            task: The task to execute
+            **options: Additional options
+            
+        Returns:
+            List of command arguments
+        """
+        cmd = ["codex", "exec"]
+        
+        # Add working directory
+        cmd.extend(["-C", self.workspace])
+        
+        # Add task
+        cmd.append(task)
+        
+        # Add full auto flag if enabled
+        if self.full_auto:
+            cmd.append("--full-auto")
+        
+        # Add sandbox mode if not default
+        if self.sandbox and self.sandbox != "default":
+            cmd.extend(["--sandbox", self.sandbox])
+        
+        # Add JSON output flag if enabled
+        if self.json_output:
+            cmd.append("--json")
+        
+        # Add output schema if specified
+        if self.output_schema:
+            cmd.extend(["--output-schema", self.output_schema])
+        
+        # Add output file if specified
+        if self.output_file:
+            cmd.extend(["-o", self.output_file])
+        
+        return cmd
+    
+    async def execute(self, prompt: str, **options) -> str:
+        """
+        Execute Codex CLI and return the result.
+        
+        Args:
+            prompt: The task/prompt to execute
+            **options: Additional options
+            
+        Returns:
+            str: The CLI output
+        """
+        cmd = self._build_command(prompt, **options)
+        
+        output = await self.execute_async(cmd)
+        
+        # Parse JSON Lines output if json_output is enabled
+        if self.json_output:
+            return self._parse_json_events(output)
+        
+        return output
+    
+    def _parse_json_events(self, output: str) -> str:
+        """
+        Parse JSON Lines output and extract the final result.
+        
+        Args:
+            output: Raw JSON Lines output
+            
+        Returns:
+            str: The extracted result
+        """
+        result_parts = []
+        
+        for line in output.strip().split('\n'):
+            if not line.strip():
+                continue
+            
+            try:
+                event = json.loads(line)
+                event_type = event.get("type", "")
+                
+                # Extract agent messages
+                if event_type == "item.completed":
+                    item = event.get("item", {})
+                    if item.get("type") == "agent_message":
+                        text = item.get("text", "")
+                        if text:
+                            result_parts.append(text)
+                
+            except json.JSONDecodeError:
+                continue
+        
+        return '\n'.join(result_parts) if result_parts else output
+    
+    async def stream(self, prompt: str, **options) -> AsyncIterator[Dict[str, Any]]:
+        """
+        Stream output from Codex CLI.
+        
+        Args:
+            prompt: The task/prompt to execute
+            **options: Additional options
+            
+        Yields:
+            dict: Parsed JSON events from the CLI
+        """
+        # Ensure JSON output is enabled for streaming
+        original_json = self.json_output
+        self.json_output = True
+        
+        try:
+            cmd = self._build_command(prompt, **options)
+            
+            async for line in self.stream_async(cmd):
+                if line.strip():
+                    try:
+                        event = json.loads(line)
+                        yield event
+                    except json.JSONDecodeError:
+                        yield {"type": "text", "content": line}
+        finally:
+            self.json_output = original_json
+    
+    async def execute_with_schema(
+        self, 
+        prompt: str, 
+        schema_path: str,
+        output_path: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        Execute Codex with structured output schema.
+        
+        Args:
+            prompt: The task/prompt to execute
+            schema_path: Path to the JSON schema file
+            output_path: Optional path to save the output
+            
+        Returns:
+            dict: Parsed structured output
+        """
+        original_schema = self.output_schema
+        original_output = self.output_file
+        
+        self.output_schema = schema_path
+        if output_path:
+            self.output_file = output_path
+        
+        try:
+            cmd = self._build_command(prompt)
+            output = await self.execute_async(cmd)
+            
+            # If output file was specified, read from it
+            if output_path and os.path.exists(output_path):
+                with open(output_path, 'r') as f:
+                    return json.load(f)
+            
+            # Otherwise parse the output
+            try:
+                return json.loads(output)
+            except json.JSONDecodeError:
+                return {"result": output}
+        finally:
+            self.output_schema = original_schema
+            self.output_file = original_output
+    
+    def get_env(self) -> Dict[str, str]:
+        """Get environment variables for CLI execution."""
+        env = super().get_env()
+        
+        # Codex uses ChatGPT authentication or API key
+        # The CLI handles authentication internally
+        
+        return env

praisonai/integrations/cursor_cli.py

@@ -0,0 +1,195 @@
+"""
+Cursor CLI Integration.
+
+Provides integration with Cursor's CLI (cursor-agent) for AI-powered coding tasks.
+
+Features:
+- Headless mode execution with JSON output
+- Force mode for file modifications
+- Model selection
+- Session resume support
+- Streaming output with partial deltas
+
+Usage:
+    from praisonai.integrations import CursorCLIIntegration
+    
+    # Create integration
+    cursor = CursorCLIIntegration(workspace="/path/to/project")
+    
+    # Execute a coding task
+    result = await cursor.execute("Fix the authentication bug")
+    
+    # Execute with force mode (allows file modifications)
+    cursor_force = CursorCLIIntegration(force=True)
+    result = await cursor_force.execute("Refactor the module")
+    
+    # Use as agent tool
+    tool = cursor.as_tool()
+"""
+
+import json
+import os
+from typing import AsyncIterator, Dict, Any, Optional, List
+
+from .base import BaseCLIIntegration
+
+
+class CursorCLIIntegration(BaseCLIIntegration):
+    """
+    Integration with Cursor CLI (cursor-agent).
+    
+    Attributes:
+        output_format: Output format ("json", "text", "stream-json")
+        force: Whether to allow file modifications
+        model: Model to use (e.g., "gpt-5")
+        stream_partial: Whether to stream partial output
+        resume_session: Session ID to resume
+    """
+    
+    def __init__(
+        self,
+        workspace: str = ".",
+        timeout: int = 300,
+        output_format: str = "json",
+        force: bool = False,
+        model: Optional[str] = None,
+        stream_partial: bool = False,
+        resume_session: Optional[str] = None,
+    ):
+        """
+        Initialize Cursor CLI integration.
+        
+        Args:
+            workspace: Working directory for CLI execution
+            timeout: Timeout in seconds for CLI execution
+            output_format: Output format ("json", "text", "stream-json")
+            force: Whether to allow file modifications (--force)
+            model: Model to use (e.g., "gpt-5")
+            stream_partial: Whether to stream partial output (--stream-partial-output)
+            resume_session: Session ID to resume (--resume)
+        """
+        super().__init__(workspace=workspace, timeout=timeout)
+        
+        self.output_format = output_format
+        self.force = force
+        self.model = model
+        self.stream_partial = stream_partial
+        self.resume_session = resume_session
+    
+    @property
+    def cli_command(self) -> str:
+        """Return the CLI command name."""
+        return "cursor-agent"
+    
+    def _build_command(self, prompt: str, **options) -> List[str]:
+        """
+        Build the Cursor CLI command.
+        
+        Args:
+            prompt: The prompt to send
+            **options: Additional options
+            
+        Returns:
+            List of command arguments
+        """
+        cmd = ["cursor-agent"]
+        
+        # Add print mode flag
+        cmd.append("-p")
+        
+        # Add workspace
+        cmd.extend(["--workspace", self.workspace])
+        
+        # Add force flag if enabled
+        if self.force:
+            cmd.append("--force")
+        
+        # Add model if specified
+        if self.model:
+            cmd.extend(["-m", self.model])
+        
+        # Add output format
+        cmd.extend(["--output-format", self.output_format])
+        
+        # Add stream partial flag if enabled
+        if self.stream_partial:
+            cmd.append("--stream-partial-output")
+        
+        # Add resume session if specified
+        if self.resume_session:
+            cmd.extend(["--resume", self.resume_session])
+        
+        # Add prompt (must be last)
+        cmd.append(prompt)
+        
+        return cmd
+    
+    async def execute(self, prompt: str, **options) -> str:
+        """
+        Execute Cursor CLI and return the result.
+        
+        Args:
+            prompt: The prompt/query to send
+            **options: Additional options
+            
+        Returns:
+            str: The CLI output (parsed from JSON if output_format is "json")
+        """
+        cmd = self._build_command(prompt, **options)
+        
+        output = await self.execute_async(cmd)
+        
+        # Parse JSON output if applicable
+        if self.output_format == "json":
+            try:
+                data = json.loads(output)
+                # Extract the main result
+                if isinstance(data, dict):
+                    return data.get("result", data.get("content", str(data)))
+                return str(data)
+            except json.JSONDecodeError:
+                return output
+        
+        return output
+    
+    async def stream(self, prompt: str, **options) -> AsyncIterator[Dict[str, Any]]:
+        """
+        Stream output from Cursor CLI.
+        
+        Args:
+            prompt: The prompt/query to send
+            **options: Additional options
+            
+        Yields:
+            dict: Parsed JSON events from the CLI
+        """
+        # Use stream-json format for streaming
+        original_format = self.output_format
+        original_partial = self.stream_partial
+        
+        self.output_format = "stream-json"
+        self.stream_partial = True
+        
+        try:
+            cmd = self._build_command(prompt, **options)
+            
+            async for line in self.stream_async(cmd):
+                if line.strip():
+                    try:
+                        event = json.loads(line)
+                        yield event
+                    except json.JSONDecodeError:
+                        yield {"type": "text", "content": line}
+        finally:
+            self.output_format = original_format
+            self.stream_partial = original_partial
+    
+    def get_env(self) -> Dict[str, str]:
+        """Get environment variables for CLI execution."""
+        env = super().get_env()
+        
+        # Add Cursor API key if available
+        if "CURSOR_API_KEY" in os.environ:
+            env["CURSOR_API_KEY"] = os.environ["CURSOR_API_KEY"]
+        
+        return env

praisonai/integrations/gemini_cli.py

@@ -0,0 +1,222 @@
+"""
+Gemini CLI Integration.
+
+Provides integration with Google's Gemini CLI for AI-powered coding tasks.
+
+Features:
+- Headless mode execution with JSON output
+- Model selection (gemini-2.5-pro, gemini-2.5-flash, etc.)
+- Multi-directory context support
+- Google Search grounding
+- Usage statistics
+
+Usage:
+    from praisonai.integrations import GeminiCLIIntegration
+    
+    # Create integration
+    gemini = GeminiCLIIntegration(workspace="/path/to/project")
+    
+    # Execute a coding task
+    result = await gemini.execute("Analyze this codebase")
+    
+    # Get result with stats
+    result, stats = await gemini.execute_with_stats("Explain the architecture")
+    
+    # Use as agent tool
+    tool = gemini.as_tool()
+"""
+
+import json
+import os
+from typing import AsyncIterator, Dict, Any, Optional, List, Tuple
+
+from .base import BaseCLIIntegration
+
+
+class GeminiCLIIntegration(BaseCLIIntegration):
+    """
+    Integration with Google's Gemini CLI.
+    
+    Attributes:
+        output_format: Output format ("json", "text", "stream-json")
+        model: Gemini model to use
+        include_directories: Additional directories to include in context
+        sandbox: Whether to run in sandbox mode
+    """
+    
+    def __init__(
+        self,
+        workspace: str = ".",
+        timeout: int = 300,
+        output_format: str = "json",
+        model: str = "gemini-2.5-pro",
+        include_directories: Optional[List[str]] = None,
+        sandbox: bool = False,
+    ):
+        """
+        Initialize Gemini CLI integration.
+        
+        Args:
+            workspace: Working directory for CLI execution
+            timeout: Timeout in seconds for CLI execution
+            output_format: Output format ("json", "text", "stream-json")
+            model: Gemini model to use (e.g., "gemini-2.5-pro", "gemini-2.5-flash")
+            include_directories: Additional directories to include in context
+            sandbox: Whether to run in sandbox mode
+        """
+        super().__init__(workspace=workspace, timeout=timeout)
+        
+        self.output_format = output_format
+        self.model = model
+        self.include_directories = include_directories
+        self.sandbox = sandbox
+        
+        # Store last stats for retrieval
+        self._last_stats: Optional[Dict[str, Any]] = None
+    
+    @property
+    def cli_command(self) -> str:
+        """Return the CLI command name."""
+        return "gemini"
+    
+    def _build_command(self, prompt: str, **options) -> List[str]:
+        """
+        Build the Gemini CLI command.
+        
+        Args:
+            prompt: The prompt to send
+            **options: Additional options
+            
+        Returns:
+            List of command arguments
+        """
+        cmd = ["gemini"]
+        
+        # Add model
+        cmd.extend(["-m", self.model])
+        
+        # Add output format
+        cmd.extend(["--output-format", self.output_format])
+        
+        # Add include directories if specified
+        if self.include_directories:
+            cmd.extend(["--include-directories", ",".join(self.include_directories)])
+        
+        # Add sandbox flag if enabled
+        if self.sandbox:
+            cmd.append("--sandbox")
+        
+        # Add YOLO mode for non-interactive execution
+        cmd.append("--yolo")
+        
+        # Add prompt flag with prompt value
+        cmd.extend(["-p", prompt])
+        
+        return cmd
+    
+    async def execute(self, prompt: str, **options) -> str:
+        """
+        Execute Gemini CLI and return the result.
+        
+        Args:
+            prompt: The prompt/query to send
+            **options: Additional options
+            
+        Returns:
+            str: The CLI output (parsed from JSON if output_format is "json")
+        """
+        cmd = self._build_command(prompt, **options)
+        
+        output = await self.execute_async(cmd)
+        
+        # Parse JSON output if applicable
+        if self.output_format == "json":
+            try:
+                data = json.loads(output)
+                # Store stats for later retrieval
+                self._last_stats = data.get("stats")
+                # Extract the main response
+                return data.get("response", str(data))
+            except json.JSONDecodeError:
+                return output
+        
+        return output
+    
+    async def execute_with_stats(self, prompt: str, **options) -> Tuple[str, Optional[Dict[str, Any]]]:
+        """
+        Execute Gemini CLI and return both result and usage stats.
+        
+        Args:
+            prompt: The prompt/query to send
+            **options: Additional options
+            
+        Returns:
+            Tuple[str, dict]: (result, stats) where stats contains usage information
+        """
+        # Ensure JSON format for stats
+        original_format = self.output_format
+        self.output_format = "json"
+        
+        try:
+            cmd = self._build_command(prompt, **options)
+            output = await self.execute_async(cmd)
+            
+            try:
+                data = json.loads(output)
+                response = data.get("response", str(data))
+                stats = data.get("stats")
+                return response, stats
+            except json.JSONDecodeError:
+                return output, None
+        finally:
+            self.output_format = original_format
+    
+    async def stream(self, prompt: str, **options) -> AsyncIterator[Dict[str, Any]]:
+        """
+        Stream output from Gemini CLI.
+        
+        Args:
+            prompt: The prompt/query to send
+            **options: Additional options
+            
+        Yields:
+            dict: Parsed JSON events from the CLI
+        """
+        # Use stream-json format for streaming
+        original_format = self.output_format
+        self.output_format = "stream-json"
+        
+        try:
+            cmd = self._build_command(prompt, **options)
+            
+            async for line in self.stream_async(cmd):
+                if line.strip():
+                    try:
+                        event = json.loads(line)
+                        yield event
+                    except json.JSONDecodeError:
+                        yield {"type": "text", "content": line}
+        finally:
+            self.output_format = original_format
+    
+    def get_last_stats(self) -> Optional[Dict[str, Any]]:
+        """
+        Get the stats from the last execution.
+        
+        Returns:
+            dict: Usage statistics or None if not available
+        """
+        return self._last_stats
+    
+    def get_env(self) -> Dict[str, str]:
+        """Get environment variables for CLI execution."""
+        env = super().get_env()
+        
+        # Add Google API key if available
+        if "GOOGLE_API_KEY" in os.environ:
+            env["GOOGLE_API_KEY"] = os.environ["GOOGLE_API_KEY"]
+        elif "GEMINI_API_KEY" in os.environ:
+            # Map GEMINI_API_KEY to GOOGLE_API_KEY
+            env["GOOGLE_API_KEY"] = os.environ["GEMINI_API_KEY"]
+        
+        return env