syncade 0.6.2__py3-none-any.whl

syncade/adapters/producer_openai.py

@@ -0,0 +1,226 @@
+"""Producer adapter for the OpenAI ``codex`` CLI.
+
+Symmetric to :class:`syncade.adapters.openai.CodexAdapter` but for
+the fix-it subprocess. Real headless producer runs use ``yolo`` to
+create git commits because the ``workspace-write`` sandbox blocks
+``.git/index.lock`` writes. The output type is
+:class:`syncade.adapters.producer.ProducerOutput` (just the narrative text),
+not a structured
+:class:`syncade.findings.ReviewerOutput`.
+
+Built against the codex CLI's observed JSONL output.
+``codex exec``'s JSONL extraction reuses
+:meth:`CodexAdapter.extract_final_text` so the
+shared envelope-parsing path stays one source of truth (this is
+the same pattern used when the synthesizer reuses the
+extractor with a different no-agent-message exception class).
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from syncade.adapters.base import Invocation
+from syncade.adapters.openai import (
+    _YOLO_FLAG,
+    CodexAdapter,
+    _check_codex_auth,
+)
+from syncade.adapters.producer import ProducerOutput
+from syncade.auth_preflight import assert_codex_reality_honours_declaration
+from syncade.config import ProducerConfig
+from syncade.config_auth import apply_auth_to_env
+from syncade.findings import ReviewerOutputError
+from syncade.process import SubprocessResult
+from syncade.worktree_env import worktree_scoped_env
+
+_PRODUCER_PERMISSION_VALUES: tuple[str, ...] = ("yolo",)
+
+
+class OpenAIProducerAdapter:
+    """ProducerAdapter for the OpenAI ``codex`` CLI.
+
+    ``build_invocation`` produces a ``codex exec --json`` argv that:
+
+    - pins the model from :attr:`ProducerConfig.model`
+    - sets reasoning effort via ``-c model_reasoning_effort=<level>``
+      (codex has no dedicated ``--effort`` flag — same discovery-doc
+      finding the reviewer adapter relies on)
+    - maps permissions: ``yolo`` →
+      ``--dangerously-bypass-approvals-and-sandbox``; stale/sandboxed values
+      rejected at build time
+    - scopes file access to the producer worktree via ``-C`` and
+      ``--add-dir``
+
+    ``parse_output`` extracts the final ``agent_message`` text via
+    :meth:`CodexAdapter.extract_final_text`, passing
+    :class:`ReviewerOutputError` as the no-agent-message exception
+    class (the producer doesn't have a phase-specific exception
+    type, and exit 40 is the right bucket either way — a producer
+    that completed cleanly but emitted no agent message is
+    operationally similar to a reviewer that did the same).
+
+    ``check_auth`` runs ``codex login status``. The producer and
+    reviewer adapters share auth state (same ``~/.codex/auth.json``), but the
+    method remains available for callers that drive the producer phase in
+    isolation.
+
+    The adapter never shells out itself in ``build_invocation`` or
+    ``parse_output``. ``check_auth`` is the one exception (same
+    pattern as :class:`CodexAdapter.check_auth`).
+    """
+
+    name = "openai"
+
+    def check_auth(self) -> None:
+        _check_codex_auth(
+            binary_missing_message=(
+                "codex binary not found on PATH — install codex-cli to "
+                "run the producer subprocess (the OpenAI Codex CLI, not "
+                "a third-party fork)"
+            )
+        )
+
+    def build_invocation(
+        self,
+        producer_config: ProducerConfig,
+        worktree_path: Path,
+        prompt: str,
+    ) -> Invocation:
+        """Construct the ``codex exec --json`` invocation for one
+        producer round.
+
+        Same argv shape as :meth:`CodexAdapter.build_invocation` (per
+        the codex CLI output notes) with the
+        :data:`syncade.config.ProducerPermissions` value-set (``yolo``).
+
+        Raises:
+            ValueError: If ``producer_config.provider`` is not
+                ``"openai"`` — defensive guard against misroute.
+            ValueError: If ``producer_config.permissions`` is
+                ``"safe"`` — belt-and-braces guard for callers that
+                bypass the schema's :data:`ProducerPermissions`
+                Literal.
+        """
+        self._validate_provider(producer_config.provider)
+        self._validate_permissions(producer_config.permissions)
+        # Structural backstop: refuse to spawn codex for a non-auto declaration the probed
+        # login does not honour, on any path that skipped the CLI auth gate. No-op on the
+        # gated CLI path. See syncade.auth_preflight.
+        assert_codex_reality_honours_declaration(producer_config)
+
+        argv: list[str] = [
+            "codex",
+            "exec",
+            "--json",
+            "--model",
+            producer_config.model,
+            "-c",
+            f"model_reasoning_effort={producer_config.thinking}",
+        ]
+        argv.append(_YOLO_FLAG)
+        # The prompt goes on STDIN, never argv — see AnthropicAdapter.build_invocation.
+        # `codex exec` reads instructions from stdin when no positional PROMPT is given.
+        argv.extend(
+            [
+                "-C",
+                str(worktree_path),
+                "--add-dir",
+                str(worktree_path),
+            ]
+        )
+        return Invocation(
+            argv=argv,
+            cwd=worktree_path,
+            env=apply_auth_to_env(worktree_scoped_env(worktree_path), producer_config),
+            stdin_text=prompt,
+            timeout_seconds=None,
+        )
+
+    @staticmethod
+    def _validate_provider(provider: str) -> None:
+        """Refuse a config whose ``provider`` is not ``"openai"``.
+
+        Mirrors :meth:`CodexAdapter._validate_provider`. The
+        producer registry routes by provider name; this guard
+        catches a misroute at build time instead of letting the
+        subprocess fail with a confusing codex-side error after
+        non-codex flags get spliced in.
+        """
+        if provider != "openai":
+            raise ValueError(
+                f"OpenAIProducerAdapter received a ProducerConfig with "
+                f"provider={provider!r}; expected 'openai'. The "
+                f"producer registry should route configs to the adapter "
+                f"whose name matches the config's provider field."
+            )
+
+    @staticmethod
+    def _validate_permissions(permissions: str) -> None:
+        """Refuse unsupported permissions at build time.
+
+        Same logic as the reviewer adapter's analogous guard plus
+        :meth:`AnthropicProducerAdapter._validate_permissions`. The
+        :data:`ProducerPermissions` Literal already rejects ``safe``
+        at config-load; this guard catches the case where a caller
+        constructs a :class:`ProducerConfig` programmatically and
+        bypasses the schema (typically in unit tests).
+        """
+        if permissions == "safe":
+            raise ValueError(
+                "OpenAIProducerAdapter cannot run a producer with "
+                "permissions='safe' headlessly: the corresponding "
+                "`approval_policy=untrusted` mode prompts for tool use "
+                "and `codex exec` cannot answer prompts. Use 'yolo' for "
+                "headless producer commits."
+            )
+        if permissions not in _PRODUCER_PERMISSION_VALUES:
+            valid = "', '".join(_PRODUCER_PERMISSION_VALUES)
+            raise ValueError(
+                "OpenAIProducerAdapter received unsupported producer "
+                f"permissions={permissions!r}; expected one of '{valid}'."
+            )
+
+    def parse_output(self, result: SubprocessResult) -> ProducerOutput:
+        """Parse a finished ``codex exec --json`` subprocess result.
+
+        Decision tree:
+
+        1. Extract the final ``agent_message`` text via
+           :meth:`CodexAdapter.extract_final_text`,
+           passing :class:`ReviewerOutputError` as the
+           no-agent-message exception class.
+        2. The extractor itself handles subprocess-side failures
+           (``turn.failed`` events, non-zero rc, unrecovered bare ``error``
+           streams, auth signatures) — it raises
+           :class:`ReviewerInvocationError` for those, which the
+           orchestrator's producer-phase exception handler maps to
+           exit 40 (subprocess failure).
+        3. On success, wrap the text in
+           :class:`ProducerOutput(narrative_text=...)`. No further
+           structured parsing — the producer doesn't emit a
+           schema-bound payload (unlike the reviewer adapter where
+           the next step is ``parse_reviewer_output`` against the
+           extracted text).
+
+        :meth:`CodexAdapter.extract_final_text` is
+        reused (rather than re-implemented in this module) for the
+        same reason the synthesizer uses it: codex's
+        JSONL stream-extraction logic is non-trivial, and a divergent
+        implementation in the producer adapter would have its own
+        edge cases to discover (turn.failed-vs-error event
+        precedence, auth-signature detection, empty-agent-message
+        handling).
+        """
+        # Reuse the codex reviewer adapter's extraction helper via
+        # an internal CodexAdapter instance. The instance is
+        # stateless across calls, so allocating fresh per parse_output
+        # is cheap and avoids stuffing the helper into a static
+        # @classmethod (which would need to update CodexAdapter's
+        # surface unnecessarily).
+        codex_helper = CodexAdapter()
+        final_text = codex_helper.extract_final_text(
+            result,
+            empty_output_exception_class=ReviewerOutputError,
+        )
+        return ProducerOutput(narrative_text=final_text)

syncade/adapters/registry.py

@@ -0,0 +1,81 @@
+"""Provider-string-to-adapter lookup for the dispatcher.
+
+The dispatcher takes a list of :class:`ReviewerConfig`s and
+routes each to the adapter whose :attr:`ReviewerAdapter.name` matches
+the config's ``provider`` field. This module is that routing table.
+
+Intentionally a tiny dict and not a plugin system. Adding a new
+provider lands by appending one line here; nothing dynamic until we
+have evidence we need it.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Literal
+
+from syncade.adapters.anthropic import AnthropicAdapter
+from syncade.adapters.base import ReviewerAdapter
+from syncade.adapters.openai import CodexAdapter
+
+ProviderRole = Literal["reviewer", "producer"]
+
+
+@dataclass(frozen=True)
+class UnknownProviderError(ValueError):
+    role: ProviderRole
+    requested: str
+    known: tuple[str, ...]
+
+    def __str__(self) -> str:
+        known = ", ".join(sorted(self.known))
+        return (
+            f"unknown {self.role} adapter {self.requested!r} in "
+            f".syncade/config.toml. Known adapters: {known}"
+        )
+
+
+# Mapping: provider string → zero-arg factory that constructs the
+# adapter. Using factories (not pre-built instances) so each call to
+# ``get_adapter`` returns a fresh adapter — keeps tests that mutate
+# adapter state from leaking across calls.
+_ADAPTER_FACTORIES: dict[str, Callable[[], ReviewerAdapter]] = {
+    "anthropic": AnthropicAdapter,
+    "openai": CodexAdapter,
+}
+
+
+def get_adapter(provider: str) -> ReviewerAdapter:
+    """Return a fresh adapter instance for the given provider string.
+
+    The provider name must match a key in the registry. The known
+    providers are tied to ``ReviewerAdapter.name`` for each shipped
+    adapter; the dispatcher uses this lookup to route each
+    :class:`~syncade.config.ReviewerConfig` to its matching adapter.
+
+    Raises:
+        ValueError: When ``provider`` is not a known key. The error
+            message names the bad input AND lists the known
+            providers, so a user with a typo in
+            ``.syncade/config.toml`` (``provider = "anthrpic"``) sees
+            both their mistake and the fix at once.
+    """
+    try:
+        factory = _ADAPTER_FACTORIES[provider]
+    except KeyError:
+        raise UnknownProviderError(
+            role="reviewer",
+            requested=provider,
+            known=tuple(_ADAPTER_FACTORIES),
+        ) from None
+    return factory()
+
+
+def known_providers() -> list[str]:
+    """Return the sorted list of registered provider names.
+
+    Useful for surface-area assertions in tests and for any future
+    `syncade providers` CLI command that lists what's available.
+    """
+    return sorted(_ADAPTER_FACTORIES)