agentel 0.2.8 → 0.3.1

package/src/importers/factory.js

@@ -0,0 +1,396 @@
+"use strict";
+
+const fs = require("fs");
+
+const PROVIDER = "factory";
+
+function parseFactorySessionFile(file, options = {}) {
+  let text;
+  try {
+    text = fs.readFileSync(file, "utf8");
+  } catch {
+    return null;
+  }
+  return parseFactorySessionText(text, options);
+}
+
+// Factory droid transcripts are JSONL: a `session_start` header line followed
+// by `message` wrapper lines whose payloads use Anthropic-style content blocks.
+// Block keys drift between snake_case and camelCase across droid versions
+// (tool_use_id vs toolUseId, media_type vs mediaType), so accept both.
+function parseFactorySessionText(text, options = {}) {
+  const lines = String(text || "").split(/\r?\n/);
+  let header = null;
+  const messages = [];
+  const fallbackTime = toIso(options.fallbackTime) || new Date().toISOString();
+  let index = 0;
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    const entry = parseJson(line);
+    if (!entry || typeof entry !== "object") continue;
+    if (entry.type === "session_start") {
+      header ||= entry;
+      continue;
+    }
+    if (!header) continue;
+    if (entry.type === "todo_state") continue;
+    if (entry.type !== "message" || !entry.message || typeof entry.message !== "object") continue;
+    messages.push(...factoryEntryMessages(entry, { fallbackTime, index }));
+    index++;
+  }
+  if (!header || !firstString(header.id)) return null;
+  return {
+    header,
+    sessionId: firstString(header.id),
+    title: firstString(header.sessionTitle, header.title),
+    cwd: firstString(header.cwd, header.lastCwd),
+    messages,
+    startedAt: messages[0]?.timestamp || fallbackTime,
+    endedAt: messages[messages.length - 1]?.timestamp || fallbackTime
+  };
+}
+
+function factoryEntryMessages(entry, context) {
+  const payload = entry.message;
+  const role = normalizeFactoryRole(payload.role);
+  const timestamp =
+    toIso(entry.timestamp) ||
+    toIso(payload.createdAt) ||
+    toIso(payload.timestamp) ||
+    offsetTimestamp(context.fallbackTime, context.index);
+  const blocks = normalizeFactoryContent(payload.content);
+  const texts = [];
+  const thinking = [];
+  const toolCalls = [];
+  const toolResults = [];
+  for (const block of blocks) {
+    if (!block || typeof block !== "object") continue;
+    const type = String(block.type || "");
+    if (type === "text" && typeof block.text === "string") texts.push(block.text);
+    else if (type === "thinking") thinking.push(firstString(block.thinking, block.text));
+    else if (type === "redacted_thinking") thinking.push("[redacted thinking]");
+    else if (type === "tool_use") {
+      const call = factoryToolCall(block);
+      if (call) toolCalls.push(call);
+    } else if (type === "tool_result") {
+      const result = factoryToolResult(block);
+      if (result) toolResults.push(result);
+    } else if (type === "image" || type === "document") {
+      texts.push(factoryAttachmentLabel(block));
+    }
+  }
+  const result = [];
+  const content = texts.filter(Boolean).join("\n").trim();
+  const thinkingText = thinking.filter(Boolean).join("\n\n").trim();
+  if (content || toolCalls.length || thinkingText) {
+    result.push({
+      role: role === "tool" ? "assistant" : role,
+      content,
+      timestamp,
+      metadata: compactObject({
+        provider: PROVIDER,
+        providerMessageId: firstString(entry.id),
+        parentMessageId: firstString(entry.parentId),
+        model: role === "assistant" ? firstString(payload.model) : undefined,
+        thinking: thinkingText || undefined,
+        visibility: factoryVisibility(payload.visibility),
+        isError: payload.isError === true || undefined,
+        userMessageSource: firstString(payload.userMessageSource) || undefined,
+        toolCalls: toolCalls.length ? toolCalls : undefined
+      })
+    });
+  }
+  for (const toolResult of toolResults) {
+    result.push({
+      role: "tool",
+      content: toolResult.output,
+      timestamp,
+      metadata: compactObject({
+        provider: PROVIDER,
+        providerMessageId: firstString(entry.id),
+        toolResult
+      })
+    });
+  }
+  return result;
+}
+
+function factoryToolCall(block) {
+  const name = firstString(block.name);
+  if (!name) return null;
+  const args = block.input && typeof block.input === "object" ? block.input : parseJson(block.input) || undefined;
+  const summary = summarizeToolArguments(args);
+  return compactObject({
+    id: firstString(block.id) || undefined,
+    name,
+    displayName: toolDisplayName(name),
+    rawCategory: "tool_use",
+    category: factoryToolCategory(name),
+    title: toolDisplayName(name),
+    status: "tool_call",
+    argument: summary,
+    rawInputSummary: summary,
+    inputPreview: summary,
+    target: toolTarget(args) || undefined,
+    arguments: args,
+    provider: PROVIDER
+  });
+}
+
+function factoryToolResult(block) {
+  const id = firstString(block.tool_use_id, block.toolUseId);
+  const parsedContent = factoryToolResultContent(block.content);
+  const detail = parsedContent.detail;
+  const output = firstString(detail?.diff) || parsedContent.text || (detail ? JSON.stringify(detail) : "");
+  if (!output && !id) return null;
+  const isError = block.isError === true || block.is_error === true || detail?.success === false;
+  const lineCount = output ? output.split(/\r?\n/).length : 0;
+  const structuredPatch = factoryStructuredPatch(detail);
+  return compactObject({
+    provider: PROVIDER,
+    id: id || undefined,
+    kind: "Tool result",
+    title: isError ? "Tool error" : "Tool result",
+    rawCategory: "tool_result",
+    category: "tool",
+    summary: firstLine(output),
+    output,
+    lineCount: lineCount || undefined,
+    collapsed: lineCount > 18 || undefined,
+    status: isError ? "error" : "completed",
+    structuredPatch: structuredPatch.length ? structuredPatch : undefined
+  });
+}
+
+function factoryToolResultContent(content) {
+  if (typeof content === "string") {
+    const detail = parseJson(content);
+    if (detail && typeof detail === "object" && !Array.isArray(detail) && (detail.diff || detail.diffLines || detail.success !== undefined)) {
+      return { text: firstString(detail.content, detail.message), detail };
+    }
+    return { text: content, detail: null };
+  }
+  if (Array.isArray(content)) {
+    const texts = content
+      .map((item) => {
+        if (typeof item === "string") return item;
+        if (item && typeof item === "object" && typeof item.text === "string") return item.text;
+        if (item && typeof item === "object" && (item.type === "image" || item.type === "document")) return factoryAttachmentLabel(item);
+        return "";
+      })
+      .filter(Boolean);
+    return { text: texts.join("\n"), detail: null };
+  }
+  if (content && typeof content === "object") {
+    if (content.diff || content.diffLines || content.success !== undefined) {
+      return { text: firstString(content.content, content.message), detail: content };
+    }
+    return { text: JSON.stringify(content), detail: null };
+  }
+  return { text: "", detail: null };
+}
+
+// Factory file-op results store per-line diffs as
+// {type: added|removed|unchanged|context, content, lineNumber: {old?, new?}}.
+function factoryStructuredPatch(detail) {
+  const diffLines = Array.isArray(detail?.diffLines) ? detail.diffLines : [];
+  if (!diffLines.length) return [];
+  const lines = [];
+  let oldStart = 0;
+  let newStart = 0;
+  for (const item of diffLines) {
+    if (!item || typeof item !== "object") continue;
+    const type = String(item.type || "");
+    const prefix = type === "added" ? "+" : type === "removed" ? "-" : " ";
+    lines.push(`${prefix}${String(item.content ?? "")}`);
+    const oldLine = Number(item.lineNumber?.old);
+    const newLine = Number(item.lineNumber?.new);
+    if (!oldStart && Number.isFinite(oldLine) && oldLine > 0) oldStart = oldLine;
+    if (!newStart && Number.isFinite(newLine) && newLine > 0) newStart = newLine;
+  }
+  if (!lines.length) return [];
+  const hunk = { oldStart: oldStart || 1, newStart: newStart || 1, lines };
+  const file = firstString(detail?.file_path, detail?.filePath);
+  if (file) hunk.file = file;
+  return [hunk];
+}
+
+// Sidecar <sessionId>.settings.json carries aggregate token usage and session
+// configuration; there is no per-message usage in droid transcripts.
+function factorySessionSummary(settings, header) {
+  if (!settings && !header) return null;
+  const tokenUsage = settings?.tokenUsage && typeof settings.tokenUsage === "object" ? settings.tokenUsage : null;
+  const usage = factoryUsage(tokenUsage);
+  const model = cleanFactoryModel(firstString(settings?.model));
+  return compactObject({
+    usage: usage || undefined,
+    modelUsage: model ? [{ model, source: "factory-session-settings" }] : undefined,
+    factoryDroid: compactObject({
+      model: firstString(settings?.model) || undefined,
+      reasoningEffort: firstString(settings?.reasoningEffort) || undefined,
+      autonomyMode: firstString(settings?.autonomyMode, settings?.autonomyLevel) || undefined,
+      specModeModel: firstString(settings?.specModeModel) || undefined,
+      providerLock: firstString(settings?.providerLock) || undefined,
+      apiProviderLock: firstString(settings?.apiProviderLock) || undefined,
+      factoryCredits: positiveNumber(tokenUsage?.factoryCredits),
+      assistantActiveTimeMs: positiveNumber(settings?.assistantActiveTimeMs),
+      archivedAt: toIso(settings?.archivedAt) || undefined,
+      sessionType: firstString(header?.decompSessionType) || undefined,
+      callingSessionId: firstString(header?.callingSessionId) || undefined,
+      parentSessionId: firstString(header?.parent) || undefined,
+      owner: firstString(header?.owner) || undefined,
+      subagentTokenUsageBySessionId:
+        settings?.childInclusiveTokenUsageBySessionId && typeof settings.childInclusiveTokenUsageBySessionId === "object" && Object.keys(settings.childInclusiveTokenUsageBySessionId).length
+          ? settings.childInclusiveTokenUsageBySessionId
+          : undefined
+    })
+  });
+}
+
+function factoryUsage(tokenUsage) {
+  if (!tokenUsage) return null;
+  const inputTokens = positiveNumber(tokenUsage.inputTokens);
+  const outputTokens = positiveNumber(tokenUsage.outputTokens);
+  const cacheReadTokens = positiveNumber(tokenUsage.cacheReadTokens ?? tokenUsage.cacheReadInputTokens);
+  const cacheCreationTokens = positiveNumber(tokenUsage.cacheCreationTokens ?? tokenUsage.cacheCreationInputTokens);
+  if (!inputTokens && !outputTokens && !cacheReadTokens && !cacheCreationTokens) return null;
+  return compactObject({
+    inputTokens,
+    outputTokens,
+    cacheReadTokens: cacheReadTokens || undefined,
+    cacheCreationInputTokens: cacheCreationTokens || undefined,
+    source: "factory-session-settings"
+  });
+}
+
+// BYOK model ids look like "custom:Claude-Opus-4.5-Thinking-[Anthropic]-0".
+function cleanFactoryModel(model) {
+  if (!model) return "";
+  return model
+    .replace(/^custom:/, "")
+    .replace(/-?\[[^\]]*\](-\d+)?$/, "")
+    .trim();
+}
+
+function factoryVisibility(value) {
+  const text = firstString(value);
+  return text && text !== "both" ? text : undefined;
+}
+
+function normalizeFactoryRole(role) {
+  const text = String(role || "").toLowerCase();
+  if (text === "user" || text === "assistant" || text === "system" || text === "tool") return text;
+  return "assistant";
+}
+
+function normalizeFactoryContent(content) {
+  if (typeof content === "string") return content.trim() ? [{ type: "text", text: content }] : [];
+  if (Array.isArray(content)) return content;
+  if (content && typeof content === "object") return [content];
+  return [];
+}
+
+function factoryAttachmentLabel(block) {
+  const mime = firstString(block?.source?.media_type, block?.source?.mediaType, block?.media_type, block?.mediaType);
+  return mime ? `[Attachment: ${mime}]` : "[Attachment]";
+}
+
+function factoryToolCategory(name) {
+  const text = String(name || "");
+  if (/^task$/i.test(text) || /subagent/i.test(text)) return "task";
+  if (/execute|bash|shell|command/i.test(text)) return "shell";
+  if (/websearch|fetchurl|web|url|http/i.test(text)) return "web";
+  if (/edit|create|write|applypatch|patch|todowrite/i.test(text)) return "edit";
+  if (/^read$|^ls$|view/i.test(text)) return "read";
+  if (/grep|glob|find|search/i.test(text)) return "search";
+  if (/^mcp__/i.test(text)) return "mcp";
+  return "tool";
+}
+
+function summarizeToolArguments(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", "prompt", "query", "pattern", "file_path", "path", "url", "skill", "plan"]) {
+    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") return "";
+  return firstString(args.file_path, args.filePath, args.path, args.directory_path, args.folder, args.url);
+}
+
+function toolDisplayName(value) {
+  const text = String(value || "tool").trim();
+  return text
+    .split(/_+|(?=[A-Z])/g)
+    .filter(Boolean)
+    .map((part) => part.replace(/(^|[-\s])([a-z])/g, (_, prefix, char) => `${prefix}${char.toUpperCase()}`))
+    .join(" ");
+}
+
+function firstLine(value) {
+  return String(value || "").split(/\r?\n/).find((line) => line.trim())?.trim() || "";
+}
+
+function offsetTimestamp(base, index) {
+  const date = new Date(base);
+  if (Number.isNaN(date.valueOf())) return base;
+  return new Date(date.valueOf() + index * 1000).toISOString();
+}
+
+function toIso(value) {
+  if (!value) return "";
+  if (typeof value === "number") {
+    const ms = value > 1e12 ? value : value * 1000;
+    const date = new Date(ms);
+    return Number.isNaN(date.valueOf()) ? "" : date.toISOString();
+  }
+  const date = new Date(value);
+  return Number.isNaN(date.valueOf()) ? "" : date.toISOString();
+}
+
+function parseJson(text) {
+  if (typeof text !== "string" || !text.trim()) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+
+function firstString(...values) {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim()) return value.trim();
+  }
+  return "";
+}
+
+function positiveNumber(value) {
+  const number = Number(value);
+  return Number.isFinite(number) && number > 0 ? number : undefined;
+}
+
+function compactObject(value) {
+  if (!value || typeof value !== "object") return value;
+  const result = {};
+  for (const [key, item] of Object.entries(value)) {
+    if (item === undefined || item === null || item === "") continue;
+    result[key] = item;
+  }
+  return Object.keys(result).length ? result : undefined;
+}
+
+module.exports = {
+  cleanFactoryModel,
+  factorySessionSummary,
+  factoryStructuredPatch,
+  parseFactorySessionFile,
+  parseFactorySessionText
+};

