agent-replay 0.1.0

package/build/server/chunks/index2-f44F-4KW.js

@@ -0,0 +1,614 @@
+import { readFile, readdir, stat } from 'fs/promises';
+import { join, basename } from 'path';
+import { b as private_env } from './shared-server-DaWdgxVh.js';
+import { homedir } from 'os';
+import Database from 'better-sqlite3';
+
+const CLAUDE_DIR = private_env.CLAUDE_DIR || join(homedir(), ".claude", "projects");
+private_env.DEMO_MODE === "true";
+const PRICING = {
+  "claude-opus-4-6": { input: 15, output: 75 },
+  "claude-sonnet-4-5-20250929": { input: 3, output: 15 },
+  "claude-haiku-4-5-20251001": { input: 0.8, output: 4 },
+  // Older models
+  "claude-3-5-sonnet-20241022": { input: 3, output: 15 },
+  "claude-3-5-haiku-20241022": { input: 0.8, output: 4 },
+  "claude-3-opus-20240229": { input: 15, output: 75 },
+  "claude-3-sonnet-20240229": { input: 3, output: 15 }
+};
+const DEFAULT_PRICING = { input: 3, output: 15 };
+function estimateCost(model, inputTokens, outputTokens) {
+  const pricing = PRICING[model] || DEFAULT_PRICING;
+  return (inputTokens * pricing.input + outputTokens * pricing.output) / 1e6;
+}
+function decodeProjectName(dirName) {
+  return dirName.replace(/-/g, "/").replace(/^\//, "");
+}
+async function discoverSessions() {
+  const sessions = [];
+  let projectDirs;
+  try {
+    projectDirs = await readdir(CLAUDE_DIR);
+  } catch {
+    return [];
+  }
+  for (const projectDir of projectDirs) {
+    const projectPath = join(CLAUDE_DIR, projectDir);
+    const projectStat = await stat(projectPath).catch(() => null);
+    if (!projectStat?.isDirectory()) continue;
+    let files;
+    try {
+      files = await readdir(projectPath);
+    } catch {
+      continue;
+    }
+    for (const file of files) {
+      if (!file.endsWith(".jsonl")) continue;
+      const filePath = join(projectPath, file);
+      const sessionId = basename(file, ".jsonl");
+      try {
+        const summary = await buildSummary(filePath, sessionId, projectDir);
+        if (summary) sessions.push(summary);
+      } catch {
+      }
+    }
+  }
+  sessions.sort((a, b) => new Date(b.lastActiveAt).getTime() - new Date(a.lastActiveAt).getTime());
+  return sessions;
+}
+async function buildSummary(filePath, sessionId, projectDir) {
+  const content = await readFile(filePath, "utf-8");
+  const lines = content.split("\n").filter((l) => l.trim());
+  if (lines.length === 0) return null;
+  let slug = "";
+  let model = "";
+  let version = "";
+  let startedAt = "";
+  let lastActiveAt = "";
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let toolCallCount = 0;
+  let eventCount = 0;
+  for (const line of lines) {
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (entry.type === "progress" || entry.type === "queue-operation")
+      continue;
+    if (entry.type === "user") {
+      const userEntry = entry;
+      if (!startedAt && userEntry.timestamp) startedAt = userEntry.timestamp;
+      if (userEntry.timestamp) lastActiveAt = userEntry.timestamp;
+      if (userEntry.slug && !slug) slug = userEntry.slug;
+      if (userEntry.version && !version) version = userEntry.version;
+      eventCount++;
+    }
+    if (entry.type === "assistant") {
+      const assistantEntry = entry;
+      if (assistantEntry.timestamp) lastActiveAt = assistantEntry.timestamp;
+      if (assistantEntry.message.model && !model && assistantEntry.message.model !== "synthetic")
+        model = assistantEntry.message.model;
+      const usage = assistantEntry.message.usage;
+      if (usage) {
+        inputTokens += (usage.input_tokens || 0) + (usage.cache_read_input_tokens || 0);
+        outputTokens += usage.output_tokens || 0;
+      }
+      const content2 = assistantEntry.message.content;
+      if (Array.isArray(content2)) {
+        for (const block of content2) {
+          if (block.type === "tool_use") toolCallCount++;
+        }
+      }
+      eventCount++;
+    }
+  }
+  if (!startedAt) return null;
+  return {
+    sessionId,
+    project: decodeProjectName(projectDir),
+    slug,
+    startedAt,
+    lastActiveAt,
+    model,
+    version,
+    eventCount,
+    toolCallCount,
+    inputTokens,
+    outputTokens,
+    estimatedCost: estimateCost(model, inputTokens, outputTokens),
+    filePath,
+    provider: "claude-code"
+  };
+}
+async function parseSession(filePath, sessionId, project) {
+  const content = await readFile(filePath, "utf-8");
+  const lines = content.split("\n").filter((l) => l.trim());
+  const entries = [];
+  for (const line of lines) {
+    try {
+      const entry = JSON.parse(line);
+      entries.push(entry);
+    } catch {
+    }
+  }
+  const filtered = entries.filter(
+    (e) => e.type !== "progress" && e.type !== "file-history-snapshot" && e.type !== "queue-operation"
+  );
+  const assistantTurns = /* @__PURE__ */ new Map();
+  const orderedEntries = [];
+  const seenAssistantIds = /* @__PURE__ */ new Set();
+  for (const entry of filtered) {
+    if (entry.type === "user") {
+      orderedEntries.push({ kind: "user", entry });
+    } else if (entry.type === "assistant") {
+      const aEntry = entry;
+      const msgId = aEntry.message.id || aEntry.uuid;
+      if (!assistantTurns.has(msgId)) {
+        assistantTurns.set(msgId, {
+          messageId: msgId,
+          timestamp: aEntry.timestamp,
+          model: aEntry.message.model || "",
+          blocks: [],
+          inputTokens: 0,
+          outputTokens: 0
+        });
+      }
+      const turn = assistantTurns.get(msgId);
+      const rawContent = aEntry.message.content;
+      if (typeof rawContent === "string") {
+        if (rawContent.trim()) {
+          turn.blocks.push({ type: "text", text: rawContent });
+        }
+      } else if (Array.isArray(rawContent)) {
+        for (const block of rawContent) {
+          turn.blocks.push(block);
+        }
+      }
+      const usage = aEntry.message.usage;
+      if (usage) {
+        turn.inputTokens += (usage.input_tokens || 0) + (usage.cache_read_input_tokens || 0);
+        turn.outputTokens += usage.output_tokens || 0;
+      }
+      if (!seenAssistantIds.has(msgId)) {
+        seenAssistantIds.add(msgId);
+        orderedEntries.push({ kind: "assistant_turn", messageId: msgId });
+      }
+    } else if (entry.type === "system") {
+      orderedEntries.push({ kind: "system", entry });
+    }
+  }
+  const toolResults = /* @__PURE__ */ new Map();
+  for (const entry of filtered) {
+    if (entry.type !== "user") continue;
+    const userEntry = entry;
+    const rawContent = userEntry.message.content;
+    if (!Array.isArray(rawContent)) continue;
+    for (const block of rawContent) {
+      if (block.type === "tool_result") {
+        const trBlock = block;
+        let resultText = "";
+        if (typeof trBlock.content === "string") {
+          resultText = trBlock.content;
+        } else if (Array.isArray(trBlock.content)) {
+          resultText = trBlock.content.map((b) => b.text).join("\n");
+        }
+        toolResults.set(trBlock.tool_use_id, {
+          content: resultText,
+          isError: trBlock.is_error || false
+        });
+      }
+    }
+  }
+  const events = [];
+  let eventIndex = 0;
+  let slug = "";
+  let version = "";
+  let model = "";
+  let totalInputTokens = 0;
+  let totalOutputTokens = 0;
+  let startedAt = "";
+  let lastActiveAt = "";
+  for (const ordered of orderedEntries) {
+    if (ordered.kind === "user") {
+      const userEntry = ordered.entry;
+      if (!startedAt) startedAt = userEntry.timestamp;
+      lastActiveAt = userEntry.timestamp;
+      if (userEntry.slug && !slug) slug = userEntry.slug;
+      if (userEntry.version && !version) version = userEntry.version;
+      const rawContent = userEntry.message.content;
+      if (typeof rawContent === "string") {
+        if (rawContent.trim()) {
+          events.push(makeEvent(eventIndex++, userEntry.timestamp, {
+            eventType: "user_message",
+            text: rawContent
+          }));
+        }
+      } else if (Array.isArray(rawContent)) {
+        const textParts = [];
+        for (const block of rawContent) {
+          if (block.type === "text") {
+            textParts.push(block.text);
+          }
+        }
+        if (textParts.length > 0) {
+          events.push(makeEvent(eventIndex++, userEntry.timestamp, {
+            eventType: "user_message",
+            text: textParts.join("\n")
+          }));
+        }
+      }
+    } else if (ordered.kind === "assistant_turn") {
+      const turn = assistantTurns.get(ordered.messageId);
+      if (!model && turn.model) model = turn.model;
+      totalInputTokens += turn.inputTokens;
+      totalOutputTokens += turn.outputTokens;
+      lastActiveAt = turn.timestamp;
+      for (const block of turn.blocks) {
+        if (block.type === "thinking") {
+          const thinkBlock = block;
+          if (thinkBlock.thinking.trim()) {
+            events.push(makeEvent(eventIndex++, turn.timestamp, {
+              eventType: "thinking",
+              thinking: thinkBlock.thinking
+            }));
+          }
+        } else if (block.type === "text") {
+          const textBlock = block;
+          if (textBlock.text.trim()) {
+            events.push(makeEvent(eventIndex++, turn.timestamp, {
+              eventType: "assistant_text",
+              text: textBlock.text
+            }));
+          }
+        } else if (block.type === "tool_use") {
+          const toolBlock = block;
+          const result = toolResults.get(toolBlock.id);
+          events.push(makeEvent(eventIndex++, turn.timestamp, {
+            eventType: "tool_call",
+            toolName: toolBlock.name,
+            toolUseId: toolBlock.id,
+            input: toolBlock.input,
+            result
+          }));
+        }
+      }
+    } else if (ordered.kind === "system") {
+      const sysEntry = ordered.entry;
+      if (sysEntry.subtype === "compact_boundary") {
+        events.push(makeEvent(eventIndex++, sysEntry.timestamp, {
+          eventType: "compact_boundary"
+        }));
+      } else {
+        events.push(makeEvent(eventIndex++, sysEntry.timestamp, {
+          eventType: "system",
+          subtype: sysEntry.subtype || "unknown",
+          durationMs: sysEntry.durationMs
+        }));
+      }
+    }
+  }
+  const summary = {
+    sessionId,
+    project,
+    slug,
+    startedAt,
+    lastActiveAt,
+    model,
+    version,
+    eventCount: events.length,
+    toolCallCount: events.filter((e) => e.data.eventType === "tool_call").length,
+    inputTokens: totalInputTokens,
+    outputTokens: totalOutputTokens,
+    estimatedCost: estimateCost(model, totalInputTokens, totalOutputTokens),
+    filePath,
+    provider: "claude-code"
+  };
+  return { summary, events };
+}
+function makeEvent(index, timestamp, data) {
+  return {
+    id: `evt-${index}`,
+    index,
+    timestamp,
+    data
+  };
+}
+class ClaudeCodeProvider {
+  type = "claude-code";
+  async discoverSessions() {
+    return discoverSessions();
+  }
+  async parseSession(sessionId, meta) {
+    return parseSession(meta.filePath, sessionId, meta.project);
+  }
+}
+const CURSOR_STORAGE = join(
+  homedir(),
+  "Library",
+  "Application Support",
+  "Cursor",
+  "User",
+  "workspaceStorage"
+);
+const CONVERSATION_KEY_PATTERNS = [
+  "composer.composerData",
+  "workbench.panel.aichat.view.aichat.chatdata"
+];
+function getWorkspaceName(workspaceDir) {
+  try {
+    const wsPath = join(workspaceDir, "workspace.json");
+    const data = JSON.parse(require("fs").readFileSync(wsPath, "utf-8"));
+    const folder = data.folder || data.workspace || "";
+    const decoded = decodeURIComponent(folder);
+    const parts = decoded.replace(/^file:\/\//, "").split("/");
+    return parts[parts.length - 1] || parts[parts.length - 2] || "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+function extractMessages(conv) {
+  if (conv.bubbles && Array.isArray(conv.bubbles)) {
+    return conv.bubbles.map((b) => ({
+      role: b.type === "user" ? "user" : b.type === "ai" ? "assistant" : b.type,
+      text: b.rawText || b.text || "",
+      model: b.modelName,
+      tokens: b.tokenCount
+    }));
+  }
+  if (conv.messages && Array.isArray(conv.messages)) return conv.messages;
+  if (conv.conversation && Array.isArray(conv.conversation)) return conv.conversation;
+  return [];
+}
+function getMessageRole(msg) {
+  if (msg.role === "user" || msg.type === 1) return "user";
+  if (msg.role === "assistant" || msg.role === "ai" || msg.type === 2) return "assistant";
+  return "system";
+}
+function getMessageText(msg) {
+  return msg.text || msg.content || msg.message || "";
+}
+function getTimestamp(msg) {
+  const ts = msg.timestamp || msg.createdAt;
+  if (!ts) return (/* @__PURE__ */ new Date()).toISOString();
+  const ms = ts > 1e12 ? ts : ts * 1e3;
+  return new Date(ms).toISOString();
+}
+function getConvId(conv) {
+  return conv.composerId || conv.tabId || conv.id || crypto.randomUUID();
+}
+function getConvTimestamp(conv, position) {
+  const messages = extractMessages(conv);
+  if (messages.length > 0) {
+    const msg = position === "start" ? messages[0] : messages[messages.length - 1];
+    return getTimestamp(msg);
+  }
+  const raw = position === "start" ? conv.createdAt : conv.lastUpdatedAt || conv.updatedAt || conv.createdAt;
+  if (typeof raw === "number") {
+    const ms = raw > 1e12 ? raw : raw * 1e3;
+    return new Date(ms).toISOString();
+  }
+  if (typeof raw === "string") return raw;
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+class CursorProvider {
+  type = "cursor";
+  async discoverSessions() {
+    const sessions = [];
+    let workspaceDirs;
+    try {
+      workspaceDirs = await readdir(CURSOR_STORAGE);
+    } catch {
+      return [];
+    }
+    for (const wsDir of workspaceDirs) {
+      const wsPath = join(CURSOR_STORAGE, wsDir);
+      const dbPath = join(wsPath, "state.vscdb");
+      try {
+        const s = await stat(dbPath);
+        if (!s.isFile()) continue;
+      } catch {
+        continue;
+      }
+      let db;
+      try {
+        db = new Database(dbPath, { readonly: true });
+      } catch {
+        continue;
+      }
+      try {
+        const projectName = getWorkspaceName(wsPath);
+        for (const keyPattern of CONVERSATION_KEY_PATTERNS) {
+          const rows = db.prepare(
+            "SELECT key, value FROM ItemTable WHERE key LIKE ?"
+          ).all(`%${keyPattern}%`);
+          for (const row of rows) {
+            try {
+              const raw = typeof row.value === "string" ? row.value : row.value.toString("utf-8");
+              const parsed = JSON.parse(raw);
+              const conversations = [];
+              if (Array.isArray(parsed)) {
+                conversations.push(...parsed);
+              } else if (parsed.tabs && Array.isArray(parsed.tabs)) {
+                conversations.push(...parsed.tabs);
+              } else if (parsed.allComposers && Array.isArray(parsed.allComposers)) {
+                conversations.push(...parsed.allComposers);
+              } else if (parsed.messages || parsed.bubbles || parsed.conversation) {
+                conversations.push(parsed);
+              }
+              for (const conv of conversations) {
+                const messages = extractMessages(conv);
+                if (messages.length < 2) continue;
+                const convId = getConvId(conv);
+                const startedAt = getConvTimestamp(conv, "start");
+                const lastActiveAt = getConvTimestamp(conv, "end");
+                let inputTokens = 0;
+                let outputTokens = 0;
+                let toolCallCount = 0;
+                let model = "";
+                for (const msg of messages) {
+                  const role = getMessageRole(msg);
+                  const msgModel = msg.model || msg.modelName;
+                  if (msgModel && !model) model = msgModel;
+                  if (msg.inputTokens) inputTokens += msg.inputTokens;
+                  if (msg.outputTokens) outputTokens += msg.outputTokens;
+                  if (msg.tokens || msg.tokensUsed) {
+                    const t = msg.tokens || msg.tokensUsed || 0;
+                    if (role === "user") inputTokens += t;
+                    else if (role === "assistant") outputTokens += t;
+                  }
+                }
+                const slug = conv.title || conv.name || getMessageText(messages.find((m) => getMessageRole(m) === "user") || messages[0]).slice(0, 60) || "Cursor conversation";
+                sessions.push({
+                  sessionId: `cursor-${convId}`,
+                  project: projectName,
+                  slug,
+                  startedAt,
+                  lastActiveAt,
+                  model: model || "unknown",
+                  version: "",
+                  eventCount: messages.length,
+                  toolCallCount,
+                  inputTokens,
+                  outputTokens,
+                  estimatedCost: estimateCost(model, inputTokens, outputTokens),
+                  filePath: dbPath,
+                  provider: "cursor",
+                  providerMeta: {
+                    dbPath,
+                    conversationKey: row.key,
+                    conversationId: convId,
+                    workspaceDir: wsPath
+                  }
+                });
+              }
+            } catch {
+            }
+          }
+        }
+      } finally {
+        db.close();
+      }
+    }
+    sessions.sort((a, b) => new Date(b.lastActiveAt).getTime() - new Date(a.lastActiveAt).getTime());
+    return sessions;
+  }
+  async parseSession(sessionId, meta) {
+    const { dbPath, conversationKey, conversationId } = meta;
+    const db = new Database(dbPath, { readonly: true });
+    try {
+      const rows = db.prepare(
+        "SELECT value FROM ItemTable WHERE key LIKE ?"
+      ).all(`%${conversationKey}%`);
+      for (const row of rows) {
+        const raw = typeof row.value === "string" ? row.value : row.value.toString("utf-8");
+        const parsed = JSON.parse(raw);
+        const conversations = [];
+        if (Array.isArray(parsed)) {
+          conversations.push(...parsed);
+        } else if (parsed.tabs && Array.isArray(parsed.tabs)) {
+          conversations.push(...parsed.tabs);
+        } else if (parsed.allComposers && Array.isArray(parsed.allComposers)) {
+          conversations.push(...parsed.allComposers);
+        } else if (parsed.messages || parsed.bubbles || parsed.conversation) {
+          conversations.push(parsed);
+        }
+        const conv = conversations.find((c) => getConvId(c) === conversationId);
+        if (!conv) continue;
+        return buildTimeline(conv, sessionId, meta);
+      }
+      throw new Error(`Conversation ${conversationId} not found in database`);
+    } finally {
+      db.close();
+    }
+  }
+}
+function buildTimeline(conv, sessionId, meta) {
+  const messages = extractMessages(conv);
+  const events = [];
+  let eventIndex = 0;
+  let model = "";
+  let inputTokens = 0;
+  let outputTokens = 0;
+  for (const msg of messages) {
+    const role = getMessageRole(msg);
+    const text = getMessageText(msg);
+    const timestamp = getTimestamp(msg);
+    const msgModel = msg.model || msg.modelName;
+    if (msgModel && !model) model = msgModel;
+    if (msg.inputTokens) inputTokens += msg.inputTokens;
+    if (msg.outputTokens) outputTokens += msg.outputTokens;
+    if (msg.tokens || msg.tokensUsed) {
+      const t = msg.tokens || msg.tokensUsed || 0;
+      if (role === "user") inputTokens += t;
+      else if (role === "assistant") outputTokens += t;
+    }
+    if (!text.trim()) continue;
+    let data;
+    if (role === "user") {
+      data = { eventType: "user_message", text };
+    } else if (role === "assistant") {
+      data = { eventType: "assistant_text", text };
+    } else {
+      data = { eventType: "system", subtype: "cursor" };
+    }
+    events.push({
+      id: `evt-${eventIndex}`,
+      index: eventIndex,
+      timestamp,
+      data
+    });
+    eventIndex++;
+  }
+  const startedAt = getConvTimestamp(conv, "start");
+  const lastActiveAt = getConvTimestamp(conv, "end");
+  const slug = conv.title || conv.name || getMessageText(messages.find((m) => getMessageRole(m) === "user") || messages[0]).slice(0, 60) || "Cursor conversation";
+  const summary = {
+    sessionId,
+    project: meta.project || "unknown",
+    slug,
+    startedAt,
+    lastActiveAt,
+    model: model || "unknown",
+    version: "",
+    eventCount: events.length,
+    toolCallCount: 0,
+    inputTokens,
+    outputTokens,
+    estimatedCost: estimateCost(model, inputTokens, outputTokens),
+    filePath: meta.dbPath,
+    provider: "cursor",
+    providerMeta: meta
+  };
+  return { summary, events };
+}
+const providers = [
+  new ClaudeCodeProvider(),
+  new CursorProvider()
+];
+const providerMap = new Map(
+  providers.map((p) => [p.type, p])
+);
+async function discoverAllSessions() {
+  const results = await Promise.allSettled(
+    providers.map((p) => p.discoverSessions())
+  );
+  const sessions = [];
+  for (const result of results) {
+    if (result.status === "fulfilled") {
+      sessions.push(...result.value);
+    }
+  }
+  sessions.sort((a, b) => new Date(b.lastActiveAt).getTime() - new Date(a.lastActiveAt).getTime());
+  return sessions;
+}
+async function parseSessionByProvider(sessionId, provider, meta) {
+  const p = providerMap.get(provider);
+  if (!p) throw new Error(`Unknown provider: ${provider}`);
+  return p.parseSession(sessionId, meta);
+}
+
+export { CLAUDE_DIR as C, parseSession as a, discoverAllSessions as d, parseSessionByProvider as p };
+//# sourceMappingURL=index2-f44F-4KW.js.map