ape-linux 0.4.6__tar.gz → 0.5.0__tar.gz

{ape_linux-0.4.6 → ape_linux-0.5.0}/CLAUDE.md

@@ -77,18 +77,29 @@ The flow in `ape_linux.py` is intentionally minimal:
 3. `call_llm()` wraps `pydantic_ai.Agent`, which is the provider abstraction. It sets
    `output_type=Command | CannotHelp`, so the agent returns one of those structured
    objects instead of raw text (no string-sniffing in `main()`), and forwards a
-   `model_settings` mapping (or `None`). Models are passed through verbatim in
-   `provider:name` form (e.g. `anthropic:claude-sonnet-4-5`), so Ape supports any
-   provider Pydantic AI supports without provider-specific code. The model is resolved
-   solely from the `APE_MODEL` env var → the `DEFAULT_MODEL` constant
-   (`openai-chat:gpt-4.1`); there is no CLI override. The sampling temperature is
-   resolved by `resolve_model_settings()` from the `APE_TEMPERATURE` env var → the
+   `model_settings` mapping (or `None`). The model string in `provider:name` form
+   (e.g. `anthropic:claude-sonnet-4-5`) is turned into a model object via
+   `pydantic_ai.models.infer_model()`, to which `call_llm()` passes a custom
+   `provider_factory` that builds the inferred provider with
+   `infer_provider_class(provider_name)(api_key=api_key)` — i.e. it injects Ape's own
+   API key straight into the provider rather than letting Pydantic AI read the
+   provider's standard credential env var. This stays provider-agnostic (any provider
+   whose class accepts an `api_key` works with no provider-specific code); a provider
+   that lacks an `api_key` parameter raises at call time and surfaces as a one-line
+   error. The model is resolved by `resolve_model()` solely from the **required**
+   `APE_MODEL` env var (in `provider:name` form); there is no built-in default and no
+   CLI override, so the provider is always explicit — a missing/empty `APE_MODEL` exits
+   `1` before any LLM call. The API key is resolved by `resolve_api_key()` from the
+   **`APE_API_KEY`** env var — Ape's own variable, deliberately *not* a provider's
+   standard one (e.g. `OPENAI_API_KEY`), so configuring Ape doesn't force a globally
+   named key that other tools also read; a missing/empty `APE_API_KEY` likewise exits
+   `1` before any LLM call. The sampling temperature
+   is resolved by `resolve_model_settings()` from the `APE_TEMPERATURE` env var → the
    `DEFAULT_TEMPERATURE` constant (`0.2`); the literal `"undefined"` (case-insensitive)
    yields `None` so **no** `model_settings` are sent — deliberately, because a
    hard-coded temperature crashes models that reject sampling settings (some reasoning
    models, Claude Opus 4.7/4.8) — and an unparseable value exits `1` before any LLM
-   call. Credentials come from each provider's standard env var (e.g. `OPENAI_API_KEY`,
-   `ANTHROPIC_API_KEY`).
+   call.
 4. Errors are flattened to one-line stderr messages, raising `SystemExit(1)` —
    `ModelHTTPError` reports status/message; any other exception (bad credentials,
    unknown provider) prints `str(error)`. There is no CLI framework swallowing
@@ -105,7 +116,17 @@ The flow in `ape_linux.py` is intentionally minimal:
 doesn't exit then), asserting on captured stdout/stderr with `capsys`. It monkeypatches
 `ape_linux.call_llm` so no real network/LLM calls happen; the mock returns a `Command`
 (printed to stdout, exit 0) or a `CannotHelp` to exercise the refusal path (printed to
-stderr, exit `2`). The `mockenv` fixture sets a dummy `OPENAI_API_KEY`.
+stderr, exit `2`). The `mockenv` fixture sets a dummy `APE_API_KEY` and `APE_MODEL`
+(both required). Tests that assert on `call_llm`'s arguments take its signature
+`(model, api_key, system_prompt, user_prompt, model_settings)`; a missing **or
+blank/whitespace** `APE_MODEL` or `APE_API_KEY` is each checked to exit `1` before
+`call_llm` is ever reached.
+
+`build_provider()` is covered directly (not through `main()`): tests construct the
+`openai` and `anthropic` providers with the standard credential vars deleted and assert
+the injected key lands on `provider.client.api_key` (proving the standard var is neither
+needed nor read), and that an unknown provider name raises `ValueError`. Building a
+provider is offline, so these make no network calls.
 
 `detect_system_context()` is covered by tests that assert it returns a string without
 crashing, reports the OS, and — importantly — excludes the current username, hostname,
