agentel 0.2.0

package/src/importers/claude.js

@@ -0,0 +1,349 @@
+"use strict";
+
+const { toIso } = require("../archive");
+
+function updateClaudeParseContext(event, provider, context = {}) {
+  if (!isClaudeProvider(provider) || !event || typeof event !== "object") return;
+  const message = event.message || {};
+  context.model ||= firstString(event.model, message.model);
+  context.sessionId ||= firstString(event.sessionId, event.session_id, event.session?.id);
+  context.cwd ||= firstString(event.cwd, event.workingDirectory, event.working_directory);
+}
+
+function extractClaudeMessagesFromEvent(event, provider, context = {}) {
+  if (!isClaudeProvider(provider) || !event || typeof event !== "object") return [];
+  const type = String(event.type || event.kind || event.message?.role || "").toLowerCase();
+  const message = event.message && typeof event.message === "object" ? event.message : event;
+  const role = normalizeRole(message.role || event.role || type);
+  const timestamp = eventTimestamp(event);
+
+  if (type === "summary" || event.summary) {
+    const content = firstString(event.summary, message.summary);
+    return content ? [supplementaryMessage(provider, "Claude summary", content, timestamp, "summary")] : [];
+  }
+
+  if (!role || role === "system") return [];
+
+  const content = message.content ?? event.content;
+  if (role === "assistant") return assistantMessages(event, message, provider, context, timestamp, content);
+  if (role === "user") return userMessages(event, message, provider, context, timestamp, content);
+  return [];
+}
+
+function assistantMessages(event, message, provider, context, timestamp, content) {
+  const text = visibleText(content);
+  const thinking = thinkingText(content);
+  const toolCalls = toolUseParts(content).map((part) => normalizeToolCall(part, provider)).filter(Boolean);
+  const metadata = {
+    provider,
+    eventType: firstString(event.type, event.kind),
+    model: firstString(message.model, event.model, context.model) || undefined,
+    requestId: firstString(event.requestId, event.request_id, message.id) || undefined,
+    status: firstString(message.stop_reason, event.stop_reason, event.status) || undefined,
+    usage: claudeUsage(message.usage || event.usage) || undefined,
+    toolCalls: toolCalls.length ? toolCalls : undefined
+  };
+  const result = [];
+  if (thinking) result.push(supplementaryMessage(provider, "Claude thinking", thinking, timestamp, "thinking", metadata.model));
+  if (text || toolCalls.length) result.push({ role: "assistant", content: text, timestamp, metadata });
+  return result;
+}
+
+function userMessages(event, message, provider, context, timestamp, content) {
+  const text = visibleText(content);
+  const toolResults = toolResultParts(content).map((part) => normalizeToolResult(part, provider, event.toolUseResult)).filter(Boolean);
+  const result = [];
+  if (text) {
+    result.push({
+      role: "user",
+      content: text,
+      timestamp,
+      metadata: {
+        provider,
+        eventType: firstString(event.type, event.kind),
+        model: firstString(message.model, event.model, context.model) || undefined
+      }
+    });
+  }
+  for (let index = 0; index < toolResults.length; index++) {
+    const toolResult = toolResults[index];
+    result.push({
+      role: "tool",
+      content: toolResult.output,
+      timestamp: offsetTimestamp(timestamp, index + 1),
+      metadata: {
+        provider,
+        eventType: "claude-tool-result",
+        toolResult
+      }
+    });
+  }
+  return result;
+}
+
+function supplementaryMessage(provider, title, content, timestamp, summaryKind, model = "") {
+  return {
+    role: "assistant",
+    content: `### ${title}\n\n${String(content || "").trim()}`,
+    timestamp,
+    metadata: {
+      provider,
+      eventType: `claude-${summaryKind}`,
+      supplementary: true,
+      summaryKind,
+      model: model || undefined
+    }
+  };
+}
+
+function toolUseParts(content) {
+  return arrayContent(content).filter((part) => {
+    const type = String(part?.type || part?.kind || "").toLowerCase();
+    return type === "tool_use" || type === "server_tool_use" || type === "mcp_tool_use" || type === "function_call";
+  });
+}
+
+function toolResultParts(content) {
+  return arrayContent(content).filter((part) => {
+    const type = String(part?.type || part?.kind || "").toLowerCase();
+    return type === "tool_result" || type === "function_result" || type === "tool_output";
+  });
+}
+
+function arrayContent(content) {
+  return Array.isArray(content) ? content.filter((part) => part && typeof part === "object") : [];
+}
+
+function visibleText(content) {
+  if (!Array.isArray(content)) return extractText(content).trim();
+  return content
+    .filter((part) => {
+      const type = String(part?.type || part?.kind || "").toLowerCase();
+      return !/(tool_use|tool_result|function_call|function_result|thinking|redacted_thinking)/.test(type);
+    })
+    .map((part) => extractText(part))
+    .filter(Boolean)
+    .join("\n")
+    .trim();
+}
+
+function thinkingText(content) {
+  if (!Array.isArray(content)) return "";
+  return content
+    .filter((part) => /thinking/.test(String(part?.type || part?.kind || "").toLowerCase()))
+    .map((part) => firstString(part.thinking, part.text, part.content, part.summary))
+    .filter(Boolean)
+    .join("\n\n")
+    .trim();
+}
+
+function normalizeToolCall(part, provider) {
+  const rawName = firstString(part.name, part.tool_name, part.toolName, part.function?.name, "tool");
+  const rawArgs = parseArgs(part.input ?? part.arguments ?? part.args ?? part.function?.arguments);
+  const command = toolCommandText(rawArgs);
+  const patch = extractApplyPatchFromCommand(command);
+  const name = patch && /bash|shell|command|exec|terminal/i.test(rawName) ? "apply_patch" : rawName;
+  const args = patch && rawArgs && typeof rawArgs === "object" && !Array.isArray(rawArgs)
+    ? {
+        ...rawArgs,
+        patch,
+        diff: patch,
+        path: rawArgs.path || rawArgs.file_path || rawArgs.file || patchTargetPath(patch) || undefined
+      }
+    : rawArgs;
+  const summary = summarizeArgs(args);
+  const category = patch ? "edit" : toolCategory(name, part.type);
+  return {
+    id: firstString(part.id, part.tool_use_id, part.call_id, part.callId) || undefined,
+    name,
+    displayName: displayName(name),
+    rawCategory: firstString(part.type, part.kind) || undefined,
+    category,
+    title: firstString(part.title, displayName(name)),
+    status: firstString(part.status, "tool_call"),
+    argument: summary,
+    rawInputSummary: summary,
+    inputPreview: summary,
+    target: toolTarget(args) || undefined,
+    arguments: args && typeof args === "object" && !Array.isArray(args) ? args : undefined,
+    provider
+  };
+}
+
+function normalizeToolResult(part, provider, eventToolUseResult) {
+  const output = extractToolResultOutput(part, eventToolUseResult);
+  if (!output) return null;
+  const name = firstString(part.name, part.tool_name, part.toolName, part.tool_use_id, "Tool output");
+  const category = toolCategory(name, part.type);
+  return {
+    provider,
+    id: firstString(part.tool_use_id, part.id, part.call_id, part.callId) || undefined,
+    kind: displayName(name),
+    title: part.is_error ? "Tool error" : "Tool result",
+    rawCategory: firstString(part.type, part.kind) || undefined,
+    category,
+    categoryLabel: displayName(category),
+    summary: firstLine(output),
+    output,
+    lineCount: output.split("\n").length,
+    collapsed: output.split("\n").length > 18,
+    status: part.is_error ? "error" : "completed"
+  };
+}
+
+function extractToolResultOutput(part, eventToolUseResult) {
+  const direct = extractText(part.content ?? part.output ?? part.result ?? part.text);
+  const extra = extractText(eventToolUseResult?.stdout ?? eventToolUseResult?.stderr ?? eventToolUseResult?.output ?? eventToolUseResult?.content);
+  return [direct, extra].filter(Boolean).join("\n").trim();
+}
+
+function claudeUsage(usage) {
+  if (!usage || typeof usage !== "object") return null;
+  const input = numberValue(usage.input_tokens, usage.inputTokens, usage.prompt_tokens);
+  const output = numberValue(usage.output_tokens, usage.outputTokens, usage.completion_tokens);
+  const cacheCreation = numberValue(usage.cache_creation_input_tokens, usage.cacheCreationInputTokens);
+  const cacheRead = numberValue(usage.cache_read_input_tokens, usage.cacheReadInputTokens);
+  if ([input, output, cacheCreation, cacheRead].every((value) => value == null)) return null;
+  return {
+    inputTokens: input ?? undefined,
+    outputTokens: output ?? undefined,
+    cacheCreationInputTokens: cacheCreation ?? undefined,
+    cacheReadInputTokens: cacheRead ?? undefined,
+    totalTokens: [input, output, cacheCreation, cacheRead].reduce((sum, value) => sum + (value || 0), 0)
+  };
+}
+
+function extractText(value, depth = 0) {
+  if (value == null || depth > 6) return "";
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (Array.isArray(value)) return value.map((item) => extractText(item, depth + 1)).filter(Boolean).join("\n");
+  if (typeof value === "object") {
+    if (typeof value.text === "string") return value.text;
+    if (typeof value.content === "string") return value.content;
+    if (Array.isArray(value.content)) return extractText(value.content, depth + 1);
+    if (Array.isArray(value.parts)) return extractText(value.parts, depth + 1);
+    if (value.message) return extractText(value.message, depth + 1);
+  }
+  return "";
+}
+
+function parseArgs(value) {
+  if (value == null) return {};
+  if (typeof value === "string") {
+    try {
+      return JSON.parse(value);
+    } catch {
+      return value;
+    }
+  }
+  return value;
+}
+
+function summarizeArgs(value) {
+  if (value == null) return "";
+  if (typeof value === "string") return value.slice(0, 240);
+  if (typeof value !== "object") return String(value).slice(0, 240);
+  for (const key of ["command", "cmd", "query", "pattern", "path", "file_path", "url"]) {
+    if (value[key]) return String(value[key]).slice(0, 240);
+  }
+  return Object.entries(value)
+    .slice(0, 3)
+    .map(([key, item]) => `${key}: ${typeof item === "string" ? item : JSON.stringify(item)}`)
+    .join(", ")
+    .slice(0, 240);
+}
+
+function toolTarget(args) {
+  if (!args || typeof args !== "object" || Array.isArray(args)) return "";
+  return firstString(args.path, args.file_path, args.file, args.url);
+}
+
+function toolCategory(name, type) {
+  const key = `${name || ""} ${type || ""}`.toLowerCase();
+  if (/edit|write|patch|replace|update|notebook/.test(key)) return "edit";
+  if (/bash|shell|command|exec|terminal/.test(key)) return "shell";
+  if (/read|open|view|list|ls/.test(key)) return "read";
+  if (/grep|glob|find|search|rg/.test(key)) return "search";
+  if (/web|fetch|url|browser/.test(key)) return "web";
+  if (/mcp/.test(key)) return "mcp";
+  return "tool";
+}
+
+function toolCommandText(args) {
+  if (typeof args === "string") return args;
+  if (!args || typeof args !== "object" || Array.isArray(args)) return "";
+  const command = args.command ?? args.cmd ?? args.script;
+  if (Array.isArray(command)) return command.filter((part) => typeof part === "string").join(" ");
+  return firstString(command);
+}
+
+function extractApplyPatchFromCommand(command) {
+  const text = String(command || "");
+  if (!/\bapply_patch\b/.test(text) && !/\*\*\* Begin Patch/.test(text)) return "";
+  const heredoc = text.match(/apply_patch\s*<<\s*['"]?([A-Za-z0-9_-]+)['"]?\s*\n([\s\S]*?)\n\1\b/);
+  if (heredoc) return heredoc[2].trim();
+  const begin = text.indexOf("*** Begin Patch");
+  const end = text.indexOf("*** End Patch");
+  if (begin >= 0 && end >= begin) return text.slice(begin, end + "*** End Patch".length).trim();
+  return "";
+}
+
+function patchTargetPath(patch) {
+  const match = String(patch || "").match(/^\*\*\* (?:Update|Add|Delete) File:\s+(.+)$/m);
+  return match ? match[1].trim() : "";
+}
+
+function displayName(value) {
+  return String(value || "tool")
+    .split(/_+/g)
+    .map((part) => part.replace(/(^|[-\s])([a-z])/g, (_, prefix, char) => `${prefix}${char.toUpperCase()}`))
+    .join(" ");
+}
+
+function eventTimestamp(event) {
+  return toIso(event.timestamp || event.created_at || event.createdAt || event.time || event.message?.timestamp) || "";
+}
+
+function offsetTimestamp(timestamp, offset = 0) {
+  const base = Date.parse(timestamp);
+  if (!Number.isFinite(base)) return timestamp || "";
+  return new Date(base + offset).toISOString();
+}
+
+function normalizeRole(role) {
+  const value = String(role || "").toLowerCase();
+  if (value === "human" || value.includes("user")) return "user";
+  if (value === "assistant" || value.includes("assistant")) return "assistant";
+  if (value === "system") return "system";
+  return "";
+}
+
+function numberValue(...values) {
+  for (const value of values) {
+    if (value == null || value === "") continue;
+    const number = Number(value);
+    if (Number.isFinite(number)) return number;
+  }
+  return null;
+}
+
+function firstString(...values) {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim()) return value.trim();
+  }
+  return "";
+}
+
+function firstLine(value) {
+  return String(value || "").split(/\r?\n/).find((line) => line.trim())?.trim() || "";
+}
+
+function isClaudeProvider(provider) {
+  return provider === "claude_code" || provider === "claude_sdk" || provider === "claude_desktop";
+}
+
+module.exports = {
+  extractClaudeMessagesFromEvent,
+  updateClaudeParseContext
+};