nolo-cli 0.1.10 → 0.1.12

package/ai/llm/usageRequestOptions.ts

@@ -1,59 +0,0 @@
-export interface UsageRequestOptions {
-  stream_options?: {
-    include_usage: true;
-  };
-  usage?: {
-    include: true;
-  };
-}
-
-export type UsageRequestApi = "chat-completions" | "responses";
-
-const STREAM_USAGE_PROVIDERS = new Set([
-  "google",
-  "openrouter",
-  "xai",
-  "openai",
-  "fireworks",
-  "mistral",
-]);
-
-const EXTRA_USAGE_FIELD_PROVIDERS = new Set(["openrouter"]);
-
-const normalizeProviderName = (providerName?: string | null) =>
-  typeof providerName === "string" ? providerName.trim().toLowerCase() : "";
-
-export const getUsageRequestOptions = (
-  providerName?: string | null,
-  options?: { api?: UsageRequestApi }
-): UsageRequestOptions => {
-  const normalizedProvider = normalizeProviderName(providerName);
-  const api = options?.api ?? "chat-completions";
-
-  if (api === "responses") {
-    return EXTRA_USAGE_FIELD_PROVIDERS.has(normalizedProvider)
-      ? {
-          usage: {
-            include: true as const,
-          },
-        }
-      : {};
-  }
-
-  return {
-    ...(STREAM_USAGE_PROVIDERS.has(normalizedProvider)
-      ? {
-          stream_options: {
-            include_usage: true as const,
-          },
-        }
-      : {}),
-    ...(EXTRA_USAGE_FIELD_PROVIDERS.has(normalizedProvider)
-      ? {
-          usage: {
-            include: true as const,
-          },
-        }
-      : {}),
-  };
-};

package/ai/memory/capture.ts

