@neatlogs/claude-code 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1121 @@
+"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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  getConfigPath: () => getConfigPath,
+  handleHook: () => handleHook,
+  loadConfig: () => loadConfig,
+  registerHooks: () => registerHooks,
+  updateConfig: () => updateConfig
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/hook-handler.ts
+var import_fs5 = require("fs");
+
+// src/config.ts
+var import_fs = require("fs");
+var import_os = require("os");
+var import_path = require("path");
+var CONFIG_PATH = (0, import_path.join)((0, import_os.homedir)(), ".config", "neatlogs", "config.json");
+function loadConfig() {
+  let file = {};
+  try {
+    if ((0, import_fs.existsSync)(CONFIG_PATH)) {
+      file = JSON.parse((0, import_fs.readFileSync)(CONFIG_PATH, "utf-8"));
+    }
+  } catch (err) {
+    console.warn(`[neatlogs/claude-code] Failed to read config: ${err.message}`);
+  }
+  const systemUser = (() => {
+    try {
+      return (0, import_os.userInfo)().username;
+    } catch (err) {
+      console.warn(`[neatlogs/claude-code] Could not resolve OS username: ${err.message}`);
+      return "unknown";
+    }
+  })();
+  return {
+    apiKey: process.env["NEATLOGS_API_KEY"] ?? file.api_key ?? "",
+    endpoint: process.env["NEATLOGS_ENDPOINT"] ?? file.endpoint ?? "https://staging-cloud.neatlogs.com",
+    userId: process.env["NEATLOGS_USER_ID"] ?? file.user_id ?? systemUser,
+    debug: process.env["NEATLOGS_DEBUG"] === "true" ? true : file.debug ?? false
+  };
+}
+function getConfigPath() {
+  return CONFIG_PATH;
+}
+function updateConfig(patch) {
+  const dir = (0, import_path.dirname)(CONFIG_PATH);
+  (0, import_fs.mkdirSync)(dir, { recursive: true });
+  let existing = {};
+  try {
+    if ((0, import_fs.existsSync)(CONFIG_PATH)) {
+      existing = JSON.parse((0, import_fs.readFileSync)(CONFIG_PATH, "utf-8"));
+    }
+  } catch (err) {
+    console.warn(`[neatlogs/claude-code] Failed to read existing config: ${err.message}`);
+  }
+  (0, import_fs.writeFileSync)(CONFIG_PATH, JSON.stringify({ ...existing, ...patch }, null, 2) + "\n", "utf-8");
+}
+
+// src/trace-shipper.ts
+var import_protobufjs = __toESM(require("protobufjs"), 1);
+
+// src/package-info.ts
+var PACKAGE_NAME = "@neatlogs/claude-code";
+var PACKAGE_VERSION = "0.1.0";
+
+// src/trace-shipper.ts
+var OTLP_PROTO_JSON = {
+  nested: {
+    opentelemetry: { nested: { proto: { nested: {
+      common: { nested: { v1: { nested: {
+        AnyValue: {
+          oneofs: { value: { oneof: ["stringValue", "boolValue", "intValue", "doubleValue", "arrayValue", "kvlistValue", "bytesValue"] } },
+          fields: {
+            stringValue: { type: "string", id: 1 },
+            boolValue: { type: "bool", id: 2 },
+            intValue: { type: "int64", id: 3 },
+            doubleValue: { type: "double", id: 4 },
+            arrayValue: { type: "ArrayValue", id: 5 },
+            kvlistValue: { type: "KeyValueList", id: 6 },
+            bytesValue: { type: "bytes", id: 7 }
+          }
+        },
+        ArrayValue: { fields: { values: { rule: "repeated", type: "AnyValue", id: 1 } } },
+        KeyValueList: { fields: { values: { rule: "repeated", type: "KeyValue", id: 1 } } },
+        KeyValue: { fields: { key: { type: "string", id: 1 }, value: { type: "AnyValue", id: 2 } } },
+        InstrumentationScope: { fields: { name: { type: "string", id: 1 }, version: { type: "string", id: 2 } } }
+      } } } },
+      resource: { nested: { v1: { nested: {
+        Resource: { fields: { attributes: { rule: "repeated", type: "opentelemetry.proto.common.v1.KeyValue", id: 1 } } }
+      } } } },
+      trace: { nested: { v1: { nested: {
+        ResourceSpans: { fields: {
+          resource: { type: "opentelemetry.proto.resource.v1.Resource", id: 1 },
+          scopeSpans: { rule: "repeated", type: "ScopeSpans", id: 2 }
+        } },
+        ScopeSpans: { fields: {
+          scope: { type: "opentelemetry.proto.common.v1.InstrumentationScope", id: 1 },
+          spans: { rule: "repeated", type: "Span", id: 2 }
+        } },
+        Span: { fields: {
+          traceId: { type: "bytes", id: 1 },
+          spanId: { type: "bytes", id: 2 },
+          traceState: { type: "string", id: 3 },
+          parentSpanId: { type: "bytes", id: 4 },
+          name: { type: "string", id: 5 },
+          kind: { type: "SpanKind", id: 6 },
+          startTimeUnixNano: { type: "fixed64", id: 7 },
+          endTimeUnixNano: { type: "fixed64", id: 8 },
+          attributes: { rule: "repeated", type: "opentelemetry.proto.common.v1.KeyValue", id: 9 },
+          droppedAttributesCount: { type: "uint32", id: 10 },
+          events: { rule: "repeated", type: "SpanEvent", id: 11 },
+          droppedEventsCount: { type: "uint32", id: 12 },
+          links: { rule: "repeated", type: "SpanLink", id: 13 },
+          droppedLinksCount: { type: "uint32", id: 14 },
+          status: { type: "Status", id: 15 }
+        } },
+        SpanEvent: { fields: {
+          timeUnixNano: { type: "fixed64", id: 1 },
+          name: { type: "string", id: 2 },
+          attributes: { rule: "repeated", type: "opentelemetry.proto.common.v1.KeyValue", id: 3 }
+        } },
+        SpanLink: { fields: {
+          traceId: { type: "bytes", id: 1 },
+          spanId: { type: "bytes", id: 2 },
+          traceState: { type: "string", id: 3 },
+          attributes: { rule: "repeated", type: "opentelemetry.proto.common.v1.KeyValue", id: 4 }
+        } },
+        Status: { fields: { message: { type: "string", id: 2 }, code: { type: "StatusCode", id: 3 } } },
+        StatusCode: { values: { STATUS_CODE_UNSET: 0, STATUS_CODE_OK: 1, STATUS_CODE_ERROR: 2 } },
+        SpanKind: { values: {
+          SPAN_KIND_UNSPECIFIED: 0,
+          SPAN_KIND_INTERNAL: 1,
+          SPAN_KIND_SERVER: 2,
+          SPAN_KIND_CLIENT: 3,
+          SPAN_KIND_PRODUCER: 4,
+          SPAN_KIND_CONSUMER: 5
+        } }
+      } } } },
+      collector: { nested: { trace: { nested: { v1: { nested: {
+        ExportTraceServiceRequest: { fields: { resourceSpans: { rule: "repeated", type: "opentelemetry.proto.trace.v1.ResourceSpans", id: 1 } } }
+      } } } } } }
+    } } } }
+  }
+};
+var protoRoot = import_protobufjs.default.Root.fromJSON(OTLP_PROTO_JSON);
+var ExportTraceServiceRequest = protoRoot.lookupType(
+  "opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest"
+);
+var SpanStatusCode = { UNSET: 0, OK: 1, ERROR: 2 };
+function randomBytes(length) {
+  const out = new Uint8Array(length);
+  const crypto = globalThis.crypto;
+  if (crypto && typeof crypto.getRandomValues === "function") {
+    crypto.getRandomValues(out);
+    return out;
+  }
+  for (let i = 0; i < out.length; i++) out[i] = Math.floor(Math.random() * 256);
+  return out;
+}
+function generateTraceId() {
+  return randomBytes(16);
+}
+function generateSpanId() {
+  return randomBytes(8);
+}
+function bytesToHex(bytes) {
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function hexToBytes(hex) {
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < hex.length; i += 2) {
+    bytes[i / 2] = parseInt(hex.slice(i, i + 2), 16);
+  }
+  return bytes;
+}
+function nowNanoString() {
+  return (BigInt(Date.now()) * 1000000n).toString();
+}
+function msToNanoString(ms) {
+  return (BigInt(ms) * 1000000n).toString();
+}
+function attrString(key, value) {
+  if (value === void 0) return void 0;
+  return { key, value: { stringValue: value } };
+}
+function attrInt(key, value) {
+  if (value === void 0 || !Number.isFinite(value)) return void 0;
+  return { key, value: { intValue: String(Math.trunc(value)) } };
+}
+var TraceShipper = class {
+  apiKey;
+  endpoint;
+  debug;
+  maxRetries;
+  workflowName;
+  queue = [];
+  prefix = "[neatlogs/claude-code]";
+  constructor(opts) {
+    this.apiKey = opts.apiKey;
+    this.endpoint = opts.endpoint.endsWith("/") ? opts.endpoint.slice(0, -1) : opts.endpoint;
+    this.debug = opts.debug;
+    this.maxRetries = opts.maxRetries ?? 3;
+    this.workflowName = opts.workflowName || "";
+  }
+  enqueue(span) {
+    this.queue.push(span);
+  }
+  async flush() {
+    if (this.queue.length === 0) return;
+    if (!this.apiKey) {
+      if (this.debug) console.warn(`${this.prefix} No API key \u2014 skipping export`);
+      this.queue = [];
+      return;
+    }
+    const spans = this.queue.splice(0);
+    const payload = this.buildProtobuf(spans);
+    const url = `${this.endpoint}/v1/traces`;
+    if (this.debug) {
+      console.log(`${this.prefix} Shipping ${spans.length} spans to ${url}`);
+    }
+    for (let attempt = 1; attempt <= this.maxRetries; attempt++) {
+      try {
+        const resp = await fetch(url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/x-protobuf",
+            "x-api-key": this.apiKey
+          },
+          body: payload
+        });
+        if (resp.ok) {
+          if (this.debug) console.log(`${this.prefix} Shipped ${spans.length} spans`);
+          return;
+        }
+        if (resp.status === 401) {
+          console.warn(`${this.prefix} Invalid API key (401) \u2014 dropping ${spans.length} spans`);
+          return;
+        }
+        if (resp.status < 500 && resp.status !== 429) {
+          const text = await resp.text().catch(() => "");
+          console.warn(`${this.prefix} Server returned ${resp.status}: ${text} \u2014 dropping spans`);
+          return;
+        }
+        if (this.debug) {
+          console.warn(`${this.prefix} Attempt ${attempt}/${this.maxRetries} failed: HTTP ${resp.status}`);
+        }
+      } catch (err) {
+        if (this.debug) {
+          console.warn(`${this.prefix} Attempt ${attempt}/${this.maxRetries} error: ${err.message}`);
+        }
+      }
+      if (attempt < this.maxRetries) {
+        await new Promise((r) => setTimeout(r, 500 * Math.pow(2, attempt - 1)));
+      }
+    }
+    console.warn(`${this.prefix} Failed to ship ${spans.length} spans after ${this.maxRetries} attempts`);
+  }
+  async shutdown() {
+    await this.flush();
+  }
+  buildProtobuf(spans) {
+    const protoSpans = spans.map((span) => ({
+      traceId: span.traceId,
+      spanId: span.spanId,
+      parentSpanId: span.parentSpanId || void 0,
+      name: span.name,
+      kind: span.kind,
+      startTimeUnixNano: this.nanoStringToLong(span.startTimeUnixNano),
+      endTimeUnixNano: this.nanoStringToLong(span.endTimeUnixNano),
+      attributes: span.attributes.map((a) => ({
+        key: a.key,
+        value: a.value.intValue !== void 0 ? { intValue: this.nanoStringToLong(a.value.intValue) } : a.value
+      })),
+      status: span.status ? { code: span.status.code, message: span.status.message } : void 0
+    }));
+    const resourceAttributes = [
+      { key: "service.name", value: { stringValue: "neatlogs.claude-code" } },
+      { key: "service.version", value: { stringValue: PACKAGE_VERSION } }
+    ];
+    if (this.workflowName) {
+      resourceAttributes.push({ key: "neatlogs.workflow_name", value: { stringValue: this.workflowName } });
+    }
+    const message = {
+      resourceSpans: [{
+        resource: { attributes: resourceAttributes },
+        scopeSpans: [{
+          scope: { name: PACKAGE_NAME, version: PACKAGE_VERSION },
+          spans: protoSpans
+        }]
+      }]
+    };
+    const errMsg = ExportTraceServiceRequest.verify(message);
+    if (errMsg && this.debug) {
+      console.warn(`${this.prefix} Proto verification warning: ${errMsg}`);
+    }
+    return ExportTraceServiceRequest.encode(
+      ExportTraceServiceRequest.fromObject(message)
+    ).finish();
+  }
+  nanoStringToLong(nanoStr) {
+    const big = BigInt(nanoStr);
+    const low = Number(big & 0xFFFFFFFFn);
+    const high = Number(big >> 32n & 0xFFFFFFFFn);
+    return { low, high, unsigned: true };
+  }
+};
+
+// src/event-mapper.ts
+var import_fs4 = require("fs");
+
+// src/state.ts
+var import_fs2 = require("fs");
+var import_os2 = require("os");
+var import_path2 = require("path");
+var STATE_DIR = (0, import_path2.join)((0, import_os2.tmpdir)(), "neatlogs-claude-code");
+function ensureStateDir() {
+  (0, import_fs2.mkdirSync)(STATE_DIR, { recursive: true });
+}
+function safeKey(key) {
+  return key.replace(/[^a-zA-Z0-9_\-]/g, "_");
+}
+function statePath(key) {
+  const sanitized = safeKey(key);
+  const full = (0, import_path2.join)(STATE_DIR, sanitized);
+  if (!full.startsWith(STATE_DIR)) {
+    throw new Error("Path traversal detected");
+  }
+  return full;
+}
+function writeState(key, value) {
+  ensureStateDir();
+  (0, import_fs2.writeFileSync)(statePath(key), value, "utf-8");
+}
+function readState(key) {
+  const filePath = statePath(key);
+  if (!(0, import_fs2.existsSync)(filePath)) return void 0;
+  return (0, import_fs2.readFileSync)(filePath, "utf-8");
+}
+function deleteState(key) {
+  const filePath = statePath(key);
+  if ((0, import_fs2.existsSync)(filePath)) {
+    (0, import_fs2.unlinkSync)(filePath);
+  }
+}
+function listStateFiles(prefix) {
+  if (!(0, import_fs2.existsSync)(STATE_DIR)) return [];
+  return (0, import_fs2.readdirSync)(STATE_DIR).filter((f) => f.startsWith(safeKey(prefix)));
+}
+function cleanupStateFiles(prefix) {
+  for (const file of listStateFiles(prefix)) {
+    (0, import_fs2.unlinkSync)((0, import_path2.join)(STATE_DIR, file));
+  }
+}
+
+// src/transcript.ts
+var import_fs3 = require("fs");
+function isToolResultContentBlock(value) {
+  return Boolean(
+    value && typeof value === "object" && "type" in value && value.type === "tool_result"
+  );
+}
+function isTopLevelUserPrompt(entry) {
+  if (entry.type !== "user") return false;
+  const content = entry.message?.content;
+  if (typeof content === "string") return true;
+  if (!Array.isArray(content)) return false;
+  return content.some((block) => !isToolResultContentBlock(block));
+}
+function isToolResultUserEntry(entry) {
+  if (entry.type !== "user") return false;
+  const content = entry.message?.content;
+  if (!Array.isArray(content)) return false;
+  return content.length > 0 && content.every((b) => isToolResultContentBlock(b));
+}
+function parseTranscript(transcriptPath) {
+  if (!(0, import_fs3.existsSync)(transcriptPath)) return void 0;
+  const content = (0, import_fs3.readFileSync)(transcriptPath, "utf-8");
+  const lines = content.split("\n").filter((l) => l.trim());
+  const summary = {
+    totalInputTokens: 0,
+    totalOutputTokens: 0,
+    totalCacheReadTokens: 0,
+    totalCacheCreationTokens: 0,
+    turnCount: 0,
+    toolsUsed: [],
+    hasThinking: false,
+    lastTurnTextBlocks: [],
+    llmCallPhases: []
+  };
+  const toolNames = /* @__PURE__ */ new Set();
+  let lastUsage;
+  let currentTurnTextBlocks = [];
+  let currentPhases = [];
+  let activePhase;
+  function finalizePhase() {
+    if (activePhase && (activePhase.text || activePhase.thinking || activePhase.toolCalls.length > 0)) {
+      currentPhases.push(activePhase);
+    }
+    activePhase = void 0;
+  }
+  function ensurePhase() {
+    if (!activePhase) {
+      activePhase = { text: "", thinking: "", toolCalls: [], inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, hasThinking: false };
+    }
+    return activePhase;
+  }
+  for (const line of lines) {
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch (err) {
+      if (process.env["NEATLOGS_DEBUG"] === "true") {
+        console.warn(`[neatlogs/claude-code] Skipping malformed transcript line: ${err.message}`);
+      }
+      continue;
+    }
+    if (entry.type === "system" && entry.subtype === "turn_duration") {
+      if (typeof entry.durationMs === "number") {
+        summary.totalDurationMs = (summary.totalDurationMs ?? 0) + entry.durationMs;
+      }
+      if (typeof entry.version === "string") summary.codeVersion = entry.version;
+      if (typeof entry.gitBranch === "string") summary.gitBranch = entry.gitBranch;
+      continue;
+    }
+    if (isTopLevelUserPrompt(entry)) {
+      currentTurnTextBlocks = [];
+      finalizePhase();
+      currentPhases = [];
+    }
+    if (isToolResultUserEntry(entry)) {
+      finalizePhase();
+      continue;
+    }
+    if (entry.type !== "assistant") continue;
+    const msg = entry.message;
+    if (!msg) continue;
+    summary.turnCount++;
+    if (typeof msg.model === "string") summary.model = msg.model;
+    if (typeof msg.stop_reason === "string") summary.stopReason = msg.stop_reason;
+    if (typeof entry.version === "string") summary.codeVersion = entry.version;
+    if (typeof entry.gitBranch === "string") summary.gitBranch = entry.gitBranch;
+    const usage = msg.usage;
+    if (usage) {
+      summary.totalInputTokens += usage.input_tokens ?? 0;
+      summary.totalOutputTokens += usage.output_tokens ?? 0;
+      summary.totalCacheReadTokens += usage.cache_read_input_tokens ?? 0;
+      summary.totalCacheCreationTokens += usage.cache_creation_input_tokens ?? 0;
+      if (typeof usage.service_tier === "string") summary.serviceTier = usage.service_tier;
+      lastUsage = usage;
+    }
+    const phase = ensurePhase();
+    const entryTimestamp = typeof entry.timestamp === "string" ? entry.timestamp : void 0;
+    if (entryTimestamp) {
+      if (!phase.startTimestamp) phase.startTimestamp = entryTimestamp;
+      phase.endTimestamp = entryTimestamp;
+    }
+    if (typeof msg.model === "string") phase.model = msg.model;
+    if (usage) {
+      phase.inputTokens += usage.input_tokens ?? 0;
+      phase.outputTokens += usage.output_tokens ?? 0;
+      phase.cacheReadTokens += usage.cache_read_input_tokens ?? 0;
+      phase.cacheWriteTokens += usage.cache_creation_input_tokens ?? 0;
+    }
+    const msgContent = msg.content;
+    if (Array.isArray(msgContent)) {
+      for (const block of msgContent) {
+        if (block.type === "tool_use" && typeof block.name === "string") {
+          toolNames.add(block.name);
+          phase.toolCalls.push({ id: block.id, name: block.name, input: block.input });
+        }
+        if (block.type === "thinking") {
+          summary.hasThinking = true;
+          phase.hasThinking = true;
+          if (typeof block.thinking === "string" && block.thinking.trim()) {
+            phase.thinking = phase.thinking ? phase.thinking + "\n" + block.thinking : block.thinking;
+          }
+        }
+        if (block.type === "text" && typeof block.text === "string" && block.text.trim()) {
+          currentTurnTextBlocks.push(block.text);
+          phase.text = phase.text ? phase.text + "\n" + block.text : block.text;
+        }
+      }
+      summary.lastTurnTextBlocks = [...currentTurnTextBlocks];
+    }
+  }
+  finalizePhase();
+  if (lastUsage) {
+    summary.lastTurnInputTokens = lastUsage.input_tokens;
+    summary.lastTurnOutputTokens = lastUsage.output_tokens;
+    summary.lastTurnCacheReadTokens = lastUsage.cache_read_input_tokens;
+  }
+  summary.toolsUsed = [...toolNames].sort();
+  if (summary.lastTurnTextBlocks.length > 0) {
+    summary.lastTurnFullOutput = summary.lastTurnTextBlocks.join("\n\n");
+  }
+  summary.llmCallPhases = currentPhases;
+  return summary;
+}
+
+// src/event-mapper.ts
+function safeStringify(value) {
+  if (value === void 0 || value === null) return void 0;
+  try {
+    return JSON.stringify(value);
+  } catch (err) {
+    console.warn(`[neatlogs/claude-code] JSON.stringify failed: ${err.message}`);
+    return String(value);
+  }
+}
+function sessionTraceKey(sessionId) {
+  return `trace_${sessionId}`;
+}
+function turnSpanKey(sessionId) {
+  return `turn_${sessionId}`;
+}
+function subagentSpanKey(agentId) {
+  return `subagentspan_${agentId}`;
+}
+function saveSpanContext(key, ctx) {
+  writeState(key, JSON.stringify(ctx));
+}
+function readSpanContext(key) {
+  const raw = readState(key);
+  if (!raw) return void 0;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+}
+function getSessionTrace(sessionId) {
+  return readSpanContext(sessionTraceKey(sessionId));
+}
+function getTurnParent(payload) {
+  if (payload.agent_id) {
+    const sub = readSpanContext(subagentSpanKey(payload.agent_id));
+    if (sub) return sub;
+  }
+  return readSpanContext(turnSpanKey(payload.session_id));
+}
+function deriveWorkflowName(payload) {
+  if (payload.prompt) {
+    return payload.prompt.slice(0, 60).replace(/\n/g, " ").trim() || "claude-code";
+  }
+  return "claude-code";
+}
+function ensureSessionTrace(payload, config, shipper) {
+  const existing = getSessionTrace(payload.session_id);
+  if (existing) return existing;
+  const model = readState(`model_${payload.session_id}`) || void 0;
+  const workflowName = deriveWorkflowName(payload);
+  writeState(`workflow_${payload.session_id}`, workflowName);
+  const traceId = generateTraceId();
+  const spanId = generateSpanId();
+  const now = nowNanoString();
+  const rootSpan = {
+    traceId,
+    spanId,
+    name: workflowName,
+    kind: 1,
+    startTimeUnixNano: now,
+    endTimeUnixNano: now,
+    attributes: [
+      { key: "neatlogs.span.kind", value: { stringValue: "WORKFLOW" } },
+      attrString("neatlogs.llm.request_type", "generateText"),
+      attrString("neatlogs.llm.model_name", model),
+      attrString("neatlogs.llm.provider", "anthropic"),
+      attrString("neatlogs.user_id", config.userId),
+      attrString("neatlogs.session_id", payload.session_id),
+      attrString("neatlogs.workflow_name", workflowName),
+      attrString("neatlogs.input.value", payload.prompt),
+      attrString("cwd", payload.cwd),
+      { key: "neatlogs.sdk.name", value: { stringValue: PACKAGE_NAME } },
+      { key: "neatlogs.sdk.version", value: { stringValue: PACKAGE_VERSION } }
+    ].filter((a) => a !== void 0),
+    status: { code: SpanStatusCode.OK }
+  };
+  shipper.enqueue(rootSpan);
+  const ctx = { traceIdHex: bytesToHex(traceId), spanIdHex: bytesToHex(spanId) };
+  saveSpanContext(sessionTraceKey(payload.session_id), ctx);
+  return ctx;
+}
+function isoToNanoString(iso, fallback) {
+  const ms = new Date(iso).getTime();
+  if (!Number.isFinite(ms)) return fallback;
+  return msToNanoString(ms);
+}
+function createSpan(name, parent, startNano, endNano, attributes, status) {
+  const traceId = parent ? hexToBytes(parent.traceIdHex) : generateTraceId();
+  const spanId = generateSpanId();
+  return {
+    traceId,
+    spanId,
+    parentSpanId: parent ? hexToBytes(parent.spanIdHex) : void 0,
+    name,
+    kind: 1,
+    startTimeUnixNano: startNano,
+    endTimeUnixNano: endNano,
+    attributes: attributes.filter((a) => a !== void 0),
+    status
+  };
+}
+function mapHookEvent(payload, config, shipper) {
+  switch (payload.hook_event_name) {
+    case "SessionStart":
+      handleSessionStart(payload, config, shipper);
+      break;
+    case "UserPromptSubmit":
+      handleUserPromptSubmit(payload, config, shipper);
+      break;
+    case "PreToolUse":
+      if (payload.tool_use_id) {
+        writeState(`tool_${payload.tool_use_id}`, String(Date.now()));
+      }
+      break;
+    case "PostToolUse":
+      handlePostToolUse(payload, config, shipper);
+      break;
+    case "PostToolUseFailure":
+      handlePostToolUse(payload, config, shipper, payload.error ?? "Tool execution failed");
+      break;
+    case "SubagentStart":
+      handleSubagentStart(payload, config, shipper);
+      break;
+    case "SubagentStop":
+      handleSubagentStop(payload, config, shipper);
+      break;
+    case "PermissionDenied":
+      handlePermissionDenied(payload, config, shipper);
+      break;
+    case "Stop":
+      handleStop(payload, config, shipper);
+      break;
+    case "StopFailure":
+      handleStop(payload, config, shipper, { error: payload.error, errorDetails: payload.error_details });
+      break;
+    case "InstructionsLoaded":
+      handleInstructionsLoaded(payload);
+      break;
+    case "PostCompact":
+      handlePostCompact(payload, config, shipper);
+      break;
+    case "SessionEnd":
+      handleSessionEnd(payload, config, shipper);
+      break;
+    default:
+      if (config.debug) {
+        console.log(`[neatlogs/claude-code] Ignoring unhandled event: ${payload.hook_event_name}`);
+      }
+  }
+}
+function handleSessionStart(payload, config, shipper) {
+  writeState(`model_${payload.session_id}`, payload.model ?? "");
+  ensureSessionTrace(payload, config, shipper);
+}
+function handleUserPromptSubmit(payload, config, shipper) {
+  const sessionCtx = ensureSessionTrace(payload, config, shipper);
+  if (payload.prompt) {
+    const name = payload.prompt.slice(0, 60).replace(/\n/g, " ").trim() || "claude-code";
+    writeState(`workflow_${payload.session_id}`, name);
+  }
+  const now = nowNanoString();
+  const turnSpanId = generateSpanId();
+  const turnSpan = {
+    traceId: hexToBytes(sessionCtx.traceIdHex),
+    spanId: turnSpanId,
+    parentSpanId: hexToBytes(sessionCtx.spanIdHex),
+    name: payload.prompt?.slice(0, 80) || "turn",
+    kind: 1,
+    startTimeUnixNano: now,
+    endTimeUnixNano: now,
+    attributes: [
+      { key: "neatlogs.span.kind", value: { stringValue: "CHAIN" } },
+      attrString("neatlogs.input.value", payload.prompt),
+      attrString("cwd", payload.cwd)
+    ].filter((a) => a !== void 0)
+  };
+  shipper.enqueue(turnSpan);
+  const turnCtx = { traceIdHex: sessionCtx.traceIdHex, spanIdHex: bytesToHex(turnSpanId) };
+  saveSpanContext(turnSpanKey(payload.session_id), turnCtx);
+  writeState(`turnstart_${payload.session_id}`, String(Date.now()));
+}
+function handlePostToolUse(payload, config, shipper, error) {
+  ensureSessionTrace(payload, config, shipper);
+  const parent = getTurnParent(payload);
+  const endMs = Date.now();
+  const durationMs = payload.duration_ms ?? 0;
+  const startMs = durationMs > 0 ? endMs - durationMs : endMs;
+  const span = createSpan(
+    payload.tool_name ?? "tool",
+    parent,
+    msToNanoString(startMs),
+    msToNanoString(endMs),
+    [
+      attrString("neatlogs.span.kind", "TOOL"),
+      attrString("neatlogs.tool.name", payload.tool_name),
+      attrString("neatlogs.tool_call.id", payload.tool_use_id),
+      attrString("neatlogs.tool.input", safeStringify(payload.tool_input)),
+      attrString("neatlogs.tool.output", safeStringify(payload.tool_response)),
+      attrInt("neatlogs.llm.metrics.duration_ms", durationMs)
+    ],
+    error ? { code: SpanStatusCode.ERROR, message: error } : void 0
+  );
+  shipper.enqueue(span);
+  if (payload.permission_mode === "plan") {
+    const sessionCtx = getSessionTrace(payload.session_id);
+    if (sessionCtx) {
+      const markerNow = nowNanoString();
+      const marker = createSpan("neatlogs.trace.complete", sessionCtx, markerNow, markerNow, []);
+      shipper.enqueue(marker);
+    }
+  }
+}
+function handleSubagentStart(payload, config, shipper) {
+  ensureSessionTrace(payload, config, shipper);
+  const parent = getTurnParent(payload);
+  if (payload.agent_id) {
+    writeState(`subagent_${payload.agent_id}`, String(Date.now()));
+  }
+  const now = nowNanoString();
+  const traceId = parent ? hexToBytes(parent.traceIdHex) : generateTraceId();
+  const spanId = generateSpanId();
+  const span = {
+    traceId,
+    spanId,
+    parentSpanId: parent ? hexToBytes(parent.spanIdHex) : void 0,
+    name: payload.agent_type ?? "subagent",
+    kind: 1,
+    startTimeUnixNano: now,
+    endTimeUnixNano: now,
+    attributes: [
+      { key: "neatlogs.span.kind", value: { stringValue: "AGENT" } },
+      attrString("neatlogs.agent.name", payload.agent_type),
+      attrString("neatlogs.agent_id", payload.agent_id)
+    ].filter((a) => a !== void 0)
+  };
+  shipper.enqueue(span);
+  if (payload.agent_id) {
+    saveSpanContext(subagentSpanKey(payload.agent_id), {
+      traceIdHex: bytesToHex(traceId),
+      spanIdHex: bytesToHex(spanId)
+    });
+  }
+}
+function handleSubagentStop(payload, config, shipper) {
+  ensureSessionTrace(payload, config, shipper);
+  const endMs = Date.now();
+  const savedStartRaw = payload.agent_id ? readState(`subagent_${payload.agent_id}`) : void 0;
+  const savedStartMs = savedStartRaw ? parseInt(savedStartRaw, 10) : void 0;
+  const startMs = savedStartMs && Number.isFinite(savedStartMs) && savedStartMs <= endMs ? savedStartMs : endMs;
+  let agentInput;
+  if (payload.agent_transcript_path && (0, import_fs4.existsSync)(payload.agent_transcript_path)) {
+    const summary = parseTranscript(payload.agent_transcript_path);
+    if (summary?.lastTurnTextBlocks.length) {
+      agentInput = summary.lastTurnTextBlocks[0];
+    }
+  }
+  const parent = getTurnParent(payload);
+  const span = createSpan(
+    payload.agent_type ?? "subagent",
+    parent,
+    msToNanoString(startMs),
+    msToNanoString(endMs),
+    [
+      attrString("neatlogs.span.kind", "AGENT"),
+      attrString("neatlogs.agent.name", payload.agent_type),
+      attrString("neatlogs.agent_id", payload.agent_id),
+      attrString("neatlogs.input.value", agentInput),
+      attrString("neatlogs.output.value", payload.last_assistant_message),
+      attrInt("neatlogs.llm.metrics.duration_ms", endMs - startMs)
+    ]
+  );
+  shipper.enqueue(span);
+  if (payload.agent_id) {
+    deleteState(`subagent_${payload.agent_id}`);
+    deleteState(subagentSpanKey(payload.agent_id));
+  }
+}
+function handlePermissionDenied(payload, config, shipper) {
+  ensureSessionTrace(payload, config, shipper);
+  const parent = getTurnParent(payload);
+  const now = nowNanoString();
+  const span = createSpan(
+    payload.tool_name ?? "permission_denied",
+    parent,
+    now,
+    now,
+    [
+      attrString("neatlogs.span.kind", "TOOL"),
+      attrString("neatlogs.tool.name", payload.tool_name),
+      attrString("neatlogs.tool_call.id", payload.tool_use_id),
+      attrString("neatlogs.tool.input", safeStringify(payload.tool_input)),
+      attrString("neatlogs.tool.output", payload.reason ?? "Permission denied"),
+      attrString("error.message", payload.reason ?? "Permission denied")
+    ],
+    { code: SpanStatusCode.ERROR, message: payload.reason ?? "Permission denied" }
+  );
+  shipper.enqueue(span);
+}
+function handleStop(payload, config, shipper, extra) {
+  ensureSessionTrace(payload, config, shipper);
+  const turnParent = getTurnParent(payload);
+  let emittedLLMSpan = false;
+  if (payload.transcript_path) {
+    const summary = parseTranscript(payload.transcript_path);
+    if (config.debug) {
+      (0, import_fs4.appendFileSync)("/tmp/neatlogs-hook-debug.log", `[${(/* @__PURE__ */ new Date()).toISOString()}] handleStop: transcript_path=${payload.transcript_path}, summary=${!!summary}, phases=${summary?.llmCallPhases.length ?? 0}, hasThinking=${summary?.hasThinking}
+`);
+      if (summary) {
+        for (let i = 0; i < Math.min(summary.llmCallPhases.length, 5); i++) {
+          const p = summary.llmCallPhases[i];
+          (0, import_fs4.appendFileSync)("/tmp/neatlogs-hook-debug.log", `[${(/* @__PURE__ */ new Date()).toISOString()}]   phase[${i}]: text=${p.text.length} thinking=${p.thinking.length} tools=${p.toolCalls.length}
+`);
+        }
+      }
+    }
+    if (summary && summary.llmCallPhases.length > 0) {
+      emitLLMPhaseSpans(payload, summary, shipper, turnParent, config);
+      emittedLLMSpan = true;
+    }
+  }
+  if (!emittedLLMSpan && payload.last_assistant_message) {
+    const model = readState(`model_${payload.session_id}`) || "claude";
+    const now = nowNanoString();
+    const span = createSpan(
+      model,
+      turnParent,
+      now,
+      now,
+      [
+        attrString("neatlogs.span.kind", "LLM"),
+        attrString("neatlogs.llm.request_type", "generateText"),
+        attrString("neatlogs.llm.model_name", model),
+        attrString("neatlogs.llm.provider", "anthropic"),
+        attrString("neatlogs.output.value", payload.last_assistant_message)
+      ]
+    );
+    shipper.enqueue(span);
+  }
+  if (extra?.error) {
+    const now = nowNanoString();
+    const span = createSpan(
+      "stop_failure",
+      turnParent,
+      now,
+      now,
+      [
+        attrString("neatlogs.span.kind", "CHAIN"),
+        attrString("error.message", extra.error),
+        attrString("error.details", extra.errorDetails)
+      ],
+      { code: SpanStatusCode.ERROR, message: extra.error }
+    );
+    shipper.enqueue(span);
+  }
+  const sessionCtx = getSessionTrace(payload.session_id);
+  if (sessionCtx) {
+    const now = nowNanoString();
+    const marker = createSpan(
+      "neatlogs.trace.complete",
+      sessionCtx,
+      now,
+      now,
+      []
+    );
+    shipper.enqueue(marker);
+  }
+}
+function handlePostCompact(payload, config, shipper) {
+  ensureSessionTrace(payload, config, shipper);
+  const parent = getTurnParent(payload) ?? getSessionTrace(payload.session_id);
+  const now = nowNanoString();
+  const span = createSpan(
+    "context_compaction",
+    parent,
+    now,
+    now,
+    [
+      attrString("neatlogs.span.kind", "CHAIN"),
+      attrString("neatlogs.input.value", payload.trigger),
+      attrString("neatlogs.output.value", payload.compact_summary)
+    ]
+  );
+  shipper.enqueue(span);
+}
+function handleInstructionsLoaded(payload) {
+  if (!payload.file_path || !payload.session_id) return;
+  if (!(0, import_fs4.existsSync)(payload.file_path)) return;
+  const content = (0, import_fs4.readFileSync)(payload.file_path, "utf-8");
+  const maxLen = 8192;
+  const truncated = content.length > maxLen ? content.slice(0, maxLen) + "\n...[truncated]" : content;
+  const fileKey = payload.file_path.replace(/[^a-zA-Z0-9_\-]/g, "_");
+  const header = `# ${payload.memory_type ?? "instructions"}: ${payload.file_path}
+`;
+  writeState(`instr_${payload.session_id}_${fileKey}`, header + truncated);
+}
+function handleSessionEnd(payload, config, shipper) {
+  const sessionCtx = getSessionTrace(payload.session_id);
+  if (sessionCtx) {
+    const now = nowNanoString();
+    const marker = createSpan(
+      "neatlogs.trace.complete",
+      sessionCtx,
+      now,
+      now,
+      []
+    );
+    shipper.enqueue(marker);
+  }
+  deleteState(sessionTraceKey(payload.session_id));
+  deleteState(turnSpanKey(payload.session_id));
+  deleteState(`model_${payload.session_id}`);
+  deleteState(`workflow_${payload.session_id}`);
+  deleteState(`turnstart_${payload.session_id}`);
+  cleanupStateFiles(`instr_${payload.session_id}_`);
+  cleanupStateFiles(`tool_`);
+  cleanupStateFiles(`subagent_`);
+}
+function emitLLMPhaseSpans(_payload, summary, shipper, parent, config) {
+  if (config.debug) {
+    (0, import_fs4.appendFileSync)("/tmp/neatlogs-hook-debug.log", `[${(/* @__PURE__ */ new Date()).toISOString()}] emitLLMPhaseSpans: ${summary.llmCallPhases.length} phases, hasThinking=${summary.hasThinking}
+`);
+    for (let i = 0; i < Math.min(summary.llmCallPhases.length, 5); i++) {
+      const p = summary.llmCallPhases[i];
+      (0, import_fs4.appendFileSync)("/tmp/neatlogs-hook-debug.log", `[${(/* @__PURE__ */ new Date()).toISOString()}]   phase[${i}]: text=${p.text.length} thinking=${p.thinking.length} tools=${p.toolCalls.length}
+`);
+    }
+  }
+  for (const phase of summary.llmCallPhases) {
+    const outputText = phase.text.trim();
+    if (!outputText && !phase.thinking) continue;
+    const model = phase.model ?? summary.model ?? "claude";
+    const now = nowNanoString();
+    const startNano = phase.startTimestamp ? isoToNanoString(phase.startTimestamp, now) : now;
+    const endNano = phase.endTimestamp ? isoToNanoString(phase.endTimestamp, startNano) : startNano;
+    const toolCallNames = phase.toolCalls.map((tc) => tc.name).join(", ");
+    const span = createSpan(
+      model,
+      parent,
+      startNano,
+      endNano,
+      [
+        attrString("neatlogs.span.kind", "LLM"),
+        attrString("neatlogs.llm.request_type", "generateText"),
+        attrString("neatlogs.llm.model_name", model),
+        attrString("neatlogs.llm.provider", "anthropic"),
+        attrInt("neatlogs.llm.token_count.prompt", phase.inputTokens),
+        attrInt("neatlogs.llm.token_count.completion", phase.outputTokens),
+        ...phase.cacheReadTokens > 0 ? [attrInt("neatlogs.llm.token_count.cached", phase.cacheReadTokens)] : [],
+        ...phase.cacheWriteTokens > 0 ? [attrInt("neatlogs.llm.token_count.cache_write", phase.cacheWriteTokens)] : [],
+        attrString("neatlogs.output.value", outputText),
+        ...phase.thinking ? [attrString("neatlogs.llm.thinking", phase.thinking)] : [],
+        ...toolCallNames ? [attrString("neatlogs.llm.tool_calls", toolCallNames)] : [],
+        ...phase.hasThinking ? [attrString("neatlogs.llm.has_thinking", "true")] : []
+      ]
+    );
+    shipper.enqueue(span);
+  }
+}
+
+// src/hook-handler.ts
+var STDIN_TIMEOUT_MS = 5e3;
+var DEBUG_LOG = "/tmp/neatlogs-hook-debug.log";
+function debugLog(msg) {
+  (0, import_fs5.appendFileSync)(DEBUG_LOG, `[${(/* @__PURE__ */ new Date()).toISOString()}] ${msg}
+`);
+}
+function readStdin() {
+  return new Promise((resolve) => {
+    if (process.stdin.isTTY) {
+      resolve("");
+      return;
+    }
+    const chunks = [];
+    let resolved = false;
+    function done(value) {
+      if (resolved) return;
+      resolved = true;
+      clearTimeout(timeout);
+      process.stdin.removeAllListeners();
+      process.stdin.destroy();
+      resolve(value);
+    }
+    const timeout = setTimeout(() => {
+      done(chunks.length > 0 ? Buffer.concat(chunks).toString("utf-8") : "");
+    }, STDIN_TIMEOUT_MS);
+    process.stdin.on("data", (chunk) => chunks.push(chunk));
+    process.stdin.on("end", () => done(Buffer.concat(chunks).toString("utf-8")));
+    process.stdin.on("error", (err) => {
+      console.warn(`[neatlogs/claude-code] stdin error: ${err.message}`);
+      done(chunks.length > 0 ? Buffer.concat(chunks).toString("utf-8") : "");
+    });
+  });
+}
+async function handleHook() {
+  const raw = await readStdin();
+  if (!raw.trim()) return;
+  let payload;
+  try {
+    payload = JSON.parse(raw);
+  } catch (err) {
+    console.warn(`[neatlogs/claude-code] Failed to parse hook payload: ${err.message}`);
+    return;
+  }
+  if (!payload.session_id || !payload.hook_event_name) return;
+  const config = loadConfig();
+  if (config.debug) {
+    debugLog(`Event: ${payload.hook_event_name} | Keys: ${Object.keys(payload).join(", ")}`);
+    debugLog(`Payload: ${raw.slice(0, 2e3)}`);
+  }
+  if (!config.apiKey) {
+    if (config.debug) debugLog("No API key \u2014 skipping");
+    return;
+  }
+  const shipper = new TraceShipper({
+    apiKey: config.apiKey,
+    endpoint: config.endpoint,
+    debug: config.debug,
+    workflowName: payload.prompt?.slice(0, 60).replace(/\n/g, " ").trim() || readState(`workflow_${payload.session_id}`) || "claude-code"
+  });
+  mapHookEvent(payload, { userId: config.userId, debug: config.debug }, shipper);
+  await shipper.flush();
+  if (config.debug) {
+    debugLog(`Flushed for ${payload.hook_event_name}`);
+  }
+}
+
+// src/setup.ts
+var import_fs6 = require("fs");
+var import_os3 = require("os");
+var import_path3 = require("path");
+var HOOK_EVENTS = [
+  "SessionStart",
+  "UserPromptSubmit",
+  "PreToolUse",
+  "PostToolUse",
+  "PostToolUseFailure",
+  "SubagentStart",
+  "SubagentStop",
+  "PermissionDenied",
+  "Stop",
+  "StopFailure",
+  "SessionEnd",
+  "PostCompact",
+  "InstructionsLoaded"
+];
+function getSettingsPath(scope, projectDir) {
+  if (scope === "global") {
+    return (0, import_path3.join)((0, import_os3.homedir)(), ".claude", "settings.json");
+  }
+  const base = projectDir ?? process.cwd();
+  return (0, import_path3.join)(base, ".claude", "settings.json");
+}
+function resolveCommand() {
+  return "neatlogs-claude-code hook";
+}
+function registerHooks(scope, projectDir) {
+  const settingsPath = getSettingsPath(scope, projectDir);
+  const dir = (0, import_path3.dirname)(settingsPath);
+  (0, import_fs6.mkdirSync)(dir, { recursive: true });
+  let settings = {};
+  if ((0, import_fs6.existsSync)(settingsPath)) {
+    try {
+      settings = JSON.parse((0, import_fs6.readFileSync)(settingsPath, "utf-8"));
+    } catch (err) {
+      console.warn(`[neatlogs/claude-code] Failed to parse existing settings: ${err.message}`);
+    }
+  }
+  const command = resolveCommand();
+  const existingHooks = typeof settings.hooks === "object" && !Array.isArray(settings.hooks) ? settings.hooks : {};
+  for (const event of HOOK_EVENTS) {
+    const eventGroups = existingHooks[event] ?? [];
+    const filtered = eventGroups.filter(
+      (g) => !g.hooks.some((h) => h.command.includes("neatlogs-claude-code") || h.command.includes("neatlogs/claude-code"))
+    );
+    filtered.push({ matcher: "", hooks: [{ type: "command", command }] });
+    existingHooks[event] = filtered;
+  }
+  settings.hooks = existingHooks;
+  (0, import_fs6.writeFileSync)(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+  console.log(`[neatlogs/claude-code] Registered ${HOOK_EVENTS.length} hooks in ${settingsPath}`);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getConfigPath,
+  handleHook,
+  loadConfig,
+  registerHooks,
+  updateConfig
+});