praisonai-code 0.0.1__py3-none-any.whl

praisonai_code/cli/commands/agents.py

@@ -0,0 +1,80 @@
+"""
+Agents command group for PraisonAI CLI.
+
+Provides agent management commands.
+"""
+
+import typer
+
+app = typer.Typer(help="Agent management")
+
+
+@app.command("list")
+def agents_list(
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Show detailed info"),
+):
+    """List available agents."""
+    from praisonai.cli.main import PraisonAI
+    import sys
+    
+    argv = ['agents', 'list']
+    if verbose:
+        argv.append('--verbose')
+    
+    original_argv = sys.argv
+    sys.argv = ['praisonai'] + argv
+    
+    try:
+        praison = PraisonAI()
+        praison.main()
+    except SystemExit:
+        pass
+    finally:
+        sys.argv = original_argv
+
+
+@app.command("create")
+def agents_create(
+    name: str = typer.Argument(..., help="Agent name"),
+    template: str = typer.Option(None, "--template", "-t", help="Template to use"),
+):
+    """Create a new agent."""
+    from praisonai.cli.main import PraisonAI
+    import sys
+    
+    argv = ['agents', 'create', name]
+    if template:
+        argv.extend(['--template', template])
+    
+    original_argv = sys.argv
+    sys.argv = ['praisonai'] + argv
+    
+    try:
+        praison = PraisonAI()
+        praison.main()
+    except SystemExit:
+        pass
+    finally:
+        sys.argv = original_argv
+
+
+@app.command("info")
+def agents_info(
+    name: str = typer.Argument(..., help="Agent name"),
+):
+    """Show agent information."""
+    from praisonai.cli.main import PraisonAI
+    import sys
+    
+    argv = ['agents', 'info', name]
+    
+    original_argv = sys.argv
+    sys.argv = ['praisonai'] + argv
+    
+    try:
+        praison = PraisonAI()
+        praison.main()
+    except SystemExit:
+        pass
+    finally:
+        sys.argv = original_argv

praisonai_code/cli/commands/app.py

@@ -0,0 +1,139 @@
+"""
+CLI command for AgentOS - production deployment of AI agents.
+
+Usage:
+    praisonai app                    # Start server with default config
+    praisonai app --port 9000        # Start on custom port
+    praisonai app --config app.yaml  # Load from config file
+    praisonai app --reload           # Enable auto-reload for development
+"""
+
+import click
+from typing import Optional
+
+
+@click.command("app")
+@click.option("--port", "-p", type=int, default=8000, help="Port to listen on")
+@click.option("--host", "-h", type=str, default="0.0.0.0", help="Host to bind to")
+@click.option("--config", "-c", type=click.Path(exists=True), help="Path to config file (YAML)")
+@click.option("--reload", "-r", is_flag=True, help="Enable auto-reload for development")
+@click.option("--debug", "-d", is_flag=True, help="Enable debug mode")
+@click.option("--name", "-n", type=str, default="PraisonAI App", help="Application name")
+def app_command(
+    port: int,
+    host: str,
+    config: Optional[str],
+    reload: bool,
+    debug: bool,
+    name: str,
+):
+    """
+    Start an AgentOS server for production deployment.
+    
+    AgentOS provides a FastAPI-based web service for deploying AI agents
+    with REST and WebSocket endpoints.
+    
+    Examples:
+    
+        # Start with defaults (port 8000)
+        praisonai app
+        
+        # Start on custom port
+        praisonai app --port 9000
+        
+        # Enable auto-reload for development
+        praisonai app --reload
+        
+        # Load agents from config file
+        praisonai app --config agents.yaml
+    """
+    from rich.console import Console
+    console = Console()
+    
+    try:
+        from praisonai import AgentOS
+        from praisonaiagents import AgentOSConfig
+    except ImportError as e:
+        console.print(f"[red]Error importing AgentOS: {e}[/red]")
+        console.print("[yellow]Install with: pip install praisonai[api][/yellow]")
+        raise click.Abort()
+    
+    # Load agents from config file if provided
+    agents = []
+    if config:
+        agents = _load_agents_from_config(config, console)
+    
+    # Create config
+    app_config = AgentOSConfig(
+        name=name,
+        host=host,
+        port=port,
+        reload=reload,
+        debug=debug,
+    )
+    
+    # Create and start app
+    console.print(f"\n[bold green]🚀 Starting {name}[/bold green]")
+    console.print(f"[dim]Host: {host}:{port}[/dim]")
+    if agents:
+        console.print(f"[dim]Agents: {len(agents)}[/dim]")
+    if reload:
+        console.print("[yellow]Auto-reload enabled (development mode)[/yellow]")
+    console.print()
+    
+    try:
+        agent_app = AgentOS(
+            name=name,
+            agents=agents,
+            config=app_config,
+        )
+        agent_app.serve()
+    except ImportError as e:
+        console.print(f"[red]Missing dependency: {e}[/red]")
+        console.print("[yellow]Install with: pip install praisonai[api][/yellow]")
+        raise click.Abort()
+    except Exception as e:
+        console.print(f"[red]Error starting server: {e}[/red]")
+        raise click.Abort()
+
+
+def _load_agents_from_config(config_path: str, console) -> list:
+    """Load agents from a YAML config file."""
+    import yaml
+    from pathlib import Path
+    
+    try:
+        with open(config_path, 'r') as f:
+            config_data = yaml.safe_load(f)
+    except Exception as e:
+        console.print(f"[red]Error loading config: {e}[/red]")
+        return []
+    
+    if not config_data:
+        return []
+    
+    agents = []
+    
+    # Try to load agents from config
+    agents_config = config_data.get('agents', [])
+    if not agents_config and 'agent' in config_data:
+        agents_config = [config_data['agent']]
+    
+    if agents_config:
+        try:
+            from praisonaiagents import Agent
+            
+            for agent_data in agents_config:
+                if isinstance(agent_data, dict):
+                    agent = Agent(
+                        name=agent_data.get('name', 'Agent'),
+                        role=agent_data.get('role'),
+                        instructions=agent_data.get('instructions', agent_data.get('goal', '')),
+                        llm=agent_data.get('llm'),
+                    )
+                    agents.append(agent)
+                    console.print(f"[green]✓ Loaded agent: {agent.name}[/green]")
+        except Exception as e:
+            console.print(f"[yellow]Warning: Could not load agents from config: {e}[/yellow]")
+    
+    return agents

