nolo-cli 0.1.40 → 0.1.41

package/ai/tools/remotionVideoTool.ts

@@ -0,0 +1,151 @@
+import { ContentType } from "../../app/types";
+import { addContentAction } from "../../create/space/content/addContentAction";
+import { selectCurrentSpaceId } from "../../create/space/spaceSlice";
+import { buildDatabaseFileContentUrl } from "../../database/fileUrl";
+import { fileKey } from "../../database/keys";
+import { selectCurrentServer } from "../../app/settings/settingSlice";
+import { selectUserId } from "../../auth/authSlice";
+import { callToolApi } from "./toolApiClient";
+
+type RemotionRenderVideoArgs = {
+  template?: "mobile-product" | "landscape-product" | "nolo-mobile-product" | "nolo-landscape-product";
+  brand?: string;
+  hook?: string;
+  headline?: string;
+  subline?: string;
+  prompt?: string;
+  cta?: string;
+  outputName?: string;
+};
+
+export const remotionRenderVideoFunctionSchema = {
+  name: "remotionRenderVideo",
+  description: [
+    "使用平台内 Remotion 模板渲染产品视频，并保存为可复用 MP4 文件。",
+    "",
+    "适用场景：",
+    "- 用户要生成手机传播视频、产品介绍视频、欢迎页短片、Agent/AI 工作流演示视频。",
+    "- 需要把文案、标题、输入框示例等参数化后产出 MP4。",
+    "",
+    "当前模板：",
+    "- mobile-product: 9:16 竖版，适合手机传播。",
+    "- landscape-product: 16:9 横版，适合官网/演示页。",
+    "- 兼容旧别名 nolo-mobile-product / nolo-landscape-product。",
+  ].join("\n"),
+  parameters: {
+    type: "object",
+    properties: {
+      template: {
+        type: "string",
+        enum: ["mobile-product", "landscape-product", "nolo-mobile-product", "nolo-landscape-product"],
+        description: "视频模板。默认 mobile-product。",
+      },
+      brand: {
+        type: "string",
+        description: "品牌名，例如 Nolo.Chat、你的产品名、店铺名或活动名。",
+      },
+      hook: {
+        type: "string",
+        description: "竖版视频首屏钩子标题，例如“把一句想法，推进成结果”。",
+      },
+      headline: {
+        type: "string",
+        description: "横版视频主标题；竖版缺少 hook 时也会作为 hook 使用。",
+      },
+      subline: {
+        type: "string",
+        description: "横版视频副标题。",
+      },
+      prompt: {
+        type: "string",
+        description: "手机输入框里逐字打出的示例需求。",
+      },
+      cta: {
+        type: "string",
+        description: "结尾行动号召，例如“开始体验”。",
+      },
+      outputName: {
+        type: "string",
+        description: "输出文件名，建议以 .mp4 结尾。",
+      },
+    },
+  },
+};
+
+export const remotionRenderVideoFunc = async (
+  args: RemotionRenderVideoArgs,
+  thunkApi: any
+): Promise<{ rawData: any; displayData: string; llmContext?: string }> => {
+  const result: any = await callToolApi(
+    thunkApi,
+    "/api/remotion/render",
+    {
+      template: args.template || "mobile-product",
+      brand: args.brand,
+      hook: args.hook,
+      headline: args.headline,
+      subline: args.subline,
+      prompt: args.prompt,
+      cta: args.cta,
+      outputName: args.outputName,
+    },
+    { withAuth: true }
+  );
+
+  const state = thunkApi.getState();
+  const userId = selectUserId(state);
+  const spaceId = selectCurrentSpaceId(state);
+  const currentServer = selectCurrentServer(state);
+  const fileId = result?.fileId;
+  const metadata = result?.metadata || {};
+  const fileDbKey = userId && fileId ? fileKey.single(userId, fileId) : "";
+  const url = buildDatabaseFileContentUrl(currentServer, fileDbKey || fileId);
+
+  if (spaceId && fileDbKey) {
+    try {
+      await addContentAction(
+        {
+          spaceId,
+          contentKey: fileDbKey,
+          title: metadata.originalName || "Remotion video.mp4",
+          type: ContentType.FILE,
+          fileCategory: "video",
+        } as any,
+        { dispatch: thunkApi.dispatch, getState: thunkApi.getState }
+      );
+    } catch (error) {
+      console.warn("[remotionRenderVideoFunc] Failed to add video to space:", error);
+    }
+  }
+
+  const displayLines = [
+    result?.text || "已使用 Remotion 生成视频。",
+    fileId ? `- fileId: ${fileId}` : "",
+    fileDbKey ? `- fileDbKey: ${fileDbKey}` : "",
+    url ? `- url: ${url}` : "",
+    metadata?.size ? `- size: ${metadata.size} bytes` : "",
+    result?.template ? `- template: ${result.template}` : "",
+  ].filter(Boolean);
+
+  const llmContext = [
+    "The Remotion video tool produced a reusable video file.",
+    "Reuse these exact references when mentioning or embedding the video:",
+    fileId ? `- fileId: ${fileId}` : "",
+    fileDbKey ? `- fileDbKey: ${fileDbKey}` : "",
+    url ? `- url: ${url}` : "",
+    metadata?.originalName ? `- name: ${metadata.originalName}` : "",
+    result?.template ? `- template: ${result.template}` : "",
+  ]
+    .filter(Boolean)
+    .join("\n");
+
+  return {
+    rawData: {
+      ...result,
+      fileDbKey,
+      url,
+    },
+    displayData: displayLines.join("\n"),
+    llmContext,
+  };
+};

