ntro-cli 0.1.0__py3-none-any.whl

ntro_cli/commands/auth.py

@@ -0,0 +1,107 @@
+"""ntro auth — connection management and identity."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+
+from ntro.workspace.config import load_config, save_config, write_default_config
+from ntro.workspace.exceptions import NtroError
+from ntro_cli import output as out
+from ntro_cli.context import get_client
+
+app = typer.Typer(help="Manage connections and verify identity")
+
+
+@app.command()
+def login(
+    name: str = typer.Option("local", "--name", "-n", help="Connection name"),
+    host: str = typer.Option("http://localhost:3000/v1", "--host", help="API host URL"),
+    api_key: Optional[str] = typer.Option(None, "--api-key", help="API key"),
+    default_tenant: Optional[str] = typer.Option(None, "--tenant", help="Default tenant slug"),
+    set_default: bool = typer.Option(True, "--set-default/--no-set-default", help="Set as default connection"),
+    no_interactive: bool = typer.Option(False, "--no-interactive", help="Skip prompts (use flags only)"),
+) -> None:
+    """Add or update a connection in ~/.ntro/config.toml."""
+    write_default_config()
+    config = load_config()
+
+    if not no_interactive:
+        name = typer.prompt("Connection name", default=name)
+        host = typer.prompt("API host", default=host)
+        api_key = typer.prompt("API key", default=api_key or "", hide_input=True) or None
+        default_tenant = typer.prompt("Default tenant (optional)", default=default_tenant or "", show_default=False) or None
+
+    from ntro.workspace.config import ConnectionConfig
+    config.connections[name] = ConnectionConfig(
+        name=name,
+        host=host,
+        api_key=api_key or "",
+        default_tenant=default_tenant,
+    )
+
+    if set_default:
+        config.default_connection_name = name
+
+    save_config(config)
+    out.print_success(f"Connection '{name}' saved → {host}")
+    if set_default:
+        out.print_success(f"Default connection set to '{name}'")
+
+
+@app.command("list")
+def list_connections() -> None:
+    """List all configured connections."""
+    config = load_config()
+    if not config.connections:
+        out.print_warning("No connections configured. Run 'ntro auth login' to add one.")
+        return
+
+    rows = []
+    for name, conn in config.connections.items():
+        rows.append({
+            "name": name,
+            "host": conn.host,
+            "default_tenant": conn.default_tenant or "",
+            "active": "●" if name == config.default_connection_name else "",
+        })
+    out.output(rows, columns=["active", "name", "host", "default_tenant"], title="Connections")
+
+
+@app.command()
+def test(
+    connection: Optional[str] = typer.Option(None, "-c", "--connection", help="Connection to test"),
+) -> None:
+    """Test a connection by calling GET /me."""
+    try:
+        client = get_client()
+        profile = client.identity.whoami_sync()
+        out.print_success(f"Connected as {profile.email} (org: {profile.orgId})")
+    except NtroError as e:
+        out.print_error(str(e))
+        raise typer.Exit(1)
+
+
+@app.command("set-default")
+def set_default(name: str = typer.Argument(help="Connection name to set as default")) -> None:
+    """Set the default connection."""
+    config = load_config()
+    if name not in config.connections:
+        out.print_error(f"Connection '{name}' not found. Available: {list(config.connections.keys())}")
+        raise typer.Exit(1)
+    config.default_connection_name = name
+    save_config(config)
+    out.print_success(f"Default connection set to '{name}'")
+
+
+@app.command()
+def whoami() -> None:
+    """Show current user identity (calls GET /me)."""
+    try:
+        client = get_client()
+        profile = client.identity.whoami_sync()
+        out.output(profile, title="Current User")
+    except NtroError as e:
+        out.print_error(str(e))
+        raise typer.Exit(1)

ntro_cli/commands/entity.py

@@ -0,0 +1,93 @@
+"""ntro entity — manage SPVs/funds within a tenant."""
+
+from __future__ import annotations
+
+import os
+from typing import Optional
+
+import click
+import typer
+
+from ntro.workspace.config import load_config
+from ntro.workspace.exceptions import NtroError
+from ntro_cli import output as out
+from ntro_cli.context import get_client
+from ntro_cli.helpers import load_json_input
+
+app = typer.Typer(help="Manage entities (SPVs/funds within a tenant)")
+
+
+def _resolve_tenant(tenant_flag: Optional[str]) -> str:
+    """Resolve tenant from flag > env var > config default."""
+    if tenant_flag:
+        return tenant_flag
+    env = os.environ.get("NTRO_TENANT")
+    if env:
+        return env
+    try:
+        ctx = click.get_current_context()
+        conn_name = ctx.obj.get("connection") if ctx.obj else None
+        config = load_config()
+        conn = config.get_connection(conn_name)
+        if conn.default_tenant:
+            return conn.default_tenant
+    except Exception:
+        pass
+    raise typer.BadParameter(
+        "Tenant required. Use --tenant, set NTRO_TENANT, or set default_tenant in config."
+    )
+
+
+@app.command()
+def create(
+    name: Optional[str] = typer.Option(None, help="Entity display name"),
+    slug: Optional[str] = typer.Option(None, help="URL-safe identifier"),
+    tenant: Optional[str] = typer.Option(None, "--tenant", help="Tenant slug or ID", envvar="NTRO_TENANT"),
+    entity_type: Optional[str] = typer.Option(None, "--type", help="Entity type (e.g. real-estate-spv)"),
+    jurisdiction: Optional[str] = typer.Option(None, help="Legal jurisdiction"),
+    currency: Optional[str] = typer.Option(None, help="Base currency (e.g. GBP)"),
+    schema: Optional[str] = typer.Option(None, help="Databricks schema name"),
+    json_input: Optional[str] = typer.Option(None, "--json", help="JSON payload (inline or @file)"),
+) -> None:
+    """Create a new entity within a tenant."""
+    try:
+        tenant_id = _resolve_tenant(tenant)
+
+        if json_input:
+            payload = load_json_input(json_input)
+        else:
+            if not name or not slug:
+                raise typer.BadParameter("Provide --name and --slug (or use --json)")
+            payload = {
+                "name": name,
+                "slug": slug,
+                "type": entity_type,
+                "jurisdiction": jurisdiction,
+                "currency": currency,
+                "schema": schema,
+            }
+
+        client = get_client()
+        entity = client.entities.create_sync(tenant_id=tenant_id, **payload)
+        out.output(entity, title=f"Entity created: {entity.slug}")
+    except NtroError as e:
+        out.print_error(str(e))
+        raise typer.Exit(1)
+
+
+@app.command("list")
+def list_entities(
+    tenant: Optional[str] = typer.Option(None, "--tenant", help="Filter by tenant", envvar="NTRO_TENANT"),
+) -> None:
+    """List entities (optionally filtered by tenant)."""
+    try:
+        client = get_client()
+        entities = client.entities.list_sync(tenant_id=tenant)
+        out.output(
+            entities,
+            columns=["id", "slug", "name", "tenantId", "type", "currency"],
+            title="Entities",
+        )
+    except NtroError as e:
+        out.print_error(str(e))
+        raise typer.Exit(1)

ntro_cli/commands/integration.py

@@ -0,0 +1,131 @@
+"""ntro integration — data platforms and email sources."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+
+from ntro.workspace.exceptions import NtroError
+from ntro_cli import output as out
+from ntro_cli.context import get_client
+from ntro_cli.helpers import load_json_input
+
+app = typer.Typer(help="Manage data platform integrations and email sources")
+add_app = typer.Typer(help="Add a new integration")
+app.add_typer(add_app, name="add")
+
+
+@add_app.command()
+def databricks(
+    name: Optional[str] = typer.Option(None, help="Display name"),
+    workspace_url: Optional[str] = typer.Option(None, "--workspace-url", help="Databricks workspace URL"),
+    catalog: Optional[str] = typer.Option(None, help="Unity Catalog name"),
+    client_id: Optional[str] = typer.Option(None, "--client-id", help="Service principal client ID"),
+    client_secret: Optional[str] = typer.Option(None, "--client-secret", help="Service principal secret", hide_input=True),
+    region: Optional[str] = typer.Option(None, help="Azure region (e.g. UK-South)"),
+    json_input: Optional[str] = typer.Option(None, "--json", help="JSON payload (inline or @file)"),
+) -> None:
+    """Register a Databricks data platform."""
+    try:
+        if json_input:
+            payload = load_json_input(json_input)
+        else:
+            if not all([name, workspace_url, catalog]):
+                raise typer.BadParameter("Provide --name, --workspace-url, --catalog (or use --json)")
+            payload = {
+                "name": name,
+                "provider": "DATABRICKS",
+                "region": region,
+                "config": {
+                    "workspaceUrl": workspace_url,
+                    "catalog": catalog,
+                    "authType": "service-principal",
+                    "clientId": client_id,
+                    "clientSecret": client_secret,
+                },
+            }
+
+        client = get_client()
+        result = client.integrations.create_data_platform_sync(**payload)
+        out.output(result, title=f"Integration created: {result.name}")
+    except NtroError as e:
+        out.print_error(str(e))
+        raise typer.Exit(1)
+
+
+@add_app.command()
+def email(
+    tenant_id: str = typer.Option(..., "--tenant", help="Tenant ID or slug"),
+    provider: str = typer.Option("microsoft-graph", help="Email provider"),
+    address: Optional[str] = typer.Option(None, help="Email address"),
+    json_input: Optional[str] = typer.Option(None, "--json", help="JSON payload (inline or @file)"),
+) -> None:
+    """Add an email integration."""
+    try:
+        if json_input:
+            payload = load_json_input(json_input)
+        else:
+            payload = {"tenantId": tenant_id, "provider": provider, "address": address}
+
+        client = get_client()
+        result = client.integrations.create_email_sync(**payload)
+        out.output(result, title="Email integration created")
+    except NtroError as e:
+        out.print_error(str(e))
+        raise typer.Exit(1)
+
+
+@app.command("list")
+def list_integrations() -> None:
+    """List all data platform configs."""
+    try:
+        client = get_client()
+        items = client.integrations.list_data_platforms_sync()
+        out.output(items, columns=["id", "name", "provider", "region", "ownership"], title="Data Platforms")
+    except NtroError as e:
+        out.print_error(str(e))
+        raise typer.Exit(1)
+
+
+@app.command()
+def info(id: str = typer.Argument(help="Data platform config ID")) -> None:
+    """Show data platform details."""
+    try:
+        client = get_client()
+        result = client.integrations.get_data_platform_sync(id)
+        out.output(result, title=f"Integration: {result.name}")
+    except NtroError as e:
+        out.print_error(str(e))
+        raise typer.Exit(1)
+
+
+@app.command()
+def test(id: str = typer.Argument(help="Data platform config ID")) -> None:
+    """Test a data platform connection."""
+    try:
+        from rich.console import Console
+        console = Console()
+        client = get_client()
+        with console.status("Testing connection..."):
+            result = client.integrations.test_connection_sync(id)
+        if result.success:
+            out.print_success(f"{result.message}" + (f" ({result.latencyMs}ms)" if result.latencyMs else ""))
+        else:
+            out.print_error(result.message)
+            raise typer.Exit(1)
+    except NtroError as e:
+        out.print_error(str(e))
+        raise typer.Exit(1)
+
+
+@app.command()
+def discover(id: str = typer.Argument(help="Data platform config ID")) -> None:
+    """Discover schemas in a data platform."""
+    try:
+        client = get_client()
+        schemas = client.integrations.discover_schemas_sync(id)
+        out.output(schemas, columns=["name"], title=f"Schemas in {id}")
+    except NtroError as e:
+        out.print_error(str(e))
+        raise typer.Exit(1)

