nolo-cli 0.1.8 → 0.1.9

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

package/ai/memory/types.ts

@@ -0,0 +1,46 @@
+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 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;
+  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;
+}

package/ai/memory/understanding.ts

@@ -0,0 +1,349 @@
+import type { ChatMessage } from "server/handlers/agentRun/types";
+import { createMemoryItem, writeMemoryItemWithIndexesToDb } from "./storeShared";
+import { loadMemoryCandidatesFromDb } from "./queryShared";
+import type {
+  MemoryFacet,
+  MemoryItem,
+  MemoryOwnerRef,
+  MemoryVisibility,
+} from "./types";
+
+export interface UnderstandingMemoryCandidate {
+  facet: MemoryFacet;
+  content: string;
+  importance: number;
+  confidence: number;
+  patternKey: string;
+  tags: string[];
+}
+
+const UNDERSTANDING_TAG = "understanding-memory";
+
+const normalizeClause = (value: string): string =>
+  value
+    .replace(/[“”"]/g, "")
+    .replace(/\s+/g, " ")
+    .replace(/[。！？!?；;]+$/u, "")
+    .trim();
+
+const normalizeSignalLead = (value: string): string =>
+  normalizeClause(value.split(/[\n，,。！？!?；;]+/u)[0] ?? "");
+
+const stripLead = (value: string): string =>
+  value
+    .replace(/^(明白|好的|对|是的|所以|其实|我记得|欢迎回来|嗯|那)\s*[，,：:\-]?\s*/u, "")
+    .trim();
+
+const contentToText = (content: ChatMessage["content"]): string => {
+  if (typeof content === "string") return content.trim();
+  if (!Array.isArray(content)) return "";
+  return content
+    .map((part) => (part?.type === "text" ? part.text.trim() : ""))
+    .filter(Boolean)
+    .join("\n")
+    .trim();
+};
+
+const extractPreference = (text: string): string[] => {
+  const matches: string[] = [];
+  const normalized = stripLead(text);
+
+  const moreValue = normalized.match(/[你我](?:更)?在意(.+)/u);
+  if (moreValue?.[1]) {
+    matches.push(`更在意${normalizeSignalLead(moreValue[1])}`);
+  }
+
+  const concern = normalized.match(/[你我](?:更)?关心(.+)/u);
+  if (concern?.[1]) {
+    matches.push(`更关心${normalizeSignalLead(concern[1])}`);
+  }
+
+  const fear = normalized.match(/[你我](?:更)?怕(.+)/u);
+  if (fear?.[1]) {
+    matches.push(`更怕${normalizeSignalLead(fear[1])}`);
+  }
+
+  const dontWant = normalized.match(/[你我]不想(.+)/u);
+  if (dontWant?.[1]) {
+    matches.push(`不想${normalizeSignalLead(dontWant[1])}`);
+  }
+
+  const dontHope = normalized.match(/[你我]不希望(.+)/u);
+  if (dontHope?.[1]) {
+    matches.push(`不希望${normalizeSignalLead(dontHope[1])}`);
+  }
+
+  return matches;
+};
+
+const extractStyle = (text: string): string[] => {
+  const matches: string[] = [];
+  const normalized = stripLead(text);
+
+  const dislike = normalized.match(/[你我]不喜欢(.+)/u);
+  if (dislike?.[1]) {
+    matches.push(`不喜欢${normalizeSignalLead(dislike[1])}`);
+  }
+
+  const prefer = normalized.match(/[你我](?:更)?喜欢(.+)/u);
+  if (prefer?.[1]) {
+    matches.push(`更喜欢${normalizeSignalLead(prefer[1])}`);
+  }
+
+  return matches;
+};
+
+const extractGoal = (text: string): string[] => {
+  const matches: string[] = [];
+  const normalized = stripLead(text);
+  if (/[?？]/u.test(normalized)) {
+    return matches;
+  }
+
+  const wantFirst = normalized.match(/[你我](?:这次)?(?:更)?想先(?:把)?(.+)/u);
+  if (wantFirst?.[1]) {
+    matches.push(`想先${normalizeSignalLead(wantFirst[1])}`);
+  }
+
+  const shouldFirst = normalized.match(/[你我](?:还是)?想要先(?:把)?(.+)/u);
+  if (shouldFirst?.[1]) {
+    matches.push(`想先${normalizeSignalLead(shouldFirst[1])}`);
+  }
+
+  return matches;
+};
+
+const normalizeTensionTail = (tail: string): string =>
+  normalizeClause(
+    (
+      tail.replace(/^在/u, "").replace(/^权衡/u, "").replace(/^比较/u, "")
+        .split(/[。！？!?；;\n]/u)[0] ?? ""
+    )
+  );
+
+const extractTension = (text: string): string[] => {
+  const matches: string[] = [];
+  const normalized = stripLead(text);
+
+  const weigh = normalized.match(/[你我]在权衡(.+)/u);
+  if (weigh?.[1]) {
+    matches.push(`在权衡${normalizeTensionTail(weigh[1])}`);
+  }
+
+  const struggle = normalized.match(/[你我](?:现在)?(?:真正)?纠结(?:的是)?[：:，,\s]*(.+)/u);
+  if (struggle?.[1] && struggle[1].includes("还是")) {
+    matches.push(`在权衡${normalizeTensionTail(struggle[1])}`);
+  }
+
+  const stuck = normalized.match(/[你我]卡的点不是.+?而是(.+)/u);
+  if (stuck?.[1]) {
+    matches.push(`在权衡${normalizeTensionTail(stuck[1])}`);
+  }
+
+  return matches;
+};
+
+const extractUnfinished = (text: string): string[] => {
+  const matches: string[] = [];
+  const normalized = stripLead(text);
+
+  const direct = normalized.match(/[你我](?:还)?(?:没|尚未)决定(.+)/u);
+  if (direct?.[1]) {
+    matches.push(`还没决定${normalizeClause(direct[1])}`);
+  }
+
+  const uncertain = normalized.match(/[你我](?:还)?不确定(.+)/u);
+  if (uncertain?.[1]) {
+    matches.push(`还不确定${normalizeClause(uncertain[1])}`);
+  }
+
+  const notReady = normalized.match(/[你我](?:还)?没想好(.+)/u);
+  if (notReady?.[1]) {
+    matches.push(`还没想好${normalizeClause(notReady[1])}`);
+  }
+
+  return matches;
+};
+
+const buildPatternKey = (facet: MemoryFacet, content: string): string =>
+  `understanding:${facet}:${content.toLowerCase()}`;
+
+const buildCandidate = (
+  facet: MemoryFacet,
+  content: string
+): UnderstandingMemoryCandidate | null => {
+  const normalized = normalizeClause(content);
+  if (!normalized || normalized.length < 6) return null;
+
+  const importance =
+    facet === "unfinished" ? 0.91 :
+    facet === "tension" ? 0.89 :
+    facet === "preference" ? 0.84 :
+    facet === "style" ? 0.8 :
+    0.82;
+  const confidence =
+    facet === "unfinished" || facet === "tension" ? 0.76 : 0.72;
+
+  return {
+    facet,
+    content: normalized,
+    importance,
+    confidence,
+    patternKey: buildPatternKey(facet, normalized),
+    tags: [UNDERSTANDING_TAG, `memory-facet:${facet}`],
+  };
+};
+
+export const extractUnderstandingMemoryCandidates = (input: {
+  userInput: string;
+  trace?: ChatMessage[];
+}): UnderstandingMemoryCandidate[] => {
+  const texts = [
+    input.userInput,
+    ...(input.trace ?? [])
+      .filter((message) => message.role === "assistant" || message.role === "user")
+      .map((message) => contentToText(message.content)),
+  ]
+    .map((value) => value.trim())
+    .filter(Boolean);
+
+  const candidates: UnderstandingMemoryCandidate[] = [];
+  for (const text of texts) {
+    for (const content of extractPreference(text)) {
+      const candidate = buildCandidate("preference", content);
+      if (candidate) candidates.push(candidate);
+    }
+    for (const content of extractStyle(text)) {
+      const candidate = buildCandidate("style", content);
+      if (candidate) candidates.push(candidate);
+    }
+    for (const content of extractGoal(text)) {
+      const candidate = buildCandidate("goal", content);
+      if (candidate) candidates.push(candidate);
+    }
+    for (const content of extractTension(text)) {
+      const candidate = buildCandidate("tension", content);
+      if (candidate) candidates.push(candidate);
+    }
+    for (const content of extractUnfinished(text)) {
+      const candidate = buildCandidate("unfinished", content);
+      if (candidate) candidates.push(candidate);
+    }
+  }
+
+  const seen = new Set<string>();
+  return candidates.filter((candidate) => {
+    const key = `${candidate.facet}:${candidate.content.toLowerCase()}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+};
+
+const buildUnderstandingTarget = (input: {
+  userId?: string | null;
+  spaceId?: string | null;
+  agentKey: string;
+}): {
+  owner: MemoryOwnerRef;
+  visibility: MemoryVisibility;
+} | null => {
+  if (input.userId) {
+    return {
+      owner: { ownerType: "user", ownerId: input.userId },
+      visibility: "private",
+    };
+  }
+  if (input.spaceId) {
+    return {
+      owner: { ownerType: "space", ownerId: input.spaceId },
+      visibility: "shared",
+    };
+  }
+  return null;
+};
+
+const sameUnderstanding = (item: MemoryItem, candidate: UnderstandingMemoryCandidate, agentKey: string) =>
+  item.subjectType === "agent" &&
+  item.subjectId === agentKey &&
+  item.patternKey === candidate.patternKey;
+
+export const captureUnderstandingMemoryFromDialog = async (input: {
+  db: any;
+  userId?: string | null;
+  spaceId?: string | null;
+  agentKey: string;
+  dialogId: string;
+  userInput: string;
+  trace?: ChatMessage[];
+}): Promise<void> => {
+  const target = buildUnderstandingTarget(input);
+  if (!target) return;
+
+  const candidates = extractUnderstandingMemoryCandidates({
+    userInput: input.userInput,
+    trace: input.trace,
+  });
+  if (candidates.length === 0) return;
+
+  const existing = await loadMemoryCandidatesFromDb(input.db, {
+    owners: [target.owner],
+    subjects: [{ subjectType: "agent", subjectId: input.agentKey }],
+    kinds: ["episodic", "semantic"],
+    ownerLimit: 100,
+  });
+
+  for (const candidate of candidates) {
+    const sameItems = existing.filter((item) => sameUnderstanding(item, candidate, input.agentKey));
+    const existingSemantic = sameItems.find((item) => item.kind === "semantic");
+    if (existingSemantic) continue;
+
+    const existingEpisode = sameItems.find((item) => item.kind === "episodic");
+    if (
+      existingEpisode &&
+      existingEpisode.sourceDialogId &&
+      existingEpisode.sourceDialogId !== input.dialogId
+    ) {
+      const semantic = createMemoryItem({
+        ownerType: target.owner.ownerType,
+        ownerId: target.owner.ownerId,
+        visibility: target.visibility,
+        subjectType: "agent",
+        subjectId: input.agentKey,
+        kind: "semantic",
+        content: candidate.content,
+        facet: candidate.facet,
+        importance: Math.min(0.95, candidate.importance + 0.03),
+        confidence: Math.min(0.86, candidate.confidence + 0.06),
+        tags: [...candidate.tags, "consolidated-understanding"],
+        patternKey: candidate.patternKey,
+        sourceDialogId: input.dialogId,
+      });
+      await writeMemoryItemWithIndexesToDb(input.db, semantic);
+      existing.push(semantic);
+      continue;
+    }
+
+    if (existingEpisode && existingEpisode.sourceDialogId === input.dialogId) {
+      continue;
+    }
+
+    const episodic = createMemoryItem({
+      ownerType: target.owner.ownerType,
+      ownerId: target.owner.ownerId,
+      visibility: target.visibility,
+      subjectType: "agent",
+      subjectId: input.agentKey,
+      kind: "episodic",
+      content: candidate.content,
+      facet: candidate.facet,
+      importance: candidate.importance,
+      confidence: candidate.confidence,
+      tags: candidate.tags,
+      patternKey: candidate.patternKey,
+      sourceDialogId: input.dialogId,
+    });
+    await writeMemoryItemWithIndexesToDb(input.db, episodic);
+    existing.push(episodic);
+  }
+};