package/src/importers/gemini.js

@@ -425,6 +425,7 @@ function normalizeGeminiToolCall(node, { event, part } = {}) {
       (node.code ? { language: node.language, code: node.code } : undefined)
   );
   const summary = summarizeToolArguments(args);
+  const subagent = geminiSubagentToolMetadata(name, node, args, event);
   return {
     id: firstString(node.id, node.callId, node.call_id, event?.callId, event?.call_id, part?.id) || undefined,
     name,
@@ -438,10 +439,41 @@ function normalizeGeminiToolCall(node, { event, part } = {}) {
     inputPreview: summary,
     target: toolTarget(args) || undefined,
     arguments: args && typeof args === "object" && !Array.isArray(args) ? args : undefined,
+    agentId: subagent.agentId,
+    agentName: subagent.agentName,
+    prompt: subagent.prompt,
+    subagentProgress: subagent.subagentProgress,
+    resultPreview: subagent.resultPreview,
     provider: PROVIDER
   };
 }
 
+function geminiSubagentToolMetadata(name, node = {}, args = {}, event = {}) {
+  if (!geminiIsSubagentToolName(name)) return {};
+  const resultDisplay = node.resultDisplay || node.result_display || event.resultDisplay || event.result_display || {};
+  const progress = resultDisplay && typeof resultDisplay === "object"
+    ? compactMetadata({
+        isSubagentProgress: resultDisplay.isSubagentProgress,
+        agentName: firstString(resultDisplay.agentName, resultDisplay.agent_name),
+        state: firstString(resultDisplay.state, resultDisplay.status),
+        terminateReason: firstString(resultDisplay.terminateReason, resultDisplay.terminate_reason),
+        result: previewString(firstString(resultDisplay.result, resultDisplay.output, resultDisplay.summary), 600),
+        recentActivity: Array.isArray(resultDisplay.recentActivity) ? resultDisplay.recentActivity.slice(0, 8) : undefined
+      })
+    : null;
+  return compactMetadata({
+    agentId: firstString(node.agentId, node.agent_id, event.agentId, event.agent_id, args?.agentId, args?.agent_id),
+    agentName: firstString(node.agentName, node.agent_name, resultDisplay.agentName, resultDisplay.agent_name, args?.agent_name, args?.agentName, args?.name),
+    prompt: firstString(args?.prompt, args?.task, args?.instructions),
+    subagentProgress: progress,
+    resultPreview: previewString(firstString(node.result, event.result, resultDisplay.result, resultDisplay.output, resultDisplay.summary), 600)
+  });
+}
+
+function geminiIsSubagentToolName(name) {
+  return /^(invoke[_-]?agent|run[_-]?subagent|invoke[_-]?subagent)$/i.test(String(name || ""));
+}
+
 function normalizeGeminiToolResult(node, { event, part } = {}) {
   if (!node || typeof node !== "object") return null;
   const name = firstString(
@@ -999,6 +1031,7 @@ function normalizeGeminiRole(role) {
 
 function toolCategory(name, type = "") {
   const text = `${name || ""} ${type || ""}`;
+  if (/invoke[_-]?agent|subagent/i.test(text)) return "task";
   if (/shell|bash|command|terminal|exec|npm|yarn|pnpm/i.test(text)) return "shell";
   if (/web|fetch|browser|url|http/i.test(text)) return "web";
   if (/edit|write|patch|replace|insert|update/i.test(text)) return "edit";
@@ -1127,6 +1160,12 @@ function asArray(value) {
   return value == null ? [] : [value];
 }
 
+function previewString(value, max = 600) {
+  const text = String(value || "").replace(/\s+/g, " ").trim();
+  if (!text) return "";
+  return text.length > max ? `${text.slice(0, max - 3).trimEnd()}...` : text;
+}
+
 function compactMetadata(value) {
   const output = {};
   for (const [key, item] of Object.entries(value || {})) {