@ai-matrx/agents 0.8.0 → 0.9.1

package/dist/catalog/index.js

@@ -219,8 +219,8 @@ async function readSingleAgentRow(client, agentId) {
   }
   return null;
 }
-async function writeAgentFavorite(client, agentId, isFavorite) {
-  const { error } = await client.schema("agent").from("definition").update({ is_favorite: isFavorite }).eq("id", agentId);
+async function writeAgentFavorite(client, agentId, isFavorite2) {
+  const { error } = await client.schema("agent").from("definition").update({ is_favorite: isFavorite2 }).eq("id", agentId);
   if (error) {
     throw new AgentCatalogReadError(
       "agent.definition.is_favorite",
@@ -337,6 +337,51 @@ function writeCachedDefaultRow(storage, resolved) {
   } catch {
   }
 }
+function parseCachedDefaultRow(mandateKey, raw) {
+  try {
+    if (!raw) return null;
+    const parsed = JSON.parse(raw);
+    if (!isRecord2(parsed)) return null;
+    const holderId = parsed["holderId"];
+    const holderName = parsed["holderName"];
+    if (typeof holderId !== "string" || typeof holderName !== "string") {
+      return null;
+    }
+    const description = parsed["holderDescription"];
+    const provenance = parsed["provenance"];
+    const at = parsed["at"];
+    return {
+      mandateKey,
+      holderId,
+      holderName,
+      holderDescription: typeof description === "string" ? description : null,
+      provenance: typeof provenance === "string" ? provenance : "system",
+      at: typeof at === "number" ? at : 0
+    };
+  } catch {
+    return null;
+  }
+}
+async function readCachedDefaultRowAsync(storage, mandateKey) {
+  let raw;
+  try {
+    raw = await storage.getItem(
+      CACHE_PREFIX + mandateKey
+    );
+  } catch {
+    return null;
+  }
+  return parseCachedDefaultRow(mandateKey, raw);
+}
+async function writeCachedDefaultRowAsync(storage, resolved) {
+  try {
+    await storage.setItem(
+      CACHE_PREFIX + resolved.mandateKey,
+      JSON.stringify(resolved)
+    );
+  } catch {
+  }
+}
 function defaultRowFromResolution(resolved) {
   return {
     id: mandateAgentId(resolved.mandateKey),
@@ -376,7 +421,7 @@ function detectDefaultRowDrift(cached, live) {
 }
 async function resolveDefaultRow(args) {
   const { mandateKey, transport, client, storage, lookupRow } = args;
-  const cached = readCachedDefaultRow(storage, mandateKey);
+  const cached = await readCachedDefaultRowAsync(storage, mandateKey);
   const verdict = await askTheServer(transport, mandateKey);
   if (verdict.holderType !== "agent") {
     throw new MandateDefaultRowError({
@@ -413,7 +458,7 @@ async function resolveDefaultRow(args) {
     at: Date.now()
   };
   const drift = detectDefaultRowDrift(cached, resolved);
-  writeCachedDefaultRow(storage, resolved);
+  await writeCachedDefaultRowAsync(storage, resolved);
   return { resolved, row: defaultRowFromResolution(resolved), drift };
 }
 
@@ -753,7 +798,7 @@ function createAgentCatalog(config) {
     mergeRows(result.rows);
     return result.ids;
   }
-  async function setFavorite(agentId, isFavorite) {
+  async function setFavorite(agentId, isFavorite2) {
     const existing = state.byId[agentId];
     if (!existing) {
       errorSink({
@@ -762,15 +807,15 @@ function createAgentCatalog(config) {
       });
       return;
     }
-    mergeRows([{ ...existing, isFavorite }]);
+    mergeRows([{ ...existing, isFavorite: isFavorite2 }]);
     try {
-      await writeAgentFavorite(client, agentId, isFavorite);
+      await writeAgentFavorite(client, agentId, isFavorite2);
     } catch (e) {
       mergeRows([existing]);
       errorSink({
         code: "favorite_write_failed",
         message: `the favorite could not be saved: ${errorMessage(e)}`,
-        context: { agentId, isFavorite }
+        context: { agentId, isFavorite: isFavorite2 }
       });
       notifier?.({
         level: "error",
@@ -1049,7 +1094,19 @@ function memoize3(fn) {
     return last;
   };
 }
+function compareAgentIds(a, b) {
+  const idA = a.id ?? "";
+  const idB = b.id ?? "";
+  if (idA < idB) return -1;
+  if (idA > idB) return 1;
+  return 0;
+}
 function applyAgentSortComparator(a, b, sortBy) {
+  const primary = compareAgentSortKey(a, b, sortBy);
+  if (!Number.isFinite(primary) || primary === 0) return compareAgentIds(a, b);
+  return primary;
+}
+function compareAgentSortKey(a, b, sortBy) {
   switch (sortBy) {
     case "name-asc":
       return (a.name ?? "").localeCompare(b.name ?? "");
@@ -1297,22 +1354,46 @@ var makeSelectFilteredBuiltinAgentsCount = () => {
 function agentConsumerHasActiveFilters(consumer, defaults) {
   return consumer.tab !== defaults.tab || consumer.sortBy !== defaults.sortBy || consumer.searchTerm !== "" || consumer.includedCats.length > 0 || consumer.includedTags.length > 0 || consumer.favFilter !== defaults.favFilter || consumer.archFilter !== defaults.archFilter || consumer.accessFilter !== defaults.accessFilter || consumer.favoritesFirst !== defaults.favoritesFirst;
 }
+function agentMatchesArchiveFilter(agent, archFilter) {
+  if (archFilter === "active") return !agent.isArchived;
+  if (archFilter === "archived") return Boolean(agent.isArchived);
+  return true;
+}
+function countUserRows(agents, archFilter, predicate) {
+  let n = 0;
+  for (const a of agents) {
+    if (a.agentType !== "user") continue;
+    if (!agentMatchesArchiveFilter(a, archFilter)) continue;
+    if (predicate(a)) n += 1;
+  }
+  return n;
+}
+var isOwned = (a) => a.isOwner === true;
+var isShared = (a) => a.isOwner === false && a.accessLevel != null;
+var isAny = () => true;
+var isFavorite = (a) => Boolean(a.isFavorite);
+var selectAgentTabCounts = memoize2(
+  (agents, archFilter) => ({
+    mine: countUserRows(agents, archFilter, isOwned),
+    shared: countUserRows(agents, archFilter, isShared),
+    all: countUserRows(agents, archFilter, isAny),
+    system: selectBuiltinTypeAgents(agents).length
+  })
+);
 var selectTotalUserAgentsCount = memoize1(
-  (agents) => selectUserTypeAgents(agents).length
+  (agents) => countUserRows(agents, "active", isAny)
 );
 var selectTotalOwnedAgentsCount = memoize1(
-  (agents) => selectUserTypeAgents(agents).filter((a) => a.isOwner === true).length
+  (agents) => countUserRows(agents, "active", isOwned)
 );
 var selectTotalSharedAgentsCount = memoize1(
-  (agents) => selectUserTypeAgents(agents).filter(
-    (a) => a.isOwner === false && a.accessLevel != null
-  ).length
+  (agents) => countUserRows(agents, "active", isShared)
 );
 var selectTotalBuiltinAgentsCount = memoize1(
   (agents) => selectBuiltinTypeAgents(agents).length
 );
 var selectTotalFavoriteAgentsCount = memoize1(
-  (agents) => selectUserTypeAgents(agents).filter((a) => a.isFavorite).length
+  (agents) => countUserRows(agents, "active", isFavorite)
 );
 export {
   AGENT_CARDS_LIMIT_DESKTOP,
@@ -1329,10 +1410,12 @@ export {
   _resetCatalogGlobalState,
   agentConsumerHasActiveFilters,
   agentListEmptyLabel,
+  agentMatchesArchiveFilter,
   agentMatchesSearch,
   applyAgentSortComparator,
   asAgentId,
   assertAgentCatalogSchema,
+  compareAgentIds,
   computeAgentSearchScore,
   createAgentCatalog,
   createMemoryStorage,
@@ -1364,9 +1447,11 @@ export {
   parseMandateResolution,
   readAgentCatalogRows,
   readCachedDefaultRow,
+  readCachedDefaultRowAsync,
   readSingleAgentRow,
   resolveDefaultRow,
   searchAgentsOnServer,
+  selectAgentTabCounts,
   selectAllAgentCategories,
   selectAllAgentTags,
   selectAllSystemAgentCategories,
@@ -1382,6 +1467,7 @@ export {
   sortFilteredAgents,
   toAgentSummary,
   writeAgentFavorite,
-  writeCachedDefaultRow
+  writeCachedDefaultRow,
+  writeCachedDefaultRowAsync
 };
 //# sourceMappingURL=index.js.map