PraisonAI 2.3.57__tar.gz → 2.3.62__tar.gz

{praisonai-2.3.57 → praisonai-2.3.62}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 2.3.57
+Version: 2.3.62
 Summary: PraisonAI is an AI Agents Framework with Self Reflection. PraisonAI application combines PraisonAI Agents, AutoGen, and CrewAI into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customisation, and efficient human-agent collaboration.
 Author: Mervin Praison
 License: MIT
@@ -11,7 +11,7 @@ Description-Content-Type: text/markdown
 Requires-Dist: rich>=13.7
 Requires-Dist: markdown>=3.5
 Requires-Dist: pyparsing>=3.0.0
-Requires-Dist: praisonaiagents>=0.1.18
+Requires-Dist: praisonaiagents>=0.1.21
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: instructor>=1.3.3
 Requires-Dist: PyYAML>=6.0
@@ -1155,6 +1155,20 @@ praisonai "Complex analysis task" --planning --planning-reasoning
 praisonai "Task" --planning --auto-approve-plan
 ```
 
+### Tool Approval CLI:
+```bash
+# Auto-approve ALL tool executions (use with caution!)
+praisonai "run ls command" --trust
+
+# Auto-approve tools up to a risk level (prompt for higher)
+# Levels: low, medium, high, critical
+praisonai "write to file" --approve-level high  # Prompts for critical tools only
+praisonai "task" --approve-level medium         # Prompts for high and critical
+
+# Default behavior (no flags): prompts for all dangerous tools
+praisonai "run shell command"  # Will prompt for approval
+```
+
 ### Memory CLI:
 ```bash
 # Enable memory for agent (persists across sessions)
@@ -2496,6 +2510,7 @@ PraisonAI provides zero-dependency persistent memory for agents. For detailed ex
 - 🤝 **Agent Handoffs** - Transfer context between specialised agents
 - 🛡️ **Guardrails** - Input/output validation and safety checks
 - ✅ **Human Approval** - Require human confirmation for critical actions
+- 🔐 **Tool Approval CLI** - `--trust` (auto-approve all) and `--approve-level` (risk-based approval)
 - 💬 **Sessions Management** - Isolated conversation contexts
 - 🔄 **Stateful Agents** - Maintain state across interactions
 

{praisonai-2.3.57 → praisonai-2.3.62}/PraisonAI.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 2.3.57
+Version: 2.3.62
 Summary: PraisonAI is an AI Agents Framework with Self Reflection. PraisonAI application combines PraisonAI Agents, AutoGen, and CrewAI into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customisation, and efficient human-agent collaboration.
 Author: Mervin Praison
 License: MIT
@@ -11,7 +11,7 @@ Description-Content-Type: text/markdown
 Requires-Dist: rich>=13.7
 Requires-Dist: markdown>=3.5
 Requires-Dist: pyparsing>=3.0.0
-Requires-Dist: praisonaiagents>=0.1.18
+Requires-Dist: praisonaiagents>=0.1.21
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: instructor>=1.3.3
 Requires-Dist: PyYAML>=6.0
@@ -1155,6 +1155,20 @@ praisonai "Complex analysis task" --planning --planning-reasoning
 praisonai "Task" --planning --auto-approve-plan
 ```
 
+### Tool Approval CLI:
+```bash
+# Auto-approve ALL tool executions (use with caution!)
+praisonai "run ls command" --trust
+
+# Auto-approve tools up to a risk level (prompt for higher)
+# Levels: low, medium, high, critical
+praisonai "write to file" --approve-level high  # Prompts for critical tools only
+praisonai "task" --approve-level medium         # Prompts for high and critical
+
+# Default behavior (no flags): prompts for all dangerous tools
+praisonai "run shell command"  # Will prompt for approval
+```
+
 ### Memory CLI:
 ```bash
 # Enable memory for agent (persists across sessions)
