@agentmemory/agentmemory 0.7.0

package/src/functions/enrich.ts

@@ -0,0 +1,132 @@
+import type { ISdk } from "iii-sdk";
+import { getContext } from "iii-sdk";
+import type { Memory } from "../types.js";
+import { KV } from "../state/schema.js";
+import { StateKV } from "../state/kv.js";
+
+const MAX_CONTEXT_LENGTH = 4000;
+
+function escapeXml(s: string): string {
+  return s
+    .replace(/&/g, "&")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&apos;");
+}
+
+export function registerEnrichFunction(sdk: ISdk, kv: StateKV): void {
+  sdk.registerFunction(
+    {
+      id: "mem::enrich",
+      description:
+        "Aggregate file context, relevant observations, and bug memories for pre-tool enrichment",
+    },
+    async (data: {
+      sessionId: string;
+      files: string[];
+      terms?: string[];
+      toolName?: string;
+    }) => {
+      const ctx = getContext();
+      const parts: string[] = [];
+
+      const fileContextPromise = sdk
+        .trigger<{ sessionId: string; files: string[] }, { context: string }>(
+          "mem::file-context",
+          {
+            sessionId: data.sessionId,
+            files: data.files,
+          },
+        )
+        .catch(() => ({ context: "" }));
+
+      const searchQueries: string[] = [
+        ...data.files.map((f) => f.split("/").pop() || f),
+        ...(data.terms || []),
+      ].filter((q) => q.length > 0);
+
+      const searchPromise =
+        searchQueries.length > 0
+          ? sdk
+              .trigger<
+                { query: string; limit: number },
+                { results: Array<{ observation: { narrative: string } }> }
+              >("mem::search", {
+                query: searchQueries.join(" "),
+                limit: 5,
+              })
+              .catch(() => ({ results: [] }))
+          : Promise.resolve({ results: [] });
+
+      const bugMemoriesPromise = kv
+        .list<Memory>(KV.memories)
+        .then((memories) =>
+          memories
+            .filter(
+              (m) =>
+                m.type === "bug" &&
+                m.isLatest &&
+                m.files.some((f) =>
+                  data.files.some((df) => f.includes(df) || df.includes(f)),
+                ),
+            )
+            .sort(
+              (a, b) =>
+                new Date(b.updatedAt || b.createdAt).getTime() -
+                new Date(a.updatedAt || a.createdAt).getTime(),
+            ),
+        )
+        .catch(() => []);
+
+      const [fileContext, searchResult, bugMemories] = await Promise.all([
+        fileContextPromise,
+        searchPromise,
+        bugMemoriesPromise,
+      ]);
+
+      if (fileContext.context) {
+        parts.push(fileContext.context);
+      }
+
+      if (searchResult.results.length > 0) {
+        const observations = searchResult.results
+          .map((r) => r.observation?.narrative)
+          .filter(Boolean)
+          .map((n) => escapeXml(n as string))
+          .join("\n");
+        if (observations) {
+          parts.push(
+            `<agentmemory-relevant-context>\n${observations}\n</agentmemory-relevant-context>`,
+          );
+        }
+      }
+
+      if (bugMemories.length > 0) {
+        const bugs = bugMemories
+          .slice(0, 3)
+          .map((m) => `- ${escapeXml(m.title)}: ${escapeXml(m.content)}`)
+          .join("\n");
+        parts.push(
+          `<agentmemory-past-errors>\n${bugs}\n</agentmemory-past-errors>`,
+        );
+      }
+
+      let context = parts.join("\n\n");
+      let truncated = false;
+      if (context.length > MAX_CONTEXT_LENGTH) {
+        context = context.slice(0, MAX_CONTEXT_LENGTH);
+        truncated = true;
+      }
+
+      ctx.logger.info("Enrichment completed", {
+        sessionId: data.sessionId,
+        fileCount: data.files.length,
+        contextLength: context.length,
+        truncated,
+      });
+
+      return { context, truncated };
+    },
+  );
+}

package/src/functions/evict.ts

