newmeasure-cli 0.1.0__py3-none-any.whl

cli/api_client.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+import httpx
+import typer
+
+from cli.config import get
+
+
+def client() -> httpx.Client:
+    api_url = get("api_url")
+    token = get("token")
+    if not token:
+        typer.echo("Not logged in. Run: newm login")
+        raise typer.Exit(1)
+    return httpx.Client(
+        base_url=api_url,
+        headers={"Authorization": f"Bearer {token}"},
+        timeout=300,
+    )

cli/commands/admin.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+from rich.console import Console
+
+from cli import config
+
+console = Console()
+
+admin_app = typer.Typer(help="Admin commands")
+
+
+@admin_app.command("create-token")
+def create_token(
+    customer: str = typer.Option(..., "--customer", help="Customer name"),
+    agent_url: str = typer.Option(..., "--agent-url", help="Customer's agent URL"),
+    agent_protocol: str = typer.Option(..., "--agent-protocol", help="Protocol (eve, mastra)"),
+    agent_auth_user: Optional[str] = typer.Option(None, "--agent-auth-user"),
+    agent_auth_pass: Optional[str] = typer.Option(None, "--agent-auth-pass"),
+    mcp_token: Optional[str] = typer.Option(None, "--mcp-token", help="Comma-separated MCP tokens for routing"),
+):
+    """Create a new customer API token (requires admin auth)."""
+    import httpx
+
+    cfg = config.load()
+    admin_token = typer.prompt("Admin token", hide_input=True)
+
+    body = {
+        "customer_name": customer,
+        "agent_url": agent_url,
+        "agent_protocol": agent_protocol,
+        "agent_auth_user": agent_auth_user or "",
+        "agent_auth_pass": agent_auth_pass or "",
+        "mcp_token": mcp_token or "",
+    }
+
+    c = httpx.Client(
+        base_url=cfg["api_url"],
+        headers={"Authorization": f"Bearer {admin_token}"},
+        timeout=30,
+    )
+    resp = c.post("/api/v1/admin/tokens", json=body)
+    resp.raise_for_status()
+    data = resp.json()
+
+    console.print(f"Customer: [bold]{data['customer_name']}[/bold]")
+    console.print(f"Customer ID: {data['customer_id']}")
+    console.print(f"Token: [bold]{data['token']}[/bold]")
+    console.print("\nGive this token to the customer. It cannot be retrieved again.")

cli/commands/artifacts.py

@@ -0,0 +1,48 @@
+import hashlib
+import json
+from pathlib import Path, PurePosixPath
+
+import httpx
+import typer
+from rich.console import Console
+
+from cli.api_client import client
+
+
+def artifacts(run_id, trial_id, output=None):
+    base = f"/api/v1/runs/{run_id}/trials/{trial_id}/artifacts"
+    with client() as api:
+        response = api.get(base)
+        response.raise_for_status()
+        manifest = response.json()
+        Console().print(
+            f"Status: {manifest.get('status')} | Stage: {manifest.get('stage')} | Cleanup: {manifest.get('cleanup', {}).get('status')}"
+        )
+        if output:
+            output = Path(output).resolve()
+            output.mkdir(parents=True, exist_ok=True)
+            (output / "manifest.json").write_text(json.dumps(manifest, indent=2))
+        for item in manifest.get("artifacts", []):
+            name = item["path"]
+            Console().print(f"{name} ({item['size_bytes']} bytes)")
+            if not output:
+                continue
+            relative = PurePosixPath(name)
+            destination = (output / name).resolve()
+            if (
+                relative.is_absolute()
+                or ".." in relative.parts
+                or not destination.is_relative_to(output)
+            ):
+                raise typer.BadParameter("Unsafe artifact path")
+            link = api.get(base + "/download", params={"path": name})
+            link.raise_for_status()
+            # Separate client: never send the NewMeasure bearer token to S3.
+            data = httpx.get(link.json()["url"], timeout=120).raise_for_status().content
+            if (
+                len(data) != item["size_bytes"]
+                or hashlib.sha256(data).hexdigest() != item["sha256"]
+            ):
+                raise typer.BadParameter(f"Artifact checksum mismatch: {name}")
+            destination.parent.mkdir(parents=True, exist_ok=True)
+            destination.write_bytes(data)

