proxima-cli 1.0.0__py3-none-any.whl

prox/commands/knowledge.py

@@ -0,0 +1,141 @@
+"""prox knowledge — manage knowledge sources and bases."""
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from ..api import gateway_get, gateway_post, gateway_delete, APIError
+
+app = typer.Typer(help="Manage knowledge sources and bases.")
+console = Console()
+
+source_app = typer.Typer(help="Manage knowledge sources.")
+app.add_typer(source_app, name="source")
+
+base_app = typer.Typer(help="Manage knowledge bases.")
+app.add_typer(base_app, name="base")
+
+
+@source_app.command("list")
+def list_sources():
+    """List knowledge sources."""
+    try:
+        data = gateway_get("/build/knowledge/sources")
+        sources = data.get("sources", [])
+        if not sources:
+            console.print("[dim]No sources.[/dim]")
+            return
+        table = Table(title="Knowledge Sources")
+        table.add_column("ID", style="bold")
+        table.add_column("Name")
+        table.add_column("Provider")
+        for s in sources:
+            table.add_row(s.get("id"), s.get("name", ""), s.get("provider", ""))
+        console.print(table)
+    except APIError as e:
+        console.print(f"[red]Error:[/red] {e.detail}")
+        raise typer.Exit(1)
+
+
+@source_app.command("create")
+def create_source(
+    id: str = typer.Option(..., "--id"),
+    name: str = typer.Option(..., "--name"),
+    provider: str = typer.Option(..., "--provider", help="azure_blob, s3, snowflake, etc."),
+    secret: Optional[str] = typer.Option(None, "--secret", help="Secret name for credentials"),
+    container: Optional[str] = typer.Option(None, "--container"),
+    path: Optional[str] = typer.Option(None, "--path"),
+):
+    """Create a knowledge source."""
+    payload = {"id": id, "name": name, "provider": provider}
+    if secret:
+        payload["credential_secret"] = secret
+    if container:
+        payload["container"] = container
+    if path:
+        payload["path"] = path
+    try:
+        gateway_post("/build/knowledge/sources", payload)
+        console.print(f"[green]✓[/green] Source created: {id}")
+    except APIError as e:
+        console.print(f"[red]Error:[/red] {e.detail}")
+        raise typer.Exit(1)
+
+
+@source_app.command("test")
+def test_source(source_id: str = typer.Argument(help="Source ID to test")):
+    """Test a source connection."""
+    try:
+        data = gateway_post(f"/build/knowledge/sources/{source_id}/test")
+        if data.get("success"):
+            console.print(f"[green]✓[/green] Connection successful ({data.get('rows', '?')} rows)")
+        else:
+            console.print(f"[red]✗[/red] {data.get('error', 'Connection failed')}")
+    except APIError as e:
+        console.print(f"[red]Error:[/red] {e.detail}")
+        raise typer.Exit(1)
+
+
+@source_app.command("delete")
+def delete_source(source_id: str = typer.Argument(), confirm: bool = typer.Option(False, "--yes", "-y")):
+    """Delete a knowledge source."""
+    if not confirm:
+        typer.confirm(f"Delete source '{source_id}'?", abort=True)
+    try:
+        gateway_delete(f"/build/knowledge/sources/{source_id}")
+        console.print(f"[green]✓[/green] Deleted: {source_id}")
+    except APIError as e:
+        console.print(f"[red]Error:[/red] {e.detail}")
+        raise typer.Exit(1)
+
+
+@base_app.command("list")
+def list_bases():
+    """List knowledge bases."""
+    try:
+        data = gateway_get("/build/knowledge/bases")
+        bases = data.get("bases", [])
+        if not bases:
+            console.print("[dim]No bases.[/dim]")
+            return
+        table = Table(title="Knowledge Bases")
+        table.add_column("ID", style="bold")
+        table.add_column("Name")
+        table.add_column("Sources", justify="right")
+        for b in bases:
+            table.add_row(b.get("id"), b.get("name", ""), str(len(b.get("sources", []))))
+        console.print(table)
+    except APIError as e:
+        console.print(f"[red]Error:[/red] {e.detail}")
+        raise typer.Exit(1)
+
+
+@base_app.command("create")
+def create_base(
+    id: str = typer.Option(..., "--id"),
+    name: str = typer.Option(..., "--name"),
+    sources: str = typer.Option(..., "--sources", help="Comma-separated source IDs"),
+):
+    """Create a knowledge base."""
+    try:
+        gateway_post("/build/knowledge/bases", {"id": id, "name": name, "sources": sources.split(",")})
+        console.print(f"[green]✓[/green] Base created: {id}")
+    except APIError as e:
+        console.print(f"[red]Error:[/red] {e.detail}")
+        raise typer.Exit(1)
+
+
+@base_app.command("delete")
+def delete_base(base_id: str = typer.Argument(), confirm: bool = typer.Option(False, "--yes", "-y")):
+    """Delete a knowledge base."""
+    if not confirm:
+        typer.confirm(f"Delete base '{base_id}'?", abort=True)
+    try:
+        gateway_delete(f"/build/knowledge/bases/{base_id}")
+        console.print(f"[green]✓[/green] Deleted: {base_id}")
+    except APIError as e:
+        console.print(f"[red]Error:[/red] {e.detail}")
+        raise typer.Exit(1)

