@rubytech/create-realagent 1.0.828 → 1.0.830

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

@@ -1,91 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { sessionize } from "../sessionize.js";
-import type { ParsedLine } from "../parse-export.js";
-
-function mk(dateSent: string, body = "x"): ParsedLine {
-  return { senderName: "Joel", dateSent, body, sequenceIndex: 0 };
-}
-
-describe("sessionize", () => {
-  it("returns [] for empty input", () => {
-    expect(sessionize([], 12)).toEqual([]);
-  });
-
-  it("returns one one-message session for a single message", () => {
-    const out = sessionize([mk("2026-03-14T10:00:00+00:00")], 12);
-    expect(out).toHaveLength(1);
-    expect(out[0].messages).toHaveLength(1);
-    expect(out[0].index).toBe(0);
-    expect(out[0].firstMessageAt).toBe("2026-03-14T10:00:00+00:00");
-    expect(out[0].lastMessageAt).toBe("2026-03-14T10:00:00+00:00");
-  });
-
-  it("groups messages within the gap into one session", () => {
-    const messages = [
-      mk("2026-03-14T10:00:00+00:00"),
-      mk("2026-03-14T11:00:00+00:00"),
-      mk("2026-03-14T12:00:00+00:00"),
-    ];
-    const out = sessionize(messages, 12);
-    expect(out).toHaveLength(1);
-    expect(out[0].messages).toHaveLength(3);
-  });
-
-  it("cuts at gap > gapHours", () => {
-    const messages = [
-      mk("2026-03-14T10:00:00+00:00"),
-      mk("2026-03-14T11:00:00+00:00"),
-      mk("2026-03-14T23:30:00+00:00"), // 12.5h gap from previous
-      mk("2026-03-15T00:00:00+00:00"),
-    ];
-    const out = sessionize(messages, 12);
-    expect(out).toHaveLength(2);
-    expect(out[0].messages).toHaveLength(2);
-    expect(out[1].messages).toHaveLength(2);
-    expect(out[1].index).toBe(1);
-  });
-
-  it("cuts at exact-at-threshold (gap == gapHours triggers a cut)", () => {
-    const messages = [
-      mk("2026-03-14T10:00:00+00:00"),
-      mk("2026-03-14T22:00:00+00:00"), // exactly 12h gap
-    ];
-    const out = sessionize(messages, 12);
-    expect(out).toHaveLength(2);
-  });
-
-  it("does not cut at gap just under threshold", () => {
-    const messages = [
-      mk("2026-03-14T10:00:00+00:00"),
-      mk("2026-03-14T21:59:59+00:00"), // 11h59m59s gap
-    ];
-    const out = sessionize(messages, 12);
-    expect(out).toHaveLength(1);
-  });
-
-  it("emits firstMessageAt / lastMessageAt from the session boundary messages", () => {
-    const messages = [
-      mk("2026-03-14T10:00:00+00:00"),
-      mk("2026-03-14T11:00:00+00:00"),
-      mk("2026-03-14T12:00:00+00:00"),
-    ];
-    const out = sessionize(messages, 12);
-    expect(out[0].firstMessageAt).toBe("2026-03-14T10:00:00+00:00");
-    expect(out[0].lastMessageAt).toBe("2026-03-14T12:00:00+00:00");
-  });
-
-  it("rejects non-positive gapHours", () => {
-    expect(() => sessionize([mk("2026-03-14T10:00:00+00:00")], 0)).toThrow(/positive/);
-    expect(() => sessionize([mk("2026-03-14T10:00:00+00:00")], -1)).toThrow(/positive/);
-  });
-
-  it("indexes sessions starting at 0 in chronological order", () => {
-    const messages = [
-      mk("2026-03-14T10:00:00+00:00"),
-      mk("2026-03-15T10:00:00+00:00"), // 24h gap
-      mk("2026-03-16T10:00:00+00:00"), // 24h gap
-    ];
-    const out = sessionize(messages, 12);
-    expect(out.map((s) => s.index)).toEqual([0, 1, 2]);
-  });
-});

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

