@rubytech/create-realagent 1.0.828 → 1.0.830

package/payload/server/neo4j-migrations-XTQ4WEV6.js

@@ -0,0 +1,428 @@
+import {
+  ACCOUNTS_DIR
+} from "./chunk-5OG7TUQL.js";
+import {
+  getSession,
+  projectAgent
+} from "./chunk-CUSH3UXP.js";
+
+// app/lib/neo4j-migrations.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { resolve as resolve4 } from "path";
+
+// ../neo4j/migrations/004-prune-alien-accounts.ts
+import { readFileSync, readdirSync } from "fs";
+import { resolve } from "path";
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+async function pruneAlienAccounts(driver, platformRoot) {
+  const accountsDir = resolve(platformRoot, "..", "data", "accounts");
+  const validIds = enumerateValidAccountIds(accountsDir);
+  if (validIds.size === 0) {
+    throw new Error(
+      `refusing to prune: no valid accounts found under ${accountsDir} \u2014 corrupt install? not deleting anything to avoid wiping the entire graph.`
+    );
+  }
+  const valid = Array.from(validIds);
+  const session = driver.session();
+  try {
+    const peek = await session.run(
+      `MATCH (n)
+       WHERE n.accountId IS NOT NULL AND NOT n.accountId IN $valid
+       RETURN DISTINCT n.accountId AS aid`,
+      { valid }
+    );
+    const alienIds = [];
+    for (const record of peek.records) {
+      const aid = record.get("aid");
+      if (typeof aid === "string") alienIds.push(aid);
+    }
+    if (alienIds.length === 0) return;
+    const result = await session.run(
+      `MATCH (n)
+       WHERE n.accountId IS NOT NULL AND NOT n.accountId IN $valid
+       DETACH DELETE n
+       RETURN count(n) AS pruned`,
+      { valid }
+    );
+    const prunedRaw = result.records[0]?.get("pruned");
+    const pruned = typeof prunedRaw === "number" ? prunedRaw : prunedRaw?.toNumber?.() ?? 0;
+    console.error(
+      `[graph-invariant] alien-accounts pruned=${pruned} accountIds=${alienIds.join(",")}`
+    );
+  } finally {
+    await session.close();
+  }
+}
+function enumerateValidAccountIds(accountsDir) {
+  const valid = /* @__PURE__ */ new Set();
+  let names;
+  try {
+    names = readdirSync(accountsDir);
+  } catch (err) {
+    if (err.code === "ENOENT") return valid;
+    throw err;
+  }
+  for (const name of names) {
+    if (!UUID_RE.test(name)) continue;
+    const configPath = resolve(accountsDir, name, "account.json");
+    try {
+      JSON.parse(readFileSync(configPath, "utf-8"));
+      valid.add(name);
+    } catch (err) {
+      const code = err.code ?? "parse-error";
+      if (code === "ENOENT") continue;
+      console.error(
+        `[graph-invariant] account-json-skip uuid=${name} reason=${code}`
+      );
+    }
+  }
+  return valid;
+}
+
+// ../neo4j/migrations/004-project-admin-agent.ts
+import { existsSync, readdirSync as readdirSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+async function projectAccountAdmin(accountId, accountDir) {
+  const adminDir = resolve2(accountDir, "agents", "admin");
+  const configPath = resolve2(adminDir, "config.json");
+  if (!existsSync(adminDir) || !existsSync(configPath)) {
+    return { projected: 0, failed: 0 };
+  }
+  try {
+    await projectAgent(accountId, accountDir, "admin");
+    return { projected: 1, failed: 0 };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(
+      `[admin-agent-graph-backfill] account=${accountId.slice(0, 8)} project FAILED error="${msg}"`
+    );
+    return { projected: 0, failed: 1 };
+  }
+}
+async function backfillAdminHandledBy(driver, accountId) {
+  const session = driver.session();
+  try {
+    const result = await session.run(
+      `MATCH (c:AdminConversation {accountId: $accountId})
+       WHERE NOT EXISTS((c)-[:HANDLED_BY]->(:Agent))
+       OPTIONAL MATCH (a:Agent {accountId: $accountId, slug: 'admin'})
+       FOREACH (_ IN CASE WHEN a IS NULL THEN [] ELSE [1] END | MERGE (c)-[:HANDLED_BY]->(a))
+       RETURN
+         count(c) AS candidates,
+         sum(CASE WHEN a IS NULL THEN 0 ELSE 1 END) AS edges`,
+      { accountId }
+    );
+    const toNum = (v) => {
+      if (typeof v === "number") return v;
+      if (v && typeof v.toNumber === "function") {
+        return v.toNumber();
+      }
+      return 0;
+    };
+    return {
+      candidates: toNum(result.records[0]?.get("candidates")),
+      edges: toNum(result.records[0]?.get("edges"))
+    };
+  } finally {
+    await session.close();
+  }
+}
+async function backfillChannel(driver, accountId) {
+  const session = driver.session();
+  try {
+    const result = await session.run(
+      `MATCH (c:Conversation {accountId: $accountId})
+       WHERE c.channel IS NULL
+       SET c.channel = 'webchat'
+       RETURN count(c) AS backfilled`,
+      { accountId }
+    );
+    const raw = result.records[0]?.get("backfilled");
+    if (typeof raw === "number") return raw;
+    if (raw && typeof raw.toNumber === "function") {
+      return raw.toNumber();
+    }
+    return 0;
+  } finally {
+    await session.close();
+  }
+}
+async function applyAdminAgentBackfill(driver, platformRoot) {
+  const accountsDir = resolve2(platformRoot, "..", "data", "accounts");
+  const start = Date.now();
+  if (!existsSync(accountsDir)) {
+    console.error(
+      `[admin-agent-graph-backfill] accounts-dir missing at ${accountsDir} \u2014 nothing to do`
+    );
+    return;
+  }
+  const accountEntries = readdirSync2(accountsDir, { withFileTypes: true }).filter((e) => e.isDirectory());
+  console.error(
+    `[admin-agent-graph-backfill] start accounts=${accountEntries.length}`
+  );
+  let totalProjected = 0;
+  let totalFailed = 0;
+  let totalHandledByCandidates = 0;
+  let totalHandledByEdges = 0;
+  let totalChannelBackfilled = 0;
+  const perAccount = [];
+  for (const entry of accountEntries) {
+    const accountDir = resolve2(accountsDir, entry.name);
+    const accountId = entry.name;
+    const accountStart = Date.now();
+    const { projected, failed } = await projectAccountAdmin(
+      accountId,
+      accountDir
+    );
+    totalProjected += projected;
+    totalFailed += failed;
+    let handledByStats = { candidates: 0, edges: 0 };
+    let channelBackfilled = 0;
+    try {
+      handledByStats = await backfillAdminHandledBy(driver, accountId);
+      totalHandledByCandidates += handledByStats.candidates;
+      totalHandledByEdges += handledByStats.edges;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(
+        `[admin-agent-graph-backfill] account=${accountId.slice(0, 8)} handled-by-backfill FAILED error="${msg}"`
+      );
+    }
+    try {
+      channelBackfilled = await backfillChannel(driver, accountId);
+      totalChannelBackfilled += channelBackfilled;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(
+        `[admin-agent-graph-backfill] account=${accountId.slice(0, 8)} channel-backfill FAILED error="${msg}"`
+      );
+    }
+    perAccount.push({
+      accountId,
+      projected,
+      failed,
+      handledByCandidates: handledByStats.candidates,
+      handledByEdges: handledByStats.edges,
+      channelBackfilled
+    });
+    const ms2 = Date.now() - accountStart;
+    console.error(
+      `[admin-agent-graph-backfill] account=${accountId.slice(0, 8)} projected=${projected} failed=${failed} handled-by-candidates=${handledByStats.candidates} handled-by-edges=${handledByStats.edges} channel-backfilled=${channelBackfilled} ms=${ms2}`
+    );
+  }
+  const ms = Date.now() - start;
+  console.error(
+    `[admin-agent-graph-backfill] done totals: projected=${totalProjected} failed=${totalFailed} handled-by-candidates=${totalHandledByCandidates} handled-by-edges=${totalHandledByEdges} channel-backfilled=${totalChannelBackfilled} ms=${ms}`
+  );
+}
+async function main() {
+  if (!existsSync(ACCOUNTS_DIR)) {
+    console.error(
+      `[admin-agent-graph-backfill] ACCOUNTS_DIR missing at ${ACCOUNTS_DIR} \u2014 nothing to do`
+    );
+    process.exit(0);
+  }
+  const driverShim = { session: () => getSession() };
+  const platformRoot = resolve2(ACCOUNTS_DIR, "..", "..", "platform");
+  try {
+    await applyAdminAgentBackfill(driverShim, platformRoot);
+    process.exit(0);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`[admin-agent-graph-backfill] fatal error="${msg}"`);
+    process.exit(2);
+  }
+}
+if (process.argv[1]?.endsWith("004-project-admin-agent.ts")) {
+  main().catch((err) => {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`[admin-agent-graph-backfill] fatal error="${msg}"`);
+    process.exit(2);
+  });
+}
+
+// ../neo4j/migrations/005-removed-review-feature.ts
+import { resolve as resolve3 } from "path";
+import { unlinkSync } from "fs";
+import { homedir } from "os";
+import { basename, dirname } from "path";
+async function removeReviewFeature(driver, platformRoot) {
+  const session = driver.session();
+  let eventsDeleted = 0;
+  let alertsDeleted = 0;
+  try {
+    const eventResult = await session.run(
+      `MATCH (e:Event)
+       WHERE e.actionTool = "review-digest-compose"
+          OR e.eventId STARTS WITH "review-digest-"
+       DETACH DELETE e
+       RETURN count(e) AS deleted`
+    );
+    eventsDeleted = toNumber(eventResult.records[0]?.get("deleted"));
+    const alertResult = await session.run(
+      `MATCH (a:ReviewAlert)
+       DETACH DELETE a
+       RETURN count(a) AS deleted`
+    );
+    alertsDeleted = toNumber(alertResult.records[0]?.get("deleted"));
+  } finally {
+    await session.close();
+  }
+  const installDirName = basename(dirname(platformRoot));
+  const configDir = resolve3(homedir(), `.${installDirName}`);
+  const artefacts = [
+    resolve3(configDir, "logs", "review.log"),
+    resolve3(configDir, "review-rules.json"),
+    resolve3(configDir, "review-state.json"),
+    resolve3(configDir, "review-pending-alerts.jsonl")
+  ];
+  for (const path of artefacts) {
+    try {
+      unlinkSync(path);
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT") continue;
+      console.error(
+        `[migration] removed-review-feature unlink-skip path=${path} reason=${code ?? "unknown"}`
+      );
+    }
+  }
+  console.error(
+    `[migration] removed-review-feature events=${eventsDeleted} alerts=${alertsDeleted}`
+  );
+}
+function toNumber(v) {
+  if (typeof v === "number") return v;
+  if (v && typeof v.toNumber === "function") {
+    return v.toNumber();
+  }
+  return 0;
+}
+
+// ../neo4j/migrations/006-prune-bogus-whatsapp-persons.ts
+var POLLUTED_NAME_REGEX = "(?s).*[\\n\\[].*";
+async function pruneBogusWhatsappPersons(driver) {
+  const session = driver.session();
+  try {
+    const nonAutoRes = await session.run(
+      `MATCH (p:Person {source: 'whatsapp'})
+       WHERE coalesce(p.participantStatus, '') <> 'auto-created'
+         AND p.name =~ $regex
+       RETURN elementId(p) AS elementId, p.name AS name`,
+      { regex: POLLUTED_NAME_REGEX }
+    );
+    const skippedNonAuto = nonAutoRes.records.length;
+    for (const record of nonAutoRes.records) {
+      const elementId = record.get("elementId");
+      const name = record.get("name");
+      console.error(
+        `[migration:whatsapp-bogus-person-prune] non-auto-match elementId=${elementId} name=${JSON.stringify(name)}`
+      );
+    }
+    const matchedRes = await session.run(
+      `MATCH (p:Person {source: 'whatsapp', participantStatus: 'auto-created'})
+       WHERE p.name =~ $regex
+       RETURN count(p) AS matched`,
+      { regex: POLLUTED_NAME_REGEX }
+    );
+    const matched = toNumber2(matchedRes.records[0]?.get("matched"));
+    if (matched === 0) {
+      console.error(
+        `[migration:whatsapp-bogus-person-prune] matched=0 deleted=0 skipped-non-auto=${skippedNonAuto}`
+      );
+      return;
+    }
+    const deleteRes = await session.run(
+      `MATCH (p:Person {source: 'whatsapp', participantStatus: 'auto-created'})
+       WHERE p.name =~ $regex
+       DETACH DELETE p
+       RETURN count(p) AS deleted`,
+      { regex: POLLUTED_NAME_REGEX }
+    );
+    const deleted = toNumber2(deleteRes.records[0]?.get("deleted"));
+    console.error(
+      `[migration:whatsapp-bogus-person-prune] matched=${matched} deleted=${deleted} skipped-non-auto=${skippedNonAuto}`
+    );
+  } finally {
+    await session.close();
+  }
+}
+function toNumber2(v) {
+  if (typeof v === "number") return v;
+  if (v && typeof v.toNumber === "function") {
+    return v.toNumber();
+  }
+  return 0;
+}
+
+// app/lib/neo4j-migrations.ts
+var BOOT_MIGRATIONS = [
+  { fileName: "003-person-name-eradicate.cypher", slug: "person-name-eradicate" }
+];
+async function applyBootMigrations(driver, platformRoot) {
+  for (const migration of BOOT_MIGRATIONS) {
+    await applyOne(driver, platformRoot, migration);
+  }
+  try {
+    await pruneAlienAccounts(driver, platformRoot);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`[migration] failed prune-alien-accounts error="${msg}"`);
+  }
+  try {
+    await applyAdminAgentBackfill(driver, platformRoot);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`[migration] failed admin-agent-graph-backfill error="${msg}"`);
+  }
+  try {
+    await removeReviewFeature(driver, platformRoot);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`[migration] failed removed-review-feature error="${msg}"`);
+  }
+  try {
+    await pruneBogusWhatsappPersons(driver);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`[migration] failed prune-bogus-whatsapp-persons error="${msg}"`);
+  }
+}
+async function applyOne(driver, platformRoot, migration) {
+  const path = resolve4(platformRoot, "neo4j/migrations", migration.fileName);
+  let cypher;
+  try {
+    cypher = readFileSync2(path, "utf-8");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(
+      `[migration] failed ${migration.slug} error=cannot-read-file path=${path} msg=${msg}`
+    );
+    return;
+  }
+  const session = driver.session();
+  try {
+    const result = await session.run(cypher);
+    const record = result.records[0];
+    const removedRaw = record?.get("removed");
+    const removed = toNumber3(removedRaw);
+    console.error(
+      `[migration] applied ${migration.slug} removed=${removed}`
+    );
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`[migration] failed ${migration.slug} error="${msg}"`);
+  } finally {
+    await session.close();
+  }
+}
+function toNumber3(v) {
+  if (typeof v === "number") return v;
+  if (v && typeof v.toNumber === "function") {
+    return v.toNumber();
+  }
+  return 0;
+}
+export {
+  applyBootMigrations
+};

