Vet

#!/usr/bin/env python3
import argparse
import json
import sys
from pathlib import Path

parser = argparse.ArgumentParser(description="Export Claude Code session history for vet")
parser.add_argument("--session-file", required=True, help="Path to Claude Code session .jsonl file")
args = parser.parse_args()

SESSION_FILE = Path(args.session_file)
if not SESSION_FILE.exists():
    sys.exit(0)

# Map tool_use_id -> (tool_name, tool_input) so ToolResultBlocks can reference the tool name
tool_use_info: dict[str, tuple[str, dict]] = {}
msg_counter = 0

for line in SESSION_FILE.read_text().splitlines():
    if not line.strip():
        continue
    try:
        entry = json.loads(line)
    except json.JSONDecodeError as e:
        print(
            f"WARNING: Skipping malformed JSON line in {SESSION_FILE}: {e}",
            file=sys.stderr,
        )
        continue

    entry_type = entry.get("type")
    if entry_type not in ("user", "assistant"):
        continue

    if entry.get("isSidechain"):
        continue

    message = entry.get("message", {})
    content = message.get("content")

    if entry_type == "user":
        if isinstance(content, str) and content.strip():
            print(json.dumps({"object_type": "ChatInputUserMessage", "text": content}))
        elif isinstance(content, list):
            text_parts = []
            tool_result_blocks = []
            for c in content:
                if not isinstance(c, dict):
                    continue
                if c.get("type") == "text" and c.get("text"):
                    text_parts.append(c["text"])
                elif c.get("type") == "tool_result":
                    result_content = c.get("content", "")
                    if isinstance(result_content, list):
                        result_content = " ".join(
                            rc.get("text", "")
                            for rc in result_content
                            if isinstance(rc, dict) and rc.get("type") == "text"
                        )
                    tool_use_id = c.get("tool_use_id", "")
                    tool_name, tool_input = tool_use_info.get(tool_use_id, ("unknown", {}))
                    tool_result_blocks.append(
                        {
                            "object_type": "ToolResultBlock",
                            "type": "tool_result",
                            "tool_use_id": tool_use_id,
                            "tool_name": tool_name,
                            "invocation_string": f"{tool_name}({json.dumps(tool_input)})",
                            "content": {
                                "content_type": "generic",
                                "text": result_content,
                            },
                        }
                    )
            text = " ".join(text_parts)
            if text.strip():
                print(json.dumps({"object_type": "ChatInputUserMessage", "text": text}))
            if tool_result_blocks:
                msg_counter += 1
                print(
                    json.dumps(
                        {
                            "object_type": "ResponseBlockAgentMessage",
                            "role": "user",
                            "assistant_message_id": f"claude_code_tool_result_{msg_counter}",
                            "content": tool_result_blocks,
                        }
                    )
                )
    elif entry_type == "assistant":
        if not isinstance(content, list):
            continue
        blocks = []
        for c in content:
            if not isinstance(c, dict):
                continue
            if c.get("type") == "text" and c.get("text"):
                blocks.append({"object_type": "TextBlock", "type": "text", "text": c["text"]})
            elif c.get("type") == "tool_use":
                tool_use_id = c.get("id", "")
                tool_name = c.get("name", "")
                tool_input = c.get("input", {})
                # Record for later ToolResultBlock lookups
                tool_use_info[tool_use_id] = (tool_name, tool_input)
                blocks.append(
                    {
                        "object_type": "ToolUseBlock",
                        "type": "tool_use",
                        "id": tool_use_id,
                        "name": tool_name,
                        "input": tool_input,
                    }
                )
        if blocks:
            print(
                json.dumps(
                    {
                        "object_type": "ResponseBlockAgentMessage",
                        "role": "assistant",
                        "assistant_message_id": message.get("id", entry.get("uuid", "claude_code_msg")),
                        "content": blocks,
                    }
                )
            )

#!/usr/bin/env python3
import argparse
import json
import sys
from pathlib import Path

parser = argparse.ArgumentParser(description="Export Codex session history for vet")
parser.add_argument("--session-file", required=True, help="Path to Codex session .jsonl file")
args = parser.parse_args()

SESSION_FILE = args.session_file
if not Path(SESSION_FILE).exists():
    sys.exit(0)

# Map call_id -> (fn_name, fn_input) so ToolResultBlocks can reference the tool name
call_info: dict[str, tuple[str, dict]] = {}
# Buffer tool blocks so they can be wrapped in a ResponseBlockAgentMessage
tool_block_buffer: list[dict] = []
msg_counter = 0