cli/commands/login.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+import typer
+from rich.prompt import Prompt
+
+from cli import config
+
+
+def login():
+    """Store API token."""
+    cfg = config.load()
+
+    cfg["token"] = Prompt.ask("API Token", password=True)
+
+    config.save(cfg)
+    typer.echo(f"Saved to {config.CONFIG_PATH}")

cli/commands/result.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from cli.api_client import client
+
+console = Console()
+
+
+def result(run_id: str):
+    """Get detailed results for a run."""
+    c = client()
+    resp = c.get(f"/api/v1/runs/{run_id}")
+    resp.raise_for_status()
+    data = resp.json()
+
+    console.print(f"\nRun: [bold]{data['id']}[/bold]")
+    console.print(f"Task: {data['task_id']}")
+    console.print(f"Status: {data['status']}")
+    console.print(f"Agent: {data.get('agent_url', '-')}")
+
+    trials = data.get("trials", [])
+    if not trials:
+        console.print("No trial results yet.")
+        return
+
+    table = Table(title="Trials")
+    table.add_column("Trial")
+    table.add_column("Status")
+    table.add_column("Reward")
+    table.add_column("Duration")
+    table.add_column("Error")
+
+    for t in trials:
+        reward = f"{t['reward']:.2f}" if t.get("reward") is not None else "-"
+        dur = f"{t['duration_sec']:.1f}s" if t.get("duration_sec") else "-"
+        err = (t.get("error") or "")[:50]
+        table.add_row(t["id"], t["status"], reward, dur, err)
+
+    console.print(table)
+
+    avg = data.get("avg_reward")
+    if avg is not None:
+        console.print(f"\nAvg reward: [bold]{avg:.2f}[/bold]")

cli/commands/run.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+import time
+from pathlib import Path
+from urllib.parse import urlparse
+
+import typer
+from dotenv import dotenv_values
+from rich.console import Console
+
+from cli.api_client import client
+from cli.commands.upload import upload
+
+console = Console()
+
+
+def run(
+    target: str,
+    n_trials: int = 1,
+    credentials_file: Path | None = None,
+    wait: bool = True,
+):
+    """Run an eval. TARGET is a task ID (t_...) or a local task directory path."""
+    task_id = target
+    target_path = Path(target)
+    if target_path.is_dir():
+        upload(target_path)
+        import tomllib
+
+        toml_text = (target_path / "task.toml").read_text()
+        task_id = tomllib.loads(toml_text).get("task_id")
+        if not task_id:
+            typer.echo("Failed to get task_id after upload")
+            raise typer.Exit(1)
+
+    c = client()
+    body = {
+        "task_id": task_id,
+        "n_trials": n_trials,
+    }
+
+    task_response = c.get(f"/api/v1/tasks/{task_id}")
+    task_response.raise_for_status()
+    task = task_response.json()
+    if task.get("runner") == "browser":
+        url = urlparse(str(c.base_url))
+        if url.scheme != "https" and url.hostname not in {
+            "127.0.0.1",
+            "localhost",
+            "::1",
+        }:
+            raise typer.BadParameter(
+                "Application credentials require an HTTPS NewMeasure API URL"
+            )
+        if credentials_file is None or not credentials_file.is_file():
+            raise typer.BadParameter(
+                "Browser runs require --credentials-file pointing to a local environment file"
+            )
+        values = dotenv_values(credentials_file, interpolate=False)
+        fields = task.get("credential_fields", [])
+        if any(not values.get(field) for field in fields):
+            raise typer.BadParameter(
+                f"Credential file must define: {', '.join(fields)}"
+            )
+        body["credentials"] = {field: values[field] for field in fields}
+    elif credentials_file:
+        raise typer.BadParameter(
+            "This task does not accept per-run browser credentials"
+        )
+
+    resp = c.post("/api/v1/runs", json=body)
+    body.pop("credentials", None)
+    resp.raise_for_status()
+    run_id = resp.json()["run_id"]
+    console.print(f"Run started: [bold]{run_id}[/bold]")
+    if not wait:
+        return
+
+    console.print("Waiting for results...")
+    while True:
+        time.sleep(3)
+        resp = c.get(f"/api/v1/runs/{run_id}")
+        resp.raise_for_status()
+        data = resp.json()
+        status = data["status"]
+
+        if status == "completed":
+            n = len(data.get("trials", []))
+            avg = data.get("avg_reward")
+            if avg is not None:
+                console.print(
+                    f"Done. {n} trial{'s' if n != 1 else ''}, avg reward = {avg:.2f}"
+                )
+            else:
+                console.print(f"Done. {n} trial{'s' if n != 1 else ''}.")
+            break
+        elif status == "failed":
+            console.print("[red]Run failed.[/red]")
+            raise typer.Exit(1)