@@ -2496,6 +2510,7 @@ PraisonAI provides zero-dependency persistent memory for agents. For detailed ex
 - 🤝 **Agent Handoffs** - Transfer context between specialised agents
 - 🛡️ **Guardrails** - Input/output validation and safety checks
 - ✅ **Human Approval** - Require human confirmation for critical actions
+- 🔐 **Tool Approval CLI** - `--trust` (auto-approve all) and `--approve-level` (risk-based approval)
 - 💬 **Sessions Management** - Isolated conversation contexts
 - 🔄 **Stateful Agents** - Maintain state across interactions
 

{praisonai-2.3.57 → praisonai-2.3.62}/PraisonAI.egg-info/SOURCES.txt

@@ -97,6 +97,7 @@ praisonai/ui/realtimeclient/__init__.py
 praisonai/ui/realtimeclient/tools.py
 tests/test.py
 tests/test_agents_playbook.py
+tests/test_approval_system.py
 tests/test_basic.py
 tests/test_cli_features.py
 tests/test_custom_tools_fix.py

{praisonai-2.3.57 → praisonai-2.3.62}/PraisonAI.egg-info/requires.txt

@@ -1,7 +1,7 @@
 rich>=13.7
 markdown>=3.5
 pyparsing>=3.0.0
-praisonaiagents>=0.1.18
+praisonaiagents>=0.1.21
 python-dotenv>=0.19.0
 instructor>=1.3.3
 PyYAML>=6.0

{praisonai-2.3.57 → praisonai-2.3.62}/README.md

@@ -1058,6 +1058,20 @@ praisonai "Complex analysis task" --planning --planning-reasoning
 praisonai "Task" --planning --auto-approve-plan
 ```
 
+### Tool Approval CLI:
+```bash
+# Auto-approve ALL tool executions (use with caution!)
+praisonai "run ls command" --trust
+
+# Auto-approve tools up to a risk level (prompt for higher)
+# Levels: low, medium, high, critical
+praisonai "write to file" --approve-level high  # Prompts for critical tools only
+praisonai "task" --approve-level medium         # Prompts for high and critical
+
+# Default behavior (no flags): prompts for all dangerous tools
+praisonai "run shell command"  # Will prompt for approval
+```
+
 ### Memory CLI:
 ```bash
 # Enable memory for agent (persists across sessions)
@@ -2399,6 +2413,7 @@ PraisonAI provides zero-dependency persistent memory for agents. For detailed ex
 - 🤝 **Agent Handoffs** - Transfer context between specialised agents
 - 🛡️ **Guardrails** - Input/output validation and safety checks
 - ✅ **Human Approval** - Require human confirmation for critical actions
+- 🔐 **Tool Approval CLI** - `--trust` (auto-approve all) and `--approve-level` (risk-based approval)
 - 💬 **Sessions Management** - Isolated conversation contexts
 - 🔄 **Stateful Agents** - Maintain state across interactions
 

{praisonai-2.3.57 → praisonai-2.3.62}/praisonai/cli/main.py

@@ -68,13 +68,18 @@ AUTOGEN_AVAILABLE = importlib.util.find_spec("autogen") is not None
 PRAISONAI_AVAILABLE = importlib.util.find_spec("praisonaiagents") is not None
 TRAIN_AVAILABLE = importlib.util.find_spec("unsloth") is not None
 
-logging.basicConfig(level=os.environ.get('LOGLEVEL', 'INFO'), format='%(asctime)s - %(levelname)s - %(message)s')
+logging.basicConfig(level=os.environ.get('LOGLEVEL', 'WARNING'), format='%(asctime)s - %(levelname)s - %(message)s')
 logging.getLogger('alembic').setLevel(logging.ERROR)
 logging.getLogger('gradio').setLevel(logging.ERROR)
 logging.getLogger('gradio').setLevel(os.environ.get('GRADIO_LOGLEVEL', 'WARNING'))
 logging.getLogger('rust_logger').setLevel(logging.WARNING)
 logging.getLogger('duckduckgo').setLevel(logging.ERROR)
 logging.getLogger('_client').setLevel(logging.ERROR)
