ninetrix 0.1.0__tar.gz

ninetrix-0.1.0/PKG-INFO

@@ -0,0 +1,126 @@
+Metadata-Version: 2.4
+Name: ninetrix
+Version: 0.1.0
+Summary: CLI for building and deploying AI agents as containers
+License: MIT
+Keywords: ai,agents,cli,docker,automation
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: click>=8.1
+Requires-Dist: rich>=13.7
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: jinja2>=3.1
+Requires-Dist: docker>=7.0
+Requires-Dist: mcp>=1.0
+Requires-Dist: jsonschema>=4.0
+Requires-Dist: psycopg[binary]>=3.0
+Requires-Dist: httpx>=0.27
+
+# ninetrix
+
+Build and deploy AI agents as Docker containers. Define your agent in YAML, ship it anywhere Docker runs.
+
+```bash
+pip install ninetrix
+```
+
+---
+
+## Quickstart
+
+```bash
+# Scaffold a new agent
+ninetrix init --name my-agent --provider anthropic
+
+# Build the container image
+ninetrix build --file ninetrix.yaml
+
+# Run it interactively
+ninetrix run --file ninetrix.yaml
+```
+
+## Multi-agent crews
+
+```bash
+# Start all agents on a shared Docker network
+ninetrix up --file ninetrix.yaml
+
+# Trigger the orchestrator
+ninetrix invoke --agent orchestrator -m "Research Python history and write a summary"
+
+# Stream logs from all agents
+ninetrix logs --file ninetrix.yaml
+
+# Visualize the execution trace
+ninetrix trace --thread-id <id>
+
+# Tear down
+ninetrix down --file ninetrix.yaml
+```
+
+## ninetrix.yaml
+
+```yaml
+agents:
+  orchestrator:
+    metadata:
+      role: "Research Orchestrator"
+      goal: "Coordinate search and synthesis"
+    runtime:
+      provider: anthropic
+      model: claude-sonnet-4-6
+    tools:
+      - { name: search, source: mcp://duckduckgo }
+    collaborators: [researcher, writer]
+    governance:
+      max_budget_per_run: 1.00
+      human_approval: true
+    triggers:
+      - type: webhook
+        endpoint: /run
+
+  researcher:
+    runtime: { model: claude-haiku-4-5-20251001 }
+    tools:
+      - { name: search, source: mcp://duckduckgo }
+      - { name: files,  source: mcp://filesystem }
+
+  writer:
+    runtime: { model: claude-sonnet-4-6, temperature: 0.7 }
+    tools:
+      - { name: files, source: mcp://filesystem }
+```
+
+## Commands
+
+| Command | Description |
+|---|---|
+| `ninetrix init` | Scaffold a new `ninetrix.yaml` |
+| `ninetrix build` | Build container images |
+| `ninetrix run` | Run a single agent interactively |
+| `ninetrix up` | Start all agents on a Docker bridge network |
+| `ninetrix down` | Stop and remove all crew containers |
+| `ninetrix status` | Show running agent containers |
+| `ninetrix logs` | Stream logs from all agents |
+| `ninetrix invoke` | POST a message to a running agent |
+| `ninetrix trace` | Render a multi-agent execution tree |
+| `ninetrix mcp list` | List available MCP tool servers |
+
+## Environment variables
+
+| Variable | Description |
+|---|---|
+| `ANTHROPIC_API_KEY` | Anthropic API key |
+| `OPENAI_API_KEY` | OpenAI API key |
+| `DATABASE_URL` | PostgreSQL URL for persistence |
+| `ninetrix_PROVIDER` | Override model provider at runtime |
+| `ninetrix_MODEL` | Override model at runtime |
+
+## Requirements
+
+- Python 3.10+
+- Docker
+
+## License
+
+MIT

ninetrix-0.1.0/README.md

