nolo-cli 0.1.39 → 0.1.41

package/ai/tools/evalSkillTool.ts

@@ -0,0 +1,92 @@
+import { readAction } from "../../database/actions/read";
+import type { PageData } from "../../render/page/types";
+import { evaluateSkillDocument } from "../skills/skillDiagnostics";
+
+export interface EvalSkillToolArgs {
+  id?: string;
+  content?: string;
+}
+
+export const evalSkillFunctionSchema = {
+  name: "evalSkill",
+  description:
+    "根据 skill 的 eval-config 评估它当前的工具绑定与提示是否满足预期。",
+  parameters: {
+    type: "object",
+    properties: {
+      id: {
+        type: "string",
+        description: "可选：本地 skill 文档的 dbKey（如 page-xxx）。",
+      },
+      content: {
+        type: "string",
+        description: "可选：直接传入 skill markdown 内容进行评估。",
+      },
+    },
+  } as const,
+};
+
+export async function evalSkillFunc(
+  args: EvalSkillToolArgs,
+  thunkApi: any
+): Promise<{ rawData: unknown; displayData: string }> {
+  const { id, content } = args;
+  if (!id && !content?.trim()) {
+    throw new Error("evalSkill 需要提供 id 或 content。");
+  }
+
+  let page: PageData | undefined;
+  if (id) {
+    page = (await readAction({ dbKey: id }, thunkApi)) as PageData;
+    if (!page) {
+      throw new Error(`未找到 skill 文档：${id}`);
+    }
+  }
+
+  const result = await evaluateSkillDocument(
+    {
+      id: page?.dbKey ?? id,
+      title: page?.title,
+      content: content ?? page?.content ?? "",
+      meta: page?.meta,
+      tools: page?.tools,
+    },
+    {
+      loadPage: async (dbKey) => {
+        try {
+          return (await readAction({ dbKey }, thunkApi)) as PageData;
+        } catch {
+          return undefined;
+        }
+      },
+    }
+  );
+
+  const lines = [
+    `Skill 评估：${result.name ?? result.skillId ?? id ?? "inline-skill"}`,
+    `- 状态: ${result.ok ? "通过" : "未通过"}`,
+    `- 生效工具: ${result.effectiveTools.join(", ") || "(无)"}`,
+    ...(result.missingReferences.length
+      ? [`- 缺失依赖: ${result.missingReferences.join(", ")}`]
+      : []),
+    ...result.cases.map((testCase, index) =>
+      [
+        `- Case ${index + 1}: ${testCase.passed ? "PASS" : "FAIL"} :: ${testCase.input}`,
+        ...(testCase.missingTools?.length
+          ? [`  - missingTools: ${testCase.missingTools.join(", ")}`]
+          : []),
+        ...(testCase.missingSignals?.length
+          ? [`  - missingSignals: ${testCase.missingSignals.join(", ")}`]
+          : []),
+        ...(testCase.forbiddenSignalsFound?.length
+          ? [`  - forbiddenSignalsFound: ${testCase.forbiddenSignalsFound.join(", ")}`]
+          : []),
+      ].join("\n")
+    ),
+  ];
+
+  return {
+    rawData: result,
+    displayData: lines.join("\n"),
+  };
+}

package/ai/tools/exaSearchTool.ts

