benchkit-cli 0.1.0__tar.gz → 0.1.1__tar.gz

{benchkit_cli-0.1.0/src/benchkit_cli.egg-info → benchkit_cli-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: benchkit-cli
-Version: 0.1.0
+Version: 0.1.1
 Summary: Benchmark your local LLMs with real eval suites
 License-Expression: Apache-2.0
 Requires-Python: >=3.11
@@ -69,8 +69,10 @@ cp .env.example .env
 uv run benchkit
 ```
 
-Set your server in a `.env` in the directory you run `benchkit` from (parent
-directories are not searched), or enter it on the Connect screen:
+Set your server in `~/.config/benchkit/.env` to use it from any folder, in a
+`.env` in the directory you run `benchkit` from (parent directories are not
+searched), or on the Connect screen, where "Save as default" writes the user
+config for you:
 
 ```env
 BENCHKIT_PROVIDER=openai
@@ -85,6 +87,8 @@ BENCHKIT_PROVIDER=ollama
 OLLAMA_HOST=http://localhost:11434
 ```
 
+`benchkit config` shows every setting and where it came from.
+
 No inference server available? Explore the complete UI offline:
 
 ```bash

{benchkit_cli-0.1.0 → benchkit_cli-0.1.1}/README.md

@@ -51,8 +51,10 @@ cp .env.example .env
 uv run benchkit
 ```
 
-Set your server in a `.env` in the directory you run `benchkit` from (parent
-directories are not searched), or enter it on the Connect screen:
+Set your server in `~/.config/benchkit/.env` to use it from any folder, in a
+`.env` in the directory you run `benchkit` from (parent directories are not
+searched), or on the Connect screen, where "Save as default" writes the user
+config for you:
 
 ```env
 BENCHKIT_PROVIDER=openai
@@ -67,6 +69,8 @@ BENCHKIT_PROVIDER=ollama
 OLLAMA_HOST=http://localhost:11434
 ```
 
+`benchkit config` shows every setting and where it came from.
+
 No inference server available? Explore the complete UI offline:
 
 ```bash

{benchkit_cli-0.1.0 → benchkit_cli-0.1.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "benchkit-cli"
-version = "0.1.0"
+version = "0.1.1"
 description = "Benchmark your local LLMs with real eval suites"
 readme = "README.md"
 requires-python = ">=3.11"

{benchkit_cli-0.1.0 → benchkit_cli-0.1.1}/src/benchkit/benchmarks/evalplus.py

@@ -6,6 +6,8 @@ import contextlib
 import multiprocessing
 import os
 import platform
+import shutil
+import tempfile
 import textwrap
 from functools import cache, lru_cache
 from pathlib import Path
@@ -14,6 +16,7 @@ from typing import Any
 from benchkit.benchmarks.base import Task
 from benchkit.benchmarks.downloads import Dataset
 from benchkit.benchmarks.utils import strip_think_tags
+from benchkit.executor import sandbox_env
 
 HUMANEVAL_SYSTEM = (
     "Complete the following Python function. "
@@ -43,10 +46,29 @@ def _fork_multiprocessing():
 
     EvalPlus's ``evalplus.eval`` does ``from multiprocessing import Array, Value``
     so those names are bound on that module and must be patched there as well.
+
+    The forked child runs model-written code, so it swaps its inherited
+    environment for a minimal one before running: API keys stay with the
+    parent. ``EVALPLUS_*`` is kept because the child reads its memory limit.
     """
     import evalplus.eval as _ev
 
     fork_ctx = multiprocessing.get_context("fork")
+
+    class _ScrubbedProcess(fork_ctx.Process):
+        def run(self) -> None:
+            # EvalPlus's reliability guard disables shutil.rmtree in the child.
+            rmtree = shutil.rmtree
+            home = tempfile.mkdtemp(prefix="benchkit-evalplus-")
+            env = sandbox_env(home, keep_prefixes=("EVALPLUS_",))
+            os.environ.clear()
+            os.environ.update(env)
+            tempfile.tempdir = None
+            try:
+                super().run()
+            finally:
+                rmtree(home, ignore_errors=True)
+
     mp_originals = (
         multiprocessing.Process,
         multiprocessing.Value,
@@ -54,7 +76,7 @@ def _fork_multiprocessing():
     )
     ev_originals = (_ev.Value, _ev.Array)
     try:
-        multiprocessing.Process = fork_ctx.Process
+        multiprocessing.Process = _ScrubbedProcess
         multiprocessing.Value = fork_ctx.Value
         multiprocessing.Array = fork_ctx.Array
         _ev.Value = fork_ctx.Value

{benchkit_cli-0.1.0 → benchkit_cli-0.1.1}/src/benchkit/cli.py

@@ -9,13 +9,13 @@ from __future__ import annotations
 import argparse
 import sys
 
-from dotenv import load_dotenv
 from rich import box
 from rich.console import Console
+from rich.markup import escape
 from rich.table import Table
 from rich.text import Text
 
-from benchkit import catalog
+from benchkit import catalog, config
 from benchkit.benchmarks import DESCRIPTIONS, REGISTRY
 from benchkit.client import InferenceClient
 from benchkit.engine import (
@@ -60,11 +60,11 @@ def _parse_args(argv: list[str]) -> argparse.Namespace:
     parser.add_argument(
         "command",
         nargs="?",
-        choices=("perf", "history", "render-check", "datasets"),
+        choices=("perf", "history", "render-check", "datasets", "config"),
         help=(
             "Run a performance profile, browse historical results, check "
-            "that headless rendering works on this machine, or list and "
-            "install benchmark datasets"
+            "that headless rendering works on this machine, list and "
+            "install benchmark datasets, or show the effective configuration"
         ),
     )
     parser.add_argument(
@@ -73,7 +73,8 @@ def _parse_args(argv: list[str]) -> argparse.Namespace:
         metavar="MODEL",
         help=(
             "Model name for `benchkit perf MODEL`; `install` for "
-            "`benchkit datasets install [BENCHMARK ...]`"
+            "`benchkit datasets install [BENCHMARK ...]`; `path` for "
+            "`benchkit config path`"
         ),
     )
     parser.add_argument(
@@ -83,6 +84,15 @@ def _parse_args(argv: list[str]) -> argparse.Namespace:
         help="Datasets: benchmarks to install (default: every missing one)",
     )
     parser.add_argument("--host", help="Inference host, overrides BENCHKIT_HOST")
+    parser.add_argument(
+        "--env-file",
+        metavar="PATH",
+        help=(
+            "Read settings from PATH instead of ./.env (also BENCHKIT_ENV_FILE). "
+            "Precedence: flags > environment > --env-file or ./.env > "
+            "~/.config/benchkit/.env ($XDG_CONFIG_HOME) > defaults"
+        ),
+    )
     parser.add_argument(
         "--demo",
         action="store_true",
@@ -956,11 +966,40 @@ def _perf(args: argparse.Namespace) -> None:
     )
 
 
+def _config(args: argparse.Namespace) -> None:
+    if args.perf_model == "path":
+        for entry in config.loaded().files:
+            if entry.skipped:
+                state = f"[dim]{entry.skipped}[/dim]"
+            elif entry.exists:
+                state = "[green]found[/green]"
+            else:
+                state = "[dim]missing[/dim]"
+            console.print(f"{entry.role:<18} {escape(str(entry.path))}  {state}")
+        return
+    if args.perf_model is not None:
+        console.print(
+            f"[red]Unknown config action {escape(repr(args.perf_model))}.[/red]"
+        )
+        sys.exit(1)
+
+    table = Table(box=box.SIMPLE_HEAD, header_style="bold")
+    table.add_column("Setting")
+    table.add_column("Value")
+    table.add_column("Origin", style="dim")
+    for key, value, origin in config.resolve({"BENCHKIT_HOST": args.host}):
+        shown = Text(value) if value else Text("-", style="dim")
+        table.add_row(key, shown, Text(origin))
+    console.print(table)
+
+
 def main(argv: list[str] | None = None) -> None:
-    # Only the working directory's .env: walking up to parent directories would
-    # let a file in a shared parent such as /tmp redirect the host and API key.
-    load_dotenv(".env")
     args = _parse_args(sys.argv[1:] if argv is None else argv)
+    try:
+        config.load(args.env_file)
+    except config.ConfigError as exc:
+        console.print(f"[red]{exc}[/red]")
+        sys.exit(2)
 
     if args.list:
         _list_benchmarks()
@@ -974,6 +1013,10 @@ def main(argv: list[str] | None = None) -> None:
         _datasets(args)
         return
 
+    if args.command == "config":
+        _config(args)
+        return
+
     if args.command == "perf":
         _perf(args)
         return

benchkit_cli-0.1.1/src/benchkit/config.py

@@ -0,0 +1,251 @@
+"""Layered configuration: which settings apply, and where each one came from.
+
+Precedence, highest first: CLI flags, real environment variables,
+``--env-file PATH`` (or ``BENCHKIT_ENV_FILE``), ``./.env`` in the working
+directory, the user config ``$XDG_CONFIG_HOME/benchkit/.env`` (default
+``~/.config/benchkit/.env``), then built-in defaults. An explicit env file
+replaces ``./.env`` rather than stacking on it.
+
+Only BenchKit's own keys are applied from any file, so running inside another
+project never imports that project's secrets. Parent directories are never
+searched: a ``.env`` in a shared parent such as ``/tmp`` could otherwise
+redirect the host and API key.
+"""
+
+from __future__ import annotations
+
+import os
+from collections.abc import MutableMapping
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from dotenv import dotenv_values, set_key, unset_key
+
+from benchkit.client import DEFAULT_HOST
+
+ENV_FILE_VAR = "BENCHKIT_ENV_FILE"
+_PREFIXES = ("BENCHKIT_", "EVALPLUS_")
+_NAMES = frozenset({"OLLAMA_HOST", "OPENAI_API_KEY", "OPENAI_BASE_URL"})
+_SECRET_SUFFIXES = ("_API_KEY", "_TOKEN", "_SECRET", "_PASSWORD")
+
+# Settings `benchkit config` always lists, with the default each falls back to
+# ("" when unset simply means "not used"). Internal variables the harness sets
+# for its own child processes are left out.
+# fmt: off
+SETTINGS: tuple[tuple[str, str], ...] = (
+    ("BENCHKIT_PROVIDER",             "auto"),
+    ("BENCHKIT_HOST",                 DEFAULT_HOST),
+    ("OPENAI_BASE_URL",               ""),
+    ("OLLAMA_HOST",                   ""),
+    ("BENCHKIT_API_KEY",              ""),
+    ("OPENAI_API_KEY",                ""),
+    ("BENCHKIT_TIMEOUT",              "300"),
+    ("BENCHKIT_CONCURRENCY",          ""),
+    ("BENCHKIT_HARDWARE",             ""),
+    ("BENCHKIT_PERF_CONFIG",          ""),
+    ("BENCHKIT_RETRIES",              "3"),
+    ("BENCHKIT_CONNECT_RETRIES",      "6"),
+    ("BENCHKIT_RETRY_BASE_DELAY",     "0.5"),
+    ("BENCHKIT_RETRY_MAX_DELAY",      "8"),
+    ("BENCHKIT_RETRY_MAX_WAIT",       "60"),
+    ("BENCHKIT_LOOP_KILL",            "true"),
+    ("BENCHKIT_LOOP_KILL_PERCENT",    "80"),
+    ("BENCHKIT_LOOP_KILL_SECONDS",    "10"),
+    ("BENCHKIT_PI_TIMEOUT",           "900"),
+    ("BENCHKIT_DOCKER",               "docker"),
+    ("BENCHKIT_SANDBOX_MEMORY",       "2g"),
+    ("BENCHKIT_SANDBOX_CPUS",         "2"),
+    ("BENCHKIT_SANDBOX_PIDS",         ""),
+    ("BENCHKIT_MC_ARENA_MEMORY",      "512m"),
+    ("BENCHKIT_MC_ARENA_CPUS",        "1"),
+    ("BENCHKIT_MC_ARENA_PIDS",        "64"),
+    ("BENCHKIT_MC_ARENA_BASE_IMAGE",  ""),
+    ("BENCHKIT_MC_ARENA_IMAGE",       ""),
+    ("BENCHKIT_RENDER_SETTLE",        "4"),
+    ("BENCHKIT_RENDER_TIMEOUT",       "30"),
+    ("BENCHKIT_RENDER_ALLOWED_HOSTS", ""),
+    ("BENCHKIT_RENDER_OFFLINE",       "false"),
+    ("BENCHKIT_RENDER_CHROMIUM",      ""),
+    ("BENCHKIT_RENDER_NO_SANDBOX",    "false"),
+    ("BENCHKIT_DATASET_CACHE",        ""),
+    ("BENCHKIT_VISION_CACHE",         ""),
+    ("BENCHKIT_PATCHEVAL_DATASET",    ""),
+    ("BENCHKIT_AIDER_DATASET",        ""),
+)
+# fmt: on
+
+
+class ConfigError(Exception):
+    """A configuration source was named but cannot be used."""
+
+
+@dataclass(frozen=True)
+class EnvFile:
+    """One file BenchKit considered, in precedence order."""
+
+    path: Path
+    role: str
+    exists: bool
+    skipped: str = ""
+
+
+@dataclass
+class Loaded:
+    """The files considered and the origin of every BenchKit key applied."""
+
+    files: list[EnvFile] = field(default_factory=list)
+    origins: dict[str, str] = field(default_factory=dict)
+
+
+_loaded = Loaded()
+
+
+def is_benchkit_key(key: str) -> bool:
+    return key.startswith(_PREFIXES) or key in _NAMES
+
+
+def is_secret(key: str) -> bool:
+    return key.endswith(_SECRET_SUFFIXES)
+
+
+def mask(value: str) -> str:
+    """Hide a secret, keeping the last four characters of a long one."""
+    if not value:
+        return ""
+    if len(value) <= 8:
+        return "****"
+    return "****" + value[-4:]
+
+
+def user_config_dir(environ: MutableMapping[str, str] | None = None) -> Path:
+    environ = os.environ if environ is None else environ
+    base = environ.get("XDG_CONFIG_HOME") or ""
+    root = Path(base).expanduser() if base else Path("~/.config").expanduser()
+    return root / "benchkit"
+
+
+def user_env_path(environ: MutableMapping[str, str] | None = None) -> Path:
+    return user_config_dir(environ) / ".env"
+
+
+def load(
+    env_file: str | None = None,
+    *,
+    environ: MutableMapping[str, str] | None = None,
+    cwd: Path | None = None,
+) -> Loaded:
+    """Apply BenchKit keys from the config files into ``environ``.
+
+    A key already in the environment is never overwritten, and a file only
+    fills keys that no higher file set. Raises ``ConfigError`` when an
+    explicit env file does not exist.
+    """
+    global _loaded
+    environ = os.environ if environ is None else environ
+    cwd = Path.cwd() if cwd is None else cwd
+
+    files: list[EnvFile] = []
+    project = cwd / ".env"
+    explicit, role = env_file, "--env-file"
+    if not explicit and environ.get(ENV_FILE_VAR):
+        explicit, role = environ[ENV_FILE_VAR], ENV_FILE_VAR
+    if explicit:
+        path = Path(explicit).expanduser()
+        if not path.is_absolute():
+            path = cwd / path
+        if not path.is_file():
+            raise ConfigError(f"{role}: no such file: {path}")
+        files.append(EnvFile(path, role, True))
+        files.append(
+            EnvFile(
+                project, "project", project.is_file(), skipped=f"replaced by {role}"
+            )
+        )
+    else:
+        files.append(EnvFile(project, "project", project.is_file()))
+    user = user_env_path(environ)
+    files.append(EnvFile(user, "user", user.is_file()))
+
+    origins = {key: "env" for key in environ if is_benchkit_key(key)}
+    for entry in files:
+        if not entry.exists or entry.skipped:
+            continue
+        for key, value in dotenv_values(entry.path).items():
+            if value is None or key == ENV_FILE_VAR or not is_benchkit_key(key):
+                continue
+            if key in origins:
+                continue
+            environ[key] = value
+            origins[key] = str(entry.path)
+
+    _loaded = Loaded(files, origins)
+    return _loaded
+
+
+def loaded() -> Loaded:
+    """What the last ``load`` applied (empty before the first call)."""
+    return _loaded
+
+
+def resolve(
+    flags: dict[str, str | None] | None = None,
+    *,
+    environ: MutableMapping[str, str] | None = None,
+) -> list[tuple[str, str, str]]:
+    """Every known or set BenchKit key as ``(key, value, origin)``.
+
+    ``value`` is masked for secrets. ``origin`` is ``flag``, ``env``, the file
+    path the value came from, or ``default``.
+    """
+    environ = os.environ if environ is None else environ
+    flags = {key: value for key, value in (flags or {}).items() if value}
+    defaults = dict(SETTINGS)
+    extra = sorted(
+        key
+        for key in environ
+        if is_benchkit_key(key) and key not in defaults and key != ENV_FILE_VAR
+    )
+    rows = []
+    for key in [*defaults, *extra]:
+        if key in flags:
+            value, origin = flags[key], "flag"
+        elif key in environ:
+            value, origin = environ[key], _loaded.origins.get(key, "env")
+        else:
+            value, origin = defaults.get(key, ""), "default"
+        rows.append((key, mask(value) if is_secret(key) else value, origin))
+    return rows
+
+
+def save_user(
+    values: dict[str, str | None],
+    *,
+    environ: MutableMapping[str, str] | None = None,
+) -> Path:
+    """Write ``values`` to the user config; ``None`` or ``""`` removes a key.
+
+    The file can hold an API key, so it is created readable by its owner only.
+    """
+    path = user_env_path(environ)
+    path.parent.mkdir(parents=True, exist_ok=True, mode=0o700)
+    if not path.exists():
+        path.touch(mode=0o600)
+    present = dotenv_values(path)
+    for key, value in values.items():
+        if not is_benchkit_key(key):
+            raise ValueError(f"not a BenchKit setting: {key}")
+        if value:
+            set_key(path, key, value, quote_mode="auto")
+        elif key in present:
+            unset_key(path, key, quote_mode="auto")
+    return path
+
+
+def overridden(keys: list[str]) -> dict[str, str]:
+    """Keys whose current value comes from somewhere above the user config."""
+    user = str(user_env_path())
+    return {
+        key: origin
+        for key in keys
+        if (origin := _loaded.origins.get(key)) is not None and origin != user
+    }

{benchkit_cli-0.1.0 → benchkit_cli-0.1.1}/src/benchkit/executor.py

@@ -1,5 +1,6 @@
 """Sandboxed code execution via subprocess."""
 
+import os
 import subprocess
 import sys
 import tempfile
@@ -32,6 +33,33 @@ _b.__import__ = _safe
 """
 
 
+def sandbox_env(home: str, *, keep_prefixes: tuple[str, ...] = ()) -> dict[str, str]:
+    """A minimal environment for running model-written code.
+
+    The import guard is easy to bypass, so the child must not inherit API keys
+    or anything else from BenchKit's own environment. ``HOME`` and the temp dir
+    point at ``home``; ``keep_prefixes`` keeps evaluator knobs such as
+    ``EVALPLUS_``.
+    """
+    env = {
+        "PATH": os.environ.get("PATH") or os.defpath,
+        "HOME": home,
+        "TMPDIR": home,
+        "LANG": os.environ.get("LANG") or "C.UTF-8",
+    }
+    # Windows Python cannot start without these.
+    for name in ("SYSTEMROOT", "COMSPEC"):
+        if name in os.environ:
+            env[name] = os.environ[name]
+    if keep_prefixes:
+        env.update(
+            (key, value)
+            for key, value in os.environ.items()
+            if key.startswith(keep_prefixes)
+        )
+    return env
+
+
 @dataclass(frozen=True)
 class ExecutionResult:
     """Code-verifier result with answer-safe diagnostic feedback."""
@@ -68,27 +96,26 @@ def execute_with_feedback(code: str, timeout: int = 10) -> ExecutionResult:
     """Run code and retain only a sanitized failure category."""
     full = SANDBOX_HEADER + "\n" + code
 
-    with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as f:
-        f.write(full)
-        path = Path(f.name)
-
-    try:
-        result = subprocess.run(
-            [sys.executable, str(path)],
-            capture_output=True,
-            text=True,
-            timeout=timeout,
-        )
-        if result.returncode == 0:
-            return ExecutionResult(True)
-        return ExecutionResult(False, _failure_feedback(result.stderr or ""))
-    except subprocess.TimeoutExpired:
-        return ExecutionResult(
-            False,
-            f"The submitted Python exceeded the {timeout}s verifier timeout.",
-        )
-    finally:
-        path.unlink(missing_ok=True)
+    with tempfile.TemporaryDirectory(prefix="benchkit-exec-") as home:
+        path = Path(home) / "solution.py"
+        path.write_text(full)
+        try:
+            result = subprocess.run(
+                [sys.executable, str(path)],
+                capture_output=True,
+                text=True,
+                timeout=timeout,
+                cwd=home,
+                env=sandbox_env(home),
+            )
+        except subprocess.TimeoutExpired:
+            return ExecutionResult(
+                False,
+                f"The submitted Python exceeded the {timeout}s verifier timeout.",
+            )
+    if result.returncode == 0:
+        return ExecutionResult(True)
+    return ExecutionResult(False, _failure_feedback(result.stderr or ""))
 
 
 def execute(code: str, timeout: int = 10) -> bool:

{benchkit_cli-0.1.0 → benchkit_cli-0.1.1}/src/benchkit/tui/screens/connect.py

@@ -11,6 +11,7 @@ from textual.containers import Horizontal, Vertical, VerticalScroll
 from textual.screen import Screen
 from textual.widgets import Button, Footer, Header, Input, Label, Select, Static
 
+from benchkit import config
 from benchkit.client import DEFAULT_HOST, InferenceClient
 from benchkit.demo import DemoClient
 from benchkit.tui.widgets import Banner
@@ -34,6 +35,7 @@ class ConnectScreen(Screen[None]):
         Binding("ctrl+r", "connect", "Connect"),
         Binding("f5", "connect", "Connect", show=False),
         Binding("f3", "demo", "Demo mode"),
+        Binding("ctrl+s", "save_default", "Save as default"),
         Binding("escape", "app.quit", "Quit", show=False),
     ]
 
@@ -72,6 +74,7 @@ class ConnectScreen(Screen[None]):
                         yield Input(placeholder="300", id="timeout", compact=True)
                 with Horizontal(id="connect-actions"):
                     yield Button("Connect", id="connect", variant="primary")
+                    yield Button("Save as default", id="save-default")
                     yield Button("Quit", id="quit", variant="error")
                 yield Static(HINT, id="connect-status")
         yield Footer()
@@ -111,6 +114,29 @@ class ConnectScreen(Screen[None]):
         self._status(f"Connecting to {host} …", "working")
         self._connect(host.rstrip("/"), str(provider), api_key, timeout)
 
+    def action_save_default(self) -> None:
+        """Write host, provider and key to the user config (~/.config/benchkit)."""
+        values = {
+            "BENCHKIT_HOST": self.query_one("#host", Input).value.strip().rstrip("/"),
+            "BENCHKIT_PROVIDER": str(self.query_one("#provider", Select).value),
+            "BENCHKIT_API_KEY": self.query_one("#api-key", Input).value.strip(),
+        }
+        try:
+            path = config.save_user(values)
+        except OSError as exc:
+            self._status(f"Could not save defaults: {exc}", "error")
+            return
+        message = f"Saved host, provider and key to {path}"
+        if shadowed := config.overridden(list(values)):
+            sources = ", ".join(sorted(set(shadowed.values())))
+            message += (
+                f"\n{', '.join(sorted(shadowed))} still come from {sources}, "
+                "which take precedence here."
+            )
+            self._status(message, "working")
+        else:
+            self._status(message, "ok")
+
     def action_demo(self) -> None:
         client = DemoClient()
         self._status("Demo mode — offline models, no server required.", "ok")
@@ -119,6 +145,8 @@ class ConnectScreen(Screen[None]):
     def on_button_pressed(self, event: Button.Pressed) -> None:
         if event.button.id == "connect":
             self.action_connect()
+        elif event.button.id == "save-default":
+            self.action_save_default()
         elif event.button.id == "quit":
             self.app.exit()
 

{benchkit_cli-0.1.0 → benchkit_cli-0.1.1/src/benchkit_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: benchkit-cli
-Version: 0.1.0
+Version: 0.1.1
 Summary: Benchmark your local LLMs with real eval suites
 License-Expression: Apache-2.0
 Requires-Python: >=3.11
@@ -69,8 +69,10 @@ cp .env.example .env
 uv run benchkit
 ```
 
-Set your server in a `.env` in the directory you run `benchkit` from (parent
-directories are not searched), or enter it on the Connect screen:
+Set your server in `~/.config/benchkit/.env` to use it from any folder, in a
+`.env` in the directory you run `benchkit` from (parent directories are not
+searched), or on the Connect screen, where "Save as default" writes the user
+config for you:
 
 ```env
 BENCHKIT_PROVIDER=openai
@@ -85,6 +87,8 @@ BENCHKIT_PROVIDER=ollama
 OLLAMA_HOST=http://localhost:11434
 ```
 
+`benchkit config` shows every setting and where it came from.
+
 No inference server available? Explore the complete UI offline:
 
 ```bash

{benchkit_cli-0.1.0 → benchkit_cli-0.1.1}/src/benchkit_cli.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ src/benchkit/browser.py
 src/benchkit/catalog.py
 src/benchkit/cli.py
 src/benchkit/client.py
+src/benchkit/config.py
 src/benchkit/controls.py
 src/benchkit/decision.py
 src/benchkit/demo.py
@@ -154,6 +155,7 @@ tests/test_aider_polyglot.py
 tests/test_banking77.py
 tests/test_code_verifier.py
 tests/test_concurrency.py
+tests/test_config.py
 tests/test_datasets.py
 tests/test_decision.py
 tests/test_evalplus.py