nolo-cli 0.1.13 → 0.1.14

package/ai/memory/capture.ts

@@ -0,0 +1,148 @@
+import serverDb from "database/server/db";
+import { maybeConsolidateExplicitRemember } from "./consolidate";
+import { createMemoryItem, writeMemoryItemWithIndexesToDb } from "./store";
+import type { MemoryOwnerType, MemorySubjectType, MemoryVisibility } from "./types";
+
+const EXPLICIT_REMEMBER_PATTERNS = [
+  "记住",
+  "你要记住",
+  "请记住",
+  "以后记住",
+];
+
+export const shouldCaptureExplicitMemory = (userInput: string): boolean => {
+  const text = userInput.trim();
+  if (!text) return false;
+  return EXPLICIT_REMEMBER_PATTERNS.some((pattern) => {
+    const index = text.indexOf(pattern);
+    if (index < 0) return false;
+
+    const prefix = text.slice(0, index).trim();
+    const suffix = text.slice(index + pattern.length).trim();
+    if (!suffix) return false;
+    if (!prefix) return true;
+
+    return /^(这个|这件事|这一点|这点|请你|你)?$/u.test(prefix);
+  });
+};
+
+const buildExplicitMemoryTargets = (input: {
+  userId?: string | null;
+  spaceId?: string | null;
+}): Array<{
+  ownerType: MemoryOwnerType;
+  ownerId: string;
+  visibility: MemoryVisibility;
+  subjectType: MemorySubjectType;
+  subjectId: string;
+  importance: number;
+  confidence: number;
+  tags: string[];
+}> => {
+  if (input.userId) {
+    return [
+      {
+        ownerType: "user",
+        ownerId: input.userId,
+        visibility: "private",
+        subjectType: "user",
+        subjectId: input.userId,
+        importance: 0.95,
+        confidence: 0.95,
+        tags: ["explicit-memory"],
+      },
+    ];
+  }
+
+  if (input.spaceId) {
+    return [
+      {
+        ownerType: "space",
+        ownerId: input.spaceId,
+        visibility: "shared",
+        subjectType: "space",
+        subjectId: input.spaceId,
+        importance: 0.85,
+        confidence: 0.9,
+        tags: ["explicit-memory", "space-context"],
+      },
+    ];
+  }
+
+  return [];
+};
+
+export const captureExplicitMemoryEpisode = async (input: {
+  db?: any;
+  userId?: string | null;
+  spaceId?: string | null;
+  agentKey: string;
+  dialogId: string;
+  userInput: string;
+}): Promise<void> => {
+  if (!shouldCaptureExplicitMemory(input.userInput)) return;
+  const db = input.db ?? serverDb;
+  const targets = buildExplicitMemoryTargets(input);
+
+  for (const target of targets) {
+    const item = createMemoryItem({
+      ownerType: target.ownerType,
+      ownerId: target.ownerId,
+      visibility: target.visibility,
+      subjectType: target.subjectType,
+      subjectId: target.subjectId,
+      kind: "episodic",
+      content: input.userInput.trim(),
+      importance: target.importance,
+      confidence: target.confidence,
+      tags: target.tags,
+      patternKey: "explicit-remember",
+      sourceDialogId: input.dialogId,
+    });
+    await writeMemoryItemWithIndexesToDb(db, item);
+  }
+};
+
+export const consolidateExplicitMemoryAfterDialog = async (input: {
+  db?: any;
+  userId?: string | null;
+  spaceId?: string | null;
+  agentKey: string;
+  dialogId: string;
+  userInput: string;
+}): Promise<void> => {
+  if (!shouldCaptureExplicitMemory(input.userInput)) return;
+  const db = input.db ?? serverDb;
+  const targets = buildExplicitMemoryTargets(input);
+
+  for (const target of targets) {
+    await maybeConsolidateExplicitRemember({
+      db,
+      owner: { ownerType: target.ownerType, ownerId: target.ownerId },
+      subjectType: target.subjectType,
+      subjectId: target.subjectId,
+      visibility: target.visibility,
+      content: input.userInput.trim(),
+    });
+  }
+};
+
+export const scheduleExplicitMemoryConsolidation = (input: {
+  db?: any;
+  userId?: string | null;
+  spaceId?: string | null;
+  agentKey: string;
+  dialogId: string;
+  userInput: string;
+}): void => {
+  queueMicrotask(() => {
+    void consolidateExplicitMemoryAfterDialog(input).catch((error) => {
+      console.warn("[memory] explicit post-dialog consolidation failed", {
+        dialogId: input.dialogId,
+        userId: input.userId ?? null,
+        spaceId: input.spaceId ?? null,
+        error,
+      });
+    });
+  });
+};

