nolo-cli 0.1.39 → 0.1.41

package/ai/tools/googleSearchScraperTool.ts

@@ -0,0 +1,106 @@
+// /ai/tools/googleSearchScraperTool.ts
+// Apify Google Search Results Scraper
+// Actor: https://apify.com/apify/google-search-scraper
+
+import { callApifyActor } from "./apifyActorClient";
+
+export const googleSearchScraperFunctionSchema = {
+  name: "googleSearchScraper",
+  description:
+    "通过 Apify 的 Google Search Scraper 抓取 Google 搜索结果（SERP），" +
+    "返回自然结果、付费广告、People Also Ask、相关搜索等结构化数据。" +
+    "适合需要获取真实 Google 搜索排名和摘要的场景。" +
+    "与 exa_search 的区别：此工具返回的是真实 Google SERP 数据，exa_search 是语义搜索引擎。",
+  parameters: {
+    type: "object",
+    properties: {
+      queries: {
+        type: "array",
+        items: { type: "string" },
+        description: "要搜索的关键词列表，每个元素对应一次 Google 搜索。",
+      },
+      maxPagesPerQuery: {
+        type: "integer",
+        description: "每个关键词抓取的搜索结果页数（默认 1，建议不超过 3）。",
+        default: 1,
+      },
+      resultsPerPage: {
+        type: "integer",
+        description: "每页结果数量（默认 10，最大 100）。",
+        default: 10,
+      },
+      languageCode: {
+        type: "string",
+        description: "搜索语言代码，如 'zh-CN'（中文）、'en'（英文）、'ja'（日文）等。",
+      },
+      countryCode: {
+        type: "string",
+        description: "搜索国家/地区代码，如 'cn'（中国）、'us'（美国）、'jp'（日本）等。",
+      },
+      mobileResults: {
+        type: "boolean",
+        description: "是否模拟移动端搜索（默认 false）。",
+        default: false,
+      },
+      includeUnfilteredResults: {
+        type: "boolean",
+        description: "是否包含未过滤的补充结果（默认 false）。",
+        default: false,
+      },
+      saveHtml: {
+        type: "boolean",
+        description: "是否同时保存原始 HTML（默认 false）。",
+        default: false,
+      },
+    },
+    required: ["queries"],
+  },
+};
+
+export async function googleSearchScraperFunc(
+  args: {
+    queries: string[];
+    maxPagesPerQuery?: number;
+    resultsPerPage?: number;
+    languageCode?: string;
+    countryCode?: string;
+    mobileResults?: boolean;
+    includeUnfilteredResults?: boolean;
+    saveHtml?: boolean;
+  },
+  thunkApi: any
+) {
+  const {
+    queries,
+    maxPagesPerQuery = 1,
+    resultsPerPage = 10,
+    languageCode,
+    countryCode,
+    mobileResults = false,
+    includeUnfilteredResults = false,
+    saveHtml = false,
+  } = args;
+
+  if (!queries || queries.length === 0) {
+    throw new Error("Google 搜索：必须提供至少一个搜索关键词（queries）。");
+  }
+
+  const input: Record<string, any> = {
+    queries: queries.join("\n"),
+    maxPagesPerQuery,
+    resultsPerPage,
+    mobileResults,
+    includeUnfilteredResults,
+    saveHtml,
+  };
+
+  if (languageCode) input.languageCode = languageCode;
+  if (countryCode) input.countryCode = countryCode;
+
+  return callApifyActor(thunkApi, {
+    actorId: "apify/google-search-scraper",
+    input,
+    resultType: "datasetItems",
+    displayName: "Google Search Scraper",
+  });
+}

package/ai/tools/importDataTool.ts

