@anuma/sdk 3.12.1 → 3.13.0

package/dist/expo/{chunk-ORVYPS3R.mjs → chunk-BOAKGY4R.mjs}

@@ -1790,6 +1790,31 @@ var ENTITY_KINDS = [
 function normalizeEntityName(name) {
   return name.trim().toLowerCase();
 }
+function serializeTopics(topics) {
+  return JSON.stringify(topics);
+}
+function parseTopics(value) {
+  if (typeof value !== "string" || value.length === 0) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(value);
+  } catch {
+    return null;
+  }
+  if (!Array.isArray(parsed)) return null;
+  const out = [];
+  for (const raw of parsed) {
+    if (typeof raw !== "object" || raw === null) continue;
+    const { name, kind, source } = raw;
+    if (typeof name !== "string" || name.trim().length === 0) continue;
+    out.push({
+      name,
+      ...typeof kind === "string" && kind.length > 0 ? { kind } : {},
+      source: source === "user" ? "user" : "auto"
+    });
+  }
+  return out;
+}
 
 // src/lib/db/entities/operations.ts
 function entityToStored(e) {
@@ -1839,9 +1864,62 @@ async function upsertEntitiesInWrite(ctx, entities) {
   for (const record of created) out.set(record.canonicalName, entityToStored(record));
   return { entities: out, operations: [...created, ...updated] };
 }
+async function findVaultRowInWrite(ctx, memoryId) {
+  try {
+    const rows = await ctx.database.get("memory_vault").query(Q2.where("id", memoryId)).fetch();
+    return rows[0] ?? null;
+  } catch {
+    return null;
+  }
+}
+function prepareTopicsUpdate(row, topics, now) {
+  const originalUpdatedAt = row.updatedAt.getTime();
+  return row.prepareUpdate((r) => {
+    r._setRaw("topics", serializeTopics(topics));
+    r._setRaw("topics_updated_at", now);
+    r._setRaw("updated_at", originalUpdatedAt);
+  });
+}
+function displayNamesOf(entities) {
+  const out = /* @__PURE__ */ new Map();
+  for (const e of entities) {
+    const name = e.name.trim();
+    const normalized = normalizeEntityName(name);
+    if (normalized.length === 0 || out.has(normalized)) continue;
+    out.set(normalized, name);
+  }
+  return out;
+}
+function topicsEqual(stored, computed) {
+  if (stored === null || stored.length !== computed.length) return false;
+  const key = (t) => JSON.stringify([t.name, t.kind ?? null, t.source]);
+  const storedKeys = stored.map(key).sort();
+  const computedKeys = computed.map(key).sort();
+  return storedKeys.every((k, i) => k === computedKeys[i]);
+}
+function resolveTopicsWrite(row, linked, displayNames, source) {
+  if (row === null || source === null) return null;
+  const topics = topicsForEntities(linked, displayNames, source);
+  if (topicsEqual(parseTopics(row.topics), topics)) return null;
+  return { row, topics };
+}
+function topicsForEntities(entities, displayNames, source) {
+  return entities.map((e) => {
+    const name = displayNames.get(e.canonicalName) ?? e.canonicalName;
+    return { name, ...e.kind ? { kind: e.kind } : {}, source };
+  });
+}
+function toEntityObjects(entityInputs) {
+  return entityInputs.map((e) => typeof e === "string" ? { name: e } : e);
+}
+async function prepareMemoryTopicsUpdate(ctx, memoryId, linked, inputs, source) {
+  const row = await findVaultRowInWrite(ctx, memoryId);
+  const write = resolveTopicsWrite(row, linked, displayNamesOf(toEntityObjects(inputs)), source);
+  return write === null ? null : prepareTopicsUpdate(write.row, write.topics, Date.now());
+}
 async function linkMemoryEntitiesOp(ctx, memoryId, entityInputs, options) {
   if (entityInputs.length === 0) return [];
-  const normalized = entityInputs.map((e) => typeof e === "string" ? { name: e } : e);
+  const normalized = toEntityObjects(entityInputs);
   const userId = ctx.userId;
   let skipped = false;
   let entities = [];
@@ -1851,7 +1929,8 @@ async function linkMemoryEntitiesOp(ctx, memoryId, entityInputs, options) {
       normalized
     );
     entities = Array.from(byName.values());
-    if (options?.unlessTopicsUserManaged && await autoLinkBlocked(ctx, memoryId)) {
+    const vaultRow = await findVaultRowInWrite(ctx, memoryId);
+    if (options?.unlessTopicsUserManaged && autoLinkBlocked(vaultRow)) {
       if (entityOps.length > 0) {
         await ctx.database.batch(...entityOps);
       }
@@ -1862,7 +1941,18 @@ async function linkMemoryEntitiesOp(ctx, memoryId, entityInputs, options) {
     const existingLinks = await ctx.memoryEntityCollection.query(Q2.where("memory_id", memoryId)).fetch();
     const existingEntityIds = new Set(existingLinks.map((l) => String(l.entityId)));
     const toCreate = entities.filter((e) => !existingEntityIds.has(e.uniqueId));
-    if (entityOps.length === 0 && toCreate.length === 0) return;
+    const keptIds = entities.map((e) => e.uniqueId);
+    const carriedOver = await resolveEntitiesByIds(
+      ctx,
+      [...existingEntityIds].filter((id) => !keptIds.includes(id))
+    );
+    const topicsWrite = resolveTopicsWrite(
+      vaultRow,
+      [...carriedOver, ...entities],
+      displayNamesOf(normalized),
+      options?.topicsSource ?? "auto"
+    );
+    if (entityOps.length === 0 && toCreate.length === 0 && topicsWrite === null) return;
     const linkOps = toCreate.map(
       (e) => ctx.memoryEntityCollection.prepareCreate((record) => {
         record._setRaw("memory_id", memoryId);
@@ -1870,26 +1960,42 @@ async function linkMemoryEntitiesOp(ctx, memoryId, entityInputs, options) {
         if (userId !== void 0) record._setRaw("user_id", userId);
       })
     );
-    await ctx.database.batch(...entityOps, ...linkOps);
+    await ctx.database.batch(
+      ...entityOps,
+      ...linkOps,
+      ...topicsWrite ? [prepareTopicsUpdate(topicsWrite.row, topicsWrite.topics, Date.now())] : []
+    );
   });
   return skipped ? [] : entities;
 }
-async function autoLinkBlocked(ctx, memoryId) {
-  try {
-    const rows = await ctx.database.get("memory_vault").query(Q2.where("id", memoryId)).fetch();
-    const row = rows[0];
-    return !row || !!row.isDeleted || !!row.topicsUserManaged;
-  } catch {
-    return true;
-  }
+async function resolveEntitiesByIds(ctx, entityIds) {
+  if (entityIds.length === 0) return [];
+  const rows = await ctx.entityCollection.query(Q2.where("id", Q2.oneOf(Array.from(entityIds)))).fetch();
+  return rows.map(entityToStored);
+}
+function autoLinkBlocked(row) {
+  return !row || !!row.isDeleted || !!row.topicsUserManaged;
 }
 async function replaceMemoryEntitiesGuardedOp(ctx, memoryId, entityInputs) {
-  const normalized = entityInputs.map((e) => typeof e === "string" ? { name: e } : e);
+  return replaceMemoryEntities(ctx, memoryId, entityInputs, {
+    guarded: true,
+    topicsSource: "auto"
+  });
+}
+async function relinkMemoryEntitiesFromTopicsOp(ctx, memoryId, topics) {
+  return replaceMemoryEntities(ctx, memoryId, topics, {
+    guarded: false,
+    topicsSource: null
+  });
+}
+async function replaceMemoryEntities(ctx, memoryId, entityInputs, options) {
+  const normalized = toEntityObjects(entityInputs);
   const userId = ctx.userId;
   let skipped = false;
   let entities = [];
   await ctx.database.write(async () => {
-    if (await autoLinkBlocked(ctx, memoryId)) {
+    const vaultRow = await findVaultRowInWrite(ctx, memoryId);
+    if (options.guarded && autoLinkBlocked(vaultRow)) {
       skipped = true;
       return;
     }
@@ -1903,7 +2009,15 @@ async function replaceMemoryEntitiesGuardedOp(ctx, memoryId, entityInputs) {
     const existingEntityIds = new Set(existingLinks.map((l) => String(l.entityId)));
     const toCreate = entities.filter((e) => !existingEntityIds.has(e.uniqueId));
     const toDestroy = existingLinks.filter((l) => !keep.has(String(l.entityId)));
-    if (entityOps.length === 0 && toCreate.length === 0 && toDestroy.length === 0) return;
+    const topicsWrite = resolveTopicsWrite(
+      vaultRow,
+      entities,
+      displayNamesOf(normalized),
+      options.topicsSource
+    );
+    if (entityOps.length === 0 && toCreate.length === 0 && toDestroy.length === 0 && topicsWrite === null) {
+      return;
+    }
     const orphans = await findOrphanedEntities(ctx, memoryId, toDestroy);
     await ctx.database.batch(
       ...entityOps,
@@ -1915,7 +2029,8 @@ async function replaceMemoryEntitiesGuardedOp(ctx, memoryId, entityInputs) {
         })
       ),
       ...toDestroy.map((l) => l.prepareDestroyPermanently()),
-      ...orphans.map((e) => e.prepareDestroyPermanently())
+      ...orphans.map((e) => e.prepareDestroyPermanently()),
+      ...topicsWrite ? [prepareTopicsUpdate(topicsWrite.row, topicsWrite.topics, Date.now())] : []
     );
   });
   return skipped ? null : entities;
@@ -2103,6 +2218,8 @@ function vaultMemoryToStoredRaw(memory) {
     eventTimeEnd: memory.eventTimeEnd ?? null,
     eventTimeKind: memory.eventTimeKind ?? null,
     topicsUserManaged: memory.topicsUserManaged ?? false,
+    topics: parseTopics(memory.topics),
+    topicsUpdatedAt: memory.topicsUpdatedAt ?? null,
     topicsExtractedAt: memory.topicsExtractedAt ?? null,
     topicsExtractedVersion: memory.topicsExtractedVersion ?? null,
     supersededBy: memory.supersededBy ?? null,
@@ -2379,6 +2496,8 @@ function vaultMemoryRawToStoredRaw(raw) {
     eventTimeKind: raw.event_time_kind ?? null,
     // SQLite stores booleans as 0/1, LokiJS as true/false — coerce both.
     topicsUserManaged: raw.topics_user_managed === true || raw.topics_user_managed === 1,
+    topics: parseTopics(raw.topics),
+    topicsUpdatedAt: raw.topics_updated_at ?? null,
     topicsExtractedAt: raw.topics_extracted_at ?? null,
     topicsExtractedVersion: raw.topics_extracted_version ?? null,
     supersededBy: raw.superseded_by ?? null,
@@ -2726,56 +2845,111 @@ async function getUnfiledVaultMemoriesOp(ctx) {
   );
 }
 var TOPICS_EXTRACTION_VERSION = 3;
+async function linkedEntityNamesByMemory(entityCtx, memoryIds) {
+  const CHUNK = 500;
+  const entityIdByMemory = /* @__PURE__ */ new Map();
+  const allEntityIds = /* @__PURE__ */ new Set();
+  for (let i = 0; i < memoryIds.length; i += CHUNK) {
+    const links = await entityCtx.memoryEntityCollection.query(Q3.where("memory_id", Q3.oneOf(memoryIds.slice(i, i + CHUNK)))).unsafeFetchRaw();
+    for (const link of links) {
+      const memoryId = String(link.memory_id);
+      const entityId = String(link.entity_id);
+      allEntityIds.add(entityId);
+      let bucket = entityIdByMemory.get(memoryId);
+      if (!bucket) {
+        bucket = /* @__PURE__ */ new Set();
+        entityIdByMemory.set(memoryId, bucket);
+      }
+      bucket.add(entityId);
+    }
+  }
+  const entityIds = Array.from(allEntityIds);
+  const nameById = /* @__PURE__ */ new Map();
+  for (let i = 0; i < entityIds.length; i += CHUNK) {
+    const entities = await entityCtx.entityCollection.query(Q3.where("id", Q3.oneOf(entityIds.slice(i, i + CHUNK)))).unsafeFetchRaw();
+    for (const e of entities) {
+      if (typeof e.canonical_name === "string") nameById.set(String(e.id), e.canonical_name);
+    }
+  }
+  const out = /* @__PURE__ */ new Map();
+  for (const [memoryId, ids] of entityIdByMemory) {
+    const names = /* @__PURE__ */ new Set();
+    for (const id of ids) {
+      const name = nameById.get(id);
+      if (name !== void 0) names.add(name);
+    }
+    if (names.size > 0) out.set(memoryId, names);
+  }
+  return out;
+}
+function linksDivergeFromTopics(topics, linked) {
+  const wanted = new Set(
+    topics.map((t) => normalizeEntityName(t.name)).filter((n) => n.length > 0)
+  );
+  if (wanted.size !== linked.size) return true;
+  for (const name of wanted) if (!linked.has(name)) return true;
+  return false;
+}
 async function getMemoriesNeedingTopicExtractionOp(ctx, options) {
   const entityCtx = ctx.entityCtx;
   if (!entityCtx) {
     throw new Error("getMemoriesNeedingTopicExtractionOp requires ctx.entityCtx");
   }
-  const conditions = [
-    // Boolean optional column: null (legacy) and false both mean auto-managed.
-    // Q.notEq(true) is a NULL trap on SQLite (NULL <> TRUE is NULL) — enumerate.
-    Q3.or(Q3.where("topics_user_managed", null), Q3.where("topics_user_managed", false)),
-    ...baseVaultConditions(ctx),
-    Q3.sortBy("created_at", Q3.desc)
-  ];
+  const conditions = [...baseVaultConditions(ctx), Q3.sortBy("created_at", Q3.desc)];
   const rows = await ctx.vaultMemoryCollection.query(...conditions).unsafeFetchRaw();
-  const stampedPending = [];
-  const unstamped = [];
+  const linkedNames = await linkedEntityNamesByMemory(
+    entityCtx,
+    rows.map((r) => r.id)
+  );
+  const pendingRaw = [];
+  const stampedPendingRaw = [];
+  const linkedUnstampedAll = [];
+  const topicsToRelinkAll = [];
+  const topicsBackfillAll = [];
   for (const raw of rows) {
+    const id = raw.id;
+    const topics = parseTopics(raw.topics);
+    const linked = linkedNames.get(id);
+    if (topics !== null && topics.length > 0 && linksDivergeFromTopics(topics, linked ?? /* @__PURE__ */ new Set())) {
+      topicsToRelinkAll.push(id);
+      continue;
+    }
+    if (raw.topics_user_managed) {
+      if (topics === null && linked !== void 0) topicsBackfillAll.push(id);
+      continue;
+    }
     const stamp = raw.topics_extracted_at ?? null;
+    let isPending = false;
     if (stamp !== null) {
       const version = raw.topics_extracted_version ?? 0;
       if (raw.updated_at > stamp || version < TOPICS_EXTRACTION_VERSION) {
-        stampedPending.push(raw);
+        stampedPendingRaw.push(raw);
+        isPending = true;
       }
-    } else {
-      unstamped.push(raw);
-    }
-  }
-  const linkedIds = /* @__PURE__ */ new Set();
-  const CHUNK = 500;
-  for (let i = 0; i < unstamped.length; i += CHUNK) {
-    const ids = unstamped.slice(i, i + CHUNK).map((r) => r.id);
-    const links = await entityCtx.memoryEntityCollection.query(Q3.where("memory_id", Q3.oneOf(ids))).unsafeFetchRaw();
-    for (const link of links) linkedIds.add(String(link.memory_id));
-  }
-  const linkedUnstampedAll = [];
-  const pendingRaw = [...stampedPending];
-  for (const raw of unstamped) {
-    if (linkedIds.has(raw.id)) {
-      linkedUnstampedAll.push(raw.id);
+    } else if (linked !== void 0) {
+      linkedUnstampedAll.push(id);
     } else {
       pendingRaw.push(raw);
+      isPending = true;
+    }
+    if (!isPending && topics === null && linked !== void 0) {
+      topicsBackfillAll.push(id);
     }
   }
   const cap = options?.limit !== void 0 && options.limit > 0 ? options.limit : void 0;
-  const limitedPendingRaw = cap !== void 0 ? pendingRaw.slice(0, cap) : pendingRaw;
-  const linkedUnstamped = cap !== void 0 ? linkedUnstampedAll.slice(0, cap) : linkedUnstampedAll;
+  const orderedPendingRaw = [...stampedPendingRaw, ...pendingRaw];
+  const limitedPendingRaw = cap !== void 0 ? orderedPendingRaw.slice(0, cap) : orderedPendingRaw;
   const pending = await mapInBatches(
     limitedPendingRaw,
     (raw) => vaultMemoryRawToStored(raw, ctx.walletAddress, ctx.signMessage, ctx.embeddedWalletSigner)
   );
-  return { pending, linkedUnstamped };
+  const applyCap = (ids) => cap !== void 0 ? ids.slice(0, cap) : ids;
+  return {
+    pending,
+    linkedUnstamped: applyCap(linkedUnstampedAll),
+    topicsToRelink: applyCap(topicsToRelinkAll),
+    topicsBackfill: applyCap(topicsBackfillAll)
+  };
 }
 async function stampTopicsExtractedAtOp(ctx, memoryIds, extractedAt, version = TOPICS_EXTRACTION_VERSION) {
   if (memoryIds.length === 0) return [];
@@ -2809,6 +2983,61 @@ async function stampTopicsExtractedAtOp(ctx, memoryIds, extractedAt, version = T
   }
   return stamped;
 }
+async function relinkMemoryTopicsOp(ctx, memoryIds) {
+  const entityCtx = ctx.entityCtx;
+  if (!entityCtx) {
+    throw new Error("relinkMemoryTopicsOp requires ctx.entityCtx");
+  }
+  const relinked = [];
+  for (const id of Array.from(new Set(memoryIds))) {
+    let record;
+    try {
+      record = await ctx.vaultMemoryCollection.find(id);
+    } catch {
+      continue;
+    }
+    if (record.isDeleted || !isOwnedByCtxUser(ctx, record)) continue;
+    const topics = parseTopics(record.topics);
+    if (topics === null || topics.length === 0) continue;
+    try {
+      await relinkMemoryEntitiesFromTopicsOp(entityCtx, id, topics);
+      relinked.push(id);
+    } catch (err) {
+      getLogger().warn("[memory/topics] relink failed", err);
+    }
+  }
+  return relinked;
+}
+async function backfillMemoryTopicsOp(ctx, memoryIds) {
+  const entityCtx = ctx.entityCtx;
+  if (!entityCtx) {
+    throw new Error("backfillMemoryTopicsOp requires ctx.entityCtx");
+  }
+  const filled = [];
+  for (const id of Array.from(new Set(memoryIds))) {
+    let record;
+    try {
+      record = await ctx.vaultMemoryCollection.find(id);
+    } catch {
+      continue;
+    }
+    if (record.isDeleted || !isOwnedByCtxUser(ctx, record)) continue;
+    if (parseTopics(record.topics) !== null) continue;
+    const links = await entityCtx.memoryEntityCollection.query(Q3.where("memory_id", id)).unsafeFetchRaw();
+    const entityIds = links.map((l) => String(l.entity_id));
+    if (entityIds.length === 0) continue;
+    const entities = await entityCtx.entityCollection.query(Q3.where("id", Q3.oneOf(entityIds))).fetch();
+    if (entities.length === 0) continue;
+    const source = record.topicsUserManaged ? "user" : "auto";
+    await ctx.database.write(async () => {
+      const topicsOp = await prepareMemoryTopicsUpdate(entityCtx, id, entities, [], source);
+      if (!topicsOp) return;
+      await ctx.database.batch(topicsOp);
+      filled.push(id);
+    });
+  }
+  return filled;
+}
 async function deleteAllVaultMemoriesForUserOp(ctx, userId) {
   if (ctx.userId !== void 0 && ctx.userId !== userId) return 0;
   const records = await ctx.vaultMemoryCollection.query(Q3.where("user_id", userId), Q3.where("is_deleted", false)).fetch();
@@ -5890,7 +6119,7 @@ function createMemoryVaultSearchTool(vaultCtx, embeddingOptions, cache, searchOp
             legacy.map((r) => ({ id: r.uniqueId, content: r.content, score: r.similarity }))
           );
         }
-        const { recall: recall2 } = await import("./recall-A4WZELH5.mjs");
+        const { recall: recall2 } = await import("./recall-O65PGPIQ.mjs");
         let recallDegraded = [];
         const result = await recall2(
           query,
@@ -6911,6 +7140,8 @@ export {
   TOPICS_EXTRACTION_VERSION,
   getMemoriesNeedingTopicExtractionOp,
   stampTopicsExtractedAtOp,
+  relinkMemoryTopicsOp,
+  backfillMemoryTopicsOp,
   deleteAllVaultMemoriesForUserOp,
   assertVaultScopeForSweep,
   getDecayCandidatesRawOp,