painapple-code 1.0.0__py3-none-any.whl

painapple_code/providers/codex/summary.py

@@ -0,0 +1,196 @@
+"""Codex provider — the rich-commit summary fork.
+
+`codex exec resume` continues a thread *in place*, so summarizing the turn by
+resuming the user's real thread would pollute their conversation. This mixin
+copies the thread's rollout under a fresh id and resumes the copy — the
+equivalent of Claude's `--fork-session` — then reads the structured JSON back.
+Mixed into `CodexProvider`.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from typing import Optional
+
+from painapple_code import paths
+from painapple_code.providers.base import SummaryForkPlan
+
+
+class _SummaryMixin:
+    """Branch off the real thread and summarize the turn with Codex itself."""
+
+    def build_summary_fork(
+        self,
+        *,
+        session_id: str,
+        fork_prompt: str,
+        schema_json: str,
+        cwd: str,
+        token_profile: Optional[str] = None,
+        session_model: Optional[str] = None,
+    ) -> Optional[SummaryForkPlan]:
+        """Summarize the turn with Codex itself, branching off the real thread.
+
+        `codex exec resume` continues a thread *in place* (and `--ephemeral`
+        doesn't prevent that on resume), so resuming the user's thread would
+        append every summary turn into their conversation. Instead we copy the
+        thread's rollout under a fresh id and resume the copy — the equivalent of
+        Claude's `--fork-session`. `--output-schema` forces the structured shape
+        (strict mode: every property required) and `-o` writes the final JSON to
+        a temp file. Returns None if the rollout can't be located, in which case
+        the turn still gets a basic shadow commit without AI sections.
+        """
+        import tempfile
+
+        fork = self._fork_rollout(session_id)
+        if fork is None:
+            return None
+        fork_id, copy_path = fork
+
+        schema_fd, schema_path = tempfile.mkstemp(prefix="codex_schema_", suffix=".json")
+        with os.fdopen(schema_fd, "w", encoding="utf-8") as f:
+            f.write(self._strictify_schema(schema_json))
+        out_fd, out_path = tempfile.mkstemp(prefix="codex_summary_", suffix=".json")
+        os.close(out_fd)
+
+        # `resume` has no -s flag; sandbox is a config override. read-only keeps
+        # the summarizer from touching the workspace.
+        argv = [
+            self.binary(), "exec", "resume", fork_id,
+            "--json", "--skip-git-repo-check",
+            "-c", 'sandbox_mode="read-only"',
+            "--output-schema", schema_path,
+            "-o", out_path,
+        ]
+        # Optional cheaper summarizer model (seam-described override);
+        # default inherits the thread's model.
+        summary_model = self.get_summary_model_override()
+        if summary_model and not summary_model.startswith("claude"):
+            argv += ["-m", summary_model]
+        argv.append(fork_prompt)
+
+        return SummaryForkPlan(
+            argv=argv,
+            env=None,                       # codex uses ambient auth (codex login / CODEX_API_KEY)
+            model=summary_model or "codex",
+            output_file=out_path,
+            cleanup_paths=[copy_path, schema_path, out_path],
+        )
+
+    def parse_summary_fork(
+        self,
+        *,
+        plan: SummaryForkPlan,
+        returncode: int,
+        stdout: bytes,
+        stderr: bytes,
+    ) -> tuple[Optional[dict], Optional[dict]]:
+        """Read the structured JSON from `-o` (fallback: last agent_message)."""
+        if returncode != 0:
+            return None, None
+        structured = None
+        if plan.output_file:
+            try:
+                text = open(plan.output_file, encoding="utf-8").read().strip()
+                if text:
+                    structured = json.loads(text)
+            except (OSError, json.JSONDecodeError):
+                structured = None
+        if not isinstance(structured, dict):
+            structured = self._structured_from_stream(stdout)
+        if not isinstance(structured, dict):
+            return None, None
+        usage = self._usage_from_stream(stdout)
+        cost = {
+            "cost": 0.0,                    # Codex reports no USD cost
+            "input_tokens": usage.get("input_tokens", 0) or 0,
+            "output_tokens": usage.get("output_tokens", 0) or 0,
+        }
+        return structured, cost
+
+    # --- summary-fork helpers ---------------------------------------------
+
+    @staticmethod
+    def _codex_sessions_dir():
+        """Codex rollout dir (`$CODEX_HOME/sessions` or `~/.codex/sessions`)."""
+        from pathlib import Path
+        codex_home = os.environ.get("CODEX_HOME")
+        base = Path(codex_home) if codex_home else Path.home() / ".codex"
+        d = base / "sessions"
+        return d if d.is_dir() else None
+
+    def _fork_rollout(self, session_id: str) -> Optional[tuple[str, str]]:
+        """Copy a thread's rollout under a fresh id. Returns (new_id, copy_path).
+
+        Codex stores each thread as `sessions/YYYY/MM/DD/rollout-<ts>-<uuid>.jsonl`
+        with the uuid in both the filename and the line-1 `session_meta.id`.
+        Rewriting that uuid makes a resume-by-id land on the copy, leaving the
+        original byte-for-byte untouched.
+        """
+        import uuid
+
+        sessions_dir = self._codex_sessions_dir()
+        if sessions_dir is None:
+            return None
+        matches = sorted(sessions_dir.glob(f"**/*{session_id}*.jsonl"))
+        if not matches:
+            return None
+        src = matches[0]
+        new_id = str(uuid.uuid4())
+        dst = src.with_name(src.name.replace(session_id, new_id))
+        try:
+            dst.write_text(src.read_text(encoding="utf-8").replace(session_id, new_id),
+                           encoding="utf-8")
+        except OSError:
+            return None
+        return new_id, str(dst)
+
+    @staticmethod
+    def _strictify_schema(schema_json: str) -> str:
+        """Widen `required` to every property — Codex's `--output-schema` runs in
+        OpenAI strict mode. The model emits empties for inapplicable sections,
+        which `structured_to_markdown` skips."""
+        try:
+            schema = json.loads(schema_json)
+        except json.JSONDecodeError:
+            return schema_json
+        props = schema.get("properties")
+        if isinstance(props, dict):
+            schema["required"] = list(props.keys())
+            schema["additionalProperties"] = False
+        return json.dumps(schema)
+
+    @classmethod
+    def _iter_events(cls, stdout: bytes):
+        for line in stdout.decode(errors="replace").splitlines():
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                yield json.loads(line)
+            except json.JSONDecodeError:
+                continue
+
+    @classmethod
+    def _structured_from_stream(cls, stdout: bytes) -> Optional[dict]:
+        """Fallback when `-o` is empty: the last agent_message holds the JSON."""
+        last = None
+        for ev in cls._iter_events(stdout):
+            if ev.get("type") == "item.completed":
+                item = ev.get("item") or {}
+                if item.get("type") == "agent_message":
+                    last = item.get("text")
+        if last:
+            try:
+                return json.loads(last)
+            except json.JSONDecodeError:
+                return None
+        return None
+
+    @classmethod
+    def _usage_from_stream(cls, stdout: bytes) -> dict:
+        for ev in cls._iter_events(stdout):
+            if ev.get("type") == "turn.completed":
+                return ev.get("usage") or {}
+        return {}

painapple_code/providers/codex/translate.py

@@ -0,0 +1,204 @@
+"""Codex provider — event translation into the canonical Claude-shaped stream.
+
+`translate_events` maps Codex's native event schema into the canonical
+Claude-shaped events (`system`/`assistant`/`user`/`result`) the session handlers
+and the frontend already understand:
+
+    thread.started        → system/init   (+ session id via session_id_from_event)
+    turn.started          → (nothing)
+    item.completed reasoning      → assistant {thinking}
+    item.completed agent_message  → assistant {text}
+    item.* command_execution      → assistant {tool_use Bash} + user {tool_result}
+    item.completed file_change    → assistant {tool_use Edit/Write} + user {tool_result}
+    item.completed web_search     → assistant {tool_use WebSearch} + user {tool_result}
+    item.* mcp_tool_call          → assistant {tool_use mcp__…} + user {tool_result}
+    item.completed todo_list      → assistant {tool_use TodoWrite} + user {tool_result}
+    turn.completed        → result   (tokens only; no USD cost)
+    turn.failed / error   → result   (is_error=True)
+
+Codex reports token counts but no per-turn USD cost, so result cost is left at 0.
+Token usage is per-turn already, so no cumulative→delta conversion is needed.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Optional
+
+
+class _TranslateMixin:
+    """Codex native events → canonical Claude-shaped events."""
+
+    def session_id_from_event(self, event: dict) -> Optional[str]:
+        if event.get("type") == "thread.started":
+            return event.get("thread_id")
+        return None
+
+    def translate_events(self, event: dict, state: dict) -> list[dict]:
+        etype = event.get("type")
+
+        if etype == "thread.started":
+            init = {"type": "system", "subtype": "init",
+                    "session_id": event.get("thread_id")}
+            model = state.get("model")
+            if model and not model.startswith("claude"):
+                init["model"] = model
+            return [init]
+
+        if etype == "turn.started":
+            return []
+
+        if etype == "turn.completed":
+            return [self._result_from_usage(event.get("usage") or {}, state)]
+
+        if etype in ("turn.failed", "error"):
+            err = event.get("error") or {}
+            message = err.get("message") if isinstance(err, dict) else None
+            message = message or event.get("message") or "Codex turn failed"
+            return [self._error_result(message, state)]
+
+        if etype in ("item.started", "item.updated", "item.completed"):
+            return self._translate_item(etype, event.get("item") or {}, state)
+
+        # Unknown event — ignore rather than surfacing noise.
+        return []
+
+    # --- item translation -------------------------------------------------
+
+    def _translate_item(self, etype: str, item: dict, state: dict) -> list[dict]:
+        itype = item.get("type")
+        item_id = item.get("id") or ""
+        completed = etype == "item.completed"
+        started = etype == "item.started"
+
+        if itype == "reasoning" and completed:
+            return [self._assistant([{"type": "thinking",
+                                      "thinking": item.get("text", "")}])]
+
+        if itype == "agent_message" and completed:
+            text = item.get("text", "")
+            state["last_text"] = text  # surfaced as result.result
+            return [self._assistant([{"type": "text", "text": text}])]
+
+        if itype == "command_execution":
+            if started:
+                return [self._tool_use(item_id, "Bash",
+                                       {"command": item.get("command", "")})]
+            if completed:
+                out = item.get("aggregated_output", "")
+                exit_code = item.get("exit_code")
+                if exit_code not in (None, 0):
+                    out = f"{out}\n[exit code: {exit_code}]"
+                return [self._tool_result(item_id, out)]
+            return []
+
+        if itype == "file_change" and completed:
+            msgs: list[dict] = []
+            for i, change in enumerate(item.get("changes") or []):
+                path = change.get("path", "")
+                kind = change.get("kind", "update")
+                tool = "Write" if kind == "add" else "Edit"
+                cid = f"{item_id}_{i}"
+                msgs.append(self._tool_use(cid, tool, {"file_path": path}))
+                msgs.append(self._tool_result(cid, f"{kind}: {path}"))
+            return msgs
+
+        if itype == "web_search" and completed:
+            return [
+                self._tool_use(item_id, "WebSearch", {"query": item.get("query", "")}),
+                self._tool_result(item_id, "Search completed."),
+            ]
+
+        if itype == "mcp_tool_call":
+            name = f"mcp__{item.get('server', '')}__{item.get('tool', '')}"
+            if started:
+                return [self._tool_use(item_id, name, item.get("arguments") or {})]
+            if completed:
+                result = item.get("result")
+                err = item.get("error")
+                content = err if err else json.dumps(result) if result is not None else "(no result)"
+                return [self._tool_result(item_id, str(content))]
+            return []
+
+        if itype == "todo_list" and completed:
+            todos = [
+                {"content": t.get("text", ""),
+                 "status": "completed" if t.get("completed") else "pending",
+                 "activeForm": t.get("text", "")}
+                for t in (item.get("items") or [])
+            ]
+            return [
+                self._tool_use(item_id, "TodoWrite", {"todos": todos}),
+                self._tool_result(item_id, "Todos updated."),
+            ]
+
+        if itype == "error" and completed:
+            return [self._assistant([{"type": "text",
+                                      "text": f"⚠️ {item.get('message', '')}"}])]
+
+        return []
+
+    # --- canonical-event builders ----------------------------------------
+
+    @staticmethod
+    def _assistant(blocks: list[dict]) -> dict:
+        return {"type": "assistant",
+                "message": {"role": "assistant", "content": blocks}}
+
+    @staticmethod
+    def _tool_use(tool_id: str, name: str, tool_input: dict) -> dict:
+        return {"type": "assistant", "message": {"role": "assistant", "content": [
+            {"type": "tool_use", "id": tool_id, "name": name, "input": tool_input},
+        ]}}
+
+    @staticmethod
+    def _tool_result(tool_id: str, content: str) -> dict:
+        return {"type": "user", "message": {"role": "user", "content": [
+            {"type": "tool_result", "tool_use_id": tool_id, "content": content},
+        ]}}
+
+    @staticmethod
+    def _result_from_usage(usage: dict, state: dict) -> dict:
+        in_tok = usage.get("input_tokens", 0) or 0
+        out_tok = usage.get("output_tokens", 0) or 0
+        cache_read = usage.get("cached_input_tokens", 0) or 0
+        result = {
+            "type": "result",
+            "subtype": "success",
+            "is_error": False,
+            "total_cost_usd": 0,   # Codex reports no USD cost
+            "duration_ms": 0,      # finalize_turn derives this from turn_start
+            "num_turns": 1,
+            "result": state.get("last_text", ""),
+            "usage": {
+                "input_tokens": in_tok,
+                "output_tokens": out_tok,
+                "cache_read_input_tokens": cache_read,
+                "cache_creation_input_tokens": 0,
+            },
+        }
+        # Only record a model breakdown under an OpenAI-shaped id — the seeded
+        # state model may be the Claude default that build_command dropped.
+        model = state.get("model")
+        if model and not model.startswith("claude"):
+            result["modelUsage"] = {model: {
+                "costUSD": 0,
+                "inputTokens": in_tok,
+                "outputTokens": out_tok,
+                "cacheReadInputTokens": cache_read,
+                "cacheCreationInputTokens": 0,
+            }}
+        return result
+
+    @staticmethod
+    def _error_result(message: str, state: dict) -> dict:
+        return {
+            "type": "result",
+            "subtype": "error_during_execution",
+            "is_error": True,
+            "total_cost_usd": 0,
+            "duration_ms": 0,
+            "num_turns": 1,
+            "result": message,
+            "usage": {},
+        }

painapple_code/providers/codex_app_server/__init__.py

@@ -0,0 +1,100 @@
+"""
+OpenAI Codex provider over the **app-server** protocol (`codex app-server`).
+
+The sibling `codex` provider drives `codex exec --json` — one throwaway process
+*per turn*, prompt in argv, newline-JSON to stdout, exit. That's the
+lowest-common-denominator path; it's why that provider declares `fork=False`,
+`context_command=False`, no real model list, and a hardcoded context window.
+
+This provider instead speaks the **persistent JSON-RPC protocol** the official
+Codex IDE extension uses (`codex app-server --stdio`): one long-lived process
+serves many threads and turns, streaming events as JSON-RPC notifications. It
+unlocks native fork, a real (server-reported) context window, token deltas, and
+— later — interactive approvals, none of which `codex exec` can express. It is
+marked experimental in the CLI, so it ships *alongside* the stable `codex`
+provider rather than replacing it; users pick which they want.
+
+Because the wire is JSON-RPC rather than one-way lines, this provider sets
+`transport="jsonrpc"`: the session layer hands the spawned process to a
+transport driver (see `transport.py`) that owns the bidirectional conversation —
+the `initialize` handshake, lazy `thread/start`/`thread/resume`, `turn/start`,
+id-correlated responses, and server-initiated approval requests. The read side
+is unchanged: each notification still flows through `parse_line` +
+`translate_events`.
+
+Assembled from focused mixins (this file is the combiner — see `codex/` and
+`claude/` for the same layout):
+
+    capabilities.py  → _CapabilitiesMixin  binary/auth, effort/perm vocab,
+                                            skill/agent/plugin roots, real
+                                            context window from token usage
+    launch.py        → _LaunchMixin         build_command (`codex app-server`)
+    transport.py     → JsonRpcTransport      the bidirectional JSON-RPC driver
+    translate.py     → _TranslateMixin      JSON-RPC notifications → Claude shape
+    summary.py       → _SummaryMixin         native rich-commit fork
+                                             (ephemeral thread/fork + outputSchema)
+    errors.py        → _ErrorsMixin          stderr classification / retry policy
+
+The rich-commit summary is native here — an *ephemeral* `thread/fork` plus a
+`turn/start` with `outputSchema`, no rollout-file copy (see `summary.py`). Only
+stderr classification is reused verbatim from the `codex` exec provider (the
+binary is the same, so its diagnostics are identical).
+"""
+
+from __future__ import annotations
+
+from painapple_code.providers.base import Provider, Capabilities
+from painapple_code.providers.codex_app_server.capabilities import _CapabilitiesMixin
+from painapple_code.providers.codex_app_server.launch import _LaunchMixin
+from painapple_code.providers.codex_app_server.translate import _TranslateMixin
+# Native app-server summary (ephemeral thread/fork + outputSchema; no rollout
+# copy). Errors are reused verbatim from the exec provider — identical stderr.
+from painapple_code.providers.codex_app_server.summary import _SummaryMixin
+from painapple_code.providers.codex.errors import _ErrorsMixin
+
+
+class CodexAppServerProvider(
+    _CapabilitiesMixin,
+    _LaunchMixin,
+    _TranslateMixin,
+    _SummaryMixin,
+    _ErrorsMixin,
+    Provider,
+):
+    """Adapter for the OpenAI Codex CLI over the app-server JSON-RPC protocol.
+
+    The behaviour lives in the mixins + the transport driver; this class carries
+    the static identity + capability flags and the MRO that composes them (mixins
+    first, so their overrides win, with `super()` calls — e.g. `is_available` —
+    still reaching the base implementation).
+    """
+
+    name = "codex-app-server"
+    display_name = "Codex (app-server)"
+    description = "OpenAI Codex app-server — persistent JSON-RPC, native fork"
+    capabilities = Capabilities(
+        resume=True,
+        fork=True,                 # native thread/fork (transport branches the
+                                   # source thread; no rollout copy)
+        permission_modes=True,
+        effort=True,
+        thinking_display=True,     # native reasoning items
+        context_command=False,     # metered from thread/tokenUsage, not a probe
+        cumulative_cost=False,     # per-turn usage, no USD figure
+        rich_commit_summaries=True,
+        persistent_process=True,   # one app-server process, many turns
+        forward_plain_stderr=False,  # app-server logs human progress to stderr
+        transport="jsonrpc",       # the session layer drives a transport driver
+    )
+
+    def make_transport(self, process, opts, session):
+        # Imported lazily so the package import stays cheap and asyncio stays out
+        # of the static provider description.
+        from painapple_code.providers.codex_app_server.transport import JsonRpcTransport
+        return JsonRpcTransport(process, opts, session, self)
+
+
+# Registry contribution — discovered exactly like a flat module
+# (pkgutil.iter_modules lists subpackages too), so adding this provider needed
+# no edit to providers/__init__.py.
+PROVIDERS = [CodexAppServerProvider()]

painapple_code/providers/codex_app_server/capabilities.py

@@ -0,0 +1,41 @@
+"""Codex app-server provider — declarative surface.
+
+Everything the app-server declares about itself — binary/auth, effort &
+permission vocabularies, skill/agent/plugin roots — is identical to the `codex`
+exec provider (same CLI, same `$CODEX_HOME` layout), so this inherits the exec
+capability mixin wholesale and overrides only context metering: the app-server
+reports the *real* model context window (via the tokenUsage notification, stashed
+onto the result by translate.py), so we meter against that instead of exec's
+hardcoded family default.
+"""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from painapple_code.providers.codex.capabilities import (
+    _CapabilitiesMixin as _CodexExecCapabilitiesMixin,
+    _DEFAULT_CONTEXT_WINDOW,
+)
+
+
+class _CapabilitiesMixin(_CodexExecCapabilitiesMixin):
+    """Reuses the exec provider's self-description; real context window."""
+
+    def context_from_result(self, result_msg: dict, model: Optional[str] = None) -> Optional[dict]:
+        # input_tokens is the full conversation context fed to the model this
+        # turn — the live window occupancy. Unlike exec, the app-server tells us
+        # the actual window (carried on usage.context_window by translate.py); we
+        # fall back to the exec family default only if it's somehow absent.
+        usage = (result_msg or {}).get("usage") or {}
+        in_tok = usage.get("input_tokens") or 0
+        if not in_tok:
+            return None
+        window = usage.get("context_window") or _DEFAULT_CONTEXT_WINDOW
+        return {
+            "contextTokens": in_tok,
+            "contextWindow": window,
+            "percentage": round(in_tok / window * 100, 1) if window else None,
+            "breakdown": None,
+            "memoryFiles": None,
+        }