@anuma/sdk 2.0.1 → 2.2.0

package/dist/expo/{chunk-N4FEY34G.mjs → chunk-7PAISHUN.mjs}

@@ -1663,14 +1663,19 @@ async function upsertEntitiesOp(ctx, entities) {
     return out;
   });
 }
-async function linkMemoryEntitiesOp(ctx, memoryId, entityInputs) {
+async function linkMemoryEntitiesOp(ctx, memoryId, entityInputs, options) {
   if (entityInputs.length === 0) return [];
   const normalized = entityInputs.map((e) => typeof e === "string" ? { name: e } : e);
   const byName = await upsertEntitiesOp(ctx, normalized);
   const entities = Array.from(byName.values());
   if (entities.length === 0) return [];
   const userId = ctx.userId;
+  let skipped = false;
   await ctx.database.write(async () => {
+    if (options?.unlessTopicsUserManaged && await autoLinkBlocked(ctx, memoryId)) {
+      skipped = true;
+      return;
+    }
     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));
@@ -1684,7 +1689,46 @@ async function linkMemoryEntitiesOp(ctx, memoryId, entityInputs) {
     );
     await ctx.database.batch(...prepared);
   });
-  return entities;
+  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 replaceMemoryEntitiesGuardedOp(ctx, memoryId, entityInputs) {
+  const normalized = entityInputs.map((e) => typeof e === "string" ? { name: e } : e);
+  const byName = await upsertEntitiesOp(ctx, normalized);
+  const entities = Array.from(byName.values());
+  const userId = ctx.userId;
+  let skipped = false;
+  await ctx.database.write(async () => {
+    if (await autoLinkBlocked(ctx, memoryId)) {
+      skipped = true;
+      return;
+    }
+    const existingLinks = await ctx.memoryEntityCollection.query(Q2.where("memory_id", memoryId)).fetch();
+    const keep = new Set(entities.map((e) => e.uniqueId));
+    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 (toCreate.length === 0 && toDestroy.length === 0) return;
+    await ctx.database.batch(
+      ...toCreate.map(
+        (e) => ctx.memoryEntityCollection.prepareCreate((record) => {
+          record._setRaw("memory_id", memoryId);
+          record._setRaw("entity_id", e.uniqueId);
+          if (userId !== void 0) record._setRaw("user_id", userId);
+        })
+      ),
+      ...toDestroy.map((l) => l.prepareDestroyPermanently())
+    );
+  });
+  return skipped ? null : entities;
 }
 async function unlinkMemoryEntitiesOp(ctx, memoryIds) {
   if (memoryIds.length === 0) return;
@@ -1807,6 +1851,7 @@ function vaultMemoryToStoredRaw(memory) {
     eventTimeEnd: memory.eventTimeEnd ?? null,
     eventTimeKind: memory.eventTimeKind ?? null,
     topicsUserManaged: memory.topicsUserManaged ?? false,
+    topicsExtractedAt: memory.topicsExtractedAt ?? null,
     createdAt: memory.createdAt,
     updatedAt: memory.updatedAt,
     isDeleted: memory.isDeleted
@@ -1990,6 +2035,7 @@ 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,
+    topicsExtractedAt: raw.topics_extracted_at ?? null,
     createdAt: new Date(raw.created_at),
     updatedAt: new Date(raw.updated_at),
     isDeleted: raw.is_deleted === true || raw.is_deleted === 1
@@ -2132,6 +2178,87 @@ async function getUnfiledVaultMemoriesOp(ctx) {
     (record) => vaultMemoryToStored(record, ctx.walletAddress, ctx.signMessage, ctx.embeddedWalletSigner)
   );
 }
+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 rows = await ctx.vaultMemoryCollection.query(...conditions).unsafeFetchRaw();
+  const stampedPending = [];
+  const unstamped = [];
+  for (const raw of rows) {
+    const stamp = raw.topics_extracted_at ?? null;
+    if (stamp !== null) {
+      if (raw.updated_at > stamp) stampedPending.push(raw);
+    } 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 {
+      pendingRaw.push(raw);
+    }
+  }
+  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 pending = await mapInBatches(
+    limitedPendingRaw,
+    (raw) => vaultMemoryRawToStored(raw, ctx.walletAddress, ctx.signMessage, ctx.embeddedWalletSigner)
+  );
+  return { pending, linkedUnstamped };
+}
+async function stampTopicsExtractedAtOp(ctx, memoryIds, extractedAt) {
+  if (memoryIds.length === 0) return [];
+  const uniqueIds = Array.from(new Set(memoryIds));
+  const CHUNK = 500;
+  const stamped = [];
+  for (let i = 0; i < uniqueIds.length; i += CHUNK) {
+    const chunkIds = uniqueIds.slice(i, i + CHUNK);
+    await ctx.database.write(async () => {
+      const prepared = [];
+      for (const id of chunkIds) {
+        let record;
+        try {
+          record = await ctx.vaultMemoryCollection.find(id);
+        } catch {
+          continue;
+        }
+        if (record.isDeleted || !isOwnedByCtxUser(ctx, record) || record.topicsUserManaged) {
+          continue;
+        }
+        const originalUpdatedAt = record.updatedAt.getTime();
+        prepared.push(
+          record.prepareUpdate((r) => {
+            r._setRaw("topics_extracted_at", extractedAt);
+            r._setRaw("updated_at", originalUpdatedAt);
+          })
+        );
+        stamped.push(id);
+      }
+      if (prepared.length > 0) await ctx.database.batch(...prepared);
+    });
+  }
+  return stamped;
+}
 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();
@@ -4690,7 +4817,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-DHOR5WWW.mjs");
+        const { recall: recall2 } = await import("./recall-62ZPSDHR.mjs");
         const result = await recall2(
           query,
           { vaultCtx, embeddingOptions, vaultCache: cache },
@@ -5315,6 +5442,8 @@ export {
   chunkAndEmbedAllMessages,
   ENTITY_KINDS,
   linkMemoryEntitiesOp,
+  replaceMemoryEntitiesGuardedOp,
+  vaultMemoryToStored,
   createVaultMemoryOp,
   createVaultMemoriesBatchOp,
   getVaultMemoryOp,
@@ -5323,6 +5452,8 @@ export {
   updateVaultMemoryOp,
   deleteVaultMemoryOp,
   getUnfiledVaultMemoriesOp,
+  getMemoriesNeedingTopicExtractionOp,
+  stampTopicsExtractedAtOp,
   deleteAllVaultMemoriesForUserOp,
   updateVaultMemoryEmbeddingOp,
   DEFAULT_VAULT_CACHE_SIZE,