ntro_cli/commands/run.py

@@ -0,0 +1,84 @@
+"""ntro run — inspect workflow executions."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+
+from ntro.workspace.exceptions import NtroError
+from ntro_cli import output as out
+from ntro_cli.context import get_client
+
+app = typer.Typer(help="Inspect workflow runs and execution history")
+
+
+@app.command()
+def status(id: str = typer.Argument(help="Task ID")) -> None:
+    """Show the status of a workflow run."""
+    try:
+        client = get_client()
+        task = client.tasks.get_sync(id)
+        out.output(task, title=f"Run: {task.id}")
+    except NtroError as e:
+        out.print_error(str(e))
+        raise typer.Exit(1)
+
+
+@app.command("list")
+def list_runs() -> None:
+    """List scheduled / upcoming runs."""
+    try:
+        client = get_client()
+        tasks = client.tasks.list_schedule_sync()
+        out.output(
+            tasks,
+            columns=["id", "title", "workflowId", "status", "dueDate"],
+            title="Schedule",
+        )
+    except NtroError as e:
+        out.print_error(str(e))
+        raise typer.Exit(1)
+
+
+@app.command()
+def history(
+    tenant: str = typer.Option(..., "--tenant", help="Tenant ID", envvar="NTRO_TENANT"),
+    entity: str = typer.Option(..., "--entity", help="Entity ID", envvar="NTRO_ENTITY"),
+) -> None:
+    """Show run history for a tenant/entity."""
+    try:
+        client = get_client()
+        tasks = client.tasks.history_sync(tenant, entity)
+        out.output(
+            tasks,
+            columns=["id", "title", "workflowId", "status", "createdAt"],
+            title=f"History — {entity}",
+        )
+    except NtroError as e:
+        out.print_error(str(e))
+        raise typer.Exit(1)
+
+
+@app.command()
+def incoming() -> None:
+    """List incoming (queued) runs."""
+    try:
+        client = get_client()
+        items = client.tasks.list_incoming_sync()
+        out.output(items, title="Incoming")
+    except NtroError as e:
+        out.print_error(str(e))
+        raise typer.Exit(1)
+
+
+@app.command()
+def pending() -> None:
+    """List pending (awaiting action) runs."""
+    try:
+        client = get_client()
+        items = client.tasks.list_pending_sync()
+        out.output(items, title="Pending")
+    except NtroError as e:
+        out.print_error(str(e))
+        raise typer.Exit(1)

ntro_cli/commands/tenant.py

@@ -0,0 +1,62 @@
+"""ntro tenant — manage client cells."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+
+from ntro.workspace.exceptions import NtroError
+from ntro_cli import output as out
+from ntro_cli.context import get_client
+from ntro_cli.helpers import load_json_input
+
+app = typer.Typer(help="Manage tenants (client cells)")
+
+
+@app.command()
+def create(
+    name: Optional[str] = typer.Option(None, help="Tenant display name"),
+    slug: Optional[str] = typer.Option(None, help="URL-safe identifier"),
+    integration: Optional[str] = typer.Option(None, "--integration", help="Data platform config ID"),
+    json_input: Optional[str] = typer.Option(None, "--json", help="JSON payload (inline or @file)"),
+) -> None:
+    """Create a new tenant."""
+    try:
+        if json_input:
+            payload = load_json_input(json_input)
+        else:
+            if not name or not slug:
+                raise typer.BadParameter("Provide --name and --slug (or use --json)")
+            payload = {"name": name, "slug": slug, "dataPlatformConfigId": integration}
+
+        client = get_client()
+        tenant = client.tenants.create_sync(**payload)
+        out.output(tenant, title=f"Tenant created: {tenant.slug}")
+    except NtroError as e:
+        out.print_error(str(e))
+        raise typer.Exit(1)
+
+
+@app.command("list")
+def list_tenants() -> None:
+    """List all tenants."""
+    try:
+        client = get_client()
+        tenants = client.tenants.list_sync()
+        out.output(tenants, columns=["id", "slug", "name", "status", "entityCount"], title="Tenants")
+    except NtroError as e:
+        out.print_error(str(e))
+        raise typer.Exit(1)
+
+
+@app.command()
+def info(id: str = typer.Argument(help="Tenant slug or ID")) -> None:
+    """Show tenant details."""
+    try:
+        client = get_client()
+        tenant = client.tenants.get_sync(id)
+        out.output(tenant, title=f"Tenant: {tenant.slug}")
+    except NtroError as e:
+        out.print_error(str(e))
+        raise typer.Exit(1)

