@rubytech/create-realagent 1.0.826 → 1.0.829

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

@@ -1,131 +0,0 @@
-#!/usr/bin/env bash
-# =============================================================================
-# whatsapp-ingest.sh — single deterministic Bash entry for WhatsApp archive
-# ingestion (Task 855 / Task 871). Thin wrapper: arg-validate, resolve env,
-# invoke ingest.mjs in-process. The script is the database-operator
-# subagent's only operator-facing handle on the parse → filter → archive-write
-# pipeline. Phase 1 has NO LLM. The Haiku insight pass is Phase 2 — invoked
-# consciously via `mcp__memory__whatsapp-export-insight-pass`.
-#
-# Usage:
-#   bash whatsapp-ingest.sh <archive.zip|dir|_chat.txt>
-#         --owner-element-id <id>
-#         --subject-person-id <id>
-#         --scope <admin|public>
-#         --filter <all|senders=<csv>|date-range=<isoFrom>..<isoTo>>
-#         [--account-id <accountId>]
-#         [--timezone <iana-zone>]
-#         [--date-format <DD/MM/YY|MM/DD/YY|DD/MM/YYYY|MM/DD/YYYY>]
-#
-# `--subject-person-id` is required (Task 887 §A0). DM scope: the
-# operator-confirmed third-party :Person elementId from the preview
-# histogram. Owner + subject form the closed sender set; any parsed
-# senderName outside that set LOUD-FAILs with `parser-miss` and exits
-# non-zero — bounds writer cardinality to the deterministic preview output.
-#
-# `--filter` is mandatory (Task 871). Forms:
-#   all                              — write every parsed row
-#   senders=Alice,Bob Carter         — keep rows whose senderName ∈ csv
-#   date-range=2024-01-01..2024-06-30
-#                                    — keep rows whose dateSent falls inside
-#                                      the inclusive range (date-only or full
-#                                      ISO 8601 endpoints both accepted)
-#
-# Exit 0  + JSON summary on stdout on success.
-# Exit !0 + one [whatsapp-ingest] FAIL line on stderr on failure.
-# =============================================================================
-
-set -euo pipefail
-
-# Pre-flight arg check — emit the same single-line FAIL shape ingest.mjs uses
-# so the operator's grep pattern catches both layers uniformly.
-arg_fail() {
-  local reason="$1"
-  echo "[whatsapp-ingest] FAIL phase=argv reason=\"${reason}\"" >&2
-  exit 1
-}
-
-# Locate platform root from this script's location:
-#   platform/plugins/whatsapp-import/bin/ → ../../.. = platform/
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PLATFORM_ROOT="$(cd "$SCRIPT_DIR/../../.." && pwd)"
-INGEST_MJS="$SCRIPT_DIR/ingest.mjs"
-
-if [ ! -f "$INGEST_MJS" ]; then
-  arg_fail "ingest.mjs not found at $INGEST_MJS — run from a built install"
-fi
-
-# Validate required flags up-front — gives a cleaner pre-flight error than
-# the node-side throw and keeps the failure surface single-line. argv
-# validation runs before env resolution so a wrong invocation fails on the
-# wrong invocation, not on a missing password.
-ARCHIVE=""
-OWNER_VAL=""
-SUBJECT_VAL=""
-SCOPE_VAL=""
-FILTER_VAL=""
-HAS_OWNER=0
-HAS_SUBJECT=0
-HAS_SCOPE=0
-HAS_FILTER=0
-
-ARGS=("$@")
-i=0
-while [ $i -lt ${#ARGS[@]} ]; do
-  a="${ARGS[$i]}"
-  case "$a" in
-    --owner-element-id)  HAS_OWNER=1;   OWNER_VAL="${ARGS[$((i + 1))]:-}";   i=$((i + 2)); continue ;;
-    --subject-person-id) HAS_SUBJECT=1; SUBJECT_VAL="${ARGS[$((i + 1))]:-}"; i=$((i + 2)); continue ;;
-    --scope)             HAS_SCOPE=1;   SCOPE_VAL="${ARGS[$((i + 1))]:-}";   i=$((i + 2)); continue ;;
-    --filter)            HAS_FILTER=1;  FILTER_VAL="${ARGS[$((i + 1))]:-}";  i=$((i + 2)); continue ;;
-    --account-id|--timezone|--date-format) i=$((i + 2)); continue ;;
-    --*)                 i=$((i + 2)); continue ;;
-    *)
-      if [ -z "$ARCHIVE" ]; then ARCHIVE="$a"; fi
-      i=$((i + 1))
-      continue
-      ;;
-  esac
-done
-
-[ -n "$ARCHIVE" ]                                  || arg_fail "missing positional <archive>"
-[ "$HAS_OWNER"   -eq 1 ] && [ -n "$OWNER_VAL"   ]  || arg_fail "missing --owner-element-id (or empty value)"
-[ "$HAS_SUBJECT" -eq 1 ] && [ -n "$SUBJECT_VAL" ]  || arg_fail "missing --subject-person-id (Task 887: operator-confirmed third-party :Person elementId from preview histogram)"
-[ "$HAS_SCOPE"   -eq 1 ] && [ -n "$SCOPE_VAL"   ]  || arg_fail "missing --scope (or empty value)"
-case "$SCOPE_VAL" in
-  admin|public) : ;;
-  *) arg_fail "invalid --scope \"$SCOPE_VAL\" (admin|public)" ;;
-esac
-if [ "$HAS_FILTER" -ne 1 ] || [ -z "$FILTER_VAL" ]; then
-  # Mirror ingest.mjs's pinned LOUD-FAIL line so a single grep covers both
-  # layers — the operator's runbook recipe is `grep '\[whatsapp-ingest\] FAIL filter-required'`.
-  echo "[whatsapp-ingest] FAIL filter-required reason=\"bulk-archive-gate (Task 871) — operator must specify --filter (one of all, senders=<csv>, date-range=<isoFrom>..<isoTo>)\"" >&2
-  arg_fail "missing --filter (one of all, senders=<csv>, date-range=<isoFrom>..<isoTo>)"
-fi
-
-# Lift NEO4J_PASSWORD from the install's config file when env doesn't carry it
-# (e.g. operator running directly from a shell rather than via the platform
-# server). Mirror seed-neo4j.sh precedence: env var wins, then the file.
-if [ -z "${NEO4J_PASSWORD:-}" ]; then
-  NEO4J_PASSWORD_FILE="$PLATFORM_ROOT/config/.neo4j-password"
-  if [ -f "$NEO4J_PASSWORD_FILE" ]; then
-    NEO4J_PASSWORD="$(cat "$NEO4J_PASSWORD_FILE")"
-    export NEO4J_PASSWORD
-  else
-    arg_fail "NEO4J_PASSWORD not in env and $NEO4J_PASSWORD_FILE not found"
-  fi
-fi
-
-# NEO4J_URI is hard-required (Task 787). The wrapper does not fabricate a
-# default — the platform server sets this at spawn time and the operator can
-# pass it explicitly when running standalone.
-if [ -z "${NEO4J_URI:-}" ]; then
-  arg_fail "NEO4J_URI not set (no default — set in env)"
-fi
-
-export NEO4J_USER="${NEO4J_USER:-neo4j}"
-export MAXY_PLATFORM_ROOT="$PLATFORM_ROOT"
-
-# Hand off to node. ingest.mjs handles all observability; the wrapper does
-# not double-log. Forward exit code verbatim.
-exec node "$INGEST_MJS" "$@"

