@sentry/junior-memory 0.124.0 → 0.124.2

package/dist/personal-store.d.ts

@@ -1,6 +1,10 @@
 import { z } from "zod";
 import { type MemoryDb, type MemoryRecord } from "./store";
-import type { MemoryRuntimeContext } from "./types";
+import { type MemoryRuntimeContext } from "./types";
+declare const memoryVisibilitySchema: z.ZodEnum<{
+    public: "public";
+    private: "private";
+}>;
 declare const personalMemoryCursorSchema: z.ZodObject<{
     createdAtMs: z.ZodNumber;
     id: z.ZodString;
@@ -10,29 +14,74 @@ declare const personalMemoryPageInputSchema: z.ZodObject<{
         createdAtMs: z.ZodNumber;
         id: z.ZodString;
     }, z.core.$strict>>;
+    kind: z.ZodOptional<z.ZodEnum<{
+        preference: "preference";
+        procedure: "procedure";
+        knowledge: "knowledge";
+    }>>;
     limit: z.ZodNumber;
+    origin: z.ZodOptional<z.ZodEnum<{
+        automatic: "automatic";
+        explicit: "explicit";
+    }>>;
     query: z.ZodOptional<z.ZodString>;
+    visibility: z.ZodOptional<z.ZodEnum<{
+        public: "public";
+        private: "private";
+    }>>;
 }, z.core.$strict>;
 export type PersonalMemoryCursor = z.output<typeof personalMemoryCursorSchema>;
 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 declare class PersonalMemoryNotFoundError extends Error {
     constructor();
 }
-/** 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[]>;
 }
-/** Build storage operations for every personal scope linked to one viewer. */
+/** Build storage operations for every memory scope linked to one viewer. */
 export declare function createPersonalMemoryCollection(db: MemoryDb, runtimeContexts: MemoryRuntimeContext[], options?: {
     now?: () => number;
 }): PersonalMemoryCollection;

package/dist/personal.d.ts

@@ -1,21 +1,31 @@
 import type { PluginUserPageActor } from "@sentry/junior-plugin-api";
+import { type MemoryVisibility, type PersonalMemoryRecord } from "./personal-store";
 import type { MemoryDb, MemoryRecord } from "./store";
+import type { MemoryKind } from "./types";
 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 declare class InvalidMemoryCursorError extends Error {
     constructor();
 }
 export { PersonalMemoryNotFoundError } from "./personal-store";
-/** Build personal-memory operations authorized by a viewer's linked actors. */
+export type { MemoryVisibility, PersonalMemoryRecord } from "./personal-store";
+/** Build viewer memory operations authorized by a viewer's linked actors. */
 export declare function createViewerMemories(db: MemoryDb, actors: PluginUserPageActor[]): {
     archive(id: string): Promise<MemoryRecord>;
-    get(id: string): Promise<MemoryRecord>;
+    get(id: string): Promise<PersonalMemoryRecord>;
     list(input: ViewerMemoryPageInput): Promise<ViewerMemoryPage>;
+    stats(): Promise<import("./personal-store").PersonalMemoryStats>;
+    timeline(input: {
+        days: number;
+    }): Promise<import("./personal-store").PersonalMemoryDay[]>;
 };

package/dist/user-pages.d.ts

@@ -1,4 +1,4 @@
-/** 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";
-/** Create the interactive personal Memories dashboard page. */
+/** Create the interactive Memories dashboard page. */
 export declare function createMemoryUserPage(): PluginUserPageDefinition;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/junior-memory",
-  "version": "0.124.0",
+  "version": "0.124.2",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -27,7 +27,7 @@
     "commander": "^14.0.3",
     "drizzle-orm": "^0.45.2",
     "zod": "^4.4.3",