@@ -0,0 +1,108 @@
+# ninetrix
+
+Build and deploy AI agents as Docker containers. Define your agent in YAML, ship it anywhere Docker runs.
+
+```bash
+pip install ninetrix
+```
+
+---
+
+## Quickstart
+
+```bash
+# Scaffold a new agent
+ninetrix init --name my-agent --provider anthropic
+
+# Build the container image
+ninetrix build --file ninetrix.yaml
+
+# Run it interactively
+ninetrix run --file ninetrix.yaml
+```
+
+## Multi-agent crews
+
+```bash
+# Start all agents on a shared Docker network
+ninetrix up --file ninetrix.yaml
+
+# Trigger the orchestrator
+ninetrix invoke --agent orchestrator -m "Research Python history and write a summary"
+
+# Stream logs from all agents
+ninetrix logs --file ninetrix.yaml
+
+# Visualize the execution trace
+ninetrix trace --thread-id <id>
+
+# Tear down
+ninetrix down --file ninetrix.yaml
+```
+
+## ninetrix.yaml
+
+```yaml
+agents:
+  orchestrator:
+    metadata:
+      role: "Research Orchestrator"
+      goal: "Coordinate search and synthesis"
+    runtime:
+      provider: anthropic
+      model: claude-sonnet-4-6
+    tools:
+      - { name: search, source: mcp://duckduckgo }
+    collaborators: [researcher, writer]
+    governance:
+      max_budget_per_run: 1.00
+      human_approval: true
+    triggers:
+      - type: webhook
+        endpoint: /run
+
+  researcher:
+    runtime: { model: claude-haiku-4-5-20251001 }
+    tools:
+      - { name: search, source: mcp://duckduckgo }
+      - { name: files,  source: mcp://filesystem }
+
+  writer:
+    runtime: { model: claude-sonnet-4-6, temperature: 0.7 }
+    tools:
+      - { name: files, source: mcp://filesystem }
+```
+
+## Commands
+
+| Command | Description |
+|---|---|
+| `ninetrix init` | Scaffold a new `ninetrix.yaml` |
+| `ninetrix build` | Build container images |
+| `ninetrix run` | Run a single agent interactively |
+| `ninetrix up` | Start all agents on a Docker bridge network |
+| `ninetrix down` | Stop and remove all crew containers |
+| `ninetrix status` | Show running agent containers |
+| `ninetrix logs` | Stream logs from all agents |
+| `ninetrix invoke` | POST a message to a running agent |
+| `ninetrix trace` | Render a multi-agent execution tree |
+| `ninetrix mcp list` | List available MCP tool servers |
+
+## Environment variables
+
+| Variable | Description |
+|---|---|
+| `ANTHROPIC_API_KEY` | Anthropic API key |
+| `OPENAI_API_KEY` | OpenAI API key |
+| `DATABASE_URL` | PostgreSQL URL for persistence |
+| `ninetrix_PROVIDER` | Override model provider at runtime |
+| `ninetrix_MODEL` | Override model at runtime |
+
+## Requirements
+
+- Python 3.10+
+- Docker
+
+## License
+
+MIT

ninetrix-0.1.0/agentfile/__init__.py

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

ninetrix-0.1.0/agentfile/cli.py

