@rubytech/create-realagent 1.0.828 → 1.0.829

package/payload/platform/plugins/whatsapp-import/bin/ingest.mjs

@@ -1,617 +0,0 @@
-#!/usr/bin/env node
-// =============================================================================
-// ingest.mjs — in-process orchestrator for whatsapp-ingest.sh (Task 891).
-//
-// Pipeline (single phase — Phase 2 insight derivation deferred to its own
-// follow-up task):
-//
-//   parse  → bind canonical senders → derive conversationIdentity
-//   → look up prior :ConversationArchive (delta cursor)
-//   → sessionize delta at gapHours boundaries
-//   → for each session: classify (mode='chat') → collect chunks
-//   → memoryIngest(parentLabel='ConversationArchive')
-//
-// Argv (positional): <archive-path>
-// Argv (flags):       --owner-element-id <id>
-//                     --participant-person-ids <csv>
-//                     --scope <admin|public>
-//                     [--session-gap-hours <N>]   (default 12)
-//                     [--account-id <accountId>]
-//                     [--timezone <iana>]
-//                     [--date-format <DD/MM/YY|MM/DD/YY|DD/MM/YYYY|MM/DD/YYYY>]
-//
-// Owner + participants form the closed sender set; any parsed senderName
-// outside that set LOUD-FAILs with `parser-miss` (preserves Task 887 §A0).
-// `--subject-person-id` and `--filter` are gone (the chunked archive shape
-// makes per-message filtering obsolete — chunking bounds operator surface).
-//
-// Stdout (success): one JSON line — all the counters the skill needs to
-// formulate the three operator-facing messages. See SKILL.md for the shape.
-// Stderr: one [whatsapp-import] FAIL line on failure, exit non-zero.
-// =============================================================================
-
-import { existsSync, mkdtempSync, readdirSync, rmSync, statSync, createReadStream } from "node:fs";
-import { createHash } from "node:crypto";
-import { join, resolve, dirname, basename } from "node:path";
-import { tmpdir } from "node:os";
-import { spawnSync } from "node:child_process";
-import { fileURLToPath } from "node:url";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
-// ---------------------------------------------------------------------------
-// 1. Resolve dist paths.
-// ---------------------------------------------------------------------------
-const platformRoot =
-  process.env.MAXY_PLATFORM_ROOT?.trim() ||
-  resolve(__dirname, "..", "..", "..");
-
-const PARSE_EXPORT_PATH = resolve(
-  platformRoot,
-  "plugins",
-  "whatsapp-import",
-  "lib",
-  "dist",
-  "index.js",
-);
-const NEO4J_LIB_PATH = resolve(
-  platformRoot,
-  "plugins",
-  "memory",
-  "mcp",
-  "dist",
-  "lib",
-  "neo4j.js",
-);
-const LLM_CLASSIFIER_PATH = resolve(
-  platformRoot,
-  "plugins",
-  "memory",
-  "mcp",
-  "dist",
-  "lib",
-  "llm-classifier.js",
-);
-const MEMORY_INGEST_PATH = resolve(
-  platformRoot,
-  "plugins",
-  "memory",
-  "mcp",
-  "dist",
-  "tools",
-  "memory-ingest.js",
-);
-
-// ---------------------------------------------------------------------------
-// 2. Logger
-// ---------------------------------------------------------------------------
-function log(line) {
-  process.stderr.write(`[whatsapp-import] ${line}\n`);
-}
-function fail(phase, fields) {
-  const fieldStr = Object.entries(fields)
-    .map(([k, v]) =>
-      typeof v === "string" && (v.includes(" ") || v.includes("="))
-        ? `${k}="${v.replace(/"/g, '\\"')}"`
-        : `${k}=${v ?? "-"}`,
-    )
-    .join(" ");
-  process.stderr.write(`[whatsapp-import] FAIL phase=${phase} ${fieldStr}\n`);
-  process.exit(1);
-}
-
-// ---------------------------------------------------------------------------
-// 3. Argv parsing
-// ---------------------------------------------------------------------------
-function parseArgv(argv) {
-  const args = argv.slice(2);
-  let archive = null;
-  const flags = {};
-  for (let i = 0; i < args.length; i++) {
-    const a = args[i];
-    if (!a.startsWith("--")) {
-      if (archive == null) archive = a;
-      else fail("argv", { reason: `unexpected positional argument "${a}"` });
-      continue;
-    }
-    const key = a.slice(2);
-    const v = args[++i];
-    if (v == null) fail("argv", { reason: `flag --${key} requires a value` });
-    flags[camelCase(key)] = v;
-  }
-  if (!archive) fail("argv", { reason: "missing positional <archive>" });
-  if (!flags.ownerElementId) fail("argv", { reason: "missing --owner-element-id" });
-  if (!flags.participantPersonIds) {
-    fail("argv", {
-      reason: "missing --participant-person-ids (csv of operator-confirmed :Person/:AdminUser elementIds, owner excluded)",
-    });
-  }
-  if (!flags.scope) fail("argv", { reason: "missing --scope" });
-  if (flags.scope !== "admin" && flags.scope !== "public") {
-    fail("argv", { reason: `invalid --scope "${flags.scope}" (admin|public)` });
-  }
-  return { archive, flags };
-}
-function camelCase(s) {
-  return s.replace(/-([a-z])/g, (_m, c) => c.toUpperCase());
-}
-
-// ---------------------------------------------------------------------------
-// 4. Archive resolution
-// ---------------------------------------------------------------------------
-function resolveChatTxt(archivePath) {
-  const abs = resolve(archivePath);
-  if (!existsSync(abs)) fail("argv", { reason: `archive path not found: ${abs}` });
-  const st = statSync(abs);
-  if (st.isFile() && abs.endsWith(".zip")) {
-    const tmp = mkdtempSync(join(tmpdir(), "whatsapp-ingest-"));
-    const unzip = spawnSync("unzip", ["-q", "-o", abs, "-d", tmp], { encoding: "utf8" });
-    if (unzip.status !== 0) {
-      rmSync(tmp, { recursive: true });
-      fail("argv", {
-        reason: "unzip failed",
-        archive: abs,
-        stderr: (unzip.stderr || "").slice(0, 200),
-      });
-    }
-    const chat = findChatTxt(tmp);
-    if (!chat) {
-      rmSync(tmp, { recursive: true });
-      fail("argv", { reason: "_chat.txt not found in zip", archive: abs });
-    }
-    return { chatTxt: chat, cleanup: () => rmSync(tmp, { recursive: true }) };
-  }
-  if (st.isDirectory()) {
-    const chat = findChatTxt(abs);
-    if (!chat) fail("argv", { reason: "_chat.txt not found in directory", archive: abs });
-    return { chatTxt: chat, cleanup: () => {} };
-  }
-  if (st.isFile()) {
-    return { chatTxt: abs, cleanup: () => {} };
-  }
-  fail("argv", { reason: `unsupported archive shape: ${abs}` });
-  return { chatTxt: abs, cleanup: () => {} };
-}
-function findChatTxt(dir) {
-  const entries = readdirSync(dir, { withFileTypes: true });
-  for (const e of entries) {
-    if (e.isFile() && e.name === "_chat.txt") return join(dir, e.name);
-  }
-  for (const e of entries) {
-    if (e.isDirectory()) {
-      const nested = findChatTxt(join(dir, e.name));
-      if (nested) return nested;
-    }
-  }
-  return null;
-}
-
-// ---------------------------------------------------------------------------
-// 5. Account resolution (Phase 0 = single account)
-// ---------------------------------------------------------------------------
-function resolveAccountId(flags) {
-  if (flags.accountId && flags.accountId.trim()) return flags.accountId.trim();
-  const installDir = resolve(platformRoot, "..");
-  const accountsDir = join(installDir, "data", "accounts");
-  if (!existsSync(accountsDir)) {
-    fail("argv", { reason: `accounts dir not found: ${accountsDir}; pass --account-id explicitly` });
-  }
-  const dirs = readdirSync(accountsDir, { withFileTypes: true })
-    .filter((d) => d.isDirectory() && !d.name.startsWith("."))
-    .map((d) => d.name);
-  if (dirs.length === 0) fail("argv", { reason: `no accounts found under ${accountsDir}` });
-  if (dirs.length > 1) {
-    fail("argv", {
-      reason: `multiple accounts under ${accountsDir} (${dirs.join(",")}); pass --account-id explicitly`,
-    });
-  }
-  return dirs[0];
-}
-
-// ---------------------------------------------------------------------------
-// 6. Bind canonical sender set (Task 887 §A0 preserved).
-//
-// All distinct parsed senderNames must resolve to {owner, participants...}.
-// Any miss LOUD-FAILs with `parser-miss reason="senderName=<...>"`.
-// ---------------------------------------------------------------------------
-const CANONICAL_FETCH_CYPHER = `
-UNWIND $ids AS id
-MATCH (n) WHERE elementId(n) = id
-RETURN elementId(n) AS elemId,
-       labels(n) AS labels,
-       coalesce(n.name, '') AS name,
-       coalesce(n.givenName, '') AS givenName,
-       coalesce(n.familyName, '') AS familyName,
-       coalesce(n.accountId, '') AS accountId
-`;
-
-class IngestUserFacingError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "IngestUserFacingError";
-    this.userFacing = true;
-  }
-}
-
-async function bindCanonicalSenders({
-  session,
-  accountId,
-  ownerElementId,
-  participantElementIds,
-  senderNames,
-  normaliseSenderName,
-}) {
-  const allIds = [ownerElementId, ...participantElementIds];
-  const distinctIds = Array.from(new Set(allIds));
-  if (distinctIds.length !== allIds.length) {
-    throw new IngestUserFacingError(
-      `participant id list contains duplicates (owner appears in --participant-person-ids?)`,
-    );
-  }
-  const res = await session.executeRead(async (tx) => tx.run(CANONICAL_FETCH_CYPHER, { ids: distinctIds }));
-  const seenIds = new Set();
-  const labelByElemId = new Map();
-  const index = new Map();
-  for (const r of res.records) {
-    const elemId = r.get("elemId");
-    const labels = r.get("labels") || [];
-    const acct = r.get("accountId") || "";
-    if (!acct) {
-      throw new IngestUserFacingError(`node ${elemId} has no accountId — corrupt canonical Person/AdminUser`);
-    }
-    if (acct !== accountId) {
-      throw new IngestUserFacingError(`node ${elemId} belongs to account ${acct}, not ${accountId}`);
-    }
-    if (!labels.includes("Person") && !labels.includes("AdminUser")) {
-      throw new IngestUserFacingError(`node ${elemId} has labels [${labels.join(",")}]; expected :Person or :AdminUser`);
-    }
-    seenIds.add(elemId);
-    labelByElemId.set(elemId, labels.includes("Person") ? "Person" : "AdminUser");
-    const candidates = [];
-    const name = r.get("name") || "";
-    const given = r.get("givenName") || "";
-    const family = r.get("familyName") || "";
-    if (name) candidates.push(name);
-    if (given && family) candidates.push(`${given} ${family}`);
-    if (given) candidates.push(given);
-    if (family) candidates.push(family);
-    for (const c of candidates) {
-      const norm = normaliseSenderName(c);
-      if (!norm) continue;
-      if (!index.has(norm)) index.set(norm, elemId);
-    }
-  }
-  for (const id of distinctIds) {
-    if (!seenIds.has(id)) {
-      throw new IngestUserFacingError(`elementId ${id} not found in graph`);
-    }
-  }
-  // Validate every distinct parsed senderName against the closed candidate set.
-  for (const senderName of senderNames) {
-    const norm = normaliseSenderName(senderName);
-    const hit = index.get(norm);
-    if (!hit) {
-      throw new IngestUserFacingError(
-        `parser-miss reason="senderName=${senderName} not in confirmed participant set (${distinctIds.length} confirmed elementIds; re-run with the missing :Person elementId in --participant-person-ids)"`,
-      );
-    }
-  }
-  return { participantsResolved: seenIds.size };
-}
-
-// ---------------------------------------------------------------------------
-// 7. SHA-256 of file bytes (for archiveSha256)
-// ---------------------------------------------------------------------------
-async function fileSha256(filePath) {
-  return new Promise((resolveProm, rejectProm) => {
-    const hash = createHash("sha256");
-    const stream = createReadStream(filePath);
-    stream.on("data", (chunk) => hash.update(chunk));
-    stream.on("end", () => resolveProm(hash.digest("hex")));
-    stream.on("error", rejectProm);
-  });
-}
-
-// ---------------------------------------------------------------------------
-// 8. Build natural-edge map for chat-mode classifier.
-// Chat mode doesn't use it (the chat prompt drops edge proposals), but
-// classifyDocument's signature still takes the param. Pass the empty string.
-// ---------------------------------------------------------------------------
-
-// ---------------------------------------------------------------------------
-// 9. Main
-// ---------------------------------------------------------------------------
-async function main() {
-  const startedMs = Date.now();
-  const { archive, flags } = parseArgv(process.argv);
-  const ownerElementId = flags.ownerElementId;
-  const participantElementIds = flags.participantPersonIds
-    .split(",")
-    .map((s) => s.trim())
-    .filter((s) => s.length > 0);
-  if (participantElementIds.length === 0) {
-    fail("argv", { reason: "--participant-person-ids must list at least one elementId" });
-  }
-  const scope = flags.scope;
-  const accountId = resolveAccountId(flags);
-  const timezone = flags.timezone || "Europe/London";
-  const dateFormat = flags.dateFormat;
-  const sessionGapHours = flags.sessionGapHours
-    ? parseFloat(flags.sessionGapHours)
-    : 12;
-  if (!Number.isFinite(sessionGapHours) || sessionGapHours <= 0) {
-    fail("argv", { reason: `invalid --session-gap-hours "${flags.sessionGapHours}" (must be positive number)` });
-  }
-  const sessionId =
-    flags.sessionId || `whatsapp-import:${Date.now()}:${Math.random().toString(36).slice(2, 10)}`;
-
-  // Imports — fail loudly if any compiled dist missing
-  let parseExport, sessionize, toClassifierInput, findDeltaCursor;
-  let normaliseSenderName, deriveConversationIdentity, deriveMessageContentHash;
-  let getSession, classifyDocument, memoryIngest;
-  try {
-    ({
-      parseExport,
-      sessionize,
-      toClassifierInput,
-      findDeltaCursor,
-      normaliseSenderName,
-      deriveConversationIdentity,
-      deriveMessageContentHash,
-    } = await import(PARSE_EXPORT_PATH));
-    ({ getSession } = await import(NEO4J_LIB_PATH));
-    ({ classifyDocument } = await import(LLM_CLASSIFIER_PATH));
-    ({ memoryIngest } = await import(MEMORY_INGEST_PATH));
-  } catch (err) {
-    fail("import", {
-      reason: "failed to import compiled dist",
-      detail: err instanceof Error ? err.message : String(err),
-    });
-  }
-
-  // 9a. Resolve _chat.txt + sha256
-  const { chatTxt, cleanup } = resolveChatTxt(archive);
-  const archiveSha256 = await fileSha256(chatTxt);
-  const archiveSourceFile = basename(chatTxt);
-  log(
-    `start file=${archiveSourceFile} owner=${ownerElementId} participants=${participantElementIds.length} scope=${scope} accountId=${accountId} archiveSha256=${archiveSha256.slice(0, 12)} session-gap-hours=${sessionGapHours}`,
-  );
-
-  // 9b. Parse
-  let parseResult;
-  try {
-    parseResult = parseExport({ filePath: chatTxt, accountId, timezone, dateFormat });
-  } catch (err) {
-    cleanup();
-    fail("parse", { reason: err instanceof Error ? err.message : String(err) });
-  }
-  const allLines = parseResult.parsedLines;
-  log(
-    `parsed lines=${parseResult.counters.parsed} media-skipped=${parseResult.counters.mediaSkipped} system-skipped=${parseResult.counters.systemSkipped}`,
-  );
-  if (allLines.length === 0) {
-    cleanup();
-    fail("parse", { reason: "zero parsed lines after walking archive" });
-  }
-
-  // 9c. Bind canonical senders against the confirmed set
-  const distinctSenderNames = Array.from(new Set(allLines.map((l) => l.senderName)));
-  const senderHistogram = computeSenderHistogram(allLines);
-  let session = getSession();
-  try {
-    await bindCanonicalSenders({
-      session,
-      accountId,
-      ownerElementId,
-      participantElementIds,
-      senderNames: distinctSenderNames,
-      normaliseSenderName,
-    });
-  } catch (err) {
-    await session.close().catch(() => {});
-    cleanup();
-    if (err && err.userFacing) {
-      process.stderr.write(`[whatsapp-import] FAIL ${err.message}\n`);
-      process.exit(1);
-    }
-    fail("argv", { reason: err instanceof Error ? err.message : String(err) });
-  }
-
-  // 9d. Derive conversationIdentity and look up prior :ConversationArchive
-  const conversationIdentity = deriveConversationIdentity({
-    accountId,
-    participantElementIds: [ownerElementId, ...participantElementIds],
-  });
-  let priorArchive = null;
-  try {
-    const r = await session.run(
-      `MATCH (a:ConversationArchive { conversationIdentity: $cid })
-       RETURN elementId(a) AS elemId,
-              a.lastIngestedMessageHash AS lastHash,
-              a.lastIngestedMessageAt   AS lastAt LIMIT 1`,
-      { cid: conversationIdentity },
-    );
-    if (r.records[0]) {
-      priorArchive = {
-        elemId: r.records[0].get("elemId"),
-        lastHash: r.records[0].get("lastHash"),
-        lastAt: r.records[0].get("lastAt"),
-      };
-    }
-  } catch (err) {
-    await session.close().catch(() => {});
-    cleanup();
-    fail("delta-cursor-missing", { reason: `conversationArchive lookup failed: ${err instanceof Error ? err.message : String(err)}` });
-  }
-  await session.close().catch(() => {});
-
-  // 9e. Compute deltaStart
-  let deltaStart = 0;
-  let deltaKind = "first-ingest";
-  if (priorArchive && priorArchive.lastHash) {
-    const cursor = findDeltaCursor(allLines, priorArchive.lastHash);
-    if (cursor.kind === "missing") {
-      cleanup();
-      fail("delta-cursor-missing", {
-        reason: `prior cursor not found in re-export (operator deleted prior messages, or this is a different chat archive)`,
-        priorArchive: priorArchive.elemId,
-        lastIngestedMessageAt: priorArchive.lastAt,
-      });
-    }
-    if (cursor.kind === "empty") {
-      log(`noop reason="no new messages since ${priorArchive.lastAt}"`);
-      cleanup();
-      const totalMs = Date.now() - startedMs;
-      process.stdout.write(JSON.stringify({
-        archiveElementId: priorArchive.elemId,
-        conversationIdentity,
-        archiveSha256,
-        archiveSourceFile,
-        parsed: parseResult.counters.parsed,
-        mediaSkipped: parseResult.counters.mediaSkipped,
-        systemSkipped: parseResult.counters.systemSkipped,
-        delta: { kind: "empty-delta", deltaStart: allLines.length, deltaMessages: 0 },
-        sessions: 0,
-        chunks: 0,
-        nextEdgesCreated: 0,
-        participantsLinked: 0,
-        dateRange: { first: allLines[0].dateSent, last: allLines[allLines.length - 1].dateSent },
-        senderHistogram,
-        topicKeywords: [],
-        ms: totalMs,
-        priorLastIngestedMessageAt: priorArchive.lastAt,
-      }) + "\n");
-      process.exit(0);
-    }
-    deltaStart = cursor.deltaStart;
-    deltaKind = "delta";
-  }
-  const deltaLines = allLines.slice(deltaStart);
-  log(
-    `delta cursor=${priorArchive ? priorArchive.lastHash.slice(0, 12) : "(first-ingest)"} cursor-line=${deltaStart} delta-messages=${deltaLines.length}`,
-  );
-
-  // 9f. Sessionize delta
-  const sessions = sessionize(deltaLines, sessionGapHours);
-  log(
-    `sessionize file=${archiveSourceFile} archiveSha256=${archiveSha256.slice(0, 12)} messages=${deltaLines.length} sessions=${sessions.length} gap-hours=${sessionGapHours}`,
-  );
-
-  // 9g. Classify each session via Haiku (mode='chat')
-  const allChunks = [];
-  const allKeywords = new Set();
-  for (const s of sessions) {
-    const sessionStart = Date.now();
-    const text = toClassifierInput(s);
-    const result = await classifyDocument({
-      accountId,
-      mode: "chat",
-      anchorDescription: `WhatsApp conversation between ${[ownerElementId, ...participantElementIds].length} participants (session ${s.index + 1} of ${sessions.length})`,
-      ontologyLabels: new Set([]),
-      naturalEdgeMap: "",
-      documentText: text,
-    });
-    if (result.kind === "fallback") {
-      cleanup();
-      fail("classify", { reason: `Haiku fallback on session ${s.index}: ${result.reason}` });
-    }
-    const chunkCount = result.output.sections.length;
-    log(
-      `classify-session sessionIndex=${s.index + 1}/${sessions.length} messages=${s.messages.length} chars=${text.length} chunks=${chunkCount} ms=${Date.now() - sessionStart}`,
-    );
-    if (chunkCount === 0 && s.messages.length > 0) {
-      cleanup();
-      fail("classify", {
-        reason: `session ${s.index} of ${s.messages.length} messages produced zero chunks (classifier-prompt regression)`,
-      });
-    }
-    for (const sec of result.output.sections) {
-      allChunks.push(sec);
-    }
-    for (const kw of result.output.documentKeywords) {
-      allKeywords.add(kw);
-    }
-  }
-
-  // 9h. Compute lastIngestedMessageHash from the last delta line
-  const lastLine = deltaLines[deltaLines.length - 1];
-  const lastIngestedMessageHash = deriveMessageContentHash({
-    dateSent: lastLine.dateSent,
-    senderName: lastLine.senderName,
-    body: lastLine.body,
-  });
-  const lastIngestedMessageAt = lastLine.dateSent;
-
-  // 9i. Aggregate document-level summary across sessions (concatenate first
-  //     two-three classifier summaries; the parent's summary is informational)
-  const documentSummary = sessions.length === 1
-    ? `${deltaLines.length} messages in 1 session, ${allChunks.length} chunks.`
-    : `${deltaLines.length} messages in ${sessions.length} sessions, ${allChunks.length} chunks.`;
-
-  // 9j. Call memoryIngest with parentLabel='ConversationArchive'
-  let ingestResult;
-  const ingestStart = Date.now();
-  try {
-    ingestResult = await memoryIngest({
-      accountId,
-      attachmentId: conversationIdentity, // semantic rename per parentLabel
-      parentLabel: "ConversationArchive",
-      documentSummary,
-      anchorNodeId: ownerElementId,
-      anchorLabel: "AdminUser", // unused in chat path but required by IngestParams
-      sections: allChunks,
-      scope,
-      sessionId,
-      documentKeywords: Array.from(allKeywords),
-      archiveSha256,
-      archiveSourceFile,
-      lastIngestedMessageHash,
-      lastIngestedMessageAt,
-      participantElementIds: [ownerElementId, ...participantElementIds],
-    });
-  } catch (err) {
-    cleanup();
-    fail("memory-ingest", { reason: err instanceof Error ? err.message : String(err) });
-  }
-  log(
-    `file=${archiveSourceFile} conversationIdentity=${conversationIdentity.slice(0, 12)} archiveElementId=${ingestResult.documentNodeId} chunks-written=${ingestResult.sectionCount} next-edges=${ingestResult.edgeBreakdown.NEXT ?? 0} participants=${ingestResult.edgeBreakdown.PARTICIPANT_IN ?? 0} ms=${Date.now() - ingestStart}`,
-  );
-
-  cleanup();
-  const totalMs = Date.now() - startedMs;
-  log(`done conversationIdentity=${conversationIdentity.slice(0, 12)} total-ms=${totalMs} exit=0`);
-
-  process.stdout.write(JSON.stringify({
-    archiveElementId: ingestResult.documentNodeId,
-    conversationIdentity,
-    archiveSha256,
-    archiveSourceFile,
-    parsed: parseResult.counters.parsed,
-    mediaSkipped: parseResult.counters.mediaSkipped,
-    systemSkipped: parseResult.counters.systemSkipped,
-    delta: { kind: deltaKind, deltaStart, deltaMessages: deltaLines.length },
-    sessions: sessions.length,
-    chunks: ingestResult.sectionCount,
-    nextEdgesCreated: ingestResult.edgeBreakdown.NEXT ?? 0,
-    participantsLinked: ingestResult.edgeBreakdown.PARTICIPANT_IN ?? 0,
-    dateRange: { first: allLines[0].dateSent, last: allLines[allLines.length - 1].dateSent },
-    senderHistogram,
-    topicKeywords: Array.from(allKeywords),
-    ms: totalMs,
-  }) + "\n");
-  process.exit(0);
-}
-
-function computeSenderHistogram(lines) {
-  const counts = new Map();
-  for (const l of lines) {
-    counts.set(l.senderName, (counts.get(l.senderName) ?? 0) + 1);
-  }
-  return Array.from(counts.entries())
-    .map(([name, count]) => ({ name, count }))
-    .sort((a, b) => b.count - a.count);
-}
-
-main().catch((err) => {
-  fail("uncaught", { reason: err instanceof Error ? err.message : String(err) });
-});