agentledger-cli 0.1.0__tar.gz → 0.2.0__tar.gz

agentledger_cli-0.1.0/README.md → agentledger_cli-0.2.0/PKG-INFO

@@ -1,6 +1,14 @@
+Metadata-Version: 2.5
+Name: agentledger-cli
+Version: 0.2.0
+Summary: Report Claude Code, Cursor, Gemini CLI, OpenCode and Cortex Code sessions to the AgentLedger Snowflake Native App.
+Requires-Python: >=3.10
+Requires-Dist: snowflake-connector-python>=3.12
+Description-Content-Type: text/markdown
+
 # agentledger
 
-Reports your Claude Code, Cursor CLI, Gemini CLI and Cortex Code sessions to the AgentLedger Snowflake
+Reports your Claude Code, Cursor CLI, Gemini CLI, OpenCode and Cortex Code sessions to the AgentLedger Snowflake
 Native App, so your team sees agent cost, prompts and tool use per developer, repo, branch and
 pull request.
 
@@ -23,6 +31,10 @@ After each turn the hook queues the session and returns at once. A background pr
 into the app over your own connection, at most every two minutes per agent, so a session is
 always stored as yours. Logs are in `~/.cache/agentledger/`.
 
+OpenCode has no hook yet, so its sessions are uploaded by hand: `agentledger upload opencode`
+reports the latest one, or name sessions by id (`opencode session list` shows them). They're read
+from OpenCode 2's database, `~/.local/share/opencode/opencode.db` (`$XDG_DATA_HOME` moves it).
+
 ## Requirements
 
 - A Snowflake connection in `~/.snowflake/connections.toml` that works without a prompt (key
@@ -39,6 +51,7 @@ agentledger install --app AGENTLEDGER_PROD               # the app's name, if it
 agentledger status                                       # what's set up, and each agent's latest report
 agentledger upload claude ~/.claude/projects/*/*.jsonl   # report earlier sessions
 agentledger upload gemini ~/.gemini/tmp/*/chats/*.jsonl
+agentledger upload opencode ses_1a2b3c ses_4d5e6f           # OpenCode sessions, by id
 agentledger uninstall                                    # remove the hooks and the plugin
 ```
 

agentledger_cli-0.1.0/PKG-INFO → agentledger_cli-0.2.0/README.md

@@ -1,14 +1,6 @@
-Metadata-Version: 2.5
-Name: agentledger-cli
-Version: 0.1.0
-Summary: Report Claude Code, Cursor, Gemini CLI and Cortex Code sessions to the AgentLedger Snowflake Native App.
-Requires-Python: >=3.10
-Requires-Dist: snowflake-connector-python>=3.12
-Description-Content-Type: text/markdown
-
 # agentledger
 
-Reports your Claude Code, Cursor CLI, Gemini CLI and Cortex Code sessions to the AgentLedger Snowflake
+Reports your Claude Code, Cursor CLI, Gemini CLI, OpenCode and Cortex Code sessions to the AgentLedger Snowflake
 Native App, so your team sees agent cost, prompts and tool use per developer, repo, branch and
 pull request.
 
@@ -31,6 +23,10 @@ After each turn the hook queues the session and returns at once. A background pr
 into the app over your own connection, at most every two minutes per agent, so a session is
 always stored as yours. Logs are in `~/.cache/agentledger/`.
 
+OpenCode has no hook yet, so its sessions are uploaded by hand: `agentledger upload opencode`
+reports the latest one, or name sessions by id (`opencode session list` shows them). They're read
+from OpenCode 2's database, `~/.local/share/opencode/opencode.db` (`$XDG_DATA_HOME` moves it).
+
 ## Requirements
 
 - A Snowflake connection in `~/.snowflake/connections.toml` that works without a prompt (key
@@ -47,6 +43,7 @@ agentledger install --app AGENTLEDGER_PROD               # the app's name, if it
 agentledger status                                       # what's set up, and each agent's latest report
 agentledger upload claude ~/.claude/projects/*/*.jsonl   # report earlier sessions
 agentledger upload gemini ~/.gemini/tmp/*/chats/*.jsonl
+agentledger upload opencode ses_1a2b3c ses_4d5e6f           # OpenCode sessions, by id
 agentledger uninstall                                    # remove the hooks and the plugin
 ```
 

{agentledger_cli-0.1.0 → agentledger_cli-0.2.0}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "agentledger-cli"
 dynamic = ["version"]
-description = "Report Claude Code, Cursor, Gemini CLI and Cortex Code sessions to the AgentLedger Snowflake Native App."
+description = "Report Claude Code, Cursor, Gemini CLI, OpenCode and Cortex Code sessions to the AgentLedger Snowflake Native App."
 readme = "README.md"
 requires-python = ">=3.10"
 dependencies = ["snowflake-connector-python>=3.12"]

{agentledger_cli-0.1.0 → agentledger_cli-0.2.0}/src/agentledger/__init__.py

@@ -1,2 +1,2 @@
 """Report coding-agent sessions to the AgentLedger Snowflake Native App."""
-__version__ = "0.1.0"
+__version__ = "0.2.0"

{agentledger_cli-0.1.0 → agentledger_cli-0.2.0}/src/agentledger/agents/__init__.py

@@ -1,8 +1,10 @@
 """The agents agentledger sets up. Each module names itself (ID, NAME) and can tell whether the
 agent is on this machine (detected), whether it's set up (hooked), and install / uninstall
 itself. Agents whose sessions are loaded from the machine also turn a hook call into a job
-(job), find their newest session (newest), and read a session into the app's shape (payload)."""
-from . import claude, cortex, cursor, gemini
+(job), find their newest session (newest), and read a session into the app's shape (payload).
+OpenCode has no hook yet: its sessions are only uploaded by hand."""
+from . import claude, cortex, cursor, gemini, opencode
 
 AGENTS = {agent.ID: agent for agent in (claude, cursor, gemini, cortex)}
-REPORTERS = {id: agent for id, agent in AGENTS.items() if hasattr(agent, "payload")}
+REPORTERS = {id: agent for id, agent in [*AGENTS.items(), (opencode.ID, opencode)] if hasattr(agent, "payload")}
+HOOKED = {id: agent for id, agent in REPORTERS.items() if hasattr(agent, "job")}

agentledger_cli-0.2.0/src/agentledger/agents/opencode.py

@@ -0,0 +1,246 @@
+"""OpenCode sessions, uploaded from its database with `agentledger upload opencode` (no hook yet).
+
+OpenCode 2 keeps every session in one SQLite file, ~/.local/share/opencode/opencode.db
+($XDG_DATA_HOME moves it): a row per session in session_v2 and its messages, in order, in
+session_message. Each assistant message is one of the app's model calls, with its model, its
+token counts and the times it was sent and completed; a user message the developer typed starts a
+turn (step 0). OpenCode's system notices, the instructions it adds itself (synthetic), compaction
+and idle markers aren't prompts. A session is named by its id (ses_...); subagent sessions (those
+with a parent) count toward the session that started them.
+
+Tool names are mapped to the ones the trace's file cards understand, read results are renumbered
+in Cortex Code's "12... text" form, and edit results get Cortex Code's "Edit location" line from
+the patch OpenCode keeps beside them. Reasoning is not loaded. The session is attributed to the
+git repository its tool calls touched most, else to the folder it ran in, and to the branches the
+repository's reflog shows checked out while it ran.
+"""
+import json
+import os
+import re
+import sqlite3
+from datetime import datetime, timezone
+from pathlib import Path
+
+from ..repo import PATH_ARGS, git_reports, repo_of_paths
+from ..trace import RESULT_CHARS, clip, clip_args, request
+from .claude import HARNESS
+
+ID, NAME = "opencode", "OpenCode"
+HOME = Path(os.environ.get("XDG_DATA_HOME") or Path.home() / ".local" / "share").expanduser() / "opencode"
+DB = HOME / "opencode.db"
+
+TOOL_NAMES = {"shell": "bash", "webfetch": "web_fetch", "websearch": "web_search", "todowrite": "todo_write",
+              "question": "ask_user_question"}
+ARG_RENAMES = {"path": "file_path", "filePath": "file_path", "oldString": "old_string", "newString": "new_string",
+               "replaceAll": "replace_all"}
+READ_LINES = 400
+# read's result: a "Read file <path>, lines 1-80" header, then "12: text" lines.
+READ_HEADER = re.compile(r"\ARead file .*\n")
+READ_LINE = re.compile(r"^(\d+): ?(.*)$")
+HUNK = re.compile(r"^@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@")
+
+
+class NotFound(Exception):
+    pass
+
+
+def detected():
+    return DB.is_file()
+
+
+def _connect(db):
+    return sqlite3.connect(f"file:{db}?mode=ro", uri=True)
+
+
+def newest(db=None):
+    """The id of the session that changed last, or None."""
+    db = Path(db or DB)
+    if not db.is_file():
+        return None
+    con = _connect(db)
+    try:
+        row = con.execute("SELECT id FROM session_v2 WHERE parent_id IS NULL "
+                          "ORDER BY time_updated DESC LIMIT 1").fetchone()
+    finally:
+        con.close()
+    return row[0] if row else None
+
+
+def _utc(ms):
+    return datetime.fromtimestamp(ms / 1000, timezone.utc).replace(tzinfo=None)
+
+
+def _ts(ms):
+    """Epoch milliseconds as the naive UTC text Snowflake parses."""
+    return _utc(ms).strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
+
+
+def load(session_id, db=None):
+    """The session's row and its messages in order, followed by those of its subagent sessions,
+    each message tagged with `_session`."""
+    con = _connect(Path(db or DB))
+    con.row_factory = sqlite3.Row
+    try:
+        session = con.execute("SELECT * FROM session_v2 WHERE id = ?", (session_id,)).fetchone()
+        if session is None:
+            raise NotFound(f"no OpenCode session {session_id}")
+        ids, frontier = [session_id], [session_id]
+        while frontier:
+            marks = ",".join("?" * len(frontier))
+            frontier = [r[0] for r in con.execute(f"SELECT id FROM session_v2 WHERE parent_id IN ({marks}) "
+                                                  "ORDER BY time_created", frontier)]
+            ids += frontier
+        messages = []
+        for sid in ids:
+            for row in con.execute("SELECT id, type, data FROM session_message WHERE session_id = ? ORDER BY seq",
+                                   (sid,)):
+                try:
+                    data = json.loads(row["data"])
+                except ValueError:
+                    continue
+                if isinstance(data, dict):
+                    messages.append({**data, "_id": row["id"], "_type": row["type"], "_session": sid})
+    finally:
+        con.close()
+    return dict(session), messages
+
+
+def _time(message, key="created"):
+    value = (message.get("time") or {}).get(key)
+    return value if isinstance(value, (int, float)) else None
+
+
+def prompt_of(message, session_id):
+    """The prompt a user message carries (without the context T3 Code adds), or None when it isn't
+    one: a subagent's instructions come from its parent, not the developer."""
+    if message.get("_type") != "user" or message.get("_session") != session_id:
+        return None
+    text = message.get("text")
+    text = HARNESS.sub("", text).strip() if isinstance(text, str) else ""
+    return text or None
+
+
+def edit_location(metadata, new_string):
+    """Where an edit's new text landed, in the words Cortex Code's edit results use ("Edit
+    location: lines 12-16"), from the unified diff OpenCode keeps beside the result."""
+    new = (new_string or "").split("\n")
+    first = next((line for line in new if line.strip()), None)
+    files = (metadata or {}).get("files") if isinstance(metadata, dict) else None
+    if first is None or not isinstance(files, list):
+        return None
+    for f in files:
+        n = None
+        for line in (f.get("patch") or "").splitlines() if isinstance(f, dict) else []:
+            if m := HUNK.match(line):
+                n = int(m[1])
+            elif n is not None and line[:1] in (" ", "+"):
+                if line[1:] == first:
+                    start = n - new.index(first)
+                    return f"Edit location: lines {start}-{start + len(new) - 1}"
+                n += 1
+    return None
+
+
+def _result(name, state, args):
+    texts = [c.get("text") for c in state.get("content") or [] if isinstance(c, dict)]
+    text = "\n".join(t for t in texts if isinstance(t, str))
+    if state.get("status") == "error":
+        error = state.get("error")
+        message = error.get("message") if isinstance(error, dict) else error
+        text = text or (message if isinstance(message, str) else "failed")
+        # The trace marks a tool call failed when its result reads as an error.
+        if not text.lstrip().lower().startswith("error"):
+            text = f"Error: {text}"
+    elif name == "read":
+        lines = READ_HEADER.sub("", text).splitlines()[:READ_LINES]
+        numbered = [READ_LINE.match(line) for line in lines]
+        if numbered and all(numbered):
+            text = "\n".join(f"{m[1]}... {m[2]}" for m in numbered)
+    elif name == "edit" and (where := edit_location(state.get("metadata"), args.get("new_string"))):
+        text = f"{text}\n{where}"
+    return clip(text, RESULT_CHARS)
+
+
+def _tools(message):
+    tools = []
+    for part in message.get("content") or []:
+        if not isinstance(part, dict) or part.get("type") != "tool":
+            continue
+        state = part.get("state") if isinstance(part.get("state"), dict) else {}
+        name = TOOL_NAMES.get(part.get("name"), part.get("name") or "tool")
+        args = clip_args(state.get("input") if isinstance(state.get("input"), dict) else {}, ARG_RENAMES)
+        tools.append({"id": part.get("id"), "name": name, "args": args, "result": _result(name, state, args)})
+    return tools
+
+
+def model_calls(messages, session_id):
+    """One dict per assistant message, in order: prompt (for turn starts), step, model, tokens,
+    response text, tool calls, start (when it was sent) and end (when it completed)."""
+    calls, steps, pending_prompt = [], {}, None
+    for m in messages:
+        sid = m["_session"]
+        if (prompt := prompt_of(m, session_id)) is not None:
+            # Prompts sent before the agent answered open one turn together.
+            pending_prompt = prompt if pending_prompt is None else f"{pending_prompt}\n\n{prompt}"
+            steps[sid] = 0
+            continue
+        if m.get("_type") != "assistant" or (start := _time(m)) is None:
+            continue
+        end = _time(m, "completed") or _time(m, "streamed") or start
+        step = steps.get(sid, 1 if sid != session_id else 0)
+        model = m.get("model") if isinstance(m.get("model"), dict) else {}
+        text = "".join(p.get("text") or "" for p in m.get("content") or []
+                       if isinstance(p, dict) and p.get("type") == "text").strip()
+        main = sid == session_id
+        calls.append({"id": m["_id"], "prompt": pending_prompt if main and step == 0 else None, "step": step,
+                      "model": model.get("id"), "tokens": m.get("tokens") or {}, "text": text or None,
+                      "tools": _tools(m), "start": start, "end": max(end, start)})
+        if main and step == 0:
+            pending_prompt = None
+        steps[sid] = step + 1
+    # Subagent sessions are loaded after their parent's; their calls belong where they ran.
+    return sorted(calls, key=lambda c: c["start"])
+
+
+def to_requests(calls):
+    requests = []
+    for call in calls:
+        t = call["tokens"]
+        cache = t.get("cache") if isinstance(t.get("cache"), dict) else {}
+        cache_read, cache_write = cache.get("read") or 0, cache.get("write") or 0
+        requests.append(request(
+            f"opencode-{call['id']}", call["step"], _ts(call["start"]), _ts(call["end"]),
+            call["prompt"], call["text"], call["tools"],
+            model=call["model"],
+            # OpenCode counts cached input apart from input; Snowflake's telemetry counts it in.
+            # Reasoning is billed as output.
+            input_tokens=(t.get("input") or 0) + cache_read + cache_write,
+            output_tokens=(t.get("output") or 0) + (t.get("reasoning") or 0),
+            cache_read_tokens=cache_read,
+            cache_write_tokens=cache_write))
+    return requests
+
+
+def payload(session_id, repo_dir=None, folder=None, db=None):
+    """The session for core.ingest_external_session. `repo_dir` pins its repository; `folder`
+    (where it ran) is used when its tool calls name none, else the directory OpenCode recorded."""
+    session, messages = load(session_id, db)
+    calls = model_calls(messages, session_id)
+    models = [c["model"] for c in calls if c["model"]]
+    folder = repo_dir or repo_of_paths(
+        tool["args"].get(key) for c in calls for tool in c["tools"] for key in PATH_ARGS) \
+        or folder or session.get("directory")
+    stamps = [t for m in messages if m["_session"] == session_id and (t := _time(m)) is not None]
+    started = min(stamps + [session["time_created"]])
+    prompts = sorted(_utc(_time(m)) for m in messages if _time(m) is not None and prompt_of(m, session_id))
+    reports = git_reports(folder, _utc(started), prompts) if folder else []
+    return {
+        "session_id": session_id,
+        "agent": "opencode",
+        "agent_name": NAME,
+        "model": max(set(models), key=models.count) if models else None,
+        "started_at": _ts(started),
+        **({"git_reports": reports} if reports else {}),
+        "prompts": sum(1 for c in calls if c["step"] == 0 and c["prompt"]),
+        "requests": to_requests(calls),
+    }

{agentledger_cli-0.1.0 → agentledger_cli-0.2.0}/src/agentledger/cli.py

@@ -1,4 +1,4 @@
-"""agentledger: report Claude Code, Cursor, Gemini CLI and Cortex Code sessions to the AgentLedger Snowflake app.
+"""agentledger: report Claude Code, Cursor, Gemini CLI, OpenCode and Cortex Code sessions to the AgentLedger Snowflake app.
 
     agentledger install     set up every agent on this machine (once)
     agentledger status      what's set up, and each agent's latest report
@@ -16,7 +16,7 @@ from pathlib import Path
 
 from . import __version__, app, runner
 from . import config as settings
-from .agents import AGENTS, REPORTERS
+from .agents import AGENTS, HOOKED, REPORTERS
 
 INSTALL_FIRST = "Install agentledger first: uv tool install agentledger-cli (or pipx install agentledger-cli)."
 
@@ -173,7 +173,7 @@ def report(agent, config, jobs):
 
 def cmd_hook(args):
     """Run by the agent after each turn. Returns at once and never fails the agent."""
-    agent = REPORTERS[args.agent]
+    agent = HOOKED[args.agent]
     try:
         try:
             hook = json.loads(sys.stdin.read() or "{}")
@@ -219,13 +219,14 @@ def main(argv=None):
     p = sub.add_parser("upload", help="report sessions now (default: the agent's newest)")
     p.add_argument("agent", choices=REPORTERS)
     p.add_argument("sessions", nargs="*", help="session files: Claude Code .jsonl transcripts, Cursor store.db "
-                                                    "files, Gemini CLI chats/session-*.jsonl files")
+                                                    "files, Gemini CLI chats/session-*.jsonl files; OpenCode "
+                                                    "session ids (ses_...)")
     p.add_argument("--repo-dir", help="attribute the sessions to this repository")
     p.add_argument("--dry-run", action="store_true", help=f"write the payloads under {settings.STATE} instead")
     p.set_defaults(run=cmd_upload)
 
     p = sub.add_parser("hook")  # run by the agents; without help, it stays out of the list
-    p.add_argument("agent", choices=REPORTERS)
+    p.add_argument("agent", choices=HOOKED)
     p.set_defaults(run=cmd_hook)
 
     args = parser.parse_args(argv)