cli/commands/runs.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from rich.console import Console
+from rich.table import Table
+
+from cli.api_client import client
+
+console = Console()
+
+
+def list_runs(task_id: str | None = None):
+    """List runs, optionally filtered by task ID."""
+    c = client()
+    url = "/api/v1/runs"
+    if task_id:
+        url += f"?task_id={task_id}"
+    resp = c.get(url)
+    resp.raise_for_status()
+    runs = resp.json()
+
+    if not runs:
+        console.print("No runs found.")
+        return
+
+    table = Table()
+    table.add_column("ID")
+    table.add_column("Task")
+    table.add_column("Status")
+    table.add_column("Trials")
+    table.add_column("Avg Reward")
+    table.add_column("Created")
+
+    for r in runs:
+        avg = f"{r['avg_reward']:.2f}" if r.get("avg_reward") is not None else "-"
+        table.add_row(
+            r["id"],
+            r["task_id"],
+            r["status"],
+            str(r["n_trials"]),
+            avg,
+            str(r.get("created_at", ""))[:19],
+        )
+
+    console.print(table)

cli/commands/tasks.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from rich.console import Console
+from rich.table import Table
+
+from cli.api_client import client
+
+console = Console()
+
+
+def list_tasks():
+    """List uploaded tasks."""
+    c = client()
+    resp = c.get("/api/v1/tasks")
+    resp.raise_for_status()
+    tasks = resp.json()
+
+    if not tasks:
+        console.print("No tasks found.")
+        return
+
+    table = Table()
+    table.add_column("ID")
+    table.add_column("Name")
+    table.add_column("Services")
+    table.add_column("Created")
+
+    for t in tasks:
+        table.add_row(
+            t["id"],
+            t["name"],
+            ", ".join(t.get("services", [])),
+            str(t.get("created_at", ""))[:19],
+        )
+
+    console.print(table)

cli/commands/upload.py