prox/commands/model.py

@@ -0,0 +1,69 @@
+"""prox model — manage LLM model connections."""
+
+from typing import Optional
+import typer
+from rich.console import Console
+from rich.table import Table
+from ..api import gateway_get, gateway_post, gateway_delete, APIError
+
+app = typer.Typer(help="Manage LLM models.")
+console = Console()
+
+
+@app.command("list")
+def list_models():
+    """List deployed models."""
+    try:
+        data = gateway_get("/build/models")
+        models = data.get("models", [])
+        if not models:
+            console.print("[dim]No models.[/dim]")
+            return
+        table = Table(title="Models")
+        table.add_column("ID", style="bold")
+        table.add_column("Provider")
+        table.add_column("Model")
+        table.add_column("Status")
+        for m in models:
+            st = m.get("status", "unknown")
+            st_style = "green" if st == "active" else "yellow"
+            table.add_row(m.get("id"), m.get("provider", ""), m.get("model", ""), f"[{st_style}]{st}[/{st_style}]")
+        console.print(table)
+    except APIError as e:
+        console.print(f"[red]Error:[/red] {e.detail}")
+        raise typer.Exit(1)
+
+
+@app.command("deploy")
+def deploy_model(
+    id: str = typer.Option(..., "--id"),
+    provider: str = typer.Option(..., "--provider", help="openai, anthropic, bedrock, watsonx, ollama"),
+    model: str = typer.Option(..., "--model", help="Model name (e.g. gpt-4.1-mini)"),
+    endpoint_secret: Optional[str] = typer.Option(None, "--endpoint-secret"),
+    key_secret: Optional[str] = typer.Option(None, "--key-secret"),
+):
+    """Deploy a model connection."""
+    payload = {"id": id, "provider": provider, "model": model}
+    if endpoint_secret:
+        payload["endpoint_secret"] = endpoint_secret
+    if key_secret:
+        payload["key_secret"] = key_secret
+    try:
+        gateway_post("/build/models", payload)
+        console.print(f"[green]✓[/green] Model deployed: {id}")
+    except APIError as e:
+        console.print(f"[red]Error:[/red] {e.detail}")
+        raise typer.Exit(1)
+
+
+@app.command("delete")
+def delete_model(model_id: str = typer.Argument(), confirm: bool = typer.Option(False, "--yes", "-y")):
+    """Delete a model."""
+    if not confirm:
+        typer.confirm(f"Delete model '{model_id}'?", abort=True)
+    try:
+        gateway_delete(f"/build/models/{model_id}")
+        console.print(f"[green]✓[/green] Deleted: {model_id}")
+    except APIError as e:
+        console.print(f"[red]Error:[/red] {e.detail}")
+        raise typer.Exit(1)

prox/commands/ontology.py