-    "@sentry/junior-plugin-api": "0.124.0"
+    "@sentry/junior-plugin-api": "0.124.2"
   },
   "devDependencies": {
     "@types/node": "^25.9.1",

package/src/api.ts

@@ -1,8 +1,9 @@
 /**
- * Authenticated REST resources for personal memories.
+ * Authenticated REST resources for viewer-visible memories.
  *
  * HTTP identity is one verified viewer. Linked platform actors are resolved
- * behind the route boundary and used only to authorize personal scopes.
+ * behind the route boundary and used only to authorize personal and public
+ * workspace scopes.
  */
 import { z } from "zod";
 import {
@@ -11,11 +12,12 @@ import {
   type PluginRouteApp,
   type PluginUserPageActor,
 } from "@sentry/junior-plugin-api";
-import type { MemoryDb, MemoryRecord } from "./store";
+import type { MemoryDb } from "./store";
 import {
   createViewerMemories,
   InvalidMemoryCursorError,
   PersonalMemoryNotFoundError,
+  type PersonalMemoryRecord,
 } from "./personal";
 
 export const memoryApiSchema = z
@@ -26,6 +28,7 @@ export const memoryApiSchema = z
     id: z.string().min(1),
     kind: z.enum(["preference", "procedure", "knowledge"]),
     observedAt: z.iso.datetime(),
+    visibility: z.enum(["private", "public"]),
   })
   .strict();
 
@@ -36,7 +39,39 @@ export const memoryListResponseSchema = z
   })
   .strict();
 
+const memoryDashboardDaySchema = z
+  .object({
+    date: z.iso.date(),
+    personal: z.number().int().min(0),
+    public: z.number().int().min(0),
+  })
+  .strict();
+
+export const memoryDashboardResponseSchema = z
+  .object({
+    days: z.array(memoryDashboardDaySchema).length(90),
+    generatedAt: z.iso.datetime(),
+    stats: z
+      .object({
+        active: z.number().int().min(0),
+        automatic: z.number().int().min(0),
+        createdThirtyDays: z.number().int().min(0),
+        embedded: z.number().int().min(0),
+        explicit: z.number().int().min(0),
+        knowledge: z.number().int().min(0),
+        personal: z.number().int().min(0),
+        preference: z.number().int().min(0),
+        procedure: z.number().int().min(0),
+        public: z.number().int().min(0),
+      })
+      .strict(),
+  })
+  .strict();
+
 export type MemoryApi = z.output<typeof memoryApiSchema>;
+export type MemoryDashboardResponse = z.output<
+  typeof memoryDashboardResponseSchema
+>;
 export type MemoryListResponse = z.output<typeof memoryListResponseSchema>;
 
 const memoryListQuerySchema = z
@@ -59,7 +94,7 @@ function json(body: unknown, status = 200): Response {
   });
 }
 
-function apiMemory(memory: MemoryRecord): z.output<typeof memoryApiSchema> {
+function apiMemory(memory: PersonalMemoryRecord): z.output<typeof memoryApiSchema> {
   return {
     content: memory.content,
     createdAt: new Date(memory.createdAtMs).toISOString(),
@@ -69,6 +104,7 @@ function apiMemory(memory: MemoryRecord): z.output<typeof memoryApiSchema> {
     id: memory.id,
     kind: memory.kind,
     observedAt: new Date(memory.observedAtMs).toISOString(),
+    visibility: memory.visibility,
   };
 }
 
@@ -82,7 +118,7 @@ function viewerEmail(
   return parsed.data.auth.user.email?.trim().toLowerCase() || undefined;
 }
 
-/** Create the authenticated personal-memory REST app. */
+/** Create the authenticated viewer-memory REST app. */
 export function createMemoryApi(options: MemoryApiOptions): PluginRouteApp {
   return {
     async fetch(request, context) {
@@ -94,13 +130,35 @@ export function createMemoryApi(options: MemoryApiOptions): PluginRouteApp {
       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: 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")

package/src/index.ts

@@ -1,8 +1,10 @@
 export { memoryPlugin } from "./plugin";
 export {
   memoryApiSchema,
+  memoryDashboardResponseSchema,
   memoryListResponseSchema,
   type MemoryApi,
+  type MemoryDashboardResponse,
   type MemoryListResponse,
 } from "./api";
 export type { MemoryPluginOptions } from "./plugin";