package/ai/memory/consolidate.ts

@@ -0,0 +1,104 @@
+import serverDb from "database/server/db";
+import { loadMemoryCandidatesFromDb } from "./query";
+import { createMemoryItem, writeMemoryItemWithIndexesToDb } from "./store";
+import type { MemoryItem, MemoryOwnerRef, MemorySubjectType } from "./types";
+
+const EXPLICIT_REMEMBER_PREFIXES = [
+  "你要记住",
+  "请记住",
+  "以后记住",
+  "记住",
+];
+
+const normalizeExplicitRememberContent = (text: string): string => {
+  let normalized = text.trim();
+  for (const prefix of EXPLICIT_REMEMBER_PREFIXES) {
+    if (normalized.startsWith(prefix)) {
+      normalized = normalized.slice(prefix.length).trim();
+      break;
+    }
+  }
+
+  normalized = normalized
+    .replace(/^[，,。.\s:：]+/, "")
+    .replace(/[。！？!?]+$/g, "")
+    .trim();
+
+  return normalized;
+};
+
+const buildSemanticPatternKey = (normalizedContent: string): string =>
+  `semantic-explicit:${normalizedContent.toLowerCase()}`;
+
+const shouldKeepAsSemanticCandidate = (normalizedContent: string): boolean =>
+  normalizedContent.length >= 6;
+
+const findMatchingExplicitEpisodes = (
+  items: MemoryItem[],
+  normalizedContent: string,
+  subjectId: string
+): MemoryItem[] =>
+  items.filter((item) => {
+    if (item.kind !== "episodic") return false;
+    if (item.patternKey !== "explicit-remember") return false;
+    if (item.subjectId !== subjectId) return false;
+    return normalizeExplicitRememberContent(item.content) === normalizedContent;
+  });
+
+export const maybeConsolidateExplicitRemember = async (input: {
+  db?: any;
+  owner: MemoryOwnerRef;
+  subjectType: MemorySubjectType;
+  subjectId: string;
+  visibility: "private" | "shared" | "public";
+  content: string;
+}): Promise<void> => {
+  const normalizedContent = normalizeExplicitRememberContent(input.content);
+  if (!shouldKeepAsSemanticCandidate(normalizedContent)) return;
+
+  const db = input.db ?? serverDb;
+  const items = await loadMemoryCandidatesFromDb(db, {
+    owners: [input.owner],
+    subjects: [{ subjectType: input.subjectType, subjectId: input.subjectId }],
+    kinds: ["episodic", "semantic"],
+    ownerLimit: 50,
+  });
+
+  const matchingEpisodes = findMatchingExplicitEpisodes(
+    items,
+    normalizedContent,
+    input.subjectId
+  );
+  if (matchingEpisodes.length < 2) return;
+
+  const semanticPatternKey = buildSemanticPatternKey(normalizedContent);
+  const existingSemantic = items.find(
+    (item) =>
+      item.kind === "semantic" &&
+      item.subjectId === input.subjectId &&
+      item.patternKey === semanticPatternKey
+  );
+  if (existingSemantic) return;
+
+  const semantic = createMemoryItem({
+    ownerType: input.owner.ownerType,
+    ownerId: input.owner.ownerId,
+    visibility: input.visibility,
+    subjectType: input.subjectType,
+    subjectId: input.subjectId,
+    kind: "semantic",
+    content: normalizedContent,
+    importance: 0.92,
+    confidence: 0.72,
+    tags: ["explicit-memory", "consolidated"],
+    patternKey: semanticPatternKey,
+    sourceDialogId: matchingEpisodes[matchingEpisodes.length - 1]?.sourceDialogId,
+  });
+
+  await writeMemoryItemWithIndexesToDb(db, semantic);
+};
+
+export const __test__ = {
+  normalizeExplicitRememberContent,
+  buildSemanticPatternKey,
+};