+# Suppress praisonaiagents INFO logs unless LOGLEVEL is explicitly set to debug/info
+if os.environ.get('LOGLEVEL', '').upper() not in ('DEBUG', 'INFO'):
+    logging.getLogger('praisonaiagents').setLevel(logging.WARNING)
+    logging.getLogger('praisonaiagents.llm').setLevel(logging.WARNING)
+    logging.getLogger('praisonaiagents.llm.llm').setLevel(logging.WARNING)
 
 def stream_subprocess(command, env=None):
     """
@@ -693,9 +698,18 @@ class PraisonAI:
         # Autonomy Mode - control AI action approval
         parser.add_argument("--autonomy", type=str, choices=["suggest", "auto_edit", "full_auto"], help="Set autonomy mode for AI actions")
         
+        # Tool Approval - control tool execution approval
+        parser.add_argument("--trust", action="store_true", help="Auto-approve all tool executions (skip approval prompts)")
+        parser.add_argument("--approve-level", type=str, choices=["low", "medium", "high", "critical"], 
+                          help="Auto-approve tools up to this risk level (e.g., --approve-level high approves low/medium/high but prompts for critical)")
+        
         # Sandbox Execution - secure command execution
         parser.add_argument("--sandbox", type=str, choices=["off", "basic", "strict"], help="Enable sandboxed command execution")
         
+        # External Agent - use external AI CLI tools
+        parser.add_argument("--external-agent", type=str, choices=["claude", "gemini", "codex", "cursor"],
+                          help="Use external AI CLI tool (claude, gemini, codex, cursor)")
+        
         # If we're in a test environment, parse with empty args to avoid pytest interference
         if in_test_env:
             args, unknown_args = parser.parse_known_args([])
@@ -2922,7 +2936,8 @@ Provide ONLY the commit message, no explanations."""
                 if max_tokens:
                     # Pass llm as dict with model and max_tokens
                     agent_config["llm"] = {"model": self.args.llm, "max_tokens": max_tokens}
-                    print(f"[bold cyan]Max tokens set to: {max_tokens}[/bold cyan]")
+                    if os.environ.get('LOGLEVEL', '').upper() == 'DEBUG':
+                        print(f"[bold cyan]Max tokens set to: {max_tokens}[/bold cyan]")
                 else:
                     agent_config["llm"] = self.args.llm
             
@@ -2995,6 +3010,35 @@ Provide ONLY the commit message, no explanations."""
                 
                 # ===== NEW CLI FEATURES INTEGRATION =====
                 
+                # Tool Approval - Auto-approve tools based on --trust or --approve-level
+                if getattr(self.args, 'trust', False) or getattr(self.args, 'approve_level', None):
+                    from praisonaiagents.approval import set_approval_callback, ApprovalDecision
+                    
+                    if getattr(self.args, 'trust', False):
+                        # Auto-approve all tools
+                        def auto_approve_all(function_name, arguments, risk_level):
+                            return ApprovalDecision(approved=True, reason="Auto-approved via --trust flag")
+                        set_approval_callback(auto_approve_all)
+                        print("[bold yellow]⚠️  Trust mode enabled - all tool executions will be auto-approved[/bold yellow]")
+                    elif getattr(self.args, 'approve_level', None):
+                        # Auto-approve up to specified risk level
+                        max_level = self.args.approve_level
+                        risk_order = {"low": 1, "medium": 2, "high": 3, "critical": 4}
+                        max_level_value = risk_order.get(max_level, 3)
+                        
+                        def level_based_approve(function_name, arguments, risk_level):
+                            tool_level_value = risk_order.get(risk_level, 4)
+                            if tool_level_value <= max_level_value:
+                                return ApprovalDecision(approved=True, reason=f"Auto-approved (level {risk_level} <= {max_level})")
+                            else:
+                                # Signal to pause Live display before showing approval prompt
+                                # This is handled by the approval_pending flag in status_info
+                                from praisonaiagents.approval import console_approval_callback
+                                return console_approval_callback(function_name, arguments, risk_level)
+                        
+                        set_approval_callback(level_based_approve)
+                        print(f"[bold cyan]Auto-approve enabled for tools up to '{max_level}' risk level[/bold cyan]")
+                
                 # Router - Smart model selection (must be before agent creation)
                 if getattr(self.args, 'router', False):
                     from .features.router import RouterHandler
@@ -3035,6 +3079,43 @@ Provide ONLY the commit message, no explanations."""
                             existing_tools = list(mcp_tools)
                         agent_config['tools'] = existing_tools
                 
