@sentry/junior-memory 0.116.1 → 0.118.0

package/README.md

@@ -13,6 +13,8 @@ exported types, tools, and tests are authoritative.
   learning.
 - The `memory` CLI namespace provides explicit administrative search and
   inspection.
+- The dashboard exposes a read-only **Memories** user page for personal
+  memories owned by actors linked to the signed-in user.
 
 ## Scope And Visibility
 

package/dist/index.js

@@ -949,7 +949,7 @@ function mergeSearchCandidates(candidates, nowMs, currentChannelKey) {
   }).map((candidate) => candidate.memory);
 }
 function createMemoryStore(db, context, options = {}) {
-  const runtimeContext = memoryRuntimeContextSchema.parse(context);
+  const runtimeContext2 = memoryRuntimeContextSchema.parse(context);
   const parsedOptions = memoryStoreOptionsSchema.parse({ now: options.now });
   const embedder = options.embedder;
   const maxVectorDistance = options.maxVectorDistance;
@@ -961,14 +961,14 @@ function createMemoryStore(db, context, options = {}) {
       db,
       limit: input.limit,
       nowMs,
-      scopes: deriveVisibleMemoryScopes(runtimeContext)
+      scopes: deriveVisibleMemoryScopes(runtimeContext2)
     });
   }
   async function reuseDuplicateMemory(args) {
     await rememberDuplicateIdempotency({
       ...args,
       db,
-      runtimeContext
+      runtimeContext: runtimeContext2
     });
     await storeEmbedding({
       content: args.duplicate.content,
@@ -983,8 +983,8 @@ function createMemoryStore(db, context, options = {}) {
     const input = createMemoryInputSchema.parse(rawInput);
     const nowMs = getNowMs();
     const content = normalizeContent(input.content);
-    const scope = deriveMemoryScope(runtimeContext, scopeKind);
-    const subject = deriveMemorySubject(runtimeContext, scope);
+    const scope = deriveMemoryScope(runtimeContext2, scopeKind);
+    const subject = deriveMemorySubject(runtimeContext2, scope);
     if (content.length > MAX_MEMORY_CONTENT_CHARS) {
       throw new Error("Memory content exceeds the maximum length.");
     }
@@ -1075,7 +1075,7 @@ function createMemoryStore(db, context, options = {}) {
         candidates: preferenceCandidates,
         content,
         decider: supersessionDecider,
-        runtimeContext
+        runtimeContext: runtimeContext2
       });
       if (adjudication.decision === "duplicate") {
         return await reuseDuplicateMemory({
@@ -1102,8 +1102,8 @@ function createMemoryStore(db, context, options = {}) {
         observedAtMs: nowMs,
         scope: scope.scope,
         scopeKey: scope.scopeKey,
-        sourceKey: sourceKey(runtimeContext),
-        sourcePlatform: runtimeContext.source.platform,
+        sourceKey: sourceKey(runtimeContext2),
+        sourcePlatform: runtimeContext2.source.platform,
         subjectKey: subject.subjectKey,
         subjectType: subject.subjectType,
         kind: input.kind
@@ -1182,7 +1182,23 @@ function createMemoryStore(db, context, options = {}) {
     async listMemories(input) {
       input = listMemoriesInputSchema.parse(input);
       const nowMs = getNowMs();
-      const scopes = deriveVisibleMemoryScopes(runtimeContext);
+      const scopes = deriveVisibleMemoryScopes(runtimeContext2);
+      await archiveExpiredMemoryBatch({
+        db,
+        nowMs,
+        scopes
+      });
+      return await listVisibleMemories({
+        db,
+        limit: input.limit,
+        nowMs,
+        scopes
+      });
+    },
+    async listPersonalMemories(input) {
+      input = listMemoriesInputSchema.parse(input);
+      const nowMs = getNowMs();
+      const scopes = [deriveMemoryScope(runtimeContext2, "personal")];
       await archiveExpiredMemoryBatch({
         db,
         nowMs,
@@ -1198,7 +1214,7 @@ function createMemoryStore(db, context, options = {}) {
     async searchMemories(input) {
       input = searchMemoriesInputSchema.parse(input);
       const nowMs = getNowMs();
-      const scopes = deriveVisibleMemoryScopes(runtimeContext);
+      const scopes = deriveVisibleMemoryScopes(runtimeContext2);
       await archiveExpiredMemoryBatch({
         db,
         nowMs,
@@ -1228,13 +1244,13 @@ function createMemoryStore(db, context, options = {}) {
       return mergeSearchCandidates(
         [...vectorCandidates, ...lexicalCandidates],
         nowMs,
-        sourceChannelPrefix(runtimeContext)
+        sourceChannelPrefix(runtimeContext2)
       ).slice(0, limit);
     },
     async archiveMemory(input) {
       input = archiveMemoryInputSchema.parse(input);
       const nowMs = getNowMs();
-      const scopes = deriveVisibleMemoryScopes(runtimeContext);
+      const scopes = deriveVisibleMemoryScopes(runtimeContext2);
       const predicate = activeVisiblePredicate({ nowMs, scopes });
       const idPrefix = input.id.trim();
       if (!idPrefix) {
@@ -2072,7 +2088,7 @@ function createMemoryCreateTool(context) {
       const parsedInput = parseMemoryToolInput(createMemoryInputSchema2, input);
       const toolCallId = requireToolCallId(options.toolCallId);
       const requestedExpiresAtMs = parseExpiresAt(parsedInput.expires_at);
-      const runtimeContext = memoryRuntimeContext(context);
+      const runtimeContext2 = memoryRuntimeContext(context);
       const store = memoryStore(context, {
         supersessionDecider: context.supersessionDecider
       });
@@ -2083,7 +2099,7 @@ function createMemoryCreateTool(context) {
               parseCreateMemoryRequest({
                 content: requireMemoryContent(parsedInput.content),
                 ...requestedExpiresAtMs !== void 0 ? { expiresAtMs: requestedExpiresAtMs } : {},
-                runtimeContext,
+                runtimeContext: runtimeContext2,
                 ...context.userText?.trim() ? {
                   sourceContext: {
                     currentUserText: context.userText.trim()
@@ -2309,13 +2325,13 @@ async function processMemorySession(context) {
   if (!evidenceText) {
     return;
   }
-  const runtimeContext = memoryRuntimeContextSchema.parse({
+  const runtimeContext2 = memoryRuntimeContextSchema.parse({
     conversationId: run.conversationId,
     ...run.actor ? { actor: run.actor } : {},
     source: run.source
   });
   const agent = createMemoryAgent(context.model);
-  const store = createMemoryStore(context.db, runtimeContext, {
+  const store = createMemoryStore(context.db, runtimeContext2, {
     embedder: context.embedder,
     supersessionDecider: agent
   });
@@ -2331,7 +2347,7 @@ async function processMemorySession(context) {
       })),
       actors: run.actors,
       transcript,
-      runtimeContext
+      runtimeContext: runtimeContext2
     });
   });
   if (memories.length === 0) {
@@ -2352,6 +2368,10 @@ async function processMemorySession(context) {
 }
 
 // src/recall.ts
+import {
+  definePromptContext
+} from "@sentry/junior-plugin-api";
+import { z as z6 } from "zod";
 var DEFAULT_RECALL_LIMIT = 5;
 var MAX_PROMPT_CHARS = 4e3;
 var MAX_MEMORY_LINE_CHARS = 600;
@@ -2365,48 +2385,151 @@ function trimContent(content, maxLength) {
 function formatObservedDate(observedAtMs) {
   return new Date(observedAtMs).toISOString().slice(0, 10);
 }
-function renderMemoryPrompt(memories) {
+var recalledMemorySchema = z6.object({
+  id: z6.string().min(1),
+  content: z6.string().min(1).max(MAX_MEMORY_LINE_CHARS),
+  observedAtMs: z6.number().finite(),
+  scope: z6.enum(["personal", "conversation"]),
+  kind: z6.enum(["preference", "procedure", "knowledge"])
+}).strict();
+var memoryRecallContextSchema = z6.object({
+  memories: z6.array(recalledMemorySchema).min(1).max(DEFAULT_RECALL_LIMIT)
+}).strict();
+function selectPromptMemories(memories) {
   const header = "Relevant memories for this request:";
   const footer = "Treat these as possibly stale context. Current user instructions and repository evidence take priority.";
-  const lines = [];
+  const selected = [];
   let totalChars = header.length + footer.length + 2;
   for (const memory of memories) {
-    const line = `- Observed ${formatObservedDate(memory.observedAtMs)}: ${trimContent(
-      memory.content,
-      MAX_MEMORY_LINE_CHARS
-    )}`;
+    const content = trimContent(memory.content, MAX_MEMORY_LINE_CHARS);
+    const line = `- Observed ${formatObservedDate(memory.observedAtMs)}: ${content}`;
     if (totalChars + line.length + 1 > MAX_PROMPT_CHARS) {
       break;
     }
-    lines.push(line);
+    selected.push({
+      id: memory.id,
+      content,
+      observedAtMs: memory.observedAtMs,
+      scope: memory.scope,
+      kind: memory.kind
+    });
     totalChars += line.length + 1;
   }
-  if (lines.length === 0) {
-    return void 0;
-  }
-  return `${header}
-${lines.join("\n")}
-
-${footer}`;
+  return selected;
 }
-async function createMemoryPromptMessages(context) {
+function renderMemoryPrompt(memories) {
+  return [
+    "Relevant memories for this request:",
+    ...memories.map(
+      (memory) => `- Observed ${formatObservedDate(memory.observedAtMs)}: ${memory.content}`
+    ),
+    "",
+    "Treat these as possibly stale context. Current user instructions and repository evidence take priority."
+  ].join("\n");
+}
+var memoryRecallContext = definePromptContext({
+  kind: "recall",
+  version: 1,
+  schema: memoryRecallContextSchema,
+  renderPrompt: (content) => renderMemoryPrompt(content.memories)
+});
+async function createMemoryPromptContributions(context) {
   if (!context.text.trim()) {
     return void 0;
   }
-  const runtimeContext = memoryRuntimeContextSchema.parse({
+  const runtimeContext2 = memoryRuntimeContextSchema.parse({
     ...context.conversationId ? { conversationId: context.conversationId } : {},
     ...context.actor ? { actor: context.actor } : {},
     source: context.source
   });
-  const memories = await createMemoryStore(context.db, runtimeContext, {
+  const memories = await createMemoryStore(context.db, runtimeContext2, {
     ...context.embedder ? { embedder: context.embedder } : {},
     ...context.maxVectorDistance !== void 0 ? { maxVectorDistance: context.maxVectorDistance } : {}
   }).searchMemories({
     query: context.text,
     limit: DEFAULT_RECALL_LIMIT
   });
-  const text2 = renderMemoryPrompt(memories);
-  return text2 ? [{ text: text2 }] : void 0;
+  const selected = selectPromptMemories(memories);
+  if (selected.length === 0) {
+    return void 0;
+  }
+  if (selected.some((memory) => memory.scope === "personal")) {
+    return [{ text: renderMemoryPrompt(selected) }];
+  }
+  return [memoryRecallContext({ memories: selected })];
+}
+
+// src/user-pages.ts
+var MEMORY_PAGE_LIMIT = 100;
+function runtimeContext(actor) {
+  if (actor.platform === "slack") {
+    return {
+      actor,
+      source: {
+        platform: "slack",
+        type: "priv",
+        teamId: actor.teamId,
+        channelId: "DDASHBOARD"
+      }
+    };
+  }
+  return {
+    actor,
+    source: {
+      platform: "local",
+      type: "priv",
+      conversationId: "local:dashboard:memories"
+    }
+  };
+}
+function memoryKindLabel(kind) {
+  return kind.charAt(0).toUpperCase() + kind.slice(1);
+}
+function rememberedDate(createdAtMs) {
+  return new Intl.DateTimeFormat("en-US", {
+    dateStyle: "medium",
+    timeZone: "UTC"
+  }).format(new Date(createdAtMs));
+}
+async function readPersonalMemories(db, actors) {
+  const memories = await Promise.all(
+    actors.flatMap((actor) => {
+      const context = runtimeContext(actor);
+      return context ? [
+        createMemoryStore(db, context).listPersonalMemories({
+          limit: MEMORY_PAGE_LIMIT
+        })
+      ] : [];
+    })
+  );
+  return [
+    ...new Map(memories.flat().map((memory) => [memory.id, memory])).values()
+  ].sort((left, right) => right.createdAtMs - left.createdAtMs).slice(0, MEMORY_PAGE_LIMIT);
+}
+function createMemoryUserPage() {
+  return {
+    id: "memories",
+    label: "Memories",
+    description: "Personal facts and preferences Junior remembers about you.",
+    async read(ctx) {
+      const memories = await readPersonalMemories(
+        ctx.db,
+        ctx.viewer.actors
+      );
+      return {
+        type: "list",
+        emptyText: "No personal memories yet.",
+        records: memories.map((memory) => ({
+          id: memory.id,
+          title: memory.content,
+          metadata: [
+            { label: "Type", value: memoryKindLabel(memory.kind) },
+            { label: "Remembered", value: rememberedDate(memory.createdAtMs) }
+          ]
+        }))
+      };
+    }
+  };
 }
 
 // src/plugin.ts
@@ -2471,6 +2594,7 @@ function createMemoryPlugin(options = {}) {
         }
       }
     },
+    userPages: [createMemoryUserPage()],
     hooks: {
       tools(ctx) {
         const agent = createMemoryAgent(ctx.model);
@@ -2496,7 +2620,7 @@ function createMemoryPlugin(options = {}) {
         };
       },
       async userPrompt(ctx) {
-        return await createMemoryPromptMessages({
+        return await createMemoryPromptContributions({
           ...ctx.conversationId ? { conversationId: ctx.conversationId } : {},
           ...ctx.actor ? { actor: ctx.actor } : {},
           db: ctx.db,