praisonai_code/cli/commands/attach.py

@@ -0,0 +1,95 @@
+"""
+Attach command for PraisonAI CLI.
+
+Subscribe to a live session running on the warm local runtime and stream its
+events in real time from another terminal. Multiple clients can attach to the
+same active session and observe it concurrently.
+
+    praisonai attach <session-id>
+
+The runtime must be running (``praisonai daemon start``) and a ``praisonai run``
+must have been issued against the same session id (``run --attach <id>``) for
+events to appear. Attaching is read-only: it never starts execution itself.
+"""
+
+import json as _json
+
+import typer
+
+from ..output.console import get_output_controller
+
+app = typer.Typer(help="Attach to a live session on the warm runtime")
+
+
+@app.callback(invoke_without_command=True)
+def attach_main(
+    ctx: typer.Context,
+    session_id: str = typer.Argument(..., help="Session id to attach to"),
+    json_output: bool = typer.Option(False, "--json", help="Emit raw NDJSON events"),
+):
+    """Stream live events for a running session.
+
+    Examples:
+        praisonai attach my-session
+        praisonai attach my-session --json
+    """
+    if ctx.invoked_subcommand is not None:
+        return
+
+    output = get_output_controller()
+
+    try:
+        from praisonai.runtime import (
+            get_runtime_descriptor,
+            RuntimeClient,
+            RuntimeUnavailable,
+        )
+    except ImportError as e:
+        output.print_error(f"Runtime module not available: {e}")
+        raise typer.Exit(4)
+
+    # Require a compatible runtime (same major version) so we never attach to an
+    # older runtime that lacks /sessions/{id}/events or speaks a different event
+    # contract — mirrors the gate the `run` path uses before reusing a runtime.
+    descriptor = get_runtime_descriptor(require_compatible=True)
+    if descriptor is None:
+        output.print_error(
+            "No compatible warm runtime is running. Start one with: praisonai daemon start"
+        )
+        raise typer.Exit(1)
+
+    client = RuntimeClient(descriptor)
+
+    if not json_output:
+        output.print_info(f"Attached to session '{session_id}'. Ctrl-C to detach.")
+
+    try:
+        for event in client.attach(session_id):
+            if json_output:
+                print(_json.dumps(event), flush=True)
+                continue
+            _render_event(output, event)
+    except RuntimeUnavailable as e:
+        output.print_error(f"Lost connection to runtime: {e}")
+        raise typer.Exit(1)
+    except KeyboardInterrupt:
+        if not json_output:
+            output.print_info("Detached.")
+        raise typer.Exit(0)
+
+
+def _render_event(output, event: dict) -> None:
+    """Render a single session event for human-readable terminals."""
+    etype = event.get("type", "event")
+    if etype == "run.start":
+        prompt = event.get("prompt", "")
+        output.print_info(f"▶ run.start: {prompt}")
+    elif etype == "run.result":
+        result = event.get("result", "")
+        output.print_success("✓ run.result")
+        if result:
+            print(result)
+    elif etype == "run.error":
+        output.print_error(f"✗ run.error: {event.get('error', '')}")
+    else:
+        output.print(_json.dumps(event))

