metrik-cli 0.1.0__tar.gz

metrik_cli-0.1.0/.gitignore

@@ -0,0 +1,89 @@
+# Metrik — .gitignore
+#
+# NOTE: the previous version of this file contained `docs/*`, `.gitignore`, and `.claude`,
+# which excluded the entire documentation tree — i.e. every Phase 0/1 deliverable — from
+# version control. Replaced deliberately. docs/ is the project's primary output right now.
+
+# --- Build output that must never be committed ---
+# ADR 016: diagram sources live in docs/diagrams/*.mmd; rendered images are build output.
+docs/static/diagrams/
+# ADR 015: generated reference docs are committed on purpose (drift detection), so they
+# are NOT ignored here — see docs/reference/.
+
+# --- Python ---
+__pycache__/
+*.py[cod]
+*.so
+.Python
+build/
+dist/
+*.egg-info/
+.eggs/
+.venv/
+venv/
+env/
+
+# Tooling caches
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.hypothesis/
+.coverage
+.coverage.*
+htmlcov/
+coverage.xml
+.benchmarks/
+.tox/
+.nox/
+
+# uv (ADR 013) — uv.lock IS committed; the cache is not.
+.uv/
+
+# --- Node / web (ADR 009) ---
+node_modules/
+.next/
+out/
+.turbo/
+*.tsbuildinfo
+.pnpm-store/
+
+# --- Tauri (ADR 010) ---
+apps/desktop/src-tauri/target/
+apps/desktop/src-tauri/gen/
+
+# --- Docs site (ADR 015) ---
+docs/.docusaurus/
+docs/build/
+
+# --- Metrik runtime data ---
+# The artifact store and blob store (ADR 006). Content-addressed, machine-generated,
+# gigabytes. Never in git.
+.metrik/
+*.metrik-store/
+# Local config may hold API keys (ADR 018).
+metrik.local.toml
+.env
+.env.*
+!.env.example
+
+# Model weights and checkpoints — always too large, often license-encumbered (plan.md §5.7).
+*.safetensors
+*.gguf
+*.onnx
+*.pt
+*.pth
+*.bin
+# ...except the tiny-random fixtures, which are committed on purpose (ADR 017).
+!tests/fixtures/**
+
+# --- Editors and OS ---
+.vscode/
+!.vscode/extensions.json
+.idea/
+*.swp
+.DS_Store
+Thumbs.db
+desktop.ini
+
+# --- Local agent/tooling settings ---
+.claude/settings.local.json

metrik_cli-0.1.0/PKG-INFO

@@ -0,0 +1,58 @@
+Metadata-Version: 2.4
+Name: metrik-cli
+Version: 0.1.0
+Summary: Metrik command-line interface.
+Project-URL: Homepage, https://github.com/Asmodeus14/Metrik
+Project-URL: Repository, https://github.com/Asmodeus14/Metrik
+Project-URL: Issues, https://github.com/Asmodeus14/Metrik/issues
+Author: The Metrik Authors
+License-Expression: Apache-2.0
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.11
+Requires-Dist: metrik-bench==0.1.0
+Requires-Dist: metrik-core==0.1.0
+Requires-Dist: metrik-explorer==0.1.0
+Requires-Dist: metrik-sdk==0.1.0
+Requires-Dist: metrik-viz==0.1.0
+Requires-Dist: rich>=13.7
+Requires-Dist: typer>=0.12
+Description-Content-Type: text/markdown
+
+# metrik-cli
+
+The `metrik` command-line interface.
+
+```console
+$ metrik --version
+$ metrik store path            # which store am I using, and why
+$ metrik store ls              # what is in it
+$ metrik store show <id>       # one artifact: envelope + payload
+$ metrik store lineage <id>    # trace it back to what it was derived from
+$ metrik store verify          # rehash everything; non-zero exit if anything is wrong
+
+$ metrik runs ls               # what has been run here, newest first
+$ metrik runs ls --failed      # only the ones that did not succeed
+$ metrik runs show <id>        # what was asked, what happened, what came out
+
+$ metrik plugins               # which producers are installed and loadable
+```
+
+`<id>` accepts an abbreviated digest (`b3:f8fae13`), the way `git` accepts a short commit.
+
+A run is recorded **whether the work succeeded or raised**, so a command that produced no
+artifacts still leaves a trace — with the failure kind, the message, and the remediation that
+was printed at the time. A success can be re-derived from its artifacts; a failure cannot be
+re-derived from anything, which is why it is the case most worth recording.
+
+A run whose outputs have gaps in them is `partial`, not `succeeded`. That distinction survives
+to the exit status and to `runs ls`, so a script cannot mistake a result with holes for a
+complete one.
+
+The CLI is designed dual-mode ([`plan.md`](../../plan.md) §3.1): direct and in-process against
+the store today, `--remote` against a daemon from Phase 10. That split is why the CLI can ship
+without the API existing.
+
+See [ADR 012](../../docs/planning/adr/012-cli-framework.md) for the Typer + Rich decision.

metrik_cli-0.1.0/README.md

@@ -0,0 +1,35 @@
+# metrik-cli
+
+The `metrik` command-line interface.
+
+```console
+$ metrik --version
+$ metrik store path            # which store am I using, and why
+$ metrik store ls              # what is in it
+$ metrik store show <id>       # one artifact: envelope + payload
+$ metrik store lineage <id>    # trace it back to what it was derived from
+$ metrik store verify          # rehash everything; non-zero exit if anything is wrong
+
+$ metrik runs ls               # what has been run here, newest first
+$ metrik runs ls --failed      # only the ones that did not succeed
+$ metrik runs show <id>        # what was asked, what happened, what came out
+
+$ metrik plugins               # which producers are installed and loadable
+```
+
+`<id>` accepts an abbreviated digest (`b3:f8fae13`), the way `git` accepts a short commit.
+
+A run is recorded **whether the work succeeded or raised**, so a command that produced no
+artifacts still leaves a trace — with the failure kind, the message, and the remediation that
+was printed at the time. A success can be re-derived from its artifacts; a failure cannot be
+re-derived from anything, which is why it is the case most worth recording.
+
+A run whose outputs have gaps in them is `partial`, not `succeeded`. That distinction survives
+to the exit status and to `runs ls`, so a script cannot mistake a result with holes for a
+complete one.
+
+The CLI is designed dual-mode ([`plan.md`](../../plan.md) §3.1): direct and in-process against
+the store today, `--remote` against a daemon from Phase 10. That split is why the CLI can ship
+without the API existing.
+
+See [ADR 012](../../docs/planning/adr/012-cli-framework.md) for the Typer + Rich decision.

metrik_cli-0.1.0/pyproject.toml

@@ -0,0 +1,49 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "metrik-cli"
+version = "0.1.0"
+description = "Metrik command-line interface."
+readme = "README.md"
+requires-python = ">=3.11"
+license = "Apache-2.0"
+authors = [{ name = "The Metrik Authors" }]
+classifiers = [
+    "Development Status :: 2 - Pre-Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Science/Research",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+
+# Typer for type-hints-to-CLI, Rich for output quality (ADR 012). The CLI is a *surface*,
+# so it may depend on metrik-core directly; the SDK-dogfooding contract in .importlinter
+# constrains producers and consumers, not surfaces.
+dependencies = [
+    "metrik-core==0.1.0",
+    "metrik-sdk==0.1.0",
+    "metrik-explorer==0.1.0",
+    "metrik-viz==0.1.0",
+    "metrik-bench==0.1.0",
+    "typer>=0.12",
+    "rich>=13.7",
+]
+
+[project.scripts]
+metrik = "metrik.cli.main:main"
+
+[project.urls]
+Homepage = "https://github.com/Asmodeus14/Metrik"
+Repository = "https://github.com/Asmodeus14/Metrik"
+Issues = "https://github.com/Asmodeus14/Metrik/issues"
+
+[tool.uv.sources]
+metrik-core = { workspace = true }
+metrik-sdk = { workspace = true }
+metrik-explorer = { workspace = true }
+metrik-viz = { workspace = true }
+metrik-bench = { workspace = true }
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/metrik"]

metrik_cli-0.1.0/src/metrik/cli/__init__.py

@@ -0,0 +1,36 @@
+"""The ``metrik`` command-line interface.
+
+ADR 012: Typer for type-hints-to-CLI, Rich for output quality. ``plan.md`` §10 correction 1
+moves the CLI early -- it grows with each module from Phase 2 rather than arriving at Phase 9,
+so there is a usable surface (and therefore real feedback) while the design can still change
+cheaply.
+
+The CLI is designed dual-mode (``plan.md`` §3.1): direct and in-process against the store, or
+``--remote`` against a daemon. Only the direct mode exists today; the daemon arrives in
+Phase 10. The split is worth keeping visible now because it is what lets the CLI ship without
+the API existing.
+"""
+
+from __future__ import annotations
+
+
+def _distribution_version(name: str) -> str:
+    from importlib.metadata import PackageNotFoundError, version
+
+    try:
+        return version(name)
+    except PackageNotFoundError:  # pragma: no cover - only in an uninstalled source tree
+        return "0+unknown"
+
+
+#: Read from the installed distribution rather than hardcoded.
+#:
+#: Both existed for a while and drifted: a 0.1.0 build reported 0.0.1 from `metrik --version`,
+#: found by installing the actual wheel rather than by any test. A version string is exactly
+#: the kind of duplicate that stays wrong quietly, because nothing imports it in anger.
+#:
+#: The fallback covers a source checkout with nothing installed, where there is no metadata to
+#: read and no released version to name.
+__version__ = _distribution_version("metrik-cli")
+
+__all__ = ["__version__"]

metrik_cli-0.1.0/src/metrik/cli/commands/__init__.py

@@ -0,0 +1,7 @@
+"""Command groups.
+
+One module per group. Each stays a thin shell over the library: parse, call, render. Anything
+worth testing belongs below the CLI, where it can be tested without a subprocess.
+"""
+
+from __future__ import annotations

metrik_cli-0.1.0/src/metrik/cli/commands/bench.py

@@ -0,0 +1,119 @@
+"""``metrik bench`` -- run a benchmark, or explain why it will not.
+
+ADR 019. HumanEval and MBPP ask a model to write code and then execute it, so this command
+establishes whether the machine can contain that **before** anything is generated. A refusal
+after an hour of decoding is a refusal that arrives too late to be a safety feature.
+"""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+from rich.table import Table
+from rich.text import Text
+
+from metrik.bench import TASKS, detect_runtimes, require_runtime, resolve_task
+from metrik.cli.console import out
+from metrik.core.errors import UnsupportedError
+
+__all__ = ["register"]
+
+_STYLE = {"ready": "measured", "not_running": "warn", "not_installed": "muted"}
+
+
+def register(app: typer.Typer) -> None:
+    @app.command("bench")
+    def bench(
+        model: Annotated[
+            str | None, typer.Argument(help="Model to evaluate. Omit with --check.")
+        ] = None,
+        task: Annotated[str | None, typer.Option("--task", help="Which benchmark to run.")] = None,
+        check: Annotated[
+            bool,
+            typer.Option("--check", help="Report what isolation is available and stop."),
+        ] = False,
+    ) -> None:
+        """Evaluate a model under container isolation -- or refuse, and say why.
+
+        There is no unsandboxed mode. A task that executes model-generated code runs in a
+        container or does not run (ADR 019), and no flag changes that.
+        """
+        if check:
+            _report_capability()
+            return
+
+        if model is None or task is None:
+            raise UnsupportedError(
+                "a model and a --task are required",
+                remediation="Run `metrik bench --check` to see the tasks and what can run here.",
+            )
+
+        spec = resolve_task(task)
+        if spec.executes_code:
+            # Before generation, deliberately. This raises when nothing can contain the run,
+            # and there is no branch that continues past it.
+            runtime = require_runtime(task_id=spec.id)
+            out.print(
+                f"[measured]{runtime.name} {runtime.version} ready[/measured] "
+                f"[muted]- {spec.id} will run under container isolation[/muted]"
+            )
+
+        raise UnsupportedError(
+            f"the {spec.id} runner is not implemented yet",
+            remediation=(
+                "Phase 5 ships the sandbox gate before the runner it gates. `metrik bench "
+                "--check` reports what isolation this machine has."
+            ),
+        )
+
+
+def _report_capability() -> None:
+    """What was probed, what each said, and what that permits."""
+    runtimes = detect_runtimes()
+
+    table = Table(box=None, pad_edge=False)
+    table.add_column("runtime", no_wrap=True)
+    table.add_column("state", no_wrap=True)
+    table.add_column("detail", overflow="fold")
+    for runtime in runtimes:
+        table.add_row(
+            Text(runtime.name),
+            Text(runtime.availability.value, style=_STYLE.get(runtime.availability.value, "")),
+            Text(runtime.version or runtime.detail),
+        )
+    out.print(table)
+    out.print()
+
+    usable = next((r for r in runtimes if r.ready), None)
+    tasks = Table(box=None, pad_edge=False)
+    tasks.add_column("task", style="type", no_wrap=True)
+    tasks.add_column("executes code", no_wrap=True)
+    tasks.add_column("can run here", no_wrap=True)
+    tasks.add_column("what it is", overflow="fold")
+    for spec in sorted(TASKS.values(), key=lambda s: s.id):
+        # The distinction the whole command exists to make visible: a task that executes code
+        # needs a runtime, and one that does not never did. Requiring a container for MMLU
+        # would push people to disable the check they need for HumanEval.
+        runnable = usable is not None or not spec.executes_code
+        tasks.add_row(
+            Text(spec.id),
+            Text("yes" if spec.executes_code else "no", style="warn" if spec.executes_code else ""),
+            Text("yes" if runnable else "no", style="measured" if runnable else "err"),
+            Text(spec.summary),
+        )
+    out.print(tasks)
+    out.print()
+
+    if usable is not None:
+        out.print(f"[measured]container isolation available via {usable.name}[/measured]")
+        return
+
+    out.print("[warn]no container runtime is available[/warn]")
+    for runtime in runtimes:
+        if runtime.remediation:
+            out.print(f"  [muted]{runtime.remediation}[/muted]")
+    out.print(
+        "[muted]Tasks that do not execute code still run. There is no unsandboxed mode "
+        "(ADR 019).[/muted]"
+    )