@@ -1,59 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { toClassifierInput } from "../to-classifier-input.js";
-import type { Session } from "../sessionize.js";
-
-function mkSession(messages: Session["messages"]): Session {
-  return {
-    index: 0,
-    firstMessageAt: messages[0].dateSent,
-    lastMessageAt: messages[messages.length - 1].dateSent,
-    messages,
-  };
-}
-
-describe("toClassifierInput", () => {
-  it("renders one line per message in `[ts] Sender: body` form", () => {
-    const session = mkSession([
-      { senderName: "Joel", dateSent: "2026-03-14T10:00:00+00:00", body: "hi", sequenceIndex: 0 },
-      { senderName: "Adam", dateSent: "2026-03-14T10:01:00+00:00", body: "hey", sequenceIndex: 1 },
-    ]);
-    expect(toClassifierInput(session)).toBe(
-      "[2026-03-14 10:00:00 +00:00] Joel: hi\n[2026-03-14 10:01:00 +00:00] Adam: hey",
-    );
-  });
-
-  it("preserves the operator's offset in the formatted timestamp", () => {
-    const session = mkSession([
-      { senderName: "Joel", dateSent: "2026-03-14T10:00:00+01:00", body: "hi", sequenceIndex: 0 },
-    ]);
-    expect(toClassifierInput(session)).toBe("[2026-03-14 10:00:00 +01:00] Joel: hi");
-  });
-
-  it("normalises a 'Z' offset to +00:00 in the rendered form", () => {
-    const session = mkSession([
-      { senderName: "Joel", dateSent: "2026-03-14T10:00:00Z", body: "hi", sequenceIndex: 0 },
-    ]);
-    expect(toClassifierInput(session)).toBe("[2026-03-14 10:00:00 +00:00] Joel: hi");
-  });
-
-  it("preserves multi-line message bodies verbatim (no escape, internal newlines retained)", () => {
-    const session = mkSession([
-      {
-        senderName: "Joel",
-        dateSent: "2026-03-14T10:00:00+00:00",
-        body: "line one\nline two",
-        sequenceIndex: 0,
-      },
-    ]);
-    expect(toClassifierInput(session)).toBe(
-      "[2026-03-14 10:00:00 +00:00] Joel: line one\nline two",
-    );
-  });
-
-  it("falls back to the raw ISO when the timestamp shape does not match (defensive)", () => {
-    const session = mkSession([
-      { senderName: "Joel", dateSent: "not-an-iso", body: "hi", sequenceIndex: 0 },
-    ]);
-    expect(toClassifierInput(session)).toBe("[not-an-iso] Joel: hi");
-  });
-});

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

@@ -1,54 +0,0 @@
-import type { ParsedLine } from "./parse-export.js";
-import { deriveMessageContentHash } from "./derive-keys.js";
-
-// ---------------------------------------------------------------------------
-// delta-cursor — locate the cursor for delta-append re-imports (Task 891).
-//
-// Pure function. Given a parsed re-export and the `lastIngestedMessageHash`
-// recorded on the prior `:ConversationArchive`, find the position of the
-// matching message in the parsed sequence and return `index + 1` (the slice
-// start for the delta). Three outcomes:
-//
-//   { kind: "found", deltaStart }    → slice parsedLines from deltaStart
-//   { kind: "empty" }                → cursor is the last line; no delta
-//   { kind: "missing" }              → cursor not found (LOUD-FAIL upstream)
-//
-// `missing` covers both the "operator deleted prior messages from the
-// re-export" case and the "operator imported a different chat archive"
-// case. The orchestrator emits `[whatsapp-import] FAIL delta-cursor-missing`
-// and exits non-zero when this surfaces.
-// ---------------------------------------------------------------------------
-
-export type CursorResult =
-  | { kind: "found"; deltaStart: number }
-  | { kind: "empty" }
-  | { kind: "missing" };
-
-/**
- * Walk parsed lines forward and return the first index whose content hash
- * matches `lastIngestedMessageHash`. The first match is correct because
- * messages with identical (dateSent, normalisedSenderName, body) tuples
- * are genuine duplicates — there is no way to disambiguate them and slicing
- * after the first occurrence is the chronologically safe choice.
- */
-export function findDeltaCursor(
-  parsedLines: readonly ParsedLine[],
-  lastIngestedMessageHash: string,
-): CursorResult {
-  if (!lastIngestedMessageHash || !lastIngestedMessageHash.trim()) {
-    throw new Error("findDeltaCursor: lastIngestedMessageHash must be non-empty");
-  }
-  for (let i = 0; i < parsedLines.length; i++) {
-    const line = parsedLines[i];
-    const hash = deriveMessageContentHash({
-      dateSent: line.dateSent,
-      senderName: line.senderName,
-      body: line.body,
-    });
-    if (hash === lastIngestedMessageHash) {
-      if (i === parsedLines.length - 1) return { kind: "empty" };
-      return { kind: "found", deltaStart: i + 1 };
-    }
-  }
-  return { kind: "missing" };
-}

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