package/ai/tools/searchDialogMessagesTool.ts

@@ -0,0 +1,222 @@
+import { extractCustomId } from "../../core/prefix";
+import { selectRuntimeSnapshot } from "../../app/stateViews/runtime";
+import {
+  buildDialogMessageSearchResults,
+  clampDialogSearchNumber,
+  formatDialogMessageSearchDisplay,
+  normalizeDialogSearchText,
+  type DialogMessageSearchRecord,
+} from "./dialogMessageSearch";
+
+type SearchDialogMessagesArgs = {
+  dialogKey: string;
+  query: string;
+  limit?: number;
+  scanLimit?: number;
+  contextMessages?: number;
+  role?: "user" | "assistant" | "tool" | "system";
+  includeTools?: boolean;
+};
+
+const MAX_LIMIT = 10;
+const MAX_CONTEXT_MESSAGES = 3;
+const MAX_CONTENT_CHARS = 1800;
+const CONTEXT_CONTENT_CHARS = 600;
+const SERVER_SCAN_LIMIT = 500;
+
+const getMessageSortValue = (message: DialogMessageSearchRecord) => {
+  const createdAt = message.createdAt;
+  if (typeof createdAt === "number") return createdAt;
+  if (typeof createdAt === "string") {
+    const parsed = Date.parse(createdAt);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  const id = normalizeDialogSearchText(message.id);
+  return id ? id : normalizeDialogSearchText(message.dbKey);
+};
+
+async function collectDialogMessages(db: any, dialogId: string): Promise<DialogMessageSearchRecord[]> {
+  if (!db?.iterator) return [];
+  const prefix = `dialog-${dialogId}-msg-`;
+  let iterator = db.iterator({
+    gte: prefix,
+    lte: `${prefix}\uffff`,
+  });
+  if (iterator && typeof iterator.then === "function") {
+    iterator = await iterator;
+  }
+
+  const messages: DialogMessageSearchRecord[] = [];
+  for await (const [key, value] of iterator) {
+    if (!value || typeof value !== "object") continue;
+    messages.push({
+      ...(value as DialogMessageSearchRecord),
+      dbKey: (value as DialogMessageSearchRecord).dbKey || String(key),
+    });
+  }
+
+  return messages.sort((a, b) => {
+    const left = getMessageSortValue(a);
+    const right = getMessageSortValue(b);
+    if (typeof left === "number" && typeof right === "number") return left - right;
+    return String(left).localeCompare(String(right));
+  });
+}
+
+async function fetchDialogMessagesFromServer(args: {
+  serverBase: string;
+  token?: string;
+  dialogId: string;
+  limit: number;
+}): Promise<DialogMessageSearchRecord[]> {
+  const serverBase = args.serverBase.replace(/\/+$/, "");
+  if (!serverBase || !args.token) return [];
+
+  const response = await fetch(`${serverBase}/rpc/getConvMsgs`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${args.token}`,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({ dialogId: args.dialogId, limit: args.limit }),
+  });
+  if (!response.ok) return [];
+
+  const newestFirst = await response.json();
+  if (!Array.isArray(newestFirst)) return [];
+  return [...newestFirst].reverse().map((message) => ({
+    ...(message as DialogMessageSearchRecord),
+    dbKey: (message as DialogMessageSearchRecord).dbKey,
+  }));
+}
+
+async function collectBestAvailableDialogMessages(
+  db: any,
+  dialogId: string,
+  thunkApi: any,
+  scanLimit: number,
+): Promise<DialogMessageSearchRecord[]> {
+  const localMessages = await collectDialogMessages(db, dialogId);
+  const state = thunkApi?.getState?.();
+  const runtime = state ? selectRuntimeSnapshot(state) : null;
+  const serverBases = Array.from(new Set([
+    runtime?.localRuntimeOrigin,
+    runtime?.currentServer,
+    ...(Array.isArray(runtime?.syncServers) ? runtime.syncServers : []),
+  ].filter((base): base is string => typeof base === "string" && base.trim().length > 0)));
+
+  let bestMessages = localMessages;
+  for (const serverBase of serverBases) {
+    const serverMessages = await fetchDialogMessagesFromServer({
+      serverBase,
+      token: runtime?.currentToken,
+      dialogId,
+      limit: scanLimit,
+    }).catch(() => []);
+    if (serverMessages.length > bestMessages.length) {
+      bestMessages = serverMessages;
+    }
+  }
+
+  return bestMessages;
+}
+
+export const searchDialogMessagesFunctionSchema = {
+  name: "searchDialogMessages",
+  description: [
+    "Search original messages inside a specific dialog by exact or fuzzy text.",
+    "Use this when a user asks for an exact old message, original wording, who said what, why a decision was made, early-history detail, failed attempts, files or tool evidence, or comparison with prior work from an attached conversation.",
+    "Prefer this over answering from a lossy dialog summary when the user needs evidence, provenance, or a specific prior detail.",
+    "Returns matching message ids, roles, clipped original content, and nearby context without loading the full dialog into the model context.",
+  ].join(" "),
+  parameters: {
+    type: "object",
+    properties: {
+      dialogKey: {
+        type: "string",
+        description: "Dialog dbKey, for example dialog-userId-01ABC...",
+      },
+      query: {
+        type: "string",
+        description: "Text to search for in original message content.",
+      },
+      limit: {
+        type: "number",
+        description: `Maximum matches to return. Capped at ${MAX_LIMIT}.`,
+      },
+      scanLimit: {
+        type: "number",
+        description: `Maximum messages to scan when fetching from a server. Capped at ${SERVER_SCAN_LIMIT}.`,
+      },
+      contextMessages: {
+        type: "number",
+        description: `Number of neighboring messages before/after each match. Capped at ${MAX_CONTEXT_MESSAGES}.`,
+      },
+      role: {
+        type: "string",
+        enum: ["user", "assistant", "tool", "system"],
+        description: "Optional role filter.",
+      },
+      includeTools: {
+        type: "boolean",
+        description: "Whether tool messages may match. Defaults to true.",
+      },
+    },
+    required: ["dialogKey", "query"],
+  },
+};
+
+export async function searchDialogMessagesFunc(
+  args: SearchDialogMessagesArgs,
+  _thunkApi: any,
+  context?: { db?: any }
+) {
+  const dialogKey = normalizeDialogSearchText(args?.dialogKey);
+  const query = normalizeDialogSearchText(args?.query);
+  if (!dialogKey.startsWith("dialog-")) {
+    throw new Error("searchDialogMessages requires a dialog-* dbKey.");
+  }
+  if (!query) {
+    throw new Error("searchDialogMessages requires a non-empty query.");
+  }
+
+  const db = context?.db ?? _thunkApi?.extra?.db;
+  if (!db) {
+    throw new Error("searchDialogMessages cannot access the local message database.");
+  }
+
+  const dialogId = extractCustomId(dialogKey) || dialogKey.split("-").at(-1) || "";
+  const scanLimit = clampDialogSearchNumber(
+    args.scanLimit,
+    SERVER_SCAN_LIMIT,
+    1,
+    SERVER_SCAN_LIMIT,
+  );
+  const messages = await collectBestAvailableDialogMessages(db, dialogId, _thunkApi, scanLimit);
+  const limit = clampDialogSearchNumber(args.limit, 5, 1, MAX_LIMIT);
+  const contextMessages = clampDialogSearchNumber(args.contextMessages, 1, 0, MAX_CONTEXT_MESSAGES);
+
+  const results = buildDialogMessageSearchResults({
+    messages,
+    query,
+    limit,
+    contextMessages,
+    role: args.role,
+    includeTools: args.includeTools,
+    contentClipChars: MAX_CONTENT_CHARS,
+    contextClipChars: CONTEXT_CONTENT_CHARS,
+  });
+
+  const displayData = formatDialogMessageSearchDisplay({ dialogKey, query, results });
+
+  return {
+    rawData: {
+      success: true,
+      dialogKey,
+      query,
+      scannedMessages: messages.length,
+      matches: results,
+    },
+    displayData,
+  };
+}

package/ai/tools/searchWorkspaceTool.ts

@@ -0,0 +1,259 @@
+// ai/tools/searchWorkspaceTool.ts
+
+import {
+  buildMyContentItemsFromUserData,
+  MY_CONTENT_USER_DATA_TYPES,
+  type MyContentListItem,
+} from "../../app/utils/myContentItems";
+import type { SpaceContent, SpaceData, SpaceMemberWithSpaceInfo } from "../../app/types";
+import { fetchUserData } from "../../database/client/fetchUserData";
+import { getUserDataItemTimestamp, mergeAndDedupUserData } from "../../database/userDataMerge";
+
+type SearchWorkspaceArgs = { query: string };
+
+type SearchWorkspaceResultItem = {
+  title: string;
+  type: string;
+  contentKey: string;
+  spaceId: string | null;
+  spaceName?: string;
+  createdAt?: string | number;
+  updatedAt?: string | number;
+  serverOrigin?: string;
+};
+
+type SearchWorkspaceResult = {
+  rawData: { success: true; contents: SearchWorkspaceResultItem[] };
+  displayData: string;
+};
+
+type SearchWorkspaceState = {
+  auth?: {
+    currentUser?: {
+      userId?: string | null;
+    } | null;
+  };
+  settings?: {
+    currentServer?: string;
+  };
+  space: {
+    currentSpaceId: string | null;
+    currentSpace: SpaceData | null;
+    memberSpaces: SpaceMemberWithSpaceInfo[] | null;
+  };
+};
+
+type SearchWorkspaceThunkApi = {
+  getState: () => SearchWorkspaceState;
+  dispatch: (action: unknown) => unknown;
+  extra: {
+    db: any | null;
+    tokenManager: any | null;
+  };
+};
+
+const selectCurrentSpaceIdFromState = (state: SearchWorkspaceState) =>
+  state.space.currentSpaceId;
+
+const selectCurrentSpaceFromState = (state: SearchWorkspaceState) =>
+  state.space.currentSpace;
+
+const selectAllMemberSpacesFromState = (state: SearchWorkspaceState) => {
+  const memberSpaces = state.space.memberSpaces ?? [];
+  return [...memberSpaces].sort((a, b) => {
+    const aUpdatedAt =
+      a.spaceUpdatedAt ??
+      (a as any).memberUpdatedAt ??
+      (a as any).updatedAt ??
+      (a as any).createdAt ??
+      a.joinedAt ??
+      0;
+    const bUpdatedAt =
+      b.spaceUpdatedAt ??
+      (b as any).memberUpdatedAt ??
+      (b as any).updatedAt ??
+      (b as any).createdAt ??
+      b.joinedAt ??
+      0;
+    return bUpdatedAt - aUpdatedAt;
+  });
+};
+
+export const searchWorkspaceFunctionSchema = {
+  name: "search_workspace",
+  description: "在当前空间（Workspace）中搜索页面、表格等内容。",
+  parameters: {
+    type: "object",
+    properties: {
+      query: {
+        type: "string",
+        description: "搜索关键词。将匹配标题和文件名。",
+      },
+    },
+    required: ["query"],
+  },
+};
+
+export const searchAllSpacesFunctionSchema = {
+  name: "search_all_spaces",
+  description:
+    "在当前设备已同步的全部内容中搜索当前用户的数据（等同于全部视图 Recent 的内容语义），并返回所属空间（如有）。",
+  parameters: searchWorkspaceFunctionSchema.parameters,
+};
+
+const normalizeQuery = (value: unknown) => String(value || "").trim().toLowerCase();
+
+const toSearchResultItem = (
+  item:
+    | Pick<
+        MyContentListItem,
+        "title" | "type" | "contentKey" | "spaceId" | "spaceName" | "createdAt" | "updatedAt" | "serverOrigin"
+      >
+    | (SpaceContent & { spaceId: string; spaceName?: string })
+): SearchWorkspaceResultItem => ({
+  title: String(item.title || item.contentKey || "").trim(),
+  type: String(item.type || "").trim(),
+  contentKey: String(item.contentKey || "").trim(),
+  spaceId: item.spaceId ?? null,
+  ...(item.spaceName ? { spaceName: item.spaceName } : {}),
+  ...(item.createdAt !== undefined ? { createdAt: item.createdAt } : {}),
+  ...(item.updatedAt !== undefined ? { updatedAt: item.updatedAt } : {}),
+  ...(typeof item.serverOrigin === "string" && item.serverOrigin.trim().length > 0
+    ? { serverOrigin: item.serverOrigin }
+    : {}),
+});
+
+const searchSpaceContents = (
+  space: SpaceData,
+  query: string,
+  options?: { spaceName?: string }
+): SearchWorkspaceResultItem[] => {
+  const kw = normalizeQuery(query);
+  const allContents = Object.values(space.contents || {});
+
+  return allContents
+    .filter((content): content is SpaceContent => {
+      if (!content) return false;
+      const titleMatch = (content.title ?? "").toLowerCase().includes(kw);
+      const keyMatch = (content.contentKey ?? "").toLowerCase().includes(kw);
+      return titleMatch || keyMatch;
+    })
+    .map((content) =>
+      toSearchResultItem({
+        ...content,
+        spaceId: space.id,
+        ...(options?.spaceName ? { spaceName: options.spaceName } : {}),
+      })
+    );
+};
+
+const matchesMyContentSearch = (
+  query: string,
+  item: Pick<MyContentListItem, "title" | "type" | "spaceName" | "contentKey">
+) => {
+  const kw = normalizeQuery(query);
+  if (!kw) return false;
+  return [item.title, item.type, item.spaceName, item.contentKey].some((value) =>
+    normalizeQuery(value).includes(kw)
+  );
+};
+
+const buildScopedDisplayData = (
+  query: string,
+  results: SearchWorkspaceResultItem[],
+  scopeLabel: string
+) => {
+  if (results.length === 0) {
+    return `未能在${scopeLabel}中找到匹配 "${query}" 的内容。`;
+  }
+
+  const summary = results
+    .map((item) => {
+      const spaceSuffix = item.spaceName ? ` [${item.spaceName}]` : "";
+      return `- ${item.title} (${item.contentKey})${spaceSuffix}`;
+    })
+    .join("\n");
+
+  return `在${scopeLabel}中找到 ${results.length} 个匹配项：\n${summary}`;
+};
+
+const loadLocalMyContentResults = async (
+  thunkApi: SearchWorkspaceThunkApi,
+  state: SearchWorkspaceState
+): Promise<MyContentListItem[]> => {
+  const userId = state.auth?.currentUser?.userId?.trim();
+  if (!userId) {
+    throw new Error("无法搜索全部内容，因为当前用户未登录。");
+  }
+
+  const db = thunkApi.extra?.db;
+  if (!db) {
+    throw new Error("无法搜索全部内容，因为本地数据库不可用。");
+  }
+
+  const localResults = await fetchUserData(db, MY_CONTENT_USER_DATA_TYPES, userId, {
+    includeDeleted: true,
+  });
+  const dedupedRecords = mergeAndDedupUserData(Object.values(localResults).flat(), []);
+  const sortedRecords = [...dedupedRecords].sort(
+    (a, b) => getUserDataItemTimestamp(b) - getUserDataItemTimestamp(a)
+  );
+  const memberSpaces = selectAllMemberSpacesFromState(state);
+  const spaceNameById = new Map(
+    memberSpaces.map((space) => [space.spaceId, space.spaceName || space.spaceId] as const)
+  );
+
+  return buildMyContentItemsFromUserData(
+    sortedRecords,
+    state.settings?.currentServer || "",
+    spaceNameById,
+    "我的应用",
+    "我的内容"
+  );
+};
+
+/**
+ * [Executor] 'search_workspace' 工具的执行函数。
+ */
+export async function searchWorkspaceFunc(
+  args: SearchWorkspaceArgs,
+  thunkApi: SearchWorkspaceThunkApi
+): Promise<SearchWorkspaceResult> {
+  const { getState } = thunkApi;
+  const state = getState();
+  const spaceId = selectCurrentSpaceIdFromState(state);
+
+  if (!spaceId) {
+    throw new Error("无法查询内容，因为当前空间未设定。");
+  }
+
+  const currentSpace = selectCurrentSpaceFromState(state);
+  if (!currentSpace) {
+    throw new Error("当前空间数据未找到。");
+  }
+
+  const results = searchSpaceContents(currentSpace, args.query, {
+    spaceName: currentSpace.name,
+  });
+
+  const rawData = { success: true, contents: results };
+  const displayData = buildScopedDisplayData(args.query, results, "当前空间");
+
+  return { rawData, displayData };
+}
+
+export async function searchAllSpacesFunc(
+  args: SearchWorkspaceArgs,
+  thunkApi: SearchWorkspaceThunkApi
+): Promise<SearchWorkspaceResult> {
+  const state = thunkApi.getState();
+  const items = await loadLocalMyContentResults(thunkApi, state);
+  const results = items
+    .filter((item) => matchesMyContentSearch(args.query, item))
+    .map((item) => toSearchResultItem(item));
+
+  return {
+    rawData: { success: true, contents: results },
+    displayData: buildScopedDisplayData(args.query, results, "已同步的全部内容"),
+  };
+}