@@ -0,0 +1,140 @@
+from __future__ import annotations
+
+import io
+import tomllib
+import zipfile
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+from cli.api_client import client
+
+console = Console()
+
+REQUIRED_FILES = ["task.toml", "instruction.md", "seed.json"]
+
+
+def upload(task_dir: Path):
+    """Validate and upload a task directory."""
+    if not task_dir.is_dir():
+        typer.echo(f"Not a directory: {task_dir}")
+        raise typer.Exit(1)
+
+    task_file = task_dir / "task.toml"
+    if task_file.exists():
+        config = tomllib.loads(task_file.read_text())
+        if config.get("metadata", {}).get("newmeasure", {}).get("runner") == "browser":
+            return upload_browser(task_dir, config)
+
+    for name in REQUIRED_FILES:
+        if not (task_dir / name).exists():
+            typer.echo(f"Missing required file: {name}")
+            raise typer.Exit(1)
+
+    test_sh = task_dir / "tests" / "test.sh"
+    if not test_sh.exists():
+        typer.echo("Missing required file: tests/test.sh")
+        raise typer.Exit(1)
+
+    console.print("Validating task structure... [green]✓[/green]")
+
+    task_toml_text = (task_dir / "task.toml").read_text()
+    task_id = None
+    try:
+        config = tomllib.loads(task_toml_text)
+        task_id = config.get("task_id")
+    except Exception:
+        pass
+
+    c = client()
+
+    files = {
+        "task_toml": ("task.toml", open(task_dir / "task.toml", "rb")),
+        "instruction_md": ("instruction.md", open(task_dir / "instruction.md", "rb")),
+        "seed_json": ("seed.json", open(task_dir / "seed.json", "rb")),
+        "test_sh": ("test.sh", open(test_sh, "rb")),
+    }
+
+    try:
+        if task_id:
+            resp = c.put(f"/api/v1/tasks/{task_id}", files=files)
+        else:
+            resp = c.post("/api/v1/tasks", files=files)
+
+        resp.raise_for_status()
+        data = resp.json()
+        tid = data.get("task_id", task_id)
+
+        if not task_id and tid:
+            _write_task_id(task_dir / "task.toml", tid)
+
+        action = "updated" if task_id else "created"
+        console.print(f"Task {action}: [bold]{tid}[/bold]")
+    finally:
+        for _, f in files.values():
+            f.close()
+
+
+def _write_task_id(toml_path: Path, task_id: str) -> None:
+    """Write task_id back into task.toml."""
+    text = toml_path.read_text()
+    if "task_id" in text:
+        lines = text.splitlines(keepends=True)
+        new_lines = []
+        for line in lines:
+            if line.strip().startswith("task_id"):
+                new_lines.append(f'task_id = "{task_id}"\n')
+            else:
+                new_lines.append(line)
+        toml_path.write_text("".join(new_lines))
+    else:
+        lines = text.splitlines(keepends=True)
+        inserted = False
+        for i, line in enumerate(lines):
+            key = line.strip().split("=")[0].strip() if "=" in line else ""
+            if key in ("version", "schema_version"):
+                lines.insert(i + 1, f'task_id = "{task_id}"\n')
+                inserted = True
+                break
+        if not inserted:
+            lines.insert(0, f'task_id = "{task_id}"\n')
+        toml_path.write_text("".join(lines))
+
+
+def upload_browser(task_dir: Path, config: dict):
+    names = [
+        "task.toml",
+        "instruction.md",
+        "scenario.yaml",
+        "product.md",
+        "environment/Dockerfile",
+    ]
+    if not (task_dir / "instruction.md").is_file():
+        raise typer.BadParameter("instruction.md is required")
+    data = io.BytesIO()
+    with zipfile.ZipFile(data, "w", zipfile.ZIP_DEFLATED) as archive:
+        for name in names:
+            path = task_dir / name
+            if path.is_file():
+                if path.is_symlink():
+                    raise typer.BadParameter("Task files must not be symlinks")
+                archive.writestr(name, path.read_bytes())
+        if not (task_dir / "product.md").exists():
+            # Shared task context is packaged by the CLI, never resolved on the server.
+            shared = task_dir.parent.parent / "shared" / "product.md"
+            if shared.is_file() and not shared.is_symlink():
+                archive.writestr("product.md", shared.read_bytes())
+    task_id = config.get("task_id")
+    with client() as c:
+        url = f"/api/v1/task-bundles/{task_id}" if task_id else "/api/v1/task-bundles"
+        response = c.request(
+            "PUT" if task_id else "POST",
+            url,
+            files={"bundle": ("task.zip", data.getvalue(), "application/zip")},
+        )
+        response.raise_for_status()
+        result = response.json()
+    if not task_id:
+        _write_task_id(task_dir / "task.toml", result["task_id"])
+    console.print(f"Task uploaded: [bold]{result['task_id']}[/bold]")

cli/config.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+CONFIG_DIR = Path.home() / ".newm"
+CONFIG_PATH = CONFIG_DIR / "config.json"
+
+DEFAULTS = {
+    "api_url": "https://api.newmeasure.cc",
+    "token": "",
+}
+
+
+def load() -> dict:
+    if CONFIG_PATH.exists():
+        data = json.loads(CONFIG_PATH.read_text())
+        return {**DEFAULTS, **data}
+    return dict(DEFAULTS)
+
+
+def save(config: dict) -> None:
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    CONFIG_PATH.write_text(json.dumps(config, indent=2) + "\n")
+    CONFIG_PATH.chmod(0o600)
+
+
+def get(key: str) -> str:
+    return load().get(key, "")