@@ -0,0 +1,63 @@
+import { callToolApi } from "./toolApiClient";
+
+export const exaSearchSchema = {
+    name: "exa_search",
+    description: "使用 Exa (原 Metaphor) 智能搜索引擎查找信息。这是获取高质量、最新网络信息的最佳方式。",
+    parameters: {
+        type: "object",
+        properties: {
+            query: {
+                type: "string",
+                description: "要搜索的自然语言查询字符串。",
+            },
+            numResults: {
+                type: "number",
+                description: "返回的结果数量（默认为 5）。",
+                default: 5,
+            },
+            useAutoprompt: {
+                type: "boolean",
+                description: "是否让 Exa 自动优化查询词（推荐 true）。",
+                default: true,
+            },
+            type: {
+                type: "string",
+                enum: ["neural", "keyword"],
+                description: "搜索类型：'neural' (语义搜索，默认) 或 'keyword' (精确匹配)。",
+                default: "neural",
+            },
+            includeContent: {
+                type: "boolean",
+                description: "是否直接返回网页的文本内容（RAG 模式）。如果为 true，不仅返回链接，还会返回已清洗的正文。",
+                default: true,
+            }
+        },
+        required: ["query"],
+    },
+};
+
+export const exaSearchFunc = async (input: any, thunkApi: any): Promise<any> => {
+    const { query, numResults = 5, useAutoprompt = true, type = "neural", includeContent = true } = input;
+
+    const data = await callToolApi(thunkApi, "/api/exa-search", {
+        query,
+        numResults,
+        useAutoprompt,
+        type,
+        contents: includeContent ? { text: true } : undefined,
+    }, { withAuth: true });
+
+    const results = (data.results || []).map((item: any) => ({
+        title: item.title,
+        url: item.url,
+        publishedDate: item.publishedDate,
+        author: item.author,
+        content: item.text ? item.text.slice(0, 2500) : undefined,
+    }));
+
+    return {
+        summary: `Found ${results.length} results for "${query}"`,
+        results,
+        queryUsed: data.autopromptString || query
+    };
+};

package/ai/tools/execShellTool.ts