@@ -1,148 +0,0 @@
-import serverDb from "database/server/db";
-import { maybeConsolidateExplicitRemember } from "./consolidate";
-import { createMemoryItem, writeMemoryItemWithIndexesToDb } from "./store";
-import type { MemoryOwnerType, MemorySubjectType, MemoryVisibility } from "./types";
-
-const EXPLICIT_REMEMBER_PATTERNS = [
-  "记住",
-  "你要记住",
-  "请记住",
-  "以后记住",
-];
-
-export const shouldCaptureExplicitMemory = (userInput: string): boolean => {
-  const text = userInput.trim();
-  if (!text) return false;
-  return EXPLICIT_REMEMBER_PATTERNS.some((pattern) => {
-    const index = text.indexOf(pattern);
-    if (index < 0) return false;
-
-    const prefix = text.slice(0, index).trim();
-    const suffix = text.slice(index + pattern.length).trim();
-    if (!suffix) return false;
-    if (!prefix) return true;
-
-    return /^(这个|这件事|这一点|这点|请你|你)?$/u.test(prefix);
-  });
-};
-
-const buildExplicitMemoryTargets = (input: {
-  userId?: string | null;
-  spaceId?: string | null;
-}): Array<{
-  ownerType: MemoryOwnerType;
-  ownerId: string;
-  visibility: MemoryVisibility;
-  subjectType: MemorySubjectType;
-  subjectId: string;
-  importance: number;
-  confidence: number;
-  tags: string[];
-}> => {
-  if (input.userId) {
-    return [
-      {
-        ownerType: "user",
-        ownerId: input.userId,
-        visibility: "private",
-        subjectType: "user",
-        subjectId: input.userId,
-        importance: 0.95,
-        confidence: 0.95,
-        tags: ["explicit-memory"],
-      },
-    ];
-  }
-
-  if (input.spaceId) {
-    return [
-      {
-        ownerType: "space",
-        ownerId: input.spaceId,
-        visibility: "shared",
-        subjectType: "space",
-        subjectId: input.spaceId,
-        importance: 0.85,
-        confidence: 0.9,
-        tags: ["explicit-memory", "space-context"],
-      },
-    ];
-  }
-
-  return [];
-};
-
-export const captureExplicitMemoryEpisode = async (input: {
-  db?: any;
-  userId?: string | null;
-  spaceId?: string | null;
-  agentKey: string;
-  dialogId: string;
-  userInput: string;
-}): Promise<void> => {
-  if (!shouldCaptureExplicitMemory(input.userInput)) return;
-  const db = input.db ?? serverDb;
-  const targets = buildExplicitMemoryTargets(input);
-
-  for (const target of targets) {
-    const item = createMemoryItem({
-      ownerType: target.ownerType,
-      ownerId: target.ownerId,
-      visibility: target.visibility,
-      subjectType: target.subjectType,
-      subjectId: target.subjectId,
-      kind: "episodic",
-      content: input.userInput.trim(),
-      importance: target.importance,
-      confidence: target.confidence,
-      tags: target.tags,
-      patternKey: "explicit-remember",
-      sourceDialogId: input.dialogId,
-    });
-    await writeMemoryItemWithIndexesToDb(db, item);
-  }
-};
-
-export const consolidateExplicitMemoryAfterDialog = async (input: {
-  db?: any;
-  userId?: string | null;
-  spaceId?: string | null;
-  agentKey: string;
-  dialogId: string;
-  userInput: string;
-}): Promise<void> => {
-  if (!shouldCaptureExplicitMemory(input.userInput)) return;
-  const db = input.db ?? serverDb;
-  const targets = buildExplicitMemoryTargets(input);
-
-  for (const target of targets) {
-    await maybeConsolidateExplicitRemember({
-      db,
-      owner: { ownerType: target.ownerType, ownerId: target.ownerId },
-      subjectType: target.subjectType,
-      subjectId: target.subjectId,
-      visibility: target.visibility,
-      content: input.userInput.trim(),
-    });
-  }
-};
-
-export const scheduleExplicitMemoryConsolidation = (input: {
-  db?: any;
-  userId?: string | null;
-  spaceId?: string | null;
-  agentKey: string;
-  dialogId: string;
-  userInput: string;
-}): void => {
-  queueMicrotask(() => {
-    void consolidateExplicitMemoryAfterDialog(input).catch((error) => {
-      console.warn("[memory] explicit post-dialog consolidation failed", {
-        dialogId: input.dialogId,
-        userId: input.userId ?? null,
-        spaceId: input.spaceId ?? null,
-        error,
-      });
-    });
-  });
-};

package/ai/memory/consolidate.ts