+                # External Agent - Use external AI CLI tools directly
+                if getattr(self.args, 'external_agent', None):
+                    from rich.console import Console
+                    ext_console = Console()
+                    external_agent_name = self.args.external_agent
+                    try:
+                        from .features.external_agents import ExternalAgentsHandler
+                        handler = ExternalAgentsHandler(verbose=getattr(self.args, 'verbose', False))
+                        
+                        # Get workspace from current directory
+                        import os
+                        workspace = os.getcwd()
+                        
+                        integration = handler.get_integration(external_agent_name, workspace=workspace)
+                        
+                        if integration.is_available:
+                            ext_console.print(f"[bold cyan]🔌 Using external agent: {external_agent_name}[/bold cyan]")
+                            
+                            # Run the external agent directly instead of PraisonAI agent
+                            import asyncio
+                            try:
+                                result = asyncio.run(integration.execute(prompt))
+                                ext_console.print(f"\n[bold green]Result from {external_agent_name}:[/bold green]")
+                                ext_console.print(result)
+                                # Return empty string to avoid duplicate printing by caller
+                                return ""
+                            except Exception as e:
+                                ext_console.print(f"[red]Error executing {external_agent_name}: {e}[/red]")
+                                return None
+                        else:
+                            ext_console.print(f"[yellow]⚠️ External agent '{external_agent_name}' is not installed[/yellow]")
+                            ext_console.print(f"[dim]Install with: {handler._get_install_instructions(external_agent_name)}[/dim]")
+                            return None
+                    except Exception as e:
+                        ext_console.print(f"[red]Error setting up external agent: {e}[/red]")
+                        return None
+                
                 # Fast Context - Codebase search
                 if getattr(self.args, 'fast_context', None):
                     from .features.fast_context import FastContextHandler
@@ -3264,7 +3345,9 @@ Now, {final_instruction.lower()}:"""
             'result': None,
             'error': None,
             'start_time': time.time(),
-            'available_tools': tool_names
+            'available_tools': tool_names,
+            'approval_pending': False,  # Flag to pause Live display during approval
+            'live_instance': None  # Reference to Live instance for stopping
         }
         
         def tool_call_callback(message):
@@ -3327,6 +3410,53 @@ Now, {final_instruction.lower()}:"""
             finally:
                 status_info['done'] = True
         
