@sentry/junior-memory 0.120.0 → 0.122.0

package/dist/index.js

@@ -2829,12 +2829,166 @@ async function createMemoryPromptContributions(context) {
   if (selected.length === 0) {
     return void 0;
   }
-  if (selected.some((memory) => memory.scope === "personal")) {
-    return [{ text: renderMemoryPrompt(selected) }];
-  }
   return [memoryRecallContext({ memories: selected })];
 }
 
+// src/operational-report.ts
+import { and as and4, eq as eq5, gt as gt4, isNull as isNull3, or as or4, sql as sql4 } from "drizzle-orm";
+import { z as z10 } from "zod";
+var DAY_MS = 24 * 60 * 60 * 1e3;
+var WINDOWS = [7, 30, 90];
+var memoryDaySchema = z10.object({
+  conversation: z10.number().int().nonnegative(),
+  date: z10.string().date(),
+  personal: z10.number().int().nonnegative()
+}).strict();
+function queryRows(result) {
+  if (typeof result !== "object" || result === null || !("rows" in result) || !Array.isArray(result.rows)) {
+    throw new TypeError("Memory activity query did not return rows");
+  }
+  return result.rows;
+}
+function startOfUtcDay(value) {
+  const date = new Date(value);
+  date.setUTCHours(0, 0, 0, 0);
+  return date;
+}
+async function aggregateMemoryDays(args) {
+  const end = startOfUtcDay(args.nowMs);
+  const start = startOfUtcDay(args.nowMs - (WINDOWS.at(-1) - 1) * DAY_MS);
+  const endExclusiveMs = end.getTime() + DAY_MS;
+  const table = juniorMemoryMemories;
+  const result = await args.db.execute(sql4`
+    WITH days AS (
+      SELECT generate_series(
+        date_trunc('day', ${start}::timestamptz AT TIME ZONE 'UTC'),
+        date_trunc('day', ${end}::timestamptz AT TIME ZONE 'UTC'),
+        interval '1 day'
+      ) AS day
+    ), daily AS (
+      SELECT
+        date_trunc(
+          'day',
+          to_timestamp(${table.createdAtMs} / 1000.0) AT TIME ZONE 'UTC'
+        ) AS day,
+        count(*) FILTER (
+          WHERE ${table.scope} = 'personal'
+        )::integer AS personal,
+        count(*) FILTER (
+          WHERE ${table.scope} = 'conversation'
+        )::integer AS conversation
+      FROM ${table}
+      WHERE ${table.createdAtMs} >= ${start.getTime()}
+        AND ${table.createdAtMs} < ${endExclusiveMs}
+      GROUP BY date_trunc(
+        'day',
+        to_timestamp(${table.createdAtMs} / 1000.0) AT TIME ZONE 'UTC'
+      )
+    )
+    SELECT
+      to_char(days.day, 'YYYY-MM-DD') AS date,
+      coalesce(daily.personal, 0)::integer AS personal,
+      coalesce(daily.conversation, 0)::integer AS conversation
+    FROM days
+    LEFT JOIN daily ON daily.day = days.day
+    ORDER BY days.day
+  `);
+  return z10.array(memoryDaySchema).parse(queryRows(result));
+}
+function formatCount(value) {
+  return new Intl.NumberFormat("en-US").format(value);
+}
+function formatPercent(value) {
+  return new Intl.NumberFormat("en-US", {
+    maximumFractionDigits: 0,
+    style: "percent"
+  }).format(value);
+}
+async function buildMemoryOperationalReport(args) {
+  const active = and4(
+    isNull3(juniorMemoryMemories.archivedAtMs),
+    isNull3(juniorMemoryMemories.supersededAtMs),
+    isNull3(juniorMemoryMemories.supersededById),
+    or4(
+      isNull3(juniorMemoryMemories.expiresAtMs),
+      gt4(juniorMemoryMemories.expiresAtMs, args.nowMs)
+    )
+  );
+  const [[counts], memoryDays] = await Promise.all([
+    args.db.select({
+      active: sql4`count(*) filter (where ${active})`.mapWith(Number),
+      conversation: sql4`count(*) filter (where ${active} and ${juniorMemoryMemories.scope} = 'conversation')`.mapWith(
+        Number
+      ),
+      createdThirtyDays: sql4`count(*) filter (where ${juniorMemoryMemories.createdAtMs} >= ${args.nowMs - 30 * DAY_MS})`.mapWith(
+        Number
+      ),
+      embedded: sql4`count(${juniorMemoryEmbeddings.memoryId}) filter (where ${active})`.mapWith(
+        Number
+      ),
+      personal: sql4`count(*) filter (where ${active} and ${juniorMemoryMemories.scope} = 'personal')`.mapWith(
+        Number
+      )
+    }).from(juniorMemoryMemories).leftJoin(
+      juniorMemoryEmbeddings,
+      eq5(juniorMemoryEmbeddings.memoryId, juniorMemoryMemories.id)
+    ),
+    aggregateMemoryDays(args)
+  ]);
+  const activeCount = counts?.active ?? 0;
+  const embeddedCount = counts?.embedded ?? 0;
+  const embeddingCoverage = activeCount === 0 ? 0 : embeddedCount / activeCount;
+  return {
+    generatedAt: new Date(args.nowMs).toISOString(),
+    title: "Memory",
+    metrics: [
+      {
+        label: "active memories",
+        tone: activeCount > 0 ? "good" : "neutral",
+        value: formatCount(activeCount)
+      },
+      {
+        label: "created \xB7 30d",
+        value: formatCount(counts?.createdThirtyDays ?? 0)
+      },
+      {
+        label: "personal",
+        value: formatCount(counts?.personal ?? 0)
+      },
+      {
+        label: "conversation",
+        value: formatCount(counts?.conversation ?? 0)
+      },
+      {
+        label: "embedding coverage",
+        tone: activeCount === 0 ? "neutral" : embeddedCount === activeCount ? "good" : "warning",
+        value: formatPercent(embeddingCoverage)
+      }
+    ],
+    widgets: [
+      {
+        categories: memoryDays.map((day) => ({
+          id: day.date,
+          label: day.date,
+          values: {
+            conversation: day.conversation,
+            personal: day.personal
+          }
+        })),
+        description: "Memories stored per day by scope",
+        id: "memories-created",
+        series: [
+          { key: "personal", label: "Personal" },
+          { key: "conversation", label: "Conversation" }
+        ],
+        timeRangeDays: [...WINDOWS],
+        title: "Memories created",
+        type: "bar_chart"
+      }
+    ]
+  };
+}
+
 // src/user-pages.ts
 function memoryKindLabel(kind) {
   return kind.charAt(0).toUpperCase() + kind.slice(1);
@@ -2950,6 +3104,12 @@ function memoryPlugin(options = {}) {
     },
     userPages: [createMemoryUserPage()],
     hooks: {
+      async operationalReport(ctx) {
+        return await buildMemoryOperationalReport({
+          db: ctx.db,
+          nowMs: ctx.nowMs
+        });
+      },
       apiRoutes(ctx) {
         return createMemoryApi({
           actors: ctx.viewer.actors,