iris-chatbot 0.2.4

package/template/src/lib/memory.ts

@@ -0,0 +1,695 @@
+import { nanoid } from "nanoid";
+import { db } from "./db";
+import type {
+  MemoryContextPayload,
+  MemoryEntry,
+  MemoryKind,
+  MemoryMusicAlias,
+  MemoryScope,
+  MemorySettings,
+  MemorySource,
+} from "./types";
+
+const MAX_MEMORY_ENTRIES = 300;
+const MAX_MEMORY_CONTEXT_CHARS = 1800;
+const DAY_MS = 24 * 60 * 60 * 1000;
+
+type CapturedMemoryCandidate = {
+  kind: MemoryKind;
+  scope: MemoryScope;
+  conversationId?: string;
+  key: string;
+  value: string;
+  normalizedKey: string;
+  source: MemorySource;
+  confidence: number;
+};
+
+export function normalizeMemoryKey(input: string): string {
+  return input
+    .normalize("NFKD")
+    .replace(/[\u0300-\u036f]/g, "")
+    .toLowerCase()
+    .replace(/[^a-z0-9\s]/g, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function trimSentence(input: string): string {
+  return input
+    .trim()
+    .replace(/["'`]+$/g, "")
+    .replace(/^["'`]+/g, "")
+    .replace(/[.?!\s]+$/g, "")
+    .trim();
+}
+
+function detectScope(text: string): MemoryScope {
+  return /\b(for this chat|in this chat|for this thread)\b/i.test(text)
+    ? "conversation"
+    : "global";
+}
+
+function looksSensitive(text: string): boolean {
+  const patterns = [
+    /\b(?:password|passcode|pin)\b\s*(?:is|=|:)?\s*\S+/i,
+    /\b(?:api[_\s-]?key|access[_\s-]?token|secret|private key)\b\s*(?:is|=|:)?\s*\S+/i,
+    /\bsk-[a-zA-Z0-9]{12,}\b/,
+    /\b\d{3}-\d{2}-\d{4}\b/,
+    /\b(?:\d[ -]*?){13,19}\b/,
+    /\b[A-Za-z0-9+/_-]{24,}\.[A-Za-z0-9+/_-]{10,}\.[A-Za-z0-9+/_-]{10,}\b/,
+  ];
+  return patterns.some((pattern) => pattern.test(text));
+}
+
+function createCandidate(input: {
+  kind: MemoryKind;
+  scope: MemoryScope;
+  conversationId?: string;
+  key: string;
+  value: string;
+  source: MemorySource;
+  confidence: number;
+}): CapturedMemoryCandidate | null {
+  const key = trimSentence(input.key);
+  const value = trimSentence(input.value);
+  if (!key || !value) {
+    return null;
+  }
+  const normalizedKey = normalizeMemoryKey(key);
+  if (!normalizedKey) {
+    return null;
+  }
+  return {
+    kind: input.kind,
+    scope: input.scope,
+    conversationId: input.scope === "conversation" ? input.conversationId : undefined,
+    key,
+    value,
+    normalizedKey,
+    source: input.source,
+    confidence: input.confidence,
+  };
+}
+
+function parseMusicTarget(target: string): { query: string; title?: string; artist?: string } {
+  const trimmed = trimSentence(target);
+  const bySplit = trimmed.split(/\s+by\s+/i);
+  if (bySplit.length > 1) {
+    const title = trimSentence(bySplit[0] ?? "");
+    const artist = trimSentence(bySplit.slice(1).join(" by "));
+    return {
+      query: trimmed,
+      title: title || undefined,
+      artist: artist || undefined,
+    };
+  }
+  return { query: trimmed };
+}
+
+function parseStoredMusicAlias(entry: MemoryEntry): MemoryMusicAlias | null {
+  try {
+    const parsed = JSON.parse(entry.value) as {
+      query?: unknown;
+      title?: unknown;
+      artist?: unknown;
+    };
+    if (typeof parsed.query !== "string" || !parsed.query.trim()) {
+      return null;
+    }
+    return {
+      alias: entry.key,
+      query: parsed.query.trim(),
+      title: typeof parsed.title === "string" && parsed.title.trim() ? parsed.title.trim() : undefined,
+      artist: typeof parsed.artist === "string" && parsed.artist.trim() ? parsed.artist.trim() : undefined,
+    };
+  } catch {
+    const query = trimSentence(entry.value);
+    if (!query) {
+      return null;
+    }
+    return {
+      alias: entry.key,
+      query,
+    };
+  }
+}
+
+function extractExplicitCandidates(params: {
+  text: string;
+  scope: MemoryScope;
+  conversationId: string;
+}): CapturedMemoryCandidate[] {
+  const { text, scope, conversationId } = params;
+  const candidates: CapturedMemoryCandidate[] = [];
+
+  const aliasMeaningMatch = text.match(
+    /\bwhen\s+i\s+say\s+["']?(.+?)["']?\s+i\s+mean\s+["']?(.+?)["']?(?:[.?!]|$)/i,
+  );
+  if (aliasMeaningMatch?.[1] && aliasMeaningMatch?.[2]) {
+    const candidate = createCandidate({
+      kind: "person_alias",
+      scope,
+      conversationId,
+      key: aliasMeaningMatch[1],
+      value: aliasMeaningMatch[2],
+      source: "explicit",
+      confidence: 1,
+    });
+    if (candidate) {
+      candidates.push(candidate);
+    }
+  }
+
+  const aliasMessageMatch = text.match(
+    /\bwhen\s+i\s+say\s+["']?(.+?)["']?\s+(?:text|message)\s+["']?(.+?)["']?(?:[.?!]|$)/i,
+  );
+  if (aliasMessageMatch?.[1] && aliasMessageMatch?.[2]) {
+    const candidate = createCandidate({
+      kind: "person_alias",
+      scope,
+      conversationId,
+      key: aliasMessageMatch[1],
+      value: aliasMessageMatch[2],
+      source: "explicit",
+      confidence: 1,
+    });
+    if (candidate) {
+      candidates.push(candidate);
+    }
+  }
+
+  const aliasPlayMatch = text.match(
+    /\bwhen\s+i\s+say\s+["']?(.+?)["']?\s+play\s+["']?(.+?)["']?(?:[.?!]|$)/i,
+  );
+  if (aliasPlayMatch?.[1] && aliasPlayMatch?.[2]) {
+    const parsedTarget = parseMusicTarget(aliasPlayMatch[2]);
+    const candidate = createCandidate({
+      kind: "music_alias",
+      scope,
+      conversationId,
+      key: aliasPlayMatch[1],
+      value: JSON.stringify(parsedTarget),
+      source: "explicit",
+      confidence: 1,
+    });
+    if (candidate) {
+      candidates.push(candidate);
+    }
+  }
+
+  const rememberMatch = text.match(/\bremember(?:\s+that)?\s+(.+)$/i);
+  if (!rememberMatch?.[1]) {
+    return candidates;
+  }
+
+  const remembered = trimSentence(rememberMatch[1]);
+  if (!remembered) {
+    return candidates;
+  }
+
+  const nameMatch = remembered.match(/^my\s+name\s+is\s+(.+)$/i);
+  if (nameMatch?.[1]) {
+    const candidate = createCandidate({
+      kind: "profile",
+      scope,
+      conversationId,
+      key: "name",
+      value: nameMatch[1],
+      source: "explicit",
+      confidence: 1,
+    });
+    if (candidate) {
+      candidates.push(candidate);
+    }
+    return candidates;
+  }
+
+  const callMeMatch = remembered.match(/^call\s+me\s+(.+)$/i);
+  if (callMeMatch?.[1]) {
+    const candidate = createCandidate({
+      kind: "profile",
+      scope,
+      conversationId,
+      key: "name",
+      value: callMeMatch[1],
+      source: "explicit",
+      confidence: 1,
+    });
+    if (candidate) {
+      candidates.push(candidate);
+    }
+    return candidates;
+  }
+
+  if (/\b(i\s+prefer|default\s+to|always\s+use)\b/i.test(remembered)) {
+    const candidate = createCandidate({
+      kind: "preference",
+      scope,
+      conversationId,
+      key: remembered,
+      value: remembered,
+      source: "explicit",
+      confidence: 1,
+    });
+    if (candidate) {
+      candidates.push(candidate);
+    }
+    return candidates;
+  }
+
+  const noteCandidate = createCandidate({
+    kind: "note",
+    scope,
+    conversationId,
+    key: remembered.slice(0, 80),
+    value: remembered,
+    source: "explicit",
+    confidence: 1,
+  });
+  if (noteCandidate) {
+    candidates.push(noteCandidate);
+  }
+
+  return candidates;
+}
+
+function extractAutoCandidates(params: {
+  text: string;
+  scope: MemoryScope;
+  conversationId: string;
+}): CapturedMemoryCandidate[] {
+  const { text, scope, conversationId } = params;
+  const candidates: CapturedMemoryCandidate[] = [];
+
+  const nameMatch = text.match(/\bmy\s+name\s+is\s+([^.!?\n]+)(?:[.!?]|$)/i);
+  if (nameMatch?.[1]) {
+    const candidate = createCandidate({
+      kind: "profile",
+      scope,
+      conversationId,
+      key: "name",
+      value: nameMatch[1],
+      source: "auto",
+      confidence: 0.75,
+    });
+    if (candidate) {
+      candidates.push(candidate);
+    }
+  }
+
+  const callMeMatch = text.match(/\bcall\s+me\s+([^.!?\n]+)(?:[.!?]|$)/i);
+  if (callMeMatch?.[1]) {
+    const candidate = createCandidate({
+      kind: "profile",
+      scope,
+      conversationId,
+      key: "name",
+      value: callMeMatch[1],
+      source: "auto",
+      confidence: 0.75,
+    });
+    if (candidate) {
+      candidates.push(candidate);
+    }
+  }
+
+  const preferenceMatchers: Array<{ pattern: RegExp; prefix: string }> = [
+    { pattern: /\bi\s+prefer\s+([^.!?\n]+)(?:[.!?]|$)/i, prefix: "I prefer" },
+    { pattern: /\bdefault\s+to\s+([^.!?\n]+)(?:[.!?]|$)/i, prefix: "Default to" },
+    { pattern: /\balways\s+use\s+([^.!?\n]+)(?:[.!?]|$)/i, prefix: "Always use" },
+  ];
+
+  for (const matcher of preferenceMatchers) {
+    const match = text.match(matcher.pattern);
+    if (!match?.[1]) {
+      continue;
+    }
+    const value = `${matcher.prefix} ${trimSentence(match[1])}`;
+    const candidate = createCandidate({
+      kind: "preference",
+      scope,
+      conversationId,
+      key: trimSentence(match[1]),
+      value,
+      source: "auto",
+      confidence: 0.75,
+    });
+    if (candidate) {
+      candidates.push(candidate);
+    }
+  }
+
+  return candidates;
+}
+
+async function upsertMemoryCandidate(candidate: CapturedMemoryCandidate): Promise<void> {
+  const now = Date.now();
+  const existing = await db.memories
+    .where("normalizedKey")
+    .equals(candidate.normalizedKey)
+    .filter(
+      (entry) =>
+        entry.kind === candidate.kind &&
+        entry.scope === candidate.scope &&
+        (candidate.scope === "conversation"
+          ? entry.conversationId === candidate.conversationId
+          : !entry.conversationId),
+    )
+    .first();
+
+  if (!existing) {
+    await db.memories.add({
+      id: nanoid(),
+      ...candidate,
+      createdAt: now,
+      updatedAt: now,
+      lastUsedAt: now,
+    });
+    return;
+  }
+
+  const shouldReplaceValue = candidate.source !== "auto" || existing.source === "auto";
+  await db.memories.update(existing.id, {
+    ...(shouldReplaceValue
+      ? {
+          key: candidate.key,
+          value: candidate.value,
+          normalizedKey: candidate.normalizedKey,
+          source: candidate.source,
+          confidence: candidate.confidence,
+        }
+      : {}),
+    updatedAt: now,
+  });
+}
+
+async function enforceMemoryCap(): Promise<void> {
+  const total = await db.memories.count();
+  if (total <= MAX_MEMORY_ENTRIES) {
+    return;
+  }
+  const overflow = total - MAX_MEMORY_ENTRIES;
+  const oldest = await db.memories.orderBy("lastUsedAt").limit(overflow).toArray();
+  if (oldest.length === 0) {
+    return;
+  }
+  await db.memories.bulkDelete(oldest.map((entry) => entry.id));
+}
+
+function dedupeCandidates(candidates: CapturedMemoryCandidate[]): CapturedMemoryCandidate[] {
+  const byKey = new Map<string, CapturedMemoryCandidate>();
+  for (const candidate of candidates) {
+    const composite = [
+      candidate.kind,
+      candidate.scope,
+      candidate.conversationId ?? "",
+      candidate.normalizedKey,
+    ].join("::");
+    const existing = byKey.get(composite);
+    if (!existing) {
+      byKey.set(composite, candidate);
+      continue;
+    }
+    if (candidate.source === "explicit" || (candidate.source === "manual" && existing.source === "auto")) {
+      byKey.set(composite, candidate);
+    }
+  }
+  return [...byKey.values()];
+}
+
+export async function captureMemoriesFromUserTurn(params: {
+  text: string;
+  conversationId: string;
+  settingsMemory?: MemorySettings | null;
+}): Promise<void> {
+  const rawText = params.text?.trim();
+  if (!rawText) {
+    return;
+  }
+
+  const settings = params.settingsMemory;
+  if (settings?.enabled === false) {
+    return;
+  }
+  if (looksSensitive(rawText)) {
+    return;
+  }
+
+  const scope = detectScope(rawText);
+  const explicitCandidates = extractExplicitCandidates({
+    text: rawText,
+    scope,
+    conversationId: params.conversationId,
+  });
+  const autoCandidates = settings?.autoCapture === false
+    ? []
+    : extractAutoCandidates({
+        text: rawText,
+        scope,
+        conversationId: params.conversationId,
+      });
+
+  const candidates = dedupeCandidates([...explicitCandidates, ...autoCandidates]);
+  if (candidates.length === 0) {
+    return;
+  }
+
+  for (const candidate of candidates) {
+    await upsertMemoryCandidate(candidate);
+  }
+  await enforceMemoryCap();
+}
+
+function tokenize(input: string): string[] {
+  const normalized = normalizeMemoryKey(input);
+  if (!normalized) {
+    return [];
+  }
+  return normalized.split(" ").filter(Boolean);
+}
+
+function scoreMemoryEntry(entry: MemoryEntry, query: string): number {
+  const queryNormalized = normalizeMemoryKey(query);
+  const queryTokens = tokenize(query);
+  const keyTokens = tokenize(entry.key);
+  const valueTokens = tokenize(entry.value);
+
+  let score = 0;
+  if (queryNormalized) {
+    if (entry.normalizedKey === queryNormalized) {
+      score += 140;
+    }
+    if (
+      entry.normalizedKey.length >= 3 &&
+      queryNormalized.includes(entry.normalizedKey)
+    ) {
+      score += 80;
+    }
+    if (queryNormalized.length >= 3 && entry.normalizedKey.includes(queryNormalized)) {
+      score += 45;
+    }
+  }
+
+  if (queryTokens.length > 0) {
+    const tokenSet = new Set([...keyTokens, ...valueTokens]);
+    let overlap = 0;
+    for (const token of queryTokens) {
+      if (tokenSet.has(token)) {
+        overlap += 1;
+      }
+    }
+    score += overlap * 14;
+  }
+
+  if (entry.source === "manual") {
+    score += 32;
+  } else if (entry.source === "explicit") {
+    score += 26;
+  } else {
+    score += 10;
+  }
+
+  const ageDays = Math.max(0, Math.floor((Date.now() - entry.updatedAt) / DAY_MS));
+  score += Math.max(0, 20 - ageDays);
+  score += Math.round(Math.max(0, Math.min(1, entry.confidence)) * 15);
+
+  return score;
+}
+
+function selectMemoryEntries(candidates: MemoryEntry[], query: string): MemoryEntry[] {
+  const ranked = [...candidates]
+    .map((entry) => ({ entry, score: scoreMemoryEntry(entry, query) }))
+    .sort((left, right) => {
+      if (right.score !== left.score) {
+        return right.score - left.score;
+      }
+      return right.entry.updatedAt - left.entry.updatedAt;
+    })
+    .map((item) => item.entry);
+
+  const selected: MemoryEntry[] = [];
+  let profilePreferenceCount = 0;
+  let personAliasCount = 0;
+  let musicAliasCount = 0;
+  let noteCount = 0;
+
+  for (const entry of ranked) {
+    if ((entry.kind === "profile" || entry.kind === "preference") && profilePreferenceCount >= 3) {
+      continue;
+    }
+    if (entry.kind === "person_alias" && personAliasCount >= 3) {
+      continue;
+    }
+    if (entry.kind === "music_alias" && musicAliasCount >= 2) {
+      continue;
+    }
+    if (entry.kind === "note" && noteCount >= 2) {
+      continue;
+    }
+
+    selected.push(entry);
+
+    if (entry.kind === "profile" || entry.kind === "preference") {
+      profilePreferenceCount += 1;
+    } else if (entry.kind === "person_alias") {
+      personAliasCount += 1;
+    } else if (entry.kind === "music_alias") {
+      musicAliasCount += 1;
+    } else if (entry.kind === "note") {
+      noteCount += 1;
+    }
+  }
+
+  return selected;
+}
+
+function buildSystemMessage(entries: MemoryEntry[]): string | null {
+  if (entries.length === 0) {
+    return null;
+  }
+
+  const profiles = entries.filter((entry) => entry.kind === "profile" || entry.kind === "preference");
+  const people = entries.filter((entry) => entry.kind === "person_alias");
+  const music = entries.filter((entry) => entry.kind === "music_alias");
+  const notes = entries.filter((entry) => entry.kind === "note");
+
+  const lines: string[] = [
+    "On-device memory context (local user profile and aliases):",
+    "Use this as helpful context. If memory conflicts with the current request, ask a concise clarification.",
+  ];
+
+  if (profiles.length > 0) {
+    lines.push("", "### Profile & Preferences");
+    for (const entry of profiles) {
+      lines.push(`- **${entry.key}:** ${entry.value}`);
+    }
+  }
+
+  if (people.length > 0) {
+    lines.push("", "### Person Aliases");
+    for (const entry of people) {
+      lines.push(`- \"${entry.key}\" refers to ${entry.value}`);
+    }
+  }
+
+  if (music.length > 0) {
+    lines.push("", "### Music Aliases");
+    for (const entry of music) {
+      const parsed = parseStoredMusicAlias(entry);
+      if (!parsed) {
+        continue;
+      }
+      const suffix = parsed.artist ? ` by ${parsed.artist}` : "";
+      lines.push(`- \"${parsed.alias}\" means play ${parsed.query}${suffix}`);
+    }
+  }
+
+  if (notes.length > 0) {
+    lines.push("", "### Notes");
+    for (const entry of notes) {
+      lines.push(`- ${entry.value}`);
+    }
+  }
+
+  let message = "";
+  for (const line of lines) {
+    const next = message ? `${message}\n${line}` : line;
+    if (next.length > MAX_MEMORY_CONTEXT_CHARS) {
+      break;
+    }
+    message = next;
+  }
+
+  return message || null;
+}
+
+function buildAliasPayload(entries: MemoryEntry[], toolInfluence: boolean): MemoryContextPayload["aliases"] {
+  if (!toolInfluence) {
+    return { people: [], music: [] };
+  }
+
+  const people = entries
+    .filter((entry) => entry.kind === "person_alias")
+    .map((entry) => ({ alias: entry.key, target: entry.value }));
+
+  const music: MemoryMusicAlias[] = [];
+  for (const entry of entries) {
+    if (entry.kind !== "music_alias") {
+      continue;
+    }
+    const parsed = parseStoredMusicAlias(entry);
+    if (!parsed) {
+      continue;
+    }
+    music.push(parsed);
+  }
+
+  return { people, music };
+}
+
+export async function buildMemoryContextForPrompt(params: {
+  query: string;
+  conversationId: string;
+  enabled: boolean;
+  toolInfluence?: boolean;
+}): Promise<{
+  systemMessage: string | null;
+  payload: MemoryContextPayload;
+  usedEntryIds: string[];
+}> {
+  if (!params.enabled) {
+    return {
+      systemMessage: null,
+      payload: {
+        enabled: false,
+        aliases: { people: [], music: [] },
+      },
+      usedEntryIds: [],
+    };
+  }
+
+  const allMemories = await db.memories.toArray();
+  const inScope = allMemories.filter(
+    (entry) => entry.scope === "global" || entry.conversationId === params.conversationId,
+  );
+  const selected = selectMemoryEntries(inScope, params.query);
+  const aliases = buildAliasPayload(selected, params.toolInfluence !== false);
+
+  return {
+    systemMessage: buildSystemMessage(selected),
+    payload: {
+      enabled: true,
+      aliases,
+    },
+    usedEntryIds: selected.map((entry) => entry.id),
+  };
+}
+
+export async function markMemoriesUsed(ids: string[]): Promise<void> {
+  if (!Array.isArray(ids) || ids.length === 0) {
+    return;
+  }
+  const now = Date.now();
+  await Promise.all(ids.map((id) => db.memories.update(id, { lastUsedAt: now })));
+}