@@ -0,0 +1,136 @@
+"""Ninetrix CLI entry point."""
+
+from __future__ import annotations
+
+import os
+import sys
+
+import click
+from rich.console import Console
+
+from agentfile import __version__
+from agentfile.commands.init import init_cmd
+from agentfile.commands.build import build_cmd
+from agentfile.commands.run import run_cmd
+from agentfile.commands.deploy import deploy_cmd
+from agentfile.commands.mcp import mcp_cmd
+from agentfile.commands.up import up_cmd
+from agentfile.commands.down import down_cmd
+from agentfile.commands.status import status_cmd
+from agentfile.commands.logs import logs_cmd
+from agentfile.commands.invoke import invoke_cmd
+from agentfile.commands.trace import trace_cmd
+from agentfile.commands.restart import restart_cmd
+from agentfile.commands.rollback import rollback_cmd
+from agentfile.commands.doctor import doctor_cmd
+from agentfile.commands.validate import validate_cmd
+from agentfile.commands.auth import auth_cmd
+from agentfile.commands.compose import compose_cmd
+from agentfile.commands.gateway import gateway_cmd
+from agentfile.commands.dev import dev_command
+
+console = Console()
+
+LOGO = "[bold purple] Ninetrix [/bold purple]"
+
+
+@click.group()
+@click.version_option(__version__, "--version", "-V")
+def cli() -> None:
+    """[bold]Ninetrix[/bold] — build and deploy AI agents as containers.
+
+    \b
+    Quick start:
+      ninetrix init          scaffold agentfile.yaml
+      ninetrix build         build Docker image(s)
+      ninetrix run           run entry agent locally
+      ninetrix deploy        push & deploy to a registry
+      ninetrix mcp list      inspect MCP tool integrations
+
+    \b
+    Multi-agent warm pool:
+      ninetrix up            start all agents on a Docker network
+      ninetrix status        show agent container status
+      ninetrix invoke        send a message to a running agent
+      ninetrix logs          stream agent container logs
+      ninetrix trace         visualize a multi-agent run
+      ninetrix restart       rebuild and restart one agent
+      ninetrix rollback      switch one agent to a previous image tag
+      ninetrix down          stop the warm pool
+
+    \b
+    Compose deployment:
+      ninetrix compose       generate docker-compose.yml for any cloud
+
+    \b
+    MCP Gateway:
+      ninetrix gateway start   start local gateway + worker stack
+      ninetrix gateway status  show connected workers and tools
+      ninetrix gateway stop    tear down the gateway stack
+
+    \b
+    Local environment:
+      ninetrix dev           start local server (API + MCP gateway + dashboard)
+
+    \b
+    Utilities:
+      ninetrix validate      lint agentfile.yaml without building
+      ninetrix doctor        check Docker, API, pool, and env vars
+      ninetrix auth          manage API authentication
+    """
+    pass
+
+
+# Register sub-commands
+cli.add_command(init_cmd,   name="init")
+cli.add_command(build_cmd,  name="build")
+cli.add_command(run_cmd,    name="run")
+cli.add_command(deploy_cmd, name="deploy")
+cli.add_command(mcp_cmd,    name="mcp")
+cli.add_command(up_cmd,     name="up")
+cli.add_command(down_cmd,   name="down")
+cli.add_command(status_cmd, name="status")
+cli.add_command(logs_cmd,   name="logs")
+cli.add_command(invoke_cmd,   name="invoke")
+cli.add_command(trace_cmd,   name="trace")
+cli.add_command(restart_cmd,  name="restart")
+cli.add_command(rollback_cmd, name="rollback")
+cli.add_command(doctor_cmd,   name="doctor")
+cli.add_command(validate_cmd, name="validate")
+cli.add_command(auth_cmd,     name="auth")
+cli.add_command(compose_cmd,  name="compose")
+cli.add_command(gateway_cmd,  name="gateway")
+cli.add_command(dev_command,   name="dev")
+
+
+def main() -> None:
+    debug = os.environ.get("NINETRIX_DEBUG") == "1"
+    try:
+        cli(standalone_mode=False)
+    except click.exceptions.Exit as exc:
+        sys.exit(exc.exit_code)
+    except click.exceptions.Abort:
+        console.print("\n[yellow]Aborted.[/yellow]")
+        sys.exit(1)
+    except SystemExit:
+        raise
+    except Exception as exc:
+        if debug:
+            raise
+        # Friendly last-resort handler — individual commands should catch their
+        # own exceptions and give better messages, but this prevents raw tracebacks.
+        from docker.errors import DockerException
+        from agentfile.core.errors import fmt_docker_error
+        if isinstance(exc, DockerException):
+            msg, hint = fmt_docker_error(exc)
+            console.print(f"\n  [red]✗[/red] Docker error: {msg}")
+            if hint:
+                console.print(f"    [dim]Hint: {hint}[/dim]")
+        else:
+            console.print(f"\n  [red]✗[/red] {exc}")
+        console.print("    [dim]Set NINETRIX_DEBUG=1 for the full traceback.[/dim]")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