package/payload/platform/plugins/whatsapp-import/lib/src/__tests__/filter-gate.test.ts

@@ -1,172 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { spawnSync } from "node:child_process";
-import { mkdtempSync, writeFileSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join, resolve, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-
-import { parseFilterArg, applyFilter } from "../filter.js";
-import type { ParsedLine } from "../parse-export.js";
-
-// ---------------------------------------------------------------------------
-// filter-gate — Task 871 contract: --filter is mandatory, three forms.
-//
-// The unit tests cover the helper module's pure-function surface (parse +
-// apply). The integration test spawns ingest.mjs as a subprocess and
-// asserts the no-flag invocation exits non-zero with the LOUD-FAIL line
-// (`[whatsapp-ingest] FAIL phase=argv reason="--filter is required …"`)
-// before any Neo4j connection — argv parsing fires before imports/sessions.
-// ---------------------------------------------------------------------------
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-// src/__tests__/ → ../../bin/ingest.mjs (up to src/, up to lib/, up to plugin
-// root, then bin/).
-const INGEST_MJS = resolve(__dirname, "..", "..", "..", "bin", "ingest.mjs");
-
-function lines(parsed: ParsedLine[]): string[] {
-  return parsed.map((p) => `${p.senderName}@${p.dateSent}:${p.body}`);
-}
-
-const SAMPLE: ParsedLine[] = [
-  { senderName: "Alice", dateSent: "2024-01-15T09:00:00+00:00", body: "morning", sequenceIndex: 0 },
-  { senderName: "Bob",   dateSent: "2024-01-15T09:05:00+00:00", body: "hi",      sequenceIndex: 1 },
-  { senderName: "Alice", dateSent: "2024-03-20T11:00:00+00:00", body: "lunch?",  sequenceIndex: 2 },
-  { senderName: "Carol", dateSent: "2024-06-30T23:59:59+00:00: ", body: "bye",   sequenceIndex: 3 },
-  { senderName: "Bob",   dateSent: "2024-07-01T00:00:01+00:00", body: "next",    sequenceIndex: 4 },
-];
-
-// Repair the malformed dateSent fixture (extra ':' suffix would Date.parse to
-// NaN). Keep this in code, not in the const above, so the fixture reads
-// natural while we still hold a strict tuple.
-SAMPLE[3] = { ...SAMPLE[3], dateSent: "2024-06-30T23:59:59+00:00" };
-
-describe("parseFilterArg — happy path", () => {
-  it('parses --filter all', () => {
-    expect(parseFilterArg("all")).toEqual({ kind: "all" });
-  });
-
-  it('parses senders=<csv> with whitespace tolerance', () => {
-    expect(parseFilterArg("senders=Alice, Bob Carter ,  Carol")).toEqual({
-      kind: "senders",
-      senders: ["Alice", "Bob Carter", "Carol"],
-    });
-  });
-
-  it('parses date-range=<from>..<to>', () => {
-    expect(parseFilterArg("date-range=2024-01-01..2024-06-30")).toEqual({
-      kind: "date-range",
-      fromIso: "2024-01-01",
-      toIso: "2024-06-30",
-    });
-  });
-});
-
-describe("parseFilterArg — LOUD-FAIL on malformed input", () => {
-  it("rejects undefined / empty", () => {
-    expect(() => parseFilterArg(undefined)).toThrow(/--filter is required/);
-    expect(() => parseFilterArg("")).toThrow(/--filter is required/);
-    expect(() => parseFilterArg("   ")).toThrow(/--filter is required/);
-  });
-
-  it("rejects unknown form", () => {
-    expect(() => parseFilterArg("everyone")).toThrow(/unrecognised form/);
-    expect(() => parseFilterArg("nope=yes")).toThrow(/unrecognised form/);
-  });
-
-  it("rejects senders= with no names", () => {
-    expect(() => parseFilterArg("senders=")).toThrow(/at least one/);
-    expect(() => parseFilterArg("senders=,,,")).toThrow(/at least one/);
-  });
-
-  it("rejects date-range with malformed shape or unparseable ISO", () => {
-    expect(() => parseFilterArg("date-range=2024-01-01")).toThrow(/<isoFrom>\.\.<isoTo>/);
-    expect(() => parseFilterArg("date-range=..2024-06-30")).toThrow(/both endpoints/);
-    expect(() => parseFilterArg("date-range=2024-01-01..")).toThrow(/both endpoints/);
-    expect(() => parseFilterArg("date-range=not-a-date..2024-06-30")).toThrow(/not parseable/);
-    expect(() => parseFilterArg("date-range=2024-06-30..2024-01-01")).toThrow(/later than/);
-  });
-});
-
-describe("applyFilter — semantics", () => {
-  it("--filter all keeps every row, preserves the parser's original sequenceIndex", () => {
-    const out = applyFilter(SAMPLE, parseFilterArg("all"));
-    expect(out.length).toBe(SAMPLE.length);
-    expect(out.map((l) => l.sequenceIndex)).toEqual([0, 1, 2, 3, 4]);
-  });
-
-  it("--filter senders=Alice,Bob keeps only those senders, sequenceIndex stays as the parser-stamped value (Carol's index 3 drops out)", () => {
-    const out = applyFilter(SAMPLE, parseFilterArg("senders=Alice,Bob"));
-    expect(lines(out)).toEqual([
-      "Alice@2024-01-15T09:00:00+00:00:morning",
-      "Bob@2024-01-15T09:05:00+00:00:hi",
-      "Alice@2024-03-20T11:00:00+00:00:lunch?",
-      "Bob@2024-07-01T00:00:01+00:00:next",
-    ]);
-    expect(out.map((l) => l.sequenceIndex)).toEqual([0, 1, 2, 4]);
-  });
-
-  it("--filter date-range clips inclusively on both ends", () => {
-    const out = applyFilter(SAMPLE, parseFilterArg("date-range=2024-01-01..2024-06-30"));
-    // 2024-06-30T23:59:59 IS inclusive; 2024-07-01 is NOT.
-    expect(out.map((l) => `${l.senderName}/${l.dateSent}`)).toEqual([
-      "Alice/2024-01-15T09:00:00+00:00",
-      "Bob/2024-01-15T09:05:00+00:00",
-      "Alice/2024-03-20T11:00:00+00:00",
-      "Carol/2024-06-30T23:59:59+00:00",
-    ]);
-  });
-
-  it("--filter date-range with full ISO 8601 endpoints", () => {
-    const out = applyFilter(
-      SAMPLE,
-      parseFilterArg("date-range=2024-03-01T00:00:00Z..2024-06-15T00:00:00Z"),
-    );
-    expect(out).toHaveLength(1);
-    expect(out[0].senderName).toBe("Alice");
-    expect(out[0].body).toBe("lunch?");
-  });
-
-  it("an unmatched senders filter returns []", () => {
-    const out = applyFilter(SAMPLE, parseFilterArg("senders=Nobody"));
-    expect(out).toEqual([]);
-  });
-});
-
-describe("ingest.mjs — missing --filter exits non-zero with LOUD-FAIL line", () => {
-  it("emits [whatsapp-ingest] FAIL phase=argv reason=\"--filter required ...\" before touching Neo4j", () => {
-    // Write a stub _chat.txt; argv parse fires first and rejects the call
-    // before resolveChatTxt/Neo4j connection. We do NOT need a real archive
-    // to test the gate.
-    const work = mkdtempSync(join(tmpdir(), "filter-gate-"));
-    try {
-      const stub = join(work, "_chat.txt");
-      writeFileSync(stub, "[14/03/26, 10:15:23] Joel: stub\n");
-
-      const res = spawnSync(
-        "node",
-        [
-          INGEST_MJS,
-          stub,
-          "--owner-element-id",
-          "stub-owner",
-          "--subject-person-id",
-          "stub-subject",
-          "--scope",
-          "admin",
-        ],
-        { encoding: "utf8" },
-      );
-
-      expect(res.status).not.toBe(0);
-      const stderr = res.stderr ?? "";
-      expect(stderr).toMatch(/\[whatsapp-ingest\] FAIL phase=argv/);
-      expect(stderr).toMatch(/reason="--filter is required/);
-      // Confirm the gate fired BEFORE any Neo4j or import work — no
-      // [whatsapp-ingest] start line, no archive-write log line.
-      expect(stderr).not.toMatch(/\[whatsapp-ingest\] start /);
-      expect(stderr).not.toMatch(/\[memory-archive-write\]/);
-    } finally {
-      rmSync(work, { recursive: true, force: true });
-    }
-  });
-});

package/payload/platform/plugins/whatsapp-import/lib/src/__tests__/ingest-idempotence.test.ts

@@ -1,141 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  normaliseSenderName,
-  sha256Hex,
-  deriveMessageId,
-  observationContentHash,
-} from "../derive-keys.js";
-
-describe("normaliseSenderName", () => {
-  it("returns NFKC-trim-lower form", () => {
-    expect(normaliseSenderName("  Adam Mackay  ")).toBe("adam mackay");
-  });
-
-  it("collapses NFKC equivalent forms (composed vs decomposed accents)", () => {
-    const composed = "Adám";
-    const decomposed = "Adám";
-    expect(normaliseSenderName(composed)).toBe(normaliseSenderName(decomposed));
-  });
-
-  it("collapses full-width characters to ASCII via NFKC", () => {
-    expect(normaliseSenderName("Ａｄａｍ")).toBe("adam");
-  });
-
-  it("returns empty string for empty input without throwing", () => {
-    expect(normaliseSenderName("")).toBe("");
-  });
-});
-
-describe("sha256Hex", () => {
-  it("matches the canonical sha256 of an empty string", () => {
-    expect(sha256Hex("")).toBe(
-      "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
-    );
-  });
-
-  it("produces a deterministic hex digest", () => {
-    expect(sha256Hex("hello")).toBe(sha256Hex("hello"));
-    expect(sha256Hex("hello")).not.toBe(sha256Hex("world"));
-  });
-});
-
-describe("deriveMessageId", () => {
-  const baseInputs = {
-    conversationSha256: "abc123",
-    dateSent: "2026-03-14T10:15:23+00:00",
-    senderName: "Adam Mackay",
-    body: "Hello there",
-  };
-
-  it("produces a stable id for identical inputs", () => {
-    const id1 = deriveMessageId(baseInputs);
-    const id2 = deriveMessageId({ ...baseInputs });
-    expect(id1).toBe(id2);
-  });
-
-  it("collapses identical (sender, dateSent, body) tuples to one id under NFKC-trim-lower (correct for export duplicates)", () => {
-    const id1 = deriveMessageId(baseInputs);
-    const id2 = deriveMessageId({ ...baseInputs, senderName: "  ADAM Mackay  " });
-    expect(id1).toBe(id2);
-  });
-
-  it("changes when the body differs", () => {
-    const id1 = deriveMessageId(baseInputs);
-    const id2 = deriveMessageId({ ...baseInputs, body: "Hello there!" });
-    expect(id1).not.toBe(id2);
-  });
-
-  it("changes when the sender differs (after normalisation)", () => {
-    const id1 = deriveMessageId(baseInputs);
-    const id2 = deriveMessageId({ ...baseInputs, senderName: "Joel" });
-    expect(id1).not.toBe(id2);
-  });
-
-  it("changes when the dateSent differs", () => {
-    const id1 = deriveMessageId(baseInputs);
-    const id2 = deriveMessageId({
-      ...baseInputs,
-      dateSent: "2026-03-14T10:15:24+00:00",
-    });
-    expect(id1).not.toBe(id2);
-  });
-
-  it("changes when the conversation changes", () => {
-    const id1 = deriveMessageId(baseInputs);
-    const id2 = deriveMessageId({ ...baseInputs, conversationSha256: "def456" });
-    expect(id1).not.toBe(id2);
-  });
-
-  it("starts with the whatsapp-export:msg prefix and embeds normalised sender", () => {
-    const id = deriveMessageId(baseInputs);
-    expect(id.startsWith("whatsapp-export:msg:")).toBe(true);
-    expect(id).toContain(":adam mackay:");
-  });
-
-  it("does not embed array-position or FNV32 collapse (Task 870 contract)", () => {
-    const id = deriveMessageId(baseInputs);
-    expect(id).toContain(":msg:");
-    expect(id).toMatch(/:[a-f0-9]{64}$/);
-    expect(id).not.toMatch(/:\d+:[a-f0-9]{8}$/);
-  });
-
-  it("produces a stable id for empty body", () => {
-    const id = deriveMessageId({ ...baseInputs, body: "" });
-    expect(id).toBe(deriveMessageId({ ...baseInputs, body: "" }));
-  });
-});
-
-describe("observationContentHash", () => {
-  it("is deterministic for identical inputs", () => {
-    const fields = { summary: "Adam said hi", from: "Adam", to: "Joel", subject: null };
-    expect(observationContentHash(fields)).toBe(observationContentHash(fields));
-  });
-
-  it("normalises NFKC + trim + lowercase across all fields", () => {
-    const a = { summary: "  Hello  ", from: "ADAM", to: null, subject: null };
-    const b = { summary: "hello", from: "adam", to: null, subject: null };
-    expect(observationContentHash(a)).toBe(observationContentHash(b));
-  });
-
-  it("treats null and empty string equivalently", () => {
-    const withNull = { summary: "x", from: null, to: null, subject: null };
-    const withEmpty = { summary: "x", from: "", to: "", subject: "" };
-    expect(observationContentHash(withNull)).toBe(observationContentHash(withEmpty));
-  });
-
-  it("changes when any field changes", () => {
-    const base = { summary: "x", from: null, to: null, subject: null };
-    expect(observationContentHash(base)).not.toBe(
-      observationContentHash({ ...base, summary: "y" }),
-    );
-    expect(observationContentHash(base)).not.toBe(
-      observationContentHash({ ...base, from: "z" }),
-    );
-  });
-
-  it("collapses NFKC equivalent forms in summary", () => {
-    const composed = { summary: "Adám", from: null, to: null, subject: null };
-    const decomposed = { summary: "Adám", from: null, to: null, subject: null };
-    expect(observationContentHash(composed)).toBe(observationContentHash(decomposed));
-  });
-});

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

@@ -1,83 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { parseExport } from "../parse-export.js";
-
-// Task 887 — bidi-strip regression. Some WhatsApp exports prefix every
-// timestamp header with U+200E (LEFT-TO-RIGHT MARK) or U+200F (RTL MARK).
-// Pre-fix `decodeAndNormalise` left those bytes in place; the timestamp
-// regex (`^\[(\d{2})\/...`) failed; the LRM-prefixed line was glued onto
-// the previous body as a continuation; the next clean header parsed its
-// senderName off the polluted body — leaking 23 :Person nodes per import
-// in the Adam Mackay archive. The fix strips U+200E/U+200F before
-// tokenisation; this test reproduces the failure shape.
-
-let workDir: string;
-
-beforeEach(() => {
-  workDir = mkdtempSync(join(tmpdir(), "whatsapp-export-lrm-"));
-});
-
-afterEach(() => {
-  rmSync(workDir, { recursive: true, force: true });
-});
-
-function writeChat(name: string, content: string): string {
-  const filePath = join(workDir, name);
-  writeFileSync(filePath, content);
-  return filePath;
-}
-
-describe("parseExport — bidi-strip (Task 887)", () => {
-  it("strips U+200E from timestamp headers and parses each row independently", () => {
-    const LRM = "‎";
-    const filePath = writeChat(
-      "_chat.txt",
-      [
-        `${LRM}[04/02/26, 11:52:16] Adam Mackay: hi`,
-        `${LRM}[04/02/26, 11:52:30] Joel Smalley: hey`,
-        "",
-      ].join("\n"),
-    );
-
-    const result = parseExport({
-      filePath,
-      accountId: "acct-887",
-      timezone: "Europe/London",
-    });
-
-    expect(result.parsedLines).toHaveLength(2);
-    expect(result.parsedLines.map((l) => l.senderName).sort()).toEqual([
-      "Adam Mackay",
-      "Joel Smalley",
-    ]);
-    for (const line of result.parsedLines) {
-      expect(line.senderName).not.toContain("\n");
-      expect(line.senderName).not.toContain("[");
-      expect(line.senderName).not.toContain(LRM);
-    }
-  });
-
-  it("strips U+200F (RLM) on the timestamp line", () => {
-    const RLM = "‏";
-    const filePath = writeChat(
-      "_chat.txt",
-      [
-        `${RLM}[14/03/26, 10:15:23] Joel: Hello`,
-        `${RLM}[14/03/26, 10:16:01] Sarah: Hi back`,
-        "",
-      ].join("\n"),
-    );
-
-    const result = parseExport({
-      filePath,
-      accountId: "acct-887",
-      timezone: "Europe/London",
-    });
-
-    expect(result.parsedLines).toHaveLength(2);
-    expect(result.parsedLines[0].senderName).toBe("Joel");
-    expect(result.parsedLines[1].senderName).toBe("Sarah");
-  });
-});