@respan/cli 0.5.2 → 0.6.0

package/dist/hooks/claude-code.cjs

@@ -0,0 +1,951 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/hooks/claude-code.ts
+var fs2 = __toESM(require("node:fs"), 1);
+var os2 = __toESM(require("node:os"), 1);
+var path2 = __toESM(require("node:path"), 1);
+
+// src/hooks/shared.ts
+var fs = __toESM(require("node:fs"), 1);
+var os = __toESM(require("node:os"), 1);
+var path = __toESM(require("node:path"), 1);
+function resolveTracesEndpoint(baseUrl) {
+  const DEFAULT = "https://api.respan.ai/api/v2/traces";
+  if (!baseUrl) return DEFAULT;
+  const normalized = baseUrl.replace(/\/+$/, "");
+  if (normalized.endsWith("/api")) return `${normalized}/v2/traces`;
+  return `${normalized}/api/v2/traces`;
+}
+var _logFile = null;
+var _debug = false;
+function initLogging(logFile, debug2) {
+  _logFile = logFile;
+  _debug = debug2;
+  const dir = path.dirname(logFile);
+  fs.mkdirSync(dir, { recursive: true });
+}
+function log(level, message) {
+  if (!_logFile) return;
+  const ts = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19);
+  fs.appendFileSync(_logFile, `${ts} [${level}] ${message}
+`);
+}
+function debug(message) {
+  if (_debug) log("DEBUG", message);
+}
+var DEFAULT_BASE_URL = "https://api.respan.ai/api";
+function resolveCredentials() {
+  let apiKey = process.env.RESPAN_API_KEY ?? "";
+  let baseUrl = process.env.RESPAN_BASE_URL ?? DEFAULT_BASE_URL;
+  if (!apiKey) {
+    const credsFile = path.join(os.homedir(), ".respan", "credentials.json");
+    if (fs.existsSync(credsFile)) {
+      try {
+        const creds = JSON.parse(fs.readFileSync(credsFile, "utf-8"));
+        const configFile = path.join(os.homedir(), ".respan", "config.json");
+        let profile = "default";
+        if (fs.existsSync(configFile)) {
+          const cfg = JSON.parse(fs.readFileSync(configFile, "utf-8"));
+          profile = cfg.activeProfile ?? "default";
+        }
+        const cred = creds[profile] ?? {};
+        apiKey = cred.apiKey ?? cred.accessToken ?? "";
+        if (!baseUrl || baseUrl === DEFAULT_BASE_URL) {
+          baseUrl = cred.baseUrl ?? baseUrl;
+        }
+        if (baseUrl && !baseUrl.replace(/\/+$/, "").endsWith("/api")) {
+          baseUrl = baseUrl.replace(/\/+$/, "") + "/api";
+        }
+        if (apiKey) {
+          debug(`Using API key from credentials.json (profile: ${profile})`);
+        }
+      } catch (e) {
+        debug(`Failed to read credentials.json: ${e}`);
+      }
+    }
+  }
+  if (!apiKey) return null;
+  return { apiKey, baseUrl };
+}
+var KNOWN_CONFIG_KEYS = /* @__PURE__ */ new Set([
+  "customer_id",
+  "span_name",
+  "workflow_name",
+  "base_url",
+  "project_id"
+]);
+function loadRespanConfig(configPath) {
+  if (!fs.existsSync(configPath)) {
+    return { fields: {}, properties: {} };
+  }
+  try {
+    const raw = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+      return { fields: {}, properties: {} };
+    }
+    const fields = {};
+    const properties = {};
+    for (const [k, v] of Object.entries(raw)) {
+      if (KNOWN_CONFIG_KEYS.has(k)) {
+        fields[k] = String(v);
+      } else {
+        properties[k] = String(v);
+      }
+    }
+    return { fields, properties };
+  } catch (e) {
+    debug(`Failed to load config from ${configPath}: ${e}`);
+    return { fields: {}, properties: {} };
+  }
+}
+function loadState(statePath) {
+  if (!fs.existsSync(statePath)) return {};
+  try {
+    return JSON.parse(fs.readFileSync(statePath, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function saveState(statePath, state) {
+  const dir = path.dirname(statePath);
+  fs.mkdirSync(dir, { recursive: true });
+  const tmpPath = statePath + ".tmp." + process.pid;
+  try {
+    fs.writeFileSync(tmpPath, JSON.stringify(state, null, 2));
+    fs.renameSync(tmpPath, statePath);
+  } catch (e) {
+    try {
+      fs.unlinkSync(tmpPath);
+    } catch {
+    }
+    fs.writeFileSync(statePath, JSON.stringify(state, null, 2));
+  }
+}
+function acquireLock(lockPath, timeoutMs = 5e3) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    try {
+      fs.mkdirSync(lockPath);
+      return () => {
+        try {
+          fs.rmdirSync(lockPath);
+        } catch {
+        }
+      };
+    } catch {
+      const waitMs = Math.min(100, deadline - Date.now());
+      if (waitMs > 0) {
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, waitMs);
+      }
+    }
+  }
+  debug("Could not acquire lock within timeout, proceeding without lock");
+  return () => {
+  };
+}
+function nowISO() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function parseTimestamp(ts) {
+  try {
+    const d = new Date(ts);
+    return isNaN(d.getTime()) ? null : d;
+  } catch {
+    return null;
+  }
+}
+function latencySeconds(start, end) {
+  const s = parseTimestamp(start);
+  const e = parseTimestamp(end);
+  if (s && e) return (e.getTime() - s.getTime()) / 1e3;
+  return void 0;
+}
+function truncate(text, maxChars = 4e3) {
+  if (text.length <= maxChars) return text;
+  return text.slice(0, maxChars) + "\n... (truncated)";
+}
+function addDefaultsToAll(spans) {
+  return spans;
+}
+function resolveSpanFields(config, defaults) {
+  const fields = config?.fields ?? {};
+  return {
+    workflowName: process.env.RESPAN_WORKFLOW_NAME ?? fields.workflow_name ?? defaults.workflowName,
+    spanName: process.env.RESPAN_SPAN_NAME ?? fields.span_name ?? defaults.spanName,
+    customerId: process.env.RESPAN_CUSTOMER_ID ?? fields.customer_id ?? ""
+  };
+}
+function buildMetadata(config, base = {}) {
+  const metadata = { ...base };
+  if (config?.properties) {
+    Object.assign(metadata, config.properties);
+  }
+  const envMetadata = process.env.RESPAN_METADATA;
+  if (envMetadata) {
+    try {
+      const extra = JSON.parse(envMetadata);
+      if (typeof extra === "object" && extra !== null) {
+        Object.assign(metadata, extra);
+      }
+    } catch {
+    }
+  }
+  return metadata;
+}
+function toOtlpValue(value) {
+  if (value === null || value === void 0) return null;
+  if (typeof value === "string") return { stringValue: value };
+  if (typeof value === "number") {
+    return Number.isInteger(value) ? { intValue: String(value) } : { doubleValue: value };
+  }
+  if (typeof value === "boolean") return { boolValue: value };
+  if (Array.isArray(value)) {
+    const values = value.map(toOtlpValue).filter(Boolean);
+    return { arrayValue: { values } };
+  }
+  if (typeof value === "object") {
+    const values = Object.entries(value).map(([k, v]) => {
+      const converted = toOtlpValue(v);
+      return converted ? { key: k, value: converted } : null;
+    }).filter(Boolean);
+    return { kvlistValue: { values } };
+  }
+  return { stringValue: String(value) };
+}
+function toOtlpAttributes(attrs) {
+  const result = [];
+  for (const [key, value] of Object.entries(attrs)) {
+    if (value === null || value === void 0) continue;
+    const converted = toOtlpValue(value);
+    if (converted) result.push({ key, value: converted });
+  }
+  return result;
+}
+function isoToNanos(iso) {
+  const d = new Date(iso);
+  if (isNaN(d.getTime())) return "0";
+  return String(BigInt(d.getTime()) * 1000000n);
+}
+function stringToTraceId(s) {
+  let hash = 0;
+  for (let i = 0; i < s.length; i++) {
+    hash = (hash << 5) - hash + s.charCodeAt(i) | 0;
+  }
+  let hash2 = 0;
+  for (let i = s.length - 1; i >= 0; i--) {
+    hash2 = (hash2 << 7) - hash2 + s.charCodeAt(i) | 0;
+  }
+  const hex1 = (hash >>> 0).toString(16).padStart(8, "0");
+  const hex2 = (hash2 >>> 0).toString(16).padStart(8, "0");
+  const hex3 = (s.length * 2654435761 >>> 0).toString(16).padStart(8, "0");
+  const hex4 = ((hash ^ hash2) >>> 0).toString(16).padStart(8, "0");
+  return (hex1 + hex2 + hex3 + hex4).slice(0, 32);
+}
+function stringToSpanId(s) {
+  let hash = 0;
+  for (let i = 0; i < s.length; i++) {
+    hash = (hash << 5) - hash + s.charCodeAt(i) | 0;
+  }
+  const hex1 = (hash >>> 0).toString(16).padStart(8, "0");
+  let hash2 = 0;
+  for (let i = s.length - 1; i >= 0; i--) {
+    hash2 = (hash2 << 3) - hash2 + s.charCodeAt(i) | 0;
+  }
+  const hex2 = (hash2 >>> 0).toString(16).padStart(8, "0");
+  return (hex1 + hex2).slice(0, 16);
+}
+function toOtlpPayload(spans) {
+  const otlpSpans = spans.map((span) => {
+    const attrs = {};
+    if (span.thread_identifier) attrs["respan.threads.thread_identifier"] = span.thread_identifier;
+    if (span.customer_identifier) attrs["respan.customer_params.customer_identifier"] = span.customer_identifier;
+    if (span.span_workflow_name) attrs["traceloop.workflow.name"] = span.span_workflow_name;
+    if (span.span_path) attrs["traceloop.entity.path"] = span.span_path;
+    const isRoot = !span.span_parent_id;
+    const isLlm = span.span_name.includes(".chat");
+    const isTool = span.span_name.startsWith("Tool:");
+    const isThinking = span.span_name.startsWith("Thinking") || span.span_name === "Reasoning";
+    if (isLlm) {
+      attrs["traceloop.span.kind"] = "task";
+      attrs["llm.request.type"] = "chat";
+    } else if (isTool) {
+      attrs["traceloop.span.kind"] = "tool";
+    } else if (isRoot) {
+      attrs["traceloop.span.kind"] = "workflow";
+    } else if (isThinking) {
+      attrs["traceloop.span.kind"] = "task";
+    }
+    if (span.model) attrs["gen_ai.request.model"] = span.model;
+    if (span.provider_id) attrs["gen_ai.system"] = span.provider_id;
+    if (span.prompt_tokens !== void 0) attrs["gen_ai.usage.prompt_tokens"] = span.prompt_tokens;
+    if (span.completion_tokens !== void 0) attrs["gen_ai.usage.completion_tokens"] = span.completion_tokens;
+    if (span.total_tokens !== void 0) attrs["llm.usage.total_tokens"] = span.total_tokens;
+    if (span.input) attrs["traceloop.entity.input"] = span.input;
+    if (span.output) attrs["traceloop.entity.output"] = span.output;
+    if (span.metadata && Object.keys(span.metadata).length > 0) {
+      attrs["respan.metadata"] = JSON.stringify(span.metadata);
+    }
+    attrs["respan.entity.log_method"] = "ts_tracing";
+    const startNanos = isoToNanos(span.start_time);
+    let endNanos = isoToNanos(span.timestamp);
+    if (startNanos === endNanos && span.latency && span.latency > 0) {
+      const startMs = new Date(span.start_time).getTime();
+      endNanos = String(BigInt(Math.round(startMs + span.latency * 1e3)) * 1000000n);
+    }
+    const otlpSpan = {
+      traceId: stringToTraceId(span.trace_unique_id),
+      spanId: stringToSpanId(span.span_unique_id),
+      name: span.span_name,
+      kind: isLlm ? 3 : 1,
+      // 3=CLIENT (LLM calls), 1=INTERNAL
+      startTimeUnixNano: startNanos,
+      endTimeUnixNano: endNanos,
+      attributes: toOtlpAttributes(attrs),
+      status: { code: 1 }
+      // STATUS_CODE_OK
+    };
+    if (span.span_parent_id) {
+      otlpSpan.parentSpanId = stringToSpanId(span.span_parent_id);
+    }
+    return otlpSpan;
+  });
+  return {
+    resourceSpans: [{
+      resource: {
+        attributes: toOtlpAttributes({
+          "service.name": "respan-cli-hooks"
+        })
+      },
+      scopeSpans: [{
+        scope: { name: "respan-cli-hooks", version: "0.5.3" },
+        spans: otlpSpans
+      }]
+    }]
+  };
+}
+async function sendSpans(spans, apiKey, baseUrl, context) {
+  const url = resolveTracesEndpoint(baseUrl);
+  const headers = {
+    "Authorization": `Bearer ${apiKey}`,
+    "Content-Type": "application/json",
+    "X-Respan-Dogfood": "1"
+    // Anti-recursion: prevent trace loops on ingest
+  };
+  const payload = toOtlpPayload(spans);
+  const body = JSON.stringify(payload);
+  const spanNames = spans.map((s) => s.span_name);
+  debug(`Sending ${spans.length} spans (${body.length} bytes) to ${url} for ${context}: ${spanNames.join(", ")}`);
+  if (_debug) {
+    const debugDir = _logFile ? path.dirname(_logFile) : os.tmpdir();
+    const debugFile = path.join(debugDir, `respan_spans_${context.replace(/\s+/g, "_")}.json`);
+    fs.writeFileSync(debugFile, body);
+    debug(`Dumped OTLP payload to ${debugFile}`);
+  }
+  for (let attempt = 0; attempt < 3; attempt++) {
+    try {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), 3e4);
+      const response = await fetch(url, {
+        method: "POST",
+        headers,
+        body,
+        signal: controller.signal
+      });
+      clearTimeout(timeout);
+      if (response.status < 400) {
+        const text = await response.text();
+        debug(`Sent ${spans.length} spans for ${context} (attempt ${attempt + 1}): ${text.slice(0, 300)}`);
+        return;
+      }
+      if (response.status < 500) {
+        const text = await response.text();
+        log("ERROR", `Spans rejected for ${context}: HTTP ${response.status} - ${text.slice(0, 200)}`);
+        return;
+      }
+      debug(`Server error for ${context} (attempt ${attempt + 1}), retrying...`);
+      await sleep(1e3);
+    } catch (e) {
+      if (attempt < 2) {
+        await sleep(1e3);
+      } else {
+        log("ERROR", `Failed to send spans for ${context}: ${e}`);
+      }
+    }
+  }
+  log("ERROR", `Failed to send ${spans.length} spans for ${context} after 3 attempts`);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/hooks/claude-code.ts
+var STATE_DIR = path2.join(os2.homedir(), ".claude", "state");
+var LOG_FILE = path2.join(STATE_DIR, "respan_hook.log");
+var STATE_FILE = path2.join(STATE_DIR, "respan_state.json");
+var LOCK_PATH = path2.join(STATE_DIR, "respan_hook.lock");
+var DEBUG_MODE = (process.env.CC_RESPAN_DEBUG ?? "").toLowerCase() === "true";
+var MAX_CHARS = parseInt(process.env.CC_RESPAN_MAX_CHARS ?? "4000", 10) || 4e3;
+initLogging(LOG_FILE, DEBUG_MODE);
+function getContent(msg) {
+  if (msg.message && typeof msg.message === "object") {
+    return msg.message.content;
+  }
+  return msg.content;
+}
+function isToolResult(msg) {
+  const content = getContent(msg);
+  if (Array.isArray(content)) {
+    return content.some(
+      (item) => typeof item === "object" && item !== null && item.type === "tool_result"
+    );
+  }
+  return false;
+}
+function getToolCalls(msg) {
+  const content = getContent(msg);
+  if (Array.isArray(content)) {
+    return content.filter(
+      (item) => typeof item === "object" && item !== null && item.type === "tool_use"
+    );
+  }
+  return [];
+}
+function getTextContent(msg) {
+  const content = getContent(msg);
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.map((item) => {
+      if (typeof item === "string") return item;
+      if (typeof item === "object" && item !== null) {
+        if (item.type === "text") return String(item.text ?? "");
+      }
+      return "";
+    }).filter(Boolean).join("\n");
+  }
+  return "";
+}
+function mergeAssistantParts(parts) {
+  if (parts.length === 0) return {};
+  const merged = [];
+  for (const part of parts) {
+    const content = getContent(part);
+    if (Array.isArray(content)) merged.push(...content);
+    else if (content) merged.push({ type: "text", text: String(content) });
+  }
+  const result = { ...parts[0] };
+  if (result.message && typeof result.message === "object") {
+    result.message = { ...result.message, content: merged };
+  } else {
+    result.content = merged;
+  }
+  return result;
+}
+function formatToolInput(toolName, toolInput) {
+  if (!toolInput) return "";
+  const input = toolInput;
+  if (["Write", "Edit", "MultiEdit"].includes(toolName) && typeof input === "object") {
+    const filePath = input.file_path ?? input.path ?? "";
+    const content = String(input.content ?? "");
+    let result = `File: ${filePath}
+`;
+    if (content) {
+      const preview = content.length > 2e3 ? content.slice(0, 2e3) + "..." : content;
+      result += `Content:
+${preview}`;
+    }
+    return truncate(result, MAX_CHARS);
+  }
+  if (toolName === "Read" && typeof input === "object") {
+    return `File: ${input.file_path ?? input.path ?? ""}`;
+  }
+  if (["Bash", "Shell"].includes(toolName) && typeof input === "object") {
+    return `Command: ${input.command ?? ""}`;
+  }
+  try {
+    return truncate(JSON.stringify(toolInput, null, 2), MAX_CHARS);
+  } catch {
+    return truncate(String(toolInput), MAX_CHARS);
+  }
+}
+function formatToolOutput(toolName, toolOutput) {
+  if (!toolOutput) return "";
+  if (typeof toolOutput === "string") return truncate(toolOutput, MAX_CHARS);
+  if (Array.isArray(toolOutput)) {
+    const parts = [];
+    let total = 0;
+    for (const item of toolOutput) {
+      if (typeof item === "object" && item !== null) {
+        const obj = item;
+        if (obj.type === "text") {
+          const text = String(obj.text ?? "");
+          if (total + text.length > MAX_CHARS) {
+            const remaining = MAX_CHARS - total;
+            if (remaining > 100) parts.push(text.slice(0, remaining) + "... (truncated)");
+            break;
+          }
+          parts.push(text);
+          total += text.length;
+        } else if (obj.type === "image") {
+          parts.push("[Image output]");
+        }
+      } else if (typeof item === "string") {
+        if (total + item.length > MAX_CHARS) break;
+        parts.push(item);
+        total += item.length;
+      }
+    }
+    return parts.join("\n");
+  }
+  try {
+    return truncate(JSON.stringify(toolOutput, null, 2), MAX_CHARS);
+  } catch {
+    return truncate(String(toolOutput), MAX_CHARS);
+  }
+}
+function createSpans(sessionId, turnNum, userMsg, assistantMsgs, toolResults, config) {
+  const spans = [];
+  const userText = getTextContent(userMsg);
+  const userTimestamp = String(userMsg.timestamp ?? "");
+  const textParts = assistantMsgs.map(getTextContent).filter(Boolean);
+  const finalOutput = textParts.join("\n");
+  let model = "claude";
+  let usage = null;
+  let requestId;
+  let stopReason;
+  let firstAssistantTs;
+  let lastAssistantTs;
+  for (const aMsg of assistantMsgs) {
+    if (typeof aMsg !== "object" || !aMsg.message) continue;
+    const msgObj = aMsg.message;
+    model = String(msgObj.model ?? model);
+    requestId = String(aMsg.requestId ?? requestId ?? "");
+    stopReason = String(msgObj.stop_reason ?? stopReason ?? "");
+    const ts = String(aMsg.timestamp ?? "");
+    if (ts) {
+      if (!firstAssistantTs) firstAssistantTs = ts;
+      lastAssistantTs = ts;
+    }
+    const msgUsage = msgObj.usage;
+    if (msgUsage) {
+      if (!usage) {
+        usage = { ...msgUsage };
+      } else {
+        for (const key of ["input_tokens", "output_tokens", "cache_creation_input_tokens", "cache_read_input_tokens"]) {
+          if (key in msgUsage) {
+            usage[key] = (usage[key] ?? 0) + Number(msgUsage[key]);
+          }
+        }
+        if (msgUsage.service_tier) usage.service_tier = msgUsage.service_tier;
+      }
+    }
+  }
+  const now = nowISO();
+  const startTimeStr = userTimestamp || firstAssistantTs || now;
+  const timestampStr = lastAssistantTs || firstAssistantTs || now;
+  const lat = latencySeconds(startTimeStr, timestampStr);
+  const promptMessages = [];
+  if (userText) promptMessages.push({ role: "user", content: userText });
+  const completionMessage = finalOutput ? { role: "assistant", content: finalOutput } : null;
+  const { workflowName, spanName, customerId } = resolveSpanFields(config, {
+    workflowName: "claude-code",
+    spanName: "claude-code"
+  });
+  const traceUniqueId = `${sessionId}_turn_${turnNum}`;
+  const threadId = `claudecode_${sessionId}`;
+  const metadata = buildMetadata(config, { claude_code_turn: turnNum });
+  if (requestId) metadata.request_id = requestId;
+  if (stopReason) metadata.stop_reason = stopReason;
+  const usageFields = {};
+  if (usage) {
+    const pt = Number(usage.input_tokens ?? 0);
+    const ct = Number(usage.output_tokens ?? 0);
+    usageFields.prompt_tokens = pt;
+    usageFields.completion_tokens = ct;
+    if (pt + ct > 0) usageFields.total_tokens = pt + ct;
+    const cacheCreation = Number(usage.cache_creation_input_tokens ?? 0);
+    const cacheRead = Number(usage.cache_read_input_tokens ?? 0);
+    if (cacheCreation > 0) usageFields.prompt_tokens_details = { cache_creation_tokens: cacheCreation };
+    if (cacheRead > 0) {
+      usageFields.prompt_tokens_details = {
+        ...usageFields.prompt_tokens_details,
+        cached_tokens: cacheRead
+      };
+    }
+    if (usage.service_tier) metadata.service_tier = String(usage.service_tier);
+  }
+  const rootSpanId = `claudecode_${traceUniqueId}_root`;
+  spans.push({
+    trace_unique_id: traceUniqueId,
+    thread_identifier: threadId,
+    customer_identifier: customerId,
+    span_unique_id: rootSpanId,
+    span_name: spanName,
+    span_workflow_name: workflowName,
+    model,
+    provider_id: "",
+    span_path: "",
+    input: promptMessages.length ? JSON.stringify(promptMessages) : "",
+    output: completionMessage ? JSON.stringify(completionMessage) : "",
+    timestamp: timestampStr,
+    start_time: startTimeStr,
+    metadata,
+    ...lat !== void 0 ? { latency: lat } : {}
+  });
+  const genStart = firstAssistantTs || startTimeStr;
+  const genEnd = lastAssistantTs || timestampStr;
+  const genLat = latencySeconds(genStart, genEnd);
+  spans.push({
+    trace_unique_id: traceUniqueId,
+    span_unique_id: `claudecode_${traceUniqueId}_gen`,
+    span_parent_id: rootSpanId,
+    span_name: "claude.chat",
+    span_workflow_name: workflowName,
+    span_path: "claude_chat",
+    model,
+    provider_id: "anthropic",
+    metadata: {},
+    input: promptMessages.length ? JSON.stringify(promptMessages) : "",
+    output: completionMessage ? JSON.stringify(completionMessage) : "",
+    prompt_messages: promptMessages,
+    completion_message: completionMessage,
+    timestamp: genEnd,
+    start_time: genStart,
+    ...genLat !== void 0 ? { latency: genLat } : {},
+    ...usageFields
+  });
+  let thinkingNum = 0;
+  for (const aMsg of assistantMsgs) {
+    if (typeof aMsg !== "object" || !aMsg.message) continue;
+    const content = aMsg.message.content;
+    if (!Array.isArray(content)) continue;
+    for (const item of content) {
+      if (typeof item === "object" && item !== null && item.type === "thinking") {
+        const thinkingText = String(item.thinking ?? "");
+        if (!thinkingText) continue;
+        thinkingNum++;
+        const thinkingTs = String(aMsg.timestamp ?? timestampStr);
+        spans.push({
+          trace_unique_id: traceUniqueId,
+          span_unique_id: `claudecode_${traceUniqueId}_thinking_${thinkingNum}`,
+          span_parent_id: rootSpanId,
+          span_name: `Thinking ${thinkingNum}`,
+          span_workflow_name: workflowName,
+          span_path: "thinking",
+          provider_id: "",
+          metadata: {},
+          input: "",
+          output: thinkingText,
+          timestamp: thinkingTs,
+          start_time: thinkingTs
+        });
+      }
+    }
+  }
+  const toolCallMap = /* @__PURE__ */ new Map();
+  for (const aMsg of assistantMsgs) {
+    for (const tc of getToolCalls(aMsg)) {
+      const id = String(tc.id ?? "");
+      toolCallMap.set(id, {
+        name: tc.name ?? "unknown",
+        input: tc.input,
+        id,
+        timestamp: aMsg.timestamp
+      });
+    }
+  }
+  for (const tr of toolResults) {
+    const trContent = getContent(tr);
+    const trMeta = {};
+    if (typeof tr === "object" && tr.toolUseResult && typeof tr.toolUseResult === "object") {
+      const tur = tr.toolUseResult;
+      for (const [src, dst] of [["durationMs", "duration_ms"], ["numFiles", "num_files"], ["filenames", "filenames"], ["truncated", "truncated"]]) {
+        if (src in tur) trMeta[dst] = tur[src];
+      }
+    }
+    if (Array.isArray(trContent)) {
+      for (const item of trContent) {
+        if (typeof item === "object" && item !== null && item.type === "tool_result") {
+          const toolUseId = String(item.tool_use_id ?? "");
+          const existing = toolCallMap.get(toolUseId);
+          if (existing) {
+            existing.output = item.content;
+            existing.result_metadata = trMeta;
+            existing.result_timestamp = tr.timestamp;
+          }
+        }
+      }
+    }
+  }
+  let toolNum = 0;
+  for (const [, td] of toolCallMap) {
+    toolNum++;
+    const toolTs = String(td.result_timestamp ?? td.timestamp ?? timestampStr);
+    const toolStart = String(td.timestamp ?? startTimeStr);
+    const toolLat = latencySeconds(toolStart, toolTs);
+    const durationMs = td.result_metadata?.duration_ms;
+    spans.push({
+      trace_unique_id: traceUniqueId,
+      span_unique_id: `claudecode_${traceUniqueId}_tool_${toolNum}`,
+      span_parent_id: rootSpanId,
+      span_name: `Tool: ${td.name}`,
+      span_workflow_name: workflowName,
+      span_path: `tool_${String(td.name).toLowerCase()}`,
+      provider_id: "",
+      metadata: td.result_metadata ?? {},
+      input: formatToolInput(String(td.name), td.input),
+      output: formatToolOutput(String(td.name), td.output),
+      timestamp: toolTs,
+      start_time: toolStart,
+      ...durationMs ? { latency: Number(durationMs) / 1e3 } : toolLat !== void 0 ? { latency: toolLat } : {}
+    });
+  }
+  return addDefaultsToAll(spans);
+}
+function processTranscript(sessionId, transcriptFile, state, apiKey, baseUrl, config) {
+  const sessionState = state[sessionId] ?? {};
+  const lastLine = Number(sessionState.last_line ?? 0);
+  const turnCount = Number(sessionState.turn_count ?? 0);
+  const content = fs2.readFileSync(transcriptFile, "utf-8");
+  const lines = content.trim().split("\n");
+  const totalLines = lines.length;
+  if (lastLine >= totalLines) {
+    debug(`No new lines to process (last: ${lastLine}, total: ${totalLines})`);
+    return { turnsProcessed: 0, lastCommittedLine: lastLine };
+  }
+  const newMessages = [];
+  for (let i = lastLine; i < totalLines; i++) {
+    try {
+      if (lines[i].trim()) {
+        const msg = JSON.parse(lines[i]);
+        newMessages.push({ ...msg, _lineIdx: i });
+      }
+    } catch {
+    }
+  }
+  if (newMessages.length === 0) return { turnsProcessed: 0, lastCommittedLine: lastLine };
+  debug(`Processing ${newMessages.length} new messages`);
+  let turnsProcessed = 0;
+  let lastCommittedLine = lastLine;
+  let currentUser = null;
+  let currentUserLine = lastLine;
+  let currentAssistants = [];
+  let currentAssistantParts = [];
+  let currentMsgId = null;
+  let currentToolResults = [];
+  const commitTurn = () => {
+    turnsProcessed++;
+    const turnNum = turnCount + turnsProcessed;
+    const spans = createSpans(sessionId, turnNum, currentUser, currentAssistants, currentToolResults, config);
+    sendSpans(spans, apiKey, baseUrl, `turn_${turnNum}`);
+    lastCommittedLine = totalLines;
+  };
+  for (const msg of newMessages) {
+    const lineIdx = msg._lineIdx;
+    delete msg._lineIdx;
+    const role = String(msg.type ?? msg.message?.role ?? "");
+    if (role === "user") {
+      if (isToolResult(msg)) {
+        currentToolResults.push(msg);
+        continue;
+      }
+      if (currentMsgId && currentAssistantParts.length) {
+        currentAssistants.push(mergeAssistantParts(currentAssistantParts));
+        currentAssistantParts = [];
+        currentMsgId = null;
+      }
+      if (currentUser && currentAssistants.length) {
+        commitTurn();
+        lastCommittedLine = lineIdx;
+      }
+      currentUser = msg;
+      currentUserLine = lineIdx;
+      currentAssistants = [];
+      currentAssistantParts = [];
+      currentMsgId = null;
+      currentToolResults = [];
+    } else if (role === "assistant") {
+      let msgId = null;
+      if (typeof msg === "object" && msg.message) {
+        msgId = String(msg.message.id ?? "") || null;
+      }
+      if (!msgId) {
+        currentAssistantParts.push(msg);
+      } else if (msgId === currentMsgId) {
+        currentAssistantParts.push(msg);
+      } else {
+        if (currentMsgId && currentAssistantParts.length) {
+          currentAssistants.push(mergeAssistantParts(currentAssistantParts));
+        }
+        currentMsgId = msgId;
+        currentAssistantParts = [msg];
+      }
+    }
+  }
+  if (currentMsgId && currentAssistantParts.length) {
+    currentAssistants.push(mergeAssistantParts(currentAssistantParts));
+  }
+  if (currentUser && currentAssistants.length) {
+    const hasText = currentAssistants.some((m) => getTextContent(m));
+    if (hasText) {
+      commitTurn();
+      lastCommittedLine = totalLines;
+    } else {
+      lastCommittedLine = currentUserLine;
+      debug("Turn has assistant msgs but no text output yet, will retry");
+    }
+  } else {
+    if (currentUser) {
+      lastCommittedLine = currentUserLine;
+      debug(`Incomplete turn at line ${currentUserLine}, will retry next run`);
+    } else if (lastCommittedLine === lastLine) {
+      lastCommittedLine = totalLines;
+    }
+  }
+  return { turnsProcessed, lastCommittedLine };
+}
+function readStdinPayload() {
+  if (process.stdin.isTTY) return null;
+  try {
+    const raw = fs2.readFileSync(0, "utf-8");
+    if (!raw.trim()) return null;
+    const payload = JSON.parse(raw);
+    const sessionId = String(payload.session_id ?? "");
+    const transcriptPath = String(payload.transcript_path ?? "");
+    if (!sessionId || !transcriptPath) return null;
+    if (!fs2.existsSync(transcriptPath)) return null;
+    debug(`Got transcript from stdin: session=${sessionId}, path=${transcriptPath}`);
+    return { sessionId, transcriptPath };
+  } catch {
+    return null;
+  }
+}
+function findLatestTranscript() {
+  const projectsDir = path2.join(os2.homedir(), ".claude", "projects");
+  if (!fs2.existsSync(projectsDir)) return null;
+  let latestFile = null;
+  let latestMtime = 0;
+  for (const projEntry of fs2.readdirSync(projectsDir)) {
+    const projDir = path2.join(projectsDir, projEntry);
+    if (!fs2.statSync(projDir).isDirectory()) continue;
+    for (const file of fs2.readdirSync(projDir)) {
+      if (!file.endsWith(".jsonl")) continue;
+      const full = path2.join(projDir, file);
+      const mtime = fs2.statSync(full).mtimeMs;
+      if (mtime > latestMtime) {
+        latestMtime = mtime;
+        latestFile = full;
+      }
+    }
+  }
+  if (!latestFile) return null;
+  try {
+    const firstLine = fs2.readFileSync(latestFile, "utf-8").split("\n")[0];
+    if (!firstLine) return null;
+    const firstMsg = JSON.parse(firstLine);
+    const sessionId = String(firstMsg.sessionId ?? path2.basename(latestFile, ".jsonl"));
+    return { sessionId, transcriptPath: latestFile };
+  } catch {
+    return null;
+  }
+}
+async function main() {
+  const scriptStart = Date.now();
+  debug("Hook started");
+  if ((process.env.TRACE_TO_RESPAN ?? "").toLowerCase() !== "true") {
+    debug("Tracing disabled (TRACE_TO_RESPAN != true)");
+    process.exit(0);
+  }
+  const creds = resolveCredentials();
+  if (!creds) {
+    log("ERROR", "No API key found. Run: respan auth login");
+    process.exit(0);
+  }
+  const payload = readStdinPayload() ?? findLatestTranscript();
+  if (!payload) {
+    debug("No transcript file found");
+    process.exit(0);
+  }
+  const { sessionId, transcriptPath } = payload;
+  debug(`Processing session: ${sessionId}`);
+  let config = null;
+  try {
+    const content = fs2.readFileSync(transcriptPath, "utf-8");
+    const lines = content.split("\n");
+    let cwd = "";
+    for (const line of lines.slice(0, 5)) {
+      if (!line.trim()) continue;
+      try {
+        const msg = JSON.parse(line);
+        if (msg.cwd) {
+          cwd = String(msg.cwd);
+          break;
+        }
+      } catch {
+      }
+    }
+    if (cwd) {
+      config = loadRespanConfig(path2.join(cwd, ".claude", "respan.json"));
+      debug(`Loaded respan.json config from ${cwd}`);
+    }
+  } catch (e) {
+    debug(`Failed to load config: ${e}`);
+  }
+  const maxAttempts = 3;
+  let turns = 0;
+  try {
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      const unlock = acquireLock(LOCK_PATH);
+      try {
+        const state = loadState(STATE_FILE);
+        const result = processTranscript(sessionId, transcriptPath, state, creds.apiKey, creds.baseUrl, config);
+        turns = result.turnsProcessed;
+        state[sessionId] = {
+          last_line: result.lastCommittedLine,
+          turn_count: Number(state[sessionId]?.turn_count ?? 0) + turns,
+          updated: nowISO()
+        };
+        saveState(STATE_FILE, state);
+      } finally {
+        unlock?.();
+      }
+      if (turns > 0) break;
+      if (attempt < maxAttempts - 1) {
+        const delay = 500 * (attempt + 1);
+        debug(`No turns processed (attempt ${attempt + 1}/${maxAttempts}), retrying in ${delay}ms...`);
+        await new Promise((r) => setTimeout(r, delay));
+      }
+    }
+    const duration = (Date.now() - scriptStart) / 1e3;
+    log("INFO", `Processed ${turns} turns in ${duration.toFixed(1)}s`);
+    if (duration > 180) log("WARN", `Hook took ${duration.toFixed(1)}s (>3min)`);
+  } catch (e) {
+    log("ERROR", `Failed to process transcript: ${e}`);
+    if (DEBUG_MODE) debug(String(e.stack ?? e));
+  }
+}
+main().catch((e) => {
+  log("ERROR", `Hook crashed: ${e}`);
+  process.exit(1);
+});