agentel 0.2.6 → 0.3.0

package/src/importers/copilot.js

@@ -0,0 +1,385 @@
+"use strict";
+
+const fs = require("fs");
+
+const PROVIDER = "copilot";
+
+function parseCopilotEventsFile(file, options = {}) {
+  let text;
+  try {
+    text = fs.readFileSync(file, "utf8");
+  } catch {
+    return null;
+  }
+  return parseCopilotEventsText(text, options);
+}
+
+// Copilot CLI sessions live in ~/.copilot/session-state/<uuid>/events.jsonl.
+// Every line is {type, data, id, timestamp, parentId}. Lines can contain raw
+// unescaped multiline tool output in older builds, so parse line-by-line and
+// drop what does not parse.
+function parseCopilotEventsText(text, options = {}) {
+  const lines = String(text || "").split(/\r?\n/);
+  const fallbackTime = toIso(options.fallbackTime) || new Date().toISOString();
+  const messages = [];
+  let sessionId = "";
+  let cwd = "";
+  let repository = "";
+  let branch = "";
+  let copilotVersion = "";
+  let currentModel = "";
+  let shutdown = null;
+  let taskSummary = "";
+  let index = 0;
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    const event = parseJson(line);
+    if (!event || typeof event !== "object") continue;
+    const type = String(event.type || "");
+    const data = event.data && typeof event.data === "object" ? event.data : {};
+    const timestamp = toIso(event.timestamp) || offsetTimestamp(fallbackTime, index);
+    index++;
+    const base = compactObject({
+      provider: PROVIDER,
+      providerMessageId: firstString(event.id),
+      parentMessageId: firstString(event.parentId),
+      eventType: type
+    });
+    if (type === "session.start" || type === "session.resume") {
+      sessionId ||= firstString(data.sessionId);
+      const context = data.context && typeof data.context === "object" ? data.context : {};
+      cwd = firstString(context.cwd, cwd);
+      repository = firstString(context.repository, repository);
+      branch = firstString(context.branch, branch);
+      copilotVersion ||= firstString(data.copilotVersion);
+      currentModel = firstString(data.selectedModel, currentModel);
+      continue;
+    }
+    if (type === "user.message") {
+      const content = firstString(data.content, data.text, data.message);
+      if (content) messages.push({ role: "user", content, timestamp, metadata: { ...base } });
+      continue;
+    }
+    if (type === "assistant.message") {
+      const content = firstString(data.content, data.text, data.message);
+      if (content) {
+        messages.push({
+          role: "assistant",
+          content,
+          timestamp,
+          metadata: compactObject({ ...base, model: firstString(data.model, currentModel) || undefined })
+        });
+      }
+      continue;
+    }
+    if (type === "tool.execution_start") {
+      const call = copilotToolCall(data);
+      if (call) {
+        messages.push({
+          role: "assistant",
+          content: "",
+          timestamp,
+          metadata: compactObject({ ...base, model: currentModel || undefined, toolCalls: [call] })
+        });
+      }
+      continue;
+    }
+    if (type === "tool.execution_complete") {
+      currentModel = firstString(data.model, currentModel);
+      const toolResult = copilotToolResult(data);
+      if (toolResult) {
+        messages.push({ role: "tool", content: toolResult.output, timestamp, metadata: { ...base, toolResult } });
+      }
+      continue;
+    }
+    if (type === "session.model_change") {
+      const newModel = firstString(data.newModel);
+      if (newModel) {
+        currentModel = newModel;
+        messages.push({
+          role: "system",
+          content: `Model changed to ${newModel}`,
+          timestamp,
+          metadata: { ...base, providerGenerated: true, contextKind: "model_change", model: newModel }
+        });
+      }
+      continue;
+    }
+    if (type === "session.compaction_complete") {
+      messages.push({
+        role: "system",
+        content: "Context compacted",
+        timestamp,
+        metadata: compactObject({
+          ...base,
+          providerGenerated: true,
+          contextKind: "compaction",
+          tokensBefore: positiveNumber(data.preCompactionTokens)
+        })
+      });
+      continue;
+    }
+    if (type === "subagent.started" || type === "subagent.completed") {
+      const agentName = firstString(data.agentDisplayName, data.agentName);
+      messages.push({
+        role: "system",
+        content: `Subagent ${agentName || "run"} ${type === "subagent.started" ? "started" : "completed"}`,
+        timestamp,
+        metadata: compactObject({
+          ...base,
+          providerGenerated: true,
+          contextKind: "subagent",
+          agentName: agentName || undefined,
+          agentDescription: firstString(data.agentDescription) || undefined,
+          toolCallId: firstString(data.toolCallId) || undefined
+        })
+      });
+      continue;
+    }
+    if (type === "session.task_complete") {
+      taskSummary = firstString(data.summary, taskSummary);
+      continue;
+    }
+    if (type === "session.shutdown") {
+      shutdown = data;
+      continue;
+    }
+  }
+  if (!messages.length && !sessionId) return null;
+  return {
+    sessionId,
+    cwd,
+    repository,
+    branch,
+    messages,
+    startedAt: messages[0]?.timestamp || fallbackTime,
+    endedAt: messages[messages.length - 1]?.timestamp || fallbackTime,
+    sessionSummary: copilotSessionSummary({ shutdown, taskSummary, copilotVersion, repository, branch, currentModel })
+  };
+}
+
+function copilotToolCall(data) {
+  const name = firstString(data.toolName, data.name);
+  if (!name) return null;
+  // arguments is usually an object but is sometimes a JSON string.
+  let args = data.arguments;
+  if (typeof args === "string") args = parseJson(args) || { raw: args };
+  if (!args || typeof args !== "object") args = undefined;
+  const summary = summarizeToolArguments(args);
+  return compactObject({
+    id: firstString(data.toolCallId) || undefined,
+    name,
+    displayName: toolDisplayName(name),
+    rawCategory: "tool.execution_start",
+    category: copilotToolCategory(name),
+    title: toolDisplayName(name),
+    status: "tool_call",
+    argument: summary,
+    rawInputSummary: summary,
+    inputPreview: summary,
+    target: toolTarget(args) || undefined,
+    arguments: args,
+    provider: PROVIDER
+  });
+}
+
+function copilotToolResult(data) {
+  const id = firstString(data.toolCallId);
+  const output = toolOutputText(data.result?.content ?? data.result);
+  if (!id && !output) return null;
+  const isError = data.success === false;
+  const lineCount = output ? output.split(/\r?\n/).length : 0;
+  return compactObject({
+    provider: PROVIDER,
+    id: id || undefined,
+    kind: "Tool result",
+    title: isError ? "Tool error" : "Tool result",
+    rawCategory: "tool.execution_complete",
+    category: "tool",
+    summary: firstLine(output),
+    output,
+    lineCount: lineCount || undefined,
+    collapsed: lineCount > 18 || undefined,
+    status: isError ? "error" : "completed"
+  });
+}
+
+// session.shutdown (persisted since CLI 0.0.422 for cleanly ended sessions)
+// carries the only token usage in the file: per-model modelMetrics plus
+// premium-request and code-change counters.
+function copilotSessionSummary({ shutdown, taskSummary, copilotVersion, repository, branch, currentModel }) {
+  const modelMetrics = shutdown?.modelMetrics && typeof shutdown.modelMetrics === "object" ? shutdown.modelMetrics : {};
+  const totals = { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheCreationInputTokens: 0, reasoningOutputTokens: 0 };
+  const modelUsage = [];
+  for (const [model, metrics] of Object.entries(modelMetrics)) {
+    const usage = metrics?.usage && typeof metrics.usage === "object" ? metrics.usage : {};
+    totals.inputTokens += positiveNumber(usage.inputTokens) || 0;
+    totals.outputTokens += positiveNumber(usage.outputTokens) || 0;
+    totals.cacheReadTokens += positiveNumber(usage.cacheReadTokens) || 0;
+    totals.cacheCreationInputTokens += positiveNumber(usage.cacheWriteTokens) || 0;
+    totals.reasoningOutputTokens += positiveNumber(usage.reasoningTokens) || 0;
+    modelUsage.push(compactObject({
+      model,
+      requests: positiveNumber(metrics?.requests?.count),
+      source: "copilot-session-shutdown"
+    }));
+  }
+  const usage = totals.inputTokens || totals.outputTokens || totals.cacheReadTokens
+    ? compactObject({
+        inputTokens: totals.inputTokens || undefined,
+        outputTokens: totals.outputTokens || undefined,
+        cacheReadTokens: totals.cacheReadTokens || undefined,
+        cacheCreationInputTokens: totals.cacheCreationInputTokens || undefined,
+        reasoningOutputTokens: totals.reasoningOutputTokens || undefined,
+        source: "copilot-session-shutdown"
+      })
+    : undefined;
+  const codeChanges = shutdown?.codeChanges && typeof shutdown.codeChanges === "object" ? shutdown.codeChanges : null;
+  return compactObject({
+    usage,
+    modelUsage: modelUsage.length
+      ? modelUsage
+      : currentModel
+        ? [{ model: currentModel, source: "copilot-session-events" }]
+        : undefined,
+    copilotCli: compactObject({
+      copilotVersion: copilotVersion || undefined,
+      repository: repository || undefined,
+      branch: branch || undefined,
+      taskSummary: taskSummary ? taskSummary.slice(0, 600) : undefined,
+      premiumRequests: positiveNumber(shutdown?.totalPremiumRequests),
+      aiCredits: positiveNumber(shutdown?.totalNanoAiu) ? Number((shutdown.totalNanoAiu / 1e9).toFixed(4)) : undefined,
+      shutdownType: firstString(shutdown?.shutdownType) || undefined,
+      apiDurationMs: positiveNumber(shutdown?.totalApiDurationMs),
+      linesAdded: positiveNumber(codeChanges?.linesAdded),
+      linesRemoved: positiveNumber(codeChanges?.linesRemoved),
+      filesModified: Array.isArray(codeChanges?.filesModified) && codeChanges.filesModified.length
+        ? codeChanges.filesModified.slice(0, 50)
+        : undefined
+    })
+  });
+}
+
+// workspace.yaml is flat `key: value` scalars; avoid a YAML dependency.
+function parseCopilotWorkspaceYaml(text) {
+  const result = {};
+  for (const line of String(text || "").split(/\r?\n/)) {
+    const match = line.match(/^([A-Za-z0-9_]+):\s*(.*)\s*$/);
+    if (!match) continue;
+    const value = match[2].replace(/^["']|["']$/g, "").trim();
+    if (value) result[match[1]] = value;
+  }
+  return result;
+}
+
+function copilotToolCategory(name) {
+  const text = String(name || "");
+  if (/report_intent/i.test(text)) return "status";
+  if (/ask_user|ask_permission/i.test(text)) return "question";
+  if (/task|agent|delegate/i.test(text)) return "task";
+  if (/bash|shell|command|exec|powershell/i.test(text)) return "shell";
+  if (/web|fetch|url|http/i.test(text)) return "web";
+  if (/edit|write|create|patch|replace/i.test(text)) return "edit";
+  if (/read|view|cat|ls|list/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 ["intent", "command", "prompt", "query", "pattern", "path", "file_path", "url", "question"]) {
+    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 toolOutputText(value) {
+  if (value == null) return "";
+  if (typeof value === "string") return value.trim();
+  if (Array.isArray(value)) return value.map(toolOutputText).filter(Boolean).join("\n");
+  if (typeof value === "object") {
+    const preferred = value.content ?? value.output ?? value.text ?? value.message ?? value.result;
+    if (preferred != null) return toolOutputText(preferred);
+    return JSON.stringify(value);
+  }
+  return String(value);
+}
+
+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 = {
+  parseCopilotEventsFile,
+  parseCopilotEventsText,
+  parseCopilotWorkspaceYaml
+};

package/src/importers/cursor-recovery.js

@@ -0,0 +1,22 @@
+"use strict";
+
+const CURSOR_RAW_SOURCE_TYPE = "cursor-raw-sqlite-salvage";
+const CURSOR_SHARED_RAW_SOURCE_TYPES = new Set([
+  "cursor-workspace-sqlite",
+  "cursor-global-sqlite",
+  CURSOR_RAW_SOURCE_TYPE
+]);
+
+function cursorSessionUsesSharedRawFiles(sourceType) {
+  return CURSOR_SHARED_RAW_SOURCE_TYPES.has(String(sourceType || ""));
+}
+
+function isCursorRawRecoverySourceType(sourceType) {
+  return String(sourceType || "") === CURSOR_RAW_SOURCE_TYPE;
+}
+
+module.exports = {
+  CURSOR_RAW_SOURCE_TYPE,
+  cursorSessionUsesSharedRawFiles,
+  isCursorRawRecoverySourceType
+};