@raindrop-ai/claude-code 0.0.4 → 0.0.5

package/dist/index.d.ts

@@ -275,6 +275,9 @@ interface HookPayload {
     agent_transcript_path?: string;
     trigger?: string;
     compact_summary?: string;
+    file_path?: string;
+    memory_type?: string;
+    load_reason?: string;
 }
 interface MapperConfig {
     userId: string;
@@ -283,9 +286,58 @@ interface MapperConfig {
     customProperties: Record<string, unknown>;
 }
 declare function mapHookToRaindrop(payload: HookPayload, config: MapperConfig, eventShipper: EventShipper, traceShipper: TraceShipper): Promise<void>;
+/**
+ * Parse command-line args for --append-system-prompt and
+ * --append-system-prompt-file flags. Handles both space-separated form
+ * (--flag value) and equals form (--flag=value). Supports both flags
+ * appearing together (they concatenate).
+ *
+ * Exported for testing.
+ */
+declare function extractAppendSystemPrompt(args: string[]): string | undefined;
 
 declare const PACKAGE_NAME = "@raindrop-ai/claude-code";
-declare const PACKAGE_VERSION = "0.0.4";
+declare const PACKAGE_VERSION = "0.0.5";
+
+interface TranscriptSummary {
+    /** Aggregated token usage across all turns */
+    totalInputTokens: number;
+    totalOutputTokens: number;
+    totalCacheReadTokens: number;
+    totalCacheCreationTokens: number;
+    /** Token usage for the most recent turn only */
+    lastTurnInputTokens?: number;
+    lastTurnOutputTokens?: number;
+    lastTurnCacheReadTokens?: number;
+    /** Model used (from most recent assistant message) */
+    model?: string;
+    /** Service tier */
+    serviceTier?: string;
+    /** Number of API turns (assistant messages) */
+    turnCount: number;
+    /** Unique tool names used in the session */
+    toolsUsed: string[];
+    /** Stop reason from last assistant message */
+    stopReason?: string;
+    /** Total turn duration in ms (from system entries) */
+    totalDurationMs?: number;
+    /** Claude Code version */
+    codeVersion?: string;
+    /** Git branch */
+    gitBranch?: string;
+    /** Whether thinking/reasoning content was used */
+    hasThinking: boolean;
+}
+/**
+ * Parse a Claude Code transcript JSONL file and extract a summary.
+ * Returns undefined if the file doesn't exist or can't be parsed.
+ */
+declare function parseTranscript(transcriptPath: string): TranscriptSummary | undefined;
+/**
+ * Convert a TranscriptSummary into a flat properties object
+ * suitable for merging into event properties.
+ */
+declare function transcriptToProperties(summary: TranscriptSummary): Record<string, unknown>;
 
 interface LocalDebuggerResult {
     /** The resolved base URL (e.g. "http://localhost:5899/v1/"), or null if not detected. */
@@ -308,4 +360,4 @@ declare function detectLocalDebugger(debug: boolean): Promise<LocalDebuggerResul
  */
 declare function mirrorEventToLocalDebugger(baseUrl: string, payload: Record<string, unknown>, debug: boolean): void;
 
-export { EventShipper, type HookPayload, type LocalDebuggerResult, type MapperConfig, PACKAGE_NAME, PACKAGE_VERSION, type RaindropConfig, type SetupScope, TraceShipper, detectLocalDebugger, getConfigPath, loadConfig, mapHookToRaindrop, mirrorEventToLocalDebugger, updateConfig };
+export { EventShipper, type HookPayload, type LocalDebuggerResult, type MapperConfig, PACKAGE_NAME, PACKAGE_VERSION, type RaindropConfig, type SetupScope, TraceShipper, type TranscriptSummary, detectLocalDebugger, extractAppendSystemPrompt, getConfigPath, loadConfig, mapHookToRaindrop, mirrorEventToLocalDebugger, parseTranscript, transcriptToProperties, updateConfig };

package/dist/index.js

@@ -645,7 +645,7 @@ globalThis.RAINDROP_ASYNC_LOCAL_STORAGE = AsyncLocalStorage;
 
 // src/package-info.ts
 var PACKAGE_NAME = "@raindrop-ai/claude-code";
-var PACKAGE_VERSION = "0.0.4";
+var PACKAGE_VERSION = "0.0.5";
 
 // src/shipper.ts
 var EventShipper2 = class extends EventShipper {
@@ -741,10 +741,145 @@ function updateConfig(patch) {
 }
 
 // src/event-mapper.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, readdirSync, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
+import { execSync } from "child_process";
 import { randomUUID as randomUUID2 } from "crypto";
 import { tmpdir } from "os";
 import { join as join2 } from "path";
+
+// src/transcript.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+function parseTranscript(transcriptPath) {
+  var _a, _b, _c, _d, _e;
+  try {
+    if (!existsSync2(transcriptPath)) return void 0;
+    const content = readFileSync2(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
+    };
+    const toolNames = /* @__PURE__ */ new Set();
+    let lastUsage;
+    for (const line of lines) {
+      let entry;
+      try {
+        entry = JSON.parse(line);
+      } catch (e) {
+        continue;
+      }
+      if (entry.type === "system" && entry.subtype === "turn_duration") {
+        const durationMs = entry["durationMs"];
+        if (typeof durationMs === "number") {
+          summary.totalDurationMs = ((_a = summary.totalDurationMs) != null ? _a : 0) + durationMs;
+        }
+        const version = entry["version"];
+        if (typeof version === "string") {
+          summary.codeVersion = version;
+        }
+        const branch = entry["gitBranch"];
+        if (typeof branch === "string") {
+          summary.gitBranch = branch;
+        }
+        continue;
+      }
+      if (entry.type !== "assistant") continue;
+      const msg = entry.message;
+      if (!msg) continue;
+      summary.turnCount++;
+      if (msg.model) {
+        summary.model = msg.model;
+      }
+      if (msg.stop_reason) {
+        summary.stopReason = msg.stop_reason;
+      }
+      const entryVersion = entry["version"];
+      if (typeof entryVersion === "string") {
+        summary.codeVersion = entryVersion;
+      }
+      const entryBranch = entry["gitBranch"];
+      if (typeof entryBranch === "string") {
+        summary.gitBranch = entryBranch;
+      }
+      if (msg.usage) {
+        const u = msg.usage;
+        summary.totalInputTokens += (_b = u.input_tokens) != null ? _b : 0;
+        summary.totalOutputTokens += (_c = u.output_tokens) != null ? _c : 0;
+        summary.totalCacheReadTokens += (_d = u.cache_read_input_tokens) != null ? _d : 0;
+        summary.totalCacheCreationTokens += (_e = u.cache_creation_input_tokens) != null ? _e : 0;
+        if (u.service_tier) {
+          summary.serviceTier = u.service_tier;
+        }
+        lastUsage = u;
+      }
+      if (Array.isArray(msg.content)) {
+        for (const block of msg.content) {
+          if (block.type === "tool_use" && block.name) {
+            toolNames.add(block.name);
+          }
+          if (block.type === "thinking") {
+            summary.hasThinking = true;
+          }
+        }
+      }
+    }
+    if (lastUsage) {
+      summary.lastTurnInputTokens = lastUsage.input_tokens;
+      summary.lastTurnOutputTokens = lastUsage.output_tokens;
+      summary.lastTurnCacheReadTokens = lastUsage.cache_read_input_tokens;
+    }
+    summary.toolsUsed = [...toolNames].sort();
+    return summary;
+  } catch (e) {
+    return void 0;
+  }
+}
+function transcriptToProperties(summary) {
+  var _a, _b;
+  const props = {};
+  props["ai.usage.prompt_tokens"] = (_a = summary.lastTurnInputTokens) != null ? _a : summary.totalInputTokens;
+  props["ai.usage.completion_tokens"] = (_b = summary.lastTurnOutputTokens) != null ? _b : summary.totalOutputTokens;
+  if (summary.lastTurnCacheReadTokens !== void 0) {
+    props["ai.usage.cache_read_tokens"] = summary.lastTurnCacheReadTokens;
+  }
+  props["ai.usage.session_total.prompt_tokens"] = summary.totalInputTokens;
+  props["ai.usage.session_total.completion_tokens"] = summary.totalOutputTokens;
+  props["ai.usage.session_total.cache_read_tokens"] = summary.totalCacheReadTokens;
+  props["ai.usage.session_total.cache_creation_tokens"] = summary.totalCacheCreationTokens;
+  if (summary.model) {
+    props["ai.model"] = summary.model;
+  }
+  if (summary.serviceTier) {
+    props["ai.service_tier"] = summary.serviceTier;
+  }
+  if (summary.stopReason) {
+    props["ai.stop_reason"] = summary.stopReason;
+  }
+  if (summary.toolsUsed.length > 0) {
+    props["ai.tools_used"] = summary.toolsUsed.join(", ");
+  }
+  props["ai.turn_count"] = summary.turnCount;
+  if (summary.totalDurationMs !== void 0) {
+    props["ai.duration_ms"] = summary.totalDurationMs;
+  }
+  if (summary.codeVersion) {
+    props["claude_code.version"] = summary.codeVersion;
+  }
+  if (summary.gitBranch) {
+    props["git.branch"] = summary.gitBranch;
+  }
+  if (summary.hasThinking) {
+    props["ai.has_thinking"] = true;
+  }
+  return props;
+}
+
+// src/event-mapper.ts
 var MAX_ATTR_LENGTH = 32768;
 function truncate(value) {
   if (value === void 0) return void 0;
@@ -788,8 +923,8 @@ function writeState(key, value) {
 function readState(key) {
   try {
     const filePath = statePath(key);
-    if (!existsSync2(filePath)) return void 0;
-    return readFileSync2(filePath, "utf-8");
+    if (!existsSync3(filePath)) return void 0;
+    return readFileSync3(filePath, "utf-8");
   } catch (e) {
     return void 0;
   }
@@ -854,12 +989,15 @@ async function mapHookToRaindrop(payload, config, eventShipper, traceShipper) {
     cwd: payload.cwd,
     permission_mode: payload.permission_mode,
     plugin_version: PACKAGE_VERSION,
+    sdk: PACKAGE_NAME,
+    sdk_version: PACKAGE_VERSION,
     ...payload.agent_id ? { agent_id: payload.agent_id } : {},
     ...payload.agent_type ? { agent_type: payload.agent_type } : {}
   };
   switch (payload.hook_event_name) {
     case "SessionStart":
       writeState(`model_${payload.session_id}`, (_a = payload.model) != null ? _a : "");
+      tryCaptureAppendSystemPrompt(payload.session_id);
       break;
     case "UserPromptSubmit":
       await handleUserPromptSubmit(payload, convoId, config, baseProperties, eventShipper, traceShipper);
@@ -874,10 +1012,13 @@ async function mapHookToRaindrop(payload, config, eventShipper, traceShipper) {
       handlePostToolUseFailure(payload, getCurrentEventId(payload.session_id), traceShipper);
       break;
     case "Stop":
-      await handleStop(payload, getCurrentEventId(payload.session_id), config, baseProperties, eventShipper);
+      await handleStopOrFailure(payload, getCurrentEventId(payload.session_id), config, baseProperties, eventShipper, traceShipper);
       break;
     case "StopFailure":
-      await handleStopFailure(payload, getCurrentEventId(payload.session_id), config, baseProperties, eventShipper);
+      await handleStopOrFailure(payload, getCurrentEventId(payload.session_id), config, baseProperties, eventShipper, traceShipper, {
+        error: payload.error,
+        error_details: payload.error_details
+      });
       break;
     case "SubagentStart":
       handleSubagentStart(payload, getCurrentEventId(payload.session_id), traceShipper);
@@ -888,6 +1029,9 @@ async function mapHookToRaindrop(payload, config, eventShipper, traceShipper) {
     case "PermissionDenied":
       handlePermissionDenied(payload, getCurrentEventId(payload.session_id), traceShipper);
       break;
+    case "InstructionsLoaded":
+      handleInstructionsLoaded(payload);
+      break;
     case "PostCompact":
       await handlePostCompact(payload, getCurrentEventId(payload.session_id), config, baseProperties, eventShipper);
       break;
@@ -896,6 +1040,8 @@ async function mapHookToRaindrop(payload, config, eventShipper, traceShipper) {
       deleteState(turnEventKey(payload.session_id));
       deleteState(rootSpanKey(payload.session_id));
       deleteState(`model_${payload.session_id}`);
+      deleteState(appendSystemPromptKey(payload.session_id));
+      cleanupInstructions(payload.session_id);
       break;
     default:
       if (config.debug) {
@@ -1053,25 +1199,243 @@ async function handlePostCompact(payload, eventId, config, properties, eventShip
     }
   });
 }
-async function handleStop(payload, eventId, config, properties, eventShipper) {
-  await eventShipper.patch(eventId, {
-    isPending: false,
-    userId: config.userId,
-    eventName: config.eventName,
-    output: payload.last_assistant_message,
-    properties
-  });
+function handleInstructionsLoaded(payload) {
+  var _a;
+  if (!payload.file_path || !payload.session_id) return;
+  try {
+    if (existsSync3(payload.file_path)) {
+      const content = readFileSync3(payload.file_path, "utf-8");
+      const MAX_INSTRUCTIONS_LENGTH = 8192;
+      const truncated = content.length > MAX_INSTRUCTIONS_LENGTH ? content.slice(0, MAX_INSTRUCTIONS_LENGTH) + "\n...[truncated]" : content;
+      const fileKey = safeKey(payload.file_path);
+      const header = `# ${(_a = payload.memory_type) != null ? _a : "instructions"}: ${payload.file_path}
+`;
+      writeState(
+        `instr_${payload.session_id}_${fileKey}`,
+        header + truncated
+      );
+    }
+  } catch (e) {
+  }
 }
-async function handleStopFailure(payload, eventId, config, properties, eventShipper) {
+function gatherInstructions(sessionId) {
+  try {
+    if (!existsSync3(STATE_DIR)) return void 0;
+    const prefix = safeKey(`instr_${sessionId}_`);
+    const files = readdirSync(STATE_DIR).filter((f) => f.startsWith(prefix));
+    if (files.length === 0) return void 0;
+    const parts = [];
+    for (const file of files.sort()) {
+      try {
+        parts.push(readFileSync3(join2(STATE_DIR, file), "utf-8"));
+      } catch (e) {
+        continue;
+      }
+    }
+    return parts.length > 0 ? parts.join("\n\n---\n\n") : void 0;
+  } catch (e) {
+    return void 0;
+  }
+}
+function cleanupInstructions(sessionId) {
+  try {
+    if (!existsSync3(STATE_DIR)) return;
+    const prefix = safeKey(`instr_${sessionId}_`);
+    for (const file of readdirSync(STATE_DIR).filter((f) => f.startsWith(prefix))) {
+      try {
+        unlinkSync(join2(STATE_DIR, file));
+      } catch (e) {
+      }
+    }
+  } catch (e) {
+  }
+}
+var APPEND_FLAG = "--append-system-prompt";
+var APPEND_FILE_FLAG = "--append-system-prompt-file";
+var MAX_ANCESTOR_DEPTH = 15;
+var PS_TIMEOUT_MS = 3e3;
+function appendSystemPromptKey(sessionId) {
+  return `append_sysprompt_${sessionId}`;
+}
+function tryCaptureAppendSystemPrompt(sessionId) {
+  try {
+    const content = readAncestorAppendSystemPrompt();
+    if (content) {
+      writeState(appendSystemPromptKey(sessionId), content);
+    }
+  } catch (e) {
+  }
+}
+function readAncestorAppendSystemPrompt() {
+  let pid;
+  try {
+    pid = process.ppid;
+  } catch (e) {
+    return void 0;
+  }
+  if (!pid || pid <= 1) return void 0;
+  for (let depth = 0; depth < MAX_ANCESTOR_DEPTH && pid != null && pid > 1; depth++) {
+    try {
+      const args = getProcessArgs(pid);
+      if (args && args.length > 0) {
+        const content = extractAppendSystemPrompt(args);
+        if (content) return content;
+      }
+    } catch (e) {
+    }
+    try {
+      pid = getParentPid(pid);
+    } catch (e) {
+      break;
+    }
+  }
+  return void 0;
+}
+function getProcessArgs(pid) {
+  if (process.platform === "linux") {
+    try {
+      const raw = readFileSync3(`/proc/${pid}/cmdline`, "utf-8");
+      const args = raw.split("\0").filter(Boolean);
+      return args.length > 0 ? args : void 0;
+    } catch (e) {
+    }
+  }
+  try {
+    const output = execSync(`ps -ww -o args= -p ${pid}`, {
+      encoding: "utf-8",
+      timeout: PS_TIMEOUT_MS,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const trimmed = output.trim();
+    if (!trimmed) return void 0;
+    return trimmed.split(/\s+/);
+  } catch (e) {
+    return void 0;
+  }
+}
+function getParentPid(pid) {
+  try {
+    const output = execSync(`ps -o ppid= -p ${pid}`, {
+      encoding: "utf-8",
+      timeout: PS_TIMEOUT_MS,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const ppid = parseInt(output.trim(), 10);
+    return Number.isFinite(ppid) && ppid > 0 ? ppid : void 0;
+  } catch (e) {
+    return void 0;
+  }
+}
+function extractAppendSystemPrompt(args) {
+  const parts = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    try {
+      if (arg === APPEND_FILE_FLAG && i + 1 < args.length) {
+        const filePath = args[i + 1];
+        i++;
+        try {
+          if (existsSync3(filePath)) {
+            parts.push(readFileSync3(filePath, "utf-8"));
+          }
+        } catch (e) {
+        }
+        continue;
+      }
+      if (arg.startsWith(APPEND_FILE_FLAG + "=")) {
+        const filePath = arg.slice(APPEND_FILE_FLAG.length + 1);
+        try {
+          if (filePath && existsSync3(filePath)) {
+            parts.push(readFileSync3(filePath, "utf-8"));
+          }
+        } catch (e) {
+        }
+        continue;
+      }
+      if (arg === APPEND_FLAG && i + 1 < args.length) {
+        const valueParts = [];
+        for (let j = i + 1; j < args.length; j++) {
+          if (args[j].startsWith("--")) break;
+          valueParts.push(args[j]);
+          i = j;
+        }
+        if (valueParts.length > 0) {
+          parts.push(valueParts.join(" "));
+        }
+        continue;
+      }
+      if (arg.startsWith(APPEND_FLAG + "=") && !arg.startsWith(APPEND_FILE_FLAG)) {
+        const value = arg.slice(APPEND_FLAG.length + 1);
+        if (value) {
+          parts.push(value);
+        }
+        continue;
+      }
+    } catch (e) {
+      continue;
+    }
+  }
+  return parts.length > 0 ? parts.join("\n") : void 0;
+}
+function readAppendSystemPrompt(sessionId) {
+  try {
+    return readState(appendSystemPromptKey(sessionId)) || void 0;
+  } catch (e) {
+    return void 0;
+  }
+}
+function enrichFromTranscript(payload, eventId, traceShipper) {
+  var _a, _b;
+  if (!payload.transcript_path) {
+    return { summary: void 0, props: {} };
+  }
+  try {
+    const summary = parseTranscript(payload.transcript_path);
+    if (!summary) return { summary: void 0, props: {} };
+    const props = transcriptToProperties(summary);
+    const spanInputTokens = (_a = summary.lastTurnInputTokens) != null ? _a : summary.totalInputTokens;
+    const spanOutputTokens = (_b = summary.lastTurnOutputTokens) != null ? _b : summary.totalOutputTokens;
+    if (summary.model && (spanInputTokens > 0 || spanOutputTokens > 0)) {
+      const parent = getParentContext(payload);
+      const now = nowUnixNanoString();
+      traceShipper.createSpan({
+        name: summary.model,
+        eventId,
+        parent,
+        startTimeUnixNano: now,
+        endTimeUnixNano: now,
+        attributes: [
+          attrString("ai.operationId", "generateText"),
+          attrString("gen_ai.response.model", summary.model),
+          attrString("gen_ai.system", "anthropic"),
+          attrInt("gen_ai.usage.prompt_tokens", spanInputTokens),
+          attrInt("gen_ai.usage.completion_tokens", spanOutputTokens),
+          ...summary.lastTurnCacheReadTokens != null && summary.lastTurnCacheReadTokens > 0 ? [attrInt("gen_ai.usage.cache_read_tokens", summary.lastTurnCacheReadTokens)] : []
+        ]
+      });
+    }
+    return { summary, props };
+  } catch (e) {
+    return { summary: void 0, props: {} };
+  }
+}
+async function handleStopOrFailure(payload, eventId, config, properties, eventShipper, traceShipper, extraProperties) {
+  const { summary, props: transcriptProps } = enrichFromTranscript(payload, eventId, traceShipper);
+  const instructions = gatherInstructions(payload.session_id);
+  const appendSysPrompt = readAppendSystemPrompt(payload.session_id);
   await eventShipper.patch(eventId, {
     isPending: false,
     userId: config.userId,
+    convoId: payload.session_id,
     eventName: config.eventName,
     output: payload.last_assistant_message,
+    ...(summary == null ? void 0 : summary.model) ? { model: summary.model } : {},
     properties: {
       ...properties,
-      error: payload.error,
-      error_details: payload.error_details
+      ...transcriptProps,
+      ...instructions ? { system_instructions: truncate(instructions) } : {},
+      ...appendSysPrompt ? { append_system_prompt: truncate(appendSysPrompt) } : {},
+      ...extraProperties
     }
   });
 }
@@ -1088,7 +1452,7 @@ async function handleSessionEnd(payload, eventId, config, properties, eventShipp
 }
 
 // src/local-debugger.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
 import { join as join3 } from "path";
 var DEFAULT_PORT = 5899;
@@ -1099,8 +1463,8 @@ var CACHE_FILE = join3(CACHE_DIR, "debugger_cache");
 var CACHE_TTL_MS = 5e3;
 function readCache() {
   try {
-    if (!existsSync3(CACHE_FILE)) return void 0;
-    const data = JSON.parse(readFileSync3(CACHE_FILE, "utf-8"));
+    if (!existsSync4(CACHE_FILE)) return void 0;
+    const data = JSON.parse(readFileSync4(CACHE_FILE, "utf-8"));
     if (Date.now() - data.ts > CACHE_TTL_MS) return void 0;
     return data;
   } catch (e) {
@@ -1173,9 +1537,12 @@ export {
   PACKAGE_VERSION,
   TraceShipper2 as TraceShipper,
   detectLocalDebugger,
+  extractAppendSystemPrompt,
   getConfigPath,
   loadConfig,
   mapHookToRaindrop,
   mirrorEventToLocalDebugger,
+  parseTranscript,
+  transcriptToProperties,
   updateConfig
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raindrop-ai/claude-code",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "description": "Raindrop observability for Claude Code CLI — automatic session, tool call, and prompt tracing via hooks",
   "license": "MIT",
   "type": "module",