@@ -1,104 +0,0 @@
-import serverDb from "database/server/db";
-import { loadMemoryCandidatesFromDb } from "./query";
-import { createMemoryItem, writeMemoryItemWithIndexesToDb } from "./store";
-import type { MemoryItem, MemoryOwnerRef, MemorySubjectType } from "./types";
-
-const EXPLICIT_REMEMBER_PREFIXES = [
-  "你要记住",
-  "请记住",
-  "以后记住",
-  "记住",
-];
-
-const normalizeExplicitRememberContent = (text: string): string => {
-  let normalized = text.trim();
-  for (const prefix of EXPLICIT_REMEMBER_PREFIXES) {
-    if (normalized.startsWith(prefix)) {
-      normalized = normalized.slice(prefix.length).trim();
-      break;
-    }
-  }
-
-  normalized = normalized
-    .replace(/^[，,。.\s:：]+/, "")
-    .replace(/[。！？!?]+$/g, "")
-    .trim();
-
-  return normalized;
-};
-
-const buildSemanticPatternKey = (normalizedContent: string): string =>
-  `semantic-explicit:${normalizedContent.toLowerCase()}`;
-
-const shouldKeepAsSemanticCandidate = (normalizedContent: string): boolean =>
-  normalizedContent.length >= 6;
-
-const findMatchingExplicitEpisodes = (
-  items: MemoryItem[],
-  normalizedContent: string,
-  subjectId: string
-): MemoryItem[] =>
-  items.filter((item) => {
-    if (item.kind !== "episodic") return false;
-    if (item.patternKey !== "explicit-remember") return false;
-    if (item.subjectId !== subjectId) return false;
-    return normalizeExplicitRememberContent(item.content) === normalizedContent;
-  });
-
-export const maybeConsolidateExplicitRemember = async (input: {
-  db?: any;
-  owner: MemoryOwnerRef;
-  subjectType: MemorySubjectType;
-  subjectId: string;
-  visibility: "private" | "shared" | "public";
-  content: string;
-}): Promise<void> => {
-  const normalizedContent = normalizeExplicitRememberContent(input.content);
-  if (!shouldKeepAsSemanticCandidate(normalizedContent)) return;
-
-  const db = input.db ?? serverDb;
-  const items = await loadMemoryCandidatesFromDb(db, {
-    owners: [input.owner],
-    subjects: [{ subjectType: input.subjectType, subjectId: input.subjectId }],
-    kinds: ["episodic", "semantic"],
-    ownerLimit: 50,
-  });
-
-  const matchingEpisodes = findMatchingExplicitEpisodes(
-    items,
-    normalizedContent,
-    input.subjectId
-  );
-  if (matchingEpisodes.length < 2) return;
-
-  const semanticPatternKey = buildSemanticPatternKey(normalizedContent);
-  const existingSemantic = items.find(
-    (item) =>
-      item.kind === "semantic" &&
-      item.subjectId === input.subjectId &&
-      item.patternKey === semanticPatternKey
-  );
-  if (existingSemantic) return;
-
-  const semantic = createMemoryItem({
-    ownerType: input.owner.ownerType,
-    ownerId: input.owner.ownerId,
-    visibility: input.visibility,
-    subjectType: input.subjectType,
-    subjectId: input.subjectId,
-    kind: "semantic",
-    content: normalizedContent,
-    importance: 0.92,
-    confidence: 0.72,
-    tags: ["explicit-memory", "consolidated"],
-    patternKey: semanticPatternKey,
-    sourceDialogId: matchingEpisodes[matchingEpisodes.length - 1]?.sourceDialogId,
-  });
-
-  await writeMemoryItemWithIndexesToDb(db, semantic);
-};
-
-export const __test__ = {
-  normalizeExplicitRememberContent,
-  buildSemanticPatternKey,
-};

package/ai/memory/delete.ts

