nolo-cli 0.1.13 → 0.1.15

package/ai/memory/rank.ts

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

package/ai/memory/recentRelationshipRecap.ts

@@ -0,0 +1,247 @@
+import { createDialogKey, dialogMessageRange } from "database/keys";
+import { extractCustomId } from "core/prefix";
+
+interface RecentDialogLike {
+  dbKey?: string;
+  cybots?: string[];
+  summary?: string;
+  title?: string;
+  updatedAt?: string;
+  createdAt?: string;
+  spaceId?: string;
+  inheritedFromDialogKey?: string;
+}
+
+interface DialogMessageLike {
+  role?: string;
+  authorRole?: string;
+  content?: unknown;
+}
+
+const MIN_RECAP_LENGTH = 12;
+const MIN_RECAP_GAP_MS = 30 * 60 * 1000;
+
+export interface RecentRelationshipRecapResolution {
+  recap: string | null;
+  reason:
+    | "no-db"
+    | "missing-input"
+    | "no-match"
+    | "too-recent"
+    | "low-quality"
+    | "selected";
+  sourceDialogKey?: string;
+  sourceUpdatedAt?: string;
+}
+
+export const shouldUseRecentRelationshipRecap = (input: {
+  userId?: string | null;
+  agentKey?: string | null;
+  cybotsCount?: number;
+  inheritFromDialogKey?: string | null;
+  skipGreeting?: boolean;
+  triggerType?: "user" | "api" | "localhost" | "scheduled_run";
+}): boolean => {
+  if (!input.userId || !input.agentKey) return false;
+  if ((input.cybotsCount ?? 0) !== 1) return false;
+  if (input.inheritFromDialogKey) return false;
+  if (input.skipGreeting) return false;
+  if (input.triggerType && input.triggerType !== "user") return false;
+  return true;
+};
+
+const CONTINUATION_CUE_PATTERNS = [
+  "还没",
+  "还在",
+  "继续",
+  "接着",
+  "下一步",
+  "后面",
+  "之后",
+  "打算",
+  "准备",
+  "想",
+  "纠结",
+  "卡住",
+  "没想好",
+  "不确定",
+  "如何",
+  "怎么",
+  "?",
+  "？",
+];
+
+const clip = (text: string, max = 140): string =>
+  text.length <= max ? text : `${text.slice(0, max - 1).trimEnd()}…`;
+
+const normalizeText = (value: unknown): string =>
+  typeof value === "string" ? value.trim() : "";
+
+const contentToText = (content: unknown): string => {
+  if (typeof content === "string") return content.trim();
+  if (Array.isArray(content)) {
+    return content
+      .map((part) =>
+        part && typeof part === "object" && "text" in part
+          ? normalizeText((part as { text?: unknown }).text)
+          : ""
+      )
+      .filter(Boolean)
+      .join("\n")
+      .trim();
+  }
+  return "";
+};
+
+const toTimestamp = (record: RecentDialogLike): number => {
+  const updated = Date.parse(normalizeText(record.updatedAt));
+  if (Number.isFinite(updated) && updated > 0) return updated;
+  const created = Date.parse(normalizeText(record.createdAt));
+  if (Number.isFinite(created) && created > 0) return created;
+  return 0;
+};
+
+const chooseRecapText = (record: RecentDialogLike): string => {
+  const summary = normalizeText(record.summary);
+  if (isMeaningfulRecapText(summary)) return clip(summary, 160);
+  const title = normalizeText(record.title);
+  if (isMeaningfulRecapText(title)) return clip(title, 80);
+  return "";
+};
+
+const loadLastAssistantMessageText = async (
+  db: any,
+  dialogKey: string
+): Promise<string> => {
+  const dialogId = extractCustomId(dialogKey);
+  if (!dialogId) return "";
+  const range = dialogMessageRange(dialogId);
+  let iterator = db.iterator({
+    gte: range.start,
+    lte: range.end,
+    reverse: true,
+  });
+
+  if (iterator && typeof iterator.then === "function") {
+    iterator = await iterator;
+  }
+
+  for await (const [, value] of iterator) {
+    const message = (value ?? {}) as DialogMessageLike;
+    const role = normalizeText(message.role ?? message.authorRole);
+    if (role !== "assistant") continue;
+    const text = contentToText(message.content);
+    if (isMeaningfulRecapText(text)) return clip(text, 160);
+  }
+
+  return "";
+};
+
+const isLikelyTimestampTitle = (text: string): boolean =>
+  /^\d{1,2}-\d{1,2}\s+\d{1,2}:\d{2}$/.test(text);
+
+const isMeaningfulRecapText = (text: string): boolean => {
+  const normalized = normalizeText(text);
+  if (!normalized) return false;
+  if (normalized.length < MIN_RECAP_LENGTH) return false;
+  if (isLikelyTimestampTitle(normalized)) return false;
+  if (/^(继续|新对话|测试|test|hello|hi)$/i.test(normalized)) return false;
+  return true;
+};
+
+export const resolveRecentRelationshipRecap = async (input: {
+  db: any;
+  userId: string;
+  agentKey: string;
+  currentSpaceId?: string;
+  limit?: number;
+}): Promise<RecentRelationshipRecapResolution> => {
+  const { db, userId, agentKey, currentSpaceId, limit = 40 } = input;
+  if (!db) return { recap: null, reason: "no-db" };
+  if (!userId || !agentKey) return { recap: null, reason: "missing-input" };
+
+  const range = createDialogKey.rangeOfUser(userId);
+  const matches: RecentDialogLike[] = [];
+  let scanned = 0;
+
+  let iterator = db.iterator({
+    gte: range.start,
+    lte: range.end,
+    reverse: true,
+  });
+
+  if (iterator && typeof iterator.then === "function") {
+    iterator = await iterator;
+  }
+
+  for await (const [, value] of iterator) {
+    scanned += 1;
+    const record = (value ?? {}) as RecentDialogLike;
+    if (!Array.isArray(record.cybots) || !record.cybots.includes(agentKey)) {
+      if (scanned >= limit && matches.length > 0) break;
+      continue;
+    }
+    matches.push(record);
+    if (matches.length >= limit) break;
+  }
+
+  if (matches.length === 0) return { recap: null, reason: "no-match" };
+
+  const sorted = [...matches].sort((a, b) => {
+    const aSameSpace = currentSpaceId && a.spaceId === currentSpaceId ? 1 : 0;
+    const bSameSpace = currentSpaceId && b.spaceId === currentSpaceId ? 1 : 0;
+    if (aSameSpace !== bSameSpace) return bSameSpace - aSameSpace;
+    return toTimestamp(b) - toTimestamp(a);
+  });
+
+  let sawTooRecent = false;
+  let sawLowQuality = false;
+  for (const record of sorted) {
+    const ts = toTimestamp(record);
+    if (ts > 0 && Date.now() - ts < MIN_RECAP_GAP_MS) {
+      sawTooRecent = true;
+      continue;
+    }
+    let recap = chooseRecapText(record);
+    if (!recap) {
+      const dialogKey = normalizeText(record.dbKey);
+      if (dialogKey) {
+        recap = await loadLastAssistantMessageText(db, dialogKey);
+      }
+    }
+    if (recap) {
+      return {
+        recap,
+        reason: "selected",
+        sourceDialogKey: normalizeText(record.dbKey) || undefined,
+        sourceUpdatedAt: normalizeText(record.updatedAt) || undefined,
+      };
+    }
+    sawLowQuality = true;
+  }
+
+  if (sawTooRecent) return { recap: null, reason: "too-recent" };
+  if (sawLowQuality) return { recap: null, reason: "low-quality" };
+  return { recap: null, reason: "no-match" };
+};
+
+export const mergeGreetingWithRelationshipRecap = (input: {
+  greetingText?: string;
+  recentRecap?: string | null;
+}): string | null => {
+  const greetingText = normalizeText(input.greetingText);
+  const recentRecap = normalizeText(input.recentRecap);
+
+  if (!greetingText && !recentRecap) return null;
+  if (!recentRecap) return greetingText || null;
+  const continuationLike = CONTINUATION_CUE_PATTERNS.some((pattern) =>
+    recentRecap.includes(pattern)
+  );
+  if (!continuationLike) return greetingText || null;
+
+  if (!greetingText) {
+    return `我记得你上次在聊：${recentRecap}\n\n如果你还想接着那个点继续，我们可以从那里往下走；如果想换个方向也可以。`;
+  }
+
+  return `${greetingText}\n\n我记得你上次在聊：${recentRecap}\n如果你还想接着那个点继续，我们可以从那里往下走；如果想换个方向也可以。`;
+};