@@ -0,0 +1,133 @@
+// /ai/tools/importDataTool.ts
+
+import type { RootState } from "../../app/store";
+import { executeSqlFunc } from "./executeSqlTool";
+import { selectPendingRawDataByPageKey } from "../../chat/dialog/dialogSlice";
+
+// importDataFunctionSchema 保持不变
+export const importDataFunctionSchema = {
+  name: "importData",
+  description:
+    "将用户在当前消息中附带的文件内容，导入到指定的数据库表中。必须使用 `User's Current References` 上下文中的 `DB Key` 作为 `fileReferenceId`。",
+  parameters: {
+    type: "object",
+    properties: {
+      tableName: {
+        type: "string",
+        description:
+          "数据要导入的目标数据库表的名称。例如：'budgets', 'sales_records'。",
+      },
+      fileReferenceId: {
+        type: "string",
+        description:
+          "必须是从 `User's Current References` 上下文中获取到的、文件的 DB Key (例如 'page:xyz123')。",
+      },
+    },
+    required: ["tableName", "fileReferenceId"],
+  },
+};
+
+/**
+ * [Executor] 'importData' 工具的执行函数。
+ * @param args - LLM 提供的参数: { tableName: string, fileReferenceId: string }
+ * @param thunkApi - Redux Thunk API
+ * @returns {Promise<{rawData: any, displayData: string}>} - 返回标准化的结果对象
+ */
+export async function importDataFunc(
+  args: { tableName: string; fileReferenceId: string },
+  thunkApi: any
+): Promise<{ rawData: any; displayData: string }> {
+  const { tableName, fileReferenceId: pageKey } = args;
+
+  if (!tableName || !pageKey) {
+    throw new Error("`tableName` 和 `fileReferenceId` 都是必需的参数。");
+  }
+
+  try {
+    const state = thunkApi.getState() as RootState;
+
+    const pendingData = selectPendingRawDataByPageKey(state, pageKey);
+
+    if (!pendingData || !pendingData.jsonData) {
+      throw new Error(`在内存中找不到文件 (ID: ${pageKey}) 的数据。`);
+    }
+
+    const jsonData = pendingData.jsonData;
+    if (!Array.isArray(jsonData) || jsonData.length === 0) {
+      return { rawData: {}, displayData: "文件数据为空，未执行导入操作。" };
+    }
+
+    // [关键修复] 步骤 1: 查询数据库以获取真实的列名和大小写
+    const schemaInfoResult = await executeSqlFunc(
+      { sqlQuery: `PRAGMA table_info("${tableName}");` },
+      thunkApi
+    );
+
+    if (
+      !schemaInfoResult.rawData?.result ||
+      schemaInfoResult.rawData.result.length === 0
+    ) {
+      throw new Error(
+        `无法获取表 "${tableName}" 的结构信息，请检查表是否存在。`
+      );
+    }
+
+    // 从 PRAGMA 结果中提取数据库中的真实列名
+    const dbColumns = schemaInfoResult.rawData.result.map(
+      (col: any) => col.name
+    );
+
+    // [关键修复] 步骤 2: 创建从“小写键名”到“原始数据键名”的映射
+    // 这使得我们可以忽略大小写来匹配列
+    const inputKeys = Object.keys(jsonData[0]);
+    const inputKeyMap = new Map(
+      inputKeys.map((key) => [key.toLowerCase(), key])
+    );
+
+    // [关键修复] 步骤 3: 准备基于真实数据库列名的 INSERT 语句
+    const columnNamesForSql = dbColumns.map((col) => `"${col}"`).join(", ");
+    const valuePlaceholders = `(${dbColumns.map(() => "?").join(", ")})`;
+    const insertQueryTemplate = `INSERT INTO "${tableName}" (${columnNamesForSql}) VALUES ${valuePlaceholders};`;
+
+    let totalAffectedRows = 0;
+
+    await executeSqlFunc({ sqlQuery: "BEGIN TRANSACTION;" }, thunkApi);
+    try {
+      for (const row of jsonData) {
+        // [关键修复] 步骤 4: 按数据库列的顺序，不区分大小写地从数据行中提取值
+        const params = dbColumns.map((dbCol) => {
+          const originalInputKey = inputKeyMap.get(dbCol.toLowerCase());
+          // 如果在输入数据中找到了匹配的列（忽略大小写），则使用其值
+          if (originalInputKey) {
+            return row[originalInputKey] ?? null;
+          }
+          // 如果数据库有这个列，但输入数据没有，则插入 NULL
+          return null;
+        });
+
+        const result = await executeSqlFunc(
+          { sqlQuery: insertQueryTemplate, params },
+          thunkApi
+        );
+        totalAffectedRows += result.rawData?.result?.changes ?? 0;
+      }
+      await executeSqlFunc({ sqlQuery: "COMMIT;" }, thunkApi);
+    } catch (innerError) {
+      await executeSqlFunc({ sqlQuery: "ROLLBACK;" }, thunkApi);
+      throw innerError;
+    }
+
+    const displayData = `成功将文件中的 ${jsonData.length} 条记录导入到表 "${tableName}"。总共影响行数: ${totalAffectedRows}。`;
+
+    return {
+      rawData: {
+        importedCount: jsonData.length,
+        affectedRows: totalAffectedRows,
+      },
+      displayData,
+    };
+  } catch (error: any) {
+    console.error("Import Data tool error:", error);
+    throw new Error(`数据导入失败: ${error.message}`);
+  }
+}

package/ai/tools/importSkillTool.ts