ninetrix-0.1.0/agentfile/commands/auth.py

@@ -0,0 +1,120 @@
+"""ninetrix auth — manage authentication with the Ninetrix API."""
+from __future__ import annotations
+
+import json
+import os
+
+import click
+import httpx
+from rich.console import Console
+
+from agentfile.core.auth import (
+    SECRET_FILE,
+    TOKEN_FILE,
+    auth_headers,
+    clear_token,
+    save_token,
+)
+
+console = Console()
+
+
+@click.group("auth")
+def auth_cmd() -> None:
+    """Manage authentication with the Ninetrix API hub."""
+    pass
+
+
+@auth_cmd.command("login")
+@click.option("--token", "-t", required=True, metavar="TOKEN",
+              help="Personal access token from the Ninetrix dashboard (Settings → API Keys)")
+@click.option("--api-url", default=None, metavar="URL",
+              help="API URL (overrides AGENTFILE_API_URL, default: http://localhost:8000)")
+def auth_login(token: str, api_url: str | None) -> None:
+    """Save an API token — enables credential injection in ninetrix run/up."""
+    url = api_url or os.environ.get("AGENTFILE_API_URL", "http://localhost:8000")
+    console.print()
+
+    # Verify the token against the live API before saving
+    try:
+        resp = httpx.get(
+            f"{url}/integrations/credentials",
+            headers={"Authorization": f"Bearer {token}"},
+            timeout=5,
+        )
+        if resp.status_code == 401:
+            console.print("[red]Token rejected — double-check it's correct.[/red]\n")
+            raise SystemExit(1)
+        if resp.status_code not in (200,):
+            console.print(
+                f"  [yellow]Warning:[/yellow] API returned {resp.status_code}. "
+                "Saving anyway."
+            )
+    except httpx.ConnectError:
+        console.print(
+            f"  [yellow]Warning:[/yellow] Could not reach [dim]{url}[/dim] — saving token anyway."
+        )
+
+    save_token(token)
+    console.print(f"  [green]✓[/green] Token saved → [dim]{TOKEN_FILE}[/dim]")
+    console.print(f"  [dim]API:[/dim] {url}\n")
+
+
+@auth_cmd.command("logout")
+def auth_logout() -> None:
+    """Remove the stored API token."""
+    console.print()
+    if not TOKEN_FILE.exists():
+        console.print("  [dim]No token stored — nothing to remove.[/dim]\n")
+        return
+    clear_token()
+    console.print("  [green]✓[/green] Token removed.\n")
+
+
+@auth_cmd.command("status")
+@click.option("--api-url", default=None, metavar="URL", help="API URL to check")
+def auth_status(api_url: str | None) -> None:
+    """Show which auth method is active and whether the API is reachable."""
+    url = api_url or os.environ.get("AGENTFILE_API_URL", "http://localhost:8000")
+    console.print()
+    console.print("[bold]ninetrix auth status[/bold]\n")
+
+    # Determine which source the token comes from
+    if os.environ.get("AGENTFILE_API_TOKEN"):
+        method = "env var [dim](AGENTFILE_API_TOKEN)[/dim]"
+    elif TOKEN_FILE.exists():
+        try:
+            data = json.loads(TOKEN_FILE.read_text())
+            if data.get("token"):
+                method = f"token file [dim]({TOKEN_FILE})[/dim]"
+            else:
+                method = "[dim]token file (empty)[/dim]"
+        except Exception:
+            method = "[dim]token file (unreadable)[/dim]"
+    elif SECRET_FILE.exists():
+        method = f"machine secret [dim]({SECRET_FILE})[/dim]"
+    else:
+        method = "[yellow]none[/yellow]"
+
+    console.print(f"  [dim]Auth method:[/dim]  {method}")
+    console.print(f"  [dim]API URL:    [/dim]  {url}")
+
+    # Connectivity check
+    try:
+        resp = httpx.get(
+            f"{url}/integrations/credentials",
+            headers=auth_headers(url),
+            timeout=3,
+        )
+        if resp.status_code == 200:
+            console.print("  [dim]Status:    [/dim]  [green]✓ connected[/green]")
+        elif resp.status_code == 401:
+            console.print(
+                "  [dim]Status:    [/dim]  [red]✗ auth failed[/red]  "
+                "[dim]— run [bold]ninetrix auth login --token <token>[/bold][/dim]"
+            )
+        else:
+            console.print(f"  [dim]Status:    [/dim]  [yellow]HTTP {resp.status_code}[/yellow]")
+    except httpx.ConnectError:
+        console.print("  [dim]Status:    [/dim]  [dim]API not reachable[/dim]")
+    console.print()

