nolo-cli 0.1.8 → 0.1.9

package/ai/tools/updateUserPreferenceProfileTool.ts

@@ -0,0 +1,145 @@
+import { setSettings } from "app/settings/settingSlice";
+import type {
+  KnowledgeCaptureLevel,
+  SpaceContextLevel,
+  TonePreset,
+} from "ai/policy/types";
+import {
+  normalizeAgentUpdateFieldList,
+  type AgentUpdateField,
+} from "ai/policy/selfUpdateFields";
+
+export interface UpdateUserPreferenceProfileArgs {
+  userTonePreset?: TonePreset;
+  knowledgeCaptureLevel?: KnowledgeCaptureLevel;
+  spaceContextLevel?: SpaceContextLevel;
+  autoApproveSelfUpdateFields?: AgentUpdateField[];
+  globalPrompt?: string;
+  defaultAgentId?: string;
+  summary?: string;
+}
+
+export const updateUserPreferenceProfileFunctionSchema = {
+  name: "updateUserPreferenceProfile",
+  description: [
+    "当你已经明确收集到用户的个性化偏好时，使用本工具把这些偏好保存到用户设置里。",
+    "适用于保存 tone、knowledge capture、space context，以及用户的 global prompt / 自我介绍摘要。",
+    "只有在用户已经明确表达或确认后才调用；不要在信息不充分时猜测。",
+    "调用后，你应当用自然语言简要总结已保存的设置，并说明用户之后可以继续调整。",
+  ].join("\n"),
+  parameters: {
+    type: "object",
+    properties: {
+      userTonePreset: {
+        type: "string",
+        enum: ["default", "direct", "pragmatic", "friendly", "professional"],
+        description: "用户偏好的交流语气。",
+      },
+      knowledgeCaptureLevel: {
+        type: "integer",
+        enum: [1, 2, 3, 4],
+        description: "知识沉淀级别：1 不主动创建；2 先问再创建；3 回答后建议；4 高价值结果可自动创建。",
+      },
+      spaceContextLevel: {
+        type: "integer",
+        enum: [1, 2, 3, 4],
+        description: "空间上下文级别：1 不自动读取；2 只看结构和标题；3 轻量读取；4 自适应读取。",
+      },
+      autoApproveSelfUpdateFields: {
+        type: "array",
+        items: {
+          type: "string",
+          enum: [
+            "name",
+            "model",
+            "provider",
+            "prompt",
+            "introduction",
+            "greeting",
+            "isPublic",
+            "tags",
+            "tools",
+            "references",
+            "temperature",
+            "top_p",
+            "frequency_penalty",
+            "presence_penalty",
+            "max_tokens",
+            "reasoning_effort",
+          ],
+        },
+        description: "哪些 updateSelf 字段以后不再询问用户，直接自动通过。",
+      },
+      globalPrompt: {
+        type: "string",
+        description: "可选：用户希望长期保留的一小段通用偏好说明。未明确确认时不要写。",
+      },
+      defaultAgentId: {
+        type: "string",
+        description: "可选：用户明确要求切换首页默认 agent 时才填写。",
+      },
+      summary: {
+        type: "string",
+        description: "给开发和日志看的简短总结，不会影响设置本身。",
+      },
+    },
+  } as const,
+};
+
+export async function updateUserPreferenceProfileFunc(
+  args: UpdateUserPreferenceProfileArgs,
+  thunkApi: any
+): Promise<{ rawData: unknown; displayData: string }> {
+  const changes: Record<string, unknown> = {};
+
+  if (args.userTonePreset) {
+    changes.userTonePreset = args.userTonePreset;
+  }
+  if (typeof args.knowledgeCaptureLevel === "number") {
+    changes.knowledgeCaptureLevel = args.knowledgeCaptureLevel;
+  }
+  if (typeof args.spaceContextLevel === "number") {
+    changes.spaceContextLevel = args.spaceContextLevel;
+    changes.enableReadCurrentSpace = args.spaceContextLevel > 1;
+  }
+  if (Array.isArray(args.autoApproveSelfUpdateFields)) {
+    changes.autoApproveSelfUpdateFields = normalizeAgentUpdateFieldList(
+      args.autoApproveSelfUpdateFields,
+      []
+    );
+  }
+  if (typeof args.globalPrompt === "string" && args.globalPrompt.trim()) {
+    changes.globalPrompt = args.globalPrompt.trim();
+  }
+  if (typeof args.defaultAgentId === "string" && args.defaultAgentId.trim()) {
+    changes.defaultAgentId = args.defaultAgentId.trim();
+  }
+
+  if (Object.keys(changes).length === 0) {
+    throw new Error("没有可保存的用户偏好设置。");
+  }
+
+  await thunkApi.dispatch(setSettings(changes as any)).unwrap();
+
+  const rawData = {
+    success: true,
+    updated: changes,
+    summary: args.summary?.trim() || null,
+  };
+
+  const labels: string[] = [];
+  if (changes.userTonePreset) labels.push(`语气=${changes.userTonePreset}`);
+  if (changes.knowledgeCaptureLevel)
+    labels.push(`知识沉淀=${changes.knowledgeCaptureLevel}`);
+  if (changes.spaceContextLevel)
+    labels.push(`空间读取=${changes.spaceContextLevel}`);
+  if (changes.autoApproveSelfUpdateFields)
+    labels.push("自我更新免询问字段已更新");
+  if (changes.defaultAgentId) labels.push("默认助手已更新");
+  if (changes.globalPrompt) labels.push("通用提示词已更新");
+
+  return {
+    rawData,
+    displayData: `已保存用户偏好：${labels.join("，")}`,
+  };
+}

