praisonai-code 0.0.1__py3-none-any.whl

praisonai_code/cli/approval_backend.py

@@ -0,0 +1,272 @@
+"""
+Interactive CLI approval backend for PraisonAI.
+
+Provides interactive prompts for tool approval with persistent rules.
+"""
+
+import asyncio
+import os
+from typing import Optional, Dict, Any
+
+from praisonaiagents.approval import ApprovalRequest, ApprovalDecision
+from praisonaiagents.permissions import (
+    PermissionManager,
+    PermissionRule,
+    PermissionAction,
+    PermissionMode,
+)
+
+
+class InteractiveCLIApprovalBackend:
+    """
+    Interactive CLI backend for tool approvals.
+    
+    Provides terminal prompts with options to:
+    - Allow once
+    - Always allow (persist as rule)
+    - Deny
+    
+    Integrates with PermissionManager for persistent project-scoped rules.
+    """
+    
+    def __init__(
+        self,
+        project_dir: Optional[str] = None,
+        permission_mode: PermissionMode = PermissionMode.DEFAULT,
+        non_interactive: bool = False,
+        permissions_config: Optional[Dict[str, Any]] = None,
+    ):
+        """
+        Initialize the interactive CLI approval backend.
+        
+        Args:
+            project_dir: Project directory for scoped permissions
+            permission_mode: Permission mode (default, accept_edits, dont_ask, bypass, plan)
+            non_interactive: Whether to auto-approve/deny without prompting
+            permissions_config: Declarative permission rules from YAML/CLI/Python
+        """
+        self.project_dir = project_dir or os.getcwd()
+        self.permission_mode = permission_mode
+        self.non_interactive = non_interactive
+        
+        # Initialize permission manager with project-scoped storage
+        permissions_dir = os.path.join(self.project_dir, ".praisonai", "permissions")
+        self.permission_manager = PermissionManager(storage_dir=permissions_dir)
+        
+        # Load declarative permissions if provided
+        if permissions_config:
+            self.permission_manager.load_rules_from_config(permissions_config, priority_base=75)
+    
+    def _build_target_string(self, request: ApprovalRequest) -> str:
+        """Build target string for permission check."""
+        if "command" in request.arguments:
+            return f"{request.tool_name}:{request.arguments['command']}"
+        elif request.arguments:
+            # Include first arg value for more specific matching
+            first_arg = next(iter(request.arguments.values()), "")
+            if isinstance(first_arg, str) and len(first_arg) < 100:
+                return f"{request.tool_name}:{first_arg}"
+        # Use wildcard for consistency with permission patterns
+        return f"{request.tool_name}:*"
+    
+    def _format_tool_call(self, request: ApprovalRequest) -> str:
+        """Format a tool call for display."""
+        tool_name = request.tool_name
+        args = request.arguments
+        
+        # Format arguments nicely
+        if args:
+            arg_strs = []
+            for key, value in args.items():
+                if isinstance(value, str) and len(value) > 50:
+                    value = value[:47] + "..."
+                arg_strs.append(f"{key}={repr(value)}")
+            args_display = ", ".join(arg_strs)
+        else:
+            args_display = ""
+        
+        return f"{tool_name}({args_display})"
+    
+    def _prompt_user(self, request: ApprovalRequest) -> tuple[bool, bool]:
+        """
+        Prompt user for approval decision.
+        
+        Returns:
+            Tuple of (approved, persist_as_always)
+        """
+        if self.non_interactive:
+            # In non-interactive mode, we're only here if the check returned ASK
+            # (ALLOW/DENY are handled in request_approval), so default to deny
+            return (False, False)
+        
+        # Interactive prompt
+        tool_display = self._format_tool_call(request)
+        risk_color = {
+            "critical": "\033[91m",  # Red
+            "high": "\033[93m",      # Yellow
+            "medium": "\033[96m",    # Cyan
+            "low": "\033[92m",       # Green
+        }.get(request.risk_level, "\033[0m")
+        
+        print(f"\n{risk_color}⚠ Tool Approval Required{chr(27)}[0m")
+        print(f"Tool: {tool_display}")
+        print(f"Risk: {request.risk_level}")
+        if request.agent_name:
+            print(f"Agent: {request.agent_name}")
+        
+        print("\nOptions:")
+        print("  [a] Allow once")
+        print("  [A] Always allow (persist rule)")
+        print("  [d] Deny")
+        print("  [D] Always deny (persist rule)")
+        
+        while True:
+            try:
+                choice = input("\nYour choice: ").strip()
+                
+                if choice == "a":
+                    return (True, False)
+                elif choice == "A":
+                    return (True, True)
+                elif choice == "d":
+                    return (False, False)
+                elif choice == "D":
+                    return (False, True)
+                else:
+                    print("Invalid choice. Please enter a, A, d, or D.")
+            except (EOFError, KeyboardInterrupt):
+                print("\n\nApproval cancelled.")
+                return (False, False)
+    
+    def _create_pattern(self, request: ApprovalRequest) -> str:
+        """Create a permission pattern from the request."""
+        # Create a pattern that matches this specific tool
+        # Can be made more sophisticated to support wildcards
+        tool_name = request.tool_name
+        
+        # For certain tools, we can create broader patterns
+        if tool_name == "bash" and "command" in request.arguments:
+            cmd = request.arguments["command"]
+            # Extract first word as command type
+            cmd_parts = cmd.split()
+            if cmd_parts:
+                first_word = cmd_parts[0]
+                # For git commands, create pattern for all git commands
+                if first_word == "git":
+                    return f"{tool_name}:git *"
+                # For safe commands, broader patterns
+                elif first_word in ["ls", "pwd", "echo", "cat", "grep"]:
+                    return f"{tool_name}:{first_word} *"
+        
+        # Default to exact tool name
+        return f"{tool_name}:*"
+    
+    def _decision_from_mode(self, request: ApprovalRequest) -> Optional[ApprovalDecision]:
+        """
+        Check if permission mode provides an immediate decision.
+        
+        Returns None if mode doesn't apply, otherwise returns the decision.
+        """
+        # BYPASS mode: unconditional allow
+        if self.permission_mode == PermissionMode.BYPASS:
+            return ApprovalDecision(
+                approved=True,
+                reason="Bypassed by permission mode",
+                approver="permission_mode"
+            )
+        
+        # PLAN mode: unconditional deny for write/edit/shell operations
+        if self.permission_mode == PermissionMode.PLAN:
+            if request.tool_name in ["write", "edit", "delete", "bash", "shell"]:
+                return ApprovalDecision(
+                    approved=False,
+                    reason="Blocked by plan mode",
+                    approver="permission_mode"
+                )
+        
+        # ACCEPT_EDITS mode: unconditional allow for edit/write operations
+        if self.permission_mode == PermissionMode.ACCEPT_EDITS:
+            if "edit" in request.tool_name.lower() or "write" in request.tool_name.lower():
+                return ApprovalDecision(
+                    approved=True,
+                    reason="Auto-approved edit by permission mode",
+                    approver="permission_mode"
+                )
+        
+        # DONT_ASK mode in non-interactive: deny all asks
+        if self.permission_mode == PermissionMode.DONT_ASK and self.non_interactive:
+            return ApprovalDecision(
+                approved=False,
+                reason="Denied by don't-ask mode",
+                approver="permission_mode"
+            )
+        
+        return None
+    
+    async def request_approval(self, request: ApprovalRequest) -> ApprovalDecision:
+        """
+        Request approval for a tool execution.
+        
+        First checks permission modes, then existing rules, then prompts if needed.
+        """
+        # Check permission mode first (takes precedence)
+        mode_decision = self._decision_from_mode(request)
+        if mode_decision is not None:
+            return mode_decision
+        
+        # Build target string for permission check
+        target = self._build_target_string(request)
+        
+        # Check existing permissions
+        result = self.permission_manager.check(target, agent_name=request.agent_name)
+        
+        if result.action == PermissionAction.ALLOW:
+            return ApprovalDecision(
+                approved=True,
+                reason="Allowed by rule",
+                approver="permission_rule",
+                metadata={"rule_id": result.rule.id if result.rule else None}
+            )
+        elif result.action == PermissionAction.DENY:
+            return ApprovalDecision(
+                approved=False,
+                reason="Denied by rule",
+                approver="permission_rule",
+                metadata={"rule_id": result.rule.id if result.rule else None}
+            )
+        
+        # Need to ask - run prompt in thread to avoid blocking
+        loop = asyncio.get_running_loop()
+        approved, persist = await loop.run_in_executor(
+            None, self._prompt_user, request
+        )
+        
+        # If user wants to persist the decision
+        if persist:
+            pattern = self._create_pattern(request)
+            action = PermissionAction.ALLOW if approved else PermissionAction.DENY
+            
+            # Create and add the rule
+            rule = PermissionRule(
+                pattern=pattern,
+                action=action,
+                description=f"User {'allowed' if approved else 'denied'} {request.tool_name}",
+                agent_name=request.agent_name,
+                priority=100,  # User rules have high priority
+            )
+            self.permission_manager.add_rule(rule)
+        
+        return ApprovalDecision(
+            approved=approved,
+            reason="User decision" + (" (persisted)" if persist else ""),
+            approver="user",
+            metadata={"persistent": persist}
+        )
+    
+    def set_permission_mode(self, mode: PermissionMode):
+        """Update the permission mode."""
+        self.permission_mode = mode
+    
+    def get_permission_manager(self) -> PermissionManager:
+        """Get the underlying permission manager for direct access."""
+        return self.permission_manager