ninetrix-0.1.0/agentfile/commands/build.py

@@ -0,0 +1,172 @@
+"""agentfile build — validate + Dockerfile + docker build."""
+
+from __future__ import annotations
+
+import shutil
+import tempfile
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+
+import click
+from jinja2 import Environment, PackageLoader
+from rich.console import Console
+
+from agentfile.core.models import AgentDef, AgentFile
+from agentfile.core.docker import build_image
+from agentfile.core.template_context import build_context
+
+console = Console()
+
+
+def _render_templates(agent_def: AgentDef, af: AgentFile, context_dir: Path) -> None:
+    """Render Dockerfile and entrypoint.py into context_dir for a single agent."""
+    env = Environment(
+        loader=PackageLoader("agentfile", "templates"),
+        keep_trailing_newline=True,
+    )
+
+    ctx = build_context(
+        af,
+        agent_def,
+        is_saas_runner=False,
+        has_invoke_server=agent_def.serve,
+        _warn=lambda msg: console.print(f"  [yellow]Warning:[/yellow] {msg}"),
+    )
+
+    dockerfile = env.get_template("Dockerfile.j2").render(**ctx)
+    (context_dir / "Dockerfile").write_text(dockerfile)
+
+    entrypoint = env.get_template("entrypoint.py.j2").render(**ctx)
+    (context_dir / "entrypoint.py").write_text(entrypoint)
+
+
+def _build_one(
+    agent_name: str, agent_def: AgentDef, af: AgentFile,
+    agentfile_path: str, tag: str,
+) -> tuple[bool, str, list[str]]:
+    """Render templates and build one image in a worker thread.
+
+    Returns (success, full_tag, log_lines). Never prints to console directly
+    so it is safe to call from multiple threads simultaneously.
+    """
+    import docker as _docker
+    from docker.errors import DockerException as _DE
+
+    lines: list[str] = []
+    with tempfile.TemporaryDirectory(prefix=f"agentfile-build-{agent_name}-") as tmp:
+        ctx = Path(tmp)
+        shutil.copy(agentfile_path, ctx / "agentfile.yaml")
+        _render_templates(agent_def, af, ctx)
+        full_tag = agent_def.image_name(tag)
+        try:
+            client = _docker.from_env()
+            _img, logs = client.images.build(
+                path=str(ctx), tag=full_tag, rm=True, forcerm=True,
+            )
+            for chunk in logs:
+                line = chunk.get("stream", "").rstrip()
+                if line:
+                    lines.append(line)
+            return True, full_tag, lines
+        except _DE as exc:
+            return False, full_tag, [str(exc)]
+
+
+@click.command("build")
+@click.option("--file", "-f", "agentfile_path", default="agentfile.yaml",
+              show_default=True, help="Path to agentfile.yaml")
+@click.option("--tag", "-t", default="latest", show_default=True,
+              help="Docker image tag")
+@click.option("--push", is_flag=True, default=False,
+              help="Push the image(s) after building")
+@click.option("--agent", "agent_filter", default=None,
+              help="Build only this agent key (multi-agent files)")
+@click.option("--environment", "environment", default=None, metavar="NAME",
+              help="Apply environment overlay from agentfile.yaml (e.g. dev, prod)")
+def build_cmd(agentfile_path: str, tag: str, push: bool, agent_filter: str | None,
+              environment: str | None) -> None:
+    """Validate agentfile.yaml and build Docker image(s)."""
+    console.print()
+    console.print("[bold purple]ninetrix build[/bold purple]\n")
+
+    console.print(f"  Reading [bold]{agentfile_path}[/bold] …")
+    try:
+        af = AgentFile.from_path(agentfile_path)
+    except (FileNotFoundError, ValueError) as exc:
+        console.print(f"[red]{exc}[/red]")
+        raise SystemExit(1)
+
+    if environment:
+        if environment not in af.environments:
+            available = ", ".join(af.environments.keys()) or "none defined"
+            console.print(f"[red]Environment '{environment}' not found.[/red] Available: {available}")
+            raise SystemExit(1)
+        af = af.for_env(environment)
+        console.print(f"  [dim]Environment:[/dim] [bold]{environment}[/bold]")
+
+    errors = af.validate()
+    if errors:
+        console.print("[red]Validation failed:[/red]")
+        for e in errors:
+            console.print(f"    • {e}")
+        raise SystemExit(1)
+    console.print("  [green]✓[/green] Agentfile is valid")
+
+    if agent_filter:
+        if agent_filter not in af.agents:
+            console.print(f"[red]Agent '{agent_filter}' not found in agentfile.[/red]")
+            console.print(f"  Available agents: {', '.join(af.agents.keys())}")
+            raise SystemExit(1)
+        agents_to_build = {agent_filter: af.agents[agent_filter]}
+    else:
+        agents_to_build = af.agents
+
+    built_refs: list[str] = []
+
+    if len(agents_to_build) == 1:
+        # Single agent — stream docker output verbosely as before
+        agent_name, agent_def = next(iter(agents_to_build.items()))
+        with tempfile.TemporaryDirectory(prefix=f"agentfile-build-{agent_name}-") as tmp:
+            ctx = Path(tmp)
+            shutil.copy(agentfile_path, ctx / "agentfile.yaml")
+            _render_templates(agent_def, af, ctx)
+            image_ref = build_image(ctx, agent_def.image_name(), tag)
+            built_refs.append(image_ref)
+    else:
+        # Multi-agent — build all images in parallel, show spinner + summary
+        names = list(agents_to_build.keys())
+        console.print(
+            f"  [dim]Building {len(names)} image(s) in parallel: {', '.join(names)}[/dim]"
+        )
+        results: dict[str, tuple[bool, str, list[str]]] = {}
+        with console.status("  Building images…", spinner="dots"):
+            with ThreadPoolExecutor(max_workers=len(agents_to_build)) as pool:
+                futures = {
+                    pool.submit(_build_one, name, adef, af, agentfile_path, tag): name
+                    for name, adef in agents_to_build.items()
+                }
+                for future in as_completed(futures):
+                    results[futures[future]] = future.result()
+
+        any_failed = False
+        for name in names:          # print in declaration order
+            ok, ref, lines = results[name]
+            if ok:
+                console.print(f"  [green]✓[/green] Built [bold]{ref}[/bold]")
+                built_refs.append(ref)
+            else:
+                msg = lines[-1] if lines else "unknown error"
+                console.print(f"  [red]✗[/red] Failed to build [bold]{name}[/bold]: {msg}")
+                any_failed = True
+        if any_failed:
+            raise SystemExit(1)
+
+    if push:
+        from agentfile.core.docker import push_image
+        for ref in built_refs:
+            push_image(ref)
+
+    if len(built_refs) == 1:
+        console.print(f"\n  Run it with:\n    [bold]ninetrix run --image {built_refs[0]}[/bold]\n")
+    else:
+        console.print(f"\n  Start the warm pool with:\n    [bold]ninetrix up --file {agentfile_path}[/bold]\n")