ntro_cli/commands/workflow.py

@@ -0,0 +1,205 @@
+"""ntro workflow — definition, deployment, and triggering."""
+
+from __future__ import annotations
+
+import time
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+from ntro.workspace.exceptions import NtroError
+from ntro.workspace.models.common import TaskStatus
+from ntro_cli import output as out
+from ntro_cli.context import get_client
+from ntro_cli.helpers import load_json_input
+
+app = typer.Typer(help="Manage workflow definitions, deployments, and runs")
+
+
+@app.command()
+def create(
+    name: Optional[str] = typer.Option(None, help="Workflow name (slug)"),
+    description: Optional[str] = typer.Option(None, help="Description"),
+    tenant: Optional[str] = typer.Option(None, "--tenant", help="Tenant ID"),
+    schedule: Optional[str] = typer.Option(None, help="Cron schedule (e.g. '0 8 5 * *')"),
+    timezone: Optional[str] = typer.Option(None, help="Timezone (e.g. Europe/London)"),
+    json_input: Optional[str] = typer.Option(None, "--json", help="JSON payload (inline or @file)"),
+) -> None:
+    """Register a new workflow definition."""
+    try:
+        if json_input:
+            payload = load_json_input(json_input)
+        else:
+            if not name:
+                raise typer.BadParameter("Provide --name (or use --json)")
+            payload = {
+                "name": name,
+                "description": description,
+                "tenantId": tenant,
+                "schedule": schedule,
+                "timezone": timezone,
+            }
+
+        client = get_client()
+        wf = client.workflows.create_sync(**payload)
+        out.output(wf, title=f"Workflow created: {wf.name}")
+    except NtroError as e:
+        out.print_error(str(e))
+        raise typer.Exit(1)
+
+
+@app.command("list")
+def list_workflows() -> None:
+    """List all registered workflows."""
+    try:
+        client = get_client()
+        workflows = client.workflows.list_sync()
+        out.output(
+            workflows,
+            columns=["id", "name", "description", "schedule", "latestVersion"],
+            title="Workflows",
+        )
+    except NtroError as e:
+        out.print_error(str(e))
+        raise typer.Exit(1)
+
+
+@app.command()
+def info(id: str = typer.Argument(help="Workflow ID or name")) -> None:
+    """Show workflow details."""
+    try:
+        client = get_client()
+        wf = client.workflows.get_sync(id)
+        out.output(wf, title=f"Workflow: {wf.name}")
+    except NtroError as e:
+        out.print_error(str(e))
+        raise typer.Exit(1)
+
+
+@app.command()
+def push(
+    id: str = typer.Argument(help="Workflow ID"),
+    file: Path = typer.Argument(help="Artifact file to upload (.zip or .tar.gz)"),
+) -> None:
+    """Upload a new workflow version artifact."""
+    try:
+        if not file.exists():
+            out.print_error(f"File not found: {file}")
+            raise typer.Exit(1)
+
+        client = get_client()
+        version = client.workflows.push_sync(id, file)
+        out.output(version, title=f"Version pushed: {version.version}")
+    except NtroError as e:
+        out.print_error(str(e))
+        raise typer.Exit(1)
+
+
+@app.command()
+def deploy(
+    workflow_id: Optional[str] = typer.Option(None, "--workflow", help="Workflow ID"),
+    version_id: Optional[str] = typer.Option(None, "--version", help="Workflow version ID"),
+    tenant: Optional[str] = typer.Option(None, "--tenant", help="Tenant ID"),
+    entity: Optional[str] = typer.Option(None, "--entity", help="Entity ID"),
+    json_input: Optional[str] = typer.Option(None, "--json", help="JSON payload (inline or @file)"),
+) -> None:
+    """Deploy a workflow version to a tenant/entity."""
+    try:
+        if json_input:
+            payload = load_json_input(json_input)
+        else:
+            if not workflow_id or not version_id:
+                raise typer.BadParameter("Provide --workflow and --version (or use --json)")
+            payload = {
+                "workflowId": workflow_id,
+                "workflowVersionId": version_id,
+                "tenantId": tenant,
+                "entityId": entity,
+            }
+
+        client = get_client()
+        deployment = client.deployments.create_sync(**payload)
+        out.output(deployment, title=f"Deployment created: {deployment.id}")
+    except NtroError as e:
+        out.print_error(str(e))
+        raise typer.Exit(1)
+
+
+@app.command("deploy-status")
+def deploy_status(id: str = typer.Argument(help="Deployment ID")) -> None:
+    """Check deployment status."""
+    try:
+        client = get_client()
+        deployment = client.deployments.get_sync(id)
+        out.output(deployment, title=f"Deployment: {deployment.id}")
+    except NtroError as e:
+        out.print_error(str(e))
+        raise typer.Exit(1)
+
+
+@app.command("run")
+def run_workflow(
+    name: str = typer.Argument(help="Workflow name (e.g. nav-monthly)"),
+    tenant: Optional[str] = typer.Option(None, "--tenant", help="Tenant ID", envvar="NTRO_TENANT"),
+    entity: Optional[str] = typer.Option(None, "--entity", help="Entity ID", envvar="NTRO_ENTITY"),
+    period: Optional[str] = typer.Option(None, "--period", help="Accounting period (e.g. 2026-03)"),
+    priority: Optional[str] = typer.Option(None, "--priority", help="Priority: LOW, NORMAL, HIGH"),
+    dry_run: bool = typer.Option(False, "--dry-run", help="Validate without committing"),
+    wait: bool = typer.Option(False, "--wait", help="Poll until task completes"),
+    json_input: Optional[str] = typer.Option(None, "--json", help="JSON payload (inline or @file)"),
+) -> None:
+    """Trigger a workflow run."""
+    try:
+        if json_input:
+            payload = load_json_input(json_input)
+        else:
+            if not tenant:
+                raise typer.BadParameter("Provide --tenant or set NTRO_TENANT / default_tenant in config")
+            context: dict = {}
+            if period:
+                context["period"] = period
+            if priority:
+                context["priority"] = priority
+            if dry_run:
+                context["dry_run"] = True
+            payload = {
+                "tenantId": tenant,
+                "entityId": entity,
+                "workflowId": name,
+                "context": context,
+            }
+
+        client = get_client()
+        task = client.tasks.create_sync(**payload)
+        out.output(task, title=f"Run started: {task.id}")
+
+        if wait:
+            _poll_task(client, task.id)
+
+    except NtroError as e:
+        out.print_error(str(e))
+        raise typer.Exit(1)
+
+
+def _poll_task(client, task_id: str, interval: int = 3, timeout: int = 300) -> None:
+    from rich.console import Console
+    console = Console()
+    deadline = time.monotonic() + timeout
+
+    with console.status(f"Waiting for task {task_id}...") as status:
+        while time.monotonic() < deadline:
+            try:
+                task = client.tasks.get_sync(task_id)
+                status.update(f"[dim]{task.status}[/dim] — {task.id}")
+                if task.status in (TaskStatus.COMPLETED, TaskStatus.FAILED, TaskStatus.CANCELLED):
+                    break
+                time.sleep(interval)
+            except NtroError:
+                time.sleep(interval)
+
+    try:
+        task = client.tasks.get_sync(task_id)
+        out.output(task, title=f"Final status: {task.status}")
+    except NtroError as e:
+        out.print_error(str(e))

