@sentry/junior-memory 0.124.0 → 0.124.2

package/src/personal-store.ts

@@ -1,10 +1,10 @@
 /**
- * SQL operations over personal memories owned by one authenticated viewer.
+ * SQL operations over memories visible to one authenticated viewer.
  *
  * A viewer may resolve to several runtime actors. This store combines their
- * personal scopes without treating one actor as the canonical identity.
+ * personal scopes with authorized public workspace conversation scopes.
  */
-import { and, asc, desc, eq, gt, ilike, lt, or, sql } from "drizzle-orm";
+import { and, asc, desc, eq, gt, ilike, like, lt, or, sql } from "drizzle-orm";
 import { z } from "zod";
 import { juniorMemoryEmbeddings, juniorMemoryMemories } from "./db/schema";
 import { deriveMemoryScope, type ResolvedMemoryScope } from "./scope";
@@ -15,9 +15,10 @@ import {
   type MemoryDb,
   type MemoryRecord,
 } from "./store";
-import type { MemoryRuntimeContext } from "./types";
+import { MEMORY_KINDS, type MemoryRuntimeContext } from "./types";
 
 const nonEmptyStringSchema = z.string().min(1);
+const memoryVisibilitySchema = z.enum(["private", "public"]);
 const personalMemoryCursorSchema = z
   .object({
     createdAtMs: z.number().finite(),
@@ -27,10 +28,19 @@ const personalMemoryCursorSchema = z
 const personalMemoryPageInputSchema = z
   .object({
     cursor: personalMemoryCursorSchema.optional(),
+    kind: z.enum(MEMORY_KINDS).optional(),
     limit: z.number().int().min(1).max(50),
+    origin: z.enum(["automatic", "explicit"]).optional(),
     query: z.string().max(200).optional(),
+    visibility: memoryVisibilitySchema.optional(),
   })
   .strict();
+const personalMemoryTimelineInputSchema = z
+  .object({
+    days: z.number().int().min(1).max(365),
+  })
+  .strict();
+const DAY_MS = 24 * 60 * 60 * 1_000;
 
 export type PersonalMemoryCursor = z.output<typeof personalMemoryCursorSchema>;
 
@@ -38,11 +48,41 @@ export type PersonalMemoryPageInput = z.output<
   typeof personalMemoryPageInputSchema
 >;
 
+export type MemoryVisibility = z.output<typeof memoryVisibilitySchema>;
+
 export interface PersonalMemoryPage {
-  memories: MemoryRecord[];
+  memories: PersonalMemoryRecord[];
   nextCursor?: PersonalMemoryCursor;
 }
 
+/** Safe provenance attached to one viewer-visible memory. */
+export type PersonalMemoryRecord = MemoryRecord & {
+  origin: "automatic" | "explicit" | "other";
+  sourcePlatform: "local" | "slack";
+  visibility: MemoryVisibility;
+};
+
+/** Viewer-scoped active memory totals used by the dashboard. */
+export interface PersonalMemoryStats {
+  active: number;
+  automatic: number;
+  createdThirtyDays: number;
+  embedded: number;
+  explicit: number;
+  knowledge: number;
+  personal: number;
+  preference: number;
+  procedure: number;
+  public: number;
+}
+
+/** Viewer-scoped memory creation totals for one UTC calendar day. */
+export interface PersonalMemoryDay {
+  date: string;
+  personal: number;
+  public: number;
+}
+
 /** Expected failure when a viewer does not own the requested memory. */
 export class PersonalMemoryNotFoundError extends Error {
   constructor() {
@@ -51,14 +91,18 @@ export class PersonalMemoryNotFoundError extends Error {
   }
 }
 
-/** Viewer-scoped personal memory operations shared by dashboard and REST. */
+/** Viewer-scoped memory operations shared by dashboard and REST. */
 export interface PersonalMemoryCollection {
   /** Archive one exact personal memory owned by a linked actor. */
   archive(id: string): Promise<MemoryRecord>;
-  /** Read one exact personal memory owned by a linked actor. */
-  get(id: string): Promise<MemoryRecord>;
-  /** List one stable page across every linked personal scope. */
+  /** Read one exact memory visible to a linked actor. */
+  get(id: string): Promise<PersonalMemoryRecord>;
+  /** List one stable page across every authorized viewer scope. */
   list(input: PersonalMemoryPageInput): Promise<PersonalMemoryPage>;
+  /** Summarize active memories across every authorized viewer scope. */
+  stats(): Promise<PersonalMemoryStats>;
+  /** Read memory creation history across every authorized viewer scope. */
+  timeline(input: { days: number }): Promise<PersonalMemoryDay[]>;
 }
 
 function personalScopes(
@@ -74,6 +118,45 @@ function personalScopes(
   ];
 }
 
+/** Public workspace conversation scopes authorized by the viewer's Slack teams. */
+function publicWorkspaceScopes(
+  runtimeContexts: MemoryRuntimeContext[],
+): ResolvedMemoryScope[] {
+  return [
+    ...new Map(
+      runtimeContexts.flatMap((context) => {
+        if (context.source.platform !== "slack" || !context.actor) {
+          return [];
+        }
+        if (context.actor.platform !== "slack") {
+          return [];
+        }
+        const scope: ResolvedMemoryScope = {
+          scope: "conversation",
+          scopeKey: `slack:${context.actor.teamId}`,
+        };
+        return [[`${scope.scope}:${scope.scopeKey}`, scope] as const];
+      }),
+    ).values(),
+  ];
+}
+
+function scopePredicate(scopes: ResolvedMemoryScope[]) {
+  if (scopes.length === 0) return undefined;
+  return or(
+    ...scopes.map((scope) =>
+      and(
+        eq(juniorMemoryMemories.scope, scope.scope),
+        eq(juniorMemoryMemories.scopeKey, scope.scopeKey),
+      ),
+    ),
+  );
+}
+
+function utcDate(ms: number): string {
+  return new Date(ms).toISOString().slice(0, 10);
+}
+
 function searchTerms(query: string): string[] {
   return [
     ...new Set(
@@ -86,20 +169,75 @@ function searchTerms(query: string): string[] {
   ];
 }
 
-/** Build storage operations for every personal scope linked to one viewer. */
+function memoryOrigin(
+  idempotencyKey: string | null,
+): PersonalMemoryRecord["origin"] {
+  if (idempotencyKey?.startsWith("session:")) return "automatic";
+  if (idempotencyKey?.startsWith("tool:")) return "explicit";
+  return "other";
+}
+
+function memoryVisibility(
+  scope: MemoryRecord["scope"],
+): PersonalMemoryRecord["visibility"] {
+  return scope === "personal" ? "private" : "public";
+}
+
+function personalMemoryRecord(
+  row: typeof juniorMemoryMemories.$inferSelect,
+): PersonalMemoryRecord {
+  const memory = parseMemoryRow(row);
+  return {
+    ...memory,
+    origin: memoryOrigin(row.idempotencyKey),
+    sourcePlatform: row.sourcePlatform,
+    visibility: memoryVisibility(memory.scope),
+  };
+}
+
+function emptyStats(): PersonalMemoryStats {
+  return {
+    active: 0,
+    automatic: 0,
+    createdThirtyDays: 0,
+    embedded: 0,
+    explicit: 0,
+    knowledge: 0,
+    personal: 0,
+    preference: 0,
+    procedure: 0,
+    public: 0,
+  };
+}
+
+/** Build storage operations for every memory scope linked to one viewer. */
 export function createPersonalMemoryCollection(
   db: MemoryDb,
   runtimeContexts: MemoryRuntimeContext[],
   options: { now?: () => number } = {},
 ): PersonalMemoryCollection {
-  const scopes = personalScopes(runtimeContexts);
+  const privateScopes = personalScopes(runtimeContexts);
+  const publicScopes = publicWorkspaceScopes(runtimeContexts);
+  const allScopes = [...privateScopes, ...publicScopes];
   const getNowMs = () => options.now?.() ?? Date.now();
 
+  function scopesForVisibility(
+    visibility: MemoryVisibility | undefined,
+  ): ResolvedMemoryScope[] {
+    if (visibility === "private") return privateScopes;
+    if (visibility === "public") return publicScopes;
+    return allScopes;
+  }
+
   return {
     async archive(id) {
       const memoryId = nonEmptyStringSchema.parse(id);
       const nowMs = getNowMs();
-      const predicate = activeVisiblePredicate({ nowMs, scopes });
+      // Forget is personal-only; public workspace memories stay shared.
+      const predicate = activeVisiblePredicate({
+        nowMs,
+        scopes: privateScopes,
+      });
       if (!predicate) {
         throw new PersonalMemoryNotFoundError();
       }
@@ -123,7 +261,7 @@ export function createPersonalMemoryCollection(
     async get(id) {
       const memoryId = nonEmptyStringSchema.parse(id);
       const nowMs = getNowMs();
-      const predicate = activeVisiblePredicate({ nowMs, scopes });
+      const predicate = activeVisiblePredicate({ nowMs, scopes: allScopes });
       if (!predicate) {
         throw new PersonalMemoryNotFoundError();
       }
@@ -135,12 +273,13 @@ export function createPersonalMemoryCollection(
       if (!rows[0]) {
         throw new PersonalMemoryNotFoundError();
       }
-      return parseMemoryRow(rows[0]);
+      return personalMemoryRecord(rows[0]);
     },
 
     async list(input) {
       input = personalMemoryPageInputSchema.parse(input);
       const nowMs = getNowMs();
+      const scopes = scopesForVisibility(input.visibility);
       await archiveExpiredMemoryBatch({ db, nowMs, scopes });
       const active = activeVisiblePredicate({ nowMs, scopes });
       if (!active) {
@@ -167,17 +306,26 @@ export function createPersonalMemoryCollection(
                   ilike(juniorMemoryMemories.content, `%${term}%`),
                 ),
               );
+      const kind = input.kind
+        ? eq(juniorMemoryMemories.kind, input.kind)
+        : undefined;
+      const origin =
+        input.origin === "automatic"
+          ? like(juniorMemoryMemories.idempotencyKey, "session:%")
+          : input.origin === "explicit"
+            ? like(juniorMemoryMemories.idempotencyKey, "tool:%")
+            : undefined;
       const rows = await db
         .select()
         .from(juniorMemoryMemories)
-        .where(and(active, cursor, search))
+        .where(and(active, cursor, search, kind, origin))
         .orderBy(
           desc(juniorMemoryMemories.createdAtMs),
           asc(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,
@@ -191,5 +339,117 @@ export function createPersonalMemoryCollection(
           : {}),
       };
     },
+
+    async stats() {
+      const nowMs = getNowMs();
+      await archiveExpiredMemoryBatch({ db, nowMs, scopes: allScopes });
+      const active = activeVisiblePredicate({ nowMs, scopes: allScopes });
+      if (!active) {
+        return emptyStats();
+      }
+      const [counts] = await db
+        .select({
+          active: sql<number>`count(*)`.mapWith(Number),
+          automatic:
+            sql<number>`count(*) filter (where ${juniorMemoryMemories.idempotencyKey} like 'session:%')`.mapWith(
+              Number,
+            ),
+          createdThirtyDays:
+            sql<number>`count(*) filter (where ${juniorMemoryMemories.createdAtMs} >= ${nowMs - 30 * 24 * 60 * 60 * 1_000})`.mapWith(
+              Number,
+            ),
+          embedded:
+            sql<number>`count(${juniorMemoryEmbeddings.memoryId})`.mapWith(
+              Number,
+            ),
+          explicit:
+            sql<number>`count(*) filter (where ${juniorMemoryMemories.idempotencyKey} like 'tool:%')`.mapWith(
+              Number,
+            ),
+          knowledge:
+            sql<number>`count(*) filter (where ${juniorMemoryMemories.kind} = 'knowledge')`.mapWith(
+              Number,
+            ),
+          personal:
+            sql<number>`count(*) filter (where ${juniorMemoryMemories.scope} = 'personal')`.mapWith(
+              Number,
+            ),
+          preference:
+            sql<number>`count(*) filter (where ${juniorMemoryMemories.kind} = 'preference')`.mapWith(
+              Number,
+            ),
+          procedure:
+            sql<number>`count(*) filter (where ${juniorMemoryMemories.kind} = 'procedure')`.mapWith(
+              Number,
+            ),
+          public:
+            sql<number>`count(*) filter (where ${juniorMemoryMemories.scope} = 'conversation')`.mapWith(
+              Number,
+            ),
+        })
+        .from(juniorMemoryMemories)
+        .leftJoin(
+          juniorMemoryEmbeddings,
+          eq(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,
+        personal: counts?.personal ?? 0,
+        preference: counts?.preference ?? 0,
+        procedure: counts?.procedure ?? 0,
+        public: counts?.public ?? 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 = scopePredicate(allScopes);
+      if (!ownership) {
+        return Array.from({ length: input.days }, (_, index) => ({
+          date: utcDate(startMs + index * DAY_MS),
+          personal: 0,
+          public: 0,
+        }));
+      }
+      const rows = await db
+        .select({
+          date: sql<string>`to_char(to_timestamp(${juniorMemoryMemories.createdAtMs} / 1000.0) AT TIME ZONE 'UTC', 'YYYY-MM-DD')`.as(
+            "date",
+          ),
+          personal:
+            sql<number>`count(*) filter (where ${juniorMemoryMemories.scope} = 'personal')`.mapWith(
+              Number,
+            ),
+          public:
+            sql<number>`count(*) filter (where ${juniorMemoryMemories.scope} = 'conversation')`.mapWith(
+              Number,
+            ),
+        })
+        .from(juniorMemoryMemories)
+        .where(
+          and(ownership, gt(juniorMemoryMemories.createdAtMs, startMs - 1)),
+        )
+        .groupBy(
+          sql`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 }, (_, index) => {
+        const date = utcDate(startMs + index * DAY_MS);
+        const row = byDate.get(date);
+        return {
+          date,
+          personal: row?.personal ?? 0,
+          public: row?.public ?? 0,
+        };
+      });
+    },
   };
 }

package/src/personal.ts

@@ -2,32 +2,43 @@
  * Authenticated-viewer memory access shared by REST and dashboard projections.
  *
  * Viewer identity may resolve to multiple platform actors. This module keeps
- * that federation behind one personal-memory collection.
+ * that federation behind one viewer-memory collection spanning personal and
+ * authorized public workspace scopes.
  */
 import { z } from "zod";
 import type { PluginUserPageActor } from "@sentry/junior-plugin-api";
-import { createPersonalMemoryCollection } from "./personal-store";
+import {
+  createPersonalMemoryCollection,
+  type MemoryVisibility,
+  type PersonalMemoryRecord,
+} from "./personal-store";
 import type { MemoryDb, MemoryRecord } from "./store";
-import type { MemoryRuntimeContext } from "./types";
+import type { MemoryKind, MemoryRuntimeContext } from "./types";
 
 const cursorSchema = z
   .object({
     createdAtMs: z.number().finite(),
     id: z.string().min(1),
+    kind: z.enum(["preference", "procedure", "knowledge"]).optional(),
+    origin: z.enum(["automatic", "explicit"]).optional(),
     query: z.string().max(200).optional(),
     version: z.literal(1),
+    visibility: z.enum(["private", "public"]).optional(),
   })
   .strict();
 
 export interface ViewerMemoryPage {
-  memories: MemoryRecord[];
+  memories: PersonalMemoryRecord[];
   nextCursor?: string;
 }
 
 export interface ViewerMemoryPageInput {
   cursor?: string;
+  kind?: MemoryKind;
   limit: number;
+  origin?: "automatic" | "explicit";
   query?: string;
+  visibility?: MemoryVisibility;
 }
 
 export class InvalidMemoryCursorError extends Error {
@@ -38,6 +49,7 @@ export class InvalidMemoryCursorError extends Error {
 }
 
 export { PersonalMemoryNotFoundError } from "./personal-store";
+export type { MemoryVisibility, PersonalMemoryRecord } from "./personal-store";
 
 function runtimeContext(actor: PluginUserPageActor): MemoryRuntimeContext {
   if (actor.platform === "slack") {
@@ -61,13 +73,21 @@ function runtimeContext(actor: PluginUserPageActor): MemoryRuntimeContext {
   };
 }
 
-function decodeCursor(value: string | undefined, query: string | undefined) {
+function decodeCursor(
+  value: string | undefined,
+  input: Pick<ViewerMemoryPageInput, "kind" | "origin" | "query" | "visibility">,
+) {
   if (!value) return undefined;
   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 ||
+      parsed.visibility !== input.visibility
+    ) {
       throw new InvalidMemoryCursorError();
     }
     return { createdAtMs: parsed.createdAtMs, id: parsed.id };
@@ -78,15 +98,22 @@ function decodeCursor(value: string | undefined, query: string | undefined) {
 
 function encodeCursor(
   cursor: { createdAtMs: number; id: string },
-  query: string | undefined,
+  input: Pick<ViewerMemoryPageInput, "kind" | "origin" | "query" | "visibility">,
 ): string {
   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 } : {}),
+      ...(input.visibility ? { visibility: input.visibility } : {}),
+      version: 1,
+    }),
     "utf8",
   ).toString("base64url");
 }
 
-/** Build personal-memory operations authorized by a viewer's linked actors. */
+/** Build viewer memory operations authorized by a viewer's linked actors. */
 export function createViewerMemories(
   db: MemoryDb,
   actors: PluginUserPageActor[],
@@ -99,22 +126,34 @@ export function createViewerMemories(
     async archive(id: string): Promise<MemoryRecord> {
       return await collection.archive(id);
     },
-    async get(id: string): Promise<MemoryRecord> {
+    async get(id: string): Promise<PersonalMemoryRecord> {
       return await collection.get(id);
     },
     async list(input: ViewerMemoryPageInput): Promise<ViewerMemoryPage> {
       const query = input.query?.trim() || undefined;
+      const filters = {
+        ...(input.kind ? { kind: input.kind } : {}),
+        ...(input.origin ? { origin: input.origin } : {}),
+        ...(query ? { query } : {}),
+        ...(input.visibility ? { visibility: input.visibility } : {}),
+      };
       const page = await collection.list({
-        cursor: decodeCursor(input.cursor, query),
+        cursor: decodeCursor(input.cursor, filters),
+        ...filters,
         limit: input.limit,
-        ...(query ? { query } : {}),
       });
       return {
         memories: page.memories,
         ...(page.nextCursor
-          ? { nextCursor: encodeCursor(page.nextCursor, query) }
+          ? { nextCursor: encodeCursor(page.nextCursor, filters) }
           : {}),
       };
     },
+    async stats() {
+      return await collection.stats();
+    },
+    async timeline(input: { days: number }) {
+      return await collection.timeline(input);
+    },
   };
 }

package/src/user-pages.ts

@@ -1,56 +1,104 @@
-/** Project viewer-owned memories into Junior's core-rendered user page. */
+/** Project viewer-visible memories into Junior's core-rendered user page. */
 import type { PluginUserPageDefinition } from "@sentry/junior-plugin-api";
 import { createViewerMemories } from "./personal";
-import type { MemoryDb, MemoryRecord } from "./store";
+import type {
+  MemoryVisibility,
+  PersonalMemoryRecord,
+} from "./personal-store";
+import type { MemoryDb } from "./store";
 
-function memoryKindLabel(kind: MemoryRecord["kind"]): string {
-  return kind.charAt(0).toUpperCase() + kind.slice(1);
+function titleCase(value: string): string {
+  return value.charAt(0).toUpperCase() + value.slice(1);
 }
 
 function rememberedDate(createdAtMs: number): string {
   return new Intl.DateTimeFormat("en-US", {
     dateStyle: "medium",
+    timeStyle: "short",
     timeZone: "UTC",
   }).format(new Date(createdAtMs));
 }
 
-/** Create the interactive personal Memories dashboard page. */
+function originLabel(origin: PersonalMemoryRecord["origin"]): string {
+  if (origin === "automatic") return "Automatic";
+  if (origin === "explicit") return "Explicit";
+  return "Other";
+}
+
+function visibilityLabel(visibility: MemoryVisibility): string {
+  return visibility === "public" ? "Public" : "Private";
+}
+
+function pageFilter(filter: string | undefined): {
+  visibility?: MemoryVisibility;
+} {
+  if (filter === "private") return { visibility: "private" };
+  if (filter === "public") return { visibility: "public" };
+  return {};
+}
+
+function pageEmptyText(input: { filter?: string; query?: string }): string {
+  if (input.query) return "No memories matched your search.";
+  if (input.filter === "private") return "No private memories yet.";
+  if (input.filter === "public") return "No public memories yet.";
+  return "No memories yet.";
+}
+
+/** Create the interactive Memories dashboard page. */
 export function createMemoryUserPage(): PluginUserPageDefinition {
   return {
     id: "memories",
     label: "Memories",
-    description: "Personal facts and preferences Junior remembers about you.",
+    navigation: "primary",
+    description:
+      "Personal and public memories Junior can use across conversations.",
     async read(ctx, input) {
-      const page = await createViewerMemories(
+      const memories = createViewerMemories(
         ctx.db as MemoryDb,
         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) => ({
-          actions: [
-            {
-              confirmation: "Forget this memory?",
-              href: `/api/plugins/memory/memories/${encodeURIComponent(memory.id)}`,
-              label: "Forget",
-              method: "DELETE" as const,
-              tone: "danger" as const,
-            },
-          ],
+          actions:
+            memory.visibility === "private"
+              ? [
+                  {
+                    confirmation: "Forget this memory?",
+                    href: `/api/plugins/memory/memories/${encodeURIComponent(memory.id)}`,
+                    label: "Forget",
+                    method: "DELETE" as const,
+                    tone: "danger" as const,
+                  },
+                ]
+              : [],
           id: memory.id,
           title: memory.content,
           metadata: [
-            { label: "Type", value: memoryKindLabel(memory.kind) },
+            { label: "Type", value: titleCase(memory.kind) },
+            { label: "Learned", value: originLabel(memory.origin) },
+            { label: "Source", value: titleCase(memory.sourcePlatform) },
+            {
+              label: "Visibility",
+              value: visibilityLabel(memory.visibility),
+            },
             { label: "Remembered", value: rememberedDate(memory.createdAtMs) },
+            { label: "Observed", value: rememberedDate(memory.observedAtMs) },
+            {
+              label: "Expires",
+              value: memory.expiresAtMs
+                ? rememberedDate(memory.expiresAtMs)
+                : "Never",
+            },
           ],
         })),
       };