@anuma/sdk 2.0.1 → 2.2.0

package/dist/server/{chunk-45GOZ3AB.mjs → chunk-KEMPJE6C.mjs}

@@ -15849,14 +15849,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(import_watermelondb2.Q.where("memory_id", memoryId)).fetch();
     const existingEntityIds = new Set(existingLinks.map((l) => String(l.entityId)));
     const toCreate = entities.filter((e) => !existingEntityIds.has(e.uniqueId));
@@ -15870,7 +15875,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(import_watermelondb2.Q.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(import_watermelondb2.Q.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;
@@ -15993,6 +16037,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
@@ -16176,6 +16221,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
@@ -16318,6 +16364,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.
+    import_watermelondb3.Q.or(import_watermelondb3.Q.where("topics_user_managed", null), import_watermelondb3.Q.where("topics_user_managed", false)),
+    ...baseVaultConditions(ctx),
+    import_watermelondb3.Q.sortBy("created_at", import_watermelondb3.Q.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(import_watermelondb3.Q.where("memory_id", import_watermelondb3.Q.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(import_watermelondb3.Q.where("user_id", userId), import_watermelondb3.Q.where("is_deleted", false)).fetch();
@@ -18848,7 +18975,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-RMBNCEG6.mjs");
+        const { recall: recall2 } = await import("./recall-K2YHLBBV.mjs");
         const result = await recall2(
           query,
           { vaultCtx, embeddingOptions, vaultCache: cache },
@@ -19476,6 +19603,8 @@ export {
   makeSyntheticStoredConversation,
   ENTITY_KINDS,
   linkMemoryEntitiesOp,
+  replaceMemoryEntitiesGuardedOp,
+  vaultMemoryToStored,
   createVaultMemoryOp,
   createVaultMemoriesBatchOp,
   getVaultMemoryOp,
@@ -19484,6 +19613,8 @@ export {
   updateVaultMemoryOp,
   deleteVaultMemoryOp,
   getUnfiledVaultMemoriesOp,
+  getMemoriesNeedingTopicExtractionOp,
+  stampTopicsExtractedAtOp,
   deleteAllVaultMemoriesForUserOp,
   updateVaultMemoryEmbeddingOp,
   DEFAULT_CHUNK_SIZE,