+        # Set up approval callback that stops Live display before prompting
+        # Only if not using --trust (which auto-approves everything)
+        if not getattr(self.args, 'trust', False):
+            from praisonaiagents.approval import set_approval_callback, ApprovalDecision
+            from rich.prompt import Confirm
+            from rich.panel import Panel
+            
+            def cli_approval_with_live_pause(function_name, arguments, risk_level):
+                """Approval callback that stops Live display before prompting."""
+                # Signal to stop Live display
+                status_info['approval_pending'] = True
+                
+                # Wait a moment for Live to stop
+                time.sleep(0.2)
+                
+                # Now show the approval prompt
+                risk_colors = {"critical": "bold red", "high": "red", "medium": "yellow", "low": "blue"}
+                risk_color = risk_colors.get(risk_level, "white")
+                
+                tool_info = f"[bold]Function:[/] {function_name}\n"
+                tool_info += f"[bold]Risk Level:[/] [{risk_color}]{risk_level.upper()}[/{risk_color}]\n"
+                tool_info += "[bold]Arguments:[/]\n"
+                for key, value in arguments.items():
+                    str_value = str(value)[:100] + "..." if len(str(value)) > 100 else str(value)
+                    tool_info += f"  {key}: {str_value}\n"
+                
+                console.print(Panel(tool_info.strip(), title="🔒 Tool Approval Required", border_style=risk_color))
+                
+                try:
+                    approved = Confirm.ask(f"[{risk_color}]Execute this {risk_level} risk tool?[/{risk_color}]", default=False)
+                    status_info['approval_pending'] = False
+                    
+                    if approved:
+                        console.print("[green]✅ Approved[/green]")
+                        return ApprovalDecision(approved=True, reason="User approved")
+                    else:
+                        console.print("[red]❌ Denied[/red]")
+                        return ApprovalDecision(approved=False, reason="User denied")
+                except (KeyboardInterrupt, EOFError):
+                    status_info['approval_pending'] = False
+                    console.print("\n[red]❌ Cancelled[/red]")
+                    return ApprovalDecision(approved=False, reason="User cancelled")
+            
+            # Only set if not already set by --approve-level
+            if not getattr(self.args, 'approve_level', None):
+                set_approval_callback(cli_approval_with_live_pause)
+        
         # Start agent in background thread
         thread = threading.Thread(target=run_agent, daemon=True)
         thread.start()
@@ -3334,9 +3464,26 @@ Now, {final_instruction.lower()}:"""
         # Show live status while processing
         try:
             with Live(build_status_display(), console=console, refresh_per_second=4, transient=True) as live:
+                status_info['live_instance'] = live
                 while not status_info['done']:
+                    # Check if approval is pending - stop Live to show prompt
+                    if status_info['approval_pending']:
+                        break
                     live.update(build_status_display())
                     time.sleep(0.1)
+            
+            # If approval was pending, wait for it to complete then restart Live
+            while status_info['approval_pending']:
+                time.sleep(0.1)
+            
+            # Continue with Live display if not done
+            if not status_info['done']:
+                with Live(build_status_display(), console=console, refresh_per_second=4, transient=True) as live:
+                    while not status_info['done']:
+                        if status_info['approval_pending']:
+                            break
+                        live.update(build_status_display())
+                        time.sleep(0.1)
         except KeyboardInterrupt:
             console.print("\n[dim]Interrupted[/dim]")
             # Unregister callback

{praisonai-2.3.57 → praisonai-2.3.62}/praisonai/deploy.py

@@ -57,7 +57,7 @@ class CloudDeployer:
             file.write("FROM python:3.11-slim\n")
             file.write("WORKDIR /app\n")
             file.write("COPY . .\n")
-            file.write("RUN pip install flask praisonai==2.3.57 gunicorn markdown\n")
+            file.write("RUN pip install flask praisonai==2.3.62 gunicorn markdown\n")
             file.write("EXPOSE 8080\n")
             file.write('CMD ["gunicorn", "-b", "0.0.0.0:8080", "api:app"]\n')
             

{praisonai-2.3.57 → praisonai-2.3.62}/praisonai/integrations/base.py

@@ -135,7 +135,8 @@ class BaseCLIIntegration(ABC):
             *cmd,
             stdout=asyncio.subprocess.PIPE,
             stderr=asyncio.subprocess.PIPE,
-            cwd=self.workspace
+            cwd=self.workspace,
+            env=self.get_env()
         )
         
         try:
@@ -173,7 +174,8 @@ class BaseCLIIntegration(ABC):
             *cmd,
             stdout=asyncio.subprocess.PIPE,
             stderr=asyncio.subprocess.PIPE,
-            cwd=self.workspace
+            cwd=self.workspace,
+            env=self.get_env()
         )
         
         try:
@@ -208,7 +210,8 @@ class BaseCLIIntegration(ABC):
             *cmd,
             stdout=asyncio.subprocess.PIPE,
             stderr=asyncio.subprocess.PIPE,
-            cwd=self.workspace
+            cwd=self.workspace,
+            env=self.get_env()
         )
         
         try:

{praisonai-2.3.57 → praisonai-2.3.62}/praisonai/integrations/claude_code.py

@@ -127,23 +127,16 @@ class ClaudeCodeIntegration(BaseCLIIntegration):
         """
         cmd = ["claude"]
         