praisonai_code/cli/branding.py

@@ -0,0 +1,94 @@
+"""
+PraisonAI Branding - Single Source of Truth.
+
+This module provides unified branding assets (logo, version, product name)
+for all interactive UIs. All frontends should import from here.
+
+Usage:
+    from praisonai.cli.branding import get_logo, get_version, PRODUCT_NAME
+"""
+
+# Product name
+PRODUCT_NAME = "Praison AI"
+
+# ASCII Art Logos - responsive to terminal width
+LOGO_LARGE = r"""
+ ██████╗ ██████╗  █████╗ ██╗███████╗ ██████╗ ███╗   ██╗     █████╗ ██╗
+ ██╔══██╗██╔══██╗██╔══██╗██║██╔════╝██╔═══██╗████╗  ██║    ██╔══██╗██║
+ ██████╔╝██████╔╝███████║██║███████╗██║   ██║██╔██╗ ██║    ███████║██║
+ ██╔═══╝ ██╔══██╗██╔══██║██║╚════██║██║   ██║██║╚██╗██║    ██╔══██║██║
+ ██║     ██║  ██║██║  ██║██║███████║╚██████╔╝██║ ╚████║    ██║  ██║██║
+ ╚═╝     ╚═╝  ╚═╝╚═╝  ╚═╝╚═╝╚══════╝ ╚═════╝ ╚═╝  ╚═══╝    ╚═╝  ╚═╝╚═╝
+"""
+
+LOGO_MEDIUM = r"""
+ ╔═╗┬─┐┌─┐┬┌─┐┌─┐┌┐┌  ╔═╗╦
+ ╠═╝├┬┘├─┤│└─┐│ ││││  ╠═╣║
+ ╩  ┴└─┴ ┴┴└─┘└─┘┘└┘  ╩ ╩╩
+"""
+
+LOGO_SMALL = "▶ Praison AI"
+
+LOGO_MINIMAL = "Praison AI"
+
+
+def get_version() -> str:
+    """Get PraisonAI version string."""
+    try:
+        from praisonai import __version__
+        return __version__
+    except Exception:
+        return "1.0.0"
+
+
+def get_logo(width: int = 80) -> str:
+    """
+    Get appropriate logo based on terminal width.
+    
+    Args:
+        width: Terminal width in characters
+        
+    Returns:
+        ASCII art logo string appropriate for the width
+    """
+    if width >= 75:
+        return LOGO_LARGE
+    elif width >= 40:
+        return LOGO_MEDIUM
+    else:
+        return LOGO_SMALL
+
+
+def get_banner(width: int = 80, show_version: bool = True, model: str = None) -> str:
+    """
+    Get full banner with logo, version, and optional model info.
+    
+    Args:
+        width: Terminal width
+        show_version: Whether to include version
+        model: Optional model name to display
+        
+    Returns:
+        Complete banner string
+    """
+    lines = []
+    
+    # Logo
+    logo = get_logo(width)
+    lines.append(logo.strip())
+    lines.append("")
+    
+    # Version and model
+    version_line = f"  v{get_version()}"
+    if model:
+        version_line += f" · Model: {model}"
+    lines.append(version_line)
+    lines.append("")
+    
+    return "\n".join(lines)
+
+
+def get_welcome_tips() -> str:
+    """Get welcome tips for new sessions."""
+    return """  Type your message and press Enter. Use /help for commands.
+  Use PageUp/PageDown or Ctrl+Up/Down to scroll."""

