genxai-framework 0.1.0__py3-none-any.whl

cli/__init__.py

@@ -0,0 +1,3 @@
+"""GenXAI CLI - Command Line Interface for GenXAI."""
+
+__version__ = "0.1.0"

cli/commands/__init__.py

@@ -0,0 +1,6 @@
+"""CLI commands for GenXAI."""
+
+from cli.commands.tool import tool
+from cli.commands.metrics import metrics
+
+__all__ = ["tool", "metrics"]

cli/commands/approval.py

@@ -0,0 +1,85 @@
+"""Approval management CLI commands."""
+
+import click
+from rich.console import Console
+from rich.table import Table
+
+from genxai.security.audit import get_approval_service
+
+console = Console()
+
+
+@click.group()
+def approval():
+    """Manage approval requests."""
+    pass
+
+
+@approval.command("list")
+def list_approvals():
+    """List approval requests."""
+    approvals = get_approval_service()._requests.values()
+    if not approvals:
+        console.print("[yellow]No approval requests found.[/yellow]")
+        return
+
+    table = Table(title="Approval Requests")
+    table.add_column("Request ID", style="cyan")
+    table.add_column("Action", style="white")
+    table.add_column("Resource", style="green")
+    table.add_column("Actor", style="magenta")
+    table.add_column("Status", style="yellow")
+
+    for request in approvals:
+        table.add_row(
+            request.request_id,
+            request.action,
+            request.resource_id,
+            request.actor_id,
+            request.status,
+        )
+
+    console.print(table)
+
+
+@approval.command("submit")
+@click.option("--action", required=True)
+@click.option("--resource", required=True)
+@click.option("--actor", required=True)
+def submit_approval(action: str, resource: str, actor: str):
+    """Submit a new approval request."""
+    request = get_approval_service().submit(action, resource, actor)
+    console.print(f"[green]✓ Approval submitted: {request.request_id}[/green]")
+
+
+@approval.command("approve")
+@click.argument("request_id")
+def approve_request(request_id: str):
+    """Approve a request."""
+    request = get_approval_service().approve(request_id)
+    if not request:
+        console.print(f"[red]Request '{request_id}' not found.[/red]")
+        raise click.Abort()
+    console.print(f"[green]✓ Approved {request_id}[/green]")
+
+
+@approval.command("reject")
+@click.argument("request_id")
+def reject_request(request_id: str):
+    """Reject a request."""
+    request = get_approval_service().reject(request_id)
+    if not request:
+        console.print(f"[red]Request '{request_id}' not found.[/red]")
+        raise click.Abort()
+    console.print(f"[yellow]✓ Rejected {request_id}[/yellow]")
+
+
+@approval.command("clear")
+def clear_requests():
+    """Clear all approval requests."""
+    get_approval_service().clear()
+    console.print("[green]✓ Cleared approval requests[/green]")
+
+
+if __name__ == "__main__":
+    approval()

cli/commands/audit.py