package/ai/memory/delete.ts

@@ -0,0 +1,147 @@
+import serverDb from "database/server/db";
+import {
+  createMemoryKey,
+  createMemoryOwnerIndexKey,
+  createMemorySubjectKindIndexKey,
+  memoryOwnerRange,
+} from "database/keys";
+import type {
+  MemoryFacet,
+  MemoryItem,
+  MemoryKind,
+  MemoryOwnerRef,
+  MemorySubjectType,
+} from "./types";
+
+interface DeleteMemoryFilters {
+  ids?: string[];
+  kinds?: MemoryKind[];
+  facets?: MemoryFacet[];
+  subjectType?: MemorySubjectType;
+  subjectId?: string;
+  patternKeyPrefix?: string;
+  sourceDialogId?: string;
+  tags?: string[];
+  limit?: number;
+}
+
+export interface DeleteMemoryResult {
+  deletedCount: number;
+  deletedIds: string[];
+  matchedItems: MemoryItem[];
+}
+
+const normalizeSet = (values?: string[]): Set<string> | null => {
+  if (!Array.isArray(values) || values.length === 0) return null;
+  const normalized = values
+    .map((value) => value.trim())
+    .filter(Boolean);
+  return normalized.length > 0 ? new Set(normalized) : null;
+};
+
+const matchesFilters = (item: MemoryItem, filters: DeleteMemoryFilters): boolean => {
+  const idSet = normalizeSet(filters.ids);
+  if (idSet && !idSet.has(item.id)) return false;
+
+  const kindSet = normalizeSet(filters.kinds);
+  if (kindSet && !kindSet.has(item.kind)) return false;
+
+  const facetSet = normalizeSet(filters.facets);
+  if (facetSet && (!item.facet || !facetSet.has(item.facet))) return false;
+
+  if (filters.subjectType && item.subjectType !== filters.subjectType) return false;
+  if (filters.subjectId && item.subjectId !== filters.subjectId) return false;
+
+  const prefix = typeof filters.patternKeyPrefix === "string"
+    ? filters.patternKeyPrefix.trim()
+    : "";
+  if (prefix && !(item.patternKey ?? "").startsWith(prefix)) return false;
+
+  if (filters.sourceDialogId && item.sourceDialogId !== filters.sourceDialogId) {
+    return false;
+  }
+
+  const tagSet = normalizeSet(filters.tags);
+  if (tagSet) {
+    const itemTags = new Set((item.tags ?? []).map((tag) => tag.trim()).filter(Boolean));
+    for (const tag of tagSet) {
+      if (!itemTags.has(tag)) return false;
+    }
+  }
+
+  return true;
+};
+
+const deleteMemoryItemWithIndexesInBatch = (
+  batch: any,
+  item: MemoryItem
+) => {
+  batch.del(createMemoryKey(item.ownerType, item.ownerId, item.id));
+  batch.del(
+    createMemoryOwnerIndexKey(
+      item.ownerType,
+      item.ownerId,
+      item.createdAt,
+      item.id
+    )
+  );
+  batch.del(
+    createMemorySubjectKindIndexKey(
+      item.subjectType,
+      item.subjectId,
+      item.kind,
+      item.createdAt,
+      item.id
+    )
+  );
+};
+
+export const deleteMemoriesForOwnerFromDb = async (
+  db: any,
+  owner: MemoryOwnerRef,
+  filters: DeleteMemoryFilters = {}
+): Promise<DeleteMemoryResult> => {
+  const range = memoryOwnerRange(owner.ownerType, owner.ownerId);
+  const matchedItems: MemoryItem[] = [];
+  const limit = typeof filters.limit === "number" && filters.limit > 0
+    ? filters.limit
+    : Number.POSITIVE_INFINITY;
+
+  for await (const [, value] of db.iterator({
+    gte: range.start,
+    lte: range.end,
+    reverse: true,
+  })) {
+    const memoryId = typeof value?.memoryId === "string" ? value.memoryId : "";
+    if (!memoryId) continue;
+    const item = (await db
+      .get(createMemoryKey(owner.ownerType, owner.ownerId, memoryId))
+      .catch(() => null)) as MemoryItem | null;
+    if (!item) continue;
+    if (!matchesFilters(item, filters)) continue;
+    matchedItems.push(item);
+    if (matchedItems.length >= limit) break;
+  }
+
+  if (matchedItems.length === 0) {
+    return { deletedCount: 0, deletedIds: [], matchedItems: [] };
+  }
+
+  const batch = db.batch();
+  for (const item of matchedItems) {
+    deleteMemoryItemWithIndexesInBatch(batch, item);
+  }
+  await batch.write();
+
+  return {
+    deletedCount: matchedItems.length,
+    deletedIds: matchedItems.map((item) => item.id),
+    matchedItems,
+  };
+};
+
+export const deleteMemoriesForOwner = async (
+  owner: MemoryOwnerRef,
+  filters: DeleteMemoryFilters = {}
+): Promise<DeleteMemoryResult> =>
+  deleteMemoriesForOwnerFromDb(serverDb, owner, filters);

