@sentry/junior-memory 0.120.0 → 0.122.0

package/dist/operational-report.d.ts

@@ -0,0 +1,7 @@
+import type { PluginOperationalReportContent } from "@sentry/junior-plugin-api";
+import type { MemoryDb } from "./store";
+/** Build aggregate memory storage and indexing diagnostics for the System page. */
+export declare function buildMemoryOperationalReport(args: {
+    db: MemoryDb;
+    nowMs: number;
+}): Promise<PluginOperationalReportContent>;

package/dist/recall.d.ts

@@ -31,10 +31,5 @@ export declare const memoryRecallContextSchema: z.ZodObject<{
         }>;
     }, z.core.$strict>>;
 }, z.core.$strict>;
-/**
- * Build active memory recall contributions.
- *
- * Personal recall remains prompt-only so conversation reporting cannot widen
- * actor-scoped memory visibility.
- */
+/** Build active memory recall contributions. */
 export declare function createMemoryPromptContributions(context: MemoryRecallContext): Promise<UserPromptContribution[] | undefined>;

package/dist/tools.d.ts

@@ -52,6 +52,39 @@ export declare function createMemoryCreateTool(context: MemoryCreateToolContext)
         message: string;
         retryable?: boolean | undefined;
     } | undefined;
+}, {
+    [x: string]: unknown;
+    ok: true;
+    status: "success";
+    target: string;
+    data: {
+        created: boolean;
+        memory: {
+            id: string;
+            content: string;
+            createdAtMs: number;
+            observedAtMs: number;
+            expiresAtMs?: number | undefined;
+        };
+    };
+    created: boolean;
+    memory: {
+        id: string;
+        content: string;
+        createdAtMs: number;
+        observedAtMs: number;
+        expiresAtMs?: number | undefined;
+    };
+    truncated?: boolean | undefined;
+    continuation?: {
+        arguments: Record<string, unknown>;
+        reason?: string | undefined;
+    } | undefined;
+    error?: string | {
+        kind: string;
+        message: string;
+        retryable?: boolean | undefined;
+    } | undefined;
 }>;
 /** Create a tool that archives a visible memory in the active context. */
 export declare function createMemoryRemoveTool(context: MemoryToolContext): import("@sentry/junior-plugin-api").PluginToolDefinition<{
@@ -87,6 +120,37 @@ export declare function createMemoryRemoveTool(context: MemoryToolContext): impo
         message: string;
         retryable?: boolean | undefined;
     } | undefined;
+}, {
+    [x: string]: unknown;
+    ok: true;
+    status: "success";
+    target: string;
+    data: {
+        memory: {
+            id: string;
+            content: string;
+            createdAtMs: number;
+            observedAtMs: number;
+            expiresAtMs?: number | undefined;
+        };
+    };
+    memory: {
+        id: string;
+        content: string;
+        createdAtMs: number;
+        observedAtMs: number;
+        expiresAtMs?: number | undefined;
+    };
+    truncated?: boolean | undefined;
+    continuation?: {
+        arguments: Record<string, unknown>;
+        reason?: string | undefined;
+    } | undefined;
+    error?: string | {
+        kind: string;
+        message: string;
+        retryable?: boolean | undefined;
+    } | undefined;
 }>;
 /** Create a tool that lists visible active memories in the active context. */
 export declare function createMemoryListTool(context: MemoryToolContext): import("@sentry/junior-plugin-api").PluginToolDefinition<{
@@ -122,6 +186,37 @@ export declare function createMemoryListTool(context: MemoryToolContext): import
         message: string;
         retryable?: boolean | undefined;
     } | undefined;
+}, {
+    [x: string]: unknown;
+    ok: true;
+    status: "success";
+    target: string;
+    data: {
+        memories: {
+            id: string;
+            content: string;
+            createdAtMs: number;
+            observedAtMs: number;
+            expiresAtMs?: number | undefined;
+        }[];
+    };
+    memories: {
+        id: string;
+        content: string;
+        createdAtMs: number;
+        observedAtMs: number;
+        expiresAtMs?: number | undefined;
+    }[];
+    truncated?: boolean | undefined;
+    continuation?: {
+        arguments: Record<string, unknown>;
+        reason?: string | undefined;
+    } | undefined;
+    error?: string | {
+        kind: string;
+        message: string;
+        retryable?: boolean | undefined;
+    } | undefined;
 }>;
 /** Create a tool that searches visible active memories in the active context. */
 export declare function createMemorySearchTool(context: MemoryToolContext): import("@sentry/junior-plugin-api").PluginToolDefinition<{
@@ -158,4 +253,35 @@ export declare function createMemorySearchTool(context: MemoryToolContext): impo
         message: string;
         retryable?: boolean | undefined;
     } | undefined;
+}, {
+    [x: string]: unknown;
+    ok: true;
+    status: "success";
+    target: string;
+    data: {
+        memories: {
+            id: string;
+            content: string;
+            createdAtMs: number;
+            observedAtMs: number;
+            expiresAtMs?: number | undefined;
+        }[];
+    };
+    memories: {
+        id: string;
+        content: string;
+        createdAtMs: number;
+        observedAtMs: number;
+        expiresAtMs?: number | undefined;
+    }[];
+    truncated?: boolean | undefined;
+    continuation?: {
+        arguments: Record<string, unknown>;
+        reason?: string | undefined;
+    } | undefined;
+    error?: string | {
+        kind: string;
+        message: string;
+        retryable?: boolean | undefined;
+    } | undefined;
 }>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/junior-memory",
