nolo-cli 0.1.30 → 0.1.32

package/ai/memory/consolidate.ts

@@ -1,104 +0,0 @@
-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

@@ -1,147 +0,0 @@
-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

@@ -1,84 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,160 +0,0 @@
-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);

package/ai/memory/rank.ts

@@ -1,105 +0,0 @@
-import type { MemoryItem } from "./types";
-
-const CJK_SEQUENCE_REGEX = /[\u3400-\u4dbf\u4e00-\u9fff]+/g;
-const MEMORY_IDENTIFIER_REGEX = /\b(?:memory|noise)-[a-z0-9][a-z0-9-]*/gi;
-
-const buildCjkTokens = (text: string): string[] => {
-  const sequences = text.match(CJK_SEQUENCE_REGEX) ?? [];
-  const tokens: string[] = [];
-
-  for (const sequence of sequences) {
-    if (sequence.length >= 2) {
-      tokens.push(sequence);
-    }
-    for (let index = 0; index < sequence.length - 1; index += 1) {
-      tokens.push(sequence.slice(index, index + 2));
-    }
-  }
-
-  return tokens;
-};
-
-const tokenize = (text: string): string[] => {
-  const normalized = text.toLowerCase();
-  const wordTokens = normalized
-    .split(/[\s,.;:!?()[\]{}"'`，。！？：；、]+/)
-    .map((token) => token.trim())
-    .filter((token) => token.length >= 2);
-
-  return [...wordTokens, ...buildCjkTokens(normalized)];
-};
-
-const keywordScore = (query: string, item: MemoryItem): number => {
-  const queryTokens = new Set(tokenize(query));
-  if (queryTokens.size === 0) return 0;
-  const haystack = new Set([
-    ...tokenize(item.content),
-    ...(item.tags ?? []).map((tag) => tag.toLowerCase()),
-    item.patternKey?.toLowerCase() ?? "",
-  ]);
-  let matches = 0;
-  for (const token of queryTokens) {
-    if (haystack.has(token)) matches += 1;
-  }
-  return Math.min(1, matches / Math.max(2, queryTokens.size));
-};
-
-const identifierScore = (query: string, item: MemoryItem): number => {
-  const identifiers = query.match(MEMORY_IDENTIFIER_REGEX) ?? [];
-  if (identifiers.length === 0) return 0;
-  const content = item.content.toLowerCase();
-  const matches = identifiers.filter((identifier) =>
-    content.includes(identifier.toLowerCase())
-  ).length;
-  return matches / identifiers.length;
-};
-
-const activationScore = (item: MemoryItem, nowMs: number): number => {
-  const lastActivatedMs = Date.parse(item.lastActivatedAt || item.createdAt);
-  const ageDays = Math.max(0, (nowMs - lastActivatedMs) / 86_400_000);
-  const recency = 1 / (1 + ageDays / 7);
-  const reinforcement = Math.min(1, Math.log1p(item.activationCount ?? 0) / 3);
-  return 0.7 * recency + 0.3 * reinforcement;
-};
-
-const typeFitScore = (item: MemoryItem): number => {
-  if (item.kind === "episodic") return 0.75;
-  if (item.kind === "semantic") return 0.9;
-  return 0.85;
-};
-
-const understandingScore = (item: MemoryItem): number => {
-  if (!item.tags?.includes("understanding-memory")) return 0;
-  if (item.facet === "unfinished") return 1;
-  if (item.facet === "tension") return 0.95;
-  if (item.facet === "preference") return 0.85;
-  if (item.facet === "style") return 0.75;
-  return 0.8;
-};
-
-export const scoreMemoryItem = (item: MemoryItem, query: string, nowMs = Date.now()): number => {
-  const queryMatch = keywordScore(query, item);
-  const identifierMatch = identifierScore(query, item);
-  const activation = activationScore(item, nowMs);
-  const importance = item.importance ?? 0;
-  const confidence = item.confidence ?? 0;
-  const typeFit = typeFitScore(item);
-  const understanding = understandingScore(item);
-  return (
-    0.3 * queryMatch +
-    0.25 * identifierMatch +
-    0.15 * activation +
-    0.15 * importance +
-    0.1 * confidence +
-    0.03 * typeFit +
-    0.02 * understanding
-  );
-};
-
-export const rankMemoryCandidates = (
-  items: MemoryItem[],
-  query: string
-): MemoryItem[] =>
-  [...items].sort(
-    (a, b) => scoreMemoryItem(b, query) - scoreMemoryItem(a, query)
-  );