agentprof 0.1.0__py3-none-any.whl

agentprof/adapters/codex/discovery.py

@@ -0,0 +1,117 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 epicodic
+"""Locate and group native Codex rollout files."""
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+
+from agentprof.adapters.codex.rollout import ThreadSpawn
+
+_SNIFF_LINES = 20
+
+
+@dataclass(frozen=True)
+class RolloutFile:
+    """Discovery metadata for one recognized rollout file."""
+
+    path: Path
+    session_id: str
+    thread_id: str | None
+    parent_thread_id: str | None
+    agent_nickname: str | None
+    thread_spawn: ThreadSpawn | None
+    cwd: str | None
+
+
+@dataclass(frozen=True)
+class SessionFiles:
+    """All rollout files and metadata belonging to one root Codex session."""
+
+    session_id: str
+    main: Path | None
+    files: list[Path]
+    rollouts: list[RolloutFile]
+
+
+def default_sessions_root(home: Path) -> Path:
+    """The default local Codex sessions directory."""
+    return home / ".codex" / "sessions"
+
+
+def read_metadata(path: Path) -> RolloutFile | None:
+    """Read only through the first valid `session_meta`, without parsing rollout activity."""
+    try:
+        with path.open("rb") as lines:
+            for _, raw_line in zip(range(_SNIFF_LINES), lines, strict=False):
+                try:
+                    line = raw_line.decode("utf-8")
+                except UnicodeDecodeError:
+                    continue
+                metadata = _metadata_from_line(path, line)
+                if metadata is not None:
+                    return metadata
+    except OSError:
+        return None
+    return None
+
+
+def _metadata_from_line(path: Path, line: str) -> RolloutFile | None:
+    try:
+        entry = json.loads(line)
+    except json.JSONDecodeError:
+        return None
+    if not isinstance(entry, dict) or entry.get("type") != "session_meta":
+        return None
+    payload = entry.get("payload")
+    if not isinstance(payload, dict):
+        return None
+    session_id = _text(payload.get("session_id"))
+    if session_id is None:
+        return None
+    source = payload.get("source")
+    subagent = source.get("subagent") if isinstance(source, dict) else None
+    spawn = _thread_spawn(subagent.get("thread_spawn")) if isinstance(subagent, dict) else None
+    return RolloutFile(
+        path=path,
+        session_id=session_id,
+        thread_id=_text(payload.get("id")),
+        parent_thread_id=_text(payload.get("parent_thread_id")),
+        agent_nickname=_text(payload.get("agent_nickname")),
+        thread_spawn=spawn,
+        cwd=_text(payload.get("cwd")),
+    )
+
+
+def _text(value: object) -> str | None:
+    return value if isinstance(value, str) and value else None
+
+
+def _thread_spawn(value: object) -> ThreadSpawn | None:
+    if not isinstance(value, dict):
+        return None
+    depth = value.get("depth")
+    return ThreadSpawn(
+        parent_thread_id=_text(value.get("parent_thread_id")),
+        depth=depth if isinstance(depth, int) and not isinstance(depth, bool) else None,
+        agent_path=_text(value.get("agent_path")),
+        agent_nickname=_text(value.get("agent_nickname")),
+        agent_role=_text(value.get("agent_role")),
+    )
+
+
+def session_files(root: Path) -> list[SessionFiles]:
+    """Find nested recognized rollout JSONLs, grouped by root session ID."""
+    if not root.is_dir():
+        return []
+    grouped: dict[str, list[RolloutFile]] = {}
+    for path in sorted(root.glob("**/*.jsonl")):
+        metadata = read_metadata(path)
+        if metadata is not None:
+            grouped.setdefault(metadata.session_id, []).append(metadata)
+    return [_session_files(session_id, rollouts) for session_id, rollouts in sorted(grouped.items())]
+
+
+def _session_files(session_id: str, rollouts: list[RolloutFile]) -> SessionFiles:
+    main = next((rollout.path for rollout in rollouts if rollout.parent_thread_id is None), None)
+    return SessionFiles(session_id, main, [rollout.path for rollout in rollouts], rollouts)