@@ -0,0 +1,162 @@
+import { createDoc } from "../../render/page/docSlice";
+import { selectCurrentSpaceId } from "../../create/space/spaceSlice";
+import type { RootState } from "../../app/store";
+import { canonicalizeToolNames } from "./toolNameAliases";
+import {
+  buildSkillDocMarkdown,
+  parseExternalSkillMarkdown,
+  type SkillDocConfig,
+} from "../skills/skillDocProtocol";
+import { buildSkillFollowupResult } from "./skillFollowup";
+
+export interface ImportSkillToolArgs {
+  url?: string;
+  content?: string;
+  title?: string;
+  spaceId?: string;
+  categoryId?: string;
+}
+
+const normalizeUrl = (rawUrl: string): string => {
+  const trimmed = rawUrl.trim();
+  const githubBlobMatch = trimmed.match(
+    /^https:\/\/github\.com\/([^/]+)\/([^/]+)\/blob\/([^/]+)\/(.+)$/
+  );
+  if (githubBlobMatch) {
+    const [, owner, repo, ref, path] = githubBlobMatch;
+    return `https://raw.githubusercontent.com/${owner}/${repo}/${ref}/${path}`;
+  }
+  return trimmed;
+};
+
+const slugify = (value: string): string =>
+  value
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "") || "imported-skill";
+
+const mapImportedTools = (toolNames: string[]): string[] =>
+  canonicalizeToolNames(
+    toolNames.filter((toolName) => /^[a-zA-Z0-9_-]+$/.test(toolName))
+  );
+
+export const importSkillFunctionSchema = {
+  name: "importSkill",
+  description: [
+    "从外部 SKILL.md、GitHub 地址或原始 Markdown 文本导入一个 skill，并保存为当前空间中的普通文档。",
+    "导入后会自动附加隐藏的 skill-config 协议块；无法映射的脚本环境会降级为说明型 skill。",
+    "导入成功后，如果用户还没说明下一步，优先调用 ui_ask_choice 继续询问：仅保存、挂到现有 Agent，还是新建一个 Agent 来使用它。",
+  ].join("\n"),
+  parameters: {
+    type: "object",
+    properties: {
+      url: {
+        type: "string",
+        description:
+          "可选：远程 SKILL.md 地址。支持 raw GitHub URL，也支持 github.com/.../blob/... 链接。",
+      },
+      content: {
+        type: "string",
+        description:
+          "可选：原始 SKILL.md 或普通 Markdown 内容。如果提供，则优先使用它而不是 url。",
+      },
+      title: {
+        type: "string",
+        description: "可选：导入后文档标题。未提供时优先使用外部 skill name。",
+      },
+      spaceId: {
+        type: "string",
+        description: '可选：目标 spaceId；不传则优先使用当前 space。可传空字符串 ""。',
+      },
+      categoryId: {
+        type: "string",
+        description: '可选：目标分类 categoryId；不传时传空字符串 ""。',
+      },
+    },
+  } as const,
+};
+
+export async function importSkillFunc(
+  args: ImportSkillToolArgs,
+  thunkApi: any
+): Promise<{ rawData: unknown; displayData: string }> {
+  const { dispatch, getState } = thunkApi;
+  const state = getState() as RootState;
+  const explicitContent = typeof args.content === "string" ? args.content.trim() : "";
+  const url = typeof args.url === "string" ? normalizeUrl(args.url) : "";
+
+  if (!explicitContent && !url) {
+    throw new Error("importSkill 需要提供 content 或 url。");
+  }
+
+  let rawMarkdown = explicitContent;
+  if (!rawMarkdown) {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`导入 skill 失败：HTTP ${response.status}`);
+    }
+    rawMarkdown = (await response.text()).trim();
+  }
+
+  const parsed = parseExternalSkillMarkdown(rawMarkdown);
+  const docTitle =
+    (args.title ?? "").trim() ||
+    parsed.name ||
+    "Imported Skill";
+  const normalizedTools = mapImportedTools(parsed.allowedTools);
+  const description =
+    parsed.description ||
+    "Imported external skill. Review instructions and mapped tools before using it in agents.";
+  const skillConfig: SkillDocConfig = {
+    version: "0.1",
+    kind: "skill",
+    id: slugify(parsed.name || docTitle),
+    name: parsed.name || docTitle,
+    description,
+    triggerMode: "explicit",
+    toolNames: normalizedTools,
+    budgetTier: "medium",
+    dispatchPreferred: false,
+    modalities: ["text"],
+  };
+
+  const importedBody = [
+    parsed.body,
+    parsed.compatibility ? `\n## Compatibility\n${parsed.compatibility}` : "",
+    url ? `\nImported from: ${url}` : "",
+  ]
+    .filter(Boolean)
+    .join("\n\n")
+    .trim();
+
+  const content = buildSkillDocMarkdown({
+    body: importedBody,
+    skillConfig,
+  });
+
+  const explicitSpaceId = (args.spaceId ?? "").trim() || undefined;
+  const currentSpaceId = selectCurrentSpaceId(state) || undefined;
+  const spaceId = explicitSpaceId ?? currentSpaceId;
+  const categoryId = (args.categoryId ?? "").trim() || undefined;
+
+  const createDocResult = await (dispatch as any)(
+    (createDoc as any)({
+      title: docTitle,
+      spaceId,
+      categoryId,
+      content,
+    })
+  );
+  const id = await createDocResult.unwrap();
+
+  return buildSkillFollowupResult({
+    dbKey: id,
+    title: docTitle,
+    skillId: skillConfig.id,
+    spaceId: spaceId ?? null,
+    toolNames: normalizedTools,
+    importedFrom: url || null,
+    hasEvalConfig: false,
+  });
+}