@@ -0,0 +1,209 @@
+"""prox ontology — manage ontologies on the platform."""
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+import yaml
+from rich.console import Console
+from rich.table import Table
+
+from ..api import gateway_get, gateway_post, gateway_put, gateway_delete, APIError
+
+app = typer.Typer(help="Manage ontologies.")
+console = Console()
+
+
+@app.command("list")
+def list_ontologies():
+    """List all ontologies on the platform."""
+    try:
+        data = gateway_get("/build/ontology")
+    except APIError as e:
+        console.print(f"[red]Error:[/red] {e.detail}")
+        raise typer.Exit(1)
+
+    ontologies = data.get("ontologies", [])
+    if not ontologies:
+        console.print("[dim]No ontologies.[/dim]")
+        return
+
+    table = Table(title=f"Ontologies ({len(ontologies)})")
+    table.add_column("ID", style="bold")
+    table.add_column("Name")
+    table.add_column("Entities", justify="right")
+    table.add_column("Actions", justify="right")
+    table.add_column("Version")
+
+    for o in ontologies:
+        table.add_row(o.get("id"), o.get("name", ""), str(o.get("entities", 0)), str(o.get("actions", 0)), o.get("version", "—"))
+
+    console.print(table)
+
+
+@app.command("show")
+def show_ontology(ontology_id: str = typer.Argument(help="Ontology ID")):
+    """Show ontology details."""
+    try:
+        data = gateway_get(f"/build/ontology/{ontology_id}")
+    except APIError as e:
+        console.print(f"[red]Error:[/red] {e.detail}")
+        raise typer.Exit(1)
+
+    o = data.get("ontology", {})
+    console.print(f"\n[bold]{o.get('name', ontology_id)}[/bold] (v{o.get('version', '?')})")
+    console.print(f"[dim]{o.get('description', '')}[/dim]\n")
+
+    entities = o.get("entities", {})
+    relationships = o.get("relationships", [])
+    actions = o.get("actions", {})
+    events = o.get("events", [])
+
+    console.print(f"  Entities:       {len(entities)}")
+    console.print(f"  Relationships:  {len(relationships)}")
+    console.print(f"  Actions:        {len(actions)}")
+    console.print(f"  Events:         {len(events)}")
+    console.print()
+
+    if entities:
+        console.print("  [bold]Entities:[/bold]")
+        for name, edef in entities.items():
+            props = len(edef.get("properties", {}))
+            console.print(f"    • {name} ({props} properties)")
+    if actions:
+        console.print(f"\n  [bold]Actions:[/bold]")
+        for aname, adef in actions.items():
+            console.print(f"    • {aname} → {adef.get('entity', '?')}")
+    console.print()
+
+
+@app.command("create")
+def create_ontology(
+    from_file: Path = typer.Option(..., "--from", help="YAML ontology definition file"),
+):
+    """Create an ontology from a YAML file."""
+    if not from_file.exists():
+        console.print(f"[red]Error:[/red] File not found: {from_file}")
+        raise typer.Exit(1)
+
+    data = yaml.safe_load(from_file.read_text())
+    if not data.get("id"):
+        console.print("[red]Error:[/red] Ontology YAML must have an 'id' field")
+        raise typer.Exit(1)
+
+    try:
+        gateway_post("/build/ontology", data)
+        console.print(f"[green]✓[/green] Ontology created: {data['id']}")
+    except APIError as e:
+        console.print(f"[red]Error:[/red] {e.detail}")
+        raise typer.Exit(1)
+
+
+@app.command("update")
+def update_ontology(
+    ontology_id: str = typer.Argument(help="Ontology ID"),
+    from_file: Path = typer.Option(..., "--from", help="YAML ontology definition file"),
+):
+    """Update an existing ontology from a YAML file."""
+    if not from_file.exists():
+        console.print(f"[red]Error:[/red] File not found: {from_file}")
+        raise typer.Exit(1)
+
+    data = yaml.safe_load(from_file.read_text())
+    data["id"] = ontology_id
+
+    try:
+        gateway_put(f"/build/ontology/{ontology_id}", data)
+        console.print(f"[green]✓[/green] Ontology updated: {ontology_id}")
+    except APIError as e:
+        console.print(f"[red]Error:[/red] {e.detail}")
+        raise typer.Exit(1)
+
+
+@app.command("validate")
+def validate_ontology_cmd(
+    from_file: Path = typer.Option(..., "--from", help="YAML ontology file to validate"),
+):
+    """Validate an ontology YAML file without creating it."""
+    if not from_file.exists():
+        console.print(f"[red]Error:[/red] File not found: {from_file}")
+        raise typer.Exit(1)
+
+    data = yaml.safe_load(from_file.read_text())
+
+    # Import the validator
+    import sys
+    from pathlib import Path as P
+    platform_path = str(P(__file__).resolve().parent.parent.parent.parent.parent)
+    sys.path.insert(0, platform_path)
+    try:
+        from ontology import validate_ontology
+        errors = validate_ontology(data)
+        if errors:
+            console.print(f"[red]✗ Validation failed ({len(errors)} errors):[/red]")
+            for err in errors:
+                console.print(f"  • {err}")
+            raise typer.Exit(1)
+        else:
+            entities = len(data.get("entities", {}))
+            actions = len(data.get("actions", {}))
+            console.print(f"[green]✓[/green] Valid ontology: {data.get('id', '?')} ({entities} entities, {actions} actions)")
+    except ImportError:
+        # Fallback: basic validation
+        if not data.get("id"):
+            console.print("[red]✗[/red] Missing 'id' field")
+            raise typer.Exit(1)
+        console.print(f"[green]✓[/green] Basic validation passed: {data.get('id', '?')}")
+
+
+@app.command("publish")
+def publish_ontology(ontology_id: str = typer.Argument(help="Ontology ID to publish")):
+    """Publish an ontology (creates immutable version)."""
+    try:
+        data = gateway_post(f"/build/ontology/{ontology_id}/publish")
+        console.print(f"[green]✓[/green] Published: {ontology_id} → v{data.get('version', '?')}")
+    except APIError as e:
+        console.print(f"[red]Error:[/red] {e.detail}")
+        raise typer.Exit(1)
+
+
+@app.command("versions")
+def list_versions(ontology_id: str = typer.Argument(help="Ontology ID")):
+    """List published versions of an ontology."""
+    try:
+        data = gateway_get(f"/build/ontology/{ontology_id}/versions")
+    except APIError as e:
+        console.print(f"[red]Error:[/red] {e.detail}")
+        raise typer.Exit(1)
+
+    versions = data.get("versions", [])
+    if not versions:
+        console.print("[dim]No published versions yet.[/dim]")
+        return
+
+    table = Table(title=f"Versions — {ontology_id}")
+    table.add_column("Version", style="bold")
+    table.add_column("Entities", justify="right")
+    table.add_column("Published")
+
+    for v in versions:
+        table.add_row(f"v{v.get('version', '?')}", str(v.get("entities", 0)), v.get("published_at", "—"))
+
+    console.print(table)
+
+
+@app.command("delete")
+def delete_ontology(
+    ontology_id: str = typer.Argument(help="Ontology ID to delete"),
+    confirm: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation"),
+):
+    """Delete an ontology."""
+    if not confirm:
+        typer.confirm(f"Delete ontology '{ontology_id}'? This cannot be undone", abort=True)
+
+    try:
+        gateway_delete(f"/build/ontology/{ontology_id}")
+        console.print(f"[green]✓[/green] Deleted: {ontology_id}")
+    except APIError as e:
+        console.print(f"[red]Error:[/red] {e.detail}")
+        raise typer.Exit(1)

