octarin-cli 0.3.4 → 0.4.0

package/assets/claude_code/hook.py

@@ -27,7 +27,7 @@ import os
 import ssl
 import subprocess
 import sys
-import time
+import urllib.parse
 import urllib.request
 import uuid
 from datetime import datetime, timezone
@@ -593,19 +593,42 @@ def post_event(event: dict) -> bool:
         return False
 
 
-def load_state() -> dict:
+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)
     try:
-        return json.loads(STATE_FILE.read_text(encoding="utf-8")) if STATE_FILE.exists() else {}
+        if f.exists():
+            return {key: json.loads(f.read_text(encoding="utf-8"))}
     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) -> None:
+def save_state(state: dict, key: str) -> None:
     try:
         STATE_DIR.mkdir(parents=True, exist_ok=True)
-        tmp = STATE_FILE.with_suffix(".tmp")
-        tmp.write_text(json.dumps(state, sort_keys=True), encoding="utf-8")
-        os.replace(tmp, STATE_FILE)
+        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)
     except Exception:
         pass
 
@@ -616,10 +639,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)
+    save_state(state, key)
     if not entries:
         return None
 
@@ -628,7 +651,12 @@ def build_event(payload: dict) -> dict | None:
         return None
 
     repo = Path(cwd).name if cwd else None
-    src_trace = f"{session_id}:{int(time.time())}"
+    # 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}"
     trace_id = str(uuid.uuid5(_TRACE_NAMESPACE, f"{SOURCE}:{src_trace}"))
     times = [s["start_time"] for s in spans]
 
@@ -652,9 +680,70 @@ def build_event(payload: dict) -> dict | None:
     }
 
 
+def _api_base() -> str:
+    """The API base URL (no trailing slash), derived from the capture env.
+
+    Prefers OCTARIN_API_BASE; otherwise strips ``/v1/ingest`` off OCTARIN_INGEST_URL.
+    """
+    base = (os.environ.get("OCTARIN_API_BASE") or "").rstrip("/")
+    if base:
+        return base
+    url = (os.environ.get("OCTARIN_INGEST_URL") or "").rstrip("/")
+    if url.endswith("/v1/ingest"):
+        return url[: -len("/v1/ingest")]
+    return ""
+
+
+def inject_context(payload: dict) -> None:
+    """SessionStart: fetch the org's Memory pack and emit it as additionalContext.
+
+    Octarin Memory is the team's durable, shared knowledge (decisions, conventions,
+    gotchas). On a new session we pull the pack for this repo and hand it to Claude
+    Code as ``hookSpecificOutput.additionalContext`` so the agent starts with the
+    team's hard-won context instead of rediscovering it. Fail-open and silent: any
+    problem (no key, network, empty) prints nothing and the session proceeds.
+    """
+    base = _api_base()
+    api_key = os.environ.get("OCTARIN_API_KEY", "")
+    if not base or not api_key:
+        return
+    cwd = payload.get("cwd") or payload.get("workspace") or ""
+    repo = Path(cwd).name if cwd else ""
+    qs = urllib.parse.urlencode({"repo": repo, "limit": "8"})
+    req = urllib.request.Request(f"{base}/v1/memory/agent-context?{qs}", method="GET")
+    req.add_header("Authorization", f"Bearer {api_key}")
+    try:
+        with urllib.request.urlopen(req, timeout=HTTP_TIMEOUT_S, context=_ssl_context()) as resp:
+            if not (200 <= resp.status < 300):
+                return
+            data = json.loads(resp.read().decode("utf-8"))
+    except Exception:
+        return
+    context = ((data or {}).get("context") or "").strip()
+    if not context:
+        return
+    header = (
+        "# Octarin Memory — durable decisions, conventions & gotchas your team has "
+        "recorded (shared across everyone). Treat as authoritative context:\n"
+    )
+    out = {
+        "hookSpecificOutput": {
+            "hookEventName": "SessionStart",
+            "additionalContext": header + context,
+        }
+    }
+    sys.stdout.write(json.dumps(out))
+
+
 def main() -> int:
     try:
         payload = read_payload()
+        # One script, two Claude Code hooks: SessionStart injects Memory context;
+        # Stop (the default) captures the finished turn.
+        event_name = str(payload.get("hook_event_name") or payload.get("hookEventName") or "")
+        if event_name == "SessionStart":
+            inject_context(payload)
+            return 0
         event = build_event(payload)
         if event is None:
             return 0

package/assets/repo-template/dot-claude/octarin/hook.py

@@ -391,6 +391,11 @@ def build_spans(  # noqa: PLR0915 - top-down transcript parser; splitting it
 
     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
@@ -417,6 +422,32 @@ def build_spans(  # noqa: PLR0915 - top-down transcript parser; splitting it
         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,
+                    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)
@@ -443,6 +474,7 @@ def build_spans(  # noqa: PLR0915 - top-down transcript parser; splitting it
         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
 
@@ -452,31 +484,16 @@ def build_spans(  # noqa: PLR0915 - top-down transcript parser; splitting it
         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,
+                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": "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
 
@@ -484,6 +501,43 @@ def build_spans(  # noqa: PLR0915 - top-down transcript parser; splitting it
     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],
+    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": "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.
 

package/dist/init.js

@@ -129,13 +129,22 @@ async function readJson(path) {
 function hasOctarin(value) {
     return JSON.stringify(value ?? "").toLowerCase().includes("octarin");
 }
-/** Merge the Stop hook into ~/.claude/settings.json, preserving other settings. */
+/**
+ * Merge Octarin's Claude Code hooks into ~/.claude/settings.json, preserving
+ * other settings. Two events, ONE wrapper command (hook.py branches on the
+ * hook event): **Stop** captures the finished turn; **SessionStart** injects the
+ * team's shared Octarin Memory pack as context so a new session starts with the
+ * org's durable decisions/conventions/gotchas. Idempotent (deduped by the
+ * "octarin" marker in the command).
+ */
 async function mergeClaudeSettings(path, command) {
     const json = await readJson(path);
     const hooks = (json.hooks ??= {});
-    const stop = (Array.isArray(hooks.Stop) ? hooks.Stop : (hooks.Stop = []));
-    if (!stop.some(hasOctarin)) {
-        stop.push({ hooks: [{ type: "command", command }] });
+    for (const event of ["Stop", "SessionStart"]) {
+        const arr = (Array.isArray(hooks[event]) ? hooks[event] : (hooks[event] = []));
+        if (!arr.some(hasOctarin)) {
+            arr.push({ hooks: [{ type: "command", command }] });
+        }
     }
     await fs.mkdir(dirname(path), { recursive: true });
     await fs.writeFile(path, JSON.stringify(json, null, 2) + "\n");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "octarin-cli",
-  "version": "0.3.4",
+  "version": "0.4.0",
   "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",