agentel 0.2.8 → 0.3.0

package/src/importers/pi.js

@@ -0,0 +1,422 @@
+"use strict";
+
+const fs = require("fs");
+
+const PROVIDER = "pi";
+
+function parsePiSessionFile(file, options = {}) {
+  let text;
+  try {
+    text = fs.readFileSync(file, "utf8");
+  } catch {
+    return null;
+  }
+  return parsePiSessionText(text, options);
+}
+
+// pi sessions are JSONL with a `session` header line followed by tree-linked
+// entries (id/parentId, 8-char hex). v1 files have no entry ids and store
+// provider/modelId on the header; v2 added the tree plus branch/label/custom
+// entries; v3 renamed the hookMessage role to custom. Entries are imported in
+// file order (branches included) with ids preserved in metadata.
+function parsePiSessionText(text, options = {}) {
+  const lines = String(text || "").split(/\r?\n/);
+  let header = null;
+  let name = "";
+  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") {
+      header ||= entry;
+      continue;
+    }
+    if (!header) return null;
+    const timestamp = toIso(entry.timestamp) || offsetTimestamp(fallbackTime, index);
+    index++;
+    if (entry.type === "session_info") {
+      name = firstString(entry.name, name);
+      continue;
+    }
+    if (entry.type === "message" && entry.message && typeof entry.message === "object") {
+      messages.push(...piEntryMessages(entry, timestamp, header));
+      continue;
+    }
+    const systemMessage = piSystemMessage(entry, timestamp);
+    if (systemMessage) messages.push(systemMessage);
+  }
+  if (!header || !firstString(header.id)) return null;
+  return {
+    header,
+    sessionId: firstString(header.id),
+    title: name,
+    cwd: firstString(header.cwd),
+    version: Number(header.version) || 1,
+    parentSession: firstString(header.parentSession, header.branchedFrom),
+    messages,
+    startedAt: toIso(header.timestamp) || messages[0]?.timestamp || fallbackTime,
+    endedAt: messages[messages.length - 1]?.timestamp || toIso(header.timestamp) || fallbackTime
+  };
+}
+
+function piEntryMessages(entry, timestamp, header) {
+  const payload = entry.message;
+  const role = String(payload.role || "");
+  const base = compactObject({
+    provider: PROVIDER,
+    providerMessageId: firstString(entry.id),
+    parentMessageId: firstString(entry.parentId)
+  }) || { provider: PROVIDER };
+  if (role === "user") {
+    const content = piContentText(payload.content);
+    if (!content) return [];
+    return [{ role: "user", content, timestamp, metadata: { ...base } }];
+  }
+  if (role === "assistant") {
+    return piAssistantMessages(payload, timestamp, base, header);
+  }
+  if (role === "toolResult") {
+    const toolResult = piToolResult(payload);
+    if (!toolResult) return [];
+    return [{ role: "tool", content: toolResult.output, timestamp, metadata: { ...base, toolResult } }];
+  }
+  if (role === "bashExecution") {
+    return piBashExecutionMessages(payload, timestamp, base);
+  }
+  if (role === "custom" || role === "hookMessage") {
+    const content = piContentText(payload.content);
+    if (!content) return [];
+    return [{
+      role: "system",
+      content,
+      timestamp,
+      metadata: { ...base, providerGenerated: true, contextKind: "extension", contextSource: firstString(payload.customType) || undefined }
+    }];
+  }
+  if (role === "branchSummary" || role === "compactionSummary") {
+    const content = firstString(payload.summary);
+    if (!content) return [];
+    return [{
+      role: "system",
+      content,
+      timestamp,
+      metadata: { ...base, providerGenerated: true, contextKind: role === "branchSummary" ? "branch_summary" : "compaction" }
+    }];
+  }
+  return [];
+}
+
+function piAssistantMessages(payload, timestamp, base, header) {
+  const blocks = Array.isArray(payload.content) ? payload.content : [];
+  const texts = [];
+  const thinking = [];
+  const toolCalls = [];
+  for (const block of blocks) {
+    if (!block || typeof block !== "object") continue;
+    if (block.type === "text" && typeof block.text === "string") texts.push(block.text);
+    else if (block.type === "thinking") thinking.push(block.redacted ? "[redacted thinking]" : firstString(block.thinking));
+    else if (block.type === "toolCall") {
+      const call = piToolCall(block);
+      if (call) toolCalls.push(call);
+    }
+  }
+  if (typeof payload.content === "string") texts.push(payload.content);
+  const content = texts.filter(Boolean).join("\n").trim();
+  const thinkingText = thinking.filter(Boolean).join("\n\n").trim();
+  if (!content && !toolCalls.length && !thinkingText && !payload.errorMessage) return [];
+  return [{
+    role: "assistant",
+    content: content || (payload.errorMessage ? `Error: ${payload.errorMessage}` : ""),
+    timestamp,
+    metadata: compactObject({
+      ...base,
+      model: firstString(payload.model, payload.responseModel, header?.modelId) || undefined,
+      modelProvider: firstString(payload.provider, header?.provider) || undefined,
+      thinking: thinkingText || undefined,
+      stopReason: firstString(payload.stopReason) || undefined,
+      isError: payload.stopReason === "error" || undefined,
+      usage: piUsage(payload.usage),
+      toolCalls: toolCalls.length ? toolCalls : undefined
+    })
+  }];
+}
+
+function piToolCall(block) {
+  const name = firstString(block.name);
+  if (!name) return null;
+  const args = block.arguments && typeof block.arguments === "object" ? block.arguments : undefined;
+  const summary = summarizeToolArguments(args);
+  return compactObject({
+    id: firstString(block.id) || undefined,
+    name,
+    displayName: toolDisplayName(name),
+    rawCategory: "toolCall",
+    category: piToolCategory(name),
+    title: toolDisplayName(name),
+    status: "tool_call",
+    argument: summary,
+    rawInputSummary: summary,
+    inputPreview: summary,
+    target: toolTarget(args) || undefined,
+    arguments: args,
+    provider: PROVIDER
+  });
+}
+
+function piToolResult(payload) {
+  const output = piContentText(payload.content);
+  const id = firstString(payload.toolCallId);
+  if (!output && !id) return null;
+  const isError = payload.isError === true;
+  const lineCount = output ? output.split(/\r?\n/).length : 0;
+  return compactObject({
+    provider: PROVIDER,
+    id: id || undefined,
+    kind: toolDisplayName(firstString(payload.toolName, "tool")),
+    title: isError ? "Tool error" : "Tool result",
+    rawCategory: "toolResult",
+    category: piToolCategory(firstString(payload.toolName)),
+    summary: firstLine(output),
+    output,
+    lineCount: lineCount || undefined,
+    collapsed: lineCount > 18 || undefined,
+    status: isError ? "error" : "completed"
+  });
+}
+
+// `!` shell commands typed by the user are stored as bashExecution messages
+// with the captured output and exit code.
+function piBashExecutionMessages(payload, timestamp, base) {
+  const command = firstString(payload.command);
+  if (!command) return [];
+  const messages = [{
+    role: "user",
+    content: `! ${command}`,
+    timestamp,
+    metadata: { ...base, eventType: "pi-bash-execution" }
+  }];
+  const output = firstString(payload.output);
+  if (output) {
+    const lineCount = output.split(/\r?\n/).length;
+    messages.push({
+      role: "tool",
+      content: output,
+      timestamp,
+      metadata: {
+        ...base,
+        toolResult: compactObject({
+          provider: PROVIDER,
+          kind: "Bash",
+          title: payload.exitCode ? "Tool error" : "Tool result",
+          rawCategory: "bashExecution",
+          category: "shell",
+          summary: firstLine(output),
+          output,
+          lineCount,
+          collapsed: lineCount > 18 || undefined,
+          status: payload.cancelled ? "cancelled" : payload.exitCode ? "error" : "completed",
+          exitCode: Number.isFinite(Number(payload.exitCode)) ? Number(payload.exitCode) : undefined
+        })
+      }
+    });
+  }
+  return messages;
+}
+
+function piSystemMessage(entry, timestamp) {
+  const base = compactObject({
+    provider: PROVIDER,
+    providerMessageId: firstString(entry.id),
+    parentMessageId: firstString(entry.parentId),
+    providerGenerated: true
+  });
+  if (entry.type === "model_change") {
+    const model = firstString(entry.modelId, entry.model);
+    if (!model) return null;
+    return {
+      role: "system",
+      content: `Model changed to ${model}`,
+      timestamp,
+      metadata: { ...base, eventType: "pi-model-change", contextKind: "model_change", model }
+    };
+  }
+  if (entry.type === "thinking_level_change") {
+    const level = firstString(entry.thinkingLevel);
+    if (!level) return null;
+    return {
+      role: "system",
+      content: `Thinking level changed to ${level}`,
+      timestamp,
+      metadata: { ...base, eventType: "pi-thinking-level-change", contextKind: "thinking_level_change" }
+    };
+  }
+  if (entry.type === "compaction") {
+    return {
+      role: "system",
+      content: firstString(entry.summary, "Context compacted"),
+      timestamp,
+      metadata: compactObject({
+        ...base,
+        eventType: "pi-compaction",
+        contextKind: "compaction",
+        tokensBefore: Number.isFinite(Number(entry.tokensBefore)) ? Number(entry.tokensBefore) : undefined,
+        firstKeptEntryId: firstString(entry.firstKeptEntryId) || undefined
+      })
+    };
+  }
+  if (entry.type === "branch_summary") {
+    return {
+      role: "system",
+      content: firstString(entry.summary, "Returned from branch"),
+      timestamp,
+      metadata: compactObject({ ...base, eventType: "pi-branch-summary", contextKind: "branch_summary", fromId: firstString(entry.fromId) || undefined })
+    };
+  }
+  if (entry.type === "custom_message") {
+    const content = piContentText(entry.content);
+    if (!content) return null;
+    return {
+      role: "system",
+      content,
+      timestamp,
+      metadata: compactObject({ ...base, eventType: "pi-custom-message", contextKind: "extension", contextSource: firstString(entry.customType) || undefined })
+    };
+  }
+  return null;
+}
+
+// pi usage mirrors API token fields: input excludes cache reads/writes, and
+// per-message dollar cost is stored under cost.total.
+function piUsage(usage) {
+  if (!usage || typeof usage !== "object") return undefined;
+  const inputTokens = positiveNumber(usage.input);
+  const outputTokens = positiveNumber(usage.output);
+  const cacheReadTokens = positiveNumber(usage.cacheRead);
+  const cacheCreationInputTokens = positiveNumber(usage.cacheWrite);
+  const totalTokens = positiveNumber(usage.totalTokens);
+  const costUsd = positiveNumber(usage.cost?.total);
+  if (!inputTokens && !outputTokens && !cacheReadTokens && !cacheCreationInputTokens && !totalTokens) return undefined;
+  return compactObject({
+    inputTokens,
+    outputTokens,
+    cacheReadTokens,
+    cacheCreationInputTokens,
+    totalTokens,
+    costUsd
+  });
+}
+
+function piContentText(content) {
+  if (typeof content === "string") return content.trim();
+  if (!Array.isArray(content)) return "";
+  return content
+    .map((block) => {
+      if (typeof block === "string") return block;
+      if (block && typeof block === "object" && typeof block.text === "string") return block.text;
+      if (block && typeof block === "object" && block.type === "image") return "[Attachment: image]";
+      return "";
+    })
+    .filter(Boolean)
+    .join("\n")
+    .trim();
+}
+
+function piToolCategory(name) {
+  const text = String(name || "");
+  if (/subagent|task|agent/i.test(text)) return "task";
+  if (/bash|shell|command|exec/i.test(text)) return "shell";
+  if (/web|fetch|url|http|browser/i.test(text)) return "web";
+  if (/edit|write|patch|replace/i.test(text)) return "edit";
+  if (/read|view|cat|ls|list/i.test(text)) return "read";
+  if (/grep|glob|find|search|rg/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", "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") return "";
+  return firstString(args.path, args.file_path, args.filePath, args.file, args.directory, 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 = {
+  parsePiSessionFile,
+  parsePiSessionText
+};

package/src/importers/providers.js

@@ -1,5 +1,7 @@
 "use strict";
 
+const { canonicalImportSource } = require("../sources");
+
 const PROVIDER_ADAPTERS = [
   {
     source: "codex",
@@ -67,10 +69,10 @@ const PROVIDER_ADAPTERS = [
       helpers.importClaudeDesktopProvider("claude_desktop", since, { ...options, claudeDesktopKind: "claude-code-desktop-metadata" }, env)
   },
   {
-    source: "claude-workspace",
+    source: "claude-cowork",
     provider: "claude_desktop",
     sourceType: "claude-workspace-desktop",
-    label: "Claude Workspace",
+    label: "Claude Cowork",
     run: ({ helpers, since, options, env }) =>
       helpers.importClaudeDesktopProvider("claude_desktop", since, { ...options, claudeDesktopKind: "claude-workspace-desktop" }, env)
   },
@@ -146,9 +148,10 @@ const PROVIDER_ADAPTERS = [
   {
     source: "windsurf",
     provider: "windsurf",
+    sourceType: "windsurf-cascade-brain",
     label: "Windsurf",
-    disabled: true,
-    run: ({ helpers }) => helpers.disabledImportResult("windsurf")
+    run: ({ helpers, since, options, env }) =>
+      helpers.importStructuredProvider("windsurf", helpers.readWindsurfSessions(options, env), since, options, env)
   },
   {
     source: "antigravity",
@@ -158,6 +161,22 @@ const PROVIDER_ADAPTERS = [
     run: ({ helpers, since, options, env }) =>
       helpers.importStructuredProvider("antigravity", helpers.readAntigravitySessions(options, env), since, options, env)
   },
+  {
+    source: "antigravity-cli",
+    provider: "antigravity_cli",
+    sourceType: "antigravity-cli-transcript-log",
+    label: "Antigravity CLI",
+    run: ({ helpers, since, options, env }) =>
+      helpers.importStructuredProvider("antigravity_cli", helpers.readAntigravityCliSessions(options, env), since, options, env)
+  },
+  {
+    source: "antigravity-ide",
+    provider: "antigravity_ide",
+    sourceType: "antigravity-ide-transcript-log",
+    label: "Antigravity IDE",
+    run: ({ helpers, since, options, env }) =>
+      helpers.importStructuredProvider("antigravity_ide", helpers.readAntigravityIdeSessions(options, env), since, options, env)
+  },
   {
     source: "devin-cli",
     provider: "devin",
@@ -165,11 +184,51 @@ const PROVIDER_ADAPTERS = [
     label: "Devin CLI",
     run: ({ helpers, since, options, env }) =>
       helpers.importStructuredProvider("devin", helpers.readDevinSessions(env, options), since, options, env)
+  },
+  {
+    source: "devin-desktop",
+    provider: "devin",
+    sourceType: "devin-desktop-acp-events",
+    label: "Devin Desktop",
+    run: ({ helpers, since, options, env }) =>
+      helpers.importStructuredProvider("devin", helpers.readDevinDesktopSessions(env, options), since, options, env)
+  },
+  {
+    source: "copilot-cli",
+    provider: "copilot",
+    sourceType: "copilot-cli-history",
+    label: "GitHub Copilot CLI",
+    run: ({ helpers, since, options, env }) =>
+      helpers.importStructuredProvider("copilot", helpers.readCopilotCliSessions(env, options), since, options, env)
+  },
+  {
+    source: "factory",
+    provider: "factory",
+    sourceType: "factory-droid-history",
+    label: "Factory Droid",
+    run: ({ helpers, since, options, env }) =>
+      helpers.importStructuredProvider("factory", helpers.readFactorySessions(env, options), since, options, env)
+  },
+  {
+    source: "grok-build",
+    provider: "grok",
+    sourceType: "grok-build-history",
+    label: "Grok Build",
+    run: ({ helpers, since, options, env }) =>
+      helpers.importStructuredProvider("grok", helpers.readGrokBuildSessions(env, options), since, options, env)
+  },
+  {
+    source: "pi",
+    provider: "pi",
+    sourceType: "pi-cli-history",
+    label: "pi",
+    run: ({ helpers, since, options, env }) =>
+      helpers.importStructuredProvider("pi", helpers.readPiSessions(env, options), since, options, env)
   }
 ];
 
 function providerAdapterForSource(source) {
-  const key = String(source || "").trim();
+  const key = canonicalImportSource(source);
   return PROVIDER_ADAPTERS.find((adapter) => adapter.source === key) || null;
 }