prox/commands/platform.py

@@ -0,0 +1,50 @@
+"""prox platform — health, status, service management."""
+
+import typer
+from rich.console import Console
+from rich.table import Table
+from ..api import gateway_get, APIError
+from ..config import get_value
+
+app = typer.Typer(help="Platform health and status.")
+console = Console()
+
+
+@app.command("health")
+def health():
+    """Check platform health."""
+    gateway = get_value("gateway") or "not configured"
+    console.print(f"\n  [bold]Platform Health[/bold]  ({gateway})\n")
+
+    services = [
+        ("Gateway", "/health"),
+        ("Orchestrator", "/orchestrator/health"),
+        ("Knowledge", "/knowledge/health"),
+        ("Runtime", "/runtime/health"),
+    ]
+
+    for name, path in services:
+        try:
+            data = gateway_get(path)
+            status = data.get("status", "ok")
+            console.print(f"  [green]●[/green] {name:15} {status}")
+        except APIError:
+            console.print(f"  [red]●[/red] {name:15} unreachable")
+        except Exception:
+            console.print(f"  [red]●[/red] {name:15} error")
+
+    console.print()
+
+
+@app.command("status")
+def status():
+    """Show platform status summary."""
+    try:
+        data = gateway_get("/health")
+        console.print(f"\n  Gateway:    [green]healthy[/green]")
+        console.print(f"  Version:    {data.get('version', '—')}")
+        console.print(f"  Agents:     {data.get('agents_registered', '—')}")
+        console.print(f"  Uptime:     {data.get('uptime', '—')}")
+    except APIError as e:
+        console.print(f"  Gateway:    [red]error[/red] ({e.detail[:100]})")
+    console.print()

prox/commands/routine.py