def flush_tool_blocks() -> None:
    """Emit any buffered tool blocks wrapped in a ResponseBlockAgentMessage."""
    global msg_counter
    if not tool_block_buffer:
        return
    msg_counter += 1
    print(
        json.dumps(
            {
                "object_type": "ResponseBlockAgentMessage",
                "role": "assistant",
                "assistant_message_id": f"codex_tool_msg_{msg_counter}",
                "content": list(tool_block_buffer),
            }
        )
    )
    tool_block_buffer.clear()


for line in Path(SESSION_FILE).read_text().splitlines():
    if not line.strip():
        continue
    try:
        entry = json.loads(line)
    except json.JSONDecodeError as e:
        print(
            f"WARNING: Skipping malformed JSON line in {SESSION_FILE}: {e}",
            file=sys.stderr,
        )
        continue

    if entry.get("type") != "response_item":
        continue

    payload = entry.get("payload", {})
    payload_type = payload.get("type")

    if payload_type == "function_call":
        call_id = payload.get("call_id", payload.get("id", ""))
        fn_name = payload.get("name", "")
        fn_args = payload.get("arguments", "")
        # arguments is a JSON string in the Responses API; try to parse it
        try:
            fn_input = json.loads(fn_args) if isinstance(fn_args, str) else fn_args
        except (json.JSONDecodeError, TypeError):
            fn_input = {"raw": fn_args}
        call_info[call_id] = (fn_name, fn_input)
        tool_block_buffer.append(
            {
                "object_type": "ToolUseBlock",
                "type": "tool_use",
                "id": call_id,
                "name": fn_name,
                "input": fn_input,
            }
        )
        continue

    if payload_type == "function_call_output":
        call_id = payload.get("call_id", "")
        output = payload.get("output", "")
        fn_name, fn_input = call_info.get(call_id, ("unknown", {}))
        tool_block_buffer.append(
            {
                "object_type": "ToolResultBlock",
                "type": "tool_result",
                "tool_use_id": call_id,
                "tool_name": fn_name,
                "invocation_string": f"{fn_name}({json.dumps(fn_input)})",
                "content": {"content_type": "generic", "text": output},
            }
        )
        continue

    if payload_type != "message":
        continue

    role = payload.get("role")
    content = payload.get("content", [])

    if role == "user":
        # Flush any pending tool blocks before the user message
        flush_tool_blocks()
        text = " ".join(c.get("text", "") for c in content if c.get("type") == "input_text")
        if text:
            print(json.dumps({"object_type": "ChatInputUserMessage", "text": text}))
    elif role == "assistant":
        # Merge buffered tool blocks into this assistant message
        blocks = list(tool_block_buffer)
        tool_block_buffer.clear()
        for c in content:
            if c.get("type") == "output_text" and c.get("text"):
                blocks.append({"object_type": "TextBlock", "type": "text", "text": c["text"]})
        if blocks:
            msg_counter += 1
            print(
                json.dumps(
                    {
                        "object_type": "ResponseBlockAgentMessage",
                        "role": "assistant",
                        "assistant_message_id": f"codex_msg_{msg_counter}",
                        "content": blocks,
                    }
                )
            )

# Flush any remaining tool blocks at end of file
flush_tool_blocks()

#!/usr/bin/env python3
import argparse
import json
import sys
from pathlib import Path

parser = argparse.ArgumentParser(description="Export Gemini CLI session history for vet")
parser.add_argument("--session-file", required=True, help="Path to Gemini CLI session .json file")
args = parser.parse_args()

SESSION_FILE = Path(args.session_file)
if not SESSION_FILE.exists():
    print(f"ERROR: Session file {SESSION_FILE} does not exist", file=sys.stderr)
    sys.exit(1)

try:
    data = json.loads(SESSION_FILE.read_text())
except json.JSONDecodeError as e:
    print(f"ERROR: Failed to parse JSON from {SESSION_FILE}: {e}", file=sys.stderr)
    sys.exit(1)

messages = data.get("messages", [])