package/ai/memory/overlay.ts

@@ -0,0 +1,84 @@
+import type { MemoryItem } from "./types";
+
+const KIND_TITLES: Record<MemoryItem["kind"], string> = {
+  episodic: "Episodic",
+  semantic: "Semantic",
+  procedural: "Procedural",
+};
+
+const normalizeDisplayContent = (item: MemoryItem): string => {
+  const normalized = item.content
+    .trim()
+    .replace(/^(你要记住|请记住|以后记住|记住)[，,。.\s:：]*/u, "")
+    .replace(/[。！？!?]+$/u, "")
+    .trim();
+  const stripPrefix = (prefix: string) =>
+    normalized.startsWith(prefix) ? normalized.slice(prefix.length).trim() : normalized;
+
+  if (item.kind === "semantic") {
+    if (item.tags?.includes("understanding-memory")) {
+      switch (item.facet) {
+        case "unfinished":
+          return `用户仍未定下：${stripPrefix("还没决定")}`;
+        case "tension":
+          return `用户当前在权衡：${stripPrefix("在权衡")}`;
+        case "preference":
+          return `用户当前更在意：${stripPrefix("更在意")}`;
+        case "style":
+          return `用户互动偏好：${stripPrefix("更喜欢")}`;
+        case "goal":
+          return `用户当前目标：${stripPrefix("想推进")}`;
+      }
+    }
+    return `用户长期偏好/事实：${normalized}`;
+  }
+
+  if (item.kind === "episodic" && item.patternKey === "explicit-remember") {
+    return `用户明确要求你记住：${normalized}`;
+  }
+
+  if (item.kind === "episodic" && item.tags?.includes("understanding-memory")) {
+    switch (item.facet) {
+      case "unfinished":
+        return `最近一次对话显示：用户还没定下 ${stripPrefix("还没决定")}`;
+      case "tension":
+        return `最近一次对话显示：用户还在权衡 ${stripPrefix("在权衡")}`;
+      case "preference":
+        return `最近一次对话显示：用户更在意 ${stripPrefix("更在意")}`;
+      case "style":
+        return `最近一次对话显示：用户更偏好 ${stripPrefix("更喜欢")}`;
+      case "goal":
+        return `最近一次对话显示：用户想推进 ${stripPrefix("想推进")}`;
+    }
+  }
+
+  return normalized;
+};
+
+export const buildMemoryOverlay = (items: MemoryItem[]): string | null => {
+  if (items.length === 0) return null;
+
+  const byKind: Record<string, MemoryItem[]> = {
+    episodic: [],
+    semantic: [],
+    procedural: [],
+  };
+  for (const item of items) {
+    byKind[item.kind].push(item);
+  }
+
+  const sections = Object.entries(byKind)
+    .filter(([, list]) => list.length > 0)
+    .map(([kind, list]) => {
+      const lines = list.slice(0, 3).map((item) => `- ${normalizeDisplayContent(item)}`);
+      return [`[${KIND_TITLES[kind as MemoryItem["kind"]]}]`, ...lines].join("\n");
+    });
+
+  return [
+    "--- Memory Overlay ---",
+    "以下是当前请求可用的记忆事实；相关时直接基于这些记忆回答。",
+    "用户当前输入优先于记忆；记忆只辅助理解，不要求迎合。",
+    "",
+    ...sections,
+  ].join("\n");
+};

