@withone/cli 1.50.0 → 1.51.0

package/dist/{chunk-GXOIR3GF.js → chunk-ZOJW6IMU.js}

@@ -10,7 +10,7 @@ import {
 import {
   getBackend,
   upsertRecord
-} from "./chunk-7RV7T5PX.js";
+} from "./chunk-Z4KAQGIG.js";
 
 // src/commands/mem/migrate.ts
 import fs4 from "fs";
@@ -387,6 +387,273 @@ function deleteDatabase(platform) {
   if (fs3.existsSync(dbPath + "-shm")) fs3.unlinkSync(dbPath + "-shm");
 }
 
+// src/lib/memory/sync/mem-writer.ts
+function resolveWildcardPath(root, path5) {
+  const segments = path5.split("[]");
+  if (segments.length === 1) {
+    return [getByDotPath(root, path5)];
+  }
+  const recurse = (value, idx) => {
+    if (value === null || value === void 0) return [];
+    const segment = segments[idx];
+    const head = segment.startsWith(".") ? segment.slice(1) : segment;
+    if (idx === segments.length - 1) {
+      if (!Array.isArray(value)) return [];
+      if (head === "") return value;
+      return value.map((el) => getByDotPath(el, head));
+    }
+    if (!Array.isArray(value)) return [];
+    const results = [];
+    for (const el of value) {
+      const next = head === "" ? el : getByDotPath(el, head);
+      results.push(...recurse(next, idx + 1));
+    }
+    return results;
+  };
+  const firstHead = segments[0];
+  const firstValue = firstHead === "" ? root : getByDotPath(root, firstHead);
+  return recurse(firstValue, 1);
+}
+function extractSearchableFromPaths(record, paths) {
+  const parts = [];
+  const perPath = [];
+  for (const path5 of paths) {
+    const values = resolveWildcardPath(record, path5);
+    const collected = [];
+    const absorb = (v) => {
+      if (v === null || v === void 0) return;
+      if (typeof v === "string") {
+        const t = v.trim();
+        if (t) collected.push(t);
+      } else if (typeof v === "number" || typeof v === "boolean") {
+        collected.push(String(v));
+      } else if (Array.isArray(v)) {
+        for (const inner of v) absorb(inner);
+      }
+    };
+    for (const v of values) absorb(v);
+    if (collected.length > 0) {
+      parts.push(...collected);
+      perPath.push({ path: path5, found: true, sample: collected.join(" ").slice(0, 80) });
+    } else {
+      perPath.push({ path: path5, found: false, sample: "" });
+    }
+  }
+  const text = parts.join(" ").replace(/\s+/g, " ").trim();
+  return { text, paths: perPath };
+}
+function getSearchablePaths(profile) {
+  const paths = profile.memory?.searchable;
+  if (!paths || !Array.isArray(paths) || paths.length === 0) return void 0;
+  return paths;
+}
+async function writePageToMemory(profile, records, opts = {}) {
+  const report = {
+    attempted: 0,
+    inserted: 0,
+    updated: 0,
+    skipped: 0,
+    preserved: 0,
+    sourceKeysSeen: [],
+    inserts: [],
+    updates: []
+  };
+  const type = `${profile.platform}/${profile.model}`;
+  const embedFlag = opts.embedOverride ?? deriveEmbedFlag(profile);
+  const searchablePaths = getSearchablePaths(profile);
+  const declaresIdentityKeys = (profile.identityKeys?.length ?? 0) > 0;
+  const enrichTimestampField = profile.enrich?.timestampField ?? "_enriched_at";
+  for (const record of records) {
+    report.attempted++;
+    const externalId = getByDotPath(record, profile.idField);
+    if (externalId === void 0 || externalId === null || externalId === "") {
+      report.skipped++;
+      continue;
+    }
+    if (typeof externalId === "object") {
+      report.skipped++;
+      continue;
+    }
+    const sourceKey = `${type}:${String(externalId)}`;
+    const alreadyEnriched = opts.alreadyEnrichedIds?.has(String(externalId)) ?? false;
+    if (alreadyEnriched) report.preserved++;
+    const keys = [sourceKey, ...collectEntityKeys(record, profile)];
+    const preEnrichShape = !!profile.enrich && record[enrichTimestampField] == null;
+    const identityKeys = !declaresIdentityKeys || preEnrichShape ? void 0 : collectAssociationKeys(record, profile);
+    const data = { ...record };
+    for (const k of Object.keys(data)) {
+      if (k.startsWith("_")) delete data[k];
+    }
+    const searchable_text = searchablePaths ? extractSearchableFromPaths(record, searchablePaths).text : void 0;
+    try {
+      const res = await upsertRecord(
+        {
+          type,
+          data,
+          keys,
+          identity_keys: identityKeys,
+          searchable_text,
+          sources: {
+            [sourceKey]: {
+              last_synced_at: (/* @__PURE__ */ new Date()).toISOString(),
+              metadata: { source: profile.platform }
+            }
+          },
+          tags: ["synced", profile.platform],
+          embed: embedFlag
+        },
+        // Sync must REPLACE: if a field vanished at the source (phone
+        // number removed, Gmail thread archived) it must also vanish
+        // from memory. The default merge behaviour is correct for
+        // interactive `mem add` / `mem update`, wrong for sync.
+        //
+        // ...unless this row is already enriched, in which case we are the
+        // thin half of the record and must not speak for the whole of it.
+        // See the "NEVER DEGRADE" comment above.
+        alreadyEnriched ? { embed: embedFlag, replace: false, preserveDerived: true } : { embed: embedFlag, replace: true }
+      );
+      report.sourceKeysSeen.push(sourceKey);
+      if (res.action === "inserted") {
+        report.inserted++;
+        if (opts.capturePerAction) report.inserts.push(record);
+      } else {
+        report.updated++;
+        if (opts.capturePerAction) report.updates.push(record);
+      }
+    } catch {
+      report.skipped++;
+    }
+  }
+  return report;
+}
+function deriveEmbedFlag(profile) {
+  if (profile.memory && typeof profile.memory.embed === "boolean") return profile.memory.embed;
+  return false;
+}
+function deriveIdentityPrefix(dotPath) {
+  const lower = dotPath.toLowerCase();
+  if (lower.includes("email")) return "email";
+  if (lower.includes("phone")) return "phone";
+  if (lower.includes("domain")) return "domain";
+  return "id";
+}
+var EMAIL_RE = /[A-Za-z0-9._%+'-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/g;
+function identityValuesFor(prefix, raw, opts = {}) {
+  if (raw === null || raw === void 0 || typeof raw === "object") return [];
+  const s = String(raw);
+  if (prefix === "email") {
+    const found = (s.match(EMAIL_RE) ?? []).map((e) => e.toLowerCase());
+    if (found.length > 0 || !opts.fallbackToScalar) return found;
+  }
+  const v = s.toLowerCase().trim();
+  return v ? [v] : [];
+}
+function tokenizeIdentityPath(path5) {
+  const tokens = [];
+  const re = /([^.[\]]+)|\[([^\]]*)\]/g;
+  let m;
+  while ((m = re.exec(path5)) !== null) {
+    if (m[1] !== void 0) {
+      tokens.push({ type: "field", name: m[1] });
+    } else {
+      const inner = m[2];
+      if (inner === "") tokens.push({ type: "wild" });
+      else if (/^\d+$/.test(inner)) tokens.push({ type: "index", i: Number(inner) });
+      else {
+        const eq = inner.indexOf("=");
+        if (eq > 0) {
+          const field = inner.slice(0, eq).trim();
+          const value = inner.slice(eq + 1).trim().replace(/^['"]|['"]$/g, "");
+          tokens.push({ type: "filter", field, value });
+        }
+      }
+    }
+  }
+  return tokens;
+}
+function resolveIdentityPath(root, path5) {
+  let frontier = [root];
+  for (const tok of tokenizeIdentityPath(path5)) {
+    const next = [];
+    for (const cur of frontier) {
+      if (cur === null || cur === void 0) continue;
+      if (tok.type === "field") {
+        if (Array.isArray(cur)) {
+          if (/^\d+$/.test(tok.name)) next.push(cur[Number(tok.name)]);
+        } else if (typeof cur === "object") {
+          next.push(cur[tok.name]);
+        }
+      } else if (tok.type === "index") {
+        if (Array.isArray(cur)) next.push(cur[tok.i]);
+      } else if (tok.type === "wild") {
+        if (Array.isArray(cur)) next.push(...cur);
+      } else {
+        if (Array.isArray(cur)) {
+          for (const el of cur) {
+            if (el && typeof el === "object" && String(el[tok.field] ?? "").toLowerCase() === tok.value.toLowerCase()) {
+              next.push(el);
+            }
+          }
+        }
+      }
+    }
+    frontier = next;
+  }
+  return frontier;
+}
+function keysForEntry(record, prefix, path5) {
+  if (!prefix || !path5) return [];
+  const out = [];
+  for (const raw of resolveIdentityPath(record, path5)) {
+    for (const value of identityValuesFor(prefix, raw)) out.push(`${prefix}:${value}`);
+  }
+  return out;
+}
+function normalizePrefix(prefix) {
+  const p2 = prefix.trim().toLowerCase();
+  return /^[a-z0-9_]+$/.test(p2) ? p2 : null;
+}
+function dedupe(keys) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const k of keys) {
+    if (seen.has(k)) continue;
+    seen.add(k);
+    out.push(k);
+  }
+  return out;
+}
+function resolveEntityIdentity(record, identityKey) {
+  if (!identityKey) return null;
+  const prefix = deriveIdentityPrefix(identityKey);
+  const values = dedupe(
+    resolveIdentityPath(record, identityKey).flatMap((raw) => identityValuesFor(prefix, raw, { fallbackToScalar: true }))
+  );
+  const value = values.length === 1 ? values[0] : null;
+  return { prefix, values, value, key: value ? `${prefix}:${value}` : null };
+}
+function normalizeEntityIdentityValue(identityKey, raw) {
+  const values = dedupe(identityValuesFor(deriveIdentityPrefix(identityKey), raw, { fallbackToScalar: true }));
+  return values.length === 1 ? values[0] : null;
+}
+function collectEntityKeys(record, profile) {
+  const identity = resolveEntityIdentity(record, profile.identityKey);
+  return identity?.key ? [identity.key] : [];
+}
+function collectAssociationKeys(record, profile) {
+  const out = [];
+  for (const entry of profile.identityKeys ?? []) {
+    if (!entry || !entry.path || !entry.prefix) continue;
+    const prefix = normalizePrefix(entry.prefix);
+    if (!prefix) continue;
+    out.push(...keysForEntry(record, prefix, entry.path));
+  }
+  return dedupe(out);
+}
+function collectIdentityKeys(record, profile) {
+  return dedupe([...collectEntityKeys(record, profile), ...collectAssociationKeys(record, profile)]);
+}
+
 // src/commands/mem/migrate.ts
 async function memMigrateCommand(flags) {
   requireMemoryInit();
@@ -472,10 +739,10 @@ async function memMigrateCommand(flags) {
           const keys = [sourceKey];
           let identityValueNorm = null;
           if (identityKey) {
-            const idValue = getByDotPath(hydrated, identityKey);
-            if (idValue !== void 0 && idValue !== null && idValue !== "" && typeof idValue !== "object") {
-              identityValueNorm = String(idValue).toLowerCase().trim();
-              keys.push(`${deriveIdentityPrefix(identityKey)}:${identityValueNorm}`);
+            const identity = resolveEntityIdentity(hydrated, identityKey);
+            if (identity?.key) {
+              identityValueNorm = identity.value;
+              keys.push(identity.key);
             }
           }
           let mergeTarget = false;
@@ -658,7 +925,7 @@ async function buildIdentityMap(backend, type, identityKey) {
     for (const row of res.rows) {
       const ident = row.ident;
       if (ident === null || ident === void 0 || typeof ident !== "string") continue;
-      const norm = ident.toLowerCase().trim();
+      const norm = normalizeEntityIdentityValue(identityKey, ident);
       if (!norm) continue;
       if (!map.has(norm)) {
         map.set(norm, {
@@ -724,13 +991,6 @@ function resolveBuiltinProfilePath(platform, model) {
   const candidate = path4.join(dir, platform, `${model}.json`);
   return fs4.existsSync(candidate) ? candidate : null;
 }
-function deriveIdentityPrefix(path5) {
-  const lower = path5.toLowerCase();
-  if (lower.includes("email")) return "email";
-  if (lower.includes("phone")) return "phone";
-  if (lower.includes("domain")) return "domain";
-  return "id";
-}
 
 export {
   readProfile,
@@ -753,6 +1013,11 @@ export {
   dropTable,
   countRecords,
   deleteDatabase,
+  extractSearchableFromPaths,
+  getSearchablePaths,
+  writePageToMemory,
+  resolveEntityIdentity,
+  collectIdentityKeys,
   loadBuiltinProfile,
   listBuiltinProfiles,
   memMigrateCommand,