praisonai_code/cli/commands/audit.py

@@ -0,0 +1,102 @@
+"""
+CLI command for agent-centric compliance auditing.
+
+Usage:
+    praisonai audit agent-centric --scan /path/to/examples
+    praisonai audit agent-centric --fix /path/to/examples
+    praisonai audit agent-centric --check /path/to/examples
+"""
+
+import click
+import json
+import sys
+from pathlib import Path
+
+
+@click.group()
+def audit():
+    """Audit commands for compliance checking."""
+    pass
+
+
+@audit.command("agent-centric")
+@click.option("--scan", "scan_path", type=click.Path(exists=True), help="Scan path for compliance")
+@click.option("--fix", "fix_path", type=click.Path(exists=True), help="Fix non-compliant files")
+@click.option("--check", "check_path", type=click.Path(exists=True), help="Check and fail if non-compliant")
+@click.option("--json", "output_json", is_flag=True, help="Output as JSON")
+@click.option("--line-limit", default=40, help="Line limit for header scan (default: 40)")
+@click.option("--only-examples", is_flag=True, help="Only scan Python examples")
+@click.option("--only-docs", is_flag=True, help="Only scan documentation")
+@click.option("--verbose", "-v", is_flag=True, help="Verbose output")
+def agent_centric(scan_path, fix_path, check_path, output_json, line_limit, only_examples, only_docs, verbose):
+    """
+    Audit agent-centric compliance for examples and docs.
+    
+    Examples:
+        praisonai audit agent-centric --scan ./examples
+        praisonai audit agent-centric --fix ./examples --verbose
+        praisonai audit agent-centric --check ./examples  # Fails if non-compliant
+    """
+    from praisonai.audit.agent_centric import AgentCentricAuditor, ComplianceStatus
+    
+    path = scan_path or fix_path or check_path
+    if not path:
+        click.echo("Error: Must specify --scan, --fix, or --check with a path", err=True)
+        sys.exit(1)
+    
+    auditor = AgentCentricAuditor(line_limit=line_limit, verbose=verbose)
+    
+    if fix_path:
+        # Fix mode
+        click.echo(f"Fixing non-compliant files in: {fix_path}")
+        report = auditor.scan(fix_path)
+        
+        fixed_count = 0
+        for result in report.results:
+            if result.status == ComplianceStatus.NON_COMPLIANT:
+                success, reason = auditor.fix_file(result.file_path)
+                if success:
+                    fixed_count += 1
+                    if verbose:
+                        click.echo(f"  Fixed: {result.file_path} - {reason}")
+        
+        click.echo(f"\nFixed {fixed_count} files")
+        
+        # Re-scan to verify
+        report = auditor.scan(fix_path)
+        click.echo(f"Compliance rate: {report.compliance_rate():.1f}%")
+        
+    else:
+        # Scan or check mode
+        report = auditor.scan(path)
+        
+        if output_json:
+            click.echo(auditor.to_json(report))
+        else:
+            click.echo(f"\n{'='*60}")
+            click.echo("AGENT-CENTRIC COMPLIANCE REPORT")
+            click.echo(f"{'='*60}")
+            click.echo(f"Total files:    {report.total_files}")
+            click.echo(f"Compliant:      {report.compliant}")
+            click.echo(f"Non-compliant:  {report.non_compliant}")
+            click.echo(f"Skipped:        {report.skipped}")
+            click.echo(f"Compliance rate: {report.compliance_rate():.1f}%")
+            
+            if report.by_reason:
+                click.echo(f"\nBy Reason:")
+                for reason, count in sorted(report.by_reason.items()):
+                    click.echo(f"  {reason}: {count}")
+            
+            if verbose and report.non_compliant > 0:
+                click.echo(f"\nNon-compliant files:")
+                for r in report.results:
+                    if r.status == ComplianceStatus.NON_COMPLIANT:
+                        click.echo(f"  {r.file_path}")
+                        click.echo(f"    Reason: {r.reason.value if r.reason else 'unknown'}")
+        
+        # Check mode - fail if non-compliant
+        if check_path and report.non_compliant > 0:
+            click.echo(f"\n❌ FAILED: {report.non_compliant} non-compliant files found", err=True)
+            sys.exit(1)
+        elif check_path:
+            click.echo(f"\n✓ PASSED: All files are agent-centric compliant")