package/ai/memory/query.ts

@@ -0,0 +1,38 @@
+import serverDb from "database/server/db";
+import type {
+  MemoryItem,
+  MemoryKind,
+  MemoryOwnerRef,
+  MemorySubjectRef,
+} from "./types";
+import {
+  buildDefaultSubjects,
+  chooseMemoryOwners,
+  loadMemoryCandidatesFromDb,
+  loadOwnerItemsFromDb,
+  loadSubjectKindItemsFromDb,
+} from "./queryShared";
+
+export {
+  buildDefaultSubjects,
+  chooseMemoryOwners,
+  loadMemoryCandidatesFromDb,
+  loadOwnerItemsFromDb,
+  loadSubjectKindItemsFromDb,
+};
+
+export const loadOwnerItems = async (
+  owner: MemoryOwnerRef,
+  limit: number
+): Promise<MemoryItem[]> => {
+  return loadOwnerItemsFromDb(serverDb, owner, limit);
+};
+
+export const loadMemoryCandidates = async (input: {
+  owners: MemoryOwnerRef[];
+  subjects: MemorySubjectRef[];
+  kinds?: MemoryKind[];
+  ownerLimit?: number;
+}): Promise<MemoryItem[]> => {
+  return loadMemoryCandidatesFromDb(serverDb, input);
+};

package/ai/memory/queryShared.ts