@@ -121,4 +142,34 @@ line.
   uses 3.14 (`.python-version`).
 - Version is read at runtime from package metadata (`importlib.metadata.version`), so
   the single source of truth is `pyproject.toml`'s `version`. Publishing is tag-driven
-  (`.github/workflows/publish.yaml`).
+  (`.github/workflows/publish.yaml`). See **Releasing** below for the full flow.
+
+## Releasing
+
+Releases are cut from `main` and published to PyPI by the tag-driven `publish.yaml`
+workflow, which runs `uv build` + `uv publish` on **any** pushed tag. Tags are **bare
+version numbers with no `v` prefix** (e.g. `0.4.6`) and must match `pyproject.toml`'s
+`version`. Follow these steps (this is the process that worked for `0.4.6`):
+
+1. **Bump the version** in `pyproject.toml`, then `uv sync` so `uv.lock` records the new
+   local package version.
+2. **Verify locally**: `just lint`, `just type-check`, and `just test` must all pass.
+3. **Branch + commit + push**: create a `release-<version>` branch, commit the change
+   (bundle whatever feature work is shipping in the release), and push it.
+4. **Open a PR** against `main` (`gh pr create`) and wait for CI to go green with
+   `gh pr checks <n> --watch` (the `Tests` workflow runs `Lint` plus the 3.10–3.13 ×
+   ubuntu/macos test matrix — nine checks total).
+5. **Squash-merge** once green: `gh pr merge <n> --squash --delete-branch`.
+6. **Tag on `main`**: `git checkout main && git pull`, then `git tag <version> &&
+   git push origin <version>`. Pushing the tag is what triggers `publish.yaml` → PyPI.
+7. **Create the GitHub release**: `gh release create <version> --generate-notes
+   --verify-tag`. This reuses the already-pushed tag and fills the body with GitHub's
+   auto-generated changelog.
+8. **Verify the publish**: watch the run (`gh run watch <id> --exit-status`) and confirm
+   PyPI serves the new version, e.g. `uv run --isolated --no-project --refresh-package
+   ape-linux --with ape-linux python -c "import importlib.metadata as m;
+   print(m.version('ape-linux'))"`.
+
+Note on release notes: `--generate-notes` diffs against the previous release tag, so any
+PR merged after that tag is listed — including ones that never got their own release.
+That is expected, not a bug; leave the auto-generated notes as-is unless asked.