praisonai_code/cli/commands/__init__.py

@@ -0,0 +1,114 @@
+"""
+PraisonAI Code CLI Commands Module.
+
+Agentic Typer command groups moved from ``praisonai.cli.commands`` as part
+of the praisonai-code extraction (issue #2516 / parent #2512). Bot-channel
+commands remain in ``praisonai.cli.commands``.
+
+Lazy imports keep startup fast; each attribute maps to the ``app`` object of
+the corresponding command module.
+"""
+
+__all__ = [
+    'run_app',
+    'config_app',
+    'traces_app',
+    'env_app',
+    'session_app',
+    'schedule_app',
+    'serve_app',
+    'completion_app',
+    'version_app',
+    'debug_app',
+    'lsp_app',
+    'diag_app',
+    'doctor_app',
+    'setup_app',
+    'acp_app',
+    'mcp_app',
+    'rag_app',
+    'test_app',
+    'examples_app',
+    'replay_app',
+    'github_app',
+    'langextract_app',
+    'agent_app',
+    'command_app',
+]
+
+
+def __getattr__(name: str):
+    """Lazy load command apps."""
+    if name == 'run_app':
+        from .run import app as run_app
+        return run_app
+    elif name == 'config_app':
+        from .config import app as config_app
+        return config_app
+    elif name == 'traces_app':
+        from .traces import app as traces_app
+        return traces_app
+    elif name == 'env_app':
+        from .environment import app as env_app
+        return env_app
+    elif name == 'session_app':
+        from .session import app as session_app
+        return session_app
+    elif name == 'schedule_app':
+        from .schedule import app as schedule_app
+        return schedule_app
+    elif name == 'serve_app':
+        from .serve import app as serve_app
+        return serve_app
+    elif name == 'completion_app':
+        from .completion import app as completion_app
+        return completion_app
+    elif name == 'version_app':
+        from .version import app as version_app
+        return version_app
+    elif name == 'debug_app':
+        from .debug import app as debug_app
+        return debug_app
+    elif name == 'lsp_app':
+        from .lsp import app as lsp_app
+        return lsp_app
+    elif name == 'diag_app':
+        from .diag import app as diag_app
+        return diag_app
+    elif name == 'doctor_app':
+        from .doctor import app as doctor_app
+        return doctor_app
+    elif name == 'setup_app':
+        from .setup import app as setup_app
+        return setup_app
+    elif name == 'acp_app':
+        from .acp import app as acp_app
+        return acp_app
+    elif name == 'mcp_app':
+        from .mcp import app as mcp_app
+        return mcp_app
+    elif name == 'rag_app':
+        from .rag import app as rag_app
+        return rag_app
+    elif name == 'test_app':
+        from .test import app as test_app
+        return test_app
+    elif name == 'examples_app':
+        from .examples import app as examples_app
+        return examples_app
+    elif name == 'replay_app':
+        from .replay import app as replay_app
+        return replay_app
+    elif name == 'github_app':
+        from .github import app as github_app
+        return github_app
+    elif name == 'langextract_app':
+        from .langextract import app as langextract_app
+        return langextract_app
+    elif name == 'agent_app':
+        from .agent import app as agent_app
+        return agent_app
+    elif name == 'command_app':
+        from .command import app as command_app
+        return command_app
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

