devguard-scanner 0.2.0__tar.gz → 0.4.0__tar.gz

{devguard_scanner-0.2.0 → devguard_scanner-0.4.0}/CHANGELOG.md

@@ -3,6 +3,27 @@
 All notable changes are documented here. The format follows [Keep a Changelog](https://keepachangelog.com/) and
 the project uses [semantic versioning](https://semver.org).
 
+## 0.4.0
+
+- `devguard config init` writes the user config with an AI profile: numbered choices on a terminal (Enter takes
+  the default), or the defaults and flags with `-y` or without a terminal (`--provider anthropic|openai|local`,
+  `--model`, `--key-env`, `--base-url`, `--path`, `--force`). `devguard config path` prints the file location.
+- With a single AI profile, `--ai` uses it without `default_profile`. Without any profile, the error points to
+  `devguard config init`.
+- Container images are published on every push to `main` (`:main`, `:sha-<commit>`), and the hosted API on Vercel
+  is deployed from CI with that exact image digest.
+
+## 0.3.0
+
+- The default drop folder for local scans (`DEVGUARD_API_LOCAL_ROOT`, and the folder `compose.yaml` mounts) is
+  now `~/devguard-scanner-data` instead of `~/devguard-scanner`. Move the folder, or set the variable to keep
+  the old location.
+- File locations use `devguard-scanner` (only the command is still `devguard`): config
+  `~/.config/devguard-scanner/config.toml` (the old `~/.config/devguard/config.toml` is still read if the new one
+  is missing), app data `~/.local/share/devguard-scanner/` (AI consent and cache, MCP audit log), and reports
+  `~/devguard-scanner/reports/` on every OS. In the container image the config is
+  `/etc/devguard-scanner/config.toml`.
+
 ## 0.2.0
 
 Remote scanning, the HTTP API, and the container image.

{devguard_scanner-0.2.0 → devguard_scanner-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: devguard-scanner
-Version: 0.2.0
+Version: 0.4.0
 Summary: Scan untrusted code repositories for malware before you open, install, or run them. Files are analyzed as data and never executed.
 Project-URL: Homepage, https://github.com/yilmazhasan/devguard-scanner
 Project-URL: Documentation, https://github.com/yilmazhasan/devguard-scanner/tree/main/docs
@@ -65,7 +65,7 @@ Findings: 5 (1 critical, 2 high, 1 medium, 1 low)
   - [critical] Automatic trigger reaches dangerous code (package.json:5)
   - [high] Browser profile data targeted (lib/collect.js:7)
   - [high] Cryptocurrency wallet data targeted (lib/collect.js:10)
-Report (md): ~/.local/share/devguard/reports/interview-task-1a2b3c4d/latest/report.md
+Report (md): ~/devguard-scanner/reports/interview-task-1a2b3c4d/latest/report.md
 ```
 
 | Verdict | Meaning |
@@ -96,7 +96,7 @@ curl -s 'https://devguard-scanner.vercel.app/v1/scans/github/owner/repo?format=m
 # one-off scan in a throwaway container
 docker run --rm ghcr.io/yilmazhasan/devguard-scanner scan https://github.com/owner/repo --stdout md
 
-# self-hosted API, plus local scans of anything you copy into ~/devguard-scanner (mounted read-only)
+# self-hosted API, plus local scans of anything you copy into ~/devguard-scanner-data (mounted read-only)
 docker compose up -d
 ```
 

{devguard_scanner-0.2.0 → devguard_scanner-0.4.0}/README.md

@@ -27,7 +27,7 @@ Findings: 5 (1 critical, 2 high, 1 medium, 1 low)
   - [critical] Automatic trigger reaches dangerous code (package.json:5)
   - [high] Browser profile data targeted (lib/collect.js:7)
   - [high] Cryptocurrency wallet data targeted (lib/collect.js:10)
-Report (md): ~/.local/share/devguard/reports/interview-task-1a2b3c4d/latest/report.md
+Report (md): ~/devguard-scanner/reports/interview-task-1a2b3c4d/latest/report.md
 ```
 
 | Verdict | Meaning |
@@ -58,7 +58,7 @@ curl -s 'https://devguard-scanner.vercel.app/v1/scans/github/owner/repo?format=m
 # one-off scan in a throwaway container
 docker run --rm ghcr.io/yilmazhasan/devguard-scanner scan https://github.com/owner/repo --stdout md
 
-# self-hosted API, plus local scans of anything you copy into ~/devguard-scanner (mounted read-only)
+# self-hosted API, plus local scans of anything you copy into ~/devguard-scanner-data (mounted read-only)
 docker compose up -d
 ```
 

{devguard_scanner-0.2.0 → devguard_scanner-0.4.0}/src/devguard/__init__.py

@@ -1,5 +1,5 @@
 """DevGuard: pre-open security scanner for untrusted code workspaces."""
 
-__version__ = "0.2.0"
+__version__ = "0.4.0"
 RULESET_VERSION = "2026.10.0"
 SCHEMA_VERSION = "1"

{devguard_scanner-0.2.0 → devguard_scanner-0.4.0}/src/devguard/ai/registry.py

@@ -101,8 +101,15 @@ def load_provider(
 ) -> LoadedProvider:
     """Load a profile's provider. `secrets` supplies already-resolved values (an API caller's own key)."""
     name = profile_name or cfg.default_profile
+    if not name and len(cfg.profiles) == 1:
+        name = next(iter(cfg.profiles))
     if not name:
-        raise ProviderError("no AI profile selected: pass --ai-profile or set ai.default_profile in your user config")
+        if not cfg.profiles:
+            raise ProviderError("no AI profile configured: run `devguard config init` to create one")
+        raise ProviderError(
+            f"several AI profiles ({', '.join(sorted(cfg.profiles))}) and no default: pass --ai-profile NAME "
+            "or set ai.default_profile in your config"
+        )
     profile = cfg.profiles.get(name)
     if profile is None:
         raise ProviderError(f"unknown AI profile {name!r}; configured: {', '.join(sorted(cfg.profiles)) or 'none'}")

{devguard_scanner-0.2.0 → devguard_scanner-0.4.0}/src/devguard/api/local.py

@@ -1,8 +1,8 @@
 """Local scans for a self-hosted API: directories inside one drop folder (DEVGUARD_API_LOCAL_ROOT).
 
-Put a repository into the drop folder (default ~/devguard-scanner; /workspace in Docker, mounted read-only) and
+Put a repository into the drop folder (default ~/devguard-scanner-data; /workspace in Docker, mounted read-only) and
 ask the API to scan it by name. Instead of copying, a top-level entry may be a symlink to the repository
-(`ln -s /path/to/repo ~/devguard-scanner/repo`); in Docker, bind-mount it instead
+(`ln -s /path/to/repo ~/devguard-scanner-data/repo`); in Docker, bind-mount it instead
 (`-v /path/to/repo:/workspace/repo:ro`), since the container cannot see symlink targets on the host.
 
 Only what you put there is reachable: names are relative, `..` and absolute paths are refused, and symlinks
@@ -47,7 +47,7 @@ def resolve_local(root: Path, name: str) -> Path:
         st = os.lstat(current)
     except FileNotFoundError:
         raise LocalPathError(404, "not_found", f"{first!r} is not in the drop folder") from None
-    if stat.S_ISLNK(st.st_mode):  # a link you placed in the drop folder, e.g. ln -s ~/code/repo ~/devguard-scanner/
+    if stat.S_ISLNK(st.st_mode):  # a link placed in the drop folder: ln -s ~/code/repo ~/devguard-scanner-data/
         try:
             current = current.resolve(strict=True)
         except (OSError, RuntimeError):

{devguard_scanner-0.2.0 → devguard_scanner-0.4.0}/src/devguard/api/settings.py

@@ -4,7 +4,7 @@
     DEVGUARD_API_<NAME>     overrides one field, e.g. DEVGUARD_API_MAX_REPO_MB=200
     DEVGUARD_GITHUB_TOKEN   GitHub token without scopes (5,000 API requests/hour instead of 60)
     DEVGUARD_API_MONGODB_URI (or MONGODB_URI)  enables the request log in MongoDB
-    DEVGUARD_API_LOCAL_ROOT drop folder for local scans (default ~/devguard-scanner; ignored by the public profile)
+    DEVGUARD_API_LOCAL_ROOT drop folder for local scans (default ~/devguard-scanner-data; ignored by the public profile)
 
 Nothing in a request can change these.
 """
@@ -51,7 +51,7 @@ class APISettings(BaseModel):
     ai_max_cost_usd: float = 1.0
     github_token: SecretStr | None = None
     # Self-host only: scan directories copied into this drop folder (POST /v1/scans/local). Never public.
-    local_root: str | None = "~/devguard-scanner"
+    local_root: str | None = "~/devguard-scanner-data"
     # request log (optional; see devguard.api.traffic)
     mongodb_uri: SecretStr | None = None
     mongodb_db: str = "devguard"

{devguard_scanner-0.2.0 → devguard_scanner-0.4.0}/src/devguard/cli.py

@@ -108,6 +108,21 @@ def _parser() -> argparse.ArgumentParser:
     sv.add_argument("--port", type=int, help="Port (default: $PORT or 8000).")
     sv.add_argument("--profile", choices=["public", "selfhost", "dev"], help="Limits profile (default: selfhost).")
 
+    c = sub.add_parser("config", help="Create or locate the user config file.")
+    csub = c.add_subparsers(dest="config_command", required=True)
+    ci = csub.add_parser(
+        "init",
+        help="Write a config with an AI profile (asks on a terminal; -y or no terminal: defaults/flags).",
+    )
+    ci.add_argument("--provider", choices=["anthropic", "openai", "local"])
+    ci.add_argument("--model", help="Model id (default: claude-opus-5-5, gpt-4o, or llama3.1).")
+    ci.add_argument("--key-env", help="Environment variable that holds the API key (default: the provider's usual).")
+    ci.add_argument("--base-url", help="Server URL for --provider local (default: Ollama on localhost).")
+    ci.add_argument("--path", type=Path, help="Where to write it (default: the user config file).")
+    ci.add_argument("--force", action="store_true", help="Overwrite an existing file (kept as .bak).")
+    ci.add_argument("-y", "--yes", action="store_true", help="Do not ask; use the flags and defaults.")
+    csub.add_parser("path", help="Print the user config file path.")
+
     sub.add_parser("doctor", help="Check the installation and configuration.")
     return p
 
@@ -131,6 +146,8 @@ def main(argv: list[str] | None = None) -> int:
             return serve(roots, expose_investigation=args.expose_investigation_tools, config=cfg)
         if args.command == "serve":
             return _serve(args)
+        if args.command == "config":
+            return _config(args)
         if args.command == "doctor":
             return _doctor()
     except ConfigError as exc:
@@ -337,15 +354,42 @@ def _ai(args: argparse.Namespace) -> int:
     return EXIT_OK if report.ok else EXIT_FINDINGS
 
 
+def _config(args: argparse.Namespace) -> int:
+    from devguard.core.config import user_config_file
+
+    if args.config_command == "path":
+        path = user_config_file()
+        print(path if path.is_file() else f"{path} (not created yet: run `devguard config init`)")
+        return EXIT_OK
+    from devguard.core.config_init import run_init
+
+    result = run_init(
+        path=args.path,
+        provider=args.provider,
+        model=args.model,
+        key_env=args.key_env,
+        base_url=args.base_url,
+        force=args.force,
+        assume_defaults=args.yes,
+    )
+    print(f"\nWrote {result.path} (profile {result.choice.profile!r}, {result.choice.label}).")
+    print("Next:")
+    if result.key_env and not os.environ.get(result.key_env):
+        print(f"  export {result.key_env}=...        # your API key; it is not stored in the file")
+    print("  devguard ai test                 # checks the profile with synthetic data only")
+    print("  devguard scan ./repo --ai")
+    return EXIT_OK
+
+
 def _doctor() -> int:
     import importlib.util
     import platform
 
     from devguard.ai.registry import AIConfig, available_entry_points
-    from devguard.core.config import user_config_dir
+    from devguard.core.config import user_config_file
 
     print(f"devguard {__version__}, ruleset {RULESET_VERSION}, Python {platform.python_version()}")
-    cfg_file = user_config_dir() / "config.toml"
+    cfg_file = user_config_file()
     print(f"User config: {cfg_file} ({'found' if cfg_file.is_file() else 'not found'})")
     try:
         cfg = load_config(None, None)

{devguard_scanner-0.2.0 → devguard_scanner-0.4.0}/src/devguard/core/config.py

@@ -51,22 +51,37 @@ class ScanConfig(BaseModel):
         }
 
 
-def user_config_dir() -> Path:
+APP_DIR = "devguard-scanner"  # directory name for config, data, and reports; only the command is `devguard`
+_LEGACY_APP_DIR = "devguard"  # used up to 0.2.0
+
+
+def user_config_dir(name: str = APP_DIR) -> Path:
     if sys.platform == "win32":
         base = os.environ.get("APPDATA") or str(Path.home() / "AppData" / "Roaming")
-        return Path(base) / "devguard"
+        return Path(base) / name
     if sys.platform == "darwin":
-        return Path.home() / "Library" / "Application Support" / "devguard"
-    return Path(os.environ.get("XDG_CONFIG_HOME") or Path.home() / ".config") / "devguard"
+        return Path.home() / "Library" / "Application Support" / name
+    return Path(os.environ.get("XDG_CONFIG_HOME") or Path.home() / ".config") / name
+
+
+def user_config_file() -> Path:
+    """The user config file, falling back to the pre-0.3 location when only that one exists."""
+    current = user_config_dir() / "config.toml"
+    legacy = user_config_dir(_LEGACY_APP_DIR) / "config.toml"
+    return legacy if not current.is_file() and legacy.is_file() else current
 
 
 def user_data_dir() -> Path:
     if sys.platform == "win32":
         base = os.environ.get("LOCALAPPDATA") or str(Path.home() / "AppData" / "Local")
-        return Path(base) / "devguard"
+        return Path(base) / APP_DIR
     if sys.platform == "darwin":
-        return Path.home() / "Library" / "Application Support" / "devguard"
-    return Path(os.environ.get("XDG_DATA_HOME") or Path.home() / ".local" / "share") / "devguard"
+        return Path.home() / "Library" / "Application Support" / APP_DIR
+    return Path(os.environ.get("XDG_DATA_HOME") or Path.home() / ".local" / "share") / APP_DIR
+
+
+def reports_dir() -> Path:
+    return Path.home() / APP_DIR / "reports"
 
 
 def is_within(path: Path, root: Path) -> bool:
@@ -80,11 +95,11 @@ def is_within(path: Path, root: Path) -> bool:
 def default_output_dir(target: Path) -> Path:
     resolved = target.resolve()
     digest = hashlib.sha256(str(resolved).encode()).hexdigest()[:8]
-    return user_data_dir() / "reports" / f"{resolved.name or 'root'}-{digest}"
+    return reports_dir() / f"{resolved.name or 'root'}-{digest}"
 
 
 def remote_output_dir(owner: str, repo: str) -> Path:
-    return user_data_dir() / "reports" / f"github-{owner}-{repo}"
+    return reports_dir() / f"github-{owner}-{repo}"
 
 
 def _read_toml(path: Path, target: Path | None) -> dict[str, Any]:
@@ -108,7 +123,7 @@ def load_config(
     overrides: dict[str, Any] | None = None,
 ) -> ScanConfig:
     data: dict[str, Any] = {}
-    user_file = user_config_dir() / "config.toml"
+    user_file = user_config_file()
     if user_file.is_file():
         data = _merge(data, _read_toml(user_file, target))
     if explicit is not None:

devguard_scanner-0.4.0/src/devguard/core/config_init.py

@@ -0,0 +1,167 @@
+"""`devguard config init`: write a user config with one AI profile.
+
+Interactive on a terminal (numbered choices, Enter takes the default); with `--yes` or without a terminal it
+writes the defaults, or whatever the flags say. The API key itself is never written: the profile references
+an environment variable.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import sys
+from collections.abc import Callable
+from dataclasses import dataclass
+from pathlib import Path
+
+from devguard.core.config import ConfigError, user_config_dir
+
+
+@dataclass(frozen=True)
+class Choice:
+    key: str
+    label: str
+    provider: str
+    profile: str
+    model: str
+    key_env: str | None = None
+    base_url: str | None = None
+
+
+CHOICES = [
+    Choice("anthropic", "Claude (Anthropic)", "anthropic", "claude", "claude-opus-5-5", key_env="ANTHROPIC_API_KEY"),
+    Choice("openai", "OpenAI", "openai", "gpt", "gpt-4o", key_env="OPENAI_API_KEY"),
+    Choice(
+        "local",
+        "Local model via Ollama (code stays on this machine)",
+        "openai-compatible",
+        "local",
+        "llama3.1",
+        base_url="http://localhost:11434/v1",
+    ),
+]
+BY_KEY = {c.key: c for c in CHOICES}
+_MODEL = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._:/-]{0,99}$")
+_ENV = re.compile(r"^[A-Za-z_][A-Za-z0-9_]{0,63}$")
+
+
+def default_choice() -> Choice:
+    """Prefer the provider whose key is already in the environment."""
+    for c in CHOICES:
+        if c.key_env and os.environ.get(c.key_env):
+            return c
+    return CHOICES[0]
+
+
+def render(choice: Choice, model: str, key_env: str | None, base_url: str | None) -> str:
+    q = json.dumps  # a JSON string of these validated values is a valid TOML basic string
+    lines = [
+        "# DevGuard user configuration, written by `devguard config init`.",
+        "# All options: https://github.com/yilmazhasan/devguard-scanner/blob/main/docs/ai.md",
+        "",
+        "[ai]",
+        f"default_profile = {q(choice.profile)}",
+        "# max_cost_usd = 1.0     # per scan; enforced when the cost is known (see price_* below)",
+        "# send_excerpts = true   # false: send finding metadata only, no code excerpts",
+        "",
+        f"[ai.profiles.{choice.profile}]",
+        f"provider = {q(choice.provider)}",
+        f"model = {q(model)}",
+    ]
+    if base_url:
+        lines.append(f"base_url = {q(base_url)}")
+    if key_env:
+        lines.append(f"secrets = {{ api_key = {q('env:' + key_env)} }}   # the key is read from ${key_env}")
+    if choice.key == "local":
+        lines.append("data_stays_local = true   # no consent prompt; nothing leaves this machine")
+    if choice.provider == "openai":
+        lines += [
+            "# USD per 1M tokens for this model, so max_cost_usd is enforced:",
+            "# price_input_per_mtok = 0.0",
+            "# price_output_per_mtok = 0.0",
+        ]
+    return "\n".join(lines) + "\n"
+
+
+@dataclass
+class InitResult:
+    path: Path
+    choice: Choice
+    key_env: str | None
+
+
+def run_init(
+    *,
+    path: Path | None,
+    provider: str | None,
+    model: str | None,
+    key_env: str | None,
+    base_url: str | None,
+    force: bool,
+    assume_defaults: bool,
+    ask: Callable[[str], str] = input,
+    out: Callable[[str], None] = print,
+) -> InitResult:
+    interactive = not assume_defaults and sys.stdin.isatty()
+    target = (path or user_config_dir() / "config.toml").expanduser()
+
+    def prompt(question: str, default: str) -> str:
+        if not interactive:
+            return default
+        try:
+            answer = ask(f"{question} [{default}]: ").strip()
+        except EOFError:
+            answer = ""
+        return answer or default
+
+    if target.is_dir():
+        raise ConfigError(
+            f"{target} is a directory (Docker creates one when you mount a config file that does not exist yet). "
+            "Remove it, then run this again."
+        )
+    if target.exists() and not force:
+        if not interactive:
+            raise ConfigError(f"{target} already exists; pass --force to overwrite it")
+        answer = prompt(f"{target} exists. Overwrite it (the old file is kept as {target.name}.bak)? y/n", "n")
+        if answer.lower() not in ("y", "yes"):
+            raise ConfigError(f"{target} was not changed")
+
+    if provider is not None:
+        if provider not in BY_KEY:
+            raise ConfigError(f"unknown provider {provider!r}; choose one of {', '.join(BY_KEY)}")
+        choice = BY_KEY[provider]
+    else:
+        default = default_choice()
+        choice = default
+        if interactive:
+            out("Which AI provider?")
+            for i, c in enumerate(CHOICES, 1):
+                out(f"  {i}) {c.label}{'  (default)' if c is default else ''}")
+            while True:
+                picked = prompt(f"Choose 1-{len(CHOICES)}", str(CHOICES.index(default) + 1))
+                if picked.isdigit() and 1 <= int(picked) <= len(CHOICES):
+                    choice = CHOICES[int(picked) - 1]
+                    break
+                out(f"  Please enter a number from 1 to {len(CHOICES)}.")
+
+    model = model or prompt("Model", choice.model)
+    if not _MODEL.match(model):
+        raise ConfigError(f"invalid model id {model!r}")
+    if choice.key_env:
+        key_env = key_env or prompt("Environment variable that holds the API key", choice.key_env)
+        if not _ENV.match(key_env):
+            raise ConfigError(f"invalid environment variable name {key_env!r}")
+    else:
+        key_env = None
+    if choice.base_url:
+        base_url = base_url or prompt("Server URL", choice.base_url)
+    else:
+        base_url = None
+
+    text = render(choice, model, key_env, base_url)
+    target.parent.mkdir(parents=True, exist_ok=True)
+    if target.exists():
+        target.with_name(target.name + ".bak").write_bytes(target.read_bytes())
+    target.write_text(text, encoding="utf-8")
+    return InitResult(target, choice, key_env)

{devguard_scanner-0.2.0 → devguard_scanner-0.4.0}/tests/test_report_cli.py

@@ -116,3 +116,68 @@ def test_example_config_is_valid(tmp_path: Path) -> None:
     ai = AIConfig.model_validate(cfg.ai)
     assert set(ai.profiles) == {"claude", "gpt", "local"}
     assert cfg.mcp["allowed_roots"] == ["~/code"]
+
+
+def test_user_config_falls_back_to_legacy_dir(tmp_path, monkeypatch) -> None:
+    from devguard.core.config import user_config_file
+
+    monkeypatch.setattr("sys.platform", "linux")  # XDG_CONFIG_HOME only applies there
+    monkeypatch.setenv("XDG_CONFIG_HOME", str(tmp_path))
+    legacy = tmp_path / "devguard" / "config.toml"
+    legacy.parent.mkdir()
+    legacy.write_text("[scan]\n")
+    assert user_config_file() == legacy
+    current = tmp_path / "devguard-scanner" / "config.toml"
+    current.parent.mkdir()
+    current.write_text("[scan]\n")
+    assert user_config_file() == current
+
+
+def test_config_init_defaults_write_a_loadable_profile(tmp_path, monkeypatch) -> None:
+    import tomllib
+
+    from devguard.ai.registry import AIConfig
+
+    monkeypatch.delenv("ANTHROPIC_API_KEY", raising=False)
+    monkeypatch.setenv("OPENAI_API_KEY", "sk-test")  # the provider with a key set is the default
+    path = tmp_path / "cfg" / "config.toml"
+    assert main(["config", "init", "-y", "--path", str(path)]) == 0
+    cfg = AIConfig.model_validate(tomllib.loads(path.read_text())["ai"])
+    assert cfg.default_profile == "gpt"
+    assert cfg.profiles["gpt"].secrets == {"api_key": "env:OPENAI_API_KEY"}
+    assert "sk-test" not in path.read_text()
+    # an existing file is kept unless --force; --force leaves a backup
+    assert main(["config", "init", "-y", "--path", str(path), "--provider", "local"]) == 2
+    assert main(["config", "init", "-y", "--path", str(path), "--provider", "local", "--force"]) == 0
+    assert "data_stays_local = true" in path.read_text()
+    assert "OPENAI_API_KEY" in (tmp_path / "cfg" / "config.toml.bak").read_text()
+
+
+def test_config_init_interactive_choices(tmp_path, monkeypatch) -> None:
+    from devguard.core.config_init import run_init
+
+    monkeypatch.setattr("sys.stdin.isatty", lambda: True)
+    answers = iter(["9", "1", "", "MY_KEY"])  # invalid pick, Claude, default model, custom key variable
+    result = run_init(
+        path=tmp_path / "config.toml",
+        provider=None,
+        model=None,
+        key_env=None,
+        base_url=None,
+        force=False,
+        assume_defaults=False,
+        ask=lambda _q: next(answers),
+        out=lambda _s: None,
+    )
+    text = result.path.read_text()
+    assert 'model = "claude-opus-5-5"' in text and '"env:MY_KEY"' in text
+
+
+def test_single_profile_needs_no_default() -> None:
+    from devguard.ai.registry import AIConfig, ProviderError, load_provider
+
+    one = AIConfig.model_validate({"profiles": {"only": {"provider": "nonexistent-provider"}}})
+    with pytest.raises(ProviderError, match="nonexistent-provider"):  # got past profile selection
+        load_provider(one, None, None)
+    with pytest.raises(ProviderError, match="devguard config init"):
+        load_provider(AIConfig(), None, None)