octarin-cli 0.3.3 → 0.3.4

package/assets/claude_code/hook.py

@@ -27,6 +27,7 @@ import os
 import ssl
 import subprocess
 import sys
+import time
 import urllib.request
 import uuid
 from datetime import datetime, timezone
@@ -346,6 +347,11 @@ def build_spans(entries: list[dict]) -> tuple[list[dict], dict, list[str], str |
 
     pending_user_text = ""
     pending_user_attachments: list[dict] = []
+    # One API generation streams as SEVERAL transcript entries (one per content
+    # block — text, then each tool_use) that share the same message id and each
+    # repeat the generation's FULL usage. Merge them into ONE span keyed by that
+    # id: usage/cost counted once, outputs concatenated, tool children attached.
+    llm_span_by_id: dict[str, dict] = {}
     # ts of the previous transcript entry; the LLM call started when the user
     # prompt / tool result landed, finished when the assistant message appears.
     prev_ts: str | None = None
@@ -372,6 +378,31 @@ def build_spans(entries: list[dict]) -> tuple[list[dict], dict, list[str], str |
         span_id = _msg(entry).get("id") or uuid.uuid4().hex
         out_text = _truncate(_text(content))
 
+        existing = llm_span_by_id.get(str(span_id))
+        if existing is not None:
+            # Continuation entry of an already-seen generation: extend the span,
+            # never re-count its usage (each entry repeats the full totals).
+            existing["end_time"] = ts
+            if out_text:
+                joined = (
+                    f"{existing['output']}\n{out_text}" if existing["output"] else out_text
+                )
+                existing["output"] = _truncate(joined)
+            for tu in _blocks(content, "tool_use"):
+                _append_tool_span(
+                    spans,
+                    totals,
+                    tu,
+                    parent_span_id=str(span_id),
+                    ts=ts,
+                    results_by_id=results_by_id,
+                    errors_by_id=errors_by_id,
+                    result_ts_by_id=result_ts_by_id,
+                    attachments_by_tool_id=attachments_by_tool_id,
+                )
+            prev_ts = ts
+            continue
+
         in_tok = usage.get("input", 0)
         out_tok = usage.get("output", 0)
         cache_r = usage.get("cache_read", 0)
@@ -398,6 +429,7 @@ def build_spans(entries: list[dict]) -> tuple[list[dict], dict, list[str], str |
         if pending_user_attachments:
             llm_span["attachments"] = pending_user_attachments
         spans.append(llm_span)
+        llm_span_by_id[str(span_id)] = llm_span
         pending_user_text = ""  # consumed by this generation
         pending_user_attachments = []  # consumed by this generation
 
@@ -407,29 +439,17 @@ def build_spans(entries: list[dict]) -> tuple[list[dict], dict, list[str], str |
         totals["total_tokens"] += in_tok + out_tok
 
         for tu in _blocks(content, "tool_use"):
-            tid = str(tu.get("id") or uuid.uuid4().hex)
-            tname = tu.get("name") or "unknown"
-            tu_input = tu.get("input")
-            input_str = (
-                tu_input if isinstance(tu_input, str) else json.dumps(tu_input, ensure_ascii=False)
+            _append_tool_span(
+                spans,
+                totals,
+                tu,
+                parent_span_id=str(span_id),
+                ts=ts,
+                results_by_id=results_by_id,
+                errors_by_id=errors_by_id,
+                result_ts_by_id=result_ts_by_id,
+                attachments_by_tool_id=attachments_by_tool_id,
             )
-            tool_span = {
-                "span_id": tid,
-                "parent_span_id": str(span_id),
-                "name": f"Tool: {tname}",
-                "span_type": "tool",
-                "start_time": ts,
-                "end_time": result_ts_by_id.get(tid, ts),
-                "input": _truncate(input_str),
-                "output": _truncate(results_by_id.get(tid, "")) or None,
-                "status": "error" if errors_by_id.get(tid) else "ok",
-                "attributes": {"tool_name": tname, "tool_id": tid},
-            }
-            tool_atts = attachments_by_tool_id.get(tid)
-            if tool_atts:
-                tool_span["attachments"] = tool_atts
-            spans.append(tool_span)
-            totals["tool_call_count"] += 1
 
         prev_ts = ts
 
@@ -437,6 +457,42 @@ def build_spans(entries: list[dict]) -> tuple[list[dict], dict, list[str], str |
     return spans, totals, models, None
 
 
+def _append_tool_span(
+    spans: list[dict],
+    totals: dict,
+    tu: dict,
+    *,
+    parent_span_id: str,
+    ts: str,
+    results_by_id: dict[str, str],
+    errors_by_id: dict[str, bool],
+    result_ts_by_id: dict[str, str],
+    attachments_by_tool_id: dict[str, list[dict]],
+) -> None:
+    """Append one ``tool`` child span for a ``tool_use`` block to ``spans``."""
+    tid = str(tu.get("id") or uuid.uuid4().hex)
+    tname = tu.get("name") or "unknown"
+    tu_input = tu.get("input")
+    input_str = tu_input if isinstance(tu_input, str) else json.dumps(tu_input, ensure_ascii=False)
+    tool_span = {
+        "span_id": tid,
+        "parent_span_id": parent_span_id,
+        "name": f"Tool: {tname}",
+        "span_type": "tool",
+        "start_time": ts,
+        "end_time": result_ts_by_id.get(tid, ts),
+        "input": _truncate(input_str),
+        "output": _truncate(results_by_id.get(tid, "")) or None,
+        "status": "error" if errors_by_id.get(tid) else "ok",
+        "attributes": {"tool_name": tname, "tool_id": tid},
+    }
+    tool_atts = attachments_by_tool_id.get(tid)
+    if tool_atts:
+        tool_span["attachments"] = tool_atts
+    spans.append(tool_span)
+    totals["tool_call_count"] += 1
+
+
 def user_ref() -> str:
     """Resolve the engineer's real identity for attribution.
 
@@ -537,42 +593,19 @@ def post_event(event: dict) -> bool:
         return False
 
 
-def _state_file(key: str) -> Path:
-    """Per-session state file.
-
-    One file per session key, NOT one shared JSON: with the shared file two
-    concurrent sessions raced load→save and the last writer clobbered the other
-    session's offset back, so its next fire re-read (and re-sent) transcript
-    chunks it had already shipped.
-    """
-    return STATE_DIR / f"claude_code_state.{key[:32]}.json"
-
-
-def load_state(key: str) -> dict:
-    f = _state_file(key)
+def load_state() -> dict:
     try:
-        if f.exists():
-            return {key: json.loads(f.read_text(encoding="utf-8"))}
+        return json.loads(STATE_FILE.read_text(encoding="utf-8")) if STATE_FILE.exists() else {}
     except Exception:
         return {}
-    # One-time migration: pick this session's entry out of the legacy shared file.
-    try:
-        if STATE_FILE.exists():
-            legacy = json.loads(STATE_FILE.read_text(encoding="utf-8"))
-            if key in legacy:
-                return {key: legacy[key]}
-    except Exception:
-        pass
-    return {}
 
 
-def save_state(state: dict, key: str) -> None:
+def save_state(state: dict) -> None:
     try:
         STATE_DIR.mkdir(parents=True, exist_ok=True)
-        f = _state_file(key)
-        tmp = f.with_suffix(".tmp")
-        tmp.write_text(json.dumps(state.get(key) or {}, sort_keys=True), encoding="utf-8")
-        os.replace(tmp, f)
+        tmp = STATE_FILE.with_suffix(".tmp")
+        tmp.write_text(json.dumps(state, sort_keys=True), encoding="utf-8")
+        os.replace(tmp, STATE_FILE)
     except Exception:
         pass
 
@@ -583,10 +616,10 @@ def build_event(payload: dict) -> dict | None:
     if not session_id or path is None:
         return None
 
+    state = load_state()
     key = hashlib.sha256(f"{session_id}::{path}".encode()).hexdigest()
-    state = load_state(key)
     entries = read_new_entries(path, state, key)
-    save_state(state, key)
+    save_state(state)
     if not entries:
         return None
 
@@ -595,12 +628,7 @@ def build_event(payload: dict) -> dict | None:
         return None
 
     repo = Path(cwd).name if cwd else None
-    # Day-stable trace id (like the Cursor hook): every fire for a session
-    # upserts the SAME trace, so a re-sent chunk (offset race, retry) replaces
-    # its span rows in the ReplacingMergeTree instead of minting a new trace
-    # per second and double-counting. The date suffix splits multi-day sessions.
-    day = datetime.now(timezone.utc).strftime("%Y-%m-%d")
-    src_trace = f"{session_id}:{day}"
+    src_trace = f"{session_id}:{int(time.time())}"
     trace_id = str(uuid.uuid5(_TRACE_NAMESPACE, f"{SOURCE}:{src_trace}"))
     times = [s["start_time"] for s in spans]
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "octarin-cli",
-  "version": "0.3.3",
+  "version": "0.3.4",
   "description": "Octarin's per-user CLI: install AI-coding capture (`octarin init` / `init-repo`) and authorize a machine (`octarin login`). Streams your Claude Code / Cursor / Codex usage to your Octarin workspace.",
   "keywords": [
     "octarin",