@@ -0,0 +1,266 @@
+import { DEFAULT_LOCAL_API_ORIGIN } from "../../core/localOrigins";
+import { callToolApi } from "./toolApiClient";
+import { ToolResultError } from "./toolResultError";
+
+type ExecShellKind = "auto" | "bash" | "powershell";
+
+type ExecShellRequestArgs = {
+  command?: string;
+  cwd?: string;
+  interactive?: boolean;
+  pty?: boolean;
+  shell?: ExecShellKind;
+  sessionId?: string;
+  input?: string;
+  close?: boolean;
+};
+
+export const execShellFunctionSchema = {
+  name: "execShell",
+  description:
+    "跨平台 shell 执行工具。会在 Windows 上优先使用 PowerShell，在 Linux/macOS 上使用 bash。环境不明确时，先调用 checkEnv({check:'context'}) 判断当前平台与可用 shell。支持交互式 session：先用 interactive=true 启动，再通过 sessionId + input 继续写入 stdin，或用 sessionId 单独轮询输出。仅用于本地开发环境。对 rm 等危险命令默认拦截，需显式传 unsafe: true 才会执行。不要用它执行 rg/grep 代码搜索；代码搜索请改用 codeSearch。",
+  parameters: {
+    type: "object",
+    properties: {
+      command: {
+        type: "string",
+        description:
+          "要执行的 shell 命令，例如: 'git status --short', 'Get-Location', 'bun test --watch=false'。",
+      },
+      cwd: {
+        type: "string",
+        description:
+          "可选：命令执行的工作目录（相对于 diff-server 所在机器），默认使用后端的 process.cwd()。",
+      },
+      shell: {
+        type: "string",
+        enum: ["auto", "bash", "powershell"],
+        description:
+          "可选：显式指定 shell。默认 auto：Windows 优先 PowerShell，其他系统使用 bash。",
+      },
+      unsafe: {
+        type: "boolean",
+        description:
+          "可选：是否允许执行被判定为危险的命令（例如 rm -rf）。默认 false；当为 false 且命令被识别为危险时，会直接拦截而不真正执行。",
+      },
+      interactive: {
+        type: "boolean",
+        description:
+          "可选：是否以交互式 session 启动命令。为 true 时接口会立即返回 sessionId，后续可继续写 stdin 或轮询输出。",
+      },
+      pty: {
+        type: "boolean",
+        description:
+          "可选：是否为交互式 session 分配伪终端（PTY）。当前仅 bash 路径支持；Windows PowerShell 会自动降级为非 PTY 交互。",
+      },
+      sessionId: {
+        type: "string",
+        description:
+          "可选：已存在的交互式 sessionId。传入后可继续写入 input、查询最新输出或关闭该 session。",
+      },
+      input: {
+        type: "string",
+        description:
+          "可选：要写入 session stdin 的文本。通常需要自己补换行，例如 'y\\n' 或 'exit\\n'。",
+      },
+      close: {
+        type: "boolean",
+        description:
+          "可选：是否关闭指定 session。通常与 sessionId 搭配使用。",
+      },
+    },
+  },
+};
+
+function isDangerousCommand(rawCommand: string): boolean {
+  const command = rawCommand.trim();
+  const normalized = command.replace(/\s+/g, " ");
+
+  if (
+    /^rm\b/i.test(normalized) ||
+    /\bsudo\s+rm\b/i.test(normalized) ||
+    /\brm\s+-[rf]+\b/i.test(normalized) ||
+    /\brm\s+-[^\s]*r[^\s]*f[^\s]*/i.test(normalized)
+  ) {
+    return true;
+  }
+
+  if (/\brm\s+-[^\s]*f[^\s]*/i.test(normalized)) {
+    return true;
+  }
+
+  return false;
+}
+
+async function requestExec(
+  args: ExecShellRequestArgs,
+  thunkApi?: any,
+  endpoint = "/api/exec-shell",
+  context?: { agentKey?: string },
+): Promise<any> {
+  const payload = Object.fromEntries(
+    Object.entries(args).filter(([, value]) => value !== undefined)
+  );
+
+  if (thunkApi?.getState) {
+    return callToolApi(thunkApi, endpoint, payload, {
+      withAuth: true,
+      agentKey: context?.agentKey,
+    });
+  }
+
+  const baseUrl =
+    (typeof process !== "undefined" &&
+      (process as any).env?.DIFF_SERVER_ORIGIN) ||
+    (typeof window !== "undefined" ? window.location.origin : DEFAULT_LOCAL_API_ORIGIN);
+  const url = `${baseUrl}${endpoint}`;
+  const headers: Record<string, string> = { "Content-Type": "application/json" };
+  if (typeof window !== "undefined" && (window as any).__NOLO_DESKTOP__) {
+    headers["X-Nolo-Desktop-Tool"] = "1";
+  }
+  const res = await fetch(url, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(payload),
+  });
+
+  const text = await res.text();
+  try {
+    return text ? JSON.parse(text) : {};
+  } catch {
+    return { raw: text, ok: res.ok, status: res.status };
+  }
+}
+
+function formatExecResult(prefixLabel: string, args: any, json: any, trimmedCommand: string, sessionId?: string) {
+  const prefix = json?.ok === false || json?.error ? `[${prefixLabel} 失败]` : `[${prefixLabel} 成功]`;
+  const stdout = json.stdout ?? "";
+  const stderr = json.stderr ?? "";
+  const exitCode = json.exitCode ?? json.code ?? null;
+  const responseSessionId = json.sessionId ?? sessionId ?? null;
+  const responseInteractive = json.interactive === true;
+  const responseRunning = json.running;
+
+  const displayParts: string[] = [];
+  displayParts.push(`${prefix} command: ${json.command ?? trimmedCommand ?? "(session follow-up)"}`);
+  if (json.shell ?? args.shell) {
+    displayParts.push(`shell: ${json.shell ?? args.shell}`);
+  }
+  if (args.cwd) {
+    displayParts.push(`cwd: ${args.cwd}`);
+  }
+  if (responseSessionId) {
+    displayParts.push(`sessionId: ${responseSessionId}`);
+  }
+  if (responseInteractive) {
+    displayParts.push(`running: ${responseRunning === false ? "false" : "true"}`);
+  }
+  if (exitCode !== null && exitCode !== undefined) {
+    displayParts.push(`exitCode: ${exitCode}`);
+  }
+  if (stdout) {
+    displayParts.push("\n[stdout]\n" + stdout.trim());
+  }
+  if (stderr) {
+    displayParts.push("\n[stderr]\n" + stderr.trim());
+  }
+
+  return {
+    rawData: {
+      command: trimmedCommand || null,
+      cwd: args.cwd ?? null,
+      shell: args.shell ?? "auto",
+      ...json,
+    },
+    displayData: displayParts.join("\n"),
+  };
+}
+
+function throwExecToolError(toolName: "execShell", message: string, rawData?: any): never {
+  const displayData = `${toolName} 调用失败：${message}`;
+  throw new ToolResultError(displayData, {
+    code: "EXEC_TOOL_FAILED",
+    rawData: rawData ?? { error: displayData },
+    displayData,
+    retryable: true,
+  });
+}
+
+function buildBlockedResponse(toolName: "execShell", trimmedCommand: string, cwd?: string, shell?: ExecShellKind) {
+  const lines: string[] = [];
+  lines.push(`[${toolName} 拦截] 检测到潜在危险命令，默认不执行。`);
+  lines.push(`command: ${trimmedCommand}`);
+  if (cwd) {
+    lines.push(`cwd: ${cwd}`);
+  }
+  lines.push(
+    "如果你确实确认需要执行，请在界面中手动确认或在工具参数中显式传入 unsafe: true（仍建议先检查命令是否有误）。"
+  );
+
+  return {
+    rawData: {
+      applied: false,
+      blocked: true,
+      reason: "dangerous_command",
+      requireUnsafe: true,
+      command: trimmedCommand,
+      cwd: cwd ?? null,
+      shell: shell ?? "auto",
+    },
+    displayData: lines.join("\n"),
+  };
+}
+
+export const startExecShellSession = (
+  thunkApi: any,
+  args: { command: string; cwd?: string; pty?: boolean; shell?: ExecShellKind }
+) =>
+  requestExec(
+    {
+      command: args.command,
+      cwd: args.cwd,
+      interactive: true,
+      pty: args.pty,
+      shell: args.shell,
+    },
+    thunkApi,
+  );
+
+export async function execShellFunc(args: any, thunkApi?: any, context?: { agentKey?: string }): Promise<{
+  rawData: any;
+  displayData: string;
+}> {
+  const { command, cwd, shell, unsafe, interactive, pty, sessionId, input, close } = args || {};
+  const isSessionFollowup = typeof sessionId === "string" && sessionId.trim().length > 0;
+
+  if (!isSessionFollowup && (!command || typeof command !== "string")) {
+    const msg = "execShell 需要提供 command，或提供有效的 sessionId 来继续已有交互式 session。";
+    return { rawData: { error: msg }, displayData: msg };
+  }
+
+  const trimmedCommand = typeof command === "string" ? command.trim() : "";
+  if (!isSessionFollowup && !unsafe && isDangerousCommand(trimmedCommand)) {
+    return buildBlockedResponse("execShell", trimmedCommand, cwd, shell);
+  }
+
+  try {
+    const json = await requestExec({
+      ...(trimmedCommand ? { command: trimmedCommand } : {}),
+      ...(cwd ? { cwd } : {}),
+      ...(shell ? { shell } : {}),
+      ...(interactive ? { interactive: true } : {}),
+      ...(pty ? { pty: true } : {}),
+      ...(isSessionFollowup ? { sessionId } : {}),
+      ...(typeof input === "string" ? { input } : {}),
+      ...(close ? { close: true } : {}),
+    }, thunkApi, "/api/exec-shell", context);
+    if (json?.ok === false || json?.error) {
+      const message = typeof json?.error === "string" ? json.error : JSON.stringify(json?.error ?? json);
+      throwExecToolError("execShell", message, { command: trimmedCommand || null, ...json });
+    }
+    return formatExecResult("execShell", { cwd, shell }, json, trimmedCommand, sessionId);
+  } catch (error: any) {
+    if (error instanceof ToolResultError) throw error;
+    throwExecToolError("execShell", error?.message || String(error));
+  }
+}