ntro_cli/context.py

@@ -0,0 +1,33 @@
+"""CLI context — SDK client initialisation and shared state."""
+
+from __future__ import annotations
+
+import click
+
+from ntro.workspace import Client
+
+
+def get_client() -> Client:
+    """Build and return a Client from the current Typer context."""
+    ctx = click.get_current_context()
+    obj: dict = ctx.ensure_object(dict)
+
+    if "client" not in obj:
+        connection: str | None = obj.get("connection")
+        host: str | None = obj.get("host")
+        debug: bool = obj.get("debug", False)
+
+        if host:
+            # Explicit host overrides config entirely
+            from ntro.workspace.config import load_config
+            conn_name = connection or None
+            try:
+                cfg = load_config().get_connection(conn_name)
+                api_key = cfg.api_key
+            except Exception:
+                api_key = ""
+            obj["client"] = Client(host=host, api_key=api_key, debug=debug)
+        else:
+            obj["client"] = Client.from_config(connection=connection, debug=debug)
+
+    return obj["client"]

ntro_cli/helpers.py

@@ -0,0 +1,21 @@
+"""Shared CLI helpers."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+
+def load_json_input(value: str) -> dict:
+    """Parse a --json argument.
+
+    Accepts:
+      - Inline JSON string:  '{"name": "Acme"}'
+      - File reference:      @./config.json  or  @/abs/path.json
+    """
+    if value.startswith("@"):
+        path = Path(value[1:]).expanduser()
+        if not path.exists():
+            raise FileNotFoundError(f"JSON file not found: {path}")
+        return json.loads(path.read_text())
+    return json.loads(value)

ntro_cli/main.py

@@ -0,0 +1,70 @@
+"""ntro CLI — root Typer app."""
+
+from __future__ import annotations
+
+import logging
+from typing import Optional
+
+import typer
+
+from ntro_cli import output as out
+from ntro_cli.commands import auth, entity, integration, run, tenant, workflow
+
+app = typer.Typer(
+    name="ntro",
+    help="ntro platform CLI",
+    no_args_is_help=True,
+    pretty_exceptions_show_locals=False,
+)
+
+app.add_typer(auth.app, name="auth")
+app.add_typer(integration.app, name="integration")
+app.add_typer(tenant.app, name="tenant")
+app.add_typer(entity.app, name="entity")
+app.add_typer(workflow.app, name="workflow")
+app.add_typer(run.app, name="run")
+
+
+@app.callback()
+def main(
+    ctx: typer.Context,
+    connection: Optional[str] = typer.Option(
+        None, "-c", "--connection",
+        help="Connection name from ~/.ntro/config.toml",
+        envvar="NTRO_DEFAULT_CONNECTION_NAME",
+    ),
+    host: Optional[str] = typer.Option(
+        None, "--host",
+        help="Override API host URL (e.g. http://localhost:3000/v1)",
+        envvar="NTRO_HOST",
+    ),
+    output: str = typer.Option(
+        "text", "-o", "--output",
+        help="Output format: text or json",
+    ),
+    debug: bool = typer.Option(False, "--debug", help="Enable debug logging"),
+    log_level: Optional[str] = typer.Option(
+        None, "--log-level",
+        help="Log level: DEBUG, INFO, WARN, ERROR",
+    ),
+) -> None:
+    """ntro platform CLI.
+
+    Default API: https://api.ntropii.com/v1
+    Local dev:   http://localhost:3000/v1  (use -c local or --host)
+
+    Quickstart:
+      ntro auth login          # configure a connection
+      ntro auth whoami         # verify identity
+      ntro tenant list         # list tenants
+    """
+    ctx.ensure_object(dict)
+    ctx.obj["connection"] = connection
+    ctx.obj["host"] = host
+    ctx.obj["debug"] = debug
+
+    out.set_format(output)
+
+    if debug or log_level:
+        level = getattr(logging, (log_level or "DEBUG").upper(), logging.DEBUG)
+        logging.basicConfig(level=level, format="%(name)s %(levelname)s %(message)s")

ntro_cli/output.py

@@ -0,0 +1,104 @@
+"""Output formatters — Rich tables/panels for text mode, raw JSON for json mode."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from pydantic import BaseModel
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+console = Console()
+err_console = Console(stderr=True)
+
+# Current output format — set by main.py callback from --output flag
+_output_format: str = "text"
+
+
+def set_format(fmt: str) -> None:
+    global _output_format
+    _output_format = fmt
+
+
+def get_format() -> str:
+    return _output_format
+
+
+def _to_dict(obj: Any) -> dict:
+    if isinstance(obj, BaseModel):
+        return obj.model_dump(mode="json")
+    if isinstance(obj, dict):
+        return obj
+    return {"value": str(obj)}
+
+
+def _to_dict_list(items: list) -> list[dict]:
+    return [_to_dict(i) for i in items]
+
+
+def output(
+    data: Any,
+    *,
+    columns: list[str] | None = None,
+    title: str | None = None,
+) -> None:
+    """Print data to stdout in the current output format."""
+    if _output_format == "json":
+        _print_json(data)
+    else:
+        if isinstance(data, list):
+            _print_table(data, columns=columns, title=title)
+        else:
+            _print_panel(data, title=title)
+
+
+def _print_json(data: Any) -> None:
+    if isinstance(data, list):
+        raw = [_to_dict(d) for d in data]
+    elif isinstance(data, BaseModel):
+        raw = data.model_dump()
+    else:
+        raw = data
+    console.print_json(json.dumps(raw, default=str))
+
+
+def _print_table(items: list, columns: list[str] | None, title: str | None) -> None:
+    if not items:
+        console.print("[dim]No results.[/dim]")
+        return
+
+    rows = _to_dict_list(items)
+
+    # Determine columns: explicit list, or all keys from first row
+    cols = columns or list(rows[0].keys())
+
+    table = Table(title=title, show_header=True, header_style="bold cyan")
+    for col in cols:
+        table.add_column(col)
+
+    for row in rows:
+        table.add_row(*[str(row.get(col, "")) for col in cols])
+
+    console.print(table)
+
+
+def _print_panel(data: Any, title: str | None) -> None:
+    row = _to_dict(data)
+    lines = "\n".join(
+        f"[bold]{k}[/bold]: {v}" for k, v in row.items() if v not in (None, "", [])
+    )
+    console.print(Panel(lines, title=title or "", expand=False))
+
+
+def print_success(message: str) -> None:
+    console.print(f"[green]✓[/green] {message}")
+
+
+def print_error(message: str) -> None:
+    err_console.print(f"[red]✗[/red] {message}")
+
+
+def print_warning(message: str) -> None:
+    console.print(f"[yellow]![/yellow] {message}")