package/ai/tools/whisperTool.ts

@@ -0,0 +1,77 @@
+import { ToolDefinition } from ".";
+import { callToolApi } from "./toolApiClient";
+
+const SHARED_PARAMS = {
+  type: "object",
+  properties: {
+    audioUrl: {
+      type: "string",
+      description:
+        "音频来源：内部文件 ID (file-... 或 ULID)、公开 http/https URL，或 base64 data URI（data:audio/...;base64,...）。支持 mp3、wav、m4a、ogg、flac 等常见格式。",
+    },
+    language: {
+      type: "string",
+      description:
+        "可选，指定音频语言以提升精度（如 'zh'、'en'、'ja'）。不指定则自动检测。",
+    },
+  },
+  required: ["audioUrl"],
+};
+
+// ── whisper-large-v3-turbo（快速、便宜）──────────────────
+
+export const whisperTurboSchema = {
+  name: "whisper_turbo",
+  description:
+    "使用 openai/whisper-large-v3-turbo 对音频进行语音转文字（ASR）。速度快、价格低（$0.0002/min），适合大多数场景的实时或批量转录。",
+  parameters: SHARED_PARAMS,
+};
+
+export const whisperTurboFunc: ToolDefinition["executor"] = async (
+  input: any,
+  thunkApi
+) => {
+  const { audioUrl, language } = input;
+  const data = await callToolApi(
+    thunkApi,
+    "/api/whisper-turbo",
+    { audioUrl, language },
+    { withAuth: true }
+  );
+  return {
+    summary: "Transcription completed",
+    text: data.text || "",
+    language: data.language,
+    duration: data.duration,
+    rawData: data,
+  };
+};
+
+// ── whisper-large-v3（高精度）────────────────────────────
+
+export const whisperV3Schema = {
+  name: "whisper_v3",
+  description:
+    "使用 openai/whisper-large-v3 对音频进行高精度语音转文字（ASR）。精度更高（尤其多语言/中文），价格稍高（$0.00045/min），适合对准确率要求严格的场景。",
+  parameters: SHARED_PARAMS,
+};
+
+export const whisperV3Func: ToolDefinition["executor"] = async (
+  input: any,
+  thunkApi
+) => {
+  const { audioUrl, language } = input;
+  const data = await callToolApi(
+    thunkApi,
+    "/api/whisper-v3",
+    { audioUrl, language },
+    { withAuth: true }
+  );
+  return {
+    summary: "Transcription completed",
+    text: data.text || "",
+    language: data.language,
+    duration: data.duration,
+    rawData: data,
+  };
+};