@@ -1,147 +0,0 @@
-import serverDb from "database/server/db";
-import {
-  createMemoryKey,
-  createMemoryOwnerIndexKey,
-  createMemorySubjectKindIndexKey,
-  memoryOwnerRange,
-} from "database/keys";
-import type {
-  MemoryFacet,
-  MemoryItem,
-  MemoryKind,
-  MemoryOwnerRef,
-  MemorySubjectType,
-} from "./types";
-
-interface DeleteMemoryFilters {
-  ids?: string[];
-  kinds?: MemoryKind[];
-  facets?: MemoryFacet[];
-  subjectType?: MemorySubjectType;
-  subjectId?: string;
-  patternKeyPrefix?: string;
-  sourceDialogId?: string;
-  tags?: string[];
-  limit?: number;
-}
-
-export interface DeleteMemoryResult {
-  deletedCount: number;
-  deletedIds: string[];
-  matchedItems: MemoryItem[];
-}
-
-const normalizeSet = (values?: string[]): Set<string> | null => {
-  if (!Array.isArray(values) || values.length === 0) return null;
-  const normalized = values
-    .map((value) => value.trim())
-    .filter(Boolean);
-  return normalized.length > 0 ? new Set(normalized) : null;
-};
-
-const matchesFilters = (item: MemoryItem, filters: DeleteMemoryFilters): boolean => {
-  const idSet = normalizeSet(filters.ids);
-  if (idSet && !idSet.has(item.id)) return false;
-
-  const kindSet = normalizeSet(filters.kinds);
-  if (kindSet && !kindSet.has(item.kind)) return false;
-
-  const facetSet = normalizeSet(filters.facets);
-  if (facetSet && (!item.facet || !facetSet.has(item.facet))) return false;
-
-  if (filters.subjectType && item.subjectType !== filters.subjectType) return false;
-  if (filters.subjectId && item.subjectId !== filters.subjectId) return false;
-
-  const prefix = typeof filters.patternKeyPrefix === "string"
-    ? filters.patternKeyPrefix.trim()
-    : "";
-  if (prefix && !(item.patternKey ?? "").startsWith(prefix)) return false;
-
-  if (filters.sourceDialogId && item.sourceDialogId !== filters.sourceDialogId) {
-    return false;
-  }
-
-  const tagSet = normalizeSet(filters.tags);
-  if (tagSet) {
-    const itemTags = new Set((item.tags ?? []).map((tag) => tag.trim()).filter(Boolean));
-    for (const tag of tagSet) {
-      if (!itemTags.has(tag)) return false;
-    }
-  }
-
-  return true;
-};
-
-const deleteMemoryItemWithIndexesInBatch = (
-  batch: any,
-  item: MemoryItem
-) => {
-  batch.del(createMemoryKey(item.ownerType, item.ownerId, item.id));
-  batch.del(
-    createMemoryOwnerIndexKey(
-      item.ownerType,
-      item.ownerId,
-      item.createdAt,
-      item.id
-    )
-  );
-  batch.del(
-    createMemorySubjectKindIndexKey(
-      item.subjectType,
-      item.subjectId,
-      item.kind,
-      item.createdAt,
-      item.id
-    )
-  );
-};
-
-export const deleteMemoriesForOwnerFromDb = async (
-  db: any,
-  owner: MemoryOwnerRef,
-  filters: DeleteMemoryFilters = {}
-): Promise<DeleteMemoryResult> => {
-  const range = memoryOwnerRange(owner.ownerType, owner.ownerId);
-  const matchedItems: MemoryItem[] = [];
-  const limit = typeof filters.limit === "number" && filters.limit > 0
-    ? filters.limit
-    : Number.POSITIVE_INFINITY;
-
-  for await (const [, value] of db.iterator({
-    gte: range.start,
-    lte: range.end,
-    reverse: true,
-  })) {
-    const memoryId = typeof value?.memoryId === "string" ? value.memoryId : "";
-    if (!memoryId) continue;
-    const item = (await db
-      .get(createMemoryKey(owner.ownerType, owner.ownerId, memoryId))
-      .catch(() => null)) as MemoryItem | null;
-    if (!item) continue;
-    if (!matchesFilters(item, filters)) continue;
-    matchedItems.push(item);
-    if (matchedItems.length >= limit) break;
-  }
-
-  if (matchedItems.length === 0) {
-    return { deletedCount: 0, deletedIds: [], matchedItems: [] };
-  }
-
-  const batch = db.batch();
-  for (const item of matchedItems) {
-    deleteMemoryItemWithIndexesInBatch(batch, item);
-  }
-  await batch.write();
-
-  return {
-    deletedCount: matchedItems.length,
-    deletedIds: matchedItems.map((item) => item.id),
-    matchedItems,
-  };
-};
-
-export const deleteMemoriesForOwner = async (
-  owner: MemoryOwnerRef,
-  filters: DeleteMemoryFilters = {}
-): Promise<DeleteMemoryResult> =>
-  deleteMemoriesForOwnerFromDb(serverDb, owner, filters);

package/ai/memory/overlay.ts