ntro_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: ntro-cli
+Version: 0.1.0
+Summary: CLI for the ntro platform
+Requires-Python: >=3.11
+Requires-Dist: ntro>=0.1.0
+Requires-Dist: rich>=13.0
+Requires-Dist: typer>=0.12
+Provides-Extra: dev
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.4; extra == 'dev'

ntro_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+ntro_cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ntro_cli/context.py,sha256=Fvq6YV4GUH2q12nnyVBKnkOHPV6UN9ebxPs6LtMh2h8,1048
+ntro_cli/helpers.py,sha256=wuEOOMZyy2hiexk9-BphLqVK8mDZ8kbPoOs2JiQlo1A,555
+ntro_cli/main.py,sha256=9bv85ayEdBLkcuHZQLfag5Z8h_KtybmbGg-AIFMLB7U,2045
+ntro_cli/output.py,sha256=giP8028Ezz2mpHddBNcCP0jgRqHnqRDpGaErlZlPiYU,2612
+ntro_cli/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ntro_cli/commands/auth.py,sha256=qspNRBzMrIAngTU9YUn1n8yOVdqfkUdmUvYGVPRGoWg,3833
+ntro_cli/commands/entity.py,sha256=cqfUNvfB2KvtozvgfE13epgpRn1ygtL5MytIe2tVp4Y,3251
+ntro_cli/commands/integration.py,sha256=37J7Xl5Ne8u9JMp1Dhc-BmAfUU7eGzEcAlTtUhoGItY,4880
+ntro_cli/commands/run.py,sha256=Fcvh27lKuYPd1CN6lhVRzU_SPWHo36XFJ2RjOFiSd4A,2302
+ntro_cli/commands/tenant.py,sha256=I5qyyQLgLD9QjLB9nixRtHL_QAjORgbZyXQiAY-JjJk,2017
+ntro_cli/commands/workflow.py,sha256=hM3stg47bp_sCqbGNnI76bhyecpNoiIAnYiW6B9Iw2A,7333
+ntro_cli-0.1.0.dist-info/METADATA,sha256=DgKliN1BOO978soIXeEDEAhW-TYdx3o1WZ4TIjYqGIY,337
+ntro_cli-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+ntro_cli-0.1.0.dist-info/entry_points.txt,sha256=u6Q6GPMkr87NZjSc8GqeHFwa7XW3Yk0hREwqQWKyPbQ,43
+ntro_cli-0.1.0.dist-info/RECORD,,

ntro_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

ntro_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ntro = ntro_cli.main:app