@@ -0,0 +1,127 @@
+"""Audit log management CLI commands."""
+
+import csv
+import json
+from dataclasses import asdict
+from pathlib import Path
+
+import click
+from rich.console import Console
+from rich.table import Table
+
+from genxai.security.audit import get_audit_log
+
+console = Console()
+
+
+@click.group()
+def audit():
+    """Manage audit logs."""
+    pass
+
+
+@audit.command("list")
+@click.option(
+    "--format",
+    "output_format",
+    type=click.Choice(["table", "json", "csv"]),
+    default="table",
+)
+def list_events(output_format: str):
+    """List audit events."""
+    events = get_audit_log().list_events()
+    if not events:
+        console.print("[yellow]No audit events found.[/yellow]")
+        return
+
+    if output_format == "json":
+        data = [asdict(event) for event in events]
+        click.echo(json.dumps(data, default=str, indent=2))
+        return
+
+    if output_format == "csv":
+        writer = csv.writer(click.get_text_stream("stdout"))
+        writer.writerow(["action", "actor_id", "resource_id", "status", "timestamp"])
+        for event in events:
+            writer.writerow(
+                [
+                    event.action,
+                    event.actor_id,
+                    event.resource_id,
+                    event.status,
+                    event.timestamp.isoformat(),
+                ]
+            )
+        return
+
+    table = Table(title="Audit Events")
+    table.add_column("Action", style="cyan")
+    table.add_column("Actor", style="magenta")
+    table.add_column("Resource", style="green")
+    table.add_column("Status", style="yellow")
+    table.add_column("Timestamp", style="white")
+
+    for event in events:
+        table.add_row(
+            event.action,
+            event.actor_id,
+            event.resource_id,
+            event.status,
+            event.timestamp.isoformat(),
+        )
+
+    console.print(table)
+
+
+@audit.command("export")
+@click.option("--output", "output_path", required=True)
+@click.option(
+    "--format",
+    "output_format",
+    type=click.Choice(["json", "csv"]),
+    default="json",
+)
+def export_events(output_path: str, output_format: str):
+    """Export audit events to a JSON/CSV file."""
+    events = get_audit_log().list_events()
+    export_path = Path(output_path)
+    if output_format == "csv":
+        if export_path.suffix.lower() != ".csv":
+            export_path = export_path.with_suffix(".csv")
+        with export_path.open("w", encoding="utf-8", newline="") as file:
+            writer = csv.writer(file)
+            writer.writerow(["action", "actor_id", "resource_id", "status", "timestamp"])
+            for event in events:
+                writer.writerow(
+                    [
+                        event.action,
+                        event.actor_id,
+                        event.resource_id,
+                        event.status,
+                        event.timestamp.isoformat(),
+                    ]
+                )
+    else:
+        if export_path.suffix.lower() != ".json":
+            export_path = export_path.with_suffix(".json")
+        export_path.write_text(json.dumps([asdict(event) for event in events], default=str, indent=2))
+
+    console.print(f"[green]✓ Exported {len(events)} events to {export_path}[/green]")
+
+
+@audit.command("clear")
+def clear_events():
+    """Clear audit events."""
+    get_audit_log().clear()
+    console.print("[green]✓ Cleared audit log[/green]")
+
+
+@audit.command("compact")
+def compact_audit_db():
+    """Compact audit database (VACUUM)."""
+    get_audit_log()._store.vacuum()
+    console.print("[green]✓ Compacted audit database[/green]")
+
+
+if __name__ == "__main__":
+    audit()

cli/commands/metrics.py

@@ -0,0 +1,25 @@
+"""Metrics API CLI commands."""
+
+import click
+
+
+@click.group()
+def metrics() -> None:
+    """Manage metrics API server."""
+    pass
+
+
+@metrics.command("serve")
+@click.option("--host", default="0.0.0.0", show_default=True, help="Host to bind")
+@click.option("--port", default=8001, show_default=True, help="Port to bind")
+@click.option("--reload", is_flag=True, default=False, help="Enable auto-reload")
+def serve(host: str, port: int, reload: bool) -> None:
+    """Start the metrics API server."""
+    try:
+        import uvicorn
+    except ImportError as exc:
+        raise click.ClickException(
+            "Uvicorn is required to serve the metrics API. Install with: pip install genxai[api]"
+        ) from exc
+
+    uvicorn.run("genxai.api.app:create_app", host=host, port=port, reload=reload, factory=True)

cli/commands/tool.py