@@ -0,0 +1,163 @@
+import type { ISdk } from "iii-sdk";
+import { getContext } from "iii-sdk";
+import type {
+  Session,
+  CompressedObservation,
+  SessionSummary,
+  Memory,
+} from "../types.js";
+import { KV } from "../state/schema.js";
+import { StateKV } from "../state/kv.js";
+
+interface EvictionConfig {
+  staleSessionDays: number;
+  lowImportanceMaxDays: number;
+  lowImportanceThreshold: number;
+  maxObservationsPerProject: number;
+}
+
+const MS_PER_DAY = 24 * 60 * 60 * 1000;
+
+const DEFAULTS: EvictionConfig = {
+  staleSessionDays: 30,
+  lowImportanceMaxDays: 90,
+  lowImportanceThreshold: 3,
+  maxObservationsPerProject: 10_000,
+};
+
+interface EvictionStats {
+  staleSessions: number;
+  lowImportanceObs: number;
+  capEvictions: number;
+  expiredMemories: number;
+  nonLatestMemories: number;
+  dryRun: boolean;
+}
+
+export function registerEvictFunction(sdk: ISdk, kv: StateKV): void {
+  sdk.registerFunction(
+    {
+      id: "mem::evict",
+      description: "Evict stale memories based on age and importance",
+    },
+    async (data: { dryRun?: boolean }): Promise<EvictionStats> => {
+      const ctx = getContext();
+      const dryRun = data?.dryRun ?? false;
+
+      const configOverride = await kv
+        .get<Partial<EvictionConfig>>(KV.config, "eviction")
+        .catch(() => null);
+      const cfg = { ...DEFAULTS, ...configOverride };
+
+      const now = Date.now();
+      const stats: EvictionStats = {
+        staleSessions: 0,
+        lowImportanceObs: 0,
+        capEvictions: 0,
+        expiredMemories: 0,
+        nonLatestMemories: 0,
+        dryRun,
+      };
+
+      const sessions = await kv.list<Session>(KV.sessions).catch(() => []);
+      const summaries = await kv
+        .list<SessionSummary>(KV.summaries)
+        .catch(() => []);
+      const summaryIds = new Set(summaries.map((s) => s.sessionId));
+
+      for (const session of sessions) {
+        if (!session.startedAt) continue;
+        const age = now - new Date(session.startedAt).getTime();
+        const staleDays = cfg.staleSessionDays * MS_PER_DAY;
+        if (age > staleDays && !summaryIds.has(session.id)) {
+          stats.staleSessions++;
+          if (!dryRun) {
+            await kv.delete(KV.sessions, session.id).catch(() => {});
+          }
+        }
+      }
+
+      const projectObs = new Map<string, CompressedObservation[]>();
+      for (const session of sessions) {
+        const obs = await kv
+          .list<CompressedObservation>(KV.observations(session.id))
+          .catch(() => []);
+        const compressed = obs.filter((o) => o.title);
+
+        for (const o of compressed) {
+          if (!o.timestamp) continue;
+          const age = now - new Date(o.timestamp).getTime();
+          const maxAge = cfg.lowImportanceMaxDays * MS_PER_DAY;
+          if (
+            age > maxAge &&
+            (o.importance ?? 5) < cfg.lowImportanceThreshold
+          ) {
+            stats.lowImportanceObs++;
+            if (!dryRun) {
+              await kv
+                .delete(KV.observations(session.id), o.id)
+                .catch(() => {});
+            }
+          }
+        }
+
+        const project = session.project || "unknown";
+        const existing = projectObs.get(project) || [];
+        existing.push(...compressed);
+        projectObs.set(project, existing);
+      }
+
+      for (const [, obs] of projectObs) {
+        if (obs.length > cfg.maxObservationsPerProject) {
+          const sorted = obs.sort(
+            (a, b) => (a.importance ?? 5) - (b.importance ?? 5),
+          );
+          const toEvict = sorted.slice(
+            0,
+            obs.length - cfg.maxObservationsPerProject,
+          );
+          stats.capEvictions += toEvict.length;
+          if (!dryRun) {
+            for (const o of toEvict) {
+              await kv
+                .delete(KV.observations(o.sessionId), o.id)
+                .catch(() => {});
+            }
+          }
+        }
+      }
+
+      const memories = await kv.list<Memory>(KV.memories).catch(() => []);
+      const evictedMemIds = new Set<string>();
+      for (const mem of memories) {
+        if (mem.forgetAfter) {
+          const expiry = new Date(mem.forgetAfter).getTime();
+          if (now > expiry) {
+            stats.expiredMemories++;
+            evictedMemIds.add(mem.id);
+            if (!dryRun) {
+              await kv.delete(KV.memories, mem.id).catch(() => {});
+            }
+          }
+        }
+
+        if (
+          !evictedMemIds.has(mem.id) &&
+          mem.isLatest === false &&
+          mem.createdAt
+        ) {
+          const age = now - new Date(mem.createdAt).getTime();
+          if (age > cfg.lowImportanceMaxDays * MS_PER_DAY) {
+            stats.nonLatestMemories++;
+            if (!dryRun) {
+              await kv.delete(KV.memories, mem.id).catch(() => {});
+            }
+          }
+        }
+      }
+
+      ctx.logger.info("Eviction complete", { stats });
+      return stats;
+    },
+  );
+}