@betterdb/memory 0.2.0 → 0.4.1

package/src/memory/retrieval.ts

@@ -1,75 +1,9 @@
-import { config } from "../config.js";
-import type { ModelClient } from "../client/model.js";
-import type { ValkeyClient } from "../client/valkey.js";
 import type { EpisodicMemory } from "./schema.js";
-import { AgingPipeline } from "./aging.js";
+import type { RecallResult } from "./recall.js";
 
-// --- Memory Retriever ---
-
-export class MemoryRetriever {
-  private valkeyClient: ValkeyClient;
-  private modelClient: ModelClient;
-  private agingPipeline: AgingPipeline;
-
-  constructor(valkeyClient: ValkeyClient, modelClient: ModelClient) {
-    this.valkeyClient = valkeyClient;
-    this.modelClient = modelClient;
-    this.agingPipeline = new AgingPipeline(valkeyClient, modelClient);
-  }
-
-  async retrieve(
-    queryContext: string,
-    project: string,
-  ): Promise<EpisodicMemory[]> {
-    await this.maybeRunAging(project);
-
-    const embedding = await this.modelClient.embed(queryContext);
-
-    const topK = config.memory.maxContextMemories * 2;
-    const candidates = await this.valkeyClient.searchMemories(
-      embedding,
-      project,
-      topK,
-    );
-
-    const now = Date.now();
-    const scored = candidates
-      .filter((m) => m.importanceScore >= 0.1)
-      .map((m) => {
-        const daysSince =
-          (now - new Date(m.lastAccessed).getTime()) / (1000 * 60 * 60 * 24);
-        const recencyFactor = Math.pow(
-          config.memory.decayRate,
-          Math.max(daysSince, 0),
-        );
-        return {
-          memory: m,
-          score: m.importanceScore * recencyFactor,
-        };
-      })
-      .sort((a, b) => b.score - a.score)
-      .slice(0, config.memory.maxContextMemories);
-
-    // Fire-and-forget access increments
-    for (const { memory } of scored) {
-      this.valkeyClient.incrementAccess(memory.memoryId).catch(() => {});
-    }
-
-    return scored.map((s) => s.memory);
-  }
-
-  async maybeRunAging(project: string): Promise<void> {
-    const lastRun = await this.valkeyClient.getLastAgingRun();
-    const hoursAgo = lastRun
-      ? (Date.now() - lastRun.getTime()) / (1000 * 60 * 60)
-      : Infinity;
-
-    if (hoursAgo >= config.memory.agingIntervalHours) {
-      await this.agingPipeline.runDecay(project);
-      await this.valkeyClient.setLastAgingRun(new Date());
-    }
-  }
-}
+// Recall (KNN + composite recency/importance scoring + access reinforcement)
+// now lives in @betterdb/agent-memory's MemoryStore, reached via
+// PluginMemoryStore.recall. This module keeps only the formatters.
 
 // --- Format for Injection ---
 
@@ -89,6 +23,9 @@ export function formatForInjection(memories: EpisodicMemory[]): string {
     for (const d of m.summary.decisions) {
       sections.push(`  - Decision: ${d}`);
     }
+    for (const pat of m.summary.patterns) {
+      sections.push(`  - Pattern: ${pat}`);
+    }
     for (const p of m.summary.problemsSolved) {
       sections.push(`  - Solved: ${p.problem} → ${p.resolution}`);
     }
@@ -112,3 +49,69 @@ export function formatForInjection(memories: EpisodicMemory[]): string {
 
   return sections.join("\n");
 }
+
+// --- Format search_context result (reader contract) ---
+
+function detailLines(m: EpisodicMemory): string[] {
+  const lines: string[] = [];
+  for (const d of m.summary.decisions) lines.push(`    - Decision: ${d}`);
+  for (const pat of m.summary.patterns) lines.push(`    - Pattern: ${pat}`);
+  for (const p of m.summary.problemsSolved) {
+    lines.push(`    - Solved: ${p.problem} → ${p.resolution}`);
+  }
+  for (const t of m.summary.openThreads) lines.push(`    - Open: ${t}`);
+  return lines;
+}
+
+/**
+ * Format an escalating-recall result for the search_context tool. The output
+ * is self-instructing: on a miss it tells the model to be honest and not
+ * fabricate (mirroring the LongMemEval reader prompt); on a hit it tells the
+ * model to answer only from the excerpts. `topK` caps how many hits are shown.
+ */
+export function formatSearchResult(
+  query: string,
+  result: RecallResult,
+  topK: number,
+): string {
+  if (result.hits.length === 0) {
+    const searched =
+      result.scope === "all"
+        ? "this project AND all other projects"
+        : "this project";
+    // Cross-project was asked for but is disabled by config — don't offer a
+    // scope="all" retry the config would also refuse; say so plainly instead.
+    const offer = result.crossProjectBlocked
+      ? ` Cross-project search is disabled by configuration (BETTERDB_ALLOW_CROSS_PROJECT=false), so widening is not available.`
+      : result.scope === "project"
+        ? ` You may offer to search across ALL projects — call search_context again with scope="all".`
+        : "";
+    return [
+      `# Memory search: "${query}"`,
+      `Searched: ${searched}.`,
+      `NO memories cleared the relevance threshold.`,
+      `Tell the user you found nothing in memory about this. Do NOT fabricate an ` +
+        `answer, and do NOT substitute a codebase search as if it were recall.${offer}`,
+    ].join("\n");
+  }
+
+  const shown = result.hits.slice(0, topK);
+  const lines: string[] = [
+    `# Memory search: "${query}"`,
+    `Scope: ${result.scope} · confidence: ${result.confidence} · ${shown.length} match(es)`,
+    ``,
+  ];
+  shown.forEach((h, i) => {
+    const date = h.memory.timestamp.split("T")[0];
+    lines.push(
+      `[${i + 1}] (rel ${h.relevance.toFixed(2)}, ${date}) ${h.memory.summary.oneLineSummary}`,
+    );
+    lines.push(...detailLines(h.memory));
+  });
+  lines.push(``);
+  lines.push(
+    `Answer the user ONLY from these excerpts. If they do not contain the answer, ` +
+      `say so plainly — do not invent.`,
+  );
+  return lines.join("\n");
+}