package/ai/tools/writeFileTool.ts

@@ -0,0 +1,210 @@
+// 文件路径: packages/ai/tools/writeFileTool.ts
+
+import { bumpDevReloadSuppressIfSelfEditing } from "./devReloadUtils";
+import { getToolBaseUrl } from "./toolApiClient";
+
+// ---- Types ----
+
+export type WriteFileArgs = {
+    /**
+     * 目标文件相对项目根目录（bun-nolo）的路径，例如：
+     * - packages/chat/src/messages/web/NewComponent.tsx
+     * - packages/server/some-script.ts
+     */
+    filePath: string;
+    /**
+     * 要写入文件的完整内容。
+     * - 如果文件不存在：将创建新文件，并写入该内容；
+     * - 如果文件已存在：
+     *   - overwrite = true：覆盖原有内容；
+     *   - overwrite 未设置或为 false：请求会失败。
+     */
+    content: string;
+    overwrite?: boolean;
+};
+
+// ---- 工具 Schema，供 LLM 调用 ----
+
+export const writeFileFunctionSchema = {
+    name: "writeFile",
+    description: [
+        "在后端服务器上写入一个完整文件的内容，可用于新建文件或覆盖已有文件。",
+        "",
+        "适用场景：",
+        "- 新建一个全新的代码文件（例如新组件、新工具函数、配置文件等）",
+        "- 覆盖一个文件的全部内容（当你需要重写整个文件时）",
+        "",
+        "行为约定：",
+        "- 当目标文件不存在：直接创建新文件并写入 content。",
+        "- 当目标文件已存在：",
+        "  - 如果 overwrite=true，则覆盖原文件内容；",
+        "  - 否则请求会失败，以避免意外覆盖。",
+        "",
+        "返回数据约定（rawData.response 中）：",
+        "- created / overwritten：指示本次操作是新建还是覆盖。",
+        "- newContent：写入后的完整文件内容（统一使用 \\n 作为换行符），用于 UI 中的代码预览。",
+        "- diff：如果文件原本存在，则返回基于旧内容与 newContent 的行级 diff（diffLines 结果），用于 UI 中的 Diff 视图。",
+        "",
+        "注意：",
+        "- filePath 必须是相对项目根目录（bun-nolo）的相对路径，且不能越出项目根目录。",
+        "- 建议只在“新建文件/全量重写”时使用本工具；修改部分内容时优先使用 applyEdit。",
+        "- 如果用户给了 URL 或网页资料来驱动本次改动，先抓取网页并核对字段，再决定是否需要整文件覆盖。",
+    ].join("\n"),
+    parameters: {
+        type: "object",
+        properties: {
+            filePath: {
+                type: "string",
+                description:
+                    "目标文件相对项目根目录（bun-nolo）的路径，例如: packages/chat/src/messages/web/NewComponent.tsx",
+            },
+            content: {
+                type: "string",
+                description:
+                    "要写入文件的完整内容。对于新建文件，就是文件的全部内容；对于覆盖已有文件，会用该内容替换原内容。",
+            },
+            overwrite: {
+                type: "boolean",
+                description:
+                    "是否允许覆盖已存在的文件。缺省或为 false 时，如果文件已存在将报错；true 时允许覆盖。",
+            },
+        },
+        required: ["filePath", "content"],
+    },
+};
+
+// ---- 预览执行：不写文件，只展示信息 ----
+
+export async function writeFilePreviewFunc(
+    args: WriteFileArgs,
+    _thunkApi: any
+): Promise<{ rawData: any; displayData?: string }> {
+    const { filePath, content, overwrite } = args;
+
+    if (!filePath || typeof filePath !== "string") {
+        throw new Error("writeFile 预览失败：必须提供有效的 filePath 字符串。");
+    }
+    if (typeof content !== "string") {
+        throw new Error("writeFile 预览失败：content 必须是字符串。");
+    }
+
+    const mode = overwrite ? "允许覆盖（已存在则覆盖）" : "仅新建（已存在则报错）";
+    const lengthInfo = `内容长度: ${content.length} 个字符`;
+
+    return {
+        rawData: {
+            previewOnly: true,
+            filePath,
+            overwrite: !!overwrite,
+            content,
+        },
+        displayData: `⏸️ 文件写入预览: ${filePath}（模式: ${mode}，${lengthInfo}）`,
+    };
+}
+
+// ---- 真正执行：POST 到后端 /api/write-file ----
+
+export async function writeFileFunc(
+    args: WriteFileArgs,
+    thunkApi: any,
+    context?: { parentMessageId?: string; signal?: AbortSignal }
+): Promise<{ rawData: any; displayData?: string }> {
+    const { filePath, content, overwrite } = args;
+
+    if (!filePath || typeof filePath !== "string") {
+        throw new Error("写入文件失败：必须提供有效的 filePath 字符串。");
+    }
+    if (typeof content !== "string") {
+        throw new Error("写入文件失败：content 必须是字符串。");
+    }
+
+    try {
+        const baseUrl = getToolBaseUrl(thunkApi);
+
+        if (!baseUrl) {
+            throw new Error("写入文件失败：无法获取 writeFile 服务器地址。");
+        }
+
+        const apiUrl = `${baseUrl.replace(/\/+$/, "")}/api/write-file`;
+
+        // 自举写入前增加 reload 抑制
+        bumpDevReloadSuppressIfSelfEditing(filePath);
+
+        const response = await fetch(apiUrl, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            signal: context?.signal,
+            body: JSON.stringify({ filePath, content, overwrite }),
+        });
+
+        const status = response.status;
+        const textBody = await response.text();
+        let data: any = {};
+        try {
+            data = textBody ? JSON.parse(textBody) : {};
+        } catch {
+            // 非 JSON 的情况忽略解析错误
+        }
+
+        // 409：文件已存在但未允许覆盖 → 视为“写入冲突”，不抛异常
+        if (status === 409) {
+            const serverMsg =
+                data?.error ||
+                "写入文件失败：目标文件已存在，且 overwrite 未设置为 true。";
+
+            return {
+                rawData: {
+                    applied: false,
+                    conflict: true,
+                    fileExists: true,
+                    filePath,
+                    overwrite: !!overwrite,
+                    serverMessage: serverMsg,
+                },
+                displayData: [
+                    "⏸️ 检测到目标文件已存在，暂未写入。",
+                    `- filePath: ${filePath}`,
+                    `- 服务器消息: ${serverMsg}`,
+                    "",
+                    "如需覆盖，请在下一次调用 writeFile 时显式设置 overwrite: true。",
+                ].join("\n"),
+            };
+        }
+
+        if (!response.ok || data?.error) {
+            const errMsg =
+                data?.error ||
+                `writeFile API 请求失败，状态码: ${status}. 响应: ${textBody}`;
+            console.error("writeFile API Error:", errMsg);
+            throw new Error(errMsg);
+        }
+
+        const created: boolean | undefined = data?.created;
+        const overwrittenFlag: boolean | undefined = data?.overwritten;
+
+        let actionDesc = "写入";
+        if (created === true) {
+            actionDesc = "新建";
+        } else if (overwrittenFlag === true) {
+            actionDesc = "覆盖";
+        }
+
+        return {
+            rawData: {
+                applied: true,
+                filePath,
+                overwrite: !!overwrite,
+                // 把这次写入的原始内容也附带上，方便调试
+                content,
+                // 服务端返回的详细结果（包括 newContent / diff 等）
+                response: data,
+            },
+            displayData: `✅ 已成功${actionDesc}文件: ${filePath}`,
+        };
+    } catch (error: any) {
+        console.error("执行 writeFile 时发生错误:", error);
+        throw new Error(
+            `写入文件 (${filePath}) 失败：${error?.message || String(error)}`
+        );
+    }
+}