cli/main.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+import subprocess
+import sys
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+from cli.commands.admin import admin_app
+from cli.commands.artifacts import artifacts as artifacts_cmd
+from cli.commands.login import login as login_cmd
+from cli.commands.result import result as result_cmd
+from cli.commands.run import run as run_cmd
+from cli.commands.runs import list_runs
+from cli.commands.tasks import list_tasks
+from cli.commands.upload import upload as upload_cmd
+
+app = typer.Typer(
+    name="newm",
+    help="NewMeasure eval CLI",
+    no_args_is_help=True,
+)
+app.add_typer(admin_app, name="admin")
+
+
+@app.command()
+def login():
+    """Store API token."""
+    login_cmd()
+
+
+@app.command()
+def upload(task_dir: Path = typer.Argument(..., help="Path to task directory")):
+    """Validate and upload a task."""
+    upload_cmd(task_dir)
+
+
+@app.command()
+def run(
+    target: str = typer.Argument(..., help="Task ID (t_...) or local task directory"),
+    n_trials: int = typer.Option(1, "--n-trials", help="Number of trials"),
+    credentials_file: Optional[Path] = typer.Option(
+        None,
+        "--credentials-file",
+        help="Per-run application credentials (not uploaded as a file)",
+    ),
+    wait: bool = typer.Option(
+        True, "--wait/--no-wait", help="Wait for results after submission"
+    ),
+):
+    """Run an eval against your agent."""
+    run_cmd(
+        target=target, n_trials=n_trials, credentials_file=credentials_file, wait=wait
+    )
+
+
+@app.command()
+def artifacts(
+    run_id: str,
+    trial_id: str,
+    output: Optional[Path] = typer.Option(
+        None, "--output", help="Download artifacts to this directory"
+    ),
+):
+    """List or download a trial's stored artifacts."""
+    artifacts_cmd(run_id, trial_id, output)
+
+
+@app.command()
+def tasks():
+    """List uploaded tasks."""
+    list_tasks()
+
+
+@app.command()
+def runs(task_id: Optional[str] = typer.Argument(None, help="Filter by task ID")):
+    """List runs."""
+    list_runs(task_id)
+
+
+@app.command()
+def result(run_id: str = typer.Argument(..., help="Run ID")):
+    """Get detailed run results."""
+    result_cmd(run_id)
+
+
+@app.command(
+    context_settings={"allow_extra_args": True, "ignore_unknown_options": True},
+)
+def harbor(ctx: typer.Context):
+    """Passthrough to Harbor CLI (power users)."""
+    cmd = ["harbor", *ctx.args]
+    sys.exit(subprocess.call(cmd))
+
+
+if __name__ == "__main__":
+    app()

