agentel 0.2.0

package/src/search.js

@@ -0,0 +1,619 @@
+"use strict";
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { spawnSync } = require("child_process");
+const { ensureConversationMarkdown, listSessions, readEvents, readTranscript, sessionHistoryTime } = require("./archive");
+const { EVENT_KINDS, renderEventText } = require("./canonical-events");
+const { loadConfig } = require("./config");
+const { paths, ensureDir, readJson, writeJson } = require("./paths");
+const { canonicalRepo } = require("./repo");
+
+function buildIndex(env = process.env) {
+  const sessions = listSessions(env);
+  const docs = [];
+  const df = {};
+  let totalLength = 0;
+
+  for (const session of sessions) {
+    if (session.conversationPath && !fs.existsSync(session.conversationPath)) ensureConversationMarkdown(session, env);
+    const events = readEvents(session);
+    const eventDocs = events.length ? docsForEvents(session, events) : [];
+    if (!eventDocs.length) ensureConversationMarkdown(session, env);
+    const sourceDocs = eventDocs.length ? eventDocs : docsForTranscript(session, readTranscript(session.transcriptPath));
+    for (const sourceDoc of sourceDocs) {
+      const indexText = normalizeIndexText(sourceDoc.text);
+      if (!indexText) continue;
+      for (const chunk of chunkText(indexText)) {
+        const tokens = tokenize(chunk);
+        if (!tokens.length) continue;
+        const tf = {};
+        for (const token of tokens) tf[token] = (tf[token] || 0) + 1;
+        for (const token of new Set(tokens)) df[token] = (df[token] || 0) + 1;
+        totalLength += tokens.length;
+        docs.push({
+          ...sourceDoc,
+          id: sourceDoc.id || `${session.sessionId}:${sourceDoc.messageIndex ?? docs.length}:${docs.length}`,
+          text: chunk,
+          matchedText: chunk,
+          tf,
+          length: tokens.length
+        });
+      }
+    }
+  }
+
+  const index = {
+    version: 2,
+    builtAt: new Date().toISOString(),
+    docCount: docs.length,
+    avgDocLength: docs.length ? totalLength / docs.length : 0,
+    df,
+    docs
+  };
+  const indexPath = paths(env).index;
+  ensureDir(path.dirname(indexPath));
+  writeJson(indexPath, index);
+  return index;
+}
+
+function docsForEvents(session, events) {
+  const indexedKinds = new Set([
+    EVENT_KINDS.PROMPT_SUBMITTED,
+    EVENT_KINDS.RESPONSE_GENERATED,
+    EVENT_KINDS.TOOL_CALLED
+  ]);
+  return events
+    .filter((event) => indexedKinds.has(event.kind))
+    .map((event) => {
+      const renderedText = renderEventText(event);
+      if (!String(renderedText || "").trim()) return null;
+      return {
+        id: event.eventId,
+        eventId: event.eventId,
+        eventKind: event.kind,
+        messageIndex: event.messageIndex,
+        sessionId: session.sessionId,
+        provider: event.provider || session.provider,
+        sourceType: event.sourceType || session.sourceType || "",
+        repoCanonical: event.repoCanonical || session.repoCanonical || "",
+        repoDisplay: displayRepoLabel(session),
+        scopeCanonical: event.scopeCanonical || session.scopeCanonical || "",
+        cwd: session.cwd || "",
+        title: session.title || event.indexed?.title || "",
+        eventTitle: event.indexed?.title || "",
+        startedAt: session.startedAt,
+        occurredAt: event.occurredAt,
+        role: event.role || "",
+        text: renderedText,
+        matchedText: renderedText,
+        path: session.conversationPath || session.transcriptPath,
+        eventPath: session.eventPath || ""
+      };
+    })
+    .filter(Boolean);
+}
+
+function docsForTranscript(session, messages) {
+  const docs = [];
+  for (const message of messages) {
+    docs.push({
+      id: `${session.sessionId}:${message.index}:${docs.length}`,
+      sessionId: session.sessionId,
+      provider: session.provider,
+      sourceType: session.sourceType || "",
+      repoCanonical: session.repoCanonical || "",
+      repoDisplay: displayRepoLabel(session),
+      scopeCanonical: session.scopeCanonical || "",
+      cwd: session.cwd || "",
+      title: session.title || "",
+      startedAt: session.startedAt,
+      occurredAt: message.timestamp || session.startedAt,
+      messageIndex: message.index,
+      role: message.role,
+      text: message.content,
+      matchedText: message.content,
+      path: session.transcriptPath
+    });
+  }
+  return docs;
+}
+
+function loadIndex(env = process.env) {
+  const indexPath = paths(env).index;
+  const existing = readJson(indexPath, null);
+  if (existing && existing.version === 2 && !indexIsStale(indexPath, env)) return existing;
+  return buildIndex(env);
+}
+
+function searchPastSessions(query, options = {}, env = process.env) {
+  try {
+    const eventResults = searchIndexedSessions(query, options, env);
+    if (eventResults.length) return eventResults;
+  } catch {
+    // Fall through to the legacy markdown path below.
+  }
+  return searchMarkdownSessions(query, options, env);
+}
+
+function searchMarkdownSessions(query, options = {}, env = process.env) {
+  const limit = Math.max(1, Math.min(Number(options.limit || 10), 50));
+  const includeWebChats = Boolean(options.includeWebChats);
+  const filter = normalizeSessionFilter(options);
+  const repo = filter.repo || inferCallingRepo(options.cwd || process.cwd());
+  const since = parseSinceFilter(options.since);
+  const queryTokens = tokenize(query);
+  const phrase = String(query || "").trim().toLowerCase();
+  if (!queryTokens.length && !phrase) return [];
+
+  const sessions = listSessions(env).filter((session) => {
+    if (!matchesSessionFilter(session, { ...filter, includeWebChats, since })) return false;
+    const conversationPath = ensureConversationMarkdown(session, env);
+    const searchPath = conversationPath || session.transcriptPath;
+    session._searchPath = searchPath;
+    return Boolean(searchPath && fs.existsSync(searchPath));
+  });
+  if (!sessions.length) return [];
+
+  const sessionByPath = new Map();
+  for (const session of sessions) {
+    sessionByPath.set(path.resolve(session._searchPath), session);
+  }
+
+  const matches = ripgrepMatches(queryTokens, [...sessionByPath.keys()]) || jsLineMatches(queryTokens, [...sessionByPath.keys()]);
+  const ranked = [];
+  const seen = new Set();
+  for (const match of matches) {
+    const session = sessionByPath.get(path.resolve(match.path));
+    if (!session) continue;
+    const key = `${session.sessionId}:${match.line}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    const excerptText = readLineWindow(match.path, match.line, 4);
+    const lower = excerptText.toLowerCase();
+    const matchedTokens = queryTokens.filter((token) => lower.includes(token));
+    let score = matchedTokens.length * 5 + (phrase && lower.includes(phrase) ? 10 : 0);
+    if (!options.repo && repo && session.repoCanonical === repo) score *= 1.25;
+    ranked.push({
+      session_id: session.sessionId,
+      provider: session.provider,
+      source_type: session.sourceType || undefined,
+      repo: session.repoCanonical || undefined,
+      repo_display: displayRepoLabel(session),
+      scope: session.scopeCanonical || undefined,
+      cwd: session.cwd || undefined,
+      title: session.title || undefined,
+      started_at: session.startedAt,
+      role: inferRoleFromMarkdown(match.path, match.line),
+      excerpt: excerptText.replace(/\s+/g, " ").trim(),
+      score: Number(score.toFixed(4)),
+      session_link: session._searchPath
+    });
+  }
+
+  ranked.sort((a, b) => b.score - a.score || String(b.started_at).localeCompare(String(a.started_at)));
+  return ranked.slice(0, limit);
+}
+
+function searchIndexedSessions(query, options = {}, env = process.env) {
+  const limit = Math.max(1, Math.min(Number(options.limit || 10), 50));
+  const includeWebChats = Boolean(options.includeWebChats);
+  const filter = normalizeSessionFilter(options);
+  const repo = filter.repo || inferCallingRepo(options.cwd || process.cwd());
+  const since = parseSinceFilter(options.since);
+  const index = loadIndex(env);
+  const queryTokens = tokenize(query);
+  const phrase = String(query || "").trim().toLowerCase();
+  if (!queryTokens.length && !phrase) return [];
+
+  const scored = [];
+  for (const doc of index.docs || []) {
+    if (!matchesSessionFilter(doc, { ...filter, includeWebChats, since })) continue;
+
+    let score = bm25Score(doc, queryTokens, index);
+    if (phrase && doc.text.toLowerCase().includes(phrase)) score += 2.5;
+    if (!options.repo && repo && doc.repoCanonical === repo) score *= 1.25;
+    if (score > 0) scored.push({ doc, score });
+  }
+
+  scored.sort((a, b) => b.score - a.score || String(b.doc.occurredAt || b.doc.startedAt).localeCompare(String(a.doc.occurredAt || a.doc.startedAt)));
+  const bySession = new Map();
+  for (const item of scored) {
+    if (!bySession.has(item.doc.sessionId)) bySession.set(item.doc.sessionId, item);
+  }
+  return [...bySession.values()].slice(0, limit).map(({ doc, score }) => ({
+    session_id: doc.sessionId,
+    provider: doc.provider,
+    source_type: doc.sourceType || undefined,
+    repo: doc.repoCanonical || undefined,
+    repo_display: doc.repoDisplay || doc.repoCanonical || undefined,
+    scope: doc.scopeCanonical || undefined,
+    cwd: doc.cwd || undefined,
+    title: doc.title || undefined,
+    started_at: doc.startedAt,
+    role: doc.role,
+    event_id: doc.eventId || undefined,
+    event_kind: doc.eventKind || undefined,
+    message_index: doc.messageIndex ?? undefined,
+    matched_text: doc.matchedText ? excerpt(doc.matchedText, queryTokens) : undefined,
+    excerpt: excerpt(doc.text, queryTokens),
+    score: Number(score.toFixed(4)),
+    session_link: doc.path
+  }));
+}
+
+function ripgrepMatches(queryTokens, files) {
+  if (!queryTokens.length || !files.length) return null;
+  const pattern = queryTokens.map(escapeRegex).join("|");
+  const result = spawnSync(
+    "rg",
+    ["--json", "--ignore-case", "--line-number", "-e", pattern, "--", ...files],
+    { encoding: "utf8", maxBuffer: 1024 * 1024 * 50 }
+  );
+  if (result.error && result.error.code === "ENOENT") return null;
+  if (result.status !== 0 && result.status !== 1) return null;
+  const matches = [];
+  for (const line of String(result.stdout || "").split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (event.type !== "match") continue;
+    const file = event.data?.path?.text;
+    const lineNumber = event.data?.line_number;
+    if (file && lineNumber) matches.push({ path: file, line: lineNumber });
+  }
+  return matches;
+}
+
+function jsLineMatches(queryTokens, files) {
+  const matches = [];
+  for (const file of files) {
+    let lines;
+    try {
+      lines = fs.readFileSync(file, "utf8").split(/\r?\n/);
+    } catch {
+      continue;
+    }
+    for (let index = 0; index < lines.length; index++) {
+      const lower = lines[index].toLowerCase();
+      if (queryTokens.some((token) => lower.includes(token))) matches.push({ path: file, line: index + 1 });
+    }
+  }
+  return matches;
+}
+
+function readLineWindow(file, lineNumber, radius = 2) {
+  try {
+    const lines = fs.readFileSync(file, "utf8").split(/\r?\n/);
+    const start = Math.max(0, lineNumber - 1 - radius);
+    const end = Math.min(lines.length, lineNumber + radius);
+    return lines.slice(start, end).join("\n").trim();
+  } catch {
+    return "";
+  }
+}
+
+function inferRoleFromMarkdown(file, lineNumber) {
+  try {
+    const lines = fs.readFileSync(file, "utf8").split(/\r?\n/);
+    for (let index = Math.min(lineNumber - 1, lines.length - 1); index >= 0; index--) {
+      const match = lines[index].match(/^##\s+([A-Za-z_ -]+)\s+-\s+/);
+      if (match) return match[1].trim().toLowerCase().replace(/\s+/g, "_");
+    }
+  } catch {
+    // Unknown role.
+  }
+  return "unknown";
+}
+
+function escapeRegex(value) {
+  return String(value).replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
+}
+
+function bm25Score(doc, queryTokens, index) {
+  const k1 = 1.2;
+  const b = 0.75;
+  const n = Math.max(1, index.docCount || 1);
+  const avgdl = Math.max(1, index.avgDocLength || 1);
+  let score = 0;
+  for (const token of queryTokens) {
+    const tf = doc.tf?.[token] || 0;
+    if (!tf) continue;
+    const df = index.df?.[token] || 0;
+    const idf = Math.log(1 + (n - df + 0.5) / (df + 0.5));
+    score += idf * ((tf * (k1 + 1)) / (tf + k1 * (1 - b + b * (doc.length / avgdl))));
+  }
+  return score;
+}
+
+function chunkText(text, maxTokens = 220, overlap = 40) {
+  const words = String(text || "").split(/\s+/).filter(Boolean);
+  if (words.length <= maxTokens) return [words.join(" ")].filter(Boolean);
+  const chunks = [];
+  for (let start = 0; start < words.length; start += maxTokens - overlap) {
+    chunks.push(words.slice(start, start + maxTokens).join(" "));
+  }
+  return chunks;
+}
+
+function tokenize(text) {
+  return String(text || "")
+    .toLowerCase()
+    .match(/[a-z0-9_./:-]{2,}/g)?.filter((token) => token.length <= MAX_INDEX_TOKEN_LENGTH && !STOP_WORDS.has(token)) || [];
+}
+
+function normalizeIndexText(text) {
+  let value = String(text || "");
+  if (!value.trim()) return "";
+  value = value.replace(/data:image\/[a-z0-9.+-]+;base64,[a-z0-9+/=_-]{512,}/gi, "[image data omitted]");
+  value = value.replace(/"data"\s*:\s*"[a-z0-9+/=_-]{512,}"/gi, '"data":"[binary data omitted]"');
+  value = value.replace(/\b[a-z0-9+/=_-]{2048,}\b/gi, "[encoded data omitted]");
+  if (value.length > MAX_INDEX_TEXT_CHARS) value = `${value.slice(0, MAX_INDEX_TEXT_CHARS)} [truncated]`;
+  return value.trim();
+}
+
+function excerpt(text, queryTokens) {
+  const value = String(text || "").replace(/\s+/g, " ").trim();
+  if (value.length <= 360) return value;
+  const lower = value.toLowerCase();
+  let position = -1;
+  for (const token of queryTokens) {
+    position = lower.indexOf(token);
+    if (position >= 0) break;
+  }
+  const start = Math.max(0, position - 120);
+  const end = Math.min(value.length, start + 360);
+  return `${start > 0 ? "..." : ""}${value.slice(start, end)}${end < value.length ? "..." : ""}`;
+}
+
+function inferCallingRepo(cwd) {
+  try {
+    return canonicalRepo(cwd).key;
+  } catch {
+    return "";
+  }
+}
+
+function listHistorySessions(options = {}, env = process.env) {
+  const since = parseSinceFilter(options.since);
+  const includeWebChats = options.includeWebChats !== false;
+  const filter = normalizeSessionFilter(options);
+  return listSessions(env)
+    .filter((session) => matchesSessionFilter(session, { ...filter, includeWebChats, since }))
+    .map(historySessionSummary)
+    .sort((a, b) => String(historySessionSortTime(b)).localeCompare(String(historySessionSortTime(a))));
+}
+
+function historySessionSummary(session) {
+  const time = sessionHistoryTime(session);
+  return {
+    session_id: session.sessionId,
+    provider: session.provider,
+    source_type: session.sourceType || undefined,
+    repo: session.repoCanonical || undefined,
+    repo_display: displayRepoLabel(session),
+    scope: session.scopeCanonical || undefined,
+    chat_virtual_repo: session.chatVirtualRepo || undefined,
+    chat_display_path: session.chatDisplayPath || undefined,
+    chat_account_id: session.chatAccountId || undefined,
+    chat_username: session.chatUsername || undefined,
+    chat_display_name: session.chatDisplayName || undefined,
+    chat_project_path: session.chatProjectPath || undefined,
+    conversation_kind: session.conversationKind || undefined,
+    pinned: Boolean(session.pinned) || undefined,
+    cwd: session.cwd || undefined,
+    title: session.title || undefined,
+    started_at: time.startedAt || undefined,
+    ended_at: time.endedAt || undefined,
+    time_status: time.status || undefined,
+    archived_at: session.importedAt || undefined,
+    messages: session.messageCount,
+    user_messages: Number.isFinite(Number(session.userMessageCount)) ? Number(session.userMessageCount) : undefined,
+    usage: session.usage || undefined,
+    models: session.models || undefined,
+    conversation: session.conversationPath,
+    transcript: session.transcriptPath
+  };
+}
+
+function historySessionSortTime(session) {
+  if (session.time_status === "recovered-time-unknown") return "";
+  return session.ended_at || session.started_at || "";
+}
+
+function displayRepoLabel(session) {
+  const chat = displayChatScopeLabel(session);
+  if (chat) return chat;
+  const repo = session.repoCanonical || session.repo || "";
+  if (repo && !repo.startsWith("path:")) return repo;
+  if (session.scopeCanonical || session.scope) return displayScopeLabel(session.scopeCanonical || session.scope);
+  const cwd = session.cwd || "";
+  if (cwd) return compactHomePath(cwd);
+  return repo || "unknown";
+}
+
+function displayScopeLabel(scope) {
+  return {
+    "claude-desktop/uncategorized": "Claude Desktop (uncategorized)",
+    "claude-code-desktop/uncategorized": "Claude Code Desktop (uncategorized)"
+  }[scope] || scope;
+}
+
+function displayChatScopeLabel(session) {
+  if (!isWebChatSession(session)) return "";
+  if (session.chatDisplayPath) return session.chatDisplayPath;
+  const display = session.chatDisplayName || session.chatUsername || session.chatAccountId || "account";
+  const project = session.chatProjectPath || chatProjectPathFromScope(session.scopeCanonical || session.scope || "");
+  return project ? `/${display}/${project}` : `/${display}/`;
+}
+
+function isWebChatSession(session) {
+  const provider = session?.provider || "";
+  const scope = session?.scopeCanonical || session?.scope || "";
+  return provider === "chatgpt" || provider === "claude_web" || /^\[(chatgpt|claude)\]conversations\//.test(scope);
+}
+
+function chatProjectPathFromScope(scope) {
+  const parts = String(scope || "").split("/").filter(Boolean);
+  return parts.length > 2 ? parts.slice(2).join("/") : "";
+}
+
+function compactHomePath(value) {
+  const resolved = path.resolve(String(value || ""));
+  const home = os.homedir();
+  if (resolved === home) return "~";
+  if (resolved.startsWith(`${home}${path.sep}`)) return `~/${resolved.slice(home.length + 1)}`;
+  return resolved;
+}
+
+function listRecentSessions(limit = 20, options = {}, env = process.env) {
+  return listHistorySessions(options, env).slice(0, limit);
+}
+
+function normalizeSessionFilter(options = {}) {
+  const providerInput = options.provider || options.source || "";
+  const normalizedProvider = normalizeProviderFilter(providerInput);
+  const explicitSourceType = options.sourceType || options.source_type || "";
+  return {
+    provider: normalizedProvider.provider,
+    sourceType: explicitSourceType || normalizedProvider.sourceType || "",
+    sourceTypes: explicitSourceType ? [explicitSourceType] : normalizedProvider.sourceTypes || [],
+    repo: options.repo || ""
+  };
+}
+
+function normalizeProviderFilter(value) {
+  const key = String(value || "").trim().toLowerCase().replace(/[-\s]+/g, "_");
+  const aliases = {
+    claude: { provider: "claude_code" },
+    claude_code: { provider: "claude_code" },
+    claude_cli: { provider: "claude_code" },
+    claude_desktop: { provider: "claude_desktop" },
+    claude_code_desktop: { provider: "claude_desktop", sourceType: "claude-code-desktop-metadata", sourceTypes: ["claude-code-desktop-metadata"] },
+    claude_workspace: { provider: "claude_desktop", sourceType: "claude-workspace-desktop", sourceTypes: ["claude-workspace-desktop"] },
+    claude_workspace_desktop: { provider: "claude_desktop", sourceType: "claude-workspace-desktop", sourceTypes: ["claude-workspace-desktop"] },
+    claude_sdk: { provider: "claude_sdk" },
+    codex: { provider: "codex" },
+    codex_cli: { provider: "codex", sourceType: "codex-cli-history", sourceTypes: ["codex-cli-history", "cli-history"] },
+    codex_desktop: { provider: "codex", sourceType: "codex-desktop-history", sourceTypes: ["codex-desktop-history"] },
+    cursor: { provider: "cursor" },
+    cline: { provider: "cline", sourceType: "cline-task-history", sourceTypes: ["cline-task-history"] },
+    opencode: { provider: "opencode", sourceType: "opencode-history", sourceTypes: ["opencode-history"] },
+    aider: { provider: "aider", sourceType: "aider-chat-history", sourceTypes: ["aider-chat-history"] },
+    devin: { provider: "devin" },
+    devin_cli: { provider: "devin", sourceType: "devin-cli-history", sourceTypes: ["devin-cli-history"] },
+    gemini: { provider: "gemini_cli" },
+    gemini_cli: { provider: "gemini_cli" },
+    windsurf: { provider: "windsurf" },
+    antigravity: { provider: "antigravity" },
+    chatgpt: { provider: "chatgpt" },
+    claude_web: { provider: "claude_web" },
+    claude_ai: { provider: "claude_web" }
+  };
+  return aliases[key] || { provider: key };
+}
+
+function matchesSessionFilter(session, filter) {
+  if (filter.provider && session.provider !== filter.provider) return false;
+  const sourceTypes = filter.sourceTypes?.length ? filter.sourceTypes : filter.sourceType ? [filter.sourceType] : [];
+  if (sourceTypes.length && !sourceTypes.includes(session.sourceType)) return false;
+  if (!filter.includeWebChats && session.scopeCanonical && session.storageScope !== "local") return false;
+  if (filter.repo && !matchesRepoFilter(session, filter.repo)) return false;
+  if (filter.since) {
+    const time = sessionHistoryTime(session);
+    const comparable = time.startedAt || time.endedAt;
+    if (!comparable || new Date(comparable) < filter.since) return false;
+  }
+  return true;
+}
+
+function matchesRepoFilter(session, repoFilter) {
+  const wanted = String(repoFilter || "").toLowerCase();
+  if (!wanted) return true;
+  return [session.repoCanonical, session.repo, session.scopeCanonical, session.scope, session.chatVirtualRepo, session.chatDisplayPath, session.chatDisplayName, session.chatUsername, session.cwd, displayRepoLabel(session)]
+    .filter(Boolean)
+    .map((value) => String(value).toLowerCase())
+    .some((value) => value === wanted || value.includes(wanted));
+}
+
+function reindexIfNeeded(env = process.env) {
+  const cfg = loadConfig(env);
+  if (cfg.index.paused) return { paused: true, index: readJson(paths(env).index, null) };
+  const indexPath = paths(env).index;
+  try {
+    const stat = fs.statSync(indexPath);
+    if (Date.now() - stat.mtimeMs < 10 * 60 * 1000) return { paused: false, index: readJson(indexPath, null) };
+  } catch {
+    // Missing index: build below.
+  }
+  return { paused: false, index: buildIndex(env) };
+}
+
+function indexIsStale(indexPath, env = process.env) {
+  let indexStat;
+  try {
+    indexStat = fs.statSync(indexPath);
+  } catch {
+    return true;
+  }
+  for (const session of listSessions(env)) {
+    try {
+      if (fs.statSync(session.transcriptPath).mtimeMs > indexStat.mtimeMs) return true;
+      if (fs.statSync(session.metadataPath).mtimeMs > indexStat.mtimeMs) return true;
+      if (session.eventPath && fs.existsSync(session.eventPath) && fs.statSync(session.eventPath).mtimeMs > indexStat.mtimeMs) return true;
+    } catch {
+      return true;
+    }
+  }
+  return false;
+}
+
+function parseSinceFilter(value) {
+  if (!value || value === "all") return null;
+  const match = String(value).match(/^(\d+)([dhm])$/);
+  if (!match) {
+    const date = new Date(value);
+    return Number.isNaN(date.getTime()) ? null : date;
+  }
+  const amount = Number(match[1]);
+  const unit = match[2];
+  const ms = unit === "d" ? amount * 86400000 : unit === "h" ? amount * 3600000 : amount * 60000;
+  return new Date(Date.now() - ms);
+}
+
+const MAX_INDEX_TEXT_CHARS = 50000;
+const MAX_INDEX_TOKEN_LENGTH = 128;
+
+const STOP_WORDS = new Set([
+  "the",
+  "and",
+  "for",
+  "that",
+  "this",
+  "with",
+  "from",
+  "you",
+  "are",
+  "was",
+  "were",
+  "have",
+  "has",
+  "had"
+]);
+
+module.exports = {
+  buildIndex,
+  chunkText,
+  listHistorySessions,
+  listRecentSessions,
+  loadIndex,
+  reindexIfNeeded,
+  sessionHistoryTime,
+  searchPastSessions,
+  tokenize
+};

package/src/sources.js

@@ -0,0 +1,86 @@
+"use strict";
+
+const SOURCE_GROUPS = [
+  {
+    group: "OpenAI",
+    sources: [
+      { source: "codex-cli", provider: "codex", sourceType: "codex-cli-history", label: "Codex CLI" },
+      { source: "codex-desktop", provider: "codex", sourceType: "codex-desktop-history", label: "Codex Desktop" },
+      { source: "chatgpt", provider: "chatgpt", label: "ChatGPT" }
+    ]
+  },
+  {
+    group: "Anthropic",
+    sources: [
+      { source: "claude", provider: "claude_code", label: "Claude Code CLI" },
+      { source: "claude-code-desktop", provider: "claude_desktop", sourceType: "claude-code-desktop-metadata", label: "Claude Code Desktop" },
+      { source: "claude-workspace", provider: "claude_desktop", sourceType: "claude-workspace-desktop", label: "Claude Workspace" },
+      { source: "claude-web", provider: "claude_web", label: "Claude.ai" },
+      { source: "claude-sdk", provider: "claude_sdk", label: "Claude SDK jobs" }
+    ]
+  },
+  {
+    group: "Google",
+    sources: [
+      { source: "gemini-cli", provider: "gemini_cli", label: "Gemini CLI" },
+      { source: "antigravity", provider: "antigravity", label: "Antigravity" }
+    ]
+  },
+  {
+    group: "Cognition",
+    sources: [
+      { source: "devin-cli", provider: "devin", sourceType: "devin-cli-history", label: "Devin CLI" }
+    ]
+  },
+  {
+    group: "Other",
+    sources: [
+      { source: "cursor", provider: "cursor", label: "Cursor" },
+      { source: "cline", provider: "cline", sourceType: "cline-task-history", label: "Cline" },
+      { source: "opencode", provider: "opencode", sourceType: "opencode-history", label: "OpenCode" },
+      { source: "aider", provider: "aider", sourceType: "aider-chat-history", label: "Aider" }
+    ]
+  }
+];
+
+const DISABLED_IMPORT_SOURCES = new Set(["windsurf"]);
+
+const DISABLED_IMPORT_SOURCE_MESSAGES = {
+  windsurf:
+    "Windsurf import is disabled because current Cascade transcripts are encrypted binary stores. agentlog can detect those sessions, but cannot archive readable conversation text yet."
+};
+
+const IMPORT_SOURCE_ORDER = [
+  "codex-cli",
+  "codex-desktop",
+  "claude",
+  "claude-code-desktop",
+  "claude-workspace",
+  "gemini-cli",
+  "antigravity",
+  "devin-cli",
+  "cursor",
+  "cline",
+  "opencode",
+  "aider"
+];
+
+const HISTORY_PROVIDER_OPTIONS = SOURCE_GROUPS.flatMap((group) => group.sources);
+
+function enabledImportSources(sources) {
+  return (sources || []).filter((source) => !DISABLED_IMPORT_SOURCES.has(source));
+}
+
+function sourceLabel(source) {
+  return HISTORY_PROVIDER_OPTIONS.find((item) => item.source === source)?.label || source;
+}
+
+module.exports = {
+  DISABLED_IMPORT_SOURCE_MESSAGES,
+  DISABLED_IMPORT_SOURCES,
+  HISTORY_PROVIDER_OPTIONS,
+  IMPORT_SOURCE_ORDER,
+  SOURCE_GROUPS,
+  enabledImportSources,
+  sourceLabel
+};