praisonai_code/cli/commands/acp.py

@@ -0,0 +1,80 @@
+"""
+ACP command group for PraisonAI CLI.
+
+Wraps existing ACP functionality from features/acp.py.
+Provides Agent Client Protocol server for IDE integration.
+"""
+
+from typing import Optional
+
+import typer
+
+from ..output.console import get_output_controller
+
+app = typer.Typer(help="Agent Client Protocol server")
+
+
+@app.callback(invoke_without_command=True)
+def acp_main(
+    ctx: typer.Context,
+    workspace: str = typer.Option(".", "--workspace", "-w", help="Workspace root directory"),
+    agent: str = typer.Option("default", "--agent", "-a", help="Agent name or configuration file"),
+    agents_file: Optional[str] = typer.Option(None, "--agents", help="Multi-agent configuration YAML file"),
+    router: bool = typer.Option(False, "--router", help="Enable router agent for task delegation"),
+    model: Optional[str] = typer.Option(None, "--model", "-m", help="LLM model to use"),
+    resume: Optional[str] = typer.Option(None, "--resume", "-r", help="Resume session by ID"),
+    last: bool = typer.Option(False, "--last", help="Resume the last session"),
+    approve: str = typer.Option("manual", "--approve", help="Approval mode: manual, auto, scoped"),
+    read_only: bool = typer.Option(True, "--read-only/--allow-write", help="Read-only mode"),
+    allow_shell: bool = typer.Option(False, "--allow-shell", help="Allow shell command execution"),
+    allow_network: bool = typer.Option(False, "--allow-network", help="Allow network requests"),
+    debug: bool = typer.Option(False, "--debug", help="Enable debug logging"),
+    profile: Optional[str] = typer.Option(None, "--profile", help="Use named profile from config"),
+):
+    """Start ACP server for IDE integration.
+    
+    DEPRECATED: Use `praisonai serve acp` instead.
+    """
+    import sys
+    
+    # Print deprecation warning
+    print("\n\033[93m⚠ DEPRECATION WARNING:\033[0m", file=sys.stderr)
+    print("\033[93m'praisonai acp' is deprecated and will be removed in a future version.\033[0m", file=sys.stderr)
+    print("\033[93mPlease use 'praisonai serve acp' instead.\033[0m\n", file=sys.stderr)
+    
+    # Build args for existing handler
+    args = [
+        "--workspace", workspace,
+        "--agent", agent,
+        "--approve", approve,
+    ]
+    
+    if agents_file:
+        args.extend(["--agents", agents_file])
+    if router:
+        args.append("--router")
+    if model:
+        args.extend(["--model", model])
+    if resume:
+        args.extend(["--resume", resume])
+    if last:
+        args.append("--last")
+    if not read_only:
+        args.append("--allow-write")
+    if allow_shell:
+        args.append("--allow-shell")
+    if allow_network:
+        args.append("--allow-network")
+    if debug:
+        args.append("--debug")
+    if profile:
+        args.extend(["--profile", profile])
+    
+    try:
+        from praisonai.cli.features.acp import run_acp_command
+        exit_code = run_acp_command(args)
+        raise typer.Exit(exit_code)
+    except ImportError as e:
+        output = get_output_controller()
+        output.print_error(f"ACP module not available: {e}")
+        raise typer.Exit(4)