-        # Add continue flag if needed
-        if continue_session or self._session_active:
-            cmd.append("--continue")
-        
-        # Add skip permissions flag
-        if self.skip_permissions:
-            cmd.append("--dangerously-skip-permissions")
-        
-        # Add print mode flag
+        # Add print mode flag for non-interactive output
         cmd.append("-p")
         
-        # Add prompt
-        cmd.append(prompt)
-        
         # Add output format
         cmd.extend(["--output-format", self.output_format])
         
+        # Add continue flag if needed
+        if continue_session or self._session_active:
+            cmd.append("--continue")
+        
         # Add model if specified
         if self.model:
             cmd.extend(["--model", self.model])
@@ -160,6 +153,13 @@ class ClaudeCodeIntegration(BaseCLIIntegration):
         if self.disallowed_tools:
             cmd.extend(["--disallowedTools", ",".join(self.disallowed_tools)])
         
+        # Add verbose if needed
+        if options.get('verbose'):
+            cmd.append("--verbose")
+        
+        # Add prompt last
+        cmd.append(prompt)
+        
         return cmd
     
     async def execute(self, prompt: str, **options) -> str:

{praisonai-2.3.57 → praisonai-2.3.62}/praisonai/integrations/codex_cli.py

@@ -93,6 +93,9 @@ class CodexCLIIntegration(BaseCLIIntegration):
         """
         cmd = ["codex", "exec"]
         
+        # Add working directory
+        cmd.extend(["-C", self.workspace])
+        
         # Add task
         cmd.append(task)
         

{praisonai-2.3.57 → praisonai-2.3.62}/praisonai/integrations/cursor_cli.py

@@ -97,6 +97,9 @@ class CursorCLIIntegration(BaseCLIIntegration):
         # 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")

{praisonai-2.3.57 → praisonai-2.3.62}/praisonai/integrations/gemini_cli.py

@@ -92,12 +92,6 @@ class GeminiCLIIntegration(BaseCLIIntegration):
         """
         cmd = ["gemini"]
         
-        # Add print mode flag
-        cmd.append("-p")
-        
-        # Add prompt
-        cmd.append(prompt)
-        
         # Add model
         cmd.extend(["-m", self.model])
         
@@ -112,6 +106,12 @@ class GeminiCLIIntegration(BaseCLIIntegration):
         if self.sandbox:
             cmd.append("--sandbox")
         
+        # Add YOLO mode for non-interactive execution
+        cmd.append("--yolo")
+        
+        # Add prompt as positional argument (must be last)
+        cmd.append(prompt)
+        
         return cmd
     
     async def execute(self, prompt: str, **options) -> str:

praisonai-2.3.62/praisonai/version.py

@@ -0,0 +1 @@
+__version__ = "2.3.62"

{praisonai-2.3.57 → praisonai-2.3.62}/pyproject.toml