@@ -1,84 +0,0 @@
-import type { MemoryItem } from "./types";
-
-const KIND_TITLES: Record<MemoryItem["kind"], string> = {
-  episodic: "Episodic",
-  semantic: "Semantic",
-  procedural: "Procedural",
-};
-
-const normalizeDisplayContent = (item: MemoryItem): string => {
-  const normalized = item.content
-    .trim()
-    .replace(/^(你要记住|请记住|以后记住|记住)[，,。.\s:：]*/u, "")
-    .replace(/[。！？!?]+$/u, "")
-    .trim();
-  const stripPrefix = (prefix: string) =>
-    normalized.startsWith(prefix) ? normalized.slice(prefix.length).trim() : normalized;
-
-  if (item.kind === "semantic") {
-    if (item.tags?.includes("understanding-memory")) {
-      switch (item.facet) {
-        case "unfinished":
-          return `用户仍未定下：${stripPrefix("还没决定")}`;
-        case "tension":
-          return `用户当前在权衡：${stripPrefix("在权衡")}`;
-        case "preference":
-          return `用户当前更在意：${stripPrefix("更在意")}`;
-        case "style":
-          return `用户互动偏好：${stripPrefix("更喜欢")}`;
-        case "goal":
-          return `用户当前目标：${stripPrefix("想推进")}`;
-      }
-    }
-    return `用户长期偏好/事实：${normalized}`;
-  }
-
-  if (item.kind === "episodic" && item.patternKey === "explicit-remember") {
-    return `用户明确要求你记住：${normalized}`;
-  }
-
-  if (item.kind === "episodic" && item.tags?.includes("understanding-memory")) {
-    switch (item.facet) {
-      case "unfinished":
-        return `最近一次对话显示：用户还没定下 ${stripPrefix("还没决定")}`;
-      case "tension":
-        return `最近一次对话显示：用户还在权衡 ${stripPrefix("在权衡")}`;
-      case "preference":
-        return `最近一次对话显示：用户更在意 ${stripPrefix("更在意")}`;
-      case "style":
-        return `最近一次对话显示：用户更偏好 ${stripPrefix("更喜欢")}`;
-      case "goal":
-        return `最近一次对话显示：用户想推进 ${stripPrefix("想推进")}`;
-    }
-  }
-
-  return normalized;
-};
-
-export const buildMemoryOverlay = (items: MemoryItem[]): string | null => {
-  if (items.length === 0) return null;
-
-  const byKind: Record<string, MemoryItem[]> = {
-    episodic: [],
-    semantic: [],
-    procedural: [],
-  };
-  for (const item of items) {
-    byKind[item.kind].push(item);
-  }
-
-  const sections = Object.entries(byKind)
-    .filter(([, list]) => list.length > 0)
-    .map(([kind, list]) => {
-      const lines = list.slice(0, 3).map((item) => `- ${normalizeDisplayContent(item)}`);
-      return [`[${KIND_TITLES[kind as MemoryItem["kind"]]}]`, ...lines].join("\n");
-    });
-
-  return [
-    "--- Memory Overlay ---",
-    "以下是当前请求可用的记忆事实；相关时直接基于这些记忆回答。",
-    "用户当前输入优先于记忆；记忆只辅助理解，不要求迎合。",
-    "",
-    ...sections,
-  ].join("\n");
-};

package/ai/memory/query.ts

@@ -1,38 +0,0 @@
-import serverDb from "database/server/db";
-import type {
-  MemoryItem,
-  MemoryKind,
-  MemoryOwnerRef,
-  MemorySubjectRef,
-} from "./types";
-import {
-  buildDefaultSubjects,
-  chooseMemoryOwners,
-  loadMemoryCandidatesFromDb,
-  loadOwnerItemsFromDb,
-  loadSubjectKindItemsFromDb,
-} from "./queryShared";
-
-export {
-  buildDefaultSubjects,
-  chooseMemoryOwners,
-  loadMemoryCandidatesFromDb,
-  loadOwnerItemsFromDb,
-  loadSubjectKindItemsFromDb,
-};
-
-export const loadOwnerItems = async (
-  owner: MemoryOwnerRef,
-  limit: number
-): Promise<MemoryItem[]> => {
-  return loadOwnerItemsFromDb(serverDb, owner, limit);
-};
-
-export const loadMemoryCandidates = async (input: {
-  owners: MemoryOwnerRef[];
-  subjects: MemorySubjectRef[];
-  kinds?: MemoryKind[];
-  ownerLimit?: number;
-}): Promise<MemoryItem[]> => {
-  return loadMemoryCandidatesFromDb(serverDb, input);
-};