@@ -1,82 +0,0 @@
-import { createHash } from "node:crypto";
-
-// ---------------------------------------------------------------------------
-// derive-keys — natural-key derivation for whatsapp-import (Task 891,
-// supersedes Task 870's per-message contract).
-//
-// Pure functions. No I/O. The whole point is that re-imports of the same
-// archive collapse to the same identity regardless of release-level drift in
-// chunk indices, hash widths, or arbitrary tiebreakers.
-//
-// Identity contracts (Task 891 brief):
-//
-//   conversationIdentity   = sha256(accountId + ":" + sortedParticipantElementIds.join(","))
-//   messageContentHash     = sha256(dateSent + "|" + NFKC-trim-lower(senderName) + "|" + body)
-//
-// `conversationIdentity` is stable across re-exports — same operator + same
-// participant set → same identity, regardless of file bytes. DM and group
-// follow the same formula; the difference is the participant array length.
-// `messageContentHash` is content-only (no archive sha256, no chunk index)
-// so cursor lookup survives a fresh re-export of the same chat.
-// ---------------------------------------------------------------------------
-
-export function normaliseSenderName(name: string): string {
-  return name.normalize("NFKC").trim().toLowerCase();
-}
-
-export function sha256Hex(input: string): string {
-  return createHash("sha256").update(input).digest("hex");
-}
-
-export interface DeriveConversationIdentityInput {
-  accountId: string;
-  /**
-   * Element IDs of every confirmed participant (owner + others). Order is
-   * not significant; the function sorts internally so the same set always
-   * produces the same identity.
-   */
-  participantElementIds: readonly string[];
-}
-
-/**
- * Compute the stable identity for a conversation. Same accountId + same
- * participant set ⇒ same identity, regardless of message content or export
- * file bytes. DM and group chats use this identical formula.
- */
-export function deriveConversationIdentity(
-  input: DeriveConversationIdentityInput,
-): string {
-  if (!input.accountId || !input.accountId.trim()) {
-    throw new Error("deriveConversationIdentity: accountId is required");
-  }
-  if (input.participantElementIds.length === 0) {
-    throw new Error("deriveConversationIdentity: participantElementIds must be non-empty");
-  }
-  const sorted = [...input.participantElementIds].sort();
-  return sha256Hex(`${input.accountId}:${sorted.join(",")}`);
-}
-
-export interface DeriveMessageContentHashInput {
-  /** ISO 8601 with timezone offset, as emitted by parseExport. */
-  dateSent: string;
-  /** Raw senderName from the export line. Normalised internally. */
-  senderName: string;
-  /** Raw message body. */
-  body: string;
-}
-
-/**
- * Compute a content-only hash for a single message. Used as the delta-append
- * cursor: `:ConversationArchive.lastIngestedMessageHash` records the hash of
- * the last ingested message; on re-import, the orchestrator finds the line
- * with the matching hash and slices everything after it.
- *
- * Excludes archive sha256 deliberately — the cursor must survive a fresh
- * re-export of the same chat (different file bytes, same message tuples).
- */
-export function deriveMessageContentHash(
-  input: DeriveMessageContentHashInput,
-): string {
-  const norm = normaliseSenderName(input.senderName);
-  return sha256Hex(`${input.dateSent}|${norm}|${input.body}`);
-}

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

@@ -1,22 +0,0 @@
-export { parseExport } from "./parse-export.js";
-export type {
-  ParseExportInput,
-  ParseExportResult,
-  ParseExportCounters,
-  ParsedLine,
-} from "./parse-export.js";
-export {
-  normaliseSenderName,
-  sha256Hex,
-  deriveConversationIdentity,
-  deriveMessageContentHash,
-} from "./derive-keys.js";
-export type {
-  DeriveConversationIdentityInput,
-  DeriveMessageContentHashInput,
-} from "./derive-keys.js";
-export { sessionize } from "./sessionize.js";
-export type { Session } from "./sessionize.js";
-export { toClassifierInput } from "./to-classifier-input.js";
-export { findDeltaCursor } from "./delta-cursor.js";
-export type { CursorResult } from "./delta-cursor.js";