package/ai/memory/remember.ts

@@ -0,0 +1,167 @@
+import serverDb from "database/server/db";
+import { createMemoryItem, writeMemoryItemWithIndexesToDb } from "./store";
+import type { MemoryKind, MemoryOwnerType, MemorySubjectType, MemoryVisibility } from "./types";
+
+export type RememberMemoryScope = "auto" | "user" | "space";
+
+export interface RememberMemoryInput {
+  db?: any;
+  userId?: string | null;
+  spaceId?: string | null;
+  dialogId?: string | null;
+  content: string;
+  scope?: RememberMemoryScope;
+  kind?: MemoryKind;
+}
+
+export interface RememberMemoryResult {
+  success: true;
+  content: string;
+  requestedScope: RememberMemoryScope;
+  resolvedScopes: Array<{
+    ownerType: MemoryOwnerType;
+    ownerId: string;
+    subjectType: MemorySubjectType;
+    subjectId: string;
+    visibility: MemoryVisibility;
+  }>;
+}
+
+const MEMORY_KINDS = new Set<MemoryKind>(["episodic", "semantic", "procedural"]);
+
+const buildRememberTargets = (input: {
+  userId?: string | null;
+  spaceId?: string | null;
+  scope: RememberMemoryScope;
+}): Array<{
+  ownerType: MemoryOwnerType;
+  ownerId: string;
+  visibility: MemoryVisibility;
+  subjectType: MemorySubjectType;
+  subjectId: string;
+}> => {
+  if (input.scope === "user") {
+    if (!input.userId) {
+      throw new Error("rememberMemory: user scope requires userId");
+    }
+    return [
+      {
+        ownerType: "user",
+        ownerId: input.userId,
+        visibility: "private",
+        subjectType: "user",
+        subjectId: input.userId,
+      },
+    ];
+  }
+
+  if (input.scope === "space") {
+    if (input.spaceId) {
+      return [
+        {
+          ownerType: "space",
+          ownerId: input.spaceId,
+          visibility: "shared",
+          subjectType: "space",
+          subjectId: input.spaceId,
+        },
+      ];
+    }
+    if (input.userId) {
+      return [
+        {
+          ownerType: "user",
+          ownerId: input.userId,
+          visibility: "private",
+          subjectType: "user",
+          subjectId: input.userId,
+        },
+      ];
+    }
+    throw new Error("rememberMemory: space scope requires spaceId");
+  }
+
+  if (input.userId) {
+    return [
+      {
+        ownerType: "user",
+        ownerId: input.userId,
+        visibility: "private",
+        subjectType: "user",
+        subjectId: input.userId,
+      },
+    ];
+  }
+
+  if (input.spaceId) {
+    return [
+      {
+        ownerType: "space",
+        ownerId: input.spaceId,
+        visibility: "shared",
+        subjectType: "space",
+        subjectId: input.spaceId,
+      },
+    ];
+  }
+
+  return [];
+};
+
+export const rememberMemory = async (
+  input: RememberMemoryInput
+): Promise<RememberMemoryResult> => {
+  const content = input.content.trim();
+  if (!content) {
+    throw new Error("rememberMemory: content is required");
+  }
+
+  const scope = input.scope ?? "auto";
+  const targets = buildRememberTargets({
+    userId: input.userId,
+    spaceId: input.spaceId,
+    scope,
+  });
+  if (targets.length === 0) {
+    throw new Error("rememberMemory: no valid owner scope found");
+  }
+
+  const db = input.db ?? serverDb;
+  const kind = input.kind ?? "episodic";
+  if (!MEMORY_KINDS.has(kind)) {
+    throw new Error("rememberMemory: kind must be episodic, semantic, or procedural");
+  }
+  for (const target of targets) {
+    const item = createMemoryItem({
+      ownerType: target.ownerType,
+      ownerId: target.ownerId,
+      visibility: target.visibility,
+      subjectType: target.subjectType,
+      subjectId: target.subjectId,
+      kind,
+      content,
+      importance: kind === "procedural" ? 0.88 : target.ownerType === "user" ? 0.82 : 0.76,
+      confidence: kind === "procedural" ? 0.78 : 0.72,
+      tags:
+        target.ownerType === "user"
+          ? ["agent-remembered", ...(kind === "procedural" ? ["procedural-memory"] : [])]
+          : ["agent-remembered", "space-context", ...(kind === "procedural" ? ["procedural-memory"] : [])],
+      patternKey: kind === "procedural" ? "procedural-runbook" : "agent-remember",
+      sourceDialogId: input.dialogId ?? undefined,
+    });
+    await writeMemoryItemWithIndexesToDb(db, item);
+  }
+
+  return {
+    success: true,
+    content,
+    requestedScope: scope,
+    resolvedScopes: targets.map((target) => ({
+      ownerType: target.ownerType,
+      ownerId: target.ownerId,
+      subjectType: target.subjectType,
+      subjectId: target.subjectId,
+      visibility: target.visibility,
+    })),
+  };
+};

