@rubytech/create-realagent 1.0.828 → 1.0.830

package/payload/platform/plugins/whatsapp-import/lib/src/parse-export.ts

@@ -1,471 +0,0 @@
-import { createHash } from "node:crypto";
-import { readFileSync } from "node:fs";
-
-// ---------------------------------------------------------------------------
-// parse-export — deterministic WhatsApp `_chat.txt` parser (Task 805).
-//
-// Pure function. No LLM in the per-line decision path. Replaces the prose
-// grammar that lived in references/export-parse.md when the database-operator
-// specialist's Sonnet was the line tokeniser. Every grammar branch here is
-// exercised by the vitest grid in `__tests__/parse-export.test.ts`; that
-// grid IS the contract — extending the grammar means a new test first.
-//
-// Doctrine alignment:
-//   - feedback_deterministic_means_remove_llm.md — the LLM is no longer in
-//     the per-line decision path.
-//   - feedback_deterministic_is_a_shell_script.md — TypeScript is the right
-//     deliverable shape here (UTF-8 decode + multi-line body assembly + sha256
-//     would be cumbersome in shell); the LITERAL-MAPPING rule yields to
-//     "Node module" because the per-line decision path is the deliverable, not
-//     a one-shot orchestrator.
-//   - feedback_loud_failures.md — encoding errors, empty files, and lines
-//     that match a timestamp prefix but cannot be tokenised throw with named
-//     reasons rather than degrading silently.
-// ---------------------------------------------------------------------------
-
-export interface ParseExportInput {
-  /** Absolute path to the `_chat.txt` file. */
-  filePath: string;
-  /** Account scope used to compose `conversationId`. */
-  accountId: string;
-  /** IANA timezone the operator confirmed (e.g. `Europe/London`). */
-  timezone: string;
-  /**
-   * Date ordering and year shape. Omit for auto-detect (Task 845): the parser
-   * probes the first matched line as DD/MM and locks that ordering if range-valid;
-   * otherwise locks MM/DD. Year shape is independent — `\d{2,4}` accepts 2-digit
-   * (mapped `2000+yy`) and 4-digit (passed through) years per-line, including
-   * mixed-year files.
-   */
-  dateFormat?: "DD/MM/YY" | "MM/DD/YY" | "DD/MM/YYYY" | "MM/DD/YYYY";
-}
-
-export interface ParsedLine {
-  senderName: string;
-  /** ISO 8601 with timezone offset for the supplied IANA zone. */
-  dateSent: string;
-  body: string;
-  /** Position within emitted (post-skip) messages, 0-based. */
-  sequenceIndex: number;
-}
-
-export interface ParseExportCounters {
-  parsed: number;
-  systemSkipped: number;
-  mediaSkipped: number;
-  parseErrors: number;
-}
-
-export interface ParseExportResult {
-  conversationId: string;
-  /** `whatsapp-export:<sha256-hex>` of the raw file bytes. */
-  archiveSourceFile: string;
-  parsedLines: ParsedLine[];
-  counters: ParseExportCounters;
-}
-
-// Year capture is `\d{2}|\d{4}` so a single regex covers both 2-digit (legacy)
-// and 4-digit (modern WhatsApp default) prefixes — Task 845. Exactly 2 or 4
-// chars; 3-digit years (truncation typos, hand-edited files) are rejected as
-// not-a-prefix and surface via parse-grammar-miss, not silently coerced into
-// year-202-AD timestamps. Year semantics are resolved per-match in
-// `matchTimestampPrefix` from the captured length, not from the regex shape,
-// so mixed-year files parse natively.
-const TIMESTAMP_PREFIX_DDMMYY =
-  /^\[(\d{2})\/(\d{2})\/(\d{4}|\d{2}),\s+(\d{1,2}):(\d{2})(?::(\d{2}))?\]\s*(.*)$/;
-
-const TIMESTAMP_PREFIX_MMDDYY = TIMESTAMP_PREFIX_DDMMYY; // shape is identical; ordering differs in interpretation only
-
-// System-message patterns that appear WITHOUT a `: ` sender/body separator.
-// WhatsApp emits group-event and security-code lines as `<Sender> <verb> ...`
-// (no colon). Lines that match the timestamp prefix but lack `: ` and do not
-// match one of these patterns are LOUD-FAIL parse errors — never silently
-// dropped.
-const LINE_LEVEL_SYSTEM_PATTERNS: RegExp[] = [
-  /^Messages and calls are end-to-end encrypted/i,
-  /'s security code changed\.?$/i,
-  / created group ["“”]/,
-  / added /,
-  / removed /,
-  / left$/,
-  / changed the subject from /,
-  / changed this group's icon/,
-  / joined using this group's invite link/,
-  /^You're now an admin$/i,
-  /^You created group/i,
-];
-
-// Body-level patterns evaluated after `Sender: body` split. These are real
-// messages syntactically but carry no graph value (deletions, media-only).
-const BODY_LEVEL_SYSTEM_PATTERNS: RegExp[] = [
-  /^You deleted this message\.?$/,
-  /^This message was deleted\.?$/,
-];
-
-const MEDIA_ONLY_PATTERNS: RegExp[] = [
-  /^<Media omitted>$/,
-  /^IMG-\d+-\w+\.(jpg|jpeg|png|heic|gif)\s*\(file attached\)$/i,
-  /^VID-\d+-\w+\.mp4\s*\(file attached\)$/i,
-  /^PTT-\d+-\w+\.opus\s*\(file attached\)$/i,
-  /^AUD-\d+-\w+\.opus\s*\(file attached\)$/i,
-  /^STK-\d+-\w+\.webp\s*\(file attached\)$/i,
-  /^.+\.(pdf|docx|doc|xlsx|xls|pptx|ppt|zip|csv|txt)\s*\(file attached\)$/i,
-  /^‎.+attached:\s*.+$/, // alternative LRM-prefixed format on some platforms
-];
-
-export function parseExport(input: ParseExportInput): ParseExportResult {
-  const { filePath, accountId, timezone, dateFormat: explicitDateFormat } = input;
-
-  if (!accountId || !accountId.trim()) {
-    throw new Error("parse-export: accountId is required.");
-  }
-  if (!timezone || !timezone.trim()) {
-    throw new Error("parse-export: timezone is required (e.g. 'Europe/London').");
-  }
-
-  const rawBytes = readFileSync(filePath);
-  const sha256Hex = createHash("sha256").update(rawBytes).digest("hex");
-  const archiveSourceFile = `whatsapp-export:${sha256Hex}`;
-  const conversationId = `whatsapp-export:${sha256Hex}:${accountId}`;
-
-  const text = decodeAndNormalise(rawBytes);
-  if (text.length === 0) {
-    throw new Error(
-      `parse-export: file is empty — not a _chat.txt. file=${filePath}`,
-    );
-  }
-
-  const lines = text.split("\n");
-  // Auto-detect when `dateFormat` is omitted (Task 845): probe the first line
-  // that contains a timestamp prefix as DD/MM; lock DD/MM if range-valid,
-  // otherwise lock MM/DD. WhatsApp's locale is set per device, so a single
-  // file never mixes DD/MM and MM/DD — locking once from line 1 is correct.
-  // Concatenated multi-locale exports require an explicit `dateFormat`.
-  const ordering = resolveOrdering(explicitDateFormat, lines);
-  const counters: ParseExportCounters = {
-    parsed: 0,
-    systemSkipped: 0,
-    mediaSkipped: 0,
-    parseErrors: 0,
-  };
-
-  // Stage 1 — tokenise into raw messages (timestamp + remainder), accumulating
-  // continuation lines into the previous remainder. Stage 2 then categorises
-  // each tokenised message (system / media / real) so the counter increments
-  // happen exactly once per source line.
-  interface RawMessage {
-    rawLineIndex: number; // 1-based file line number for LOUD-FAIL diagnostics
-    year: number;
-    month: number;
-    day: number;
-    hour: number;
-    minute: number;
-    second: number;
-    remainder: string; // everything after `]` on the prefix line, plus continuation lines
-  }
-  const raw: RawMessage[] = [];
-
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    if (line.length === 0 && i === lines.length - 1) continue; // trailing newline
-    const prefixMatch = matchTimestampPrefix(line, ordering);
-    if (prefixMatch) {
-      raw.push({
-        rawLineIndex: i + 1,
-        ...prefixMatch.dateParts,
-        remainder: prefixMatch.remainder,
-      });
-    } else {
-      // Continuation of the previous message body. If there is no previous
-      // message, this line is leading garbage — ignore it (matches the
-      // export-parse.md edge case where a leading BOM or blank line precedes
-      // the first timestamp).
-      const last = raw[raw.length - 1];
-      if (last) {
-        last.remainder += "\n" + line;
-      }
-    }
-  }
-
-  // Stage 2 — categorise each raw message. Do NOT trim trailing whitespace
-  // from the remainder before splitting — `Joel: ` (sender + colon + trailing
-  // space + newline) collapses to `Joel:` after a `\s+$` trim and the `: `
-  // separator disappears, turning an empty-body system skip into a LOUD-FAIL.
-  const parsedLines: ParsedLine[] = [];
-  for (const r of raw) {
-    const remainder = r.remainder;
-    const colonIdx = findFirstColonSeparator(remainder);
-
-    if (colonIdx === -1) {
-      // No `: ` separator. Must match a known system pattern or LOUD-FAIL.
-      const trimmed = remainder.replace(/\s+$/, "");
-      if (matchesAny(trimmed, LINE_LEVEL_SYSTEM_PATTERNS)) {
-        counters.systemSkipped++;
-        continue;
-      }
-      counters.parseErrors++;
-      throw new Error(
-        `parse-export: parse-error file=${filePath} line=${r.rawLineIndex} reason=no-sender-body-separator content="${trimmed.slice(0, 80)}"`,
-      );
-    }
-
-    const senderName = remainder.slice(0, colonIdx).trim();
-    const body = remainder.slice(colonIdx + 2).replace(/\s+$/, "");
-
-    if (body.length === 0) {
-      counters.systemSkipped++;
-      continue;
-    }
-    if (matchesAny(body, BODY_LEVEL_SYSTEM_PATTERNS)) {
-      counters.systemSkipped++;
-      continue;
-    }
-    if (matchesAny(body, MEDIA_ONLY_PATTERNS)) {
-      counters.mediaSkipped++;
-      continue;
-    }
-
-    const dateSent = isoWithOffset(
-      r.year,
-      r.month,
-      r.day,
-      r.hour,
-      r.minute,
-      r.second,
-      timezone,
-    );
-
-    parsedLines.push({
-      senderName,
-      dateSent,
-      body,
-      sequenceIndex: parsedLines.length,
-    });
-    counters.parsed++;
-  }
-
-  if (parsedLines.length === 0 && counters.systemSkipped === 0 && counters.mediaSkipped === 0) {
-    // Task 845: include a sanitised first-line sample so the operator knows
-    // WHY the file rejected — closes the diagnostic gap that left conversation
-    // 47c6a590-0c2c-4006-9aca-6ee9ec93c95f guessing. Echoed to stderr too so
-    // server.log has a grep-able adjunct to the existing parse-failed line.
-    const sample = sampleFirstNonBlankLine(lines, 100);
-    process.stderr.write(
-      `[whatsapp-import] parse-grammar-miss first-line="${sample}"\n`,
-    );
-    throw new Error(
-      `parse-export: zero parsed lines after walking ${filePath} — not a _chat.txt or all lines failed grammar. parse-grammar-miss first-line="${sample}"`,
-    );
-  }
-
-  return {
-    conversationId,
-    archiveSourceFile,
-    parsedLines,
-    counters,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Internals
-// ---------------------------------------------------------------------------
-
-function decodeAndNormalise(bytes: Buffer): string {
-  // Strict UTF-8 decode. Node's TextDecoder with `fatal: true` throws on
-  // invalid bytes — that's the LOUD-FAIL the brief mandates for encoding
-  // errors. The default `Buffer.toString('utf8')` silently substitutes
-  // U+FFFD, which would let bad bytes propagate into the graph.
-  let text: string;
-  try {
-    text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
-  } catch (err) {
-    throw new Error(
-      `parse-export: UTF-8 decode failed — ${err instanceof Error ? err.message : String(err)}. The file is not valid UTF-8; re-export from WhatsApp.`,
-    );
-  }
-
-  // Strip leading BOM (U+FEFF).
-  if (text.charCodeAt(0) === 0xfeff) {
-    text = text.slice(1);
-  }
-
-  // Normalise mixed line endings to LF.
-  text = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
-
-  // Task 887 — strip Unicode bidi marks (U+200E LRM, U+200F RLM) only at
-  // line-start, where some WhatsApp builds prefix the timestamp header.
-  // Without stripping, `^\[(\d{2})\/...` fails on the prefixed line, the
-  // line is appended as a continuation of the previous body, and the next
-  // clean header parses its senderName off the polluted body — leaking 23
-  // bogus :Person nodes per import in the Adam Mackay archive. Body-internal
-  // bidi marks (e.g. the LRM in `: ‎Forwarded`) are preserved — they carry
-  // semantic information about message origin and are exercised by
-  // parse-export.test.ts. Counts emitted to stderr for the operator's tail.
-  const leadingBidiMatches = text.match(/(?:^|\n)[‎‏]+/g) || [];
-  let lrmStripped = 0;
-  let rlmStripped = 0;
-  for (const m of leadingBidiMatches) {
-    for (const ch of m) {
-      if (ch === "‎") lrmStripped++;
-      else if (ch === "‏") rlmStripped++;
-    }
-  }
-  if (leadingBidiMatches.length > 0) {
-    text = text.replace(/(^|\n)[‎‏]+/g, "$1");
-    process.stderr.write(
-      `[whatsapp-ingest] decoded normalised lrm-stripped=${lrmStripped} rlm-stripped=${rlmStripped}\n`,
-    );
-  }
-
-  return text;
-}
-
-interface TimestampMatch {
-  dateParts: {
-    year: number;
-    month: number;
-    day: number;
-    hour: number;
-    minute: number;
-    second: number;
-  };
-  remainder: string;
-}
-
-type Ordering = "DDMM" | "MMDD";
-
-function matchTimestampPrefix(
-  line: string,
-  ordering: Ordering,
-): TimestampMatch | null {
-  const re = ordering === "MMDD" ? TIMESTAMP_PREFIX_MMDDYY : TIMESTAMP_PREFIX_DDMMYY;
-  const m = line.match(re);
-  if (!m) return null;
-  const a = parseInt(m[1], 10); // dd or mm depending on ordering
-  const b = parseInt(m[2], 10); // mm or dd
-  const yearRaw = m[3];
-  const hour = parseInt(m[4], 10);
-  const minute = parseInt(m[5], 10);
-  const second = m[6] !== undefined ? parseInt(m[6], 10) : 0;
-  const remainder = m[7] ?? "";
-  const day = ordering === "MMDD" ? b : a;
-  const month = ordering === "MMDD" ? a : b;
-  // Range-check before passing to Date.UTC — that function silently rolls
-  // over invalid components (Date.UTC(2026, 13, 1) → 2027-02-01), which
-  // would corrupt timestamps when the operator passes the wrong ordering
-  // for a US-locale export. Reject as not-a-prefix; the caller retries the
-  // file with the correct ordering or LOUD-FAILs when the file isn't a chat.
-  if (month < 1 || month > 12 || day < 1 || day > 31) return null;
-  if (hour > 23 || minute > 59 || second > 59) return null;
-  // Task 845: branch year semantics on captured length. WhatsApp's modern
-  // exports emit 4-digit years; legacy exports emit 2-digit. Both are
-  // accepted by the same regex and disambiguated here so a single file may
-  // hold both shapes (mixed-year imports parse natively).
-  const year = yearRaw.length === 2 ? 2000 + parseInt(yearRaw, 10) : parseInt(yearRaw, 10);
-  return {
-    dateParts: { year, month, day, hour, minute, second },
-    remainder,
-  };
-}
-
-function resolveOrdering(
-  explicit: ParseExportInput["dateFormat"],
-  lines: readonly string[],
-): Ordering {
-  if (explicit === "MM/DD/YY" || explicit === "MM/DD/YYYY") return "MMDD";
-  if (explicit === "DD/MM/YY" || explicit === "DD/MM/YYYY") return "DDMM";
-  // Auto-detect: probe the first prefix-matching line as DD/MM. If range-valid,
-  // lock DD/MM (WhatsApp's global default). Otherwise lock MM/DD (US-locale
-  // exports, which are the only meaningful exception). Locked once.
-  for (const line of lines) {
-    if (matchTimestampPrefix(line, "DDMM")) return "DDMM";
-    if (matchTimestampPrefix(line, "MMDD")) return "MMDD";
-  }
-  return "DDMM"; // No matching line — caller will throw zero-parsed-lines anyway.
-}
-
-function sampleFirstNonBlankLine(lines: readonly string[], maxScan: number): string {
-  const scanLimit = Math.min(maxScan, lines.length);
-  for (let i = 0; i < scanLimit; i++) {
-    const trimmed = lines[i].trim();
-    if (trimmed.length === 0) continue;
-    // Strip control characters (including tab, BEL, etc.) so the diagnostic
-    // line stays single-line and grep-friendly. Truncate to 80 chars per
-    // Task 845 brief — enough to recognise the offending header shape.
-    const sanitised = trimmed.replace(/[\x00-\x1F\x7F]/g, "");
-    return sanitised.slice(0, 80);
-  }
-  return "";
-}
-
-function findFirstColonSeparator(remainder: string): number {
-  // Split on the FIRST `: ` (colon-space). A sender display name may itself
-  // contain a `:` (e.g. "Joel: Work"), so we anchor on the first colon
-  // followed by a space — that's the WhatsApp export's stable separator.
-  const idx = remainder.indexOf(": ");
-  return idx;
-}
-
-function matchesAny(text: string, patterns: RegExp[]): boolean {
-  for (const p of patterns) {
-    if (p.test(text)) return true;
-  }
-  return false;
-}
-
-function isoWithOffset(
-  year: number,
-  month: number,
-  day: number,
-  hour: number,
-  minute: number,
-  second: number,
-  timezone: string,
-): string {
-  // Produce ISO 8601 with the offset that the supplied IANA zone holds for
-  // this wall-clock instant. Two-step refinement is needed to handle DST:
-  // the wall-clock components describe a local time, and we need the offset
-  // for the corresponding UTC instant in `timezone`.
-  const guessUtcMs = Date.UTC(year, month - 1, day, hour, minute, second);
-  let offMin = offsetMinutesAt(new Date(guessUtcMs), timezone);
-  const refinedUtcMs = guessUtcMs - offMin * 60_000;
-  offMin = offsetMinutesAt(new Date(refinedUtcMs), timezone);
-
-  const sign = offMin >= 0 ? "+" : "-";
-  const absOff = Math.abs(offMin);
-  const offHH = String(Math.floor(absOff / 60)).padStart(2, "0");
-  const offMM = String(absOff % 60).padStart(2, "0");
-  const Y = String(year).padStart(4, "0");
-  const M = String(month).padStart(2, "0");
-  const D = String(day).padStart(2, "0");
-  const H = String(hour).padStart(2, "0");
-  const Mi = String(minute).padStart(2, "0");
-  const S = String(second).padStart(2, "0");
-  return `${Y}-${M}-${D}T${H}:${Mi}:${S}${sign}${offHH}:${offMM}`;
-}
-
-function offsetMinutesAt(date: Date, timezone: string): number {
-  // Use Intl.DateTimeFormat with longOffset to read the IANA-zone offset for
-  // the given UTC instant. Output format: "GMT+01:00", "GMT-05:00", or "GMT".
-  const formatter = new Intl.DateTimeFormat("en-US", {
-    timeZone: timezone,
-    timeZoneName: "longOffset",
-  });
-  const parts = formatter.formatToParts(date);
-  const tzPart = parts.find((p) => p.type === "timeZoneName");
-  if (!tzPart) {
-    throw new Error(`parse-export: unable to read offset for timezone "${timezone}".`);
-  }
-  const value = tzPart.value;
-  if (value === "GMT" || value === "UTC") return 0;
-  const m = value.match(/^(?:GMT|UTC)([+-])(\d{1,2}):?(\d{2})?$/);
-  if (!m) {
-    throw new Error(
-      `parse-export: cannot parse timezone offset "${value}" for IANA zone "${timezone}".`,
-    );
-  }
-  const sign = m[1] === "+" ? 1 : -1;
-  const hh = parseInt(m[2], 10);
-  const mm = m[3] ? parseInt(m[3], 10) : 0;
-  return sign * (hh * 60 + mm);
-}

package/payload/platform/plugins/whatsapp-import/lib/src/sessionize.ts

@@ -1,81 +0,0 @@
-import type { ParsedLine } from "./parse-export.js";
-
-// ---------------------------------------------------------------------------
-// sessionize — Pass 1 of the chunked-archive pipeline (Task 891).
-//
-// Pure function. Splits a chronologically-ordered sequence of parsed messages
-// into "sessions" wherever the gap between consecutive `dateSent` values
-// exceeds `gapHours`. Each session feeds memory-classify (mode='chat') as a
-// turn-attributed block; the LLM then chunks each session into one or more
-// `:Section:Conversation` rows with summary+keywords (Pass 2).
-//
-// Why deterministic gap-cut, not LLM topic detection:
-//   - The natural cadence of human chat (sleep, working hours, weekend gaps)
-//     produces clean session boundaries that the operator can intuit.
-//   - LLM-only chunking against a 10K-message archive sends 10K messages into
-//     one prompt and pays attention only to the last 1K — gap-cut bounds the
-//     window before the LLM ever sees it.
-//   - The default 12h gap matches one sleep cycle: messages on the same day
-//     belong together; a 14-hour gap (last evening message → next morning) is
-//     a fresh session even when the topic is identical.
-// ---------------------------------------------------------------------------
-
-export interface Session {
-  /** 0-based index across the archive's sessions. */
-  index: number;
-  /** ISO 8601 timestamp of the first message in the session. */
-  firstMessageAt: string;
-  /** ISO 8601 timestamp of the last message in the session. */
-  lastMessageAt: string;
-  /** Messages in the session, chronological. */
-  messages: ParsedLine[];
-}
-
-/**
- * Split parsed messages into sessions on gaps ≥ `gapHours`. Input must be
- * pre-sorted by `dateSent` (parse-export emits in file order, which IS
- * chronological for any well-formed `_chat.txt`).
- *
- * Boundary semantics (exact-at-threshold):
- *   gap == gapHours    → cut here (start a new session)
- *   gap <  gapHours    → same session
- *   gap >  gapHours    → cut here
- *
- * Empty input returns []; single-message input returns one one-message session.
- */
-export function sessionize(
-  messages: readonly ParsedLine[],
-  gapHours: number,
-): Session[] {
-  if (gapHours <= 0) {
-    throw new Error(`sessionize: gapHours must be positive, got ${gapHours}`);
-  }
-  if (messages.length === 0) return [];
-
-  const gapMs = gapHours * 60 * 60 * 1000;
-  const sessions: Session[] = [];
-  let currentMessages: ParsedLine[] = [messages[0]];
-
-  const flush = () => {
-    sessions.push({
-      index: sessions.length,
-      firstMessageAt: currentMessages[0].dateSent,
-      lastMessageAt: currentMessages[currentMessages.length - 1].dateSent,
-      messages: currentMessages,
-    });
-  };
-
-  for (let i = 1; i < messages.length; i++) {
-    const prevMs = Date.parse(messages[i - 1].dateSent);
-    const currMs = Date.parse(messages[i].dateSent);
-    const gap = currMs - prevMs;
-    if (gap >= gapMs) {
-      flush();
-      currentMessages = [messages[i]];
-    } else {
-      currentMessages.push(messages[i]);
-    }
-  }
-  flush();
-  return sessions;
-}

package/payload/platform/plugins/whatsapp-import/lib/src/to-classifier-input.ts

@@ -1,48 +0,0 @@
-import type { Session } from "./sessionize.js";
-
-// ---------------------------------------------------------------------------
-// to-classifier-input — Pass 2 input formatter (Task 891).
-//
-// Pure function. Renders one Session as a turn-attributed text block ready
-// to hand to memory-classify (mode='chat'). Format:
-//
-//   [YYYY-MM-DD HH:MM:SS TZ] <Sender>: <body>
-//   [YYYY-MM-DD HH:MM:SS TZ] <Sender>: <body>
-//   ...
-//
-// Multi-line message bodies are kept verbatim (with their internal newlines).
-// The leading `[ts] <Sender>: ` prefix is the only structural addition; the
-// classifier prompt instructs Haiku to preserve it in the chunk `body` so
-// downstream Phase 2 work can recover per-message provenance via snippet
-// matching against the conversation tail.
-//
-// Timezone: each `dateSent` ISO already carries an offset (set by parseExport
-// from the operator's confirmed IANA zone). The renderer prints the
-// human-readable wall-clock for that offset; the trailing "TZ" suffix is the
-// offset itself, not a zone name.
-// ---------------------------------------------------------------------------
-
-export function toClassifierInput(session: Session): string {
-  const lines: string[] = [];
-  for (const m of session.messages) {
-    lines.push(`[${formatWallClock(m.dateSent)}] ${m.senderName}: ${m.body}`);
-  }
-  return lines.join("\n");
-}
-
-/**
- * Format an ISO 8601 instant with offset as `YYYY-MM-DD HH:MM:SS ±HH:MM`,
- * preserving the offset that the parser set from the operator's IANA zone.
- * The wall-clock components are read directly from the ISO string — no
- * Date construction (which would re-interpret in the local zone).
- */
-function formatWallClock(iso: string): string {
-  // ISO from parse-export is shaped: "YYYY-MM-DDTHH:MM:SS±HH:MM" (or "Z").
-  const m = iso.match(
-    /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.\d+)?(Z|[+-]\d{2}:?\d{2})$/,
-  );
-  if (!m) return iso; // surface the raw value if the shape drifted; pure function never throws on caller-supplied data
-  const [, y, mo, d, h, mi, s, off] = m;
-  const offsetLabel = off === "Z" ? "+00:00" : off;
-  return `${y}-${mo}-${d} ${h}:${mi}:${s} ${offsetLabel}`;
-}

package/payload/platform/plugins/whatsapp-import/lib/tsconfig.json

@@ -1,9 +0,0 @@
-{
-  "extends": "../../../tsconfig.base.json",
-  "compilerOptions": {
-    "outDir": "dist",
-    "rootDir": "src"
-  },
-  "include": ["src"],
-  "exclude": ["src/__tests__"]
-}

package/payload/platform/plugins/whatsapp-import/lib/vitest.config.ts

@@ -1,9 +0,0 @@
-import { defineConfig } from "vitest/config";
-
-export default defineConfig({
-  test: {
-    environment: "node",
-    globals: false,
-    include: ["src/__tests__/**/*.test.ts"],
-  },
-});