praisonai_code/cli/commands/agent.py

@@ -0,0 +1,116 @@
+"""
+Agent management commands for PraisonAI CLI.
+
+Provides commands to list and inspect custom agent definitions.
+"""
+
+from typing import Optional
+
+import typer
+
+from ..output.console import get_output_controller
+
+app = typer.Typer(help="Manage custom agents")
+
+
+@app.command()
+def list(
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Show detailed information"),
+):
+    """List all discovered custom agents."""
+    output = get_output_controller()
+    
+    try:
+        from praisonai.cli.features.custom_definitions import CustomDefinitionsDiscovery
+        
+        discovery = CustomDefinitionsDiscovery()
+        discovery.discover()
+        
+        agents = discovery.list_agents()
+        
+        if not agents:
+            output.print_info("No custom agents found.")
+            output.print_info("Run 'praisonai init' to scaffold a starter .praisonai/ project,")
+            output.print_info("or create agents in .praisonai/agents/*.md or ~/.praisonai/agents/*.md")
+            return
+        
+        from rich.table import Table
+        from rich.console import Console
+        
+        console = Console()
+        table = Table(title="Custom Agents", show_header=True)
+        table.add_column("Name", style="cyan")
+        table.add_column("Source", style="yellow")
+        table.add_column("Model", style="green")
+        
+        if verbose:
+            table.add_column("Path", style="dim")
+            table.add_column("Role", style="magenta")
+        
+        for agent in agents:
+            row = [
+                agent.name,
+                agent.source,
+                agent.model or "default",
+            ]
+            
+            if verbose:
+                row.extend([
+                    str(agent.path),
+                    agent.role or "Assistant"
+                ])
+            
+            table.add_row(*row)
+        
+        console.print(table)
+        
+    except Exception as e:
+        output.print_error(str(e))
+        raise typer.Exit(1)
+
+
+@app.command()
+def show(
+    name: str = typer.Argument(help="Agent name to inspect"),
+):
+    """Show details of a specific agent."""
+    output = get_output_controller()
+    
+    try:
+        from praisonai.cli.features.custom_definitions import CustomDefinitionsDiscovery
+        
+        discovery = CustomDefinitionsDiscovery()
+        agent = discovery.get_agent(name)
+        
+        if not agent:
+            output.print_error(f"Agent '{name}' not found")
+            raise typer.Exit(1)
+        
+        from rich.console import Console
+        from rich.panel import Panel
+        from rich.syntax import Syntax
+        
+        console = Console()
+        
+        # Build agent info
+        info = f"""[bold cyan]Agent: {agent.name}[/bold cyan]
+[yellow]Source:[/yellow] {agent.source}
+[yellow]Path:[/yellow] {agent.path}
+[yellow]Model:[/yellow] {agent.model or 'default'}
+[yellow]Role:[/yellow] {agent.role or 'Assistant'}
+[yellow]Goal:[/yellow] {agent.goal or 'N/A'}"""
+        
+        console.print(Panel(info, title="Agent Details", border_style="cyan"))
+        
+        if agent.instructions or agent.system_prompt:
+            prompt_text = agent.instructions or agent.system_prompt
+            syntax = Syntax(prompt_text, "markdown", theme="monokai", line_numbers=False)
+            console.print(Panel(syntax, title="System Prompt", border_style="green"))
+        
+        if agent.tools:
+            tools_text = "\n".join(f"- {tool}" for tool in agent.tools)
+            console.print(Panel(tools_text, title="Tools", border_style="yellow"))
+    
+    except Exception as e:
+        output.print_error(str(e))
+        raise typer.Exit(1)