nolo-cli 0.1.44 → 0.1.46

package/ai/tools/readFileTool.ts

@@ -1,214 +0,0 @@
-// 文件路径: packages/ai/tools/readFileTool.ts
-
-import { buildToolRequestHeaders, getToolBaseUrl } from "./toolApiClient";
-
-// ---- Types ----
-
-export type ReadFileArgs = {
-    /**
-     * 目标文件相对项目根目录（bun-nolo）的路径，例如：
-     * - packages/chat/src/messages/web/ToolMessageContent.tsx
-     * - packages/server/entry.ts
-     */
-    filePath: string;
-    /**
-     * 可选：从该行开始读取（1-based，包含）。
-     */
-    startLine?: number;
-    /**
-     * 可选：读取到该行结束（1-based，包含）。
-     */
-    endLine?: number;
-};
-
-// ---- 工具 Schema，供 LLM 调用 ----
-
-export const readFileFunctionSchema = {
-    name: "readFile",
-    description: [
-        "从后端服务器读取一个文本文件的完整内容，并辅助行级编辑工具获取精确的行号信息。",
-        "",
-        "适用场景：",
-        "- 在修改文件之前，先获取当前文件的完整内容用于分析。",
-        "- 在需要理解某个模块实现时，请求查看对应源文件。",
-        "- 在使用 applyLineEdits 按行号修改文件前，先读取文件并基于返回的 lines / lineCount 计算行号。",
-        "- 如果使用 startLine/endLine 只读取部分内容：",
-        "  - lines[0] 对应的真实行号为 lineOffset；",
-        "  - 全文件总行数为 totalLineCount；",
-        "  - 计算绝对行号时，请用 lineOffset + index。",
-        "- 为 applyLineEdits 提供 originalSnippet：",
-        "  - 对 replaceRange/deleteRange：从 lines 中取出将要修改的那几行，用 \\n 拼接，作为 originalSnippet 传给 applyLineEdits；",
-        "  - 对 insertBefore/insertAfter：从 lines 中取出插入点附近的一行原始代码，作为 originalSnippet 传给 applyLineEdits；",
-        "",
-        "行为约定：",
-        "- 当目标文件存在：返回文件的完整文本内容。",
-        "- 当目标文件不存在：返回错误信息。",
-        "",
-        "返回数据约定（rawData 中）：",
-        "- content：文件完整内容，统一使用 \\n 作为换行符。",
-        "- lines：按行拆分后的字符串数组；若使用 startLine/endLine，则 lines[0] 对应 lineOffset。",
-        "- lineCount：全文件总行数（即最大可用行号）。",
-        "- lineOffset：当使用 startLine/endLine 时，lines[0] 对应的真实行号。",
-        "- totalLineCount：全文件总行数（与 lineCount 相同，便于兼容）。",
-        "",
-        "注意：",
-        "- filePath 必须是相对项目根目录（bun-nolo）的相对路径，且不能越出项目根目录。",
-        "- 仅适用于文本文件，二进制文件的内容会被当作 UTF-8 文本读取，可能出现乱码。",
-    ].join("\n"),
-    parameters: {
-        type: "object",
-        properties: {
-            filePath: {
-                type: "string",
-                description:
-                    "目标文件相对项目根目录（bun-nolo）的路径，例如: packages/chat/src/messages/web/ToolMessageContent.tsx",
-            },
-            startLine: {
-                type: "number",
-                description:
-                    "可选：从该行开始读取（1-based，包含）。与 endLine 搭配可只读局部内容。",
-            },
-            endLine: {
-                type: "number",
-                description:
-                    "可选：读取到该行结束（1-based，包含）。与 startLine 搭配可只读局部内容。",
-            },
-        },
-        required: ["filePath"],
-    },
-};
-
-// ---- 预览执行：不读文件，只展示信息 ----
-
-export async function readFilePreviewFunc(
-    args: ReadFileArgs,
-    _thunkApi: any
-): Promise<{ rawData: any; displayData?: string }> {
-    const { filePath, startLine, endLine } = args;
-
-    if (!filePath || typeof filePath !== "string") {
-        throw new Error("readFile 预览失败：必须提供有效的 filePath 字符串。");
-    }
-
-    return {
-        rawData: {
-            previewOnly: true,
-            filePath,
-            startLine,
-            endLine,
-        },
-        displayData: `⏸️ 文件读取预览: ${filePath}`,
-    };
-}
-
-// ---- 真正执行：POST 到后端 /api/read-file ----
-
-export async function readFileFunc(
-    args: ReadFileArgs,
-    thunkApi: any,
-    context?: { parentMessageId?: string; signal?: AbortSignal; agentKey?: string }
-): Promise<{ rawData: any; displayData?: string }> {
-    const { filePath, startLine, endLine } = args;
-
-    if (!filePath || typeof filePath !== "string") {
-        throw new Error("读取文件失败：必须提供有效的 filePath 字符串。");
-    }
-
-    try {
-        const baseUrl = getToolBaseUrl(thunkApi);
-
-        if (!baseUrl) {
-            throw new Error("读取文件失败：无法获取 readFile 服务器地址。");
-        }
-
-        const apiUrl = `${baseUrl.replace(/\/+$/, "")}/api/read-file`;
-
-        const response = await fetch(apiUrl, {
-            method: "POST",
-            headers: buildToolRequestHeaders(thunkApi, {
-                withAuth: true,
-                agentKey: context?.agentKey,
-            }),
-            signal: context?.signal,
-            body: JSON.stringify({ filePath, startLine, endLine }),
-        });
-
-        const textBody = await response.text();
-        let data: any = {};
-        try {
-            data = textBody ? JSON.parse(textBody) : {};
-        } catch {
-            // 非 JSON 的情况忽略解析错误
-        }
-
-        if (!response.ok || data?.error) {
-            const errMsg =
-                data?.error ||
-                `readFile API 请求失败，状态码: ${response.status}. 响应: ${textBody}`;
-            console.error("readFile API Error:", errMsg);
-            throw new Error(errMsg);
-        }
-
-        // 统一换行符为 \n，保证与行级编辑逻辑一致
-        const serverContent: string =
-            typeof data?.content === "string" ? data.content : "";
-        const normalizedContent =
-            serverContent.indexOf("\r\n") >= 0
-                ? serverContent.replace(/\r\n/g, "\n")
-                : serverContent;
-
-        const lines =
-            normalizedContent === "" ? [] : normalizedContent.split("\n");
-
-        const lineOffset: number =
-            typeof data?.lineOffset === "number" ? data.lineOffset : 1;
-
-        const totalLineCount: number =
-            typeof data?.totalLineCount === "number"
-                ? data.totalLineCount
-                : typeof data?.lineCount === "number"
-                    ? data.lineCount
-                    : lines.length;
-
-        const rangeStart: number =
-            typeof data?.rangeStart === "number"
-                ? data.rangeStart
-                : lines.length
-                    ? lineOffset
-                    : 1;
-        const rangeEnd: number =
-            typeof data?.rangeEnd === "number"
-                ? data.rangeEnd
-                : lines.length
-                    ? lineOffset + lines.length - 1
-                    : 0;
-
-        const returnedLineCount = lines.length;
-
-        const rangeInfo =
-            totalLineCount === 0
-                ? "0 行"
-                : rangeStart === 1 && rangeEnd === totalLineCount
-                    ? `${totalLineCount} 行`
-                    : `${rangeStart}-${rangeEnd} 行 / 共 ${totalLineCount} 行`;
-
-        return {
-            rawData: {
-                applied: true,
-                filePath,
-                lines,
-                totalLineCount,
-                lineOffset,
-                rangeStart,
-                rangeEnd,
-                returnedLineCount,
-            },
-            displayData: `📖 已读取文件: ${filePath}（${rangeInfo}）`,
-        };
-    } catch (error: any) {
-        console.error("执行 readFile 时发生错误:", error);
-        throw new Error(
-            `读取文件 (${filePath}) 失败：${error?.message || String(error)}`
-        );
-    }
-}