agentprof/adapters/codex/prompts.py

@@ -0,0 +1,16 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 epicodic
+"""Derive compact topics from Codex user prompts."""
+
+NO_PROMPT = "(no prompt)"
+_TOPIC_LENGTH = 200
+
+
+def first_line(text: str, limit: int = _TOPIC_LENGTH) -> str:
+    """Return the first non-empty prompt line, stripped and bounded."""
+    return next((line.strip()[:limit] for line in text.splitlines() if line.strip()), "")
+
+
+def prompt_topic(prompt: str | None) -> str:
+    """Return a human-readable topic for a Codex turn prompt."""
+    return first_line(prompt) if prompt else NO_PROMPT

agentprof/adapters/codex/rollout.py

@@ -0,0 +1,328 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 epicodic
+"""Parse native Codex rollout JSONL files."""
+
+import json
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from agentprof.adapters.timestamps import parse_iso_ms
+
+
+@dataclass(frozen=True)
+class UsageRecord:
+    """Token usage in Agentprof's disjoint token categories."""
+
+    input: int
+    cache_read: int
+    cache_write: int
+    output: int
+
+
+@dataclass(frozen=True)
+class TokenUsage:
+    """One timestamped native token-usage record."""
+
+    usage: UsageRecord
+    timestamp_ms: int | None
+    response_id: str | None
+    source_order: int | None = None
+
+
+@dataclass(frozen=True)
+class UserInput:
+    """One native user message with its source identity and position."""
+
+    message_id: str | None
+    timestamp_ms: int | None
+    source_order: int | None
+
+
+@dataclass(frozen=True)
+class ToolResultRecord:
+    """One native output record that did not match an earlier invocation."""
+
+    call_id: str | None
+    timestamp_ms: int | None
+    source_order: int | None
+    status: str | None
+
+
+@dataclass(frozen=True)
+class ThreadSpawn:
+    """The subagent linkage stored in session metadata when available."""
+
+    parent_thread_id: str | None
+    depth: int | None
+    agent_path: str | None
+    agent_nickname: str | None
+    agent_role: str | None
+
+
+@dataclass
+class ToolCall:
+    """One native function or custom-tool call and its optional output."""
+
+    call_id: str | None
+    name: str
+    input: str | None
+    start_ms: int | None
+    output: str | None = None
+    end_ms: int | None = None
+    status: str | None = None
+    output_status: str | None = None
+    start_order: int | None = None
+    result_order: int | None = None
+    result_recorded: bool = False
+
+
+@dataclass
+class Turn:
+    """One native Codex task turn."""
+
+    turn_id: str
+    start_ms: int | None = None
+    end_ms: int | None = None
+    model: str | None = None
+    prompt: str | None = None
+    tools: list[ToolCall] = field(default_factory=list)
+    usage: UsageRecord | None = None
+    usages: list[UsageRecord] = field(default_factory=list)
+    token_usages: list[TokenUsage] = field(default_factory=list)
+    user_inputs: list[UserInput] = field(default_factory=list)
+    completion_recorded: bool = False
+    completion_order: int | None = None
+    unmatched_tool_results: list[ToolResultRecord] = field(default_factory=list)
+
+
+@dataclass
+class Rollout:
+    """The native records required for Codex session analysis."""
+
+    session_id: str | None = None
+    thread_id: str | None = None
+    parent_thread_id: str | None = None
+    agent_nickname: str | None = None
+    thread_spawn: ThreadSpawn | None = None
+    cwd: str | None = None
+    model: str | None = None
+    result: str | None = None
+    turns: list[Turn] = field(default_factory=list)
+    malformed_lines: int = 0
+    last_message_ms: int | None = None
+
+
+_USAGE_FIELDS = (
+    "input_tokens",
+    "cached_input_tokens",
+    "cache_write_input_tokens",
+    "output_tokens",
+    "reasoning_output_tokens",
+)
+
+
+def _text(value: object) -> str | None:
+    return value if isinstance(value, str) and value else None
+
+
+def _timestamp(value: object) -> int | None:
+    if not isinstance(value, str):
+        return None
+    try:
+        return parse_iso_ms(value)
+    except ValueError:
+        return None
+
+
+def _content_text(content: object) -> str | None:
+    if isinstance(content, str):
+        return content or None
+    if not isinstance(content, list):
+        return None
+    parts = [block["text"] for block in content if isinstance(block, dict) and isinstance(block.get("text"), str)]
+    return "\n".join(parts) or None
+
+
+def _thread_spawn(value: object) -> ThreadSpawn | None:
+    if not isinstance(value, dict):
+        return None
+    depth = value.get("depth")
+    return ThreadSpawn(
+        parent_thread_id=_text(value.get("parent_thread_id")),
+        depth=depth if isinstance(depth, int) and not isinstance(depth, bool) else None,
+        agent_path=_text(value.get("agent_path")),
+        agent_nickname=_text(value.get("agent_nickname")),
+        agent_role=_text(value.get("agent_role")),
+    )
+
+
+def _usage(value: object) -> UsageRecord | None:
+    if not isinstance(value, dict) or not any(name in value for name in _USAGE_FIELDS):
+        return None
+
+    def count(name: str) -> int:
+        item = value.get(name)
+        return item if isinstance(item, int) and not isinstance(item, bool) else 0
+
+    cache_read = count("cached_input_tokens")
+    cache_write = count("cache_write_input_tokens")
+    return UsageRecord(
+        input=max(count("input_tokens") - cache_read - cache_write, 0),
+        cache_read=cache_read,
+        cache_write=cache_write,
+        output=count("output_tokens"),
+    )
+
+
+class _Parser:
+    def __init__(self) -> None:
+        self.rollout = Rollout()
+        self._turns: dict[str, Turn] = {}
+        self._tools: dict[str, ToolCall] = {}
+        self._active_turn: Turn | None = None
+        self._source_order = 0
+
+    def feed(self, entry: dict[str, Any]) -> None:
+        source_order = entry.get("ordinal")
+        if not isinstance(source_order, int) or isinstance(source_order, bool):
+            source_order = self._source_order
+        self._source_order += 1
+        entry_type = entry.get("type")
+        payload = entry.get("payload")
+        if not isinstance(entry_type, str) or not isinstance(payload, dict):
+            return
+        if entry_type == "session_meta":
+            self._session_meta(payload)
+        elif entry_type == "turn_context":
+            self._turn_context(payload)
+        elif entry_type == "event_msg":
+            self._event(payload, _timestamp(entry.get("timestamp")), source_order)
+        elif entry_type == "response_item":
+            timestamp_ms = _timestamp(entry.get("timestamp"))
+            if timestamp_ms is not None and (
+                payload.get("type") == "agent_message"
+                or (payload.get("type") == "message" and payload.get("role") in ("user", "assistant"))
+            ):
+                self.rollout.last_message_ms = max(self.rollout.last_message_ms or timestamp_ms, timestamp_ms)
+            self._response_item(payload, timestamp_ms, source_order)
+        elif entry_type == "token_usage_record":
+            self._token_usage(payload, _timestamp(entry.get("timestamp")), source_order)
+
+    def _session_meta(self, payload: dict[str, Any]) -> None:
+        self.rollout.session_id = _text(payload.get("session_id")) or self.rollout.session_id
+        self.rollout.thread_id = _text(payload.get("id")) or self.rollout.thread_id
+        self.rollout.parent_thread_id = _text(payload.get("parent_thread_id")) or self.rollout.parent_thread_id
+        self.rollout.agent_nickname = _text(payload.get("agent_nickname")) or self.rollout.agent_nickname
+        source = payload.get("source")
+        subagent = source.get("subagent") if isinstance(source, dict) else None
+        spawn = _thread_spawn(subagent.get("thread_spawn")) if isinstance(subagent, dict) else None
+        self.rollout.thread_spawn = spawn or self.rollout.thread_spawn
+        self.rollout.cwd = _text(payload.get("cwd")) or self.rollout.cwd
+        self.rollout.model = _text(payload.get("model")) or self.rollout.model
+
+    def _turn_context(self, payload: dict[str, Any]) -> None:
+        turn_id = _text(payload.get("turn_id"))
+        if turn_id is not None:
+            turn = self._turn(turn_id)
+            turn.model = _text(payload.get("model")) or turn.model
+
+    def _event(self, payload: dict[str, Any], timestamp_ms: int | None, source_order: int) -> None:
+        event_type = payload.get("type")
+        turn_id = _text(payload.get("turn_id"))
+        if event_type == "task_started" and turn_id is not None:
+            turn = self._turn(turn_id)
+            turn.start_ms = _timestamp(payload.get("started_at")) or timestamp_ms or turn.start_ms
+            self._active_turn = turn
+        elif event_type == "task_complete" and turn_id is not None:
+            turn = self._turn(turn_id)
+            turn.end_ms = _timestamp(payload.get("completed_at")) or timestamp_ms or turn.end_ms
+            turn.completion_recorded = True
+            turn.completion_order = source_order
+            if self._active_turn is turn:
+                self._active_turn = None
+
+    def _response_item(self, payload: dict[str, Any], timestamp_ms: int | None, source_order: int) -> None:
+        turn = self._active_turn
+        if turn is None:
+            return
+        item_type = payload.get("type")
+        if item_type == "message" and payload.get("role") == "user":
+            turn.user_inputs.append(UserInput(_text(payload.get("id")), timestamp_ms, source_order))
+            turn.prompt = _content_text(payload.get("content")) or turn.prompt
+            return
+        if item_type == "agent_message":
+            self.rollout.result = _content_text(payload.get("content")) or self.rollout.result
+            return
+        if item_type in ("function_call", "custom_tool_call"):
+            name = _text(payload.get("name"))
+            if name is None:
+                return
+            call_id = _text(payload.get("call_id"))
+            raw_input = payload.get("arguments") if item_type == "function_call" else payload.get("input")
+            tool = ToolCall(
+                call_id,
+                name,
+                _text(raw_input),
+                timestamp_ms,
+                status=_text(payload.get("status")),
+                start_order=source_order,
+            )
+            turn.tools.append(tool)
+            if call_id is not None:
+                self._tools[call_id] = tool
+            return
+        if item_type in ("function_call_output", "custom_tool_call_output"):
+            call_id = _text(payload.get("call_id"))
+            tool = self._tools.get(call_id) if call_id is not None else None
+            if tool is not None:
+                output = payload.get("output")
+                tool.output = output if isinstance(output, str) else None
+                tool.end_ms = timestamp_ms
+                tool.output_status = _text(payload.get("status"))
+                tool.result_order = source_order
+                tool.result_recorded = True
+            else:
+                turn.unmatched_tool_results.append(
+                    ToolResultRecord(call_id, timestamp_ms, source_order, _text(payload.get("status")))
+                )
+
+    def _token_usage(self, payload: dict[str, Any], timestamp_ms: int | None, source_order: int) -> None:
+        usage = _usage(payload.get("usage"))
+        if usage is None:
+            return
+        turn_id = _text(payload.get("turn_id"))
+        turn = self._turns.get(turn_id) if turn_id is not None else self._active_turn
+        if turn is not None:
+            turn.usage = usage
+            turn.usages.append(usage)
+            turn.token_usages.append(TokenUsage(usage, timestamp_ms, _text(payload.get("response_id")), source_order))
+
+    def _turn(self, turn_id: str) -> Turn:
+        turn = self._turns.get(turn_id)
+        if turn is None:
+            turn = Turn(turn_id=turn_id, model=self.rollout.model)
+            self._turns[turn_id] = turn
+            self.rollout.turns.append(turn)
+        return turn
+
+
+def load_rollout(path: Path) -> Rollout:
+    """Load one rollout JSONL file, skipping and counting malformed lines."""
+    parser = _Parser()
+    try:
+        lines = path.open("rb")
+    except OSError:
+        return parser.rollout
+    with lines:
+        for raw_line in lines:
+            if not raw_line.strip():
+                continue
+            try:
+                entry = json.loads(raw_line.decode("utf-8"))
+                if not isinstance(entry, dict):
+                    raise TypeError("rollout line is not a JSON object")
+                parser.feed(entry)
+            except (UnicodeDecodeError, json.JSONDecodeError, TypeError, ValueError):
+                parser.rollout.malformed_lines += 1
+    return parser.rollout

