agent-first-data 0.20.0__tar.gz → 0.22.0__tar.gz

{agent_first_data-0.20.0 → agent_first_data-0.22.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-first-data
-Version: 0.20.0
+Version: 0.22.0
 Summary: A naming convention that lets AI agents understand your data without being told what it means, plus a CLI and library for reading and safely editing structured JSON, TOML, YAML, dotenv, and INI documents.
 License-Expression: MIT
 Project-URL: Repository, https://github.com/agentfirstkit/agent-first-data
@@ -28,15 +28,7 @@ print(render(value, OutputFormat.JSON))
 print(render(value, OutputFormat.PLAIN))
 ```
 
-Useful names use Python casing: `render` (the single value x format x options -> str entry point; takes an `OutputFormat` and an optional keyword-only `options=`), `redacted_value`, `redact_url_secrets`, `normalize_utc_offset`, `is_valid_rfc3339_date`, `is_valid_rfc3339_time`, `is_valid_rfc3339`, `is_valid_bcp47`, `cli_parse_output`, `build_cli_error`, `build_cli_version`, `cli_handle_version_or_continue`, `decode_protocol_event`. Skill admin and stream-redirect helpers live in `agent_first_data.skill` and `agent_first_data.stream_redirect` (import the submodule directly).
-
-Logging is available through `init_logging_json`, `init_logging_plain`, `init_logging_yaml`, `span`, and `get_logger`.
-
-```python
-from agent_first_data import init_logging_json
-
-init_logging_json("INFO", secret_names=("authorization",))
-```
+Useful names use Python casing: `render` (the single value x format x options -> str entry point; takes an `OutputFormat` and an optional keyword-only `options=`), `redacted_value`, `redact_url_secrets`, `normalize_utc_offset`, `is_valid_rfc3339_date`, `is_valid_rfc3339_time`, `is_valid_rfc3339`, `is_valid_bcp47`, `cli_parse_output`, `build_cli_error`, `build_cli_version`, `cli_handle_version_or_continue`, `decode_protocol_event`.
 
 ## Behavior Notes
 
@@ -45,12 +37,10 @@ init_logging_json("INFO", secret_names=("authorization",))
 - YAML keeps original keys and values (structure-preserving, like JSON), sorting keys by UTF-16 code unit order and quoting/escaping unsafe keys and string scalars. Plain strips formatting suffixes, formats values, sorts the same way, and renders nested objects/arrays as canonical JSON.
 - Logging records use `kind:"log"` with a nested `log` payload and a separate `level` field, so error-level logs are not terminal protocol errors.
 - `build_cli_error(message, hint?)` returns a strict-ready CLI error with `error.retryable:false` and `trace:{}`.
-- Use `cli_handle_version_or_continue()` before argument parsing so bare `--version` stays conventional and `--version --output json|yaml|plain` stays structured.
-- Use `agent_first_data.stream_redirect.install_from_raw_args()` before version/help handling if a CLI exposes `--stdout-file` or `--stderr-file`; stderr is redirected as native diagnostics, not JSON.
+- Use `cli_handle_version_or_continue()` before argument parsing so `--version`/`-V` always answers with a structured protocol-v1 `kind:"result"` version event — JSON by default, or `--output yaml|plain`/`--json` for another format; there is no conventional bare-text form. Pass your own value-taking global flag names so their value is not mistaken for the subcommand boundary.
 
 ## Reference
 
-- Full convention and API groups: [docs/overview.md](https://github.com/agentfirstkit/agent-first-data/blob/main/docs/overview.md)
 - Formal cross-language contract: [spec/agent-first-data.md](https://github.com/agentfirstkit/agent-first-data/blob/main/spec/agent-first-data.md)
 - Conformance fixtures: [spec/fixtures](https://github.com/agentfirstkit/agent-first-data/tree/main/spec/fixtures)
 - Agent skill: [skills/agent-first-data/SKILL.md](https://github.com/agentfirstkit/agent-first-data/blob/main/skills/agent-first-data/SKILL.md)

{agent_first_data-0.20.0 → agent_first_data-0.22.0}/README.md

@@ -19,15 +19,7 @@ print(render(value, OutputFormat.JSON))
 print(render(value, OutputFormat.PLAIN))
 ```
 
-Useful names use Python casing: `render` (the single value x format x options -> str entry point; takes an `OutputFormat` and an optional keyword-only `options=`), `redacted_value`, `redact_url_secrets`, `normalize_utc_offset`, `is_valid_rfc3339_date`, `is_valid_rfc3339_time`, `is_valid_rfc3339`, `is_valid_bcp47`, `cli_parse_output`, `build_cli_error`, `build_cli_version`, `cli_handle_version_or_continue`, `decode_protocol_event`. Skill admin and stream-redirect helpers live in `agent_first_data.skill` and `agent_first_data.stream_redirect` (import the submodule directly).
-
-Logging is available through `init_logging_json`, `init_logging_plain`, `init_logging_yaml`, `span`, and `get_logger`.
-
-```python
-from agent_first_data import init_logging_json
-
-init_logging_json("INFO", secret_names=("authorization",))
-```
+Useful names use Python casing: `render` (the single value x format x options -> str entry point; takes an `OutputFormat` and an optional keyword-only `options=`), `redacted_value`, `redact_url_secrets`, `normalize_utc_offset`, `is_valid_rfc3339_date`, `is_valid_rfc3339_time`, `is_valid_rfc3339`, `is_valid_bcp47`, `cli_parse_output`, `build_cli_error`, `build_cli_version`, `cli_handle_version_or_continue`, `decode_protocol_event`.
 
 ## Behavior Notes
 
@@ -36,12 +28,10 @@ init_logging_json("INFO", secret_names=("authorization",))
 - YAML keeps original keys and values (structure-preserving, like JSON), sorting keys by UTF-16 code unit order and quoting/escaping unsafe keys and string scalars. Plain strips formatting suffixes, formats values, sorts the same way, and renders nested objects/arrays as canonical JSON.
 - Logging records use `kind:"log"` with a nested `log` payload and a separate `level` field, so error-level logs are not terminal protocol errors.
 - `build_cli_error(message, hint?)` returns a strict-ready CLI error with `error.retryable:false` and `trace:{}`.
-- Use `cli_handle_version_or_continue()` before argument parsing so bare `--version` stays conventional and `--version --output json|yaml|plain` stays structured.
-- Use `agent_first_data.stream_redirect.install_from_raw_args()` before version/help handling if a CLI exposes `--stdout-file` or `--stderr-file`; stderr is redirected as native diagnostics, not JSON.
+- Use `cli_handle_version_or_continue()` before argument parsing so `--version`/`-V` always answers with a structured protocol-v1 `kind:"result"` version event — JSON by default, or `--output yaml|plain`/`--json` for another format; there is no conventional bare-text form. Pass your own value-taking global flag names so their value is not mistaken for the subcommand boundary.
 
 ## Reference
 
-- Full convention and API groups: [docs/overview.md](https://github.com/agentfirstkit/agent-first-data/blob/main/docs/overview.md)
 - Formal cross-language contract: [spec/agent-first-data.md](https://github.com/agentfirstkit/agent-first-data/blob/main/spec/agent-first-data.md)
 - Conformance fixtures: [spec/fixtures](https://github.com/agentfirstkit/agent-first-data/tree/main/spec/fixtures)
 - Agent skill: [skills/agent-first-data/SKILL.md](https://github.com/agentfirstkit/agent-first-data/blob/main/skills/agent-first-data/SKILL.md)

{agent_first_data-0.20.0 → agent_first_data-0.22.0}/agent_first_data/cli.py

@@ -385,39 +385,84 @@ class CliEmitter:
         return self.finish(json_result(payload).build(), 0)
 
 
-def build_cli_version(version: str) -> dict:
+def _split_flag(arg: str) -> tuple[str | None, str | None]:
+    """Split a flag token into its long name and optional inline ``=value``.
+
+    Mirrors the Rust pre-parser: leading dashes are stripped from the name and a
+    bare ``-`` (or an empty name) yields ``(None, None)``. ``--flag`` →
+    ``("flag", None)``; ``--flag=x`` → ``("flag", "x")`` (``x`` may be ``""``).
+    """
+    if not arg.startswith("-") or arg == "-":
+        return (None, None)
+    flag, sep, value = arg.partition("=")
+    name = flag.lstrip("-")
+    if not name:
+        return (None, None)
+    if sep:
+        return (name, value)
+    return (name, None)
+
+
+def build_cli_version(
+    name: str,
+    display_name: str | None,
+    version: str,
+    build: str | None,
+) -> dict:
     """Build a standard CLI version result event.
 
-    The result payload always carries ``code: "version"`` alongside
-    ``version``, so structured consumers can dispatch on ``code`` the same
-    way they would for any other result shape.
+    The result payload always carries ``code: "version"`` alongside ``name`` and
+    ``version``, so structured consumers can dispatch on ``code`` the same way
+    they would for any other result shape. ``name`` is the short/bin identity
+    (e.g. ``"afdata"``); ``display_name`` is an optional human-facing product
+    name (e.g. ``"Agent-First Data"``); ``build`` is an opaque caller-supplied
+    identifier (a git commit SHA, for example) — its meaning is entirely up to
+    the caller. Both ``display_name`` and ``build`` are ``None`` when
+    unavailable, and simply absent from the payload.
     """
-    return json_result({"code": "version", "version": version}).build().to_dict()
+    payload: dict[str, Any] = {"code": "version", "name": name, "version": version}
+    if display_name is not None:
+        payload["display_name"] = display_name
+    if build is not None:
+        payload["build"] = build
+    return json_result(payload).build().to_dict()
 
 
 def cli_render_version(
     name: str,
+    display_name: str | None,
     version: str,
-    format: OutputFormat | None = None,
+    build: str | None,
+    format: OutputFormat,
 ) -> str:
-    """Render CLI version output.
+    """Render a CLI version response as a protocol-v1 event in ``format``.
 
-    Pass an OutputFormat for AFDATA JSON/YAML/plain. Pass None to preserve
-    conventional "<name> <version>" text.
+    There is no conventional ``"<name> <version>"`` path: ``--version`` always
+    answers with the structured event (see :func:`build_cli_version`).
     """
-    rendered = (
-        f"{name} {version}" if format is None else render(build_cli_version(version), format)
-    )
+    rendered = render(build_cli_version(name, display_name, version, build), format)
     return rendered.rstrip("\n") + "\n"
 
 
-def cli_handle_version_or_continue(raw_args: list[str], name: str, version: str) -> str | None:
+def cli_handle_version_or_continue(
+    raw_args: list[str],
+    value_flags: list[str],
+    name: str,
+    display_name: str | None,
+    version: str,
+    build: str | None,
+) -> str | None:
     """Render version output if --version/-V is present; otherwise return None.
 
-    One blessed behavior, no configurable knobs: a bare version request
-    (``--version``/``-V`` with no output flag) always renders conventional
-    ``"<name> <version>\\n"`` text; adding ``--json`` or ``--output
-    <json|yaml|plain>`` selects the structured AFDATA rendering instead.
+    ``raw_args`` is ``sys.argv[1:]`` (no program name); scanning starts at index
+    0. ``value_flags`` names the caller's own value-taking global flags (with or
+    without leading dashes) so their value is never mistaken for the subcommand
+    boundary — the Python stand-in for Rust's ``&clap::Command`` lookup.
+
+    The one blessed behavior: ``--version``/``-V`` always answers with a
+    protocol-v1 ``kind:"result"`` version event (see :func:`build_cli_version`) —
+    JSON by default, or ``--json`` / ``--output <json|yaml|plain>`` to select
+    another format.
 
     Only a top-level version request is recognized: scanning stops at the first
     positional argument (the subcommand), so ``tool sub --version <value>``
@@ -428,6 +473,7 @@ def cli_handle_version_or_continue(raw_args: list[str], name: str, version: str)
     ``--version --output xml``. The caller should convert that to a CLI error
     with ``build_cli_error``.
     """
+    value_flag_names = {vf.lstrip("-") for vf in value_flags}
     version_requested = False
     output_format: OutputFormat | None = None
     output_error: ValueError | None = None
@@ -442,6 +488,8 @@ def cli_handle_version_or_continue(raw_args: list[str], name: str, version: str)
         # git/cargo/clap: this pre-parser only owns a top-level version request.
         if not arg.startswith("-"):
             break
+
+        flag_name, inline_value = _split_flag(arg)
         if arg in ("--version", "-V"):
             version_requested = True
             i += 1
@@ -455,17 +503,25 @@ def cli_handle_version_or_continue(raw_args: list[str], name: str, version: str)
                 output_format = OutputFormat.JSON
             i += 1
             continue
-        if arg == "--output" or arg.startswith("--output="):
+        # `--output-to` takes a value but does not affect version output. Consume
+        # its space-separated value so it is not mistaken for the subcommand
+        # boundary (which would hide a later `--version`/`--output`).
+        if flag_name == "output-to":
+            has_space_value = (
+                inline_value is None
+                and i + 1 < len(raw_args)
+                and not raw_args[i + 1].startswith("-")
+            )
+            i += 2 if has_space_value else 1
+            continue
+        if flag_name == "output":
             value: str | None
-            if arg.startswith("--output="):
-                value = arg.split("=", 1)[1]
-                step = 1
+            if inline_value is not None:
+                value = inline_value
             elif i + 1 < len(raw_args) and not raw_args[i + 1].startswith("-"):
                 value = raw_args[i + 1]
-                step = 2
             else:
                 value = None
-                step = 1
             if value is None:
                 output_error = ValueError(
                     "missing value for --output: expected json, yaml, or plain"
@@ -481,15 +537,31 @@ def cli_handle_version_or_continue(raw_args: list[str], name: str, version: str)
                         output_format = parsed_output
                 except ValueError as e:
                     output_error = e
-            i += step
+            i += 1 if (inline_value is not None or value is None) else 2
             continue
-        i += 1
+
+        # Any other flag: consume a space-separated value only if the caller
+        # listed this flag as value-taking, there is no inline `=value`, and the
+        # next arg exists and doesn't start with `-`. Otherwise it is a boolean
+        # flag and consumes only itself.
+        has_space_value = (
+            inline_value is None
+            and i + 1 < len(raw_args)
+            and not raw_args[i + 1].startswith("-")
+        )
+        i += 2 if (has_space_value and flag_name in value_flag_names) else 1
 
     if not version_requested:
         return None
     if output_error is not None:
         raise output_error
-    return cli_render_version(name, version, output_format)
+    return cli_render_version(
+        name,
+        display_name,
+        version,
+        build,
+        output_format if output_format is not None else OutputFormat.JSON,
+    )
 
 
 def build_cli_error(message: str, hint: str | None = None) -> dict | Event:

{agent_first_data-0.20.0 → agent_first_data-0.22.0}/agent_first_data.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-first-data
-Version: 0.20.0
+Version: 0.22.0
 Summary: A naming convention that lets AI agents understand your data without being told what it means, plus a CLI and library for reading and safely editing structured JSON, TOML, YAML, dotenv, and INI documents.
 License-Expression: MIT
 Project-URL: Repository, https://github.com/agentfirstkit/agent-first-data
@@ -28,15 +28,7 @@ print(render(value, OutputFormat.JSON))
 print(render(value, OutputFormat.PLAIN))
 ```
 
-Useful names use Python casing: `render` (the single value x format x options -> str entry point; takes an `OutputFormat` and an optional keyword-only `options=`), `redacted_value`, `redact_url_secrets`, `normalize_utc_offset`, `is_valid_rfc3339_date`, `is_valid_rfc3339_time`, `is_valid_rfc3339`, `is_valid_bcp47`, `cli_parse_output`, `build_cli_error`, `build_cli_version`, `cli_handle_version_or_continue`, `decode_protocol_event`. Skill admin and stream-redirect helpers live in `agent_first_data.skill` and `agent_first_data.stream_redirect` (import the submodule directly).
-
-Logging is available through `init_logging_json`, `init_logging_plain`, `init_logging_yaml`, `span`, and `get_logger`.
-
-```python
-from agent_first_data import init_logging_json
-
-init_logging_json("INFO", secret_names=("authorization",))
-```
+Useful names use Python casing: `render` (the single value x format x options -> str entry point; takes an `OutputFormat` and an optional keyword-only `options=`), `redacted_value`, `redact_url_secrets`, `normalize_utc_offset`, `is_valid_rfc3339_date`, `is_valid_rfc3339_time`, `is_valid_rfc3339`, `is_valid_bcp47`, `cli_parse_output`, `build_cli_error`, `build_cli_version`, `cli_handle_version_or_continue`, `decode_protocol_event`.
 
 ## Behavior Notes
 
@@ -45,12 +37,10 @@ init_logging_json("INFO", secret_names=("authorization",))
 - YAML keeps original keys and values (structure-preserving, like JSON), sorting keys by UTF-16 code unit order and quoting/escaping unsafe keys and string scalars. Plain strips formatting suffixes, formats values, sorts the same way, and renders nested objects/arrays as canonical JSON.
 - Logging records use `kind:"log"` with a nested `log` payload and a separate `level` field, so error-level logs are not terminal protocol errors.
 - `build_cli_error(message, hint?)` returns a strict-ready CLI error with `error.retryable:false` and `trace:{}`.
-- Use `cli_handle_version_or_continue()` before argument parsing so bare `--version` stays conventional and `--version --output json|yaml|plain` stays structured.
-- Use `agent_first_data.stream_redirect.install_from_raw_args()` before version/help handling if a CLI exposes `--stdout-file` or `--stderr-file`; stderr is redirected as native diagnostics, not JSON.
+- Use `cli_handle_version_or_continue()` before argument parsing so `--version`/`-V` always answers with a structured protocol-v1 `kind:"result"` version event — JSON by default, or `--output yaml|plain`/`--json` for another format; there is no conventional bare-text form. Pass your own value-taking global flag names so their value is not mistaken for the subcommand boundary.
 
 ## Reference
 
-- Full convention and API groups: [docs/overview.md](https://github.com/agentfirstkit/agent-first-data/blob/main/docs/overview.md)
 - Formal cross-language contract: [spec/agent-first-data.md](https://github.com/agentfirstkit/agent-first-data/blob/main/spec/agent-first-data.md)
 - Conformance fixtures: [spec/fixtures](https://github.com/agentfirstkit/agent-first-data/tree/main/spec/fixtures)
 - Agent skill: [skills/agent-first-data/SKILL.md](https://github.com/agentfirstkit/agent-first-data/blob/main/skills/agent-first-data/SKILL.md)

agent_first_data-0.22.0/agent_first_data.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+pyproject.toml
+agent_first_data/__init__.py
+agent_first_data/cli.py
+agent_first_data/format.py
+agent_first_data.egg-info/PKG-INFO
+agent_first_data.egg-info/SOURCES.txt
+agent_first_data.egg-info/dependency_links.txt
+agent_first_data.egg-info/top_level.txt
+agent_first_data/assets/protocol-v1.schema.json
+agent_first_data/assets/registry.json
+tests/test_cli.py
+tests/test_format.py
+tests/test_no_stderr_policy.py

{agent_first_data-0.20.0 → agent_first_data-0.22.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agent-first-data"
-version = "0.20.0"
+version = "0.22.0"
 description = "A naming convention that lets AI agents understand your data without being told what it means, plus a CLI and library for reading and safely editing structured JSON, TOML, YAML, dotenv, and INI documents."
 license = "MIT"
 readme = "README.md"
@@ -17,7 +17,4 @@ build-backend = "setuptools.build_meta"
 [tool.setuptools.package-data]
 agent_first_data = [
   "assets/*.json",
-  "assets/skills/agent-first-data/*.md",
-  "assets/skills/agent-first-data/references/*.md",
-  "assets/skills/agent-first-data/references/*.json",
 ]

{agent_first_data-0.20.0 → agent_first_data-0.22.0}/tests/test_cli.py

@@ -484,36 +484,72 @@ def test_finish_returns_4_on_lifecycle_violation():
 
 # ── version helpers ───────────────────────────────────────────────────────────
 
+# The value-taking global flags a caller passes through so their space-separated
+# value is not mistaken for the subcommand boundary (the Python stand-in for the
+# Rust tests' `version_test_command()` with its `--stdout-file`/`--stderr-file`).
+VERSION_VALUE_FLAGS = ["--stdout-file", "--stderr-file"]
+
+
 def test_build_cli_version_standard_shape():
-    v = build_cli_version("1.2.3")
+    v = build_cli_version("agent-cli", "Agent CLI Example", "1.2.3", "abc1234")
     assert v["kind"] == "result"
     assert v["result"]["code"] == "version"
+    assert v["result"]["name"] == "agent-cli"
+    assert v["result"]["display_name"] == "Agent CLI Example"
     assert v["result"]["version"] == "1.2.3"
+    assert v["result"]["build"] == "abc1234"
     # 0.16 spec: all events have trace by default
     assert v["trace"] == {}
 
 
-def test_cli_render_version_is_conventional_by_default():
-    assert cli_render_version("agent-cli", "1.2.3") == "agent-cli 1.2.3\n"
+def test_build_cli_version_omits_absent_display_name_and_build():
+    v = build_cli_version("agent-cli", None, "1.2.3", None)
+    result = v["result"]
+    assert result["name"] == "agent-cli"
+    assert result["version"] == "1.2.3"
+    assert "display_name" not in result
+    assert "build" not in result
 
 
-def test_cli_render_version_can_render_json():
-    out = cli_render_version("agent-cli", "1.2.3", OutputFormat.JSON)
+def test_cli_render_version_renders_json():
+    out = cli_render_version("agent-cli", None, "1.2.3", None, OutputFormat.JSON)
     assert out.endswith("\n")
     assert '"kind":"result"' in out
     assert '"code":"version"' in out
+    assert '"name":"agent-cli"' in out
     assert '"version":"1.2.3"' in out
 
 
-def test_cli_handle_version_is_conventional_by_default():
-    assert cli_handle_version_or_continue(["--version"], "agent-cli", "1.2.3") == "agent-cli 1.2.3\n"
+def test_cli_handle_version_bare_defaults_to_json():
+    # The one blessed behavior: `--version` always answers with a protocol-v1
+    # event, JSON by default — no more conventional bare-text special case.
+    out = cli_handle_version_or_continue(
+        ["--version"],
+        VERSION_VALUE_FLAGS,
+        "agent-cli",
+        "Agent CLI Example",
+        "1.2.3",
+        None,
+    )
+    assert out is not None
+    parsed = json.loads(out.strip())
+    assert parsed["kind"] == "result"
+    assert parsed["result"]["code"] == "version"
+    assert parsed["result"]["name"] == "agent-cli"
+    assert parsed["result"]["display_name"] == "Agent CLI Example"
+    assert parsed["result"]["version"] == "1.2.3"
+    assert "build" not in parsed["result"]
+    assert parsed["trace"] == {}
 
 
-def test_cli_handle_version_honors_output_flag():
+def test_cli_handle_version_honors_explicit_plain_output():
     out = cli_handle_version_or_continue(
         ["--version", "--output", "plain"],
+        VERSION_VALUE_FLAGS,
         "agent-cli",
+        None,
         "1.2.3",
+        None,
     )
     assert out is not None
     assert "kind=result" in out
@@ -521,37 +557,155 @@ def test_cli_handle_version_honors_output_flag():
     assert "result.version=1.2.3" in out
 
 
+def test_cli_handle_version_skips_output_to_space_value():
+    # A preceding `--output-to <value>` (space form) must not be mistaken for
+    # the subcommand boundary; the later `--version --output json` must still be
+    # detected.
+    out = cli_handle_version_or_continue(
+        ["--output-to", "stdout", "--version", "--output", "json"],
+        VERSION_VALUE_FLAGS,
+        "agent-cli",
+        None,
+        "1.2.3",
+        None,
+    )
+    assert out is not None
+    parsed = json.loads(out.strip())
+    assert parsed["kind"] == "result"
+    assert parsed["result"]["version"] == "1.2.3"
+
+
+def test_cli_handle_version_skips_caller_value_flag_space_value():
+    # A caller's own value-taking global flag (here `--stdout-file`/
+    # `--stderr-file`): the path value must not be mistaken for the subcommand
+    # boundary either.
+    out = cli_handle_version_or_continue(
+        ["--stdout-file", "/tmp/out.log", "--stderr-file", "/tmp/err.log", "--version"],
+        VERSION_VALUE_FLAGS,
+        "agent-cli",
+        None,
+        "1.2.3",
+        None,
+    )
+    assert out is not None
+    parsed = json.loads(out.strip())
+    assert parsed["result"]["name"] == "agent-cli"
+    assert parsed["result"]["version"] == "1.2.3"
+
+
+def test_cli_handle_version_skips_caller_value_flag_inline_value():
+    out = cli_handle_version_or_continue(
+        ["--stdout-file=/tmp/out.log", "--version"],
+        VERSION_VALUE_FLAGS,
+        "agent-cli",
+        None,
+        "1.2.3",
+        None,
+    )
+    assert out is not None
+
+
+def test_cli_handle_version_skips_caller_defined_value_flag():
+    # A consumer's *own* value-taking global flag the pre-parser has no special
+    # knowledge of — here a hypha-style comma-list `--log` — must have its
+    # space-separated value recognized through `value_flags`, not a hardcoded
+    # allowlist. Otherwise `request,startup` would be read as the subcommand
+    # boundary and `--version` dropped.
+    out = cli_handle_version_or_continue(
+        ["--log", "request,startup", "--version"],
+        ["--log"],
+        "hypha",
+        None,
+        "1.2.3",
+        None,
+    )
+    assert out is not None
+    parsed = json.loads(out.strip())
+    assert parsed["result"]["name"] == "hypha"
+    assert parsed["result"]["version"] == "1.2.3"
+
+
+def test_cli_handle_version_boolean_global_flag_does_not_over_consume():
+    # The mirror of the case above: a caller's boolean global flag (absent from
+    # value_flags) takes no value, so the following positional is the subcommand
+    # boundary and a `--version` after it belongs to the subcommand.
+    assert (
+        cli_handle_version_or_continue(
+            ["--verbose", "sense", "--version"],
+            ["--log"],
+            "hypha",
+            None,
+            "1.2.3",
+            None,
+        )
+        is None
+    )
+
+
+def test_cli_handle_version_supports_inline_output_format():
+    out = cli_handle_version_or_continue(
+        ["--output=yaml", "--version"],
+        VERSION_VALUE_FLAGS,
+        "agent-cli",
+        None,
+        "1.2.3",
+        None,
+    )
+    assert out is not None
+    assert out.startswith("---\n")
+    assert 'version: "1.2.3"' in out
+
+
 def test_cli_handle_version_json_alias():
     out = cli_handle_version_or_continue(
         ["--version", "--json"],
+        VERSION_VALUE_FLAGS,
         "agent-cli",
+        None,
         "1.2.3",
+        None,
     )
     assert out is not None
-    assert '"kind":"result"' in out
-    assert '"code":"version"' in out
-    assert '"version":"1.2.3"' in out
+    parsed = json.loads(out.strip())
+    assert parsed["kind"] == "result"
+    assert parsed["result"]["version"] == "1.2.3"
 
 
 def test_cli_handle_version_json_alias_conflict():
     with pytest.raises(ValueError, match="conflicting output formats"):
         cli_handle_version_or_continue(
             ["--version", "--json", "--output", "yaml"],
+            VERSION_VALUE_FLAGS,
             "agent-cli",
+            None,
             "1.2.3",
+            None,
         )
 
 
 def test_cli_handle_version_returns_none_without_version():
-    assert cli_handle_version_or_continue(["ping"], "agent-cli", "1.2.3") is None
+    assert (
+        cli_handle_version_or_continue(
+            ["ping"],
+            VERSION_VALUE_FLAGS,
+            "agent-cli",
+            None,
+            "1.2.3",
+            None,
+        )
+        is None
+    )
 
 
 def test_cli_handle_version_rejects_invalid_output():
     with pytest.raises(ValueError, match="xml"):
         cli_handle_version_or_continue(
             ["--version", "--output", "xml"],
+            VERSION_VALUE_FLAGS,
             "agent-cli",
+            None,
             "1.2.3",
+            None,
         )
 
 
@@ -561,16 +715,22 @@ def test_cli_handle_version_ignores_version_flag_after_subcommand():
     assert (
         cli_handle_version_or_continue(
             ["hatch", "--version", "1.3.0"],
+            VERSION_VALUE_FLAGS,
             "agent-cli",
+            None,
             "1.2.3",
+            None,
         )
         is None
     )
     assert (
         cli_handle_version_or_continue(
             ["hatch", "-V", "1.3.0"],
+            VERSION_VALUE_FLAGS,
             "agent-cli",
+            None,
             "1.2.3",
+            None,
         )
         is None
     )
@@ -581,8 +741,12 @@ def test_cli_handle_version_honors_output_flag_before_top_level_version():
     # --version is still recognized.
     out = cli_handle_version_or_continue(
         ["--output", "json", "--version"],
+        VERSION_VALUE_FLAGS,
         "agent-cli",
+        None,
         "1.2.3",
+        None,
     )
     assert out is not None
-    assert '"version":"1.2.3"' in out
+    parsed = json.loads(out.strip())
+    assert parsed["result"]["version"] == "1.2.3"

{agent_first_data-0.20.0 → agent_first_data-0.22.0}/tests/test_no_stderr_policy.py

@@ -28,8 +28,6 @@ def test_no_ad_hoc_stderr_writes_in_runtime_sources() -> None:
 
     violations: list[str] = []
     for path in files:
-        if path.name == "stream_redirect.py":
-            continue
         for lineno, line in enumerate(path.read_text(encoding="utf-8").splitlines(), start=1):
             if DISALLOWED.search(line):
                 violations.append(f"{path.name}:{lineno}: {line.strip()}")