nolo-cli 0.1.40 → 0.1.42

package/ai/memory/recentRelationshipRecap.ts

@@ -0,0 +1,251 @@
+import { createDialogKey, dialogMessageRange } from "../../database/keys";
+import { extractCustomId } from "../../core/prefix";
+import { resolveAgentMemoryPolicy } from "./policy";
+
+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 (!resolveAgentMemoryPolicy({ agentKey: input.agentKey }).allowDynamicGreetingMemory) {
+    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,111 @@
+import serverDb from "../../database/server/db";
+import { resolveScopedMemoryTargets, type MemoryScope } from "./scope";
+import { createMemoryItem, writeMemoryItemWithIndexesToDb } from "./store";
+import type {
+  MemoryItem,
+  MemoryKind,
+  MemoryOwnerType,
+  MemorySubjectType,
+  MemoryVisibility,
+} from "./types";
+
+export type RememberMemoryScope = MemoryScope;
+
+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;
+  savedItems: MemoryItem[];
+  resolvedScopes: Array<{
+    ownerType: MemoryOwnerType;
+    ownerId: string;
+    subjectType: MemorySubjectType;
+    subjectId: string;
+    visibility: MemoryVisibility;
+  }>;
+}
+
+const MEMORY_KINDS = new Set<MemoryKind>(["episodic", "semantic", "procedural"]);
+
+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";
+  let targets: ReturnType<typeof resolveScopedMemoryTargets>;
+  try {
+    targets = resolveScopedMemoryTargets({
+      userId: input.userId,
+      spaceId: input.spaceId,
+      scope,
+      fallbackToUserForMissingSpace: true,
+    });
+  } catch (error) {
+    if (scope === "user") {
+      throw new Error("rememberMemory: user scope requires userId");
+    }
+    if (scope === "space") {
+      throw new Error("rememberMemory: space scope requires spaceId");
+    }
+    throw error;
+  }
+  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");
+  }
+  const savedItems: MemoryItem[] = [];
+  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);
+    savedItems.push(item);
+  }
+
+  return {
+    success: true,
+    content,
+    requestedScope: scope,
+    savedItems,
+    resolvedScopes: targets.map((target) => ({
+      ownerType: target.ownerType,
+      ownerId: target.ownerId,
+      subjectType: target.subjectType,
+      subjectId: target.subjectId,
+      visibility: target.visibility,
+    })),
+  };
+};

package/ai/memory/scope.ts

@@ -0,0 +1,74 @@
+import type {
+  MemoryOwnerType,
+  MemorySubjectType,
+  MemoryVisibility,
+} from "./types";
+
+export type MemoryScope = "auto" | "user" | "space";
+
+export interface MemoryScopeTarget {
+  ownerType: MemoryOwnerType;
+  ownerId: string;
+  visibility: MemoryVisibility;
+  subjectType: MemorySubjectType;
+  subjectId: string;
+}
+
+export const buildUserMemoryTarget = (userId: string): MemoryScopeTarget => ({
+  ownerType: "user",
+  ownerId: userId,
+  visibility: "private",
+  subjectType: "user",
+  subjectId: userId,
+});
+
+export const buildSpaceMemoryTarget = (spaceId: string): MemoryScopeTarget => ({
+  ownerType: "space",
+  ownerId: spaceId,
+  visibility: "shared",
+  subjectType: "space",
+  subjectId: spaceId,
+});
+
+export const resolveUserOrSpaceMemoryTarget = (input: {
+  userId?: string | null;
+  spaceId?: string | null;
+}): MemoryScopeTarget | null => {
+  if (input.userId) return buildUserMemoryTarget(input.userId);
+  if (input.spaceId) return buildSpaceMemoryTarget(input.spaceId);
+  return null;
+};
+
+export const resolveScopedMemoryTargets = (input: {
+  userId?: string | null;
+  spaceId?: string | null;
+  scope?: MemoryScope;
+  fallbackToUserForMissingSpace?: boolean;
+}): MemoryScopeTarget[] => {
+  const scope = input.scope ?? "auto";
+  if (scope === "user") {
+    if (!input.userId) throw new Error("memory scope requires userId");
+    return [buildUserMemoryTarget(input.userId)];
+  }
+
+  if (scope === "space") {
+    if (input.spaceId) return [buildSpaceMemoryTarget(input.spaceId)];
+    if (input.fallbackToUserForMissingSpace && input.userId) {
+      return [buildUserMemoryTarget(input.userId)];
+    }
+    throw new Error("memory space scope requires spaceId");
+  }
+
+  const target = resolveUserOrSpaceMemoryTarget(input);
+  return target ? [target] : [];
+};
+
+export const buildAgentSubjectTarget = (
+  target: Pick<MemoryScopeTarget, "ownerType" | "ownerId" | "visibility">,
+  agentKey: string
+) => ({
+  owner: { ownerType: target.ownerType, ownerId: target.ownerId },
+  visibility: target.visibility,
+  subjectType: "agent" as const,
+  subjectId: agentKey,
+});

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();
+};

package/ai/memory/types.ts

@@ -0,0 +1,52 @@
+export type MemoryOwnerType = "user" | "space" | "system";
+export type MemoryVisibility = "private" | "shared" | "public";
+export type MemorySubjectType = "user" | "agent" | "space" | "project" | "system";
+export type MemoryKind = "episodic" | "semantic" | "procedural";
+export type MemoryFacet =
+  | "preference"
+  | "tension"
+  | "unfinished"
+  | "goal"
+  | "style";
+
+export type MemorySourceKind =
+  | "explicit-user-directive"
+  | "agent-tool"
+  | "inferred-understanding";
+
+export interface MemoryItem {
+  id: string;
+  ownerType: MemoryOwnerType;
+  ownerId: string;
+  visibility: MemoryVisibility;
+  subjectType: MemorySubjectType;
+  subjectId: string;
+  kind: MemoryKind;
+  content: string;
+  createdAt: string;
+  lastActivatedAt: string;
+  activationCount: number;
+  importance: number;
+  confidence: number;
+  tags?: string[];
+  facet?: MemoryFacet;
+  patternKey?: string;
+  sourceKind?: MemorySourceKind;
+  sourceDialogId?: string;
+  sourceMessageId?: string;
+}
+
+export interface MemoryOwnerRef {
+  ownerType: MemoryOwnerType;
+  ownerId: string;
+}
+
+export interface MemorySubjectRef {
+  subjectType: MemorySubjectType;
+  subjectId: string;
+}
+
+export interface MemoryRuntimeResolution {
+  selectedItems: MemoryItem[];
+  promptBlock: string | null;
+}