nolo-cli 0.1.8 → 0.1.9

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);

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,249 @@
+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 (!greetingText) {
+    return continuationLike
+      ? `上次我们聊到：${recentRecap}\n\n如果你还想接着那个点继续，我们可以从那里往下走；如果想换个方向也可以。`
+      : `上次我们主要聊到：${recentRecap}\n\n这次你想从哪里继续？`;
+  }
+
+  return continuationLike
+    ? `${greetingText}\n\n上次我们聊到：${recentRecap}\n如果你还想接着那个点继续，我们可以从那里往下走；如果想换个方向也可以。`
+    : `${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,
+    })),
+  };
+};