for msg in messages:
    msg_type = msg.get("type")
    content = msg.get("content")

    if msg_type == "user":
        if isinstance(content, list):
            text = " ".join(c.get("text", "") for c in content if isinstance(c, dict) and "text" in c)
        else:
            text = str(content)

        if text:
            print(json.dumps({"object_type": "ChatInputUserMessage", "text": text}))

    elif msg_type == "gemini":
        blocks = []

        # Add the text content as a TextBlock if it exists
        if content and isinstance(content, str):
            blocks.append({"object_type": "TextBlock", "type": "text", "text": content})

        # Process tool calls
        tool_calls = msg.get("toolCalls", [])
        for tc in tool_calls:
            call_id = tc.get("id")
            name = tc.get("name")
            tool_args = tc.get("args")

            blocks.append(
                {
                    "object_type": "ToolUseBlock",
                    "type": "tool_use",
                    "id": call_id,
                    "name": name,
                    "input": tool_args,
                }
            )

            # Process tool results
            results = tc.get("result", [])
            for res in results:
                # Results can be complex; extract the response content
                # Based on the example, it's often in functionResponse.response.output
                output = ""
                if "functionResponse" in res:
                    fr = res["functionResponse"]
                    response = fr.get("response", {})
                    if isinstance(response, dict):
                        output = response.get("output", "")
                    else:
                        output = str(response)
                else:
                    output = str(res)

                blocks.append(
                    {
                        "object_type": "ToolResultBlock",
                        "type": "tool_result",
                        "tool_use_id": call_id,
                        "tool_name": name,
                        "invocation_string": f"{name}({json.dumps(tool_args)})",
                        "content": {"content_type": "generic", "text": str(output)},
                    }
                )

        if blocks:
            print(
                json.dumps(
                    {
                        "object_type": "ResponseBlockAgentMessage",
                        "role": "assistant",
                        "assistant_message_id": msg.get("id"),
                        "content": blocks,
                    }
                )
            )

    elif msg_type == "info":
        # Info messages are usually system notifications, maybe skip or map to something else?
        # For now, let's just skip them as they don't typically represent agent-user dialogue.
        pass

#!/usr/bin/env python3
import argparse
import json
import os
import subprocess
import sys
import tempfile

parser = argparse.ArgumentParser(description="Export OpenCode session history for vet")
parser.add_argument("--session-id", required=True, help="OpenCode session ID (ses_...)")
args = parser.parse_args()

fd, tmppath = tempfile.mkstemp(suffix=".json")
try:
    with os.fdopen(fd, "w+b") as f:
        try:
            result = subprocess.run(
                ["opencode", "export", args.session_id],
                stdout=f,
                stderr=subprocess.PIPE,
            )
        except (FileNotFoundError, OSError) as e:
            print(
                f"WARNING: Could not run 'opencode' command: {e}",
                file=sys.stderr,
            )
            sys.exit(0)

    if result.returncode != 0:
        print(
            f"WARNING: opencode export failed for session {args.session_id}: {result.stderr.decode().strip()}",
            file=sys.stderr,
        )
        sys.exit(0)

    with open(tmppath, "r") as f:
        raw = f.read()
finally:
    os.unlink(tmppath)

if not raw.strip():
    print(
        f"WARNING: opencode export returned empty output for session {args.session_id}",
        file=sys.stderr,
    )
    sys.exit(0)

try:
    data = json.loads(raw)
except json.JSONDecodeError as e:
    print(f"WARNING: Failed to parse opencode export output: {e}", file=sys.stderr)
    sys.exit(0)

for msg in data.get("messages", []):
    info = msg.get("info", {})
    parts = msg.get("parts", [])
    role = info.get("role", "user")
    msg_id = info.get("id", "")

    if role == "user":
        text = " ".join(p.get("text", "") for p in parts if p.get("type") == "text")
        if text:
            print(json.dumps({"object_type": "ChatInputUserMessage", "text": text}))
    else:
        content = []
        for p in parts:
            if p.get("type") == "text" and p.get("text"):
                content.append({"object_type": "TextBlock", "type": "text", "text": p["text"]})
            elif p.get("type") == "tool":
                call_id = p.get("callID", "")
                tool_name = p.get("tool", "")
                state = p.get("state", {})
                tool_input = state.get("input", {})
                tool_output = state.get("output", "")
                content.append(
                    {
                        "object_type": "ToolUseBlock",
                        "type": "tool_use",
                        "id": call_id,
                        "name": tool_name,
                        "input": tool_input,
                    }
                )
                content.append(
                    {
                        "object_type": "ToolResultBlock",
                        "type": "tool_result",
                        "tool_use_id": call_id,
                        "tool_name": tool_name,
                        "invocation_string": f"{tool_name}({json.dumps(tool_input)})",
                        "content": {"content_type": "generic", "text": tool_output},
                    }
                )
        if content:
            print(
                json.dumps(
                    {
                        "object_type": "ResponseBlockAgentMessage",
                        "role": "assistant",
                        "assistant_message_id": msg_id,
                        "content": content,
                    }
                )
            )