Upload parsers.js with huggingface_hub

parsers.js

@@ -0,0 +1,621 @@
+// parsers.js — Unified session parser for Claude Code, Pi, Codex, and OpenCode
+//
+// Unified Schema:
+//   UnifiedSession { id, source, title?, cwd?, model?, provider?, startedAt?, messages[] }
+//   UnifiedMessage { id, role, timestamp?, blocks[], usage?, model? }
+//   ContentBlock = { type: "text", text }
+//                | { type: "thinking", text }
+//                | { type: "tool_call", callId, toolName, input }
+//                | { type: "tool_result", callId, content, isError? }
+
+function detectFormat(lines) {
+  for (const line of lines) {
+    if (!line || typeof line !== "object") continue;
+    // Claude Code: has uuid + type in [user, assistant, system, file-history-snapshot, progress]
+    if (line.uuid && ["user", "assistant", "system", "file-history-snapshot", "progress"].includes(line.type)) {
+      return "claude-code";
+    }
+    // Codex: envelope {timestamp, type, payload} with type=session_meta
+    if (line.type === "session_meta" && line.payload) {
+      return "codex";
+    }
+    // Pi: type=session with version + cwd (no payload wrapper)
+    if (line.type === "session" && line.version !== undefined && line.cwd) {
+      return "pi";
+    }
+    // OpenCode: type=session with directory field
+    if (line.type === "session" && line.directory) {
+      return "opencode";
+    }
+    // Codex response_item with payload
+    if (line.type === "response_item" && line.payload) {
+      return "codex";
+    }
+  }
+  return null;
+}
+
+// ─── Claude Code ─────────────────────────────────────────────
+
+function parseClaudeCode(lines) {
+  const session = {
+    id: null,
+    source: "claude-code",
+    title: null,
+    cwd: null,
+    model: null,
+    provider: "anthropic",
+    startedAt: null,
+    messages: [],
+  };
+
+  // Filter to conversation entries only (skip file-history-snapshot, progress)
+  const entries = lines.filter(
+    (l) => l && ["user", "assistant", "system"].includes(l.type)
+  );
+
+  if (entries.length > 0) {
+    session.cwd = entries[0].cwd || null;
+    session.startedAt = entries[0].timestamp || null;
+    session.id = entries[0].promptId || entries[0].uuid || null;
+  }
+
+  // Build tree and walk main branch
+  const byUuid = new Map();
+  for (const e of entries) {
+    if (e.uuid) byUuid.set(e.uuid, e);
+  }
+
+  // Find root(s) — entries with no parentUuid or parentUuid not in set
+  // Then walk children in timestamp order
+  const childrenOf = new Map();
+  for (const e of entries) {
+    const parent = e.parentUuid || null;
+    if (!childrenOf.has(parent)) childrenOf.set(parent, []);
+    childrenOf.get(parent).push(e);
+  }
+
+  // Walk main branch (non-sidechain)
+  const ordered = [];
+  function walk(parentId) {
+    const children = childrenOf.get(parentId) || [];
+    const mainBranch = children.filter((c) => !c.isSidechain);
+    mainBranch.sort(
+      (a, b) => new Date(a.timestamp) - new Date(b.timestamp)
+    );
+    for (const child of mainBranch) {
+      ordered.push(child);
+      walk(child.uuid);
+    }
+  }
+  walk(null);
+
+  // If tree walk produced nothing (flat format), fall back to array order
+  const sequence = ordered.length > 0 ? ordered : entries;
+
+  // Group consecutive assistant entries with the same message.id
+  let currentMsg = null;
+  for (const entry of sequence) {
+    const msg = entry.message || {};
+    const role = entry.type === "system" ? "system" : msg.role || entry.type;
+
+    if (role === "system" && entry.subtype === "turn_duration") continue;
+
+    const blocks = extractClaudeCodeBlocks(msg.content);
+    if (blocks.length === 0 && role !== "system") continue;
+
+    const msgId = msg.id || entry.uuid;
+
+    // Merge consecutive assistant chunks with same message.id
+    if (
+      role === "assistant" &&
+      currentMsg &&
+      currentMsg.role === "assistant" &&
+      currentMsg._rawId === msgId
+    ) {
+      currentMsg.blocks.push(...blocks);
+      if (msg.usage) currentMsg.usage = mapClaudeCodeUsage(msg.usage);
+      continue;
+    }
+
+    if (!session.model && msg.model) session.model = msg.model;
+
+    currentMsg = {
+      id: entry.uuid || msgId,
+      role: normalizeRole(role),
+      timestamp: entry.timestamp || null,
+      blocks,
+      usage: msg.usage ? mapClaudeCodeUsage(msg.usage) : undefined,
+      model: msg.model || undefined,
+      _rawId: msgId,
+    };
+    session.messages.push(currentMsg);
+  }
+
+  // Clean up internal fields
+  for (const m of session.messages) delete m._rawId;
+
+  return session;
+}
+
+function extractClaudeCodeBlocks(content) {
+  if (!content) return [];
+  if (typeof content === "string") return [{ type: "text", text: content }];
+  if (!Array.isArray(content)) return [];
+
+  const blocks = [];
+  for (const item of content) {
+    if (!item || typeof item !== "object") continue;
+    switch (item.type) {
+      case "text":
+        if (item.text) blocks.push({ type: "text", text: item.text });
+        break;
+      case "thinking":
+        if (item.thinking)
+          blocks.push({ type: "thinking", text: item.thinking });
+        break;
+      case "tool_use":
+        blocks.push({
+          type: "tool_call",
+          callId: item.id || "",
+          toolName: item.name || "unknown",
+          input: item.input || {},
+        });
+        break;
+      case "tool_result":
+        blocks.push({
+          type: "tool_result",
+          callId: item.tool_use_id || "",
+          content: formatToolResultContent(item.content),
+          isError: item.is_error || false,
+        });
+        break;
+    }
+  }
+  return blocks;
+}
+
+function formatToolResultContent(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content
+      .map((c) => {
+        if (typeof c === "string") return c;
+        if (c.type === "text") return c.text || "";
+        return JSON.stringify(c);
+      })
+      .join("\n");
+  }
+  return JSON.stringify(content);
+}
+
+function mapClaudeCodeUsage(usage) {
+  if (!usage) return undefined;
+  return {
+    inputTokens: usage.input_tokens,
+    outputTokens: usage.output_tokens,
+    cacheRead: usage.cache_read_input_tokens,
+    cacheWrite: usage.cache_creation_input_tokens,
+  };
+}
+
+// ─── Pi ──────────────────────────────────────────────────────
+
+function parsePi(lines) {
+  const session = {
+    id: null,
+    source: "pi",
+    title: null,
+    cwd: null,
+    model: null,
+    provider: null,
+    startedAt: null,
+    messages: [],
+  };
+
+  for (const line of lines) {
+    if (!line) continue;
+    switch (line.type) {
+      case "session":
+        session.id = line.id;
+        session.cwd = line.cwd;
+        session.startedAt = line.timestamp;
+        break;
+
+      case "model_change":
+        session.provider = line.provider;
+        session.model = line.modelId;
+        break;
+
+      case "message": {
+        const msg = line.message;
+        if (!msg) break;
+        const blocks = extractPiBlocks(msg.content);
+        const unified = {
+          id: line.id,
+          role: normalizeRole(msg.role),
+          timestamp: line.timestamp,
+          blocks,
+          usage: msg.usage ? mapPiUsage(msg.usage) : undefined,
+          model: msg.model || undefined,
+        };
+        session.messages.push(unified);
+        break;
+      }
+    }
+  }
+
+  return session;
+}
+
+function extractPiBlocks(content) {
+  if (!content) return [];
+  if (typeof content === "string") return [{ type: "text", text: content }];
+  if (!Array.isArray(content)) return [];
+
+  const blocks = [];
+  for (const item of content) {
+    if (!item || typeof item !== "object") continue;
+    switch (item.type) {
+      case "text":
+        if (item.text) blocks.push({ type: "text", text: item.text });
+        break;
+      case "thinking":
+        if (item.thinking)
+          blocks.push({ type: "thinking", text: item.thinking });
+        break;
+      case "toolCall":
+        blocks.push({
+          type: "tool_call",
+          callId: item.id || "",
+          toolName: item.name || "unknown",
+          input: item.arguments || {},
+        });
+        break;
+      case "toolResult":
+        blocks.push({
+          type: "tool_result",
+          callId: item.toolCallId || "",
+          content:
+            typeof item.result === "string"
+              ? item.result
+              : JSON.stringify(item.result),
+          isError: item.isError || false,
+        });
+        break;
+    }
+  }
+  return blocks;
+}
+
+function mapPiUsage(usage) {
+  if (!usage) return undefined;
+  return {
+    inputTokens: usage.input,
+    outputTokens: usage.output,
+    cacheRead: usage.cacheRead,
+    cacheWrite: usage.cacheWrite,
+  };
+}
+
+// ─── Codex ───────────────────────────────────────────────────
+
+function parseCodex(lines) {
+  const session = {
+    id: null,
+    source: "codex",
+    title: null,
+    cwd: null,
+    model: null,
+    provider: null,
+    startedAt: null,
+    messages: [],
+  };
+
+  let lastAssistant = null;
+
+  for (const line of lines) {
+    if (!line) continue;
+    const payload = line.payload || {};
+
+    switch (line.type) {
+      case "session_meta":
+        session.id = payload.id;
+        session.cwd = payload.cwd;
+        session.startedAt = payload.timestamp || line.timestamp;
+        session.provider = payload.model_provider;
+        session.model = payload.model;
+        if (payload.git) session.title = payload.git.branch;
+        break;
+
+      case "turn_context":
+        if (payload.model) session.model = session.model || payload.model;
+        break;
+
+      case "response_item": {
+        const p = payload;
+        if (p.type === "message") {
+          const role = normalizeRole(p.role);
+          if (role === "system") {
+            // developer messages — skip system instructions
+            continue;
+          }
+          const blocks = extractCodexBlocks(p.content);
+          if (blocks.length === 0) continue;
+
+          const msg = {
+            id: p.id || `codex-${session.messages.length}`,
+            role,
+            timestamp: line.timestamp,
+            blocks,
+            usage: p.usage ? mapCodexUsage(p.usage) : undefined,
+            model: p.model || undefined,
+          };
+          session.messages.push(msg);
+          if (role === "assistant") lastAssistant = msg;
+        } else if (p.type === "function_call") {
+          // Append tool call to last assistant message
+          const block = {
+            type: "tool_call",
+            callId: p.call_id || "",
+            toolName: p.name || "unknown",
+            input: tryParseJSON(p.arguments),
+          };
+          if (lastAssistant) {
+            lastAssistant.blocks.push(block);
+          } else {
+            session.messages.push({
+              id: `codex-fc-${session.messages.length}`,
+              role: "assistant",
+              timestamp: line.timestamp,
+              blocks: [block],
+            });
+          }
+        } else if (p.type === "function_call_output") {
+          session.messages.push({
+            id: `codex-fco-${session.messages.length}`,
+            role: "user",
+            timestamp: line.timestamp,
+            blocks: [
+              {
+                type: "tool_result",
+                callId: p.call_id || "",
+                content: p.output || "",
+                isError: false,
+              },
+            ],
+          });
+        } else if (p.type === "local_shell_call") {
+          const block = {
+            type: "tool_call",
+            callId: p.id || "",
+            toolName: "shell",
+            input: p.action || {},
+          };
+          if (lastAssistant) {
+            lastAssistant.blocks.push(block);
+          }
+        } else if (p.type === "reasoning") {
+          const text =
+            p.encrypted_content
+              ? "(encrypted reasoning)"
+              : p.summary
+                  ?.map((s) => s.text || "")
+                  .join("\n") || "(reasoning)";
+          if (lastAssistant) {
+            lastAssistant.blocks.unshift({ type: "thinking", text });
+          }
+        }
+        break;
+      }
+    }
+  }
+
+  return session;
+}
+
+function extractCodexBlocks(content) {
+  if (!content) return [];
+  if (typeof content === "string") return [{ type: "text", text: content }];
+  if (!Array.isArray(content)) return [];
+
+  const blocks = [];
+  for (const item of content) {
+    if (!item || typeof item !== "object") continue;
+    if (item.type === "output_text" && item.text) {
+      blocks.push({ type: "text", text: item.text });
+    } else if (item.type === "input_text" && item.text) {
+      blocks.push({ type: "text", text: item.text });
+    }
+  }
+  return blocks;
+}
+
+function mapCodexUsage(usage) {
+  if (!usage) return undefined;
+  return {
+    inputTokens: usage.input || usage.input_tokens,
+    outputTokens: usage.output || usage.output_tokens,
+    cacheRead: usage.cacheRead || usage.cache_read_input_tokens,
+    cacheWrite: usage.cacheWrite || usage.cache_creation_input_tokens,
+  };
+}
+
+// ─── OpenCode ────────────────────────────────────────────────
+
+function parseOpenCode(lines) {
+  const session = {
+    id: null,
+    source: "opencode",
+    title: null,
+    cwd: null,
+    model: null,
+    provider: null,
+    startedAt: null,
+    messages: [],
+  };
+
+  const messageParts = new Map(); // messageId -> part[]
+  const messageEntries = [];
+
+  for (const line of lines) {
+    if (!line) continue;
+    switch (line.type) {
+      case "session":
+        session.id = line.id;
+        session.title = line.title;
+        session.cwd = line.directory;
+        session.startedAt = line.time_created
+          ? new Date(line.time_created).toISOString()
+          : null;
+        break;
+
+      case "message":
+        messageEntries.push(line);
+        break;
+
+      case "part":
+        if (!messageParts.has(line.message_id)) {
+          messageParts.set(line.message_id, []);
+        }
+        messageParts.get(line.message_id).push(line);
+        break;
+    }
+  }
+
+  // Sort messages by time
+  messageEntries.sort((a, b) => (a.time_created || 0) - (b.time_created || 0));
+
+  for (const msg of messageEntries) {
+    const data = msg.data || {};
+    const role = normalizeRole(data.role);
+    const parts = messageParts.get(msg.id) || [];
+    parts.sort((a, b) => (a.time_created || 0) - (b.time_created || 0));
+
+    if (!session.model && data.model) {
+      session.model = data.model.modelID || null;
+      session.provider = data.model.providerID || null;
+    }
+
+    const blocks = [];
+    for (const part of parts) {
+      const pd = part.data || {};
+      switch (pd.type) {
+        case "text":
+          if (pd.text) blocks.push({ type: "text", text: pd.text });
+          break;
+        case "tool-invocation":
+        case "tool":
+          blocks.push({
+            type: "tool_call",
+            callId: pd.toolCallId || pd.id || "",
+            toolName: pd.toolName || pd.tool?.name || "unknown",
+            input: pd.args || pd.tool?.args || pd.input || {},
+          });
+          break;
+        case "tool-result":
+          blocks.push({
+            type: "tool_result",
+            callId: pd.toolCallId || "",
+            content:
+              typeof pd.result === "string"
+                ? pd.result
+                : JSON.stringify(pd.result),
+            isError: pd.isError || false,
+          });
+          break;
+        case "step-start":
+        case "step-finish":
+          // Skip lifecycle markers
+          break;
+        default:
+          if (pd.text) blocks.push({ type: "text", text: pd.text });
+      }
+    }
+
+    if (blocks.length === 0) continue;
+
+    const usage = data.tokens
+      ? {
+          inputTokens: data.tokens.input,
+          outputTokens: data.tokens.output,
+        }
+      : undefined;
+
+    session.messages.push({
+      id: msg.id,
+      role,
+      timestamp: msg.time_created
+        ? new Date(msg.time_created).toISOString()
+        : null,
+      blocks,
+      usage,
+      model: data.model?.modelID || undefined,
+    });
+  }
+
+  return session;
+}
+
+// ─── Shared Helpers ──────────────────────────────────────────
+
+function normalizeRole(role) {
+  if (!role) return "user";
+  const r = role.toLowerCase();
+  if (r === "developer" || r === "system") return "system";
+  if (r === "assistant") return "assistant";
+  return "user";
+}
+
+function tryParseJSON(str) {
+  if (typeof str !== "string") return str;
+  try {
+    return JSON.parse(str);
+  } catch {
+    return str;
+  }
+}
+
+// ─── Entry Point ─────────────────────────────────────────────
+
+function parseSession(jsonlText) {
+  const lines = jsonlText
+    .split("\n")
+    .filter((l) => l.trim())
+    .map((l) => {
+      try {
+        return JSON.parse(l);
+      } catch {
+        return null;
+      }
+    })
+    .filter(Boolean);
+
+  const format = detectFormat(lines);
+  if (!format) throw new Error("Unknown session format");
+
+  switch (format) {
+    case "claude-code":
+      return parseClaudeCode(lines);
+    case "pi":
+      return parsePi(lines);
+    case "codex":
+      return parseCodex(lines);
+    case "opencode":
+      return parseOpenCode(lines);
+    default:
+      throw new Error(`Unsupported format: ${format}`);
+  }
+}
+
+// Export for both browser and Node.js
+if (typeof module !== "undefined" && module.exports) {
+  module.exports = {
+    parseSession,
+    detectFormat,
+    parseClaudeCode,
+    parsePi,
+    parseCodex,
+    parseOpenCode,
+  };
+}