@@ -0,0 +1,84 @@
+"""prox routine — manage scheduled agent execution."""
+
+from pathlib import Path
+from typing import Optional
+import typer
+from rich.console import Console
+from rich.table import Table
+from ..api import gateway_get, gateway_post, gateway_delete, APIError
+
+app = typer.Typer(help="Manage routines (scheduled agent execution).")
+console = Console()
+
+
+@app.command("list")
+def list_routines():
+    """List routines."""
+    try:
+        data = gateway_get("/build/routines")
+        routines = data.get("routines", [])
+        if not routines:
+            console.print("[dim]No routines.[/dim]")
+            return
+        table = Table(title="Routines")
+        table.add_column("ID", style="bold")
+        table.add_column("Agent")
+        table.add_column("Trigger")
+        table.add_column("Status")
+        for r in routines:
+            trigger = r.get("trigger", {})
+            ttype = trigger.get("type", "manual") if isinstance(trigger, dict) else str(trigger)
+            st = r.get("status", "draft")
+            st_style = "green" if st == "active" else "dim"
+            table.add_row(r.get("id"), r.get("agent_id", ""), ttype, f"[{st_style}]{st}[/{st_style}]")
+        console.print(table)
+    except APIError as e:
+        console.print(f"[red]Error:[/red] {e.detail}")
+        raise typer.Exit(1)
+
+
+@app.command("create")
+def create_routine(
+    id: str = typer.Option(..., "--id"),
+    agent: str = typer.Option(..., "--agent", help="Agent ID"),
+    prompt: str = typer.Option(..., "--prompt", help="Prompt to send"),
+    cron: Optional[str] = typer.Option(None, "--cron", help="Cron schedule (e.g. '0 6 * * *')"),
+):
+    """Create a routine."""
+    payload = {"id": id, "agent_id": agent, "prompt": prompt, "status": "active"}
+    if cron:
+        payload["trigger"] = {"type": "cron", "schedule": cron}
+    else:
+        payload["trigger"] = {"type": "manual"}
+    try:
+        gateway_post("/build/routines", payload)
+        console.print(f"[green]✓[/green] Routine created: {id}")
+    except APIError as e:
+        console.print(f"[red]Error:[/red] {e.detail}")
+        raise typer.Exit(1)
+
+
+@app.command("trigger")
+def trigger_routine(routine_id: str = typer.Argument(help="Routine ID")):
+    """Manually trigger a routine."""
+    try:
+        data = gateway_post(f"/build/routines/{routine_id}/trigger")
+        console.print(f"[green]✓[/green] Triggered: {routine_id}")
+        if data.get("run_id"):
+            console.print(f"  Run ID: {data['run_id']}")
+    except APIError as e:
+        console.print(f"[red]Error:[/red] {e.detail}")
+        raise typer.Exit(1)
+
+
+@app.command("delete")
+def delete_routine(routine_id: str = typer.Argument(), confirm: bool = typer.Option(False, "--yes", "-y")):
+    """Delete a routine."""
+    if not confirm:
+        typer.confirm(f"Delete routine '{routine_id}'?", abort=True)
+    try:
+        gateway_delete(f"/build/routines/{routine_id}")
+        console.print(f"[green]✓[/green] Deleted: {routine_id}")
+    except APIError as e:
+        console.print(f"[red]Error:[/red] {e.detail}")
+        raise typer.Exit(1)

prox/commands/secret.py

@@ -0,0 +1,59 @@
+"""prox secret — manage platform secrets."""
+
+from typing import Optional
+import typer
+from rich.console import Console
+from rich.table import Table
+from ..api import gateway_get, gateway_post, gateway_delete, APIError
+
+app = typer.Typer(help="Manage platform secrets.")
+console = Console()
+
+
+@app.command("list")
+def list_secrets():
+    """List secrets (names only, never values)."""
+    try:
+        data = gateway_get("/build/secrets")
+        secrets = data.get("secrets", [])
+        if not secrets:
+            console.print("[dim]No secrets.[/dim]")
+            return
+        for s in secrets:
+            console.print(f"  • {s.get('name', s) if isinstance(s, dict) else s}")
+    except APIError as e:
+        console.print(f"[red]Error:[/red] {e.detail}")
+        raise typer.Exit(1)
+
+
+@app.command("set")
+def set_secret(
+    name: str = typer.Argument(help="Secret name"),
+    value: Optional[str] = typer.Option(None, "--value", "-v", help="Secret value"),
+    from_file: Optional[str] = typer.Option(None, "--from-file", help="Read value from file"),
+):
+    """Set a secret."""
+    if from_file:
+        from pathlib import Path
+        value = Path(from_file).read_text().strip()
+    if not value:
+        value = typer.prompt("Secret value", hide_input=True)
+    try:
+        gateway_post("/build/secrets", {"name": name, "value": value})
+        console.print(f"[green]✓[/green] Secret set: {name}")
+    except APIError as e:
+        console.print(f"[red]Error:[/red] {e.detail}")
+        raise typer.Exit(1)
+
+
+@app.command("delete")
+def delete_secret(name: str = typer.Argument(), confirm: bool = typer.Option(False, "--yes", "-y")):
+    """Delete a secret."""
+    if not confirm:
+        typer.confirm(f"Delete secret '{name}'?", abort=True)
+    try:
+        gateway_delete(f"/build/secrets/{name}")
+        console.print(f"[green]✓[/green] Deleted: {name}")
+    except APIError as e:
+        console.print(f"[red]Error:[/red] {e.detail}")
+        raise typer.Exit(1)