@@ -0,0 +1,160 @@
+import {
+  createMemoryKey,
+  memoryOwnerRange,
+  memorySubjectKindRange,
+} from "database/keys";
+import type {
+  MemoryItem,
+  MemoryKind,
+  MemoryOwnerRef,
+  MemorySubjectRef,
+} from "./types";
+
+export const chooseMemoryOwners = (input: {
+  userId?: string | null;
+  spaceId?: string | null;
+}): MemoryOwnerRef[] => {
+  const owners: MemoryOwnerRef[] = [];
+  if (input.userId) {
+    owners.push({ ownerType: "user", ownerId: input.userId });
+  }
+  if (input.spaceId) {
+    owners.push({ ownerType: "space", ownerId: input.spaceId });
+  }
+  return owners;
+};
+
+export const loadOwnerItemsFromDb = async (
+  db: any,
+  owner: MemoryOwnerRef,
+  limit: number
+): Promise<MemoryItem[]> => {
+  const range = memoryOwnerRange(owner.ownerType, owner.ownerId);
+  const refs: Array<{ memoryId?: string }> = [];
+  for await (const [, value] of db.iterator({
+    gte: range.start,
+    lte: range.end,
+    reverse: true,
+  })) {
+    refs.push(value ?? {});
+    if (refs.length >= limit) break;
+  }
+
+  const items = await Promise.all(
+    refs.map((ref) =>
+      typeof ref?.memoryId === "string"
+        ? db
+            .get(createMemoryKey(owner.ownerType, owner.ownerId, ref.memoryId))
+            .catch(() => null)
+        : Promise.resolve(null)
+    )
+  );
+  return items.filter((item): item is MemoryItem => !!item);
+};
+
+export const loadSubjectKindItemsFromDb = async (
+  db: any,
+  subject: MemorySubjectRef,
+  kind: MemoryKind,
+  limit: number
+): Promise<MemoryItem[]> => {
+  const range = memorySubjectKindRange(subject.subjectType, subject.subjectId, kind);
+  const refs: Array<{ memoryKey?: string }> = [];
+  for await (const [, value] of db.iterator({
+    gte: range.start,
+    lte: range.end,
+    reverse: true,
+  })) {
+    refs.push(value ?? {});
+    if (refs.length >= limit) break;
+  }
+
+  const items = await Promise.all(
+    refs.map((ref) =>
+      typeof ref?.memoryKey === "string"
+        ? db.get(ref.memoryKey).catch(() => null)
+        : Promise.resolve(null)
+    )
+  );
+  return items.filter((item): item is MemoryItem => !!item);
+};
+
+export const loadMemoryCandidatesFromDb = async (
+  db: any,
+  input: {
+    owners: MemoryOwnerRef[];
+    subjects: MemorySubjectRef[];
+    kinds?: MemoryKind[];
+    ownerLimit?: number;
+  }
+): Promise<MemoryItem[]> => {
+  const kinds = input.kinds ?? ["episodic", "semantic", "procedural"];
+  const ownerLimit = input.ownerLimit ?? 12;
+  const ownerKeySet = new Set(
+    input.owners
+      .filter((owner) => owner.ownerId)
+      .map((owner) => `${owner.ownerType}:${owner.ownerId}`)
+  );
+  const subjects = input.subjects.filter(
+    (subject): subject is MemorySubjectRef => !!subject.subjectId
+  );
+
+  const subjectResults =
+    subjects.length > 0
+      ? await Promise.all(
+          subjects.flatMap((subject) =>
+            kinds.map((kind) =>
+              loadSubjectKindItemsFromDb(db, subject, kind, ownerLimit)
+            )
+          )
+        )
+      : [];
+  const subjectHitCount = subjectResults.reduce((sum, items) => sum + items.length, 0);
+  const usingOwnerFallback = subjects.length === 0 || subjectHitCount === 0;
+  const results = usingOwnerFallback
+    ? await Promise.all(
+        input.owners.map((owner) => loadOwnerItemsFromDb(db, owner, ownerLimit))
+      )
+    : subjectResults;
+
+  const seen = new Set<string>();
+  const merged: MemoryItem[] = [];
+  for (const items of results) {
+    for (const item of items) {
+      if (seen.has(item.id)) continue;
+      if (!kinds.includes(item.kind)) continue;
+      if (
+        ownerKeySet.size > 0 &&
+        !ownerKeySet.has(`${item.ownerType}:${item.ownerId}`)
+      ) {
+        continue;
+      }
+      if (
+        !usingOwnerFallback &&
+        subjects.length > 0 &&
+        !subjects.some(
+          (subject) =>
+            subject.subjectType === item.subjectType &&
+            subject.subjectId === item.subjectId
+        )
+      ) {
+        continue;
+      }
+      seen.add(item.id);
+      merged.push(item);
+    }
+  }
+
+  return merged;
+};
+
+export const buildDefaultSubjects = (input: {
+  userId?: string | null;
+  spaceId?: string | null;
+  agentKey: string;
+}): MemorySubjectRef[] =>
+  [
+    { subjectType: "agent", subjectId: input.agentKey },
+    input.userId ? { subjectType: "user", subjectId: input.userId } : null,
+    input.spaceId ? { subjectType: "space", subjectId: input.spaceId } : null,
+  ].filter((value): value is MemorySubjectRef => !!value);