agent-first-data 0.34.0__tar.gz → 0.35.1__tar.gz

{agent_first_data-0.34.0 → agent_first_data-0.35.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-first-data
-Version: 0.34.0
+Version: 0.35.1
 Summary: A naming convention that lets AI agents understand your data without being told what it means, plus a CLI and library for reading Markdown structure and safely editing structured JSON, TOML, YAML, dotenv, and INI documents.
 License-Expression: MIT
 Project-URL: Repository, https://github.com/agentfirstkit/agent-first-data
@@ -33,11 +33,11 @@ Useful names use Python casing: `render` (the single value x format x options ->
 ## Behavior Notes
 
 - Default redaction replaces every `_secret` or configured secret-name subtree with `***`, including objects and arrays.
-- `_url` fields scrub userinfo passwords and secret-named query parameters; surrounding whitespace is trimmed and internal whitespace redacts the whole field.
+- `_url` fields scrub userinfo passwords and secret-named query parameters; surrounding whitespace is trimmed, and internal whitespace or a `://` that is not the start of a clean URL redacts the whole field, where whitespace is the explicit Unicode `White_Space` set the spec enumerates, not the language's native predicate.
 - `OutputOptions.url_names` applies URL treatment to exact legacy field names
   and recurses through collections. `redact_urls_in_text` is explicit and scans
   only complete scheme URLs, never arbitrary prose secrets.
-- 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.
+- 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; it quotes a value only when it contains ASCII space, tab, newline, carriage return, form feed, vertical tab, NBSP, `=`, `"`, or `\`, and escapes `\`, `"`, newline, carriage return, tab, form feed, and vertical tab inside the quotes.
 - 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:{}`.
 - Do not add a raw version/help pre-parser. Until the Python `CliSpec` compiler lands, applications should keep lifecycle parsing in their own parser rather than claim AFDATA closed-world help compatibility.

{agent_first_data-0.34.0 → agent_first_data-0.35.1}/README.md

@@ -24,11 +24,11 @@ Useful names use Python casing: `render` (the single value x format x options ->
 ## Behavior Notes
 
 - Default redaction replaces every `_secret` or configured secret-name subtree with `***`, including objects and arrays.
-- `_url` fields scrub userinfo passwords and secret-named query parameters; surrounding whitespace is trimmed and internal whitespace redacts the whole field.
+- `_url` fields scrub userinfo passwords and secret-named query parameters; surrounding whitespace is trimmed, and internal whitespace or a `://` that is not the start of a clean URL redacts the whole field, where whitespace is the explicit Unicode `White_Space` set the spec enumerates, not the language's native predicate.
 - `OutputOptions.url_names` applies URL treatment to exact legacy field names
   and recurses through collections. `redact_urls_in_text` is explicit and scans
   only complete scheme URLs, never arbitrary prose secrets.
-- 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.
+- 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; it quotes a value only when it contains ASCII space, tab, newline, carriage return, form feed, vertical tab, NBSP, `=`, `"`, or `\`, and escapes `\`, `"`, newline, carriage return, tab, form feed, and vertical tab inside the quotes.
 - 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:{}`.
 - Do not add a raw version/help pre-parser. Until the Python `CliSpec` compiler lands, applications should keep lifecycle parsing in their own parser rather than claim AFDATA closed-world help compatibility.

{agent_first_data-0.34.0 → agent_first_data-0.35.1}/agent_first_data/cli.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import enum
+import os
 import sys
 from typing import Any, Iterator
 
@@ -298,10 +299,27 @@ class CliEmitter:
         # mode (no diagnostic sink) keeps every event on the single writer.
         use_diagnostic = kind != "result" and self._diagnostic is not None
         sink = self._diagnostic if use_diagnostic else self._writer
-        sink.write(render(envelope, self._format, options=self._output_options) + "\n")
-        flush = getattr(sink, "flush", None)
-        if flush is not None:
-            flush()
+        try:
+            sink.write(render(envelope, self._format, options=self._output_options) + "\n")
+            flush = getattr(sink, "flush", None)
+            if flush is not None:
+                flush()
+        except BrokenPipeError:
+            # A failed flush leaves buffered bytes for interpreter shutdown to
+            # retry. Redirect the closed descriptor before finish returns 0.
+            fileno = getattr(sink, "fileno", None)
+            if fileno is not None:
+                try:
+                    descriptor = fileno()
+                except (OSError, ValueError):
+                    descriptor = None
+                if descriptor is not None:
+                    null_descriptor = os.open(os.devnull, os.O_WRONLY)
+                    try:
+                        os.dup2(null_descriptor, descriptor)
+                    finally:
+                        os.close(null_descriptor)
+            raise
         if kind in ("result", "error"):
             self._terminal_emitted = True
 

{agent_first_data-0.34.0 → agent_first_data-0.35.1}/agent_first_data/format.py

@@ -1117,7 +1117,7 @@ def _redact_url_value(value: Any, context: _RedactionContext, depth: int) -> Any
 # ═══════════════════════════════════════════
 
 
-def _redact_url_in_str(s: str, context: _RedactionContext) -> str | None:
+def _redact_url_in_str(s: str, context: _RedactionContext, depth: int = 0) -> str | None:
     """Redact secret components of a single URL string.
 
     Returns the redacted string when ``s`` is a processable URL, or None when it
@@ -1127,6 +1127,9 @@ def _redact_url_in_str(s: str, context: _RedactionContext) -> str | None:
     # Fast path + precondition: a single, whitespace-free, scheme-prefixed URL.
     if "://" not in s or not _is_single_url(s):
         return None
+    # Bound recursive redirect inspection, failing closed before stack growth.
+    if depth >= 16:
+        return REDACTED_MARKER
     scheme_sep = s.find("://")
     scheme = s[:scheme_sep]
     rest = s[scheme_sep + 3 :]
@@ -1137,9 +1140,29 @@ def _redact_url_in_str(s: str, context: _RedactionContext) -> str | None:
         if c in "/?#":
             auth_end = i
             break
+    # An unencoded '?' or '#' inside a password ends that authority early and
+    # leaves the rest of the password in the query or fragment. When a ':'
+    # precedes that early end and an '@' follows it before the first '/', the
+    # userinfo runs to that '@' — how libpq reads such a connection string.
+    first_slash = rest.find("/")
+    if first_slash == -1:
+        first_slash = len(rest)
+    at = rest.rfind("@", 0, first_slash)
+    if ":" in rest[:auth_end] and at > auth_end:
+        auth_end = len(rest)
+        for i in range(at, len(rest)):
+            if rest[i] in "/?#":
+                auth_end = i
+                break
     authority = rest[:auth_end]
     remainder = rest[auth_end:]
 
+    # An unencoded '/' inside a password ends the authority at a "port" that
+    # is not a number, with the '@' somewhere after it. Where the password
+    # ends cannot be known, so the whole value is replaced.
+    if "@" not in authority and _has_non_numeric_port(authority) and "@" in remainder:
+        return REDACTED_MARKER
+
     new_authority = _redact_userinfo_password(authority)
 
     # `remainder` is `path[?query][#fragment]`; '#' ends the query, so split the
@@ -1147,7 +1170,7 @@ def _redact_url_in_str(s: str, context: _RedactionContext) -> str | None:
     before_fragment, hash_sep, fragment = remainder.partition("#")
     path, question_sep, query = before_fragment.partition("?")
     if question_sep:
-        new_before_fragment = f"{path}?{_redact_query(query, context)}"
+        new_before_fragment = f"{path}?{_redact_query(query, context, depth)}"
     else:
         new_before_fragment = before_fragment
     # A fragment gets the same treatment as the query: `k=v&k=v` after the '#'
@@ -1155,7 +1178,19 @@ def _redact_url_in_str(s: str, context: _RedactionContext) -> str | None:
     # secret-named fragment parameter must not survive where the identically
     # named query parameter would not. A fragment that is not in that shape has
     # no '=' in its segments and passes through byte-for-byte.
-    new_fragment = f"#{_redact_query(fragment, context)}" if hash_sep else ""
+    # A hash route (`#/cb?k=v`) carries its parameters after its first '?',
+    # while a form reader keeps that '?' inside a value; redact both readings:
+    # the fragment as parameters first, so a secret value absorbs its '?',
+    # then whatever follows the first '?' that survives.
+    if not hash_sep:
+        new_fragment = ""
+    else:
+        params = _redact_query(fragment, context, depth)
+        route, route_sep, route_query = params.partition("?")
+        if route_sep:
+            new_fragment = f"#{route}?{_redact_query(route_query, context, depth)}"
+        else:
+            new_fragment = f"#{params}"
 
     return f"{scheme}://{new_authority}{new_before_fragment}{new_fragment}"
 
@@ -1273,17 +1308,19 @@ def _redact_url_field_value(s: str, context: _RedactionContext) -> str:
     redacted = _redact_url_in_str(s, context)
     if redacted is not None:
         return redacted
-    trimmed = s.strip()
+    trimmed = s.strip("".join(_SPAN_TERMINATOR_WHITESPACE))
     if trimmed != s:
         redacted = _redact_url_in_str(trimmed, context)
         if redacted is not None:
             return redacted
     # Fail closed: a _url value we could not parse as a clean scheme-prefixed
-    # URL, yet which carries a credential sigil ('@' userinfo) or internal
-    # whitespace, is redacted wholesale rather than passed through. A schemeless
-    # connection string like user:pass@host/db has no scheme anchor for the
-    # surgical span logic above, so blanket redaction is the safe default.
-    if any(c.isspace() for c in s) or "@" in s:
+    # URL, yet which carries a credential sigil ('@' userinfo), internal
+    # whitespace, or a '://' scheme separator, is redacted wholesale rather than
+    # passed through. A schemeless connection string like user:pass@host/db
+    # has no scheme anchor for the surgical span logic above, and a URL behind
+    # a non-whitespace prefix (a BOM, a zero-width space, a label) has one the
+    # span logic cannot reach, so blanket redaction is the safe default.
+    if any(_is_span_terminator_whitespace(c) for c in s) or "@" in s or "://" in s:
         return REDACTED_MARKER
     return s
 
@@ -1304,7 +1341,7 @@ def _redact_userinfo_password(authority: str) -> str:
     return f"{authority[:colon]}:{REDACTED_MARKER}{authority[at:]}"
 
 
-def _redact_query(query: str, context: _RedactionContext) -> str:
+def _redact_query(query: str, context: _RedactionContext, depth: int) -> str:
     """Redact the values of secret-named query parameters.
 
     Preserves the raw bytes of every other segment (keys, benign values,
@@ -1322,11 +1359,33 @@ def _redact_query(query: str, context: _RedactionContext) -> str:
         name = unquote_plus(raw_key)
         if context.is_secret_key(name):
             segments.append(f"{raw_key}={REDACTED_MARKER}")
+            continue
+        # A redirect target carries its own parameters: redact a nested URL in
+        # place, or the whole value when it arrived encoded.
+        raw_value = segment[eq + 1 :]
+        value = unquote_plus(raw_value)
+        redacted = _redact_url_in_str(value, context, depth + 1)
+        if redacted is not None and redacted != value:
+            if value == raw_value:
+                segments.append(f"{raw_key}={redacted}")
+            else:
+                segments.append(f"{raw_key}={REDACTED_MARKER}")
         else:
             segments.append(segment)
     return "&".join(segments)
 
 
+def _has_non_numeric_port(authority: str) -> bool:
+    """True when the authority's text after its last ':' is not a port number.
+
+    A bracketed IPv6 literal without a port ends in ']' and has none.
+    """
+    colon = authority.rfind(":")
+    if colon == -1 or authority.endswith("]"):
+        return False
+    return not all("0" <= c <= "9" for c in authority[colon + 1 :])
+
+
 def _is_single_url(s: str) -> bool:
     """True when ``s`` is a single bare URL, not a URL embedded in prose.
 
@@ -1423,20 +1482,23 @@ def _as_int(value: Any) -> int | None:
     return None
 
 
-def _as_non_neg_int(value: Any) -> int | None:
-    n = _as_int(value)
-    if n is not None and n >= 0:
+def _raw_as_int(value: Any) -> int | None:
+    if isinstance(value, _RawNumber):
+        if re.fullmatch(r"-?\d+", value.literal):
+            return int(value.literal)
+        return _as_int(float(value.literal))
+    return _as_int(value)
+
+
+def _as_u64(value: Any) -> int | None:
+    n = _raw_as_int(value)
+    if n is not None and 0 <= n <= 18_446_744_073_709_551_615:
         return n
     return None
 
 
 def _as_i64(value: Any) -> int | None:
-    if isinstance(value, _RawNumber):
-        if not re.fullmatch(r"-?\d+", value.literal):
-            return None
-        n = int(value.literal)
-    else:
-        n = _as_int(value)
+    n = _raw_as_int(value)
     if n is not None and -9_223_372_036_854_775_808 <= n <= 9_223_372_036_854_775_807:
         return n
     return None
@@ -1575,7 +1637,7 @@ def _try_process_field(key: str, value: Any) -> tuple[str, str] | None:
         return None
     stripped = _strip_suffix_ci(key, "_bytes")
     if stripped is not None:
-        n = _as_non_neg_int(numeric)
+        n = _as_u64(value)
         if n is not None:
             return stripped, _format_bytes_human(n)
         return None
@@ -1840,11 +1902,10 @@ def _yaml_key(key: str) -> str:
 def _is_ambiguous_yaml_key(key: str) -> bool:
     if key.lower() in {"true", "false", "null", "~", ".nan", ".inf", "+.inf", "-.inf"}:
         return True
-    try:
-        float(key)
-        return True
-    except ValueError:
-        return False
+    unsigned = key[1:] if key.startswith(("+", "-")) else key
+    return unsigned.lower() in {"inf", "infinity", "nan"} or re.fullmatch(
+        r"[-+]?(?:[0-9]+\.?[0-9]*|\.[0-9]+)(?:[eE][-+]?[0-9]+)?", key
+    ) is not None
 
 
 def _yaml_scalar(value: Any) -> str:
@@ -1945,7 +2006,7 @@ def _plain_scalar_raw(value: Any) -> str:
 def _quote_logfmt_value(value: str) -> str:
     if value == "":
         return ""
-    needs_quote = any(c.isspace() or c in '="\\' for c in value)
+    needs_quote = any(c in ' \t\n\r\f\v\u00a0="\\' for c in value)
     if not needs_quote:
         return value
     escaped = (

{agent_first_data-0.34.0 → agent_first_data-0.35.1}/agent_first_data.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-first-data
-Version: 0.34.0
+Version: 0.35.1
 Summary: A naming convention that lets AI agents understand your data without being told what it means, plus a CLI and library for reading Markdown structure and safely editing structured JSON, TOML, YAML, dotenv, and INI documents.
 License-Expression: MIT
 Project-URL: Repository, https://github.com/agentfirstkit/agent-first-data
@@ -33,11 +33,11 @@ Useful names use Python casing: `render` (the single value x format x options ->
 ## Behavior Notes
 
 - Default redaction replaces every `_secret` or configured secret-name subtree with `***`, including objects and arrays.
-- `_url` fields scrub userinfo passwords and secret-named query parameters; surrounding whitespace is trimmed and internal whitespace redacts the whole field.
+- `_url` fields scrub userinfo passwords and secret-named query parameters; surrounding whitespace is trimmed, and internal whitespace or a `://` that is not the start of a clean URL redacts the whole field, where whitespace is the explicit Unicode `White_Space` set the spec enumerates, not the language's native predicate.
 - `OutputOptions.url_names` applies URL treatment to exact legacy field names
   and recurses through collections. `redact_urls_in_text` is explicit and scans
   only complete scheme URLs, never arbitrary prose secrets.
-- 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.
+- 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; it quotes a value only when it contains ASCII space, tab, newline, carriage return, form feed, vertical tab, NBSP, `=`, `"`, or `\`, and escapes `\`, `"`, newline, carriage return, tab, form feed, and vertical tab inside the quotes.
 - 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:{}`.
 - Do not add a raw version/help pre-parser. Until the Python `CliSpec` compiler lands, applications should keep lifecycle parsing in their own parser rather than claim AFDATA closed-world help compatibility.

{agent_first_data-0.34.0 → agent_first_data-0.35.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agent-first-data"
-version = "0.34.0"
+version = "0.35.1"
 description = "A naming convention that lets AI agents understand your data without being told what it means, plus a CLI and library for reading Markdown structure and safely editing structured JSON, TOML, YAML, dotenv, and INI documents."
 license = "MIT"
 readme = "README.md"

{agent_first_data-0.34.0 → agent_first_data-0.35.1}/tests/test_cli.py

@@ -1,5 +1,6 @@
 """Tests for agent_first_data CLI helpers."""
 import json
+import sys
 
 import pytest
 from io import StringIO
@@ -500,3 +501,27 @@ def test_cli_render_version_renders_json():
     assert '"code":"version"' in out
     assert '"name":"agent-cli"' in out
     assert '"version":"1.2.3"' in out
+
+
+@pytest.mark.skipif(
+    sys.platform == "win32",
+    reason="closed-pipe writes surface as OSError(EINVAL) on Windows, not "
+    "BrokenPipeError; the reader-closed contract is asserted on POSIX only",
+)
+def test_real_stdout_closed_pipe_has_clean_process_exit():
+    import os
+    import subprocess
+    import sys
+
+    reader, writer = os.pipe()
+    os.close(reader)
+    try:
+        child = subprocess.run(
+            [sys.executable, "-c", "from agent_first_data import CliEmitter, OutputFormat; "
+             "raise SystemExit(CliEmitter.finite(OutputFormat.JSON).finish_result({'ok': True}))"],
+            stdout=writer, stderr=subprocess.PIPE, timeout=10,
+        )
+    finally:
+        os.close(writer)
+    assert child.returncode == 0, child.stderr
+    assert child.stderr == b""