package/ai/tools/youtubeScraperTool.ts

@@ -0,0 +1,116 @@
+// /ai/tools/youtubeScraperTool.ts
+
+import { callApifyActor } from "./apifyActorClient";
+
+export const youtubeScraperFunctionSchema = {
+  name: "youtubeScraper",
+  description:
+    "使用 Apify 的 YouTube Scraper 抓取 YouTube 视频、频道、播放列表等信息。支持 Direct URLs 或搜索关键词。",
+  parameters: {
+    type: "object",
+    properties: {
+      directUrls: {
+        type: "array",
+        description:
+          "可选。视频/频道/播放列表等 URL 列表，将映射到 startUrls。",
+        items: { type: "string" },
+      },
+      searchQueries: {
+        type: "array",
+        description: "可选。搜索关键词数组，将映射到 searchQueries。",
+        items: { type: "string" },
+      },
+      maxResults: { type: "integer", minimum: 0 },
+      maxResultsShorts: { type: "integer", minimum: 0 },
+      maxResultStreams: { type: "integer", minimum: 0 },
+      downloadSubtitles: { type: "boolean" },
+      subtitlesLanguage: {
+        type: "string",
+        enum: [
+          "any",
+          "en",
+          "de",
+          "es",
+          "fr",
+          "it",
+          "ja",
+          "ko",
+          "nl",
+          "pt",
+          "ru",
+        ],
+      },
+      subtitlesFormat: {
+        type: "string",
+        enum: ["srt", "vtt", "xml", "plaintext"],
+      },
+      extraInput: {
+        type: "object",
+        description: "可选。直接透传给 Apify 的额外 input 字段，方便扩展。",
+      },
+    },
+    required: [],
+  },
+};
+
+export async function youtubeScraperFunc(
+  args: {
+    directUrls?: string[];
+    searchQueries?: string[];
+    maxResults?: number;
+    maxResultsShorts?: number;
+    maxResultStreams?: number;
+    downloadSubtitles?: boolean;
+    subtitlesLanguage?: string;
+    subtitlesFormat?: string;
+    extraInput?: Record<string, any>;
+  },
+  thunkApi: any
+) {
+  const {
+    directUrls,
+    searchQueries,
+    maxResults,
+    maxResultsShorts,
+    maxResultStreams,
+    downloadSubtitles,
+    subtitlesLanguage,
+    subtitlesFormat,
+    extraInput = {},
+  } = args;
+
+  if (
+    (!directUrls || directUrls.length === 0) &&
+    (!searchQueries || searchQueries.length === 0)
+  ) {
+    throw new Error(
+      "YouTube 抓取：至少提供 directUrls 或 searchQueries 之一。"
+    );
+  }
+
+  const input: any = {
+    ...extraInput,
+  };
+
+  if (searchQueries?.length) input.searchQueries = searchQueries;
+  if (directUrls?.length) input.startUrls = directUrls.map((url) => ({ url }));
+
+  if (typeof maxResults === "number") input.maxResults = maxResults;
+  if (typeof maxResultsShorts === "number")
+    input.maxResultsShorts = maxResultsShorts;
+  if (typeof maxResultStreams === "number")
+    input.maxResultStreams = maxResultStreams;
+  if (typeof downloadSubtitles === "boolean")
+    input.downloadSubtitles = downloadSubtitles;
+  if (typeof subtitlesLanguage === "string")
+    input.subtitlesLanguage = subtitlesLanguage;
+  if (typeof subtitlesFormat === "string")
+    input.subtitlesFormat = subtitlesFormat;
+
+  return callApifyActor(thunkApi, {
+    actorId: "streamers~youtube-scraper",
+    input,
+    resultType: "datasetItems",
+    displayName: "YouTube Scraper",
+  });
+}