package/ai/tools/readTool.ts

@@ -1,194 +0,0 @@
-// 文件路径: ai/tools/readTool.ts
-
-import { readAction } from "../../database/actions/read";
-import { readAndWaitAction } from "../../database/actions/readAndWait";
-import { slateToSimplifiedMarkdown } from "../../create/editor/transforms/slateToSimplifiedMarkdown";
-import type { PageData } from "../../render/page/types";
-import { getRuntimeServerContext } from "../../database/runtimeServerContext";
-import { isTableMetaKey, rowKey, isAgentKey } from "../../database/keys";
-import { DataType } from "../../create/types";
-import { TableMeta } from "../../render/table/types";
-import { fetchAndSerializeTable } from "../../render/table/utils/tableSerialization";
-import { readFileFunc } from "./readFileTool";
-
-// ---- Types ----
-
-export type ReadArgs = {
-  /**
-   * 对应 database 的 dbKey
-   */
-  dbKey: string;
-
-  /**
-   * 是否等待远程结果：
-   * - false（默认）：使用 readAction，本地优先，远程在后台同步
-   * - true：使用 readAndWaitAction，等待远程与本地决策后返回“权威”结果
-   */
-  waitRemote?: boolean;
-
-  /**
-   * Backward-compatible escape hatch for models that call read with a local
-   * file path even when the readFile tool is available.
-   */
-  filePath?: string;
-  path?: string;
-};
-
-// ---- 工具 Schema，供 LLM 调用 ----
-
-export const readFunctionSchema = {
-  name: "read",
-  description: [
-    "根据指定的 dbKey 从本地/远程数据库读取一条记录。",
-    "支持所有内容类型：",
-    "- page-xxx：页面内容（返回 Markdown）",
-    "- dialog-xxx：对话历史（返回消息列表）",
-    "- agent-xxx：Agent 配置",
-    "- table-xxx：表格数据",
-    "- space-xxx：Space 完整数据（含分类和内容目录）",
-    "行为说明：",
-    "- 默认本地优先：若本地存在则立即返回，后台同步远程；",
-    "- waitRemote=true：等待远程权威结果后返回（适合需要最新数据的场景）。",
-  ].join("\n"),
-  parameters: {
-    type: "object",
-    properties: {
-      dbKey: {
-        type: "string",
-        description: "要读取的数据键，例如 PAGE-xxx、dialog-xxx、agent-xxx、space-xxx。",
-      },
-      waitRemote: {
-        type: "boolean",
-        description:
-          "是否等待远程结果。false=本地优先并在后台同步远程；true=等待远程与本地决策后返回。",
-        default: false,
-      },
-    },
-    required: ["dbKey"],
-  },
-};
-
-// ---- 执行函数 ----
-
-export async function readFunc(
-  args: ReadArgs,
-  thunkApi: any,
-  context?: { parentMessageId?: string; signal?: AbortSignal }
-): Promise<{ rawData: any; displayData?: string }> {
-  const { dbKey, waitRemote = false } = args || {};
-  const localFilePath =
-    typeof args?.filePath === "string"
-      ? args.filePath
-      : typeof args?.path === "string"
-        ? args.path
-        : "";
-
-  if (!dbKey && localFilePath) {
-    const result = await readFileFunc(
-      {
-        filePath: localFilePath,
-        startLine: (args as any).startLine,
-        endLine: (args as any).endLine,
-      },
-      thunkApi,
-      context
-    );
-    return {
-      rawData: result,
-      displayData:
-        typeof result === "string" ? result : JSON.stringify(result, null, 2),
-    };
-  }
-
-  if (!dbKey || typeof dbKey !== "string") {
-    throw new Error("read 工具需要提供字符串类型的 id（dbKey）。");
-  }
-
-  try {
-    const signal = context?.signal;
-
-    const result = waitRemote
-      ? await readAndWaitAction(dbKey, thunkApi)
-      : await readAction({ dbKey, signal }, thunkApi);
-
-    if (!result) {
-      throw new Error(`未找到 dbKey 为 ${dbKey} 的数据。`);
-    }
-
-    // 智能化处理：如果是页面，自动转 Markdown
-    if (dbKey.startsWith("PAGE-") || (result as any).type === DataType.DOC) {
-      const pageData = result as PageData;
-      const markdownContent = slateToSimplifiedMarkdown(pageData.slateData || []);
-
-      return {
-        rawData: {
-          ...pageData,
-          content: markdownContent, // 附加转换后的内容
-        },
-        displayData: `已成功读取页面《${pageData.title}》。\n\n内容预览：\n\n${markdownContent}`,
-      };
-    }
-
-    // 智能化处理：如果是表格，自动转 Markdown
-    if (isTableMetaKey(dbKey) || (result as any).type === DataType.TABLE) {
-      const tableMeta = result as TableMeta;
-      const title = tableMeta.displayName || `Table (${tableMeta.tableId})`;
-
-      // Use shared utility
-      const { rows, markdown: tableMd } = await thunkApi.dispatch(
-        async (_dispatch: any, getState: any, { db }: any) => {
-          const state = getState();
-          const { currentToken: token, remoteServers } =
-            getRuntimeServerContext(state);
-
-          return await fetchAndSerializeTable(tableMeta, db, {
-            token,
-            remoteServers,
-          });
-        }
-      );
-
-      return {
-        rawData: {
-          ...tableMeta,
-          rows,
-          markdown: tableMd,
-        },
-        displayData: `已成功读取表格《${title}》。共 ${rows.length} 行数据。\n\n内容预览：\n\n${tableMd}`,
-      };
-    }
-
-    // 智能化处理：如果是 Agent/Cybot，显示基本信息
-    if (
-      isAgentKey(dbKey) ||
-      (result as any).type === DataType.AGENT ||
-      (result as any).type === DataType.CYBOT
-    ) {
-      const agent = result as any;
-      const name = agent.name || "未命名 Agent";
-      const desc = agent.introduction || agent.description || "无描述";
-      const modelInfo = agent.model ? ` (模型: ${agent.model})` : "";
-
-      return {
-        rawData: agent,
-        displayData: `已成功读取 Agent《${name}》${modelInfo}。\n\n描述：${desc}\n提示词预览：\n${agent.prompt?.slice(0, 200) || "无"
-          }...`,
-      };
-    }
-
-    const sourceLabel = waitRemote
-      ? "已等待远程与本地完成后返回权威结果"
-      : "本地优先，已触发后台与远程同步";
-
-
-    return {
-      rawData: result,
-      displayData: `已读取数据: "${result.dbKey}"（${sourceLabel}）`,
-    };
-  } catch (error: any) {
-    console.error("执行 read 工具时发生错误:", error);
-    throw new Error(
-      `读取数据 (${dbKey}) 失败：${error?.message || String(error)}`
-    );
-  }
-}

