octarin-cli 0.3.3 → 0.4.0

package/assets/claude_code/hook.py

@@ -27,6 +27,7 @@ import os
 import ssl
 import subprocess
 import sys
+import urllib.parse
 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.
 
@@ -624,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.3",
+  "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",