package/ai/memory/runtime.ts

@@ -0,0 +1,76 @@
+import { touchMemoryItems } from "./store";
+import { buildMemoryOverlay } from "./overlay";
+import { rankMemoryCandidates } from "./rank";
+import { buildDefaultSubjects, chooseMemoryOwners, loadMemoryCandidates } from "./query";
+import type { MemoryRuntimeResolution } from "./types";
+
+const normalizeSelectedContent = (text: string): string =>
+  text
+    .trim()
+    .replace(/^(你要记住|请记住|以后记住|记住)[，,。.\s:：]*/u, "")
+    .replace(/[。！？!?]+$/u, "")
+    .trim();
+
+const selectRuntimeMemoryItems = (items: ReturnType<typeof rankMemoryCandidates>) => {
+  const seen = new Set<string>();
+  const unique = items.filter((item) => {
+    const key = `${item.kind}:${normalizeSelectedContent(item.content).toLowerCase()}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+  const selected: typeof unique = [];
+  const selectedIds = new Set<string>();
+  const add = (item: typeof unique[number] | undefined) => {
+    if (!item || selectedIds.has(item.id) || selected.length >= 4) return;
+    selected.push(item);
+    selectedIds.add(item.id);
+  };
+
+  add(unique.find((item) => item.ownerType === "user"));
+  add(unique.find((item) => item.ownerType === "space"));
+  add(unique.find((item) => item.kind === "procedural"));
+  for (const item of unique) {
+    add(item);
+  }
+  return selected;
+};
+
+export const resolveMemoryRuntime = async (input: {
+  userId?: string | null;
+  spaceId?: string | null;
+  agentKey: string;
+  userInput: string;
+}): Promise<MemoryRuntimeResolution> => {
+  const owners = chooseMemoryOwners({
+    userId: input.userId,
+    spaceId: input.spaceId,
+  });
+  if (owners.length === 0) {
+    return { selectedItems: [], promptBlock: null };
+  }
+
+  const candidates = await loadMemoryCandidates({
+    owners,
+    subjects: buildDefaultSubjects({
+      userId: input.userId,
+      spaceId: input.spaceId,
+      agentKey: input.agentKey,
+    }),
+    kinds: ["episodic", "semantic", "procedural"],
+    ownerLimit: 20,
+  });
+
+  const ranked = selectRuntimeMemoryItems(
+    rankMemoryCandidates(candidates, input.userInput)
+  );
+  if (ranked.length === 0) {
+    return { selectedItems: [], promptBlock: null };
+  }
+
+  await touchMemoryItems(ranked);
+  return {
+    selectedItems: ranked,
+    promptBlock: buildMemoryOverlay(ranked),
+  };
+};

package/ai/memory/store.ts

@@ -0,0 +1,20 @@
+import serverDb from "database/server/db";
+import type { MemoryItem } from "./types";
+import {
+  createMemoryItem,
+  touchMemoryItemsInDb,
+  writeMemoryItemWithIndexesToDb,
+} from "./storeShared";
+
+export { createMemoryItem, writeMemoryItemWithIndexesToDb, touchMemoryItemsInDb };
+
+export const writeMemoryItemWithIndexes = async (item: MemoryItem): Promise<void> => {
+  return writeMemoryItemWithIndexesToDb(serverDb, item);
+};
+
+export const touchMemoryItems = async (
+  items: MemoryItem[],
+  now = new Date().toISOString()
+): Promise<void> => {
+  return touchMemoryItemsInDb(serverDb, items, now);
+};

package/ai/memory/storeShared.ts

@@ -0,0 +1,76 @@
+import { ulid } from "database/utils/ulid";
+import {
+  createMemoryKey,
+  createMemoryOwnerIndexKey,
+  createMemorySubjectKindIndexKey,
+} from "database/keys";
+import type { MemoryItem } from "./types";
+
+export const createMemoryItem = (
+  input: Omit<MemoryItem, "id" | "createdAt" | "lastActivatedAt" | "activationCount">
+): MemoryItem => {
+  const now = new Date().toISOString();
+  return {
+    id: ulid(),
+    createdAt: now,
+    lastActivatedAt: now,
+    activationCount: 0,
+    ...input,
+  };
+};
+
+export const writeMemoryItemWithIndexesToDb = async (
+  db: any,
+  item: MemoryItem
+): Promise<void> => {
+  const batch = db.batch();
+  batch.put(createMemoryKey(item.ownerType, item.ownerId, item.id), item);
+  batch.put(
+    createMemoryOwnerIndexKey(
+      item.ownerType,
+      item.ownerId,
+      item.createdAt,
+      item.id
+    ),
+    {
+      memoryKey: createMemoryKey(item.ownerType, item.ownerId, item.id),
+      ownerType: item.ownerType,
+      ownerId: item.ownerId,
+      memoryId: item.id,
+    }
+  );
+  batch.put(
+    createMemorySubjectKindIndexKey(
+      item.subjectType,
+      item.subjectId,
+      item.kind,
+      item.createdAt,
+      item.id
+    ),
+    {
+      memoryKey: createMemoryKey(item.ownerType, item.ownerId, item.id),
+      subjectType: item.subjectType,
+      subjectId: item.subjectId,
+      kind: item.kind,
+      memoryId: item.id,
+    }
+  );
+  await batch.write();
+};
+
+export const touchMemoryItemsInDb = async (
+  db: any,
+  items: MemoryItem[],
+  now = new Date().toISOString()
+): Promise<void> => {
+  if (items.length === 0) return;
+  const batch = db.batch();
+  for (const item of items) {
+    batch.put(createMemoryKey(item.ownerType, item.ownerId, item.id), {
+      ...item,
+      lastActivatedAt: now,
+      activationCount: (item.activationCount ?? 0) + 1,
+    });
+  }
+  await batch.write();
+};