@@ -12,7 +12,7 @@ dependencies = [
     "rich>=13.7",
     "markdown>=3.5",
     "pyparsing>=3.0.0",
-    "praisonaiagents>=0.1.18",
+    "praisonaiagents>=0.1.21",
     "python-dotenv>=0.19.0",
     "instructor>=1.3.3",
     "PyYAML>=6.0",

praisonai-2.3.62/tests/test_approval_system.py

@@ -0,0 +1,221 @@
+"""
+Tests for the CLI approval system.
+
+Tests:
+1. --trust flag auto-approves all tools
+2. --approve-level flag with different risk levels
+3. Approval callback integration
+"""
+
+import pytest
+import sys
+import os
+
+# Add the src directory to the path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
+
+
+class TestApprovalFlags:
+    """Test CLI approval flags."""
+    
+    def test_trust_flag_exists(self):
+        """Test that --trust flag is defined in argparse."""
+        import argparse
+        
+        # Check that the args object has the trust attribute after parsing
+        # Parse with --help to avoid actually running anything
+        parser = argparse.ArgumentParser()
+        parser.add_argument("--trust", action="store_true")
+        parser.add_argument("--approve-level", type=str, choices=["low", "medium", "high", "critical"])
+        
+        # Test that the arguments can be parsed
+        args = parser.parse_args(['--trust'])
+        assert args.trust is True
+        
+        args = parser.parse_args([])
+        assert args.trust is False
+    
+    def test_approve_level_flag_exists(self):
+        """Test that --approve-level flag is defined in argparse."""
+        import argparse
+        
+        parser = argparse.ArgumentParser()
+        parser.add_argument("--approve-level", type=str, choices=["low", "medium", "high", "critical"])
+        
+        # Test that the arguments can be parsed
+        args = parser.parse_args(['--approve-level', 'high'])
+        assert args.approve_level == 'high'
+        
+        args = parser.parse_args(['--approve-level', 'critical'])
+        assert args.approve_level == 'critical'
+    
+    def test_trust_flag_in_praisonai_parser(self):
+        """Test that --trust flag is in PraisonAI's actual parser."""
+        from praisonai.cli.main import PraisonAI
+        
+        # Create instance - parse_args is called in __init__
+        praison = PraisonAI()
+        
+        # Call parse_args to get the args
+        args = praison.parse_args()
+        
+        # The args should have trust attribute after parse_args
+        assert hasattr(args, 'trust'), "PraisonAI.args should have 'trust' attribute"
+        # Cleanup
+        del praison
+    
+    def test_approve_level_flag_in_praisonai_parser(self):
+        """Test that --approve-level flag is in PraisonAI's actual parser."""
+        from praisonai.cli.main import PraisonAI
+        
+        # Create instance - parse_args is called in __init__
+        praison = PraisonAI()
+        
+        # Call parse_args to get the args
+        args = praison.parse_args()
+        
+        # The args should have approve_level attribute after parse_args
+        assert hasattr(args, 'approve_level'), "PraisonAI.args should have 'approve_level' attribute"
+
+
+class TestApprovalCallback:
+    """Test approval callback system."""
+    
+    def test_set_approval_callback(self):
+        """Test that we can set a custom approval callback."""
+        from praisonaiagents.approval import set_approval_callback, ApprovalDecision
+        
+        callback_called = []
+        
+        def custom_callback(function_name, arguments, risk_level):
+            callback_called.append((function_name, arguments, risk_level))
+            return ApprovalDecision(approved=True, reason="Test approved")
+        
+        set_approval_callback(custom_callback)
+        
+        # Verify callback was set
+        from praisonaiagents.approval import approval_callback
+        assert approval_callback == custom_callback
+        
+        # Reset callback
+        set_approval_callback(None)
+    
+    def test_auto_approve_callback(self):
+        """Test auto-approve callback returns approved decision."""
+        from praisonaiagents.approval import ApprovalDecision
+        
+        def auto_approve_callback(function_name, arguments, risk_level):
+            return ApprovalDecision(approved=True, reason="Auto-approved")
+        
+        decision = auto_approve_callback("execute_command", {"command": "ls"}, "critical")
+        assert decision.approved is True
+        assert decision.reason == "Auto-approved"
+    
+    def test_level_based_callback(self):
+        """Test level-based approval callback."""
+        from praisonaiagents.approval import ApprovalDecision
+        
+        def level_based_callback(function_name, arguments, risk_level, max_level="high"):
+            """Approve based on risk level threshold."""
+            levels = {"low": 1, "medium": 2, "high": 3, "critical": 4}
+            tool_level = levels.get(risk_level, 4)
+            max_allowed = levels.get(max_level, 3)
+            
+            if tool_level <= max_allowed:
+                return ApprovalDecision(approved=True, reason=f"Auto-approved (level {risk_level} <= {max_level})")
+            else:
+                return ApprovalDecision(approved=False, reason=f"Denied (level {risk_level} > {max_level})")
+        
+        # Test with max_level="high"
+        # Should approve low, medium, high but deny critical
+        assert level_based_callback("test", {}, "low", "high").approved is True
+        assert level_based_callback("test", {}, "medium", "high").approved is True
+        assert level_based_callback("test", {}, "high", "high").approved is True
+        assert level_based_callback("test", {}, "critical", "high").approved is False
+        
+        # Test with max_level="critical"
+        # Should approve everything
+        assert level_based_callback("test", {}, "critical", "critical").approved is True
+
+
+class TestApprovalRequirements:
+    """Test approval requirement configuration."""
+    
+    def test_default_dangerous_tools(self):
+        """Test that default dangerous tools are configured."""
+        from praisonaiagents.approval import APPROVAL_REQUIRED_TOOLS, TOOL_RISK_LEVELS
+        
+        # Check critical tools
+        assert "execute_command" in APPROVAL_REQUIRED_TOOLS
+        assert TOOL_RISK_LEVELS.get("execute_command") == "critical"
+        
+        # Check high risk tools
+        assert "write_file" in APPROVAL_REQUIRED_TOOLS
+        assert TOOL_RISK_LEVELS.get("write_file") == "high"
+    
+    def test_remove_approval_requirement(self):
+        """Test removing approval requirement."""
+        from praisonaiagents.approval import (
+            add_approval_requirement, 
+            remove_approval_requirement,
+            is_approval_required,
+            APPROVAL_REQUIRED_TOOLS
+        )
+        
+        # Add a test tool
+        add_approval_requirement("test_tool", "medium")
+        assert is_approval_required("test_tool") is True
+        
+        # Remove it
+        remove_approval_requirement("test_tool")
+        assert is_approval_required("test_tool") is False
+    
+    def test_is_approval_required(self):
+        """Test checking if approval is required."""
+        from praisonaiagents.approval import is_approval_required
+        
+        # execute_command should require approval
+        assert is_approval_required("execute_command") is True
+        
+        # read_file should not require approval
+        assert is_approval_required("read_file") is False
+        
+        # list_files should not require approval
+        assert is_approval_required("list_files") is False
+
+
+class TestApprovalDecision:
+    """Test ApprovalDecision class."""
+    
+    def test_approval_decision_approved(self):
+        """Test approved decision."""
+        from praisonaiagents.approval import ApprovalDecision
+        
+        decision = ApprovalDecision(approved=True, reason="User approved")
+        assert decision.approved is True
+        assert decision.reason == "User approved"
+        assert decision.modified_args == {}
+    
+    def test_approval_decision_denied(self):
+        """Test denied decision."""
+        from praisonaiagents.approval import ApprovalDecision
+        
+        decision = ApprovalDecision(approved=False, reason="User denied")
+        assert decision.approved is False
+        assert decision.reason == "User denied"
+    
+    def test_approval_decision_with_modified_args(self):
+        """Test decision with modified arguments."""
+        from praisonaiagents.approval import ApprovalDecision
+        
+        decision = ApprovalDecision(
+            approved=True, 
+            reason="Approved with modifications",
+            modified_args={"command": "ls -la"}
+        )
+        assert decision.approved is True
+        assert decision.modified_args == {"command": "ls -la"}
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

praisonai-2.3.57/praisonai/version.py

@@ -1 +0,0 @@
-__version__ = "2.3.57"