package/ai/tools/readXPostTool.ts

@@ -1,229 +0,0 @@
-import { createXReadFailure } from "../../integrations/x-reader/types";
-import type { XPost, XReadResult } from "../../integrations/x-reader/types";
-import { getRequestConfig, ToolApiError } from "./toolApiClient";
-
-export const readXPostFunctionSchema = {
-  name: "read_x_post",
-  description:
-    "读取 X/Twitter status 链接的可见帖子正文、作者和结构化数据。适合用户给出 x.com/twitter.com 帖子链接并要求查看、总结、解释或抽取信息的场景。默认通过桌面本地 Chrome/CDP bridge 读取，不要求用户粘贴 cookie 或 token。",
-  parameters: {
-    type: "object",
-    properties: {
-      url: {
-        type: "string",
-        description:
-          "要读取的 X/Twitter status URL，例如 https://x.com/user/status/123。",
-      },
-      keepOpen: {
-        type: "boolean",
-        description: "调试时是否保留临时 Chrome bridge。默认 false。",
-        default: false,
-      },
-      profileDir: {
-        type: "string",
-        description:
-          "桌面端本地 Chrome 专用 profile 目录。用于让用户在本机登录一次 X 后复用本地账号状态；不要传入用户日常 Chrome profile。",
-      },
-      headless: {
-        type: "boolean",
-        description:
-          "是否用 headless 模式启动本地 Chrome。需要用户首次登录本地 X profile 时设为 false 并配合 keepOpen。",
-        default: true,
-      },
-    },
-    required: ["url"],
-  },
-};
-
-type ReadXPostToolContext = {
-  reader?: (
-    url: string,
-    args: { keepOpen?: boolean; profileDir?: string; headless?: boolean },
-  ) => Promise<XReadResult<XPost>>;
-};
-
-async function callLocalReadXPostApi(
-  thunkApi: any,
-  body: object,
-): Promise<XReadResult<XPost>> {
-  const { currentServer, token } = getRequestConfig(thunkApi);
-  const browserOrigin = (globalThis as any).window?.location?.origin;
-  const baseUrl = typeof browserOrigin === "string" && browserOrigin
-    ? browserOrigin
-    : currentServer.replace(/\/+$/, "");
-  const headers: Record<string, string> = { "Content-Type": "application/json" };
-  if (token) headers.Authorization = `Bearer ${token}`;
-
-  const response = await fetch(`${baseUrl}/api/read-x-post`, {
-    method: "POST",
-    headers,
-    body: JSON.stringify(body),
-  });
-  const text = await response.text();
-  let data: any = null;
-  try {
-    data = text ? JSON.parse(text) : null;
-  } catch {
-    data = null;
-  }
-  if (!response.ok) {
-    throw new ToolApiError(
-      data?.error?.message ?? `read_x_post API 请求失败，状态码: ${response.status}`,
-      {
-        status: response.status,
-        code: data?.error?.code,
-        details: data,
-      },
-    );
-  }
-  return data as XReadResult<XPost>;
-}
-
-async function callDesktopReadXPostApi(
-  thunkApi: any,
-  body: object,
-): Promise<XReadResult<XPost>> {
-  const { token } = getRequestConfig(thunkApi);
-  const port = Number(process.env.NOLO_DESKTOP_SERVER_PORT ?? 3233);
-  const headers: Record<string, string> = { "Content-Type": "application/json" };
-  if (token) headers.Authorization = `Bearer ${token}`;
-
-  const response = await fetch(`http://127.0.0.1:${port}/api/read-x-post`, {
-    method: "POST",
-    headers,
-    body: JSON.stringify(body),
-  });
-  const text = await response.text();
-  let data: any = null;
-  try {
-    data = text ? JSON.parse(text) : null;
-  } catch {
-    data = null;
-  }
-  if (!response.ok) {
-    throw new ToolApiError(
-      data?.error?.message ?? `desktop read_x_post API 请求失败，状态码: ${response.status}`,
-      {
-        status: response.status,
-        code: data?.error?.code,
-        details: data,
-      },
-    );
-  }
-  return data as XReadResult<XPost>;
-}
-
-async function readWithDefaultBridge(
-  url: string,
-  args: { keepOpen?: boolean; profileDir?: string; headless?: boolean },
-  thunkApi?: any,
-): Promise<XReadResult<XPost>> {
-  if (process.env.PLATFORM === "web") {
-    if (thunkApi?.getState) {
-      return callLocalReadXPostApi(thunkApi, { url, ...args });
-    }
-
-    if (typeof window !== "undefined" && (window as any).__NOLO_DESKTOP__) {
-      try {
-        const res = await fetch("/api/read-x-post", {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ url, ...args }),
-        });
-        const data = await res.json().catch(() => null);
-        if (res.ok && data) {
-          return data as XReadResult<XPost>;
-        }
-        return createXReadFailure({
-          code: "network_error",
-          message: `desktop read_x_post endpoint failed: HTTP ${res.status}`,
-          nextStep: "请确认桌面端本地服务仍在运行，然后重试。",
-          backend: "desktop_local_browser",
-        });
-      } catch (error) {
-        return createXReadFailure({
-          code: "network_error",
-          message:
-            error instanceof Error
-              ? error.message
-              : "desktop read_x_post endpoint request failed",
-          nextStep: "请确认桌面端本地服务仍在运行，然后重试。",
-          backend: "desktop_local_browser",
-        });
-      }
-    }
-
-    return createXReadFailure({
-      code: "not_connected",
-      message: "read_x_post 需要通过服务器或桌面本地 bridge 执行，不能在普通浏览器 bundle 内直接启动 Chrome/CDP。",
-      nextStep: "请使用服务器 agent run 或桌面端本地 bridge 路径执行该工具。",
-      backend: "desktop_local_browser",
-    });
-  }
-
-  if (process.env.NOLO_DESKTOP === "1" && thunkApi?.getState) {
-    return callDesktopReadXPostApi(thunkApi, { url, ...args });
-  }
-
-  const importBridge = new Function("specifier", "return import(specifier)") as <
-    T = any,
-  >(
-    specifier: string,
-  ) => Promise<T>;
-  const { readXPostWithBridge } = await importBridge<{
-    readXPostWithBridge: (
-      url: string,
-      args: { keepOpen?: boolean; profileDir?: string; headless?: boolean },
-    ) => Promise<XReadResult<XPost>>;
-  }>("../../integrations/x-reader/bridge/readXPostWithBridge.ts");
-  return readXPostWithBridge(url, args);
-}
-
-function assertXStatusUrl(url: string) {
-  if (!/^https?:\/\/(x|twitter)\.com\/[^/]+\/status\/\d+/i.test(url)) {
-    throw new Error("read_x_post 需要一个有效的 X/Twitter status URL。");
-  }
-}
-
-function formatDisplay(result: XReadResult<XPost>) {
-  if (!result.ok) {
-    return [
-      `读取 X 帖子失败：${result.message}`,
-      `失败代码：${result.code}`,
-      result.nextStep ? `下一步：${result.nextStep}` : "",
-      `后端：${result.backend}`,
-    ]
-      .filter(Boolean)
-      .join("\n");
-  }
-
-  const post = result.data;
-  return [
-    `已读取 X 帖子：@${post.author.handle}${post.author.displayName ? `（${post.author.displayName}）` : ""}`,
-    `URL: ${post.url}`,
-    `后端：${result.backend}`,
-    "",
-    post.text,
-  ].join("\n");
-}
-
-export async function readXPostFunc(
-  args: { url: string; keepOpen?: boolean; profileDir?: string; headless?: boolean },
-  thunkApi: any,
-  context: ReadXPostToolContext = {},
-): Promise<{ rawData: XReadResult<XPost>; displayData: string }> {
-  const url = String(args?.url ?? "").trim();
-  assertXStatusUrl(url);
-
-  const keepOpen = Boolean(args?.keepOpen);
-  const profileDir = String(args?.profileDir ?? "").trim() || undefined;
-  const headless = args?.headless;
-  const rawData =
-    (await context.reader?.(url, { keepOpen, profileDir, headless })) ??
-    (await readWithDefaultBridge(url, { keepOpen, profileDir, headless }, thunkApi));
-
-  return {
-    rawData,
-    displayData: formatDisplay(rawData),
-  };
-}