package/ai/tools/executeSqlTool.ts

@@ -0,0 +1,192 @@
+// /ai/tools/executeSqlTool.ts
+
+import { getToolRequestContext, callToolApi } from "./toolApiClient";
+import { API_ENDPOINTS } from "../../database/config";
+
+/**
+ * [Schema] 定义了 'executeSql' 工具的结构，供 LLM 调用。
+ * [修改] Schema 增加对参数化查询的描述，但对 LLM 保持简单，不暴露 params 字段。
+ * LLM 应该总是生成完整的、人类可读的 SQL。参数化是由内部工具（如 importData）调用的。
+ */
+export const executeSqlFunctionSchema = {
+  name: "executeSql",
+  description:
+    "直接在 SQLite 数据库中执行任意 SQL 语句，包括查询、插入、更新、删除和表结构操作。内部支持参数化查询以防止SQL注入。",
+  parameters: {
+    type: "object",
+    properties: {
+      sqlQuery: {
+        type: "string",
+        description:
+          "要执行的完整 SQL 语句。例如：SELECT * FROM users; INSERT INTO products (name, price) VALUES ('Milk', 2.5);",
+      },
+      // 注意：params 字段不向 LLM 暴露，这是内部实现细节
+    },
+    required: ["sqlQuery"],
+  },
+};
+
+// buildRequestHeaders 和 postRequest / handleApiResponse 已统一至 toolApiClient
+
+const buildRequestHeaders = (token: string | null): Record<string, string> => {
+  const headers: Record<string, string> = { "Content-Type": "application/json" };
+  if (token) headers["Authorization"] = `Bearer ${token}`;
+  return headers;
+};
+
+const handleApiResponse = async (response: Response): Promise<any> => {
+  if (!response.ok) {
+    let errorMessage = `API 错误！状态码: ${response.status}`;
+    try {
+      const errorData = await response.json() as Record<string, any>;
+      if (errorData?.error) {
+        errorMessage += `: ${errorData.error.message || JSON.stringify(errorData.error)}`;
+      }
+    } catch (e) {
+      /* 忽略json解析错误 */
+    }
+    throw new Error(errorMessage);
+  }
+  return response.json();
+};
+
+const formatSqlResultText = (
+  data: any,
+  sqlQuery: string,
+  params?: any[]
+): string => {
+  // ... (此函数大部分逻辑保持不变)
+  if (!data.success) return `SQL 执行失败：${data.error || "未知错误"}`;
+  const result = data.result;
+
+  // [新增] 如果是参数化 INSERT，提供更精确的反馈
+  if (
+    params &&
+    params.length > 0 &&
+    sqlQuery.trim().toLowerCase().startsWith("insert")
+  ) {
+    const changes = result?.changes ?? 0;
+    const match = sqlQuery.match(/insert\s+into\s+['"]?(\w+)['"]?/i);
+    const tableName = match ? ` "${match[1]}"` : "";
+    if (changes > 0) {
+      return `✅ 成功向表${tableName}中批量插入了 ${changes} 条记录。`;
+    }
+  }
+
+  // ... (其余格式化逻辑与之前相同)
+  const lowerCaseQuery = sqlQuery.trim().toLowerCase();
+
+  if (lowerCaseQuery.startsWith("create table")) {
+    const match = sqlQuery.match(
+      /create\s+table\s+(?:if\s+not\s+exists\s+)?['"]?(\w+)['"]?/i
+    );
+    const tableName = match ? match[1] : "新";
+    return `✅ 表 "${tableName}" 已成功创建。`;
+  }
+
+  if (Array.isArray(result)) {
+    const isListTablesQuery =
+      lowerCaseQuery.includes("select") &&
+      lowerCaseQuery.includes("name") &&
+      lowerCaseQuery.includes("sqlite_master") &&
+      lowerCaseQuery.includes("type") &&
+      lowerCaseQuery.includes("'table'");
+    if (
+      isListTablesQuery &&
+      result.length > 0 &&
+      result[0].name !== undefined
+    ) {
+      const tableNames = result
+        .map((row: any) => `- \`${row.name}\``)
+        .join("\n");
+      return `查询成功，数据库中共有 ${result.length} 个表：\n\n${tableNames}`;
+    }
+    if (lowerCaseQuery.startsWith("pragma table_info(")) {
+      const match = sqlQuery.match(/\(\s*['"]?(\w+)['"]?\s*\)/);
+      const tableName = match ? ` "${match[1]}"` : "";
+      if (result.length > 0 && result[0].cid !== undefined) {
+        let resultText = `表${tableName} 的结构信息 (${result.length} 列):\n\n\`\`\`\n| 列名        | 类型      | 非空 | 主键 |\n|-------------|-----------|------|------|\n`;
+        result.forEach((col: any) => {
+          resultText += `| ${String(col.name).padEnd(11)} | ${String(col.type).padEnd(9)} | ${(col.notnull ? "是" : "否").padEnd(4)} | ${(col.pk ? "是" : "否").padEnd(4)} |\n`;
+        });
+        resultText += "```";
+        return resultText;
+      } else {
+        return `表${tableName} 不存在或没有列信息。`;
+      }
+    }
+    if (
+      lowerCaseQuery.includes("sqlite_master") &&
+      lowerCaseQuery.includes("select sql") &&
+      result.length > 0 &&
+      result[0].sql !== undefined
+    ) {
+      return `表创建 SQL 语句:\n\n\`\`\`sql\n${result[0].sql}\n\`\`\``;
+    }
+    let resultText = `SQL 查询成功，返回 ${result.length} 条记录。\n\n`;
+    if (result.length > 0) {
+      resultText +=
+        "```json\n" + JSON.stringify(result.slice(0, 5), null, 2) + "\n```";
+      if (result.length > 5)
+        resultText += `\n... 更多 ${result.length - 5} 条记录未显示。`;
+    } else {
+      resultText += "没有找到匹配的记录。";
+    }
+    return resultText;
+  } else if (typeof result === "object" && result !== null) {
+    if (result.message) return `SQL 命令执行成功：${result.message}`;
+    if (result.changes !== undefined || result.lastInsertRowid !== undefined) {
+      let resultText = `SQL 命令执行成功。`;
+      if (result.changes > 0) resultText += ` 影响行数：${result.changes}。`;
+      if (result.lastInsertRowid)
+        resultText += ` 最后插入ID：${result.lastInsertRowid}。`;
+      return resultText;
+    }
+    return `SQL 命令执行成功，原始响应：${JSON.stringify(result)}`;
+  }
+  return `SQL 命令执行成功，原始响应：${JSON.stringify(result)}`;
+};
+
+/**
+ * [Executor] 'executeSql' 工具的执行函数。
+ * [修改] 函数签名和请求体以支持可选的参数化查询。
+ * @param args - LLM 或内部工具提供的参数: { sqlQuery: string, params?: any[] }
+ * @param thunkApi - Redux Thunk API
+ * @returns {Promise<{rawData: any, displayData: string}>} - 返回标准化的结果对象
+ */
+export async function executeSqlFunc(
+  args: { sqlQuery: string; params?: any[] }, // <--- [修改] 签名接受可选的 params
+  thunkApi: any
+): Promise<{ rawData: any; displayData: string }> {
+  const { sqlQuery, params } = args;
+
+  if (!sqlQuery || typeof sqlQuery !== "string" || sqlQuery.trim() === "") {
+    throw new Error("SQL 执行失败：'sqlQuery' 必须为非空字符串。");
+  }
+
+  try {
+    const { baseUrl, token } = getToolRequestContext(thunkApi);
+    const apiUrl = `${baseUrl}${API_ENDPOINTS.EXECUTE_SQL}`;
+    const requestHeaders = buildRequestHeaders(token);
+
+    const requestBody: { sql_query: string; params?: any[] } = {
+      sql_query: sqlQuery,
+    };
+    if (params && Array.isArray(params)) {
+      requestBody.params = params;
+    }
+
+    const response = await fetch(apiUrl, { method: "POST", headers: requestHeaders, body: JSON.stringify(requestBody) });
+    const responseData = await handleApiResponse(response);
+
+    // 生成用于UI展示的文本和用于后续步骤的原始数据
+    const displayData = formatSqlResultText(responseData, sqlQuery, params);
+    const rawData = responseData; // 完整的后端响应作为原始数据
+
+    return { rawData, displayData };
+  } catch (error: any) {
+    console.error("Execute SQL tool error:", error);
+    // 重新抛出格式化的错误，以便上层捕获并显示
+    throw new Error(`SQL 执行失败：${error.message}`);
+  }
+}