agentel 0.2.6 → 0.3.0

package/src/mcp.js

@@ -63,6 +63,7 @@ async function handleRequest(message, env = process.env) {
         includeWebChats: args.include_web_chats === true,
         noRebuild: true,
         skipJsonIndex: true,
+        skipMarkdownFallback: true,
         allowStaleFts: true
       },
       env

package/src/memory-sources.js

@@ -0,0 +1,671 @@
+"use strict";
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { spawnSync } = require("child_process");
+const { listSessions, readTranscript } = require("./archive");
+const { loadConfig } = require("./config");
+const { canonicalRepo } = require("./repo");
+const { recordMemoryObservation } = require("./memory-store");
+
+// One backup pass over every provider memory store we can reach. Each source
+// is independent: a missing directory or a locked database skips that source
+// instead of failing the run. Returns per-source summaries for the CLI.
+const MAX_MEMORY_FILE_BYTES = 5 * 1024 * 1024;
+
+const CHATGPT_PLATFORM_NOTE =
+  "ChatGPT memories cannot be edited here; manage them in ChatGPT under Settings > Personalization > Manage memories.";
+const CLAUDE_WEB_PLATFORM_NOTE =
+  "Claude.ai memories cannot be edited here; manage them in your Claude.ai project or profile settings.";
+const CURSOR_PLATFORM_NOTE =
+  "Cursor memories live in Cursor's cloud; manage them in Cursor under Settings > Rules > Memories.";
+const DEVIN_PLATFORM_NOTE =
+  "Devin knowledge lives in Devin's cloud; manage it at app.devin.ai under Knowledge.";
+
+function userHome(env = process.env) {
+  return env && env.HOME ? env.HOME : os.homedir();
+}
+
+function codexHome(env = process.env) {
+  return env.CODEX_HOME || path.join(userHome(env), ".codex");
+}
+
+function geminiHome(env = process.env) {
+  return env.AGENTLOG_GEMINI_DIR || path.join(userHome(env), ".gemini");
+}
+
+function antigravityHome(env = process.env) {
+  return env.AGENTLOG_ANTIGRAVITY_DIR || path.join(geminiHome(env), "antigravity");
+}
+
+function antigravityCliHome(env = process.env) {
+  return env.AGENTLOG_ANTIGRAVITY_CLI_HOME_DIR || path.join(geminiHome(env), "antigravity-cli");
+}
+
+function antigravityIdeHome(env = process.env) {
+  return env.AGENTLOG_ANTIGRAVITY_IDE_HOME_DIR || path.join(geminiHome(env), "antigravity-ide");
+}
+
+function grokHome(env = process.env) {
+  return env.AGENTLOG_GROK_HOME || env.GROK_HOME || path.join(userHome(env), ".grok");
+}
+
+function cursorGlobalStorageDir(env = process.env) {
+  return (
+    env.AGENTLOG_CURSOR_GLOBAL_STORAGE_DIR ||
+    path.join(userHome(env), "Library", "Application Support", "Cursor", "User", "globalStorage")
+  );
+}
+
+function contentTypeForFile(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  if (ext === ".md" || ext === ".mdx") return "markdown";
+  if (ext === ".json") return "json";
+  if ([".pb", ".bin", ".sqlite", ".db", ".png", ".jpg", ".jpeg", ".gif", ".pdf"].includes(ext)) return "binary";
+  return "text";
+}
+
+function listFilesRecursive(dir, depthLimit = 6) {
+  const files = [];
+  const stack = [{ dir, depth: 0 }];
+  while (stack.length) {
+    const { dir: current, depth } = stack.pop();
+    let entries;
+    try {
+      entries = fs.readdirSync(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (entry.name.startsWith(".")) continue;
+      const full = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        if (depth < depthLimit) stack.push({ dir: full, depth: depth + 1 });
+      } else if (entry.isFile() && !entry.name.endsWith(".lock")) {
+        files.push(full);
+      }
+    }
+  }
+  return files.sort();
+}
+
+function observeFile(filePath, base, env) {
+  let stat;
+  try {
+    stat = fs.statSync(filePath);
+  } catch {
+    return null;
+  }
+  if (!stat.isFile() || stat.size > MAX_MEMORY_FILE_BYTES) return null;
+  const contentType = contentTypeForFile(filePath);
+  const content = fs.readFileSync(filePath);
+  if (contentType !== "binary" && !content.toString("utf8").trim()) return null;
+  return recordMemoryObservation(
+    {
+      ...base,
+      origin: "file",
+      sourceKind: "fs-walk",
+      livePath: filePath,
+      itemKey: filePath,
+      name: path.basename(filePath),
+      contentType,
+      content,
+      modifiedAt: stat.mtime.toISOString()
+    },
+    env
+  );
+}
+
+// ~/.claude/projects/<slug>/memory encodes the project cwd with "/" and other
+// separators flattened to "-", which is ambiguous for directory names that
+// contain dashes. Resolve by walking the filesystem and preferring the
+// longest dash-joined segment that actually exists at each level.
+function decodeClaudeProjectSlug(slug) {
+  const tokens = String(slug || "").replace(/^-/, "").split("-").filter(Boolean);
+  if (!tokens.length) return "";
+  return decodeSlugWalk(path.sep, tokens, 0, { steps: 0 }) || "";
+}
+
+function decodeSlugWalk(current, tokens, index, limit) {
+  if (limit.steps > 4000) return null;
+  if (index >= tokens.length) {
+    return fs.existsSync(current) ? current : null;
+  }
+  const joins = [];
+  let acc = "";
+  for (let next = index; next < tokens.length; next++) {
+    acc = acc ? `${acc}-${tokens[next]}` : tokens[next];
+    joins.push({ candidate: path.join(current, acc), next: next + 1 });
+  }
+  // Longest join first: "fun-potholes" should beat "fun/potholes".
+  for (const { candidate, next } of joins.reverse()) {
+    limit.steps += 1;
+    if (!fs.existsSync(candidate)) continue;
+    const result = decodeSlugWalk(candidate, tokens, next, limit);
+    if (result) return result;
+  }
+  return null;
+}
+
+// Claude Code project slugs flatten every non-alphanumeric character to "-".
+// Sessions in the archive remember both the original cwd and its canonical
+// repo key, so a slug can be resolved even after the project directory was
+// deleted.
+function claudeProjectSlugIndex(env) {
+  const index = new Map();
+  let sessions = [];
+  try {
+    sessions = listSessions(env);
+  } catch {
+    sessions = [];
+  }
+  for (const session of sessions) {
+    const cwd = String(session.cwd || "");
+    if (!cwd) continue;
+    const slug = cwd.replace(/[^a-zA-Z0-9]/g, "-");
+    if (!index.has(slug)) index.set(slug, { cwd, repo: String(session.repoCanonical || "") });
+  }
+  return index;
+}
+
+function backupClaudeCodeMemories(env, summaries) {
+  const claudeDir = path.join(userHome(env), ".claude");
+  const summary = sourceSummary("claude-code");
+  const globalTargets = [
+    path.join(claudeDir, "CLAUDE.md"),
+    ...listFilesRecursive(path.join(claudeDir, "memory")),
+    ...listFilesRecursive(path.join(claudeDir, "memories"))
+  ];
+  for (const file of globalTargets) {
+    tally(summary, observeFile(file, { provider: "claude_code", source: "claude-code-memory", scope: "global" }, env));
+  }
+  const projectsDir = path.join(claudeDir, "projects");
+  let slugs = [];
+  try {
+    slugs = fs.readdirSync(projectsDir);
+  } catch {
+    slugs = [];
+  }
+  let slugIndex = null;
+  for (const slug of slugs) {
+    const memoryDir = path.join(projectsDir, slug, "memory");
+    const files = listFilesRecursive(memoryDir);
+    if (!files.length) continue;
+    const decoded = decodeClaudeProjectSlug(slug, env);
+    if (!slugIndex) slugIndex = claudeProjectSlugIndex(env);
+    const fromSessions = slugIndex.get(slug) || null;
+    const projectPath = decoded || fromSessions?.cwd || "";
+    const repo = decoded ? canonicalRepo(decoded).key : fromSessions?.repo || "";
+    for (const file of files) {
+      tally(
+        summary,
+        observeFile(
+          file,
+          {
+            provider: "claude_code",
+            source: "claude-code-project-memory",
+            scope: "project",
+            repo,
+            projectPath: projectPath || slug
+          },
+          env
+        )
+      );
+    }
+  }
+  summaries.push(summary);
+}
+
+// In-repo agent instruction files (AGENTS.md, CLAUDE.md, rules dirs) for
+// every project the sessions archive knows about and that still exists on
+// disk. They are git-covered in their repos, but backing them up gives the
+// Memories tab one place to read and edit them next to provider memories.
+const REPO_RULES_FILES = ["AGENTS.md", "CLAUDE.md", "GEMINI.md", ".cursorrules", ".windsurfrules"];
+// Agents also honor scoped instruction files one level down (./src/GEMINI.md,
+// nested CLAUDE.md); a single readdir per project keeps that sweep cheap.
+const REPO_RULES_SUBDIR_FILES = ["AGENTS.md", "CLAUDE.md", "GEMINI.md"];
+const REPO_RULES_SUBDIR_LIMIT = 50;
+const REPO_RULES_SKIP_DIRS = new Set(["node_modules", "dist", "build", "out", "vendor", "target", "coverage", "tmp"]);
+const REPO_RULES_PROJECT_LIMIT = 300;
+
+function backupRepoRulesFiles(env, summaries) {
+  const summary = sourceSummary("repo-rules");
+  let sessions = [];
+  try {
+    sessions = listSessions(env);
+  } catch {
+    sessions = [];
+  }
+  const projects = new Map();
+  for (const session of sessions) {
+    const cwd = String(session.cwd || "");
+    if (!cwd || projects.has(cwd)) continue;
+    try {
+      if (!fs.statSync(cwd).isDirectory()) continue;
+    } catch {
+      continue;
+    }
+    projects.set(cwd, String(session.repoCanonical || ""));
+    if (projects.size >= REPO_RULES_PROJECT_LIMIT) break;
+  }
+  for (const [cwd, repo] of projects) {
+    const base = { provider: "project", source: "repo-rules", scope: "project", repo, projectPath: cwd };
+    for (const name of REPO_RULES_FILES) {
+      tally(summary, observeFile(path.join(cwd, name), base, env));
+    }
+    for (const file of listFilesRecursive(path.join(cwd, ".cursor", "rules"), 1)) {
+      tally(summary, observeFile(file, base, env));
+    }
+    let subdirs = [];
+    try {
+      subdirs = fs.readdirSync(cwd, { withFileTypes: true });
+    } catch {
+      subdirs = [];
+    }
+    let scanned = 0;
+    for (const entry of subdirs) {
+      if (!entry.isDirectory() || entry.name.startsWith(".") || REPO_RULES_SKIP_DIRS.has(entry.name)) continue;
+      if (++scanned > REPO_RULES_SUBDIR_LIMIT) break;
+      for (const name of REPO_RULES_SUBDIR_FILES) {
+        tally(summary, observeFile(path.join(cwd, entry.name, name), base, env));
+      }
+    }
+  }
+  summaries.push(summary);
+}
+
+function backupCodexMemories(env, summaries) {
+  const summary = sourceSummary("codex");
+  const home = codexHome(env);
+  const targets = [
+    path.join(home, "AGENTS.md"),
+    ...listFilesRecursive(path.join(home, "memory")),
+    ...listFilesRecursive(path.join(home, "memories"))
+  ];
+  for (const file of targets) {
+    tally(summary, observeFile(file, { provider: "codex", source: "codex-memory", scope: "global" }, env));
+  }
+  summaries.push(summary);
+}
+
+// Gemini CLI keeps private per-project memory under
+// ~/.gemini/tmp/<project-basename>/memory/ (an index MEMORY.md plus fact
+// files). The tmp dir only records the project's directory name, so the
+// owning repo is resolved through the sessions archive.
+function projectBasenameIndex(env) {
+  const index = new Map();
+  let sessions = [];
+  try {
+    sessions = listSessions(env);
+  } catch {
+    sessions = [];
+  }
+  for (const session of sessions) {
+    const cwd = String(session.cwd || "");
+    if (!cwd) continue;
+    const base = path.basename(cwd);
+    if (base && !index.has(base)) index.set(base, { cwd, repo: String(session.repoCanonical || "") });
+  }
+  return index;
+}
+
+function backupGeminiMemories(env, summaries) {
+  const summary = sourceSummary("gemini");
+  tally(
+    summary,
+    observeFile(path.join(geminiHome(env), "GEMINI.md"), { provider: "gemini_cli", source: "gemini-memory", scope: "global" }, env)
+  );
+  const tmpRoot = path.join(geminiHome(env), "tmp");
+  let entries = [];
+  try {
+    entries = fs.readdirSync(tmpRoot, { withFileTypes: true });
+  } catch {
+    entries = [];
+  }
+  let basenames = null;
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const files = listFilesRecursive(path.join(tmpRoot, entry.name, "memory"));
+    if (!files.length) continue;
+    if (!basenames) basenames = projectBasenameIndex(env);
+    const match = basenames.get(entry.name) || null;
+    for (const file of files) {
+      tally(
+        summary,
+        observeFile(
+          file,
+          {
+            provider: "gemini_cli",
+            source: "gemini-project-memory",
+            scope: "project",
+            repo: match?.repo || "",
+            projectPath: match?.cwd || entry.name
+          },
+          env
+        )
+      );
+    }
+  }
+  summaries.push(summary);
+}
+
+// Grok Build cross-session memory (--experimental-memory) keeps three styles
+// of Markdown under ~/.grok/memory/: a global MEMORY.md, per-workspace
+// <project-slug>-<hash8>/MEMORY.md, and dated /flush session logs under
+// <workspace>/sessions/. The hash8 is derived from the git remote URL, so
+// workspaces map back to projects only by slug basename. The SQLite search
+// index is derived data and skipped.
+function backupGrokMemories(env, summaries) {
+  const summary = sourceSummary("grok");
+  const memoryRoot = path.join(grokHome(env), "memory");
+  tally(summary, observeFile(path.join(memoryRoot, "MEMORY.md"), { provider: "grok", source: "grok-memory", scope: "global" }, env));
+  let entries = [];
+  try {
+    entries = fs.readdirSync(memoryRoot, { withFileTypes: true });
+  } catch {
+    entries = [];
+  }
+  let basenames = null;
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const files = listFilesRecursive(path.join(memoryRoot, entry.name)).filter((file) => contentTypeForFile(file) !== "binary");
+    if (!files.length) continue;
+    if (!basenames) basenames = projectBasenameIndex(env);
+    const slug = entry.name.replace(/-[0-9a-f]{8}$/i, "");
+    const match = basenames.get(slug) || null;
+    for (const file of files) {
+      tally(
+        summary,
+        observeFile(
+          file,
+          {
+            provider: "grok",
+            source: "grok-project-memory",
+            scope: "project",
+            repo: match?.repo || "",
+            projectPath: match?.cwd || slug
+          },
+          env
+        )
+      );
+    }
+  }
+  summaries.push(summary);
+}
+
+function backupAntigravityMemories(env, summaries) {
+  const summary = sourceSummary("antigravity");
+  const home = antigravityHome(env);
+  for (const file of listFilesRecursive(path.join(home, "knowledge"))) {
+    tally(summary, observeFile(file, { provider: "antigravity", source: "antigravity-knowledge", scope: "global" }, env));
+  }
+  for (const file of listFilesRecursive(path.join(home, "implicit"), 1)) {
+    tally(summary, observeFile(file, { provider: "antigravity", source: "antigravity-implicit", scope: "global" }, env));
+  }
+  summaries.push(summary);
+  backupAntigravitySurfaceMemories(env, summaries, "antigravity_cli", antigravityCliHome(env), "antigravity-cli");
+  backupAntigravitySurfaceMemories(env, summaries, "antigravity_ide", antigravityIdeHome(env), "antigravity-ide");
+}
+
+// The Antigravity CLI and IDE keep their own knowledge/implicit memory stores
+// under ~/.gemini/antigravity-cli and ~/.gemini/antigravity-ide, separate from
+// the 2.0 app's home.
+function backupAntigravitySurfaceMemories(env, summaries, provider, home, sourcePrefix) {
+  const summary = sourceSummary(provider);
+  for (const file of listFilesRecursive(path.join(home, "knowledge"))) {
+    tally(summary, observeFile(file, { provider, source: `${sourcePrefix}-knowledge`, scope: "global" }, env));
+  }
+  for (const file of listFilesRecursive(path.join(home, "implicit"), 1)) {
+    tally(summary, observeFile(file, { provider, source: `${sourcePrefix}-implicit`, scope: "global" }, env));
+  }
+  summaries.push(summary);
+}
+
+function readSqliteValue(dbPath, key) {
+  const query = `SELECT value FROM ItemTable WHERE key='${key.replace(/'/g, "''")}' LIMIT 1`;
+  const run = (target) =>
+    spawnSync("sqlite3", [target, "-json", query], { argv0: "agentlog-sqlite", encoding: "utf8", timeout: 20000, maxBuffer: 1024 * 1024 * 64 });
+  let result = run(dbPath);
+  if ((result.error || result.status !== 0) && fs.existsSync(dbPath)) {
+    // Cursor keeps the db open with WAL; query a point-in-time copy instead.
+    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "agentlog-memory-sqlite-"));
+    try {
+      const target = path.join(tmp, path.basename(dbPath));
+      fs.copyFileSync(dbPath, target);
+      for (const suffix of ["-wal", "-shm"]) {
+        try {
+          fs.copyFileSync(`${dbPath}${suffix}`, `${target}${suffix}`);
+        } catch {}
+      }
+      result = run(target);
+      if (result.error || result.status !== 0) return null;
+      return firstSqliteValue(result.stdout);
+    } finally {
+      fs.rmSync(tmp, { recursive: true, force: true });
+    }
+  }
+  if (result.error || result.status !== 0) return null;
+  return firstSqliteValue(result.stdout);
+}
+
+function firstSqliteValue(stdout) {
+  try {
+    const rows = JSON.parse(String(stdout || "").trim() || "[]");
+    return rows.length ? String(rows[0].value ?? "") : null;
+  } catch {
+    return null;
+  }
+}
+
+function backupCursorMemories(env, summaries) {
+  const summary = sourceSummary("cursor");
+  const dbPath = env.AGENTLOG_CURSOR_GLOBAL_STORAGE_DB || path.join(cursorGlobalStorageDir(env), "state.vscdb");
+  if (!fs.existsSync(dbPath)) {
+    summaries.push(summary);
+    return;
+  }
+  const pending = readSqliteValue(dbPath, "cursorPendingMemories");
+  if (pending && pending.trim() && pending.trim() !== "[]") {
+    tally(
+      summary,
+      recordMemoryObservation(
+        {
+          provider: "cursor",
+          source: "cursor-pending-memories",
+          sourceKind: "sqlite-key",
+          origin: "provider-cloud",
+          scope: "global",
+          itemKey: "cursorPendingMemories",
+          name: "Cursor pending memories",
+          platformNote: CURSOR_PLATFORM_NOTE,
+          contentType: "json",
+          content: pending
+        },
+        env
+      )
+    );
+  }
+  const personalContext = readSqliteValue(dbPath, "aicontext.personalContext");
+  if (personalContext && personalContext.trim()) {
+    tally(
+      summary,
+      recordMemoryObservation(
+        {
+          provider: "cursor",
+          source: "cursor-user-rules",
+          sourceKind: "sqlite-key",
+          origin: "provider-cloud",
+          scope: "global",
+          itemKey: "aicontext.personalContext",
+          name: "Cursor user rules",
+          platformNote: CURSOR_PLATFORM_NOTE,
+          contentType: "text",
+          content: personalContext
+        },
+        env
+      )
+    );
+  }
+  summaries.push(summary);
+}
+
+// Claude.ai memories arrive through the official export and are already
+// archived as claude-web-memory sessions; mirror them into memory records so
+// the Memories tab sees them without a reimport.
+function backupClaudeWebMemories(env, summaries) {
+  const summary = sourceSummary("claude-web");
+  let sessions = [];
+  try {
+    sessions = listSessions(env).filter((session) => session.sourceType === "claude-web-memory");
+  } catch {
+    sessions = [];
+  }
+  for (const session of sessions) {
+    let content = "";
+    try {
+      const messages = readTranscript(session.transcriptPath) || [];
+      content = messages.map((message) => String(message.content || "")).filter(Boolean).join("\n\n");
+    } catch {
+      continue;
+    }
+    if (!content.trim()) continue;
+    tally(
+      summary,
+      recordMemoryObservation(
+        {
+          provider: "claude_web",
+          source: "claude-web-memory",
+          sourceKind: "export-import",
+          origin: "provider-cloud",
+          scope: "global",
+          itemKey: `${session.chatAccountId || ""}:${session.title || session.sessionId}`,
+          name: session.title || "Claude memory",
+          title: session.title || "",
+          account: session.chatAccountId ? { id: session.chatAccountId } : null,
+          platformNote: CLAUDE_WEB_PLATFORM_NOTE,
+          contentType: "markdown",
+          content
+        },
+        env
+      )
+    );
+  }
+  summaries.push(summary);
+}
+
+async function backupDevinKnowledge(env, summaries) {
+  const summary = sourceSummary("devin");
+  const cfg = loadConfig(env);
+  const apiKey = env.DEVIN_API_KEY || cfg.memory?.devinApiKey || "";
+  if (!apiKey) {
+    summary.skipped = "no API key (set DEVIN_API_KEY or memory.devinApiKey in config)";
+    summaries.push(summary);
+    return;
+  }
+  const endpoint = env.AGENTLOG_DEVIN_API_BASE || "https://api.devin.ai";
+  let payload;
+  try {
+    const response = await fetch(`${endpoint}/v1/knowledge`, {
+      headers: { authorization: `Bearer ${apiKey}` }
+    });
+    if (!response.ok) throw new Error(`devin knowledge request failed: ${response.status}`);
+    payload = await response.json();
+  } catch (error) {
+    summary.error = error.message;
+    summaries.push(summary);
+    return;
+  }
+  const items = Array.isArray(payload?.knowledge) ? payload.knowledge : Array.isArray(payload) ? payload : [];
+  for (const item of items) {
+    if (!item || typeof item !== "object") continue;
+    const body = String(item.body || "").trim();
+    if (!body) continue;
+    const parts = [body];
+    if (item.trigger_description) parts.push(`Trigger: ${item.trigger_description}`);
+    if (item.pinned_repo) parts.push(`Pinned repo: ${item.pinned_repo}`);
+    tally(
+      summary,
+      recordMemoryObservation(
+        {
+          provider: "devin",
+          source: "devin-knowledge",
+          sourceKind: "api-poll",
+          origin: "provider-cloud",
+          scope: "global",
+          itemKey: String(item.id || item.name || body.slice(0, 80)),
+          name: String(item.name || item.id || "Devin knowledge"),
+          platformNote: DEVIN_PLATFORM_NOTE,
+          contentType: "markdown",
+          content: parts.join("\n\n"),
+          modifiedAt: firstIsoTimestamp(item.updated_at, item.created_at)
+        },
+        env
+      )
+    );
+  }
+  summaries.push(summary);
+}
+
+// ChatGPT has no memory export or API; users paste from Settings >
+// Personalization > Manage memories into a file and import it manually.
+function importChatGptMemories(filePath, env = process.env, options = {}) {
+  const content = fs.readFileSync(filePath, "utf8");
+  if (!content.trim()) throw new Error(`no memory text found in ${filePath}`);
+  const result = recordMemoryObservation(
+    {
+      provider: "chatgpt",
+      source: "chatgpt-manual-memories",
+      sourceKind: "export-import",
+      origin: "manual-import",
+      scope: "global",
+      itemKey: options.account ? `chatgpt:${options.account}` : "chatgpt:default",
+      name: options.account ? `ChatGPT memories (${options.account})` : "ChatGPT memories",
+      account: options.account ? { id: options.account } : null,
+      platformNote: CHATGPT_PLATFORM_NOTE,
+      contentType: "markdown",
+      content
+    },
+    env
+  );
+  return result;
+}
+
+function firstIsoTimestamp(...values) {
+  for (const value of values) {
+    if (!value) continue;
+    const date = new Date(value);
+    if (!Number.isNaN(date.getTime())) return date.toISOString();
+  }
+  return "";
+}
+
+function sourceSummary(source) {
+  return { source, items: 0, changed: 0, skipped: "", error: "" };
+}
+
+function tally(summary, result) {
+  if (!result) return;
+  summary.items += 1;
+  if (result.changed) summary.changed += 1;
+}
+
+async function collectMemoryBackup(env = process.env) {
+  const summaries = [];
+  backupRepoRulesFiles(env, summaries);
+  backupClaudeCodeMemories(env, summaries);
+  backupCodexMemories(env, summaries);
+  backupGeminiMemories(env, summaries);
+  backupGrokMemories(env, summaries);
+  backupAntigravityMemories(env, summaries);
+  backupCursorMemories(env, summaries);
+  backupClaudeWebMemories(env, summaries);
+  await backupDevinKnowledge(env, summaries);
+  return summaries;
+}
+
+module.exports = {
+  collectMemoryBackup,
+  decodeClaudeProjectSlug,
+  importChatGptMemories
+};