-  "version": "0.120.0",
+  "version": "0.122.0",
   "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.120.0"
+    "@sentry/junior-plugin-api": "0.122.0"
   },
   "devDependencies": {
     "@types/node": "^25.9.1",

package/src/operational-report.ts

@@ -0,0 +1,191 @@
+import type { PluginOperationalReportContent } from "@sentry/junior-plugin-api";
+import { and, eq, gt, isNull, or, sql } from "drizzle-orm";
+import { z } from "zod";
+import { juniorMemoryEmbeddings, juniorMemoryMemories } from "./db/schema";
+import type { MemoryDb } from "./store";
+
+const DAY_MS = 24 * 60 * 60 * 1_000;
+const WINDOWS = [7, 30, 90] as const;
+
+const memoryDaySchema = z
+  .object({
+    conversation: z.number().int().nonnegative(),
+    date: z.string().date(),
+    personal: z.number().int().nonnegative(),
+  })
+  .strict();
+
+function queryRows(result: unknown): unknown[] {
+  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: number): Date {
+  const date = new Date(value);
+  date.setUTCHours(0, 0, 0, 0);
+  return date;
+}
+
+async function aggregateMemoryDays(args: { db: MemoryDb; nowMs: number }) {
+  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(sql`
+    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 z.array(memoryDaySchema).parse(queryRows(result));
+}
+
+function formatCount(value: number): string {
+  return new Intl.NumberFormat("en-US").format(value);
+}
+
+function formatPercent(value: number): string {
+  return new Intl.NumberFormat("en-US", {
+    maximumFractionDigits: 0,
+    style: "percent",
+  }).format(value);
+}
+
+/** Build aggregate memory storage and indexing diagnostics for the System page. */
+export async function buildMemoryOperationalReport(args: {
+  db: MemoryDb;
+  nowMs: number;
+}): Promise<PluginOperationalReportContent> {
+  const active = and(
+    isNull(juniorMemoryMemories.archivedAtMs),
+    isNull(juniorMemoryMemories.supersededAtMs),
+    isNull(juniorMemoryMemories.supersededById),
+    or(
+      isNull(juniorMemoryMemories.expiresAtMs),
+      gt(juniorMemoryMemories.expiresAtMs, args.nowMs),
+    ),
+  );
+  const [[counts], memoryDays] = await Promise.all([
+    args.db
+      .select({
+        active: sql<number>`count(*) filter (where ${active})`.mapWith(Number),
+        conversation:
+          sql<number>`count(*) filter (where ${active} and ${juniorMemoryMemories.scope} = 'conversation')`.mapWith(
+            Number,
+          ),
+        createdThirtyDays:
+          sql<number>`count(*) filter (where ${juniorMemoryMemories.createdAtMs} >= ${args.nowMs - 30 * DAY_MS})`.mapWith(
+            Number,
+          ),
+        embedded:
+          sql<number>`count(${juniorMemoryEmbeddings.memoryId}) filter (where ${active})`.mapWith(
+            Number,
+          ),
+        personal:
+          sql<number>`count(*) filter (where ${active} and ${juniorMemoryMemories.scope} = 'personal')`.mapWith(
+            Number,
+          ),
+      })
+      .from(juniorMemoryMemories)
+      .leftJoin(
+        juniorMemoryEmbeddings,
+        eq(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 · 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",
+      },
+    ],
+  };
+}

package/src/plugin.ts

@@ -13,6 +13,7 @@ import {
 } from "./tools";
 import { processMemorySession } from "./process-session";
 import { createMemoryPromptContributions } from "./recall";
+import { buildMemoryOperationalReport } from "./operational-report";
 import type { MemoryDb } from "./store";
 import { createMemoryUserPage } from "./user-pages";
 
@@ -111,6 +112,12 @@ export function memoryPlugin(options: MemoryPluginOptions = {}) {
     },
     userPages: [createMemoryUserPage()],
     hooks: {
+      async operationalReport(ctx) {
+        return await buildMemoryOperationalReport({
+          db: ctx.db as MemoryDb,
+          nowMs: ctx.nowMs,
+        });
+      },
       apiRoutes(ctx) {
         return createMemoryApi({
           actors: ctx.viewer.actors,

package/src/recall.ts

@@ -108,12 +108,7 @@ const memoryRecallContext = definePromptContext({
   renderPrompt: (content) => renderMemoryPrompt(content.memories),
 });
 
-/**
- * Build active memory recall contributions.
- *
- * Personal recall remains prompt-only so conversation reporting cannot widen
- * actor-scoped memory visibility.
- */
+/** Build active memory recall contributions. */
 export async function createMemoryPromptContributions(
   context: MemoryRecallContext,
 ): Promise<UserPromptContribution[] | undefined> {
@@ -162,8 +157,5 @@ export async function createMemoryPromptContributions(
   if (selected.length === 0) {
     return undefined;
   }
-  if (selected.some((memory) => memory.scope === "personal")) {
-    return [{ text: renderMemoryPrompt(selected) }];
-  }
   return [memoryRecallContext({ memories: selected })];
 }