agentel 0.2.0 → 0.2.2

package/src/importers/gemini.js

@@ -5,6 +5,14 @@ const { toIso } = require("../archive");
 const PROVIDER = "gemini_cli";
 
 function parseGeminiCliJsonl(text, options = {}) {
+  return parseGeminiCliEvents(geminiJsonlEvents(text), options);
+}
+
+function parseGeminiCliJsonlSessions(text, options = {}) {
+  return parseGeminiCliEventSessions(geminiJsonlEvents(text), options);
+}
+
+function geminiJsonlEvents(text) {
   const events = [];
   for (const line of String(text || "").split(/\r?\n/)) {
     if (!line.trim()) continue;
@@ -14,13 +22,29 @@ function parseGeminiCliJsonl(text, options = {}) {
       // Ignore malformed partial lines in append-only history files.
     }
   }
-  return parseGeminiCliEvents(events, options);
+  return events;
 }
 
 function parseGeminiCliJson(data, options = {}) {
   return parseGeminiCliEvents(geminiEventList(data), { ...options, root: data });
 }
 
+function parseGeminiCliJsonSessions(data, options = {}) {
+  return parseGeminiCliEventSessions(geminiEventList(data), { ...options, root: data });
+}
+
+function parseGeminiCliEventSessions(events, options = {}) {
+  const groups = geminiSessionEventGroups(events, options);
+  return groups
+    .map((group) =>
+      parseGeminiCliEvents(group.events, {
+        ...options,
+        sessionId: group.sessionId || options.sessionId
+      })
+    )
+    .filter((session) => session.messages.length);
+}
+
 function parseGeminiCliEvents(events, options = {}) {
   const root = options.root && typeof options.root === "object" ? options.root : {};
   const normalizedEvents = coalesceGeminiIncrementalEvents(events);
@@ -31,19 +55,27 @@ function parseGeminiCliEvents(events, options = {}) {
   };
   let sessionId = firstString(options.sessionId, geminiSessionId(root));
   let title = firstString(options.title, geminiTitle(root));
+  let topicTitle = "";
   let cwd = firstString(options.cwd, geminiCwd(root));
   const messages = [];
+  const sessionSummaries = [];
 
   for (let index = 0; index < normalizedEvents.length; index++) {
     const event = normalizedEvents[index];
     if (!event || typeof event !== "object") continue;
     context.model = firstString(geminiModel(event), context.model);
-    sessionId ||= geminiSessionId(event);
+    sessionId ||= geminiEventSessionId(event);
     title ||= geminiTitle(event);
     cwd ||= geminiCwd(event);
     const timestamp = eventTimestamp(event, fallbackTime, index);
     context.lastTimestamp = timestamp;
     const usage = geminiUsage(event);
+    const sessionSummary = geminiSessionSummary(event, timestamp);
+    if (sessionSummary) {
+      sessionSummaries.push(sessionSummary);
+      sessionId ||= sessionSummary.sessionId;
+      continue;
+    }
 
     const checkpoint = geminiCheckpointMessage(event, timestamp);
     if (checkpoint) {
@@ -52,6 +84,7 @@ function parseGeminiCliEvents(events, options = {}) {
     }
 
     const extracted = geminiMessagesFromEvent(event, { ...context, timestamp, usage });
+    topicTitle = firstString(geminiTopicTitleFromMessages(extracted), topicTitle);
     if (extracted.length) {
       messages.push(...extracted);
       continue;
@@ -70,12 +103,13 @@ function parseGeminiCliEvents(events, options = {}) {
 
   return {
     sessionId,
-    title,
+    title: firstString(topicTitle, title),
     cwd,
     model: context.model,
     messages: sorted,
     startedAt: sorted[0]?.timestamp || "",
-    endedAt: sorted[sorted.length - 1]?.timestamp || ""
+    endedAt: sorted[sorted.length - 1]?.timestamp || "",
+    sessionSummary: mergeGeminiSessionSummaries(sessionSummaries)
   };
 }
 
@@ -101,6 +135,27 @@ function geminiEventList(data) {
   return [data];
 }
 
+function geminiSessionEventGroups(events, options = {}) {
+  const rootSessionId = firstString(options.sessionId, geminiSessionId(options.root));
+  const groups = new Map();
+  const explicitSessionIds = new Set();
+  let currentSessionId = rootSessionId;
+  for (const event of events || []) {
+    const explicitSessionId = geminiEventSessionId(event) || geminiSessionSummaryId(event);
+    if (explicitSessionId) {
+      explicitSessionIds.add(explicitSessionId);
+      currentSessionId = explicitSessionId;
+    }
+    const key = currentSessionId || "";
+    if (!groups.has(key)) groups.set(key, { sessionId: key, events: [] });
+    groups.get(key).events.push(event);
+  }
+  if (explicitSessionIds.size <= 1) {
+    return [{ sessionId: rootSessionId || [...explicitSessionIds][0] || "", events: events || [] }];
+  }
+  return [...groups.values()];
+}
+
 function coalesceGeminiIncrementalEvents(events) {
   const output = [];
   const indexes = new Map();
@@ -109,7 +164,7 @@ function coalesceGeminiIncrementalEvents(events) {
       output.push(event);
       continue;
     }
-    const id = geminiEventId(event);
+    const id = geminiIncrementalEventKey(event);
     if (!id) {
       output.push(event);
       continue;
@@ -125,6 +180,13 @@ function coalesceGeminiIncrementalEvents(events) {
   return output;
 }
 
+function geminiIncrementalEventKey(event) {
+  const id = geminiEventId(event);
+  if (!id) return "";
+  const sessionId = geminiEventSessionId(event);
+  return sessionId ? `${sessionId}:${id}` : id;
+}
+
 function mergeGeminiEvent(previous, next) {
   const merged = { ...(previous && typeof previous === "object" ? previous : {}) };
   for (const [key, value] of Object.entries(next || {})) {
@@ -571,6 +633,270 @@ function applyUsageToLastAssistant(messages, usage) {
   target.metadata = { ...(target.metadata || {}), usage };
 }
 
+function geminiTopicTitleFromMessages(messages) {
+  let title = "";
+  for (const message of messages || []) {
+    for (const call of asArray(message?.metadata?.toolCalls)) {
+      if (!isGeminiTopicContextCall(call)) continue;
+      title = firstString(geminiTopicTitleFromArgs(call.arguments), geminiTopicTitleFromArgs(call.rawInputSummary), title);
+    }
+  }
+  return title;
+}
+
+function isGeminiTopicContextCall(call) {
+  return [call?.name, call?.displayName, call?.display_name, call?.title]
+    .filter((value) => typeof value === "string" && value.trim())
+    .some((name) => {
+      const normalized = name.toLowerCase().replace(/[^a-z0-9]+/g, "");
+      return normalized === "updatetopic" || normalized === "updatetopiccontext" || /update.*topic.*context/i.test(name);
+    });
+}
+
+function geminiTopicTitleFromArgs(args) {
+  if (!args) return "";
+  if (typeof args === "string") {
+    const parsed = parseToolArgsValue(args);
+    if (parsed && typeof parsed === "object") return geminiTopicTitleFromArgs(parsed);
+    return cleanGeminiTopicTitle(
+      firstString(
+        matchGeminiTopicTitle(args, /\btitle\s*:\s*([^,\n]+)/i),
+        matchGeminiTopicTitle(args, /\btitle\s+(.+?)(?:,\s*(?:strategic[_\s-]*intent|summary)\b|\s+and\s+title\s*:|$)/i)
+      )
+    );
+  }
+  if (typeof args !== "object") return "";
+  return cleanGeminiTopicTitle(
+    firstString(
+      args.title,
+      args.topicTitle,
+      args.topic_title,
+      args.topic,
+      args.topic?.title,
+      args.context?.title,
+      args.topicContext?.title,
+      args.topic_context?.title
+    )
+  );
+}
+
+function matchGeminiTopicTitle(text, pattern) {
+  const match = String(text || "").match(pattern);
+  return match ? match[1] : "";
+}
+
+function cleanGeminiTopicTitle(value) {
+  const title = String(value || "")
+    .replace(/\s+/g, " ")
+    .trim()
+    .replace(/^["'`]+|["'`]+$/g, "")
+    .trim();
+  if (!title || /^update topic context$/i.test(title)) return "";
+  return title;
+}
+
+function geminiSessionSummary(event, timestamp) {
+  const text = geminiSessionSummaryText(event);
+  const parsed = parseGeminiSessionSummaryText(text, timestamp);
+  if (parsed) return parsed;
+  const value = event?.sessionSummary || event?.session_summary || event?.summary;
+  if (!value || typeof value !== "object") return null;
+  const structured = compactMetadata({
+    sessionId: firstString(value.sessionId, value.session_id, value.id),
+    resumeCommand: firstString(value.resumeCommand, value.resume_command),
+    toolCalls: value.toolCalls || value.tool_calls,
+    successRatePercent: numberValue(value.successRatePercent ?? value.success_rate_percent ?? value.successRate ?? value.success_rate),
+    userAgreement: value.userAgreement || value.user_agreement,
+    performance: value.performance,
+    modelUsage: Array.isArray(value.modelUsage) ? value.modelUsage : Array.isArray(value.model_usage) ? value.model_usage : undefined,
+    occurredAt: timestamp
+  });
+  const usage = geminiSessionSummaryUsage(structured);
+  if (usage) structured.usage = usage;
+  return Object.keys(structured).length ? structured : null;
+}
+
+function geminiSessionSummaryText(event) {
+  const candidates = [
+    event?.sessionSummary,
+    event?.session_summary,
+    event?.summary,
+    event?.content,
+    event?.message,
+    event?.text,
+    event?.output,
+    event?.payload?.sessionSummary,
+    event?.payload?.session_summary,
+    event?.payload?.summary,
+    event?.payload?.content,
+    event?.payload?.message,
+    event?.payload?.text,
+    event?.data?.summary,
+    event?.data?.content,
+    event?.data?.message,
+    event?.data?.text
+  ];
+  for (const candidate of candidates) {
+    if (typeof candidate === "string" && looksLikeGeminiSessionSummary(candidate)) return candidate;
+  }
+  return "";
+}
+
+function geminiSessionSummaryId(event) {
+  const text = geminiSessionSummaryText(event);
+  if (!text) return "";
+  return parseGeminiSessionSummaryText(text)?.sessionId || "";
+}
+
+function looksLikeGeminiSessionSummary(text) {
+  const normalized = String(text || "");
+  return /Interaction Summary/i.test(normalized) && /(?:Session ID:|To resume this session:)/i.test(normalized);
+}
+
+function parseGeminiSessionSummaryText(text, timestamp = "") {
+  if (!looksLikeGeminiSessionSummary(text)) return null;
+  const lines = cleanGeminiSessionSummaryLines(text);
+  const summary = { occurredAt: timestamp || undefined };
+  const modelUsage = [];
+  let inModelTable = false;
+  let lastModel = null;
+  for (const line of lines) {
+    const sessionId = line.match(/^Session ID:\s*(.+)$/i);
+    if (sessionId) {
+      summary.sessionId = sessionId[1].trim();
+      continue;
+    }
+    const toolCalls = line.match(/^Tool Calls:\s*([\d,]+)(?:\s*\(\s*(?:[\u2713\u2714]\s*)?([\d,]+)?\s*(?:x|\u00d7)\s*([\d,]+)\s*\))?/i);
+    if (toolCalls) {
+      const total = numberValue(toolCalls[1]);
+      const succeeded = numberValue(toolCalls[2]);
+      const failed = numberValue(toolCalls[3]);
+      summary.toolCalls = compactMetadata({
+        total,
+        succeeded: succeeded || (Number.isFinite(total) && Number.isFinite(failed) ? total - failed : undefined),
+        failed
+      });
+      continue;
+    }
+    const success = line.match(/^Success Rate:\s*([\d.]+)%/i);
+    if (success) {
+      summary.successRatePercent = numberValue(success[1]);
+      continue;
+    }
+    const agreement = line.match(/^User Agreement:\s*([\d.]+)%(?:\s*\(([\d,]+)\s+reviewed\))?/i);
+    if (agreement) {
+      summary.userAgreement = compactMetadata({
+        ratePercent: numberValue(agreement[1]),
+        reviewed: numberValue(agreement[2])
+      });
+      continue;
+    }
+    const wall = line.match(/^Wall Time:\s*(.+)$/i);
+    if (wall) {
+      summary.performance = { ...(summary.performance || {}), wallTimeMs: parseGeminiDurationMs(wall[1]) };
+      continue;
+    }
+    const active = line.match(/^Agent Active:\s*(.+)$/i);
+    if (active) {
+      summary.performance = { ...(summary.performance || {}), agentActiveMs: parseGeminiDurationMs(active[1]) };
+      continue;
+    }
+    const api = line.match(/^(?:\u00bb\s*)?API Time:\s*([^(]+?)(?:\s*\(([\d.]+)%\))?$/i);
+    if (api) {
+      summary.performance = { ...(summary.performance || {}), apiTimeMs: parseGeminiDurationMs(api[1]), apiTimePercent: numberValue(api[2]) };
+      continue;
+    }
+    const tool = line.match(/^(?:\u00bb\s*)?Tool Time:\s*([^(]+?)(?:\s*\(([\d.]+)%\))?$/i);
+    if (tool) {
+      summary.performance = { ...(summary.performance || {}), toolTimeMs: parseGeminiDurationMs(tool[1]), toolTimePercent: numberValue(tool[2]) };
+      continue;
+    }
+    const resume = line.match(/^To resume this session:\s*(.+)$/i);
+    if (resume) {
+      summary.resumeCommand = resume[1].trim();
+      continue;
+    }
+    if (/^Model\s+Reqs\s+Input Tokens\s+Cache Reads\s+Output Tokens$/i.test(line)) {
+      inModelTable = true;
+      continue;
+    }
+    if (!inModelTable) continue;
+    if (/^Use \/model\b/i.test(line) || /^Model Usage$/i.test(line)) continue;
+    const model = parseGeminiModelUsageLine(line);
+    if (!model) continue;
+    if (model.role && lastModel) {
+      lastModel.roles = (lastModel.roles || []).concat(model);
+      continue;
+    }
+    modelUsage.push(model);
+    lastModel = model;
+  }
+  if (modelUsage.length) summary.modelUsage = modelUsage;
+  const usage = geminiSessionSummaryUsage(summary);
+  if (usage) summary.usage = usage;
+  const compact = compactMetadata(summary);
+  if (compact.performance) compact.performance = compactMetadata(compact.performance);
+  if (compact.toolCalls) compact.toolCalls = compactMetadata(compact.toolCalls);
+  if (compact.userAgreement) compact.userAgreement = compactMetadata(compact.userAgreement);
+  return Object.keys(compact).length ? compact : null;
+}
+
+function cleanGeminiSessionSummaryLines(text) {
+  return String(text || "")
+    .replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "")
+    .split(/\r?\n/)
+    .map((line) =>
+      line
+        .replace(/^[\s\u2502\u2503\u2551]+|[\s\u2502\u2503\u2551]+$/g, "")
+        .replace(/^[\u00bb]\s*/, "\u00bb ")
+        .trim()
+    )
+    .filter((line) => line && /[A-Za-z0-9/]/.test(line) && !/^[\u2500-\u257f\s-]+$/.test(line));
+}
+
+function parseGeminiModelUsageLine(line) {
+  const role = /^\u21b3\s*/.test(line);
+  const normalized = line.replace(/^\u21b3\s*/, "");
+  const match = normalized.match(/^(.+?)\s+([\d,]+)\s+([\d,]+)\s+([\d,]+)\s+([\d,]+)$/);
+  if (!match) return null;
+  const row = {
+    requests: numberValue(match[2]),
+    inputTokens: numberValue(match[3]),
+    cacheReadTokens: numberValue(match[4]),
+    outputTokens: numberValue(match[5])
+  };
+  if (role) return { role: match[1].trim(), ...row };
+  return { model: match[1].trim(), ...row };
+}
+
+function geminiSessionSummaryUsage(summary) {
+  const models = Array.isArray(summary?.modelUsage) ? summary.modelUsage : [];
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let cacheInputTokens = 0;
+  for (const model of models) {
+    inputTokens += numberValue(model.inputTokens) || 0;
+    outputTokens += numberValue(model.outputTokens) || 0;
+    cacheInputTokens += numberValue(model.cacheReadTokens) || 0;
+  }
+  if (!inputTokens && !outputTokens && !cacheInputTokens) return null;
+  return { inputTokens, outputTokens, cacheInputTokens, totalTokens: inputTokens + outputTokens };
+}
+
+function mergeGeminiSessionSummaries(summaries) {
+  const values = summaries.filter(Boolean);
+  if (!values.length) return null;
+  return values.reduce((merged, summary) => ({
+    ...merged,
+    ...summary,
+    toolCalls: { ...(merged.toolCalls || {}), ...(summary.toolCalls || {}) },
+    userAgreement: { ...(merged.userAgreement || {}), ...(summary.userAgreement || {}) },
+    performance: { ...(merged.performance || {}), ...(summary.performance || {}) },
+    modelUsage: summary.modelUsage || merged.modelUsage,
+    usage: summary.usage || merged.usage
+  }), {});
+}
+
 function geminiSessionId(value) {
   return firstString(
     value?.sessionId,
@@ -586,6 +912,20 @@ function geminiSessionId(value) {
   );
 }
 
+function geminiEventSessionId(value) {
+  return firstString(
+    value?.sessionId,
+    value?.session_id,
+    value?.conversationId,
+    value?.conversation_id,
+    value?.chatId,
+    value?.chat_id,
+    value?.session?.id,
+    value?.metadata?.sessionId,
+    value?.metadata?.session_id
+  );
+}
+
 function geminiTitle(value) {
   return firstString(value?.title, value?.name, value?.summary, value?.metadata?.title, value?.session?.title);
 }
@@ -758,10 +1098,29 @@ function firstString(...values) {
 }
 
 function numberValue(value) {
-  const number = Number(value);
+  if (value === undefined || value === null || value === "") return undefined;
+  const number = Number(String(value ?? "").replace(/,/g, ""));
   return Number.isFinite(number) ? number : undefined;
 }
 
+function parseGeminiDurationMs(value) {
+  const text = String(value || "").trim();
+  if (!text) return undefined;
+  let total = 0;
+  const re = /([\d.]+)\s*(ms|milliseconds?|h|hr|hrs|hours?|m|min|mins|minutes?|s|sec|secs|seconds?)/gi;
+  let match;
+  while ((match = re.exec(text))) {
+    const amount = Number(match[1]);
+    if (!Number.isFinite(amount)) continue;
+    const unit = match[2].toLowerCase();
+    if (unit.startsWith("ms") || unit.startsWith("millisecond")) total += amount;
+    else if (unit === "h" || unit.startsWith("hr") || unit.startsWith("hour")) total += amount * 60 * 60 * 1000;
+    else if (unit === "m" || unit.startsWith("min") || unit.startsWith("minute")) total += amount * 60 * 1000;
+    else total += amount * 1000;
+  }
+  return total ? Math.round(total) : undefined;
+}
+
 function asArray(value) {
   if (Array.isArray(value)) return value;
   return value == null ? [] : [value];
@@ -791,5 +1150,8 @@ function uniqueObjects(values) {
 module.exports = {
   parseGeminiCliEvents,
   parseGeminiCliJson,
-  parseGeminiCliJsonl
+  parseGeminiCliJsonSessions,
+  parseGeminiCliJsonl,
+  parseGeminiCliJsonlSessions,
+  parseGeminiSessionSummaryText
 };