@threadbase-sh/scanner 0.7.2

package/dist/index.cjs

@@ -0,0 +1,1340 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ConversationScanner: () => ConversationScanner,
+  DEFAULT_TIERS: () => DEFAULT_TIERS,
+  SearchIndexer: () => SearchIndexer,
+  VALID_SORT_ORDERS: () => VALID_SORT_ORDERS,
+  applyAccountFilter: () => applyAccountFilter,
+  applyIncludeFilter: () => applyIncludeFilter,
+  applyPagination: () => applyPagination,
+  applyProjectFilter: () => applyProjectFilter,
+  applySinceFilter: () => applySinceFilter,
+  applySort: () => applySort,
+  cleanSystemTags: () => cleanSystemTags,
+  createLogger: () => createLogger,
+  detectDefaultProfile: () => detectDefaultProfile,
+  getConversation: () => getConversation,
+  getLogger: () => getLogger,
+  getProjectsDir: () => getProjectsDir,
+  loadProfiles: () => loadProfiles,
+  readGitBranch: () => readGitBranch,
+  resetDefaultScanner: () => resetDefaultScanner,
+  resolveConfigDir: () => resolveConfigDir,
+  resolveTier: () => resolveTier,
+  saveProfiles: () => saveProfiles,
+  scan: () => scan,
+  search: () => search,
+  setLogger: () => setLogger
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/filters.ts
+function applySort(metas, order) {
+  const out = [...metas];
+  switch (order) {
+    case "recent":
+      out.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+      break;
+    case "oldest":
+      out.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+      break;
+    case "messages-desc":
+      out.sort((a, b) => b.messageCount - a.messageCount);
+      break;
+    case "messages-asc":
+      out.sort((a, b) => a.messageCount - b.messageCount);
+      break;
+    case "alpha":
+      out.sort((a, b) => {
+        const cmp = a.projectName.localeCompare(b.projectName);
+        return cmp !== 0 ? cmp : a.preview.localeCompare(b.preview);
+      });
+      break;
+  }
+  return out;
+}
+function applySinceFilter(metas, since) {
+  const cutoff = parseSinceCutoff(since);
+  return metas.filter((m) => new Date(m.timestamp).getTime() >= cutoff.getTime());
+}
+function applyIncludeFilter(metas, include) {
+  switch (include) {
+    case "all":
+      return metas;
+    case "conversations":
+      return metas.filter((m) => !m.isSubagent && !m.isTeammate);
+    case "subagents":
+      return metas.filter((m) => m.isSubagent);
+    case "teammates":
+      return metas.filter((m) => m.isTeammate);
+  }
+}
+function applyProjectFilter(metas, project) {
+  const lower = project.toLowerCase();
+  return metas.filter(
+    (m) => m.projectPath.toLowerCase().includes(lower) || m.projectName.toLowerCase().includes(lower)
+  );
+}
+function applyAccountFilter(metas, account) {
+  return metas.filter((m) => m.account === account);
+}
+function applyPagination(items, limit, offset) {
+  return {
+    items: items.slice(offset, offset + limit),
+    total: items.length
+  };
+}
+function parseSinceCutoff(value) {
+  const s = value.trim();
+  if (!s) throw new Error("Empty --since value");
+  const isoMatch = s.match(/^\d{4}-\d{2}-\d{2}$/);
+  if (isoMatch) {
+    const d = /* @__PURE__ */ new Date(`${s}T00:00:00Z`);
+    if (!Number.isNaN(d.getTime())) return d;
+  }
+  const durationMatch = s.match(/^(\d+)([hdw])$/);
+  if (!durationMatch) {
+    throw new Error(
+      `Invalid --since value "${s}": expected duration like "7d", "24h", "2w" or ISO date "2006-01-02"`
+    );
+  }
+  const n = parseInt(durationMatch[1], 10);
+  const unit = durationMatch[2];
+  let ms;
+  switch (unit) {
+    case "h":
+      ms = n * 60 * 60 * 1e3;
+      break;
+    case "d":
+      ms = n * 24 * 60 * 60 * 1e3;
+      break;
+    case "w":
+      ms = n * 7 * 24 * 60 * 60 * 1e3;
+      break;
+    default:
+      throw new Error(`Invalid unit "${unit}"`);
+  }
+  return new Date(Date.now() - ms);
+}
+
+// src/git.ts
+var import_fs = require("fs");
+var import_path = require("path");
+
+// src/logger.ts
+var import_pino = __toESM(require("pino"), 1);
+var currentLogger = (0, import_pino.default)({ level: "silent" });
+function createLogger(options) {
+  if (options && typeof options.child === "function") {
+    return options;
+  }
+  return (0, import_pino.default)(options ?? { level: "silent" });
+}
+function setLogger(logger) {
+  currentLogger = logger;
+}
+function getLogger() {
+  return currentLogger;
+}
+
+// src/git.ts
+var REF_PREFIX = "ref: refs/heads/";
+var MAX_DEPTH = 6;
+function readGitBranch(projectPath) {
+  if (!projectPath) return null;
+  const log = getLogger();
+  let dir = projectPath;
+  let depth = 0;
+  while (depth < MAX_DEPTH) {
+    const headPath = (0, import_path.join)(dir, ".git", "HEAD");
+    try {
+      const content = (0, import_fs.readFileSync)(headPath, "utf-8").trim();
+      if (content.startsWith(REF_PREFIX)) {
+        const branch = content.slice(REF_PREFIX.length);
+        log.trace({ projectPath, dir, branch }, "git: branch resolved");
+        return branch;
+      }
+      if (content.length >= 7) {
+        log.trace({ projectPath, dir }, "git: detached HEAD");
+        return "(detached)";
+      }
+      return null;
+    } catch {
+    }
+    const parent = (0, import_path.dirname)(dir);
+    if (parent === dir) return null;
+    dir = parent;
+    depth++;
+  }
+  log.trace({ projectPath }, "git: no .git found within depth");
+  return null;
+}
+
+// src/indexer.ts
+var import_flexsearch = __toESM(require("flexsearch"), 1);
+var FlexSearch = import_flexsearch.default.default ?? import_flexsearch.default;
+var SearchIndexer = class {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  index;
+  documents = /* @__PURE__ */ new Map();
+  constructor() {
+    this.index = this.createIndex();
+  }
+  createIndex() {
+    return new FlexSearch.Document({
+      document: {
+        id: "id",
+        index: [
+          "content",
+          "projectName",
+          "projectPath",
+          "sessionId",
+          "sessionName",
+          "account",
+          "model",
+          "gitBranch",
+          "toolNames"
+        ],
+        store: ["id"]
+      },
+      tokenize: "forward",
+      resolution: 9,
+      cache: 100
+    });
+  }
+  addDocument(meta) {
+    this.documents.set(meta.id, meta);
+    this.index.add({
+      id: meta.id,
+      content: meta.contentSnippet,
+      projectName: meta.projectName,
+      projectPath: meta.projectPath,
+      sessionId: meta.sessionId,
+      sessionName: meta.sessionName,
+      account: meta.account,
+      model: meta.model || "",
+      gitBranch: meta.gitBranch || "",
+      toolNames: meta.toolNames.join(" ")
+    });
+  }
+  buildIndex(metas) {
+    this.clear();
+    for (const meta of metas) {
+      this.addDocument(meta);
+    }
+    getLogger().debug({ docCount: metas.length }, "indexer: built");
+  }
+  search(query, options) {
+    const limit = options?.limit ?? 50;
+    if (!query.trim()) {
+      return this.getRecent(limit);
+    }
+    const results = this.index.search(query, { limit: limit * 2, enrich: true });
+    const seen = /* @__PURE__ */ new Set();
+    const searchResults = [];
+    for (const fieldResult of results) {
+      if (!fieldResult.result) continue;
+      for (const item of fieldResult.result) {
+        const id = typeof item === "object" ? item.id : String(item);
+        if (seen.has(id)) continue;
+        seen.add(id);
+        const meta = this.documents.get(id);
+        if (!meta) continue;
+        const matches = this.generateMatches(meta, query);
+        searchResults.push({ meta, score: 1, matches });
+        if (searchResults.length >= limit) break;
+      }
+      if (searchResults.length >= limit) break;
+    }
+    return searchResults;
+  }
+  getRecent(limit) {
+    return Array.from(this.documents.values()).sort((a, b) => b.timestamp.localeCompare(a.timestamp)).slice(0, limit).map((meta) => ({
+      meta,
+      score: 1,
+      matches: [{ field: "timestamp", snippet: meta.preview }]
+    }));
+  }
+  generateMatches(meta, query) {
+    const matches = [];
+    const lowerQuery = query.toLowerCase();
+    const fields = [
+      ["contentSnippet", meta.contentSnippet],
+      ["projectName", meta.projectName],
+      ["sessionId", meta.sessionId],
+      ["sessionName", meta.sessionName],
+      ["account", meta.account],
+      ["model", meta.model || ""],
+      ["gitBranch", meta.gitBranch || ""],
+      ["toolNames", meta.toolNames.join(" ")]
+    ];
+    for (const [field, value] of fields) {
+      const idx = value.toLowerCase().indexOf(lowerQuery);
+      if (idx !== -1) {
+        const start = Math.max(0, idx - 80);
+        const end = Math.min(value.length, idx + query.length + 120);
+        let snippet = value.slice(start, end);
+        if (start > 0) snippet = `...${snippet}`;
+        if (end < value.length) snippet = `${snippet}...`;
+        matches.push({ field, snippet });
+      }
+    }
+    return matches.length > 0 ? matches : [{ field: "preview", snippet: meta.preview }];
+  }
+  getDocumentCount() {
+    return this.documents.size;
+  }
+  // Replace an already-indexed document in place. FlexSearch's `add` does not
+  // overwrite an existing id, so a single-file refresh must go through
+  // `update` to avoid stale matches lingering in the index.
+  updateDocument(meta) {
+    this.documents.set(meta.id, meta);
+    this.index.update({
+      id: meta.id,
+      content: meta.contentSnippet,
+      projectName: meta.projectName,
+      projectPath: meta.projectPath,
+      sessionId: meta.sessionId,
+      sessionName: meta.sessionName,
+      account: meta.account,
+      model: meta.model || "",
+      gitBranch: meta.gitBranch || "",
+      toolNames: meta.toolNames.join(" ")
+    });
+  }
+  removeDocument(id) {
+    this.documents.delete(id);
+    this.index.remove(id);
+  }
+  clear() {
+    this.documents.clear();
+    this.index = this.createIndex();
+    getLogger().trace("indexer: cleared");
+  }
+};
+
+// src/profiles.ts
+var import_promises = require("fs/promises");
+var import_os = require("os");
+var import_path2 = require("path");
+var PROFILES_FILE = "profiles.json";
+function resolveConfigDir(configDir) {
+  return configDir.replace(/^~/, (0, import_os.homedir)());
+}
+function getProjectsDir(profile) {
+  return (0, import_path2.join)(resolveConfigDir(profile.configDir), "projects");
+}
+async function detectDefaultProfile() {
+  return {
+    id: "default",
+    label: "Default",
+    configDir: (0, import_path2.join)((0, import_os.homedir)(), ".claude"),
+    enabled: true,
+    emoji: "\u{1F916}"
+  };
+}
+async function loadProfiles(configPath) {
+  const log = getLogger();
+  try {
+    const resolved = resolveConfigDir(configPath);
+    const data = await (0, import_promises.readFile)((0, import_path2.join)(resolved, PROFILES_FILE), "utf-8");
+    const profiles = JSON.parse(data);
+    log.debug({ configPath, count: profiles.length }, "profiles: loaded");
+    return profiles;
+  } catch (err) {
+    log.debug({ configPath, err }, "profiles: load failed, using default");
+    const defaultProfile = await detectDefaultProfile();
+    return [defaultProfile];
+  }
+}
+async function saveProfiles(profiles, configPath) {
+  const resolved = resolveConfigDir(configPath);
+  await (0, import_promises.mkdir)(resolved, { recursive: true });
+  await (0, import_promises.writeFile)((0, import_path2.join)(resolved, PROFILES_FILE), JSON.stringify(profiles, null, 2));
+  getLogger().debug({ configPath, count: profiles.length }, "profiles: saved");
+}
+
+// src/scanner.ts
+var import_fs3 = require("fs");
+
+// src/cache.ts
+var LRUCache = class {
+  map = /* @__PURE__ */ new Map();
+  capacity;
+  constructor(capacity) {
+    this.capacity = capacity;
+  }
+  get(key) {
+    const value = this.map.get(key);
+    if (value === void 0) return void 0;
+    this.map.delete(key);
+    this.map.set(key, value);
+    return value;
+  }
+  set(key, value) {
+    this.map.delete(key);
+    this.map.set(key, value);
+    if (this.map.size > this.capacity) {
+      const oldest = this.map.keys().next();
+      if (!oldest.done) this.map.delete(oldest.value);
+    }
+  }
+  has(key) {
+    return this.map.has(key);
+  }
+  delete(key) {
+    return this.map.delete(key);
+  }
+  clear() {
+    this.map.clear();
+  }
+  get size() {
+    return this.map.size;
+  }
+};
+
+// src/discovery.ts
+var import_fast_glob = __toESM(require("fast-glob"), 1);
+var import_promises2 = require("fs/promises");
+var EXCLUDED_SEGMENTS = ["/memory/", "/tool-results/"];
+var STAT_CONCURRENCY = 32;
+async function discoverJsonlFiles(dirs, onProgress) {
+  const log = getLogger();
+  const results = [];
+  for (const { projectsDir, account } of dirs) {
+    let filePaths;
+    try {
+      filePaths = await (0, import_fast_glob.default)("**/*.jsonl", {
+        cwd: projectsDir,
+        absolute: true,
+        dot: false
+      });
+    } catch (err) {
+      log.warn({ projectsDir, account, err }, "discovery: glob failed");
+      continue;
+    }
+    const filtered = filePaths.filter((fp) => !EXCLUDED_SEGMENTS.some((seg) => fp.includes(seg)));
+    let kept = 0;
+    let skippedEmpty = 0;
+    let skippedInaccessible = 0;
+    for (let i = 0; i < filtered.length; i += STAT_CONCURRENCY) {
+      const chunk = filtered.slice(i, i + STAT_CONCURRENCY);
+      const statted = await Promise.all(
+        chunk.map(async (filePath) => {
+          try {
+            const s = await (0, import_promises2.stat)(filePath);
+            return { filePath, size: s.size };
+          } catch (err) {
+            log.warn({ filePath, err }, "discovery: stat failed");
+            return { filePath, size: -1 };
+          }
+        })
+      );
+      for (const { filePath, size } of statted) {
+        if (size < 0) {
+          skippedInaccessible++;
+        } else if (size > 0) {
+          results.push({ filePath, account });
+          kept++;
+        } else {
+          skippedEmpty++;
+        }
+      }
+    }
+    log.debug(
+      {
+        projectsDir,
+        account,
+        globMatches: filePaths.length,
+        afterExclusions: filtered.length,
+        kept,
+        skippedEmpty,
+        skippedInaccessible
+      },
+      "discovery: directory scanned"
+    );
+    onProgress?.(results.length);
+  }
+  log.debug({ totalFiles: results.length, dirs: dirs.length }, "discovery: complete");
+  return results;
+}
+
+// src/parser.ts
+var import_fs2 = require("fs");
+var import_path3 = require("path");
+var import_readline = require("readline");
+
+// src/tags.ts
+var SYSTEM_TAGS = [
+  "system-reminder",
+  "command-name",
+  "command-message",
+  "command-args",
+  "ide_selection",
+  "ide_opened_file",
+  "local-command-stdout",
+  "local-command-caveat",
+  "retrieval_status",
+  "task_id",
+  "task_type",
+  "task-id",
+  "task-notification",
+  "fast_mode_info",
+  "persisted-output",
+  "tool_use_error",
+  "user-prompt-submit-hook",
+  "thinking",
+  "ask_user",
+  "teammate-message"
+];
+var SYSTEM_TAG_RE = new RegExp(`<(${SYSTEM_TAGS.join("|")})[^>]*>[\\s\\S]*?<\\/\\1>`, "g");
+function cleanSystemTags(text) {
+  return text.replace(SYSTEM_TAG_RE, "").replace(/[^\S\n]+/g, " ").replace(/\n{3,}/g, "\n\n").trim();
+}
+
+// src/parser.ts
+async function parseMeta(filePath, account, tier) {
+  const log = getLogger();
+  log.trace({ filePath, account, tier: tier.name }, "parseMeta: start");
+  let sessionId = "";
+  let badJsonLines = 0;
+  let sessionName = "";
+  let latestTimestamp = "";
+  let cwd = "";
+  let teamName = "";
+  let model = null;
+  let messageCount = 0;
+  let lastMessageSender = "user";
+  let isTeammate = false;
+  let firstUserSeen = false;
+  let firstMessage = null;
+  let lastMessage = null;
+  let lastPrompt = "";
+  const toolNameSet = /* @__PURE__ */ new Set();
+  const previewParts = [];
+  const snippetParts = [];
+  let snippetLength = 0;
+  let previewLength = 0;
+  const fileStream = (0, import_fs2.createReadStream)(filePath);
+  const rl = (0, import_readline.createInterface)({ input: fileStream, crlfDelay: Infinity });
+  try {
+    for await (const line of rl) {
+      if (!line.trim()) continue;
+      let entry;
+      try {
+        entry = JSON.parse(line);
+      } catch {
+        badJsonLines++;
+        continue;
+      }
+      if (entry.cwd && !cwd) cwd = entry.cwd;
+      if (entry.sessionId && !sessionId) sessionId = entry.sessionId;
+      if (entry.slug && !sessionName) sessionName = entry.slug;
+      if (entry.teamName && !teamName) teamName = entry.teamName;
+      if (entry.timestamp) {
+        const ts = entry.timestamp;
+        if (!latestTimestamp || ts > latestTimestamp) latestTimestamp = ts;
+      }
+      const type = entry.type;
+      if (type === "last-prompt") {
+        if (entry.lastPrompt && !lastPrompt) lastPrompt = entry.lastPrompt;
+        continue;
+      }
+      if (type !== "user" && type !== "assistant") continue;
+      if (entry.isMeta) continue;
+      if (model === null) {
+        const msg2 = entry.message;
+        if (msg2?.model) model = msg2.model;
+      }
+      if (type === "user" && !firstUserSeen) {
+        firstUserSeen = true;
+        if (isTeammateContent(entry.message?.content)) {
+          isTeammate = true;
+        }
+      }
+      const msg = entry.message;
+      const content = extractTextContent(msg?.content);
+      const hasToolUseResult = type === "user" && entry.toolUseResult != null;
+      const isOnlyToolResult = hasToolUseResult && isOnlyToolResultContent(msg?.content);
+      collectToolNames(msg?.content, toolNameSet);
+      if (content || isOnlyToolResult) {
+        messageCount++;
+        lastMessageSender = type;
+        if (content) {
+          const ts = entry.timestamp || "";
+          if (!firstMessage) {
+            firstMessage = { text: content.slice(0, 200), timestamp: ts };
+          }
+          lastMessage = { text: content.slice(0, 200), timestamp: ts };
+          if (previewLength < tier.previewMax) {
+            previewParts.push(content);
+            previewLength += content.length;
+          }
+          if (snippetLength < tier.snippetMax) {
+            const remaining = tier.snippetMax - snippetLength;
+            const chunk = content.length > remaining ? content.slice(0, remaining) : content;
+            snippetParts.push(chunk);
+            snippetLength += chunk.length;
+          }
+        }
+      }
+    }
+  } catch (err) {
+    log.warn({ filePath, err }, "parseMeta: read failed");
+    return null;
+  }
+  if (badJsonLines > 0) {
+    log.warn({ filePath, badJsonLines }, "parseMeta: skipped malformed JSON lines");
+  }
+  if (messageCount === 0) {
+    log.trace({ filePath }, "parseMeta: no messages");
+    return null;
+  }
+  const isSubagent = filePath.includes("/subagents/");
+  let parentSessionId = null;
+  if (isSubagent) {
+    const uuidDir = (0, import_path3.dirname)((0, import_path3.dirname)(filePath));
+    parentSessionId = (0, import_path3.join)((0, import_path3.dirname)(uuidDir), `${(0, import_path3.basename)(uuidDir)}.jsonl`);
+  }
+  const projectPath = cwd;
+  const preview = previewParts.join(" ").slice(0, tier.previewMax);
+  return {
+    id: filePath,
+    filePath,
+    sessionId: sessionId || (0, import_path3.basename)(filePath, ".jsonl"),
+    sessionName,
+    projectPath,
+    projectName: getShortProjectName(projectPath),
+    account,
+    timestamp: latestTimestamp || (/* @__PURE__ */ new Date()).toISOString(),
+    messageCount,
+    lastMessageSender,
+    preview,
+    contentSnippet: snippetParts.join(" "),
+    gitBranch: null,
+    model,
+    isSubagent,
+    parentSessionId,
+    isTeammate,
+    teamName: teamName || null,
+    toolNames: Array.from(toolNameSet),
+    firstMessage,
+    lastMessage,
+    lastPrompt: lastPrompt || void 0
+  };
+}
+async function parseConversation(filePath, account) {
+  const log = getLogger();
+  log.trace({ filePath, account }, "parseConversation: start");
+  const messages = [];
+  let badJsonLines = 0;
+  let sessionId = "";
+  let sessionName = "";
+  let latestTimestamp = "";
+  let cwd = "";
+  const textParts = [];
+  const pendingToolUses = /* @__PURE__ */ new Map();
+  const teamInfoMap = /* @__PURE__ */ new Map();
+  const turnDurations = [];
+  let lastPrompt = "";
+  const fileStream = (0, import_fs2.createReadStream)(filePath);
+  const rl = (0, import_readline.createInterface)({ input: fileStream, crlfDelay: Infinity });
+  try {
+    for await (const line of rl) {
+      if (!line.trim()) continue;
+      let entry;
+      try {
+        entry = JSON.parse(line);
+      } catch {
+        badJsonLines++;
+        continue;
+      }
+      if (entry.cwd && !cwd) cwd = entry.cwd;
+      if (entry.sessionId && !sessionId) sessionId = entry.sessionId;
+      if (entry.slug && !sessionName) sessionName = entry.slug;
+      if (entry.timestamp) {
+        const ts = entry.timestamp;
+        if (!latestTimestamp || ts > latestTimestamp) latestTimestamp = ts;
+      }
+      const type = entry.type;
+      if (type === "last-prompt") {
+        if (entry.lastPrompt && !lastPrompt) lastPrompt = entry.lastPrompt;
+        continue;
+      }
+      if (type === "system") {
+        if (entry.subtype === "turn_duration" && typeof entry.durationMs === "number") {
+          turnDurations.push({
+            durationMs: entry.durationMs,
+            messageCount: entry.messageCount || 0,
+            uuid: entry.uuid
+          });
+        }
+        continue;
+      }
+      if (type !== "user" && type !== "assistant") continue;
+      if (entry.isMeta) continue;
+      const msg = entry.message;
+      const toolUseBlocks = extractToolUseBlocks(msg?.content);
+      for (const block of toolUseBlocks) {
+        pendingToolUses.set(block.id, block);
+      }
+      const hasToolUseResult = type === "user" && entry.toolUseResult != null;
+      const isToolResultOnly = hasToolUseResult && isOnlyToolResultContent(msg?.content);
+      const content = extractTextContent(msg?.content);
+      const thinking = type === "assistant" ? extractThinking(msg?.content) : null;
+      const hasThinking = !!(thinking?.content || thinking?.signature);
+      if (content || isToolResultOnly || toolUseBlocks.length > 0 || hasThinking) {
+        const metadata = {};
+        if (msg?.model) metadata.model = msg.model;
+        if (msg?.stop_reason !== void 0) metadata.stopReason = msg.stop_reason;
+        if (entry.gitBranch) metadata.gitBranch = entry.gitBranch;
+        if (entry.version) metadata.version = entry.version;
+        const usage = msg?.usage;
+        if (usage) {
+          if (usage.input_tokens) metadata.inputTokens = usage.input_tokens;
+          if (usage.output_tokens) metadata.outputTokens = usage.output_tokens;
+          if (usage.cache_read_input_tokens)
+            metadata.cacheReadTokens = usage.cache_read_input_tokens;
+          if (usage.cache_creation_input_tokens)
+            metadata.cacheCreationTokens = usage.cache_creation_input_tokens;
+        }
+        const toolUseNames = extractToolUseNames(msg?.content);
+        if (toolUseNames.length > 0) metadata.toolUses = toolUseNames;
+        if (toolUseBlocks.length > 0) metadata.toolUseBlocks = toolUseBlocks;
+        if (isToolResultOnly) {
+          const toolResultBlocks = extractToolResultBlocks(msg?.content, pendingToolUses);
+          if (toolResultBlocks.length > 0) metadata.toolResults = toolResultBlocks;
+        }
+        if (entry.teamName) {
+          metadata.teamName = entry.teamName;
+          if (!teamInfoMap.has(metadata.teamName) && content) {
+            const info = parseTeammateMessageTag(content);
+            if (info) teamInfoMap.set(metadata.teamName, info);
+          }
+        }
+        const thinkingContent = thinking?.content || void 0;
+        const thinkingSignature = thinking?.signature || void 0;
+        const hasMetadata = Object.keys(metadata).length > 0;
+        messages.push({
+          role: type,
+          text: content || "",
+          timestamp: entry.timestamp || "",
+          uuid: entry.uuid || void 0,
+          metadata: hasMetadata ? metadata : void 0,
+          isToolResult: isToolResultOnly || void 0,
+          isThinking: thinkingContent || thinkingSignature ? true : void 0,
+          thinkingContent,
+          thinkingSignature,
+          parentUuid: entry.parentUuid !== void 0 ? entry.parentUuid : void 0,
+          requestId: type === "assistant" ? entry.requestId : void 0,
+          promptId: type === "user" ? entry.promptId : void 0,
+          isSidechain: typeof entry.isSidechain === "boolean" ? entry.isSidechain : void 0,
+          permissionMode: type === "user" ? entry.permissionMode : void 0,
+          hasImages: hasImageBlocks(msg?.content) || void 0,
+          attachment: entry.attachment !== void 0 ? entry.attachment : void 0
+        });
+        if (content) textParts.push(content);
+      }
+    }
+  } catch (err) {
+    log.warn({ filePath, err }, "parseConversation: read failed");
+    return null;
+  }
+  if (badJsonLines > 0) {
+    log.warn({ filePath, badJsonLines }, "parseConversation: skipped malformed JSON lines");
+  }
+  if (messages.length === 0) {
+    log.trace({ filePath }, "parseConversation: no messages");
+    return null;
+  }
+  log.debug({ filePath, messageCount: messages.length }, "parseConversation: complete");
+  if (teamInfoMap.size > 0) {
+    for (const msg of messages) {
+      if (msg.metadata?.teamName) {
+        const info = teamInfoMap.get(msg.metadata.teamName);
+        if (info) msg.metadata.teamInfo = info;
+      }
+    }
+  }
+  return {
+    id: filePath,
+    filePath,
+    projectPath: cwd,
+    projectName: getShortProjectName(cwd),
+    sessionId: sessionId || (0, import_path3.basename)(filePath, ".jsonl"),
+    sessionName,
+    messages,
+    fullText: textParts.join(" "),
+    timestamp: latestTimestamp || (/* @__PURE__ */ new Date()).toISOString(),
+    messageCount: messages.length,
+    account,
+    turnDurations: turnDurations.length > 0 ? turnDurations : void 0,
+    lastPrompt: lastPrompt || void 0
+  };
+}
+function extractTextContent(content) {
+  if (!content) return "";
+  if (typeof content === "string") return cleanSystemTags(content);
+  if (Array.isArray(content)) {
+    return content.map((item) => {
+      if (typeof item === "string") return item;
+      if (item?.type === "text" && item?.text) return item.text;
+      if (item?.type === "tool_result" && typeof item?.content === "string") return item.content;
+      return "";
+    }).filter(Boolean).map(cleanSystemTags).join(" ");
+  }
+  return "";
+}
+function extractToolUseNames(content) {
+  if (!Array.isArray(content)) return [];
+  return content.filter((item) => item?.type === "tool_use" && item?.name).map((item) => item.name);
+}
+function extractToolUseBlocks(content) {
+  if (!Array.isArray(content)) return [];
+  return content.filter((item) => item?.type === "tool_use" && item?.name && item?.id).map((item) => ({
+    id: item.id,
+    name: item.name,
+    input: item.input || {}
+  }));
+}
+var TOOL_NAME_TO_TYPE = {
+  Edit: "edit",
+  Write: "write",
+  Read: "read",
+  Bash: "bash",
+  Grep: "grep",
+  Glob: "glob",
+  Agent: "taskAgent",
+  TaskCreate: "taskCreate",
+  TaskUpdate: "taskUpdate"
+};
+function extractToolResultBlocks(content, pendingToolUses) {
+  if (!Array.isArray(content)) return [];
+  return content.filter((item) => item?.type === "tool_result" && item?.tool_use_id).map((item) => {
+    const toolName = pendingToolUses.get(item.tool_use_id)?.name ?? "";
+    return {
+      toolUseId: item.tool_use_id,
+      type: TOOL_NAME_TO_TYPE[toolName] ?? "generic",
+      content: typeof item.content === "string" ? { text: item.content } : item.content ?? {},
+      isError: typeof item.is_error === "boolean" ? item.is_error : void 0
+    };
+  });
+}
+function collectToolNames(content, toolSet) {
+  if (!Array.isArray(content)) return;
+  for (const item of content) {
+    if (item?.type === "tool_use" && item?.name) {
+      toolSet.add(item.name);
+    }
+  }
+}
+function isOnlyToolResultContent(content) {
+  if (!Array.isArray(content)) return false;
+  return content.length > 0 && content.every((item) => item?.type === "tool_result");
+}
+function isTeammateContent(content) {
+  const raw = typeof content === "string" ? content : Array.isArray(content) ? content.map(
+    (item) => typeof item === "string" ? item : item?.type === "text" ? item.text ?? "" : ""
+  ).join("") : "";
+  return raw.includes("<teammate-message");
+}
+function extractThinking(content) {
+  if (!Array.isArray(content)) return { content: "", signature: "" };
+  const blocks = content.filter((item) => item?.type === "thinking");
+  return {
+    content: blocks.map((b) => b.thinking).filter(Boolean).join("\n\n"),
+    signature: blocks.map((b) => b.signature).filter(Boolean).join("")
+  };
+}
+function hasImageBlocks(content) {
+  if (!Array.isArray(content)) return false;
+  return content.some(
+    (item) => item?.type === "image" && (item?.source?.type === "base64" || item?.file?.base64 !== void 0)
+  );
+}
+function parseTeammateMessageTag(content) {
+  const match = content.match(/<teammate-message\s+([^>]*)>/);
+  if (!match) return null;
+  const attrs = match[1];
+  const id = attrs.match(/teammate_id="([^"]*)"/)?.[1];
+  if (!id) return null;
+  const summary = attrs.match(/summary="([^"]*)"/)?.[1];
+  const color = attrs.match(/color="([^"]*)"/)?.[1];
+  return { teammateId: id, summary, color };
+}
+function getShortProjectName(fullPath) {
+  const parts = fullPath.split("/").filter(Boolean);
+  return parts.slice(-3).join("/");
+}
+
+// src/tiers.ts
+var DEFAULT_TIERS = {
+  standard: { name: "standard", previewMax: 200, snippetMax: 5e3 },
+  full: { name: "full", previewMax: 1200, snippetMax: 5e4 }
+};
+function resolveTier(tierName, customTiers) {
+  const tier = customTiers?.[tierName] ?? DEFAULT_TIERS[tierName];
+  if (!tier) {
+    throw new Error(
+      `Unknown tier "${tierName}". Available: ${Object.keys({ ...DEFAULT_TIERS, ...customTiers }).join(", ")}`
+    );
+  }
+  return tier;
+}
+
+// src/scanner.ts
+var BATCH_SIZE = 12;
+var DEFAULT_CONFIG_PATH = "~/.config/threadbase-scanner";
+var ConversationScanner = class {
+  metadataCache = /* @__PURE__ */ new Map();
+  conversationLRU;
+  sessionIdIndex = /* @__PURE__ */ new Map();
+  projects = /* @__PURE__ */ new Set();
+  indexer = new SearchIndexer();
+  // Tier the most recent scan() ran with, so refreshFile() re-parses a single
+  // file at the same content depth. Defaults to the standard tier.
+  lastTier = resolveTier("standard");
+  constructor(options) {
+    this.conversationLRU = new LRUCache(options?.conversationCacheSize ?? 5);
+  }
+  async scan(options = {}) {
+    const log = getLogger();
+    const startedAt = Date.now();
+    const profiles = await this.resolveProfiles(options.profiles);
+    const activeProfiles = profiles.filter((p) => p.enabled && p.scanHistory !== false);
+    const tier = resolveTier(options.tier ?? "standard", options.tiers);
+    this.lastTier = tier;
+    log.info(
+      {
+        activeProfiles: activeProfiles.length,
+        tier: tier.name,
+        sort: options.sort ?? "recent",
+        include: options.include ?? "all",
+        view: options.view ?? "flat"
+      },
+      "scan: start"
+    );
+    this.metadataCache.clear();
+    this.conversationLRU.clear();
+    this.sessionIdIndex.clear();
+    this.projects.clear();
+    this.indexer.clear();
+    const configDirs = activeProfiles.map((p) => ({
+      projectsDir: getProjectsDir(p),
+      account: p.id
+    }));
+    const files = await discoverJsonlFiles(configDirs);
+    const totalFiles = files.length;
+    let scanned = 0;
+    let parseFailures = 0;
+    const allMetas = [];
+    const gitBranchMemo = /* @__PURE__ */ new Map();
+    const resolveGitBranch = (projectPath) => {
+      let branch = gitBranchMemo.get(projectPath);
+      if (branch === void 0) {
+        branch = readGitBranch(projectPath);
+        gitBranchMemo.set(projectPath, branch);
+      }
+      return branch;
+    };
+    const { statCache } = options;
+    for (let i = 0; i < files.length; i += BATCH_SIZE) {
+      const batch = files.slice(i, i + BATCH_SIZE);
+      const results = await Promise.all(
+        batch.map(async ({ filePath, account }) => {
+          if (statCache) {
+            const cached = statCache.get(filePath);
+            if (cached) {
+              try {
+                const s = (0, import_fs3.statSync)(filePath);
+                if (s.mtimeMs === cached.stat.mtimeMs && s.size === cached.stat.size) {
+                  return cached.meta;
+                }
+              } catch {
+              }
+            }
+          }
+          try {
+            const meta = await parseMeta(filePath, account, tier);
+            if (meta) {
+              meta.gitBranch = resolveGitBranch(meta.projectPath);
+            }
+            return meta;
+          } catch (err) {
+            parseFailures++;
+            log.warn({ filePath, account, err }, "scan: parseMeta threw");
+            return null;
+          }
+        })
+      );
+      const batchMetas = [];
+      for (const meta of results) {
+        if (meta && meta.messageCount > 0) {
+          this.metadataCache.set(meta.id, meta);
+          this.sessionIdIndex.set(meta.sessionId, meta);
+          this.projects.add(meta.projectPath);
+          allMetas.push(meta);
+          batchMetas.push(meta);
+          this.indexer.addDocument(meta);
+        }
+      }
+      if (batchMetas.length > 0) {
+        options.onBatch?.(batchMetas);
+      }
+      scanned += batch.length;
+      log.debug({ scanned, totalFiles, batchKept: batchMetas.length }, "scan: batch complete");
+      options.onProgress?.(scanned, totalFiles);
+    }
+    let filtered = allMetas;
+    if (options.include && options.include !== "all") {
+      filtered = applyIncludeFilter(filtered, options.include);
+    }
+    if (options.project) {
+      filtered = applyProjectFilter(filtered, options.project);
+    }
+    if (options.account) {
+      filtered = applyAccountFilter(filtered, options.account);
+    }
+    if (options.since) {
+      filtered = applySinceFilter(filtered, options.since);
+    }
+    filtered = applySort(filtered, options.sort ?? "recent");
+    const total = filtered.length;
+    const conversations = this.transformView(filtered, options);
+    const elapsedMs = Date.now() - startedAt;
+    log.info(
+      {
+        totalFiles,
+        scanned,
+        kept: allMetas.length,
+        filteredTotal: total,
+        parseFailures,
+        elapsedMs
+      },
+      "scan: complete"
+    );
+    if (Array.isArray(conversations)) {
+      const limit = options.limit ?? 50;
+      const offset = options.offset ?? 0;
+      const paginated = applyPagination(conversations, limit, offset);
+      return { conversations: paginated.items, total, scanned };
+    }
+    return { conversations, total, scanned };
+  }
+  async search(query, options = {}) {
+    const log = getLogger();
+    log.debug({ query, indexSize: this.indexer.getDocumentCount() }, "search: start");
+    if (this.indexer.getDocumentCount() === 0) {
+      log.debug("search: index empty, triggering scan");
+      await this.scan({ ...options, limit: void 0, offset: void 0 });
+    }
+    let results = this.indexer.search(query, {
+      fields: options.fields,
+      limit: (options.limit ?? 50) * 2
+    });
+    if (options.include && options.include !== "all") {
+      results = results.filter((r) => {
+        switch (options.include) {
+          case "conversations":
+            return !r.meta.isSubagent && !r.meta.isTeammate;
+          case "subagents":
+            return r.meta.isSubagent;
+          case "teammates":
+            return r.meta.isTeammate;
+          default:
+            return true;
+        }
+      });
+    }
+    if (options.project) {
+      const lower = options.project.toLowerCase();
+      results = results.filter(
+        (r) => r.meta.projectPath.toLowerCase().includes(lower) || r.meta.projectName.toLowerCase().includes(lower)
+      );
+    }
+    if (options.account) {
+      results = results.filter((r) => r.meta.account === options.account);
+    }
+    if (options.since) {
+      const cutoff = parseSinceCutoff(options.since);
+      results = results.filter((r) => new Date(r.meta.timestamp).getTime() >= cutoff.getTime());
+    }
+    const limit = options.limit ?? 50;
+    const offset = options.offset ?? 0;
+    const sliced = results.slice(offset, offset + limit);
+    log.debug({ query, matched: results.length, returned: sliced.length }, "search: complete");
+    return sliced;
+  }
+  async getConversation(id, _options) {
+    const log = getLogger();
+    const cached = this.conversationLRU.get(id);
+    if (cached) {
+      log.debug({ id }, "getConversation: cache hit");
+      return cached;
+    }
+    const meta = this.metadataCache.get(id) ?? this.sessionIdIndex.get(id);
+    if (!meta) {
+      log.debug({ id }, "getConversation: not found in metadata");
+      return null;
+    }
+    log.debug({ id, filePath: meta.filePath }, "getConversation: cache miss, parsing");
+    try {
+      const conversation = await parseConversation(meta.filePath, meta.account);
+      if (conversation) {
+        this.conversationLRU.set(id, conversation);
+      }
+      return conversation;
+    } catch (err) {
+      log.warn({ id, filePath: meta.filePath, err }, "getConversation: parse failed");
+      return null;
+    }
+  }
+  // Return one bounded window of a conversation's messages plus the total
+  // message count, so a caller can serve the last page and scroll back without
+  // holding the whole conversation itself.
+  //
+  // The window is `[max(0, beforeIndex - limit), beforeIndex)` in chronological
+  // order; `beforeIndex` defaults to `total` (the newest page). `fromIndex` is
+  // the window's start index, so the caller can derive `has_more_older`
+  // (fromIndex > 0). Returns null when the id can't be resolved/parsed — the
+  // same contract as getConversation.
+  //
+  // Strategy: parse-once-then-slice. This delegates to getConversation, which
+  // parses the full conversation and caches it in conversationLRU, then slices
+  // the window. Message indices are therefore identical to a full
+  // parseConversation() by construction (same parse, same messages array).
+  // Repeated page requests for the same id reuse the single cached parse. The
+  // bounded-memory win (not holding all messages) is deferred — see
+  // docs/plans/2026-06-10-paged-conversation-parse.md.
+  async getConversationPage(id, options) {
+    const conversation = await this.getConversation(id);
+    if (!conversation) return null;
+    const { messages } = conversation;
+    const total = messages.length;
+    const { limit } = options;
+    const beforeIndex = options.beforeIndex ?? total;
+    const fromIndex = Math.max(0, beforeIndex - limit);
+    const window = messages.slice(fromIndex, beforeIndex);
+    return { messages: window, total, fromIndex };
+  }
+  // Parse one JSONL file directly and slice a page window — without any prior
+  // scan() or metadata index. This is the cold-start fast path: a single
+  // conversation can be served from one file parse (~ms) instead of waiting
+  // for a full filesystem scan. The window is the same
+  // `[max(0, beforeIndex - limit), beforeIndex)` slice as getConversationPage,
+  // and the parsed Conversation is returned alongside so the caller can build
+  // the response meta (projectPath, timestamp, messageCount, …) without a
+  // second parse. Returns null when the file can't be parsed. `account` only
+  // feeds the conversation's account field; "default" is the single-profile
+  // fallback, matching refreshFile.
+  async parseSingleFilePage(filePath, account, options) {
+    const conversation = await parseConversation(filePath, account ?? "default");
+    if (!conversation) return null;
+    const { messages } = conversation;
+    const total = messages.length;
+    const { limit } = options;
+    const beforeIndex = options.beforeIndex ?? total;
+    const fromIndex = Math.max(0, beforeIndex - limit);
+    const window = messages.slice(fromIndex, beforeIndex);
+    return { messages: window, total, fromIndex, conversation };
+  }
+  // Re-parse a single JSONL file and update every in-memory index in place —
+  // metadata cache, sessionId index, project set, search index — and evict the
+  // file's parsed conversation from the LRU so the next getConversation()
+  // re-reads it. This lets a long-lived scanner stay current with a file that
+  // grew after the initial scan() without paying for a full rescan.
+  //
+  // `account` defaults to the account already recorded for this file (the id
+  // is the file path), falling back to "default" for a file the scanner has
+  // not seen before. Returns the fresh ConversationMeta, or null when the file
+  // no longer parses (missing/empty) — in which case any prior entry for it is
+  // dropped from all indexes.
+  async refreshFile(filePath, account) {
+    const log = getLogger();
+    const previous = this.metadataCache.get(filePath);
+    const resolvedAccount = account ?? previous?.account ?? "default";
+    let meta = null;
+    try {
+      meta = await parseMeta(filePath, resolvedAccount, this.lastTier);
+    } catch (err) {
+      log.warn({ filePath, err }, "refreshFile: parseMeta threw");
+      meta = null;
+    }
+    const evict = (m) => {
+      if (!m) return;
+      this.conversationLRU.delete(m.id);
+      this.conversationLRU.delete(m.sessionId);
+    };
+    evict(previous);
+    evict(meta);
+    if (!meta || meta.messageCount === 0) {
+      if (previous) {
+        this.metadataCache.delete(previous.id);
+        this.sessionIdIndex.delete(previous.sessionId);
+        this.indexer.removeDocument(previous.id);
+      }
+      log.debug({ filePath }, "refreshFile: dropped (no parseable messages)");
+      return null;
+    }
+    meta.gitBranch = readGitBranch(meta.projectPath);
+    if (previous && previous.sessionId !== meta.sessionId) {
+      this.sessionIdIndex.delete(previous.sessionId);
+    }
+    this.metadataCache.set(meta.id, meta);
+    this.sessionIdIndex.set(meta.sessionId, meta);
+    this.projects.add(meta.projectPath);
+    if (previous) {
+      this.indexer.updateDocument(meta);
+    } else {
+      this.indexer.addDocument(meta);
+    }
+    log.debug(
+      { filePath, messageCount: meta.messageCount },
+      "refreshFile: updated in-memory indexes"
+    );
+    return meta;
+  }
+  getMetadataCache() {
+    return this.metadataCache;
+  }
+  getProjects() {
+    const normalized = /* @__PURE__ */ new Set();
+    for (const p of this.projects) {
+      normalized.add(p.replace(/\/+$/, ""));
+    }
+    return Array.from(normalized).sort();
+  }
+  async resolveProfiles(profiles) {
+    if (profiles && profiles.length > 0) return profiles;
+    return loadProfiles(DEFAULT_CONFIG_PATH);
+  }
+  transformView(metas, options) {
+    switch (options.view) {
+      case "tree":
+        return this.toTree(metas);
+      case "grouped":
+        return this.toGrouped(metas);
+      default:
+        return metas;
+    }
+  }
+  toTree(metas) {
+    const parents = [];
+    const subagents = [];
+    for (const meta of metas) {
+      if (meta.isSubagent) {
+        subagents.push(meta);
+      } else {
+        parents.push({ ...meta, subagents: [] });
+      }
+    }
+    const parentById = new Map(parents.map((p) => [p.id, p]));
+    for (const sub of subagents) {
+      const parent = sub.parentSessionId ? parentById.get(sub.parentSessionId) : void 0;
+      if (parent) {
+        parent.subagents.push(sub);
+      } else {
+        parents.push({ ...sub, subagents: [] });
+      }
+    }
+    return parents;
+  }
+  toGrouped(metas) {
+    const groups = {};
+    for (const meta of metas) {
+      const key = meta.teamName || "_default";
+      if (!groups[key]) groups[key] = [];
+      groups[key].push(meta);
+    }
+    return groups;
+  }
+};
+
+// src/types.ts
+var VALID_SORT_ORDERS = [
+  "recent",
+  "oldest",
+  "messages-desc",
+  "messages-asc",
+  "alpha"
+];
+
+// src/index.ts
+var defaultScanner;
+function getDefaultScanner() {
+  if (!defaultScanner) {
+    defaultScanner = new ConversationScanner();
+  }
+  return defaultScanner;
+}
+function resetDefaultScanner() {
+  defaultScanner = void 0;
+}
+async function scan(options, scanner) {
+  return (scanner ?? getDefaultScanner()).scan(options);
+}
+async function search(query, options, scanner) {
+  return (scanner ?? getDefaultScanner()).search(query, options);
+}
+async function getConversation(id, options, scanner) {
+  return (scanner ?? getDefaultScanner()).getConversation(id, options);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConversationScanner,
+  DEFAULT_TIERS,
+  SearchIndexer,
+  VALID_SORT_ORDERS,
+  applyAccountFilter,
+  applyIncludeFilter,
+  applyPagination,
+  applyProjectFilter,
+  applySinceFilter,
+  applySort,
+  cleanSystemTags,
+  createLogger,
+  detectDefaultProfile,
+  getConversation,
+  getLogger,
+  getProjectsDir,
+  loadProfiles,
+  readGitBranch,
+  resetDefaultScanner,
+  resolveConfigDir,
+  resolveTier,
+  saveProfiles,
+  scan,
+  search,
+  setLogger
+});
+//# sourceMappingURL=index.cjs.map