package/payload/server/server.js

@@ -51,7 +51,7 @@ import {
   vncLog,
   waitForExit,
   writeChromiumWrapper
-} from "./chunk-HAXOJNAM.js";
+} from "./chunk-7BO5HDJC.js";
 import {
   agentLogStream,
   clearSessionHistory,
@@ -79,7 +79,7 @@ import {
   sigtermFlushStreamLogs,
   unregisterSession,
   validateSession
-} from "./chunk-F5QBVHLS.js";
+} from "./chunk-EL4DZ56X.js";
 import {
   ACCOUNTS_DIR,
   PLATFORM_ROOT,
@@ -97,7 +97,7 @@ import {
   openCloudflareTask,
   readTunnelState,
   resolveUnitGoneVerdict
-} from "./chunk-T2OPNP3L.js";
+} from "./chunk-QOJ2D26Z.js";
 import {
   GREETING_DIRECTIVE,
   HAIKU_MODEL,
@@ -129,7 +129,7 @@ import {
   verifyAndGetConversationUpdatedAt,
   verifyConversationOwnership,
   writeAdminUserAndPerson
-} from "./chunk-AEHTLEC3.js";
+} from "./chunk-RC46ZYGT.js";
 
 // ../lib/graph-trash/dist/index.js
 var require_dist = __commonJS({
@@ -7285,7 +7285,7 @@ var app11 = new Hono();
 app11.post("/cancel", requireAdminSession, async (c) => {
   const session_key = c.var.sessionKey;
   try {
-    const { interruptClient: interruptClient2 } = await import("./client-pool-FXCFSUXR.js");
+    const { interruptClient: interruptClient2 } = await import("./client-pool-7NTEFNVQ.js");
     await interruptClient2(session_key);
     return c.json({ ok: true });
   } catch (err) {
@@ -12832,7 +12832,7 @@ autoDeliverPremiumPlugins(bootEntitlement?.purchasedPlugins ?? void 0);
 (async () => {
   if (!bootAccount) return;
   try {
-    const { recoverRunningCloudflareTasks } = await import("./cloudflare-task-tracker-CR6TL4VL.js");
+    const { recoverRunningCloudflareTasks } = await import("./cloudflare-task-tracker-WE77WXSI.js");
     const result = await recoverRunningCloudflareTasks(
       bootAccount.accountId,
       configDirForWhatsApp,

package/payload/platform/plugins/whatsapp-import/PLUGIN.md

@@ -1,48 +0,0 @@
----
-name: whatsapp-import
-description: "Import a WhatsApp `_chat.txt` export into the {{productName}} Neo4j graph as a `:ConversationArchive` parent + chunked `:Section:Conversation` children (the chunked-archive contract). Single-phase ingest: parse → operator-confirms owner + every participant → sessionize at gap-hours boundary → Haiku-chunk each session into topic-bounded :Section:Conversation rows with summary + topic keywords. Re-imports are delta-append: prior chunks never touched. Insight derivation (`:Observation` / `:Task` / `:Preference`) is deferred to a separate follow-up task. Skill-only plugin owned by the database-operator specialist. Opt-in per brand — not enabled by default. Distinct from the live `whatsapp` plugin (Baileys QR pairing + in-memory store)."
-tools: []
-always: false
-embed: false
-specialist: database-operator
-metadata: {"platform":{"optional":true,"pluginKey":"whatsapp-import"}}
----
-
-# WhatsApp Import
-
-Ingests a WhatsApp "Export Chat" archive (the `_chat.txt` file plus media attachments) into the {{productName}} Neo4j graph as a single document-shaped `:ConversationArchive` with chunked `:Section:Conversation` children. Skill-only plugin — no MCP server, no admin tools added. The skill runs under the `database-operator` specialist, which owns external-archive ingestion and ad-hoc graph operations.
-
-## Single-phase contract (the chunked-archive contract)
-
-Pre-Task-891 the plugin shipped two skills (`whatsapp-import` for raw load + `whatsapp-import-enrich` for Haiku-driven `:Observation` extraction). The split worked but operated at per-message granularity: insights were attached to individual `:Message` rows, missing intent that spans multiple turns, and the auto-`:Person` participant pattern leaked entities on every parser miss. the chunked-archive contract retires both skills and the per-message writer in favour of a single-phase contract:
-
-1. **Parse** — deterministic `_chat.txt` parser (unchanged from the deterministic parser contract).
-2. **Operator confirmation** — every distinct senderName must resolve to an existing `:AdminUser` or `:Person` elementId. No auto-creation.
-3. **Sessionize** — split parsed messages at gap-hours boundaries (default 12h).
-4. **Classify** — each session goes to Haiku via `memory-classify` with `mode='chat'`; returns one or more `:Section:Conversation` chunks with topic-bounded `summary`, `keywords`, `firstMessageAt`, `lastMessageAt`, `participantNames`, `messageCount`, and verbatim turn-attributed `body`.
-5. **Write** — `memory-ingest` with `parentLabel='ConversationArchive'` MERGEs the parent on `conversationIdentity = sha256(accountId + ":" + sortedParticipantElementIds)`, MERGEs `:PARTICIPANT_IN` edges, drops any prior chunks for THIS export's SHA-256 (idempotency), CREATEs new chunks, and extends the existing `:NEXT` chain from its tail.
-
-Re-imports are delta-append: prior chunks are never touched, only messages after `lastIngestedMessageHash` flow through the pipeline. See [skills/whatsapp-import/references/conversation-archive-shape.md](skills/whatsapp-import/references/conversation-archive-shape.md) for the full schema.
-
-Insight derivation (`:Observation` / `:Task` / `:Preference` / `:MENTIONS`, anchored to chunks) is deferred to a separate follow-up task with its own skill name.
-
-## When this applies
-
-The admin agent delegates to `database-operator` when the operator drops a `_chat.txt` (or its containing folder) into chat. The specialist runs the skill's owner + all-participants confirmation flow before any line is written, then invokes the deterministic Bash entry (`bin/whatsapp-ingest.sh`) once: parse → sessionize → in-process Haiku classify → in-process memory-ingest all run in one Node process.
-
-## Accepted export shapes
-
-WhatsApp's "Export Chat" emits `[DD/MM/YYYY, HH:MM:SS]` prefixes by default in modern releases and `[DD/MM/YY, HH:MM:SS]` in legacy exports. The parser accepts both year shapes (2-digit mapped `2000+yy`, 4-digit passed through) within a single file and auto-detects DD/MM vs MM/DD ordering from the first matched line — see [skills/whatsapp-import/references/export-parse.md](skills/whatsapp-import/references/export-parse.md) for the full grammar contract.
-
-## What this is not
-
-- **Not** the live `whatsapp` plugin. That plugin (Baileys QR pairing) holds messages in an in-memory store cleared on restart. This plugin imports historical exports into Neo4j as persistent graph nodes. Names are deliberately distinct (`whatsapp-import` vs `whatsapp`) so the boundary is mechanical.
-- **Not** a media-transcription pipeline. Voice notes (`.opus`), photos, PDFs are skipped at parse with a counter logged. Transcription / OCR is a separate plugin decision.
-- **Not** a generic chat-export importer. Each messaging channel (Telegram, iMessage, Signal, SMS dump) ships as its own opt-in plugin under the same shape when requested.
-- **Not** an insight-extraction pass. `:Observation` / `:Task` / `:Preference` derivation against chunks is a separate, follow-up task.
-
-## Relationship to other plugins
-
-- **memory** — provides `memory-classify` (with `mode='chat'`) and `memory-ingest` (with `parentLabel='ConversationArchive'`). The whatsapp-import bin imports both in-process — no MCP envelope between steps. All writes carry `source='whatsapp'` + `createdByAgent='whatsapp-import'` provenance. The legacy `mcp__memory__whatsapp-export-parse` / `whatsapp-export-insight-write` MCP tools and the `memory-archive-write` MCP path with `archiveType=whatsapp-export` are blocked at the harness — the Bash entry is the only supported invocation surface.
-- **database-operator specialist** — owns execution. See [admin/IDENTITY.md](../../../platform/templates/agents/admin/IDENTITY.md) delegation clause and [database-operator.md](../../../platform/templates/specialists/agents/database-operator.md) per-source archive list (which now names the chunked-archive shape under the WhatsApp entry).
-- **linkedin-import** — sister plugin under the same opt-in pattern (LinkedIn Basic Data Export). Reading [linkedin-import/PLUGIN.md](../linkedin-import/PLUGIN.md) is the fastest way to understand the load-phase shape that complements this plugin's chunked-archive approach.

package/payload/platform/plugins/whatsapp-import/lib/src/__tests__/delta-append.test.ts

@@ -1,163 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { findDeltaCursor } from "../delta-cursor.js";
-import {
-  deriveConversationIdentity,
-  deriveMessageContentHash,
-  normaliseSenderName,
-} from "../derive-keys.js";
-import type { ParsedLine } from "../parse-export.js";
-
-function mk(dateSent: string, senderName: string, body: string): ParsedLine {
-  return { dateSent, senderName, body, sequenceIndex: 0 };
-}
-
-describe("deriveConversationIdentity", () => {
-  it("is stable across participant order (sorted internally)", () => {
-    const a = deriveConversationIdentity({
-      accountId: "acct-1",
-      participantElementIds: ["1:abc:1", "1:abc:2"],
-    });
-    const b = deriveConversationIdentity({
-      accountId: "acct-1",
-      participantElementIds: ["1:abc:2", "1:abc:1"],
-    });
-    expect(a).toBe(b);
-  });
-
-  it("changes when accountId differs", () => {
-    const a = deriveConversationIdentity({
-      accountId: "acct-1",
-      participantElementIds: ["1:abc:1", "1:abc:2"],
-    });
-    const b = deriveConversationIdentity({
-      accountId: "acct-2",
-      participantElementIds: ["1:abc:1", "1:abc:2"],
-    });
-    expect(a).not.toBe(b);
-  });
-
-  it("rejects empty participant array", () => {
-    expect(() =>
-      deriveConversationIdentity({
-        accountId: "acct-1",
-        participantElementIds: [],
-      }),
-    ).toThrow(/non-empty/);
-  });
-
-  it("rejects empty accountId", () => {
-    expect(() =>
-      deriveConversationIdentity({
-        accountId: "",
-        participantElementIds: ["1:abc:1"],
-      }),
-    ).toThrow(/accountId/);
-  });
-
-  it("treats DM and group identically (same formula, different array length)", () => {
-    const dm = deriveConversationIdentity({
-      accountId: "acct-1",
-      participantElementIds: ["1:a:1", "1:a:2"],
-    });
-    const group = deriveConversationIdentity({
-      accountId: "acct-1",
-      participantElementIds: ["1:a:1", "1:a:2", "1:a:3"],
-    });
-    expect(dm).not.toBe(group);
-    // Both must hex-decode to a sha256 (64 hex chars).
-    expect(dm).toMatch(/^[a-f0-9]{64}$/);
-    expect(group).toMatch(/^[a-f0-9]{64}$/);
-  });
-});
-
-describe("deriveMessageContentHash", () => {
-  it("is content-only — no archive bytes contribute", () => {
-    const a = deriveMessageContentHash({
-      dateSent: "2026-03-14T10:00:00+00:00",
-      senderName: "Joel",
-      body: "hi",
-    });
-    const b = deriveMessageContentHash({
-      dateSent: "2026-03-14T10:00:00+00:00",
-      senderName: "Joel",
-      body: "hi",
-    });
-    expect(a).toBe(b);
-  });
-
-  it("changes when any field changes", () => {
-    const base = {
-      dateSent: "2026-03-14T10:00:00+00:00",
-      senderName: "Joel",
-      body: "hi",
-    };
-    expect(deriveMessageContentHash(base)).not.toBe(
-      deriveMessageContentHash({ ...base, body: "hello" }),
-    );
-    expect(deriveMessageContentHash(base)).not.toBe(
-      deriveMessageContentHash({ ...base, senderName: "Adam" }),
-    );
-    expect(deriveMessageContentHash(base)).not.toBe(
-      deriveMessageContentHash({ ...base, dateSent: "2026-03-14T10:00:01+00:00" }),
-    );
-  });
-
-  it("collapses NFKC-equivalent sender names to one hash", () => {
-    const a = deriveMessageContentHash({
-      dateSent: "2026-03-14T10:00:00+00:00",
-      senderName: "  ADAM Mackay  ",
-      body: "hi",
-    });
-    const b = deriveMessageContentHash({
-      dateSent: "2026-03-14T10:00:00+00:00",
-      senderName: "adam mackay",
-      body: "hi",
-    });
-    expect(a).toBe(b);
-  });
-});
-
-describe("normaliseSenderName", () => {
-  it("returns NFKC-trim-lower form", () => {
-    expect(normaliseSenderName("  Adam Mackay  ")).toBe("adam mackay");
-  });
-});
-
-describe("findDeltaCursor", () => {
-  const lines: ParsedLine[] = [
-    mk("2026-03-14T10:00:00+00:00", "Joel", "first"),
-    mk("2026-03-14T10:01:00+00:00", "Adam", "second"),
-    mk("2026-03-14T10:02:00+00:00", "Joel", "third"),
-  ];
-  const hashFor = (l: ParsedLine) =>
-    deriveMessageContentHash({
-      dateSent: l.dateSent,
-      senderName: l.senderName,
-      body: l.body,
-    });
-
-  it("returns 'found' with deltaStart = cursor + 1 when the hash matches a prior line", () => {
-    const result = findDeltaCursor(lines, hashFor(lines[0]));
-    expect(result).toEqual({ kind: "found", deltaStart: 1 });
-  });
-
-  it("returns 'empty' when the cursor is the last line (no new messages)", () => {
-    const result = findDeltaCursor(lines, hashFor(lines[2]));
-    expect(result).toEqual({ kind: "empty" });
-  });
-
-  it("returns 'missing' when no parsed line matches (LOUD-FAIL upstream)", () => {
-    const result = findDeltaCursor(lines, "deadbeef".repeat(8));
-    expect(result).toEqual({ kind: "missing" });
-  });
-
-  it("returns 'missing' for an empty parsed sequence (cursor cannot exist)", () => {
-    const result = findDeltaCursor([], hashFor(lines[0]));
-    expect(result).toEqual({ kind: "missing" });
-  });
-
-  it("rejects empty cursor hash", () => {
-    expect(() => findDeltaCursor(lines, "")).toThrow(/non-empty/);
-    expect(() => findDeltaCursor(lines, "   ")).toThrow(/non-empty/);
-  });
-});