{ape_linux-0.4.6 → ape_linux-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ape-linux
-Version: 0.4.6
+Version: 0.5.0
 Summary: AI for Linux commands
 Project-URL: Homepage, https://github.com/sbalian/ape
 Project-URL: Repository, https://github.com/sbalian/ape
@@ -32,8 +32,7 @@ Output:
 find ~/user/projects -type f -name "*attention*.pdf" > important_files.txt && mv important_files.txt ~/Documents/
 ```
 
-Ape works with any provider supported by [Pydantic AI](https://ai.pydantic.dev/models/)
-— OpenAI, Anthropic, Google, Groq, Mistral and more.
+Ape works with the following providers supported by [Pydantic AI](https://ai.pydantic.dev/models/): OpenAI, Anthropic, Google, Groq, and Mistral.
 
 To install ([`uv`](https://docs.astral.sh/uv/getting-started/installation/) recommended):
 
@@ -41,14 +40,21 @@ To install ([`uv`](https://docs.astral.sh/uv/getting-started/installation/) reco
 uv tool install ape-linux
 ```
 
-Next, set the API key for your provider using its standard environment variable.
-For example:
+Next, choose a model with `APE_MODEL` in `provider:name` form (see the
+[Pydantic AI docs](https://ai.pydantic.dev/models/) for the supported providers and
+models) and set your provider API key in `APE_API_KEY`. Ape infers the provider from
+the model name and passes this key straight to it, so `APE_API_KEY` must be a key for
+that model's provider. Ape uses its own key variable rather than a provider's standard
+one (like `OPENAI_API_KEY`), so setting it up for Ape doesn't affect other tools on
+your system:
 
 ```bash
-export OPENAI_API_KEY=key      # for OpenAI models
-export ANTHROPIC_API_KEY=key   # for Anthropic models
+export APE_MODEL=openai:gpt-5.4-nano
+export APE_API_KEY=key
 ```
 
+Both are required.
+
 To run:
 
 ```bash
@@ -87,17 +93,6 @@ Commands only ever go to standard output, so a refusal is never mistaken for one
 ape: I can only help with Linux and Unix command-line tasks.
 ```
 
-You can change the model with the `APE_MODEL` environment variable. Models are
-specified in `provider:name` form.
-See [here](https://ai.pydantic.dev/models/) for the supported providers and models.
-For example:
-
-```bash
-export APE_MODEL=anthropic:claude-sonnet-4-5
-```
-
-If `APE_MODEL` is unset, the default `openai-chat:gpt-4.1` is used.
-
 You can set the sampling temperature with the `APE_TEMPERATURE` environment
 variable (default `0.2`). Some models — for example certain reasoning models —
 reject a temperature; set `APE_TEMPERATURE=undefined` to send none at all and let

{ape_linux-0.4.6 → ape_linux-0.5.0}/README.md

@@ -12,8 +12,7 @@ Output:
 find ~/user/projects -type f -name "*attention*.pdf" > important_files.txt && mv important_files.txt ~/Documents/
 ```
 
-Ape works with any provider supported by [Pydantic AI](https://ai.pydantic.dev/models/)
-— OpenAI, Anthropic, Google, Groq, Mistral and more.
+Ape works with the following providers supported by [Pydantic AI](https://ai.pydantic.dev/models/): OpenAI, Anthropic, Google, Groq, and Mistral.
 
 To install ([`uv`](https://docs.astral.sh/uv/getting-started/installation/) recommended):
 
@@ -21,14 +20,21 @@ To install ([`uv`](https://docs.astral.sh/uv/getting-started/installation/) reco
 uv tool install ape-linux
 ```
 
-Next, set the API key for your provider using its standard environment variable.
-For example:
+Next, choose a model with `APE_MODEL` in `provider:name` form (see the
+[Pydantic AI docs](https://ai.pydantic.dev/models/) for the supported providers and
+models) and set your provider API key in `APE_API_KEY`. Ape infers the provider from
+the model name and passes this key straight to it, so `APE_API_KEY` must be a key for
+that model's provider. Ape uses its own key variable rather than a provider's standard
+one (like `OPENAI_API_KEY`), so setting it up for Ape doesn't affect other tools on
+your system:
 
 ```bash
-export OPENAI_API_KEY=key      # for OpenAI models
-export ANTHROPIC_API_KEY=key   # for Anthropic models
+export APE_MODEL=openai:gpt-5.4-nano
+export APE_API_KEY=key
 ```
 
+Both are required.
+
 To run:
 
 ```bash
@@ -67,17 +73,6 @@ Commands only ever go to standard output, so a refusal is never mistaken for one
 ape: I can only help with Linux and Unix command-line tasks.
 ```
 
-You can change the model with the `APE_MODEL` environment variable. Models are
-specified in `provider:name` form.
-See [here](https://ai.pydantic.dev/models/) for the supported providers and models.
-For example:
-
-```bash
-export APE_MODEL=anthropic:claude-sonnet-4-5
-```
-
-If `APE_MODEL` is unset, the default `openai-chat:gpt-4.1` is used.
-
 You can set the sampling temperature with the `APE_TEMPERATURE` environment
 variable (default `0.2`). Some models — for example certain reasoning models —
 reject a temperature; set `APE_TEMPERATURE=undefined` to send none at all and let

{ape_linux-0.4.6 → ape_linux-0.5.0}/ape_linux.py

@@ -4,13 +4,16 @@ import os
 import platform
 import shutil
 import sys
-from typing import cast
+from collections.abc import Callable
+from functools import partial
+from typing import Any, cast
 
 from pydantic import BaseModel
 from pydantic_ai import Agent, ModelSettings
 from pydantic_ai.exceptions import ModelHTTPError
+from pydantic_ai.models import infer_model
+from pydantic_ai.providers import Provider, infer_provider_class
 
-DEFAULT_MODEL = "openai-chat:gpt-4.1"
 DEFAULT_TEMPERATURE = 0.2
 
 HELP = """\
@@ -24,16 +27,18 @@ Example:
     ape "Create a symbolic link named 'win' pointing to /mnt/c/Users/jdoe"
     ln -s /mnt/c/Users/jdoe win
 
-The model is read from the APE_MODEL environment variable in provider:name form
-(e.g. anthropic:claude-sonnet-4-5), falling back to {default}. See
-https://ai.pydantic.dev/models/. Credentials come from each provider's standard
-environment variable (e.g. OPENAI_API_KEY, ANTHROPIC_API_KEY).
+The model is required and read from the APE_MODEL environment variable in
+provider:name form (e.g. anthropic:claude-sonnet-4-5). See
+https://ai.pydantic.dev/models/. Set your provider API key in APE_API_KEY: Ape
+infers the provider from the model name and passes this key straight to it, so
+you don't have to set a provider's standard variable (e.g. OPENAI_API_KEY) that
+other tools on your system also read.
 
 The sampling temperature is read from APE_TEMPERATURE (default {temperature}). Set
 it to "undefined" to send no temperature at all, which some models require.
 
 Run `ape-system-info` to print the detected system context sent to the model.\
-""".format(default=DEFAULT_MODEL, temperature=DEFAULT_TEMPERATURE)
+""".format(temperature=DEFAULT_TEMPERATURE)
 
 
 class Command(BaseModel):
@@ -48,14 +53,39 @@ class CannotHelp(BaseModel):
     reason: str
 
 
+def build_provider(provider_name: str, api_key: str) -> Provider[Any]:
+    """Construct the Pydantic AI provider named by ``provider_name`` with ``api_key``.
+
+    Used (with the key bound via ``functools.partial``) as the ``provider_factory`` for
+    ``infer_model`` so Ape injects its own ``APE_API_KEY`` straight into the provider
+    rather than letting Pydantic AI read the provider's standard credential env var.
+    This stays provider-agnostic: any provider whose class accepts an ``api_key`` works
+    without provider-specific code. A provider that lacks an ``api_key`` parameter
+    raises at call time (surfaced as a one-line error), which is correct — APE_API_KEY
+    only fits key-based providers.
+    """
+    # infer_provider_class returns the abstract base type[Provider], whose __init__
+    # takes no arguments; the concrete `api_key` parameter lives on each subclass and
+    # is lost through the return type. Both ty and pyright reject the call without this
+    # cast to a callable that accepts it (unlike the output_type cast below, which is a
+    # ty-only workaround).
+    provider_class = cast(
+        Callable[..., Provider[Any]], infer_provider_class(provider_name)
+    )
+    return provider_class(api_key=api_key)
+
+
 def call_llm(
     model: str,
+    api_key: str,
     system_prompt: str,
     user_prompt: str,
     model_settings: ModelSettings | None,
 ) -> Command | CannotHelp:
     agent = Agent(
-        model,
+        # infer_model parses the provider from the `provider:name` prefix;
+        # build_provider (with the key bound) constructs it with our APE_API_KEY.
+        infer_model(model, provider_factory=partial(build_provider, api_key=api_key)),
         system_prompt=system_prompt,
         output_type=Command | CannotHelp,
         # None means no settings are sent (see resolve_model_settings), so the model
@@ -68,6 +98,27 @@ def call_llm(
     return cast(Command | CannotHelp, agent.run_sync(user_prompt).output)
 
 
+def resolve_model() -> str:
+    """Resolve the model from the APE_MODEL environment variable.
+
+    The model is required and given in ``provider:name`` form (e.g.
+    ``anthropic:claude-sonnet-4-5``); Ape has no built-in default, so that the
+    provider is always explicit (it also determines which API `resolve_api_key`'s key
+    is sent to). If unset or empty, the program exits with a one-line error before any
+    LLM call.
+    """
+    model = os.environ.get("APE_MODEL")
+    if model is None or not model.strip():
+        print(
+            "ape: APE_MODEL is not set. Set it to a model in provider:name form, "
+            "e.g. anthropic:claude-sonnet-4-5 (run `ape` with no arguments for "
+            "details).",
+            file=sys.stderr,
+        )
+        raise SystemExit(1)
+    return model
+
+
 def resolve_model_settings() -> ModelSettings | None:
     """Resolve model settings from the APE_TEMPERATURE environment variable.
 
@@ -94,6 +145,26 @@ def resolve_model_settings() -> ModelSettings | None:
         raise SystemExit(1)
 
 
+def resolve_api_key() -> str:
+    """Resolve the provider API key from the APE_API_KEY environment variable.
+
+    Ape reads its own ``APE_API_KEY`` rather than each provider's standard variable
+    (e.g. ``OPENAI_API_KEY``) so that configuring Ape doesn't force a globally named
+    key that other tools on the system also pick up. The key is passed straight to the
+    provider inferred from the model name (see ``call_llm``). If it is unset or empty,
+    the program exits with a one-line error before any LLM call.
+    """
+    api_key = os.environ.get("APE_API_KEY")
+    if api_key is None or not api_key.strip():
+        print(
+            "ape: APE_API_KEY is not set. Set it to your provider API key "
+            "(run `ape` with no arguments for details).",
+            file=sys.stderr,
+        )
+        raise SystemExit(1)
+    return api_key
+
+
 def detect_system_context() -> str:
     """Best-effort description of the current system for the LLM.
 
@@ -240,8 +311,13 @@ def main() -> None:
         raise SystemExit(1)
     query = " ".join(args)
 
-    # The model is read from APE_MODEL, falling back to the default.
-    model = os.environ.get("APE_MODEL") or DEFAULT_MODEL
+    # The model is read from APE_MODEL (see resolve_model); a missing model exits
+    # here before any LLM call.
+    model = resolve_model()
+
+    # The API key is read from APE_API_KEY (see resolve_api_key); a missing key
+    # exits here before any LLM call.
+    api_key = resolve_api_key()
 
     # The sampling temperature is read from APE_TEMPERATURE (see
     # resolve_model_settings); an invalid value exits here before any LLM call.
@@ -300,7 +376,7 @@ def main() -> None:
     Answer:"""
 
     try:
-        result = call_llm(model, system_prompt, user_prompt, model_settings)
+        result = call_llm(model, api_key, system_prompt, user_prompt, model_settings)
     except ModelHTTPError as error:
         print(f"{error.status_code} error: {error.message}", file=sys.stderr)
         raise SystemExit(1)

{ape_linux-0.4.6 → ape_linux-0.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ape-linux"
-version = "0.4.6"
+version = "0.5.0"
 description = "AI for Linux commands"
 readme = "README.md"
 license = {text = "MIT License"}

{ape_linux-0.4.6 → ape_linux-0.5.0}/tests/test_app.py

@@ -5,13 +5,15 @@ import socket
 
 import pytest
 from pydantic_ai.exceptions import ModelHTTPError
+from pydantic_ai.models.test import TestModel
 
 import ape_linux
 
 
 @pytest.fixture
 def mockenv(monkeypatch):
-    monkeypatch.setenv("OPENAI_API_KEY", "key")
+    monkeypatch.setenv("APE_API_KEY", "key")
+    monkeypatch.setenv("APE_MODEL", "openai:gpt-4.1")
 
 
 def run(monkeypatch, argv):
@@ -42,7 +44,7 @@ def test_app_for_suggestion(mockenv, monkeypatch, capsys):
 def test_app_joins_multiple_args_into_query(mockenv, monkeypatch, capsys):
     captured_prompt = {}
 
-    def mockreturn(model, system_prompt, user_prompt, model_settings):
+    def mockreturn(model, api_key, system_prompt, user_prompt, model_settings):
         captured_prompt["user"] = user_prompt
         return ape_linux.Command(command="ls")
 
@@ -76,9 +78,7 @@ def test_app_reports_when_model_cannot_help(mockenv, monkeypatch, capsys):
 
 def test_app_with_api_error(mockenv, monkeypatch, capsys):
     def mockreturn(*args, **kwargs):
-        raise ModelHTTPError(
-            status_code=500, model_name="openai-chat:gpt-4o", body=None
-        )
+        raise ModelHTTPError(status_code=500, model_name="openai:gpt-4o", body=None)
 
     monkeypatch.setattr("ape_linux.call_llm", mockreturn)
     code = run(monkeypatch, ["list all the files"])
@@ -87,30 +87,91 @@ def test_app_with_api_error(mockenv, monkeypatch, capsys):
     assert code == 1
 
 
+def test_app_with_unexpected_error(mockenv, monkeypatch, capsys):
+    # A non-HTTP error (bad credentials, unknown provider, ...) is flattened to a
+    # one-line stderr message and exits 1, rather than surfacing a traceback.
+    def mockreturn(*args, **kwargs):
+        raise RuntimeError("something broke")
+
+    monkeypatch.setattr("ape_linux.call_llm", mockreturn)
+    code = run(monkeypatch, ["list all the files"])
+    captured = capsys.readouterr()
+    assert captured.out == ""
+    assert "something broke" in captured.err
+    assert code == 1
+
+
 def test_app_with_no_api_key(mockenv, monkeypatch, capsys):
-    monkeypatch.delenv("OPENAI_API_KEY")
+    # With APE_API_KEY unset (but APE_MODEL present via mockenv), ape must exit
+    # before ever reaching the LLM.
+    monkeypatch.delenv("APE_API_KEY", raising=False)
+    monkeypatch.setattr(
+        "ape_linux.call_llm",
+        lambda *args, **kwargs: pytest.fail("call_llm should not be called"),
+    )
     code = run(monkeypatch, ["list all the files"])
     captured = capsys.readouterr()
     assert captured.out == ""
-    assert captured.err != ""
+    assert "APE_API_KEY" in captured.err
     assert code == 1
 
 
-def test_app_uses_default_model_when_unset(mockenv, monkeypatch):
+def test_app_with_blank_api_key(mockenv, monkeypatch, capsys):
+    # A whitespace-only APE_API_KEY is treated as unset: exit before the LLM.
+    monkeypatch.setenv("APE_API_KEY", "   ")
+    monkeypatch.setattr(
+        "ape_linux.call_llm",
+        lambda *args, **kwargs: pytest.fail("call_llm should not be called"),
+    )
+    code = run(monkeypatch, ["list all the files"])
+    captured = capsys.readouterr()
+    assert captured.out == ""
+    assert "APE_API_KEY" in captured.err
+    assert code == 1
+
+
+def test_app_passes_api_key_to_call_llm(mockenv, monkeypatch):
     captured = {}
 
-    def mockreturn(model, *args, **kwargs):
-        captured["model"] = model
+    def mockreturn(model, api_key, *args, **kwargs):
+        captured["api_key"] = api_key
         return ape_linux.Command(command="ls")
 
-    monkeypatch.delenv("APE_MODEL", raising=False)
+    monkeypatch.setenv("APE_API_KEY", "secret-key")
     monkeypatch.setattr("ape_linux.call_llm", mockreturn)
     code = run(monkeypatch, ["list all the files"])
-    assert captured["model"] == ape_linux.DEFAULT_MODEL
-    assert ape_linux.DEFAULT_MODEL == "openai-chat:gpt-4.1"
+    assert captured["api_key"] == "secret-key"
     assert code == 0
 
 
+def test_app_with_no_model(mockenv, monkeypatch, capsys):
+    # With APE_MODEL unset, ape must exit before ever reaching the LLM.
+    monkeypatch.delenv("APE_MODEL", raising=False)
+    monkeypatch.setattr(
+        "ape_linux.call_llm",
+        lambda *args, **kwargs: pytest.fail("call_llm should not be called"),
+    )
+    code = run(monkeypatch, ["list all the files"])
+    captured = capsys.readouterr()
+    assert captured.out == ""
+    assert "APE_MODEL" in captured.err
+    assert code == 1
+
+
+def test_app_with_blank_model(mockenv, monkeypatch, capsys):
+    # A whitespace-only APE_MODEL is treated as unset: exit before the LLM.
+    monkeypatch.setenv("APE_MODEL", "   ")
+    monkeypatch.setattr(
+        "ape_linux.call_llm",
+        lambda *args, **kwargs: pytest.fail("call_llm should not be called"),
+    )
+    code = run(monkeypatch, ["list all the files"])
+    captured = capsys.readouterr()
+    assert captured.out == ""
+    assert "APE_MODEL" in captured.err
+    assert code == 1
+
+
 def test_app_uses_ape_model_env_var(mockenv, monkeypatch):
     captured = {}
 
@@ -128,7 +189,7 @@ def test_app_uses_ape_model_env_var(mockenv, monkeypatch):
 def test_app_uses_default_temperature_when_unset(mockenv, monkeypatch):
     captured = {}
 
-    def mockreturn(model, system_prompt, user_prompt, model_settings):
+    def mockreturn(model, api_key, system_prompt, user_prompt, model_settings):
         captured["settings"] = model_settings
         return ape_linux.Command(command="ls")
 
@@ -143,7 +204,7 @@ def test_app_uses_default_temperature_when_unset(mockenv, monkeypatch):
 def test_app_uses_ape_temperature_env_var(mockenv, monkeypatch):
     captured = {}
 
-    def mockreturn(model, system_prompt, user_prompt, model_settings):
+    def mockreturn(model, api_key, system_prompt, user_prompt, model_settings):
         captured["settings"] = model_settings
         return ape_linux.Command(command="ls")
 
@@ -157,7 +218,7 @@ def test_app_uses_ape_temperature_env_var(mockenv, monkeypatch):
 def test_app_undefined_temperature_sends_no_settings(mockenv, monkeypatch):
     captured = {}
 
-    def mockreturn(model, system_prompt, user_prompt, model_settings):
+    def mockreturn(model, api_key, system_prompt, user_prompt, model_settings):
         captured["settings"] = model_settings
         return ape_linux.Command(command="ls")
 
@@ -183,6 +244,43 @@ def test_app_invalid_temperature_exits_before_llm(mockenv, monkeypatch, capsys):
     assert code == 1
 
 
+def test_call_llm_returns_structured_output(monkeypatch):
+    # Exercise the real call_llm (normally mocked) without a network call by swapping in
+    # Pydantic AI's TestModel, which drives the agent and yields structured output
+    # offline. This covers the infer_model/Agent wiring and the output cast.
+    monkeypatch.setattr(
+        "ape_linux.infer_model", lambda model, provider_factory: TestModel()
+    )
+    result = ape_linux.call_llm(
+        "openai:gpt-4.1", "key", "system", "user", {"temperature": 0.2}
+    )
+    assert isinstance(result, ape_linux.Command)
+    assert isinstance(result.command, str)
+
+
+def test_build_provider_injects_key_without_standard_env_var(monkeypatch):
+    # build_provider constructs the inferred provider with our key injected directly,
+    # so the provider's standard credential variable is neither needed nor read.
+    # Constructing a provider is offline — no request is made until the agent runs.
+    monkeypatch.delenv("OPENAI_API_KEY", raising=False)
+    monkeypatch.delenv("ANTHROPIC_API_KEY", raising=False)
+
+    openai_provider = ape_linux.build_provider("openai", "injected-key")
+    assert openai_provider.name == "openai"
+    assert openai_provider.client.api_key == "injected-key"
+
+    anthropic_provider = ape_linux.build_provider("anthropic", "another-key")
+    assert anthropic_provider.name == "anthropic"
+    assert anthropic_provider.client.api_key == "another-key"
+
+
+def test_build_provider_unknown_provider_raises():
+    # An unrecognized provider name surfaces as ValueError (which main() flattens to a
+    # one-line error), rather than silently building the wrong provider.
+    with pytest.raises(ValueError):
+        ape_linux.build_provider("not-a-real-provider", "key")
+
+
 def test_system_info_entry_point(capsys):
     ape_linux.system_info()
     captured = capsys.readouterr()
@@ -223,6 +321,40 @@ def test_detect_system_context_reports_operating_system():
     assert "Operating system:" in context
 
 
+def test_detect_system_context_reports_distribution(monkeypatch):
+    # On Linux, the distribution name from os-release is reported.
+    monkeypatch.setattr(ape_linux.platform, "system", lambda: "Linux")
+    monkeypatch.setattr(
+        ape_linux.platform,
+        "freedesktop_os_release",
+        lambda: {"PRETTY_NAME": "Ubuntu 22.04.3 LTS"},
+    )
+    context = ape_linux.detect_system_context()
+    assert "Distribution: Ubuntu 22.04.3 LTS" in context
+
+
+def test_detect_system_context_never_raises_when_probe_fails(monkeypatch):
+    # The "never raises" invariant: when a probe raises, that field is omitted and the
+    # function still returns a string rather than crashing at startup.
+    monkeypatch.setattr(ape_linux.platform, "system", lambda: "Darwin")
+
+    def boom(*args, **kwargs):
+        raise OSError("probe failed")
+
+    monkeypatch.setattr(ape_linux.platform, "mac_ver", boom)
+    context = ape_linux.detect_system_context()
+    assert isinstance(context, str)
+    assert "macOS version:" not in context
+
+
+def test_detect_system_context_reports_root_privileges(monkeypatch):
+    # The root branch changes the guidance (sudo not required); its non-root twin is
+    # covered by the real host running these tests unprivileged.
+    monkeypatch.setattr(ape_linux.os, "geteuid", lambda: 0)
+    context = ape_linux.detect_system_context()
+    assert "Privileges: root (sudo not required)" in context
+
+
 def test_detect_system_context_excludes_identifying_info():
     context = ape_linux.detect_system_context()
 

{ape_linux-0.4.6 → ape_linux-0.5.0}/uv.lock

@@ -50,7 +50,7 @@ wheels = [
 
 [[package]]
 name = "ape-linux"
-version = "0.4.6"
+version = "0.5.0"
 source = { editable = "." }
 dependencies = [
     { name = "pydantic" },