nolo-cli 0.1.13 → 0.1.14

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

package/ai/memory/understandingGreeting.ts

@@ -0,0 +1,264 @@
+import { chooseMemoryOwners, loadMemoryCandidatesFromDb } from "./queryShared";
+import type { MemoryFacet, MemoryItem } from "./types";
+
+export interface UnderstandingGreetingResolution {
+  item: MemoryItem | null;
+  anchorItems: MemoryItem[];
+  followUpItem: MemoryItem | null;
+}
+
+const UNDERSTANDING_TAG = "understanding-memory";
+
+const facetPriority: Record<MemoryFacet, number> = {
+  unfinished: 5,
+  tension: 4,
+  preference: 3,
+  style: 2,
+  goal: 1,
+};
+
+const anchorFacetPriority: Record<MemoryFacet, number> = {
+  preference: 3,
+  style: 2,
+  goal: 1,
+  tension: 0,
+  unfinished: 0,
+};
+
+const normalizeText = (value: string): string =>
+  value.trim().replace(/[。！？!?]+$/u, "").trim();
+
+const stripPrefix = (text: string, prefix: string): string =>
+  text.startsWith(prefix) ? text.slice(prefix.length).trim() : text;
+
+const toTimestamp = (item: MemoryItem): number => {
+  const parsed = Date.parse(item.lastActivatedAt || item.createdAt);
+  return Number.isFinite(parsed) ? parsed : 0;
+};
+
+const isUnderstandingItem = (item: MemoryItem): boolean =>
+  Array.isArray(item.tags) && item.tags.includes(UNDERSTANDING_TAG);
+
+const sortByKindAndTime = (left: MemoryItem, right: MemoryItem): number => {
+  if (left.kind !== right.kind) return left.kind === "semantic" ? -1 : 1;
+  return toTimestamp(right) - toTimestamp(left);
+};
+
+const sameNormalizedContent = (left: string, right: string): boolean =>
+  normalizeText(left).toLowerCase() === normalizeText(right).toLowerCase();
+
+const pickAnchorItems = (items: MemoryItem[]): MemoryItem[] => {
+  const ranked = [...items]
+    .filter((item) => (item.facet ? anchorFacetPriority[item.facet] > 0 : false))
+    .sort((left, right) => {
+      const leftFacet = left.facet ? anchorFacetPriority[left.facet] ?? 0 : 0;
+      const rightFacet = right.facet ? anchorFacetPriority[right.facet] ?? 0 : 0;
+      if (leftFacet !== rightFacet) return rightFacet - leftFacet;
+      if (left.kind !== right.kind) return left.kind === "semantic" ? -1 : 1;
+      if (left.content.length !== right.content.length) {
+        return left.content.length - right.content.length;
+      }
+      return toTimestamp(right) - toTimestamp(left);
+    });
+
+  const selected: MemoryItem[] = [];
+  for (const item of ranked) {
+    if (
+      selected.some((existing) =>
+        sameNormalizedContent(existing.content, item.content) ||
+        (existing.facet && item.facet && existing.facet === item.facet)
+      )
+    ) {
+      continue;
+    }
+    selected.push(item);
+    if (selected.length >= 2) break;
+  }
+  return selected;
+};
+
+const pickFollowUpItem = (items: MemoryItem[]): MemoryItem | null =>
+  [...items]
+    .filter((item) => item.facet === "unfinished" || item.facet === "tension")
+    .sort((left, right) => {
+      const leftFacet = left.facet ? facetPriority[left.facet] ?? 0 : 0;
+      const rightFacet = right.facet ? facetPriority[right.facet] ?? 0 : 0;
+      if (leftFacet !== rightFacet) return rightFacet - leftFacet;
+      return sortByKindAndTime(left, right);
+    })[0] ?? null;
+
+export const resolveUnderstandingGreetingMemory = async (input: {
+  db: any;
+  userId?: string | null;
+  spaceId?: string | null;
+  agentKey: string;
+}): Promise<UnderstandingGreetingResolution> => {
+  const owners = chooseMemoryOwners({
+    userId: input.userId,
+    spaceId: input.spaceId,
+  });
+  if (owners.length === 0) {
+    return { item: null, anchorItems: [], followUpItem: null };
+  }
+
+  const items = await loadMemoryCandidatesFromDb(input.db, {
+    owners,
+    subjects: [{ subjectType: "agent", subjectId: input.agentKey }],
+    kinds: ["semantic", "episodic"],
+    ownerLimit: 40,
+  });
+
+  const understandingItems = items.filter(isUnderstandingItem);
+  if (understandingItems.length === 0) {
+    return { item: null, anchorItems: [], followUpItem: null };
+  }
+
+  const ranked = [...understandingItems].sort((left, right) => {
+    const leftFacet = left.facet ? facetPriority[left.facet] ?? 0 : 0;
+    const rightFacet = right.facet ? facetPriority[right.facet] ?? 0 : 0;
+    if (leftFacet !== rightFacet) return rightFacet - leftFacet;
+    return sortByKindAndTime(left, right);
+  });
+
+  const anchorItems = pickAnchorItems(understandingItems);
+  const followUpItem = pickFollowUpItem(understandingItems);
+  const item = followUpItem ?? anchorItems[0] ?? ranked[0] ?? null;
+
+  return {
+    item,
+    anchorItems,
+    followUpItem,
+  };
+};
+
+const renderLeadClause = (item: MemoryItem): string => {
+  const content = normalizeText(item.content);
+  switch (item.facet) {
+    case "unfinished":
+      return `我记得你上次还没定下来：${stripPrefix(content, "还没决定")}`;
+    case "tension":
+      return `我记得你上次还在权衡${stripPrefix(content, "在权衡")}`;
+    case "style":
+    case "preference":
+      return `我记得你上次${content}`;
+    case "goal":
+      return `我记得你上次想推进的是${content}`;
+    default:
+      return `我记得你上次提过${content}`;
+  }
+};
+
+const renderAnchorFragment = (item: MemoryItem): string => {
+  const content = normalizeText(item.content);
+  switch (item.facet) {
+    case "preference":
+      if (content.startsWith("更在意")) {
+        return `更在意的是${stripPrefix(content, "更在意")}`;
+      }
+      if (content.startsWith("更关心")) {
+        return `更关心的是${stripPrefix(content, "更关心")}`;
+      }
+      if (content.startsWith("更怕")) {
+        return `更怕${stripPrefix(content, "更怕")}`;
+      }
+      if (content.startsWith("不想")) {
+        return `不想${stripPrefix(content, "不想")}`;
+      }
+      if (content.startsWith("不希望")) {
+        return `不希望${stripPrefix(content, "不希望")}`;
+      }
+      return content;
+    case "style":
+      if (content.startsWith("不喜欢")) {
+        return `不太喜欢${stripPrefix(content, "不喜欢")}`;
+      }
+      if (content.startsWith("更喜欢")) {
+        return `更喜欢${stripPrefix(content, "更喜欢")}`;
+      }
+      return content;
+    case "goal":
+      if (content.startsWith("想先")) {
+        return `想先${stripPrefix(content, "想先")}`;
+      }
+      return `想推进的是${content}`;
+    default:
+      return content;
+  }
+};
+
+const renderAnchorSentence = (items: MemoryItem[]): string | null => {
+  if (items.length === 0) return null;
+  const fragments = items
+    .map(renderAnchorFragment)
+    .map((fragment) => fragment.trim())
+    .filter(Boolean);
+  if (fragments.length === 0) return null;
+  if (fragments.length === 1) {
+    return `我记得你上次${fragments[0]}。`;
+  }
+  return `我记得你上次${fragments[0]}，也${fragments[1]}。`;
+};
+
+const splitTradeoff = (value: string): [string, string] | null => {
+  const normalized = normalizeText(value)
+    .replace(/^在权衡/u, "")
+    .replace(/^还没决定/u, "")
+    .replace(/^还不确定/u, "")
+    .replace(/^还没想好/u, "")
+    .trim();
+  if (!normalized.includes("还是")) return null;
+
+  const [left, right] = normalized.split(/\s*还是/u, 2);
+  const normalizedLeft = normalizeText((left ?? "").replace(/[，,：:]+$/u, "").trim());
+  const normalizedRight = normalizeText((right ?? "").trim());
+  if (!normalizedLeft || !normalizedRight) return null;
+  return [normalizedLeft, normalizedRight];
+};
+
+const renderFollowUpLine = (item: MemoryItem | null): string => {
+  if (!item) {
+    return "如果你想，我们可以接着上次那个点；如果今天是新问题，也直接说。";
+  }
+
+  const tradeoff = splitTradeoff(item.content);
+  if (tradeoff) {
+    return `如果你愿意，我们可以接着看：${tradeoff[0]}，还是${tradeoff[1]}。如果今天是新问题，也直接说。`;
+  }
+
+  const content = normalizeText(item.content);
+  switch (item.facet) {
+    case "unfinished":
+      return `如果你愿意，我们可以接着把${stripPrefix(content, "还没决定")}定下来；如果今天是新问题，也直接说。`;
+    case "tension":
+      return `如果你愿意，我们可以接着看${stripPrefix(content, "在权衡")}；如果今天是新问题，也直接说。`;
+    case "goal":
+      return `如果你愿意，我们可以继续推进${stripPrefix(content, "想先")}；如果今天是新问题，也直接说。`;
+    default:
+      return "如果你想，我们可以接着上次那个点；如果今天是新问题，也直接说。";
+  }
+};
+
+export const mergeGreetingWithUnderstandingMemory = (input: {
+  greetingText?: string;
+  resolution?: UnderstandingGreetingResolution | null;
+  item?: MemoryItem | null;
+}): string | null => {
+  const greetingText = typeof input.greetingText === "string"
+    ? input.greetingText.trim()
+    : "";
+  const resolution = input.resolution ?? null;
+  const item = input.item ?? resolution?.item ?? null;
+  if (!greetingText && !item) return null;
+  if (!item) return greetingText || null;
+
+  const anchorItems = resolution?.anchorItems ?? [];
+  const followUpItem = resolution?.followUpItem ?? item;
+  const leadLine = renderAnchorSentence(anchorItems) ?? `${renderLeadClause(item)}。`;
+  const suffix = renderFollowUpLine(followUpItem);
+  const memoryBlock = `欢迎回来。${leadLine}\n${suffix}`;
+
+  if (!greetingText) {
+    return memoryBlock;
+  }
+  return `${greetingText}\n\n${memoryBlock}`;
+};

package/ai/messages/type.ts

@@ -0,0 +1,20 @@
+import { ClaudeContent } from "integrations/anthropic/type";
+
+export interface InputMessage {
+  content:
+    | Array<{
+        text?: string;
+        type: string;
+        image_url?: {
+          url: string;
+        };
+      }>
+    | string;
+  role: string;
+}
+
+export interface OutputMessage {
+  role: string;
+  content: string | ClaudeContent;
+  images: string[];
+}