agentprof/adapters/codex/tools.py

@@ -0,0 +1,97 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 epicodic
+"""Map Codex tool names to neutral tool categories and normalised arguments."""
+
+import re
+
+from agentprof.model import ToolCategory, ToolInfo
+
+_CATEGORIES: dict[str, ToolCategory] = {
+    "exec_command": ToolCategory.SHELL,
+    "exec": ToolCategory.SHELL,
+    "write_stdin": ToolCategory.SHELL_POLL,
+    "apply_patch": ToolCategory.EDIT,
+    "read_file": ToolCategory.READ,
+    "web.run": ToolCategory.WEB,
+    "spawn_agent": ToolCategory.SUBAGENT,
+    "collaboration.spawn_agent": ToolCategory.SUBAGENT,
+}
+
+# Built-in harness tools without a dedicated category; they map to `other` but are not reported as unknown.
+_KNOWN_OTHER_TOOL_IDS = {
+    "collaboration.followup_task",
+    "collaboration.send_message",
+    "collaboration.wait_agent",
+    "collaboration.interrupt_agent",
+    "collaboration.list_agents",
+    "create_goal",
+    "get_goal",
+    "update_goal",
+    "wait",
+    "sleep",
+    "wait_agent",
+    "image_gen",
+    "imagegen",
+    "image_gen.imagegen",
+    "image_gen__imagegen",
+    "request_plugin_install",
+    "tool_search",
+    "list_mcp_resources",
+    "list_mcp_resource_templates",
+    "read_mcp_resource",
+}
+_MCP_PREFIX = "mcp__"
+_FILE_CATEGORIES = (ToolCategory.READ, ToolCategory.EDIT)
+_PATCH_PATH = re.compile(r"^\*\*\* (?:Update|Add|Delete) File: (.+)$", re.MULTILINE)
+
+
+def _base_name(name: str) -> str:
+    """Return the native name without Codex's custom-tool function namespace."""
+    return name.removeprefix("functions.")
+
+
+def is_known_tool_id(name: str) -> bool:
+    """Whether `name` is expected; unknown names are counted in session diagnostics."""
+    base_name = _base_name(name)
+    return base_name in _CATEGORIES or base_name in _KNOWN_OTHER_TOOL_IDS or base_name.startswith(_MCP_PREFIX)
+
+
+def _paths(arguments: dict[str, object]) -> tuple[str, ...]:
+    """Return explicit file paths from native file arguments or an apply-patch payload."""
+    paths: list[str] = []
+    for key in ("path", "file_path", "filePath"):
+        path = arguments.get(key)
+        if isinstance(path, str) and path:
+            paths.append(path)
+            break
+    argument_paths = arguments.get("paths")
+    if isinstance(argument_paths, list):
+        paths.extend(path for path in argument_paths if isinstance(path, str) and path)
+    patch = arguments.get("patch")
+    if isinstance(patch, str):
+        paths.extend(
+            match.group(1).strip()
+            for match in _PATCH_PATH.finditer(patch.replace("\\n", "\n"))
+            if match.group(1).strip()
+        )
+    return tuple(dict.fromkeys(paths))
+
+
+def tool_info(name: str, arguments: dict[str, object]) -> ToolInfo:
+    """Build the neutral `ToolInfo` for one Codex tool call."""
+    base_name = _base_name(name)
+    category = (
+        ToolCategory.EDIT
+        if base_name == "exec" and "patch" in arguments
+        else _CATEGORIES.get(base_name, ToolCategory.OTHER)
+    )
+    paths = _paths(arguments) if category in _FILE_CATEGORIES else ()
+    command = arguments.get("cmd") or arguments.get("command")
+    return ToolInfo(
+        native_id=name,
+        category=category,
+        path=paths[0] if paths else None,
+        command=str(command) if isinstance(command, str) and command else None,
+        arguments=arguments,
+        paths=paths,
+    )