@@ -0,0 +1,389 @@
+"""Tool management CLI commands."""
+
+import click
+import json
+from pathlib import Path
+from typing import Optional
+from rich.console import Console
+from rich.table import Table
+from rich import print as rprint
+
+from genxai.tools.persistence import ToolService
+from genxai.tools.base import ToolCategory
+from genxai.tools.registry import ToolRegistry
+from genxai.tools.builtin import *  # noqa: F403 - register built-in tools
+
+console = Console()
+
+
+@click.group()
+def tool():
+    """Manage GenXAI tools."""
+    pass
+
+
+@tool.command()
+@click.option('--category', help='Filter by category')
+@click.option('--format', type=click.Choice(['table', 'json']), default='table', help='Output format')
+def list(category: Optional[str], format: str):
+    """List all tools."""
+    try:
+        tools = ToolService.list_tools()
+        
+        # Filter by category if specified
+        if category:
+            tools = [t for t in tools if t.category == category]
+        
+        if not tools:
+            console.print("[yellow]No tools found.[/yellow]")
+            return
+        
+        if format == 'json':
+            # JSON output
+            output = [t.to_dict() for t in tools]
+            click.echo(json.dumps(output, indent=2))
+        else:
+            # Table output
+            table = Table(title="GenXAI Tools")
+            table.add_column("Name", style="cyan")
+            table.add_column("Description", style="white")
+            table.add_column("Category", style="green")
+            table.add_column("Type", style="magenta")
+            table.add_column("Version", style="yellow")
+            
+            for t in tools:
+                table.add_row(
+                    t.name,
+                    t.description[:50] + "..." if len(t.description) > 50 else t.description,
+                    t.category,
+                    t.tool_type,
+                    t.version
+                )
+            
+            console.print(table)
+            console.print(f"\n[bold]Total:[/bold] {len(tools)} tools")
+            
+    except Exception as e:
+        console.print(f"[red]Error listing tools: {e}[/red]")
+        raise click.Abort()
+
+
+@tool.command()
+@click.argument('name')
+def info(name: str):
+    """Show detailed information about a tool."""
+    try:
+        tool_model = ToolService.get_tool(name)
+        
+        if not tool_model:
+            console.print(f"[red]Tool '{name}' not found.[/red]")
+            raise click.Abort()
+        
+        # Display tool information
+        console.print(f"\n[bold cyan]Tool: {tool_model.name}[/bold cyan]")
+        console.print(f"[bold]Description:[/bold] {tool_model.description}")
+        console.print(f"[bold]Category:[/bold] {tool_model.category}")
+        console.print(f"[bold]Type:[/bold] {tool_model.tool_type}")
+        console.print(f"[bold]Version:[/bold] {tool_model.version}")
+        console.print(f"[bold]Author:[/bold] {tool_model.author}")
+        console.print(f"[bold]Tags:[/bold] {', '.join(tool_model.tags)}")
+        console.print(f"[bold]Created:[/bold] {tool_model.created_at}")
+        console.print(f"[bold]Updated:[/bold] {tool_model.updated_at}")
+        
+        if tool_model.tool_type == "code_based":
+            console.print(f"\n[bold]Parameters:[/bold]")
+            for param in tool_model.parameters:
+                console.print(f"  • {param['name']} ({param['type']}): {param['description']}")
+            
+            console.print(f"\n[bold]Code:[/bold]")
+            console.print(f"[dim]{tool_model.code}[/dim]")
+        
+        elif tool_model.tool_type == "template_based":
+            console.print(f"\n[bold]Template:[/bold] {tool_model.template_name}")
+            console.print(f"[bold]Configuration:[/bold]")
+            console.print(json.dumps(tool_model.template_config, indent=2))
+        
+    except Exception as e:
+        console.print(f"[red]Error getting tool info: {e}[/red]")
+        raise click.Abort()
+
+
+@tool.command()
+@click.argument('query')
+@click.option('--category', help='Filter by category')
+def search(query: str, category: Optional[str]):
+    """Search tools by name, description, or tags."""
+    try:
+        tools = ToolService.list_tools()
+        
+        # Filter by query
+        query_lower = query.lower()
+        results = [
+            t for t in tools
+            if query_lower in t.name.lower()
+            or query_lower in t.description.lower()
+            or any(query_lower in tag.lower() for tag in t.tags)
+        ]
+        
+        # Filter by category if specified
+        if category:
+            results = [t for t in results if t.category == category]
+        
+        if not results:
+            console.print(f"[yellow]No tools found matching '{query}'.[/yellow]")
+            return
+        
+        # Display results
+        table = Table(title=f"Search Results for '{query}'")
+        table.add_column("Name", style="cyan")
+        table.add_column("Description", style="white")
+        table.add_column("Category", style="green")
+        
+        for t in results:
+            table.add_row(
+                t.name,
+                t.description[:60] + "..." if len(t.description) > 60 else t.description,
+                t.category
+            )
+        
+        console.print(table)
+        console.print(f"\n[bold]Found:[/bold] {len(results)} tools")
+        
+    except Exception as e:
+        console.print(f"[red]Error searching tools: {e}[/red]")
+        raise click.Abort()
+
+
+@tool.command()
+@click.argument('name')
+@click.option('--force', is_flag=True, help='Skip confirmation')
+def delete(name: str, force: bool):
+    """Delete a tool."""
+    try:
+        tool_model = ToolService.get_tool(name)
+        
+        if not tool_model:
+            console.print(f"[red]Tool '{name}' not found.[/red]")
+            raise click.Abort()
+        
+        # Confirm deletion
+        if not force:
+            if not click.confirm(f"Are you sure you want to delete tool '{name}'?"):
+                console.print("[yellow]Deletion cancelled.[/yellow]")
+                return
+        
+        # Delete tool
+        ToolService.delete_tool(name)
+        console.print(f"[green]✓ Tool '{name}' deleted successfully.[/green]")
+        
+    except Exception as e:
+        console.print(f"[red]Error deleting tool: {e}[/red]")
+        raise click.Abort()
+
+
+@tool.command()
+@click.argument('name')
+@click.option('--output', '-o', help='Output file path')
+@click.option('--format', type=click.Choice(['json', 'py']), default='json', help='Export format')
+def export(name: str, output: Optional[str], format: str):
+    """Export a tool to a file."""
+    try:
+        tool_model = ToolService.get_tool(name)
+        
+        if not tool_model:
+            console.print(f"[red]Tool '{name}' not found.[/red]")
+            raise click.Abort()
+        
+        # Determine output path
+        if not output:
+            output = f"{name}.{format}"
+        
+        output_path = Path(output)
+        
+        # Export based on format
+        if format == 'json':
+            data = tool_model.to_dict()
+            output_path.write_text(json.dumps(data, indent=2))
+        elif format == 'py':
+            if tool_model.tool_type != "code_based":
+                console.print("[red]Only code-based tools can be exported as Python files.[/red]")
+                raise click.Abort()
+            
+            content = f'''"""
+Tool: {tool_model.name}
+Description: {tool_model.description}
+Category: {tool_model.category}
+"""
+
+{tool_model.code}
+'''
+            output_path.write_text(content)
+        
+        console.print(f"[green]✓ Tool exported to {output_path}[/green]")
+        
+    except Exception as e:
+        console.print(f"[red]Error exporting tool: {e}[/red]")
+        raise click.Abort()
+
+
+@tool.command("export-schema")
+@click.option('--output', '-o', help='Output file path', default='tool_schemas.json')
+@click.option('--category', help='Filter by category')
+@click.option('--stdout', is_flag=True, help='Print schema bundle to stdout')
+@click.option('--format', 'output_format', type=click.Choice(['json', 'yaml']), default='json', help='Output format')
+def export_schema(output: str, category: Optional[str], stdout: bool, output_format: str):
+    """Export consolidated tool schema bundle to JSON."""
+    try:
+        category_filter = ToolCategory(category) if category else None
+        bundle = ToolRegistry.export_schema_bundle(category=category_filter)
+
+        if stdout:
+            if output_format == 'yaml':
+                try:
+                    import yaml
+                except ImportError as exc:
+                    raise ImportError(
+                        "PyYAML is required for YAML output. Install with: pip install PyYAML"
+                    ) from exc
+                click.echo(yaml.safe_dump(bundle, sort_keys=False))
+            else:
+                click.echo(json.dumps(bundle, indent=2))
+            return
+
+        if output_format == 'yaml' and not output.lower().endswith((".yaml", ".yml")):
+            output = f"{output}.yaml"
+
+        export_path = ToolRegistry.export_schema_bundle_to_file(
+            output,
+            category=category_filter,
+        )
+        console.print(
+            f"[green]✓ Tool schema bundle (v{ToolRegistry.SCHEMA_VERSION}) exported to {export_path}[/green]"
+        )
+    except ValueError:
+        console.print(f"[red]Invalid category: {category}[/red]")
+        console.print(f"Valid categories: {', '.join([c.value for c in ToolCategory])}")
+        raise click.Abort()
+    except Exception as e:
+        console.print(f"[red]Error exporting tool schemas: {e}[/red]")
+        raise click.Abort()
+
+
+@tool.command()
+@click.argument('file', type=click.Path(exists=True))
+def import_tool(file: str):
+    """Import a tool from a file."""
+    try:
+        file_path = Path(file)
+        
+        if file_path.suffix == '.json':
+            # Import from JSON
+            data = json.loads(file_path.read_text())
+            
+            # Check if tool already exists
+            if ToolService.get_tool(data['name']):
+                console.print(f"[red]Tool '{data['name']}' already exists.[/red]")
+                raise click.Abort()
+            
+            # Create tool
+            ToolService.save_tool(
+                name=data['name'],
+                description=data['description'],
+                category=data['category'],
+                tags=data.get('tags', []),
+                version=data.get('version', '1.0.0'),
+                author=data.get('author', 'GenXAI User'),
+                tool_type=data['tool_type'],
+                code=data.get('code'),
+                parameters=data.get('parameters'),
+                template_name=data.get('template_name'),
+                template_config=data.get('template_config'),
+            )
+            
+            console.print(f"[green]✓ Tool '{data['name']}' imported successfully.[/green]")
+        else:
+            console.print("[red]Only JSON files are supported for import.[/red]")
+            raise click.Abort()
+        
+    except Exception as e:
+        console.print(f"[red]Error importing tool: {e}[/red]")
+        raise click.Abort()
+
+
+@tool.command()
+@click.option('--name', required=True, help='Tool name')
+@click.option('--description', required=True, help='Tool description')
+@click.option('--category', required=True, help='Tool category')
+@click.option('--template', help='Template name for template-based tools')
+@click.option('--config', help='Template configuration (JSON string)')
+@click.option('--code-file', type=click.Path(exists=True), help='Python file for code-based tools')
+@click.option('--tags', help='Comma-separated tags')
+def create(name: str, description: str, category: str, template: Optional[str], 
+           config: Optional[str], code_file: Optional[str], tags: Optional[str]):
+    """Create a new tool."""
+    try:
+        # Check if tool already exists
+        if ToolService.get_tool(name):
+            console.print(f"[red]Tool '{name}' already exists.[/red]")
+            raise click.Abort()
+        
+        # Validate category
+        try:
+            ToolCategory(category)
+        except ValueError:
+            console.print(f"[red]Invalid category: {category}[/red]")
+            console.print(f"Valid categories: {', '.join([c.value for c in ToolCategory])}")
+            raise click.Abort()
+        
+        # Parse tags
+        tag_list = [t.strip() for t in tags.split(',')] if tags else []
+        
+        # Create tool based on type
+        if template:
+            # Template-based tool
+            if not config:
+                console.print("[red]--config is required for template-based tools.[/red]")
+                raise click.Abort()
+            
+            config_dict = json.loads(config)
+            
+            ToolService.save_tool(
+                name=name,
+                description=description,
+                category=category,
+                tags=tag_list,
+                version="1.0.0",
+                author="GenXAI User",
+                tool_type="template_based",
+                template_name=template,
+                template_config=config_dict,
+            )
+            
+        elif code_file:
+            # Code-based tool
+            code = Path(code_file).read_text()
+            
+            ToolService.save_tool(
+                name=name,
+                description=description,
+                category=category,
+                tags=tag_list,
+                version="1.0.0",
+                author="GenXAI User",
+                tool_type="code_based",
+                code=code,
+                parameters=[],  # TODO: Parse from code or require as input
+            )
+        else:
+            console.print("[red]Either --template or --code-file must be provided.[/red]")
+            raise click.Abort()
+        
+        console.print(f"[green]✓ Tool '{name}' created successfully.[/green]")
+        
+    except Exception as e:
+        console.print(f"[red]Error creating tool: {e}[/red]")
+        raise click.Abort()
+
+
+if __name__ == '__main__':
+    tool()

cli/main.py

@@ -0,0 +1,32 @@
+"""GenXAI CLI - Main entry point."""
+
+import click
+from cli.commands import tool, metrics
+from cli.commands.approval import approval
+from cli.commands.audit import audit
+
+
+@click.group()
+@click.version_option(version='0.1.0', prog_name='genxai')
+def cli():
+    """GenXAI - Multi-Agent AI Framework CLI.
+    
+    Manage tools, agents, workflows, and more from the command line.
+    """
+    pass
+
+
+# Register command groups
+cli.add_command(tool)
+cli.add_command(metrics)
+cli.add_command(approval)
+cli.add_command(audit)
+
+
+def main():
+    """Main entry point for the CLI."""
+    cli()
+
+
+if __name__ == '__main__':
+    main()