@sentry/junior-memory 0.123.0 → 0.124.1

package/dist/api.d.ts

@@ -34,7 +34,27 @@ export declare const memoryListResponseSchema: z.ZodObject<{
     }, z.core.$strict>>;
     nextCursor: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
+export declare const memoryDashboardResponseSchema: z.ZodObject<{
+    days: z.ZodArray<z.ZodObject<{
+        date: z.ZodISODate;
+        knowledge: z.ZodNumber;
+        preference: z.ZodNumber;
+        procedure: z.ZodNumber;
+    }, z.core.$strict>>;
+    generatedAt: z.ZodISODateTime;
+    stats: z.ZodObject<{
+        active: z.ZodNumber;
+        automatic: z.ZodNumber;
+        createdThirtyDays: z.ZodNumber;
+        embedded: z.ZodNumber;
+        explicit: z.ZodNumber;
+        knowledge: z.ZodNumber;
+        preference: z.ZodNumber;
+        procedure: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>;
 export type MemoryApi = z.output<typeof memoryApiSchema>;
+export type MemoryDashboardResponse = z.output<typeof memoryDashboardResponseSchema>;
 export type MemoryListResponse = z.output<typeof memoryListResponseSchema>;
 interface MemoryApiOptions {
     actors(email: string): Promise<PluginUserPageActor[]>;

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { memoryPlugin } from "./plugin";
-export { memoryApiSchema, memoryListResponseSchema, type MemoryApi, type MemoryListResponse, } from "./api";
+export { memoryApiSchema, memoryDashboardResponseSchema, memoryListResponseSchema, type MemoryApi, type MemoryDashboardResponse, type MemoryListResponse, } from "./api";
 export type { MemoryPluginOptions } from "./plugin";
 export { createMemoryStore } from "./store";
 export type { ArchiveMemoryInput, CreateMemoryInput, CreateMemoryResult, ListMemoriesInput, MemoryDb, MemoryEmbeddingProvider, MemoryRecord, MemoryStore, MemoryStoreOptions, SearchMemoriesInput, } from "./store";

package/dist/index.js

@@ -1762,7 +1762,7 @@ import {
 import { z as z5 } from "zod";
 
 // src/personal-store.ts
-import { and as and2, asc as asc2, desc as desc2, eq as eq2, gt as gt2, ilike, lt, or as or2, sql as sql3 } from "drizzle-orm";
+import { and as and2, asc as asc2, desc as desc2, eq as eq2, gt as gt2, ilike, like as like2, lt, or as or2, sql as sql3 } from "drizzle-orm";
 import { z as z4 } from "zod";
 var nonEmptyStringSchema3 = z4.string().min(1);
 var personalMemoryCursorSchema = z4.object({
@@ -1771,9 +1771,15 @@ var personalMemoryCursorSchema = z4.object({
 }).strict();
 var personalMemoryPageInputSchema = z4.object({
   cursor: personalMemoryCursorSchema.optional(),
+  kind: z4.enum(MEMORY_KINDS).optional(),
   limit: z4.number().int().min(1).max(50),
+  origin: z4.enum(["automatic", "explicit"]).optional(),
   query: z4.string().max(200).optional()
 }).strict();
+var personalMemoryTimelineInputSchema = z4.object({
+  days: z4.number().int().min(1).max(365)
+}).strict();
+var DAY_MS = 24 * 60 * 60 * 1e3;
 var PersonalMemoryNotFoundError = class extends Error {
   constructor() {
     super("Memory was not found for the authenticated viewer.");
@@ -1790,6 +1796,20 @@ function personalScopes(runtimeContexts) {
     ).values()
   ];
 }
+function personalScopePredicate(scopes) {
+  if (scopes.length === 0) return void 0;
+  return or2(
+    ...scopes.map(
+      (scope) => and2(
+        eq2(juniorMemoryMemories.scope, scope.scope),
+        eq2(juniorMemoryMemories.scopeKey, scope.scopeKey)
+      )
+    )
+  );
+}
+function utcDate(ms) {
+  return new Date(ms).toISOString().slice(0, 10);
+}
 function searchTerms(query) {
   return [
     ...new Set(
@@ -1797,6 +1817,18 @@ function searchTerms(query) {
     )
   ];
 }
+function memoryOrigin(idempotencyKey) {
+  if (idempotencyKey?.startsWith("session:")) return "automatic";
+  if (idempotencyKey?.startsWith("tool:")) return "explicit";
+  return "other";
+}
+function personalMemoryRecord(row) {
+  return {
+    ...parseMemoryRow(row),
+    origin: memoryOrigin(row.idempotencyKey),
+    sourcePlatform: row.sourcePlatform
+  };
+}
 function createPersonalMemoryCollection(db, runtimeContexts, options = {}) {
   const scopes = personalScopes(runtimeContexts);
   const getNowMs = () => options.now?.() ?? Date.now();
@@ -1852,12 +1884,14 @@ function createPersonalMemoryCollection(db, runtimeContexts, options = {}) {
           (term) => ilike(juniorMemoryMemories.content, `%${term}%`)
         )
       );
-      const rows = await db.select().from(juniorMemoryMemories).where(and2(active, cursor, search)).orderBy(
+      const kind = input.kind ? eq2(juniorMemoryMemories.kind, input.kind) : void 0;
+      const origin = input.origin === "automatic" ? like2(juniorMemoryMemories.idempotencyKey, "session:%") : input.origin === "explicit" ? like2(juniorMemoryMemories.idempotencyKey, "tool:%") : void 0;
+      const rows = await db.select().from(juniorMemoryMemories).where(and2(active, cursor, search, kind, origin)).orderBy(
         desc2(juniorMemoryMemories.createdAtMs),
         asc2(juniorMemoryMemories.id)
       ).limit(input.limit + 1);
       const hasNextPage = rows.length > input.limit;
-      const memories = rows.slice(0, input.limit).map(parseMemoryRow);
+      const memories = rows.slice(0, input.limit).map(personalMemoryRecord);
       const last = memories.at(-1);
       return {
         memories,
@@ -1868,6 +1902,103 @@ function createPersonalMemoryCollection(db, runtimeContexts, options = {}) {
           }
         } : {}
       };
+    },
+    async stats() {
+      const nowMs = getNowMs();
+      await archiveExpiredMemoryBatch({ db, nowMs, scopes });
+      const active = activeVisiblePredicate({ nowMs, scopes });
+      if (!active) {
+        return {
+          active: 0,
+          automatic: 0,
+          createdThirtyDays: 0,
+          embedded: 0,
+          explicit: 0,
+          knowledge: 0,
+          preference: 0,
+          procedure: 0
+        };
+      }
+      const [counts] = await db.select({
+        active: sql3`count(*)`.mapWith(Number),
+        automatic: sql3`count(*) filter (where ${juniorMemoryMemories.idempotencyKey} like 'session:%')`.mapWith(
+          Number
+        ),
+        createdThirtyDays: sql3`count(*) filter (where ${juniorMemoryMemories.createdAtMs} >= ${nowMs - 30 * 24 * 60 * 60 * 1e3})`.mapWith(
+          Number
+        ),
+        embedded: sql3`count(${juniorMemoryEmbeddings.memoryId})`.mapWith(
+          Number
+        ),
+        explicit: sql3`count(*) filter (where ${juniorMemoryMemories.idempotencyKey} like 'tool:%')`.mapWith(
+          Number
+        ),
+        knowledge: sql3`count(*) filter (where ${juniorMemoryMemories.kind} = 'knowledge')`.mapWith(
+          Number
+        ),
+        preference: sql3`count(*) filter (where ${juniorMemoryMemories.kind} = 'preference')`.mapWith(
+          Number
+        ),
+        procedure: sql3`count(*) filter (where ${juniorMemoryMemories.kind} = 'procedure')`.mapWith(
+          Number
+        )
+      }).from(juniorMemoryMemories).leftJoin(
+        juniorMemoryEmbeddings,
+        eq2(juniorMemoryEmbeddings.memoryId, juniorMemoryMemories.id)
+      ).where(active);
+      return {
+        active: counts?.active ?? 0,
+        automatic: counts?.automatic ?? 0,
+        createdThirtyDays: counts?.createdThirtyDays ?? 0,
+        embedded: counts?.embedded ?? 0,
+        explicit: counts?.explicit ?? 0,
+        knowledge: counts?.knowledge ?? 0,
+        preference: counts?.preference ?? 0,
+        procedure: counts?.procedure ?? 0
+      };
+    },
+    async timeline(input) {
+      input = personalMemoryTimelineInputSchema.parse(input);
+      const todayMs = Date.parse(`${utcDate(getNowMs())}T00:00:00.000Z`);
+      const startMs = todayMs - (input.days - 1) * DAY_MS;
+      const ownership = personalScopePredicate(scopes);
+      if (!ownership) {
+        return Array.from({ length: input.days }, (_, index2) => ({
+          date: utcDate(startMs + index2 * DAY_MS),
+          knowledge: 0,
+          preference: 0,
+          procedure: 0
+        }));
+      }
+      const rows = await db.select({
+        date: sql3`to_char(to_timestamp(${juniorMemoryMemories.createdAtMs} / 1000.0) AT TIME ZONE 'UTC', 'YYYY-MM-DD')`.as(
+          "date"
+        ),
+        knowledge: sql3`count(*) filter (where ${juniorMemoryMemories.kind} = 'knowledge')`.mapWith(
+          Number
+        ),
+        preference: sql3`count(*) filter (where ${juniorMemoryMemories.kind} = 'preference')`.mapWith(
+          Number
+        ),
+        procedure: sql3`count(*) filter (where ${juniorMemoryMemories.kind} = 'procedure')`.mapWith(
+          Number
+        )
+      }).from(juniorMemoryMemories).where(
+        and2(ownership, gt2(juniorMemoryMemories.createdAtMs, startMs - 1))
+      ).groupBy(
+        sql3`to_char(to_timestamp(${juniorMemoryMemories.createdAtMs} / 1000.0) AT TIME ZONE 'UTC', 'YYYY-MM-DD')`
+      );
+      const byDate = new Map(rows.map((row) => [row.date, row]));
+      return Array.from({ length: input.days }, (_, index2) => {
+        const date = utcDate(startMs + index2 * DAY_MS);
+        const row = byDate.get(date);
+        return {
+          date,
+          knowledge: row?.knowledge ?? 0,
+          preference: row?.preference ?? 0,
+          procedure: row?.procedure ?? 0
+        };
+      });
     }
   };
 }
@@ -1876,6 +2007,8 @@ function createPersonalMemoryCollection(db, runtimeContexts, options = {}) {
 var cursorSchema = z5.object({
   createdAtMs: z5.number().finite(),
   id: z5.string().min(1),
+  kind: z5.enum(["preference", "procedure", "knowledge"]).optional(),
+  origin: z5.enum(["automatic", "explicit"]).optional(),
   query: z5.string().max(200).optional(),
   version: z5.literal(1)
 }).strict();
@@ -1906,13 +2039,13 @@ function runtimeContext(actor) {
     }
   };
 }
-function decodeCursor(value, query) {
+function decodeCursor(value, input) {
   if (!value) return void 0;
   try {
     const parsed = cursorSchema.parse(
       JSON.parse(Buffer.from(value, "base64url").toString("utf8"))
     );
-    if (parsed.query !== query) {
+    if (parsed.query !== input.query || parsed.kind !== input.kind || parsed.origin !== input.origin) {
       throw new InvalidMemoryCursorError();
     }
     return { createdAtMs: parsed.createdAtMs, id: parsed.id };
@@ -1920,9 +2053,15 @@ function decodeCursor(value, query) {
     throw new InvalidMemoryCursorError();
   }
 }
-function encodeCursor(cursor, query) {
+function encodeCursor(cursor, input) {
   return Buffer.from(
-    JSON.stringify({ ...cursor, ...query ? { query } : {}, version: 1 }),
+    JSON.stringify({
+      ...cursor,
+      ...input.query ? { query: input.query } : {},
+      ...input.kind ? { kind: input.kind } : {},
+      ...input.origin ? { origin: input.origin } : {},
+      version: 1
+    }),
     "utf8"
   ).toString("base64url");
 }
@@ -1940,15 +2079,26 @@ function createViewerMemories(db, actors) {
     },
     async list(input) {
       const query = input.query?.trim() || void 0;
-      const page = await collection.list({
-        cursor: decodeCursor(input.cursor, query),
-        limit: input.limit,
+      const filters = {
+        ...input.kind ? { kind: input.kind } : {},
+        ...input.origin ? { origin: input.origin } : {},
         ...query ? { query } : {}
+      };
+      const page = await collection.list({
+        cursor: decodeCursor(input.cursor, filters),
+        ...filters,
+        limit: input.limit
       });
       return {
         memories: page.memories,
-        ...page.nextCursor ? { nextCursor: encodeCursor(page.nextCursor, query) } : {}
+        ...page.nextCursor ? { nextCursor: encodeCursor(page.nextCursor, filters) } : {}
       };
+    },
+    async stats() {
+      return await collection.stats();
+    },
+    async timeline(input) {
+      return await collection.timeline(input);
     }
   };
 }
@@ -1966,6 +2116,26 @@ var memoryListResponseSchema = z6.object({
   memories: z6.array(memoryApiSchema),
   nextCursor: z6.string().min(1).optional()
 }).strict();
+var memoryDashboardDaySchema = z6.object({
+  date: z6.iso.date(),
+  knowledge: z6.number().int().min(0),
+  preference: z6.number().int().min(0),
+  procedure: z6.number().int().min(0)
+}).strict();
+var memoryDashboardResponseSchema = z6.object({
+  days: z6.array(memoryDashboardDaySchema).length(90),
+  generatedAt: z6.iso.datetime(),
+  stats: z6.object({
+    active: z6.number().int().min(0),
+    automatic: z6.number().int().min(0),
+    createdThirtyDays: z6.number().int().min(0),
+    embedded: z6.number().int().min(0),
+    explicit: z6.number().int().min(0),
+    knowledge: z6.number().int().min(0),
+    preference: z6.number().int().min(0),
+    procedure: z6.number().int().min(0)
+  }).strict()
+}).strict();
 var memoryListQuerySchema = z6.object({
   cursor: z6.string().min(1).max(1e3).optional(),
   limit: z6.coerce.number().int().min(1).max(50).default(25),
@@ -2004,12 +2174,28 @@ function createMemoryApi(options) {
       const url = new URL(request.url);
       const memoryPath = /^\/memories\/([^/]+)$/.exec(url.pathname);
       const isCollection = url.pathname === "/memories";
-      if (!isCollection && !memoryPath) {
+      const isDashboard = url.pathname === "/dashboard";
+      if (!isCollection && !isDashboard && !memoryPath) {
         return json({ error: "Not found." }, 404);
       }
       const actors = await options.actors(email);
       const memories = createViewerMemories(options.db, actors);
       try {
+        if (isDashboard && (request.method === "GET" || request.method === "HEAD")) {
+          const [stats, days] = await Promise.all([
+            memories.stats(),
+            memories.timeline({ days: 90 })
+          ]);
+          const body = memoryDashboardResponseSchema.parse({
+            days,
+            generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            stats
+          });
+          return request.method === "HEAD" ? new Response(null, {
+            headers: { "cache-control": "no-store" },
+            status: 200
+          }) : json(body);
+        }
         if (isCollection && (request.method === "GET" || request.method === "HEAD")) {
           const query = memoryListQuerySchema.parse({
             cursor: url.searchParams.get("cursor") ?? void 0,
@@ -2925,7 +3111,7 @@ async function createMemoryPromptContributions(context) {
 // 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 z11 } from "zod";
-var DAY_MS = 24 * 60 * 60 * 1e3;
+var DAY_MS2 = 24 * 60 * 60 * 1e3;
 var WINDOWS = [7, 30, 90];
 var memoryDaySchema = z11.object({
   conversation: z11.number().int().nonnegative(),
@@ -2945,8 +3131,8 @@ function startOfUtcDay(value) {
 }
 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 start = startOfUtcDay(args.nowMs - (WINDOWS.at(-1) - 1) * DAY_MS2);
+  const endExclusiveMs = end.getTime() + DAY_MS2;
   const table = juniorMemoryMemories;
   const result = await args.db.execute(sql4`
     WITH days AS (
@@ -3010,7 +3196,7 @@ async function buildMemoryOperationalReport(args) {
       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(
+      createdThirtyDays: sql4`count(*) filter (where ${juniorMemoryMemories.createdAtMs} >= ${args.nowMs - 30 * DAY_MS2})`.mapWith(
         Number
       ),
       embedded: sql4`count(${juniorMemoryEmbeddings.memoryId}) filter (where ${active})`.mapWith(
@@ -3080,32 +3266,54 @@ async function buildMemoryOperationalReport(args) {
 }
 
 // src/user-pages.ts
-function memoryKindLabel(kind) {
-  return kind.charAt(0).toUpperCase() + kind.slice(1);
+function titleCase(value) {
+  return value.charAt(0).toUpperCase() + value.slice(1);
 }
 function rememberedDate(createdAtMs) {
   return new Intl.DateTimeFormat("en-US", {
     dateStyle: "medium",
+    timeStyle: "short",
     timeZone: "UTC"
   }).format(new Date(createdAtMs));
 }
+function originLabel(origin) {
+  if (origin === "automatic") return "Automatic";
+  if (origin === "explicit") return "Explicit";
+  return "Other";
+}
+function pageFilter(filter) {
+  if (filter === "preferences") return { kind: "preference" };
+  if (filter === "automatic") return { origin: "automatic" };
+  if (filter === "explicit") return { origin: "explicit" };
+  return {};
+}
+function pageEmptyText(input) {
+  if (input.query) return "No memories matched your search.";
+  if (input.filter === "preferences") return "No preferences yet.";
+  if (input.filter === "automatic") return "No learned memories yet.";
+  if (input.filter === "explicit") return "No saved memories yet.";
+  return "No personal memories yet.";
+}
 function createMemoryUserPage() {
   return {
     id: "memories",
     label: "Memories",
+    navigation: "primary",
     description: "Personal facts and preferences Junior remembers about you.",
     async read(ctx, input) {
-      const page = await createViewerMemories(
+      const memories = createViewerMemories(
         ctx.db,
         ctx.viewer.actors
-      ).list({
+      );
+      const page = await memories.list({
         cursor: input.cursor,
+        ...pageFilter(input.filter),
         limit: input.limit,
         ...input.query ? { query: input.query } : {}
       });
       return {
         type: "list",
-        emptyText: input.query ? "No memories matched your search." : "No personal memories yet.",
+        emptyText: pageEmptyText(input),
         ...page.nextCursor ? { nextCursor: page.nextCursor } : {},
         searchPlaceholder: "Search memories",
         records: page.memories.map((memory) => ({
@@ -3121,8 +3329,16 @@ function createMemoryUserPage() {
           id: memory.id,
           title: memory.content,
           metadata: [
-            { label: "Type", value: memoryKindLabel(memory.kind) },
-            { label: "Remembered", value: rememberedDate(memory.createdAtMs) }
+            { label: "Type", value: titleCase(memory.kind) },
+            { label: "Learned", value: originLabel(memory.origin) },
+            { label: "Source", value: titleCase(memory.sourcePlatform) },
+            { label: "Visibility", value: "Only you" },
+            { label: "Remembered", value: rememberedDate(memory.createdAtMs) },
+            { label: "Observed", value: rememberedDate(memory.observedAtMs) },
+            {
+              label: "Expires",
+              value: memory.expiresAtMs ? rememberedDate(memory.expiresAtMs) : "Never"
+            }
           ]
         }))
       };
@@ -3250,6 +3466,7 @@ export {
   MEMORY_KINDS,
   createMemoryStore,
   memoryApiSchema,
+  memoryDashboardResponseSchema,
   memoryListResponseSchema,
   memoryPlugin
 };