newmeasure_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,105 @@
+Metadata-Version: 2.5
+Name: newmeasure-cli
+Version: 0.1.0
+Summary: NewMeasure eval CLI
+Requires-Python: >=3.11
+Requires-Dist: httpx>=0.28
+Requires-Dist: python-dotenv>=1.0
+Requires-Dist: rich>=13.0
+Requires-Dist: typer>=0.16
+Description-Content-Type: text/markdown
+
+# NewMeasure CLI
+
+Upload evaluation tasks, start cloud runs, check results, and download artifacts
+from NewMeasure. Requires Python 3.11 or later and a NewMeasure customer API key.
+
+## Install
+
+```sh
+uv tool install newmeasure-cli
+```
+
+Alternatively, use `pipx install newmeasure-cli`, or install with
+`pip install newmeasure-cli` inside a virtual environment. The executable is `newm`.
+
+## Sign in
+
+```sh
+newm login
+```
+
+Enter your customer API key when prompted. The default API is
+`https://api.newmeasure.cc`. Local configuration is stored in
+`~/.newm/config.json` with owner-only permissions.
+
+## Run a task
+
+```sh
+# Upload and run a local task directory
+newm run ./my-task --no-wait
+
+# Or run an already uploaded task
+newm run t_abc123 --no-wait
+```
+
+`--no-wait` returns the run ID immediately; execution continues in the cloud.
+Without it, the CLI waits for completion. Check status with:
+
+```sh
+newm result <run-id>
+```
+
+For browser tasks, provide application credentials in a local environment file
+using the field names declared by the task, for example:
+
+```dotenv
+username=YOUR_APPLICATION_EMAIL
+password=YOUR_APPLICATION_PASSWORD
+```
+
+Keep that file out of version control. Submit it for the run:
+
+```sh
+newm run ./my-task --credentials-file credentials.env --no-wait
+```
+
+The CLI sends the declared credential values over HTTPS for that run. Cloud
+provider and model credentials are managed by the NewMeasure service.
+
+## Download browser artifacts
+
+Use the trial ID printed by `newm result`:
+
+```sh
+newm artifacts <run-id> <trial-id> --output ./artifacts/<trial-id>
+```
+
+Downloads include the available exports, evidence, and manifest. The CLI verifies
+file sizes and SHA-256 checksums. Browser smoke completion is an operational
+result, not a content-quality score. Inspect the manifest for cleanup status
+before repeating a failed task.
+
+## Other commands
+
+```sh
+newm upload ./my-task
+newm tasks
+newm runs
+newm runs <task-id>
+newm --help
+```
+
+Task IDs persist across uploads; each execution gets a fresh trial ID. Browser
+task bundles include the instruction, task settings, and optional scenario and
+product context. HTTP-agent tasks also require their seed and verifier files.
+
+## Development
+
+From the CLI source directory:
+
+```sh
+uv sync
+uv run newm --help
+uv run pytest
+```

newmeasure_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cli/api_client.py,sha256=aNSBCu915MLBn5g0LGq8usKh3kwPZ2uerGzm9DMAnbA,407
+cli/config.py,sha256=GJHPB2ySO5p3b0PiwTMypQqthsBDxRnez8mcmPZ3tK4,627
+cli/main.py,sha256=wgxIvMOU-s673VUuDkpyvHWmZwV0VByzopHHZ54S8Js,2456
+cli/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cli/commands/admin.py,sha256=XaCRw_8OGQYSH6d6lxSTcJWn3EHnWnAxJ2RpkQaLOew,1740
+cli/commands/artifacts.py,sha256=UBwYmkpX6dk3Tp25SvuObeRRh-iLq8ZzVYNOryA6TC4,1918
+cli/commands/login.py,sha256=D846YkdqNHSakFaV0hsJBjBuqMnAJCatPKrPjg0my38,300
+cli/commands/result.py,sha256=vWO6gbdRO3ubxWNFT4hybMU3HdFKj8OSTjaqwTrO6_s,1289
+cli/commands/run.py,sha256=zWq13PTsKtiSjff7XdDCx0H589rQQ5QjJt9gXpwhYXY,3115
+cli/commands/runs.py,sha256=CYR1m84liAuqL3sBYN5zi_UfarwreLcSrp15UMJkSpw,1029
+cli/commands/tasks.py,sha256=lL9zdDmaVJHFzJdV9Kowo96LlcT7ROwUBPebspR-6IQ,742
+cli/commands/upload.py,sha256=v9J6ge7iz6cbnLGjBU8CkvyXv9w9nvSLDUIUqa09Wt4,4730
+newmeasure_cli-0.1.0.dist-info/METADATA,sha256=jQwvwbaI5G-k8887SV7Pw9iiQtSIervCUDU8Ro5DRe0,2561
+newmeasure_cli-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+newmeasure_cli-0.1.0.dist-info/entry_points.txt,sha256=9cErJMpXIUirw7EG3DWPYXqbeUfOK1eEIA_2HTyM-Tw,38
+newmeasure_cli-0.1.0.dist-info/RECORD,,

newmeasure_cli-0.1.0.dist-info/WHEEL

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

newmeasure_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+newm = cli.main:app