ccx-native 0.0.1 → 0.1.0

package/ccx/system/pipes.py

@@ -0,0 +1,46 @@
+"""Quiet exit when the reader of stdout goes away (`ccx logs | head`).
+
+Standard CLI tools stop silently when the downstream reader closes the pipe.
+Python instead raises ``BrokenPipeError`` on the next write or on the final
+flush at shutdown, which prints a traceback. Entry points wrap their work in
+:func:`quiet_broken_stdout`; only a broken *stdout* is silenced, so an EPIPE
+from a worker socket still surfaces as an error.
+"""
+from __future__ import annotations
+
+import os
+import sys
+from contextlib import contextmanager
+from typing import Iterator
+
+from ccx.system import oslayer
+
+
+def stdout_reader_gone() -> bool:
+    """True when stdout is a pipe or socket whose reading end has closed."""
+    try:
+        return oslayer.stdout_reader_gone(sys.stdout.fileno())
+    except (AttributeError, OSError, ValueError):
+        return False
+
+
+@contextmanager
+def quiet_broken_stdout() -> Iterator[None]:
+    """Exit 0 without a traceback when stdout's reader has gone away."""
+    try:
+        try:
+            yield
+        finally:
+            sys.stdout.flush()
+    except BrokenPipeError:
+        if not stdout_reader_gone():
+            raise
+        # Point stdout at /dev/null so the interpreter's own shutdown flush of
+        # whatever is still buffered cannot fail again.
+        devnull = os.open(os.devnull, os.O_WRONLY)
+        os.dup2(devnull, sys.stdout.fileno())
+        os.close(devnull)
+        raise SystemExit(0)
+
+
+__all__ = ["quiet_broken_stdout", "stdout_reader_gone"]

package/ccx/system/sanitize.py

@@ -0,0 +1,43 @@
+"""One sanitizer for every native payload CCX preserves or persists.
+
+Hidden reasoning is the thing CCX must never write down. Both places that keep
+native payloads — the normalized conversation document and the Codex evidence
+journal — have to strip it exactly the same way, so the rule lives here, in a
+module low enough that either can import it without importing the other.
+
+The rule is structural rather than a list of known types: any mapping whose
+``type`` mentions reasoning loses its raw ``content``, at every depth. A future
+item type that nests a reasoning-shaped payload inside itself is covered
+without being anticipated, while the engine's own surfaced ``summary`` — which
+is not hidden — survives.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def is_reasoning_shaped(value: Any) -> bool:
+    """Does this mapping look like it carries chain-of-thought?"""
+    return (
+        isinstance(value, dict)
+        and "reasoning" in str(value.get("type", "")).lower()
+    )
+
+
+def safe_native(value: Any) -> Any:
+    """A copy of one native payload that is safe to persist verbatim."""
+    if isinstance(value, list):
+        return [safe_native(entry) for entry in value]
+    if not isinstance(value, dict):
+        return value
+    hide = is_reasoning_shaped(value)
+    return {
+        key: safe_native(entry)
+        for key, entry in value.items()
+        if not key.startswith("_ccx_")
+        and not (hide and key == "content")
+    }
+
+
+__all__ = ["is_reasoning_shaped", "safe_native"]