nolo-cli 0.1.39 → 0.1.41

package/ai/tools/listUserSpacesTool.ts

@@ -0,0 +1,113 @@
+// 文件路径: ai/tools/listUserSpacesTool.ts
+
+/**
+ * listUserSpaces 工具
+ * 
+ * 用于 AI 获取当前用户可访问的所有 Space 列表（概览）。
+ * 只返回 Space 名称和 ID，不返回详细内容，避免 Token 爆炸。
+ * 
+ * 使用场景：
+ * - 用户询问"我有哪些空间"
+ * - AI 需要确定要查询哪个 Space
+ * - 跨 Space 导航
+ */
+
+import type { RootState } from "../../app/store";
+import { selectAllMemberSpaces } from "../../create/space/spaceSlice";
+
+// ---- Types ----
+
+export type ListUserSpacesArgs = {
+    /**
+     * 是否只返回用户拥有的 Space（角色为 owner）
+     */
+    ownedOnly?: boolean;
+};
+
+// ---- 工具 Schema，供 LLM 调用 ----
+
+export const listUserSpacesFunctionSchema = {
+    name: "listUserSpaces",
+    description: [
+        "获取当前用户可访问的所有 Space（工作空间）列表。",
+        "",
+        "返回内容：",
+        "- 每个 Space 的 ID 和名称",
+        "- 用户在该 Space 的角色（owner/member）",
+        "",
+        "使用场景：",
+        "- 用户询问'我有哪些空间'",
+        "- 需要确定要查询哪个 Space",
+        "- 跨 Space 导航",
+        "",
+        "注意：只返回概览信息，如需查看 Space 详细内容，使用 listSpaceContent 工具。",
+    ].join("\n"),
+    parameters: {
+        type: "object",
+        properties: {
+            ownedOnly: {
+                type: "boolean",
+                description: "是否只返回用户拥有的 Space。默认 false（返回所有可访问的 Space）。",
+                default: false,
+            },
+        },
+        required: [],
+    },
+};
+
+// ---- 执行函数 ----
+
+export async function listUserSpacesFunc(
+    args: ListUserSpacesArgs,
+    thunkApi: any,
+    context?: { parentMessageId?: string; signal?: AbortSignal }
+): Promise<{ rawData: any; displayData?: string }> {
+    const { ownedOnly = false } = args || {};
+
+    try {
+        const { getState } = thunkApi;
+        const state: RootState = getState();
+
+        let memberSpaces = selectAllMemberSpaces(state);
+
+        if (ownedOnly) {
+            memberSpaces = memberSpaces.filter((ms) => ms.role === "owner");
+        }
+
+        if (memberSpaces.length === 0) {
+            return {
+                rawData: { spaces: [] },
+                displayData: ownedOnly
+                    ? "当前用户没有拥有任何 Space。"
+                    : "当前用户没有可访问的 Space。",
+            };
+        }
+
+        // 格式化输出
+        let resultText = `=== 用户可访问的 Space 列表 (${memberSpaces.length}) ===\n\n`;
+
+        const spacesData = memberSpaces.map((ms, index) => {
+            const roleLabel = ms.role === "owner" ? "👑 Owner" : "👤 Member";
+            resultText += `${index + 1}. ${ms.spaceName || ms.spaceId}\n`;
+            resultText += `   ID: ${ms.spaceId} | Role: ${roleLabel}\n`;
+
+            return {
+                spaceId: ms.spaceId,
+                name: ms.spaceName || ms.spaceId,
+                role: ms.role,
+            };
+        });
+
+        resultText += `\n提示：使用 listSpaceContent(spaceId) 可查看指定 Space 的详细内容。`;
+
+        return {
+            rawData: { spaces: spacesData },
+            displayData: resultText,
+        };
+    } catch (error: any) {
+        console.error("执行 listUserSpaces 工具时发生错误:", error);
+        throw new Error(
+            `获取用户 Space 列表失败：${error?.message || String(error)}`
+        );
+    }
+}

package/ai/tools/localFilesTool.ts

@@ -0,0 +1,276 @@
+import {
+  buildToolRequestHeaders,
+  getRequestConfig,
+  resolveToolApiBaseUrl,
+} from "./toolApiClient";
+
+export type LocalFileOperation = {
+  kind: "mkdir" | "move" | "rename" | "writeText" | "deleteToTrash";
+  sourceRelativePath?: string;
+  destinationRelativePath?: string;
+  content?: string;
+  reason: string;
+  conflictPolicy: "skip" | "overwrite" | "rename";
+};
+
+type ToolResult = {
+  rawData: any;
+  displayData?: string;
+};
+
+type LocalFilesDeps = {
+  getBaseUrl?: (thunkApi: any) => string;
+  fetchImpl?: typeof fetch;
+};
+
+export const listLocalRootsFunctionSchema = {
+  name: "listLocalRoots",
+  description: "列出当前桌面客户端里已经授权的本地文件夹 roots，供后续的本地文件读取和整理工具使用。",
+  parameters: {
+    type: "object",
+    properties: {},
+  },
+};
+
+export const requestLocalFolderAccessFunctionSchema = {
+  name: "requestLocalFolderAccess",
+  description: "为桌面客户端请求授权一个本地文件夹。传入绝对路径后，返回可供后续 listLocalFiles/readLocalFile 使用的 rootId。",
+  parameters: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "要授权的本地文件夹绝对路径，例如 /Users/me/Desktop 或 C:\\Users\\me\\Downloads。" },
+      label: { type: "string", description: "可选的人类可读名称，例如 Desktop、Downloads、Project Root。" },
+      id: { type: "string", description: "可选的 rootId；如果省略则由桌面端生成。" },
+    },
+    required: ["path"],
+  },
+};
+
+export const listLocalFilesFunctionSchema = {
+  name: "listLocalFiles",
+  description: "列出桌面客户端中用户已授权本地文件夹内的文件和目录。只能访问已授权根目录内的相对路径。",
+  parameters: {
+    type: "object",
+    properties: {
+      rootId: { type: "string", description: "已授权的本地文件夹 ID。" },
+      relativePath: { type: "string", description: "相对已授权根目录的路径，例如 . 或 Documents。" },
+    },
+    required: ["rootId"],
+  },
+};
+
+export const readLocalFileFunctionSchema = {
+  name: "readLocalFile",
+  description: "读取桌面客户端中用户已授权本地文件夹内的文本文件。路径必须是授权根目录内的相对路径。",
+  parameters: {
+    type: "object",
+    properties: {
+      rootId: { type: "string", description: "已授权的本地文件夹 ID。" },
+      relativePath: { type: "string", description: "相对已授权根目录的文本文件路径。" },
+    },
+    required: ["rootId", "relativePath"],
+  },
+};
+
+export const proposeLocalFileChangesFunctionSchema = {
+  name: "proposeLocalFileChanges",
+  description: "为用户已授权的本地文件夹创建整理计划。该工具只创建待确认计划，不会直接修改本地文件。",
+  parameters: {
+    type: "object",
+    properties: {
+      rootId: { type: "string", description: "已授权的本地文件夹 ID。" },
+      summary: { type: "string", description: "本次整理计划摘要。" },
+      operations: {
+        type: "array",
+        description: "待执行的文件操作列表。",
+        items: {
+          type: "object",
+          properties: {
+            kind: { type: "string", enum: ["mkdir", "move", "rename", "writeText", "deleteToTrash"] },
+            sourceRelativePath: { type: "string" },
+            destinationRelativePath: { type: "string" },
+            content: { type: "string" },
+            reason: { type: "string" },
+            conflictPolicy: { type: "string", enum: ["skip", "overwrite", "rename"] },
+          },
+          required: ["kind", "reason", "conflictPolicy"],
+        },
+      },
+      riskLevel: { type: "string", enum: ["low", "medium", "high"] },
+    },
+    required: ["rootId", "summary", "operations"],
+  },
+};
+
+export const executeApprovedLocalFileChangesFunctionSchema = {
+  name: "executeApprovedLocalFileChanges",
+  description: "执行用户已经确认的本地文件整理计划。必须传入 proposeLocalFileChanges 返回的 planId。",
+  parameters: {
+    type: "object",
+    properties: {
+      planId: { type: "string", description: "已确认计划的 ID。" },
+    },
+    required: ["planId"],
+  },
+};
+
+export const undoLocalFileChangeBatchFunctionSchema = {
+  name: "undoLocalFileChangeBatch",
+  description: "撤销一个本地文件整理批次中可撤销的移动或重命名操作。",
+  parameters: {
+    type: "object",
+    properties: {
+      batchId: { type: "string", description: "执行历史批次 ID。" },
+    },
+    required: ["batchId"],
+  },
+};
+
+export function createLocalFilesToolHandlers(deps: LocalFilesDeps = {}) {
+  const resolveUrl = (thunkApi: any, path: string) => {
+    const { currentServer } = getRequestConfig(thunkApi);
+    const baseUrl = resolveToolApiBaseUrl(currentServer, path);
+    if (!baseUrl) throw new Error("无法获取工具服务器地址。");
+    return `${baseUrl.replace(/\/+$/, "")}${path}`;
+  };
+
+  const request = async (
+    thunkApi: any,
+    path: string,
+    init: RequestInit = {},
+    signal?: AbortSignal
+  ) => {
+    const url = deps.getBaseUrl
+      ? `${deps.getBaseUrl(thunkApi).replace(/\/+$/, "")}${path}`
+      : resolveUrl(thunkApi, path);
+    const headers = new Headers(buildToolRequestHeaders(thunkApi, { withAuth: true }));
+    const initHeaders = new Headers(init.headers);
+    initHeaders.forEach((value, key) => headers.set(key, value));
+    const response = await (deps.fetchImpl ?? fetch)(url, {
+      ...init,
+      headers,
+      signal,
+    });
+    const text = await response.text();
+    const data = text ? JSON.parse(text) : {};
+    if (!response.ok || data?.ok === false || data?.error) {
+      throw new Error(data?.error || `desktop files bridge failed: ${response.status}`);
+    }
+    return data;
+  };
+
+  const post = async (thunkApi: any, path: string, body: object, signal?: AbortSignal) => {
+    return request(thunkApi, path, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+    }, signal);
+  };
+
+  return {
+    async listRoots(_args: Record<string, never>, thunkApi: any, context?: { signal?: AbortSignal }): Promise<ToolResult> {
+      const data = await request(thunkApi, "/api/desktop/files/roots", {
+        method: "GET",
+      }, context?.signal);
+      const rootCount = Array.isArray(data?.roots) ? data.roots.length : 0;
+      return {
+        rawData: data,
+        displayData: `已列出已授权本地文件夹 roots（${rootCount} 个）`,
+      };
+    },
+
+    async requestRoot(args: { path: string; label?: string; id?: string }, thunkApi: any, context?: { signal?: AbortSignal }): Promise<ToolResult> {
+      requireString(args.path, "path");
+      const body: Record<string, string> = { path: args.path };
+      if (typeof args.label === "string" && args.label.trim()) body.label = args.label.trim();
+      if (typeof args.id === "string" && args.id.trim()) body.id = args.id.trim();
+      const data = await post(thunkApi, "/api/desktop/files/roots/request", body, context?.signal);
+      return {
+        rawData: data,
+        displayData: `已授权本地文件夹: ${data?.root?.label || args.label || args.path}`,
+      };
+    },
+
+    async list(args: { rootId: string; relativePath?: string }, thunkApi: any, context?: { signal?: AbortSignal }): Promise<ToolResult> {
+      requireString(args.rootId, "rootId");
+      const data = await post(thunkApi, "/api/desktop/files/list", {
+        rootId: args.rootId,
+        relativePath: args.relativePath || ".",
+      }, context?.signal);
+      return {
+        rawData: data,
+        displayData: `已列出本地文件: ${args.relativePath || "."}`,
+      };
+    },
+
+    async read(args: { rootId: string; relativePath: string }, thunkApi: any, context?: { signal?: AbortSignal }): Promise<ToolResult> {
+      requireString(args.rootId, "rootId");
+      requireString(args.relativePath, "relativePath");
+      const data = await post(thunkApi, "/api/desktop/files/read", args, context?.signal);
+      return {
+        rawData: data,
+        displayData: `已读取本地文件: ${args.relativePath}`,
+      };
+    },
+
+    async propose(args: { rootId: string; summary: string; operations: LocalFileOperation[]; riskLevel?: "low" | "medium" | "high" }, thunkApi: any, context?: { signal?: AbortSignal }): Promise<ToolResult> {
+      requireString(args.rootId, "rootId");
+      requireString(args.summary, "summary");
+      if (!Array.isArray(args.operations) || args.operations.length === 0) {
+        throw new Error("operations 不能为空。");
+      }
+      const data = await post(thunkApi, "/api/desktop/files/plan", args, context?.signal);
+      return {
+        rawData: data,
+        displayData: `已创建本地文件整理计划，等待确认: ${args.summary}`,
+      };
+    },
+
+    async proposePreview(args: { rootId: string; summary: string; operations: LocalFileOperation[] }): Promise<ToolResult> {
+      return {
+        rawData: {
+          previewOnly: true,
+          rootId: args.rootId,
+          summary: args.summary,
+          operations: args.operations,
+        },
+        displayData: `待确认本地文件整理计划: ${args.summary}（${args.operations?.length ?? 0} 项）`,
+      };
+    },
+
+    async execute(args: { planId: string }, thunkApi: any, context?: { signal?: AbortSignal }): Promise<ToolResult> {
+      requireString(args.planId, "planId");
+      const data = await post(thunkApi, "/api/desktop/files/execute", args, context?.signal);
+      return {
+        rawData: data,
+        displayData: `已执行本地文件整理计划: ${args.planId}`,
+      };
+    },
+
+    async undo(args: { batchId: string }, thunkApi: any, context?: { signal?: AbortSignal }): Promise<ToolResult> {
+      requireString(args.batchId, "batchId");
+      const data = await post(thunkApi, "/api/desktop/files/undo", args, context?.signal);
+      return {
+        rawData: data,
+        displayData: `已撤销本地文件整理批次: ${args.batchId}`,
+      };
+    },
+  };
+}
+
+function requireString(value: unknown, name: string) {
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error(`${name} 必须是非空字符串。`);
+  }
+}
+
+const defaultHandlers = createLocalFilesToolHandlers();
+
+export const listLocalRootsFunc = defaultHandlers.listRoots;
+export const requestLocalFolderAccessFunc = defaultHandlers.requestRoot;
+export const listLocalFilesFunc = defaultHandlers.list;
+export const readLocalFileFunc = defaultHandlers.read;
+export const proposeLocalFileChangesFunc = defaultHandlers.propose;
+export const proposeLocalFileChangesPreviewFunc = defaultHandlers.proposePreview;
+export const executeApprovedLocalFileChangesFunc = defaultHandlers.execute;
+export const undoLocalFileChangeBatchFunc = defaultHandlers.undo;

package/ai/tools/marxistsOfflineBook.ts

@@ -0,0 +1,253 @@
+export type MarxistsOfflineBookPage = {
+  name: string;
+  url: string;
+  title: string;
+};
+
+export type MarxistsOfflineBookResult = {
+  title: string;
+  startUrl: string;
+  indexUrl: string;
+  stylesheetUrl: string | null;
+  pages: MarxistsOfflineBookPage[];
+  html: string;
+  validation: {
+    pageCount: number;
+    hasEmbeddedAssets: boolean;
+    hasNetworkUrls: boolean;
+    hasUtf8Meta: boolean;
+    byteLength: number;
+  };
+};
+
+export type ConvertMarxistsBookArgs = {
+  startUrl: string;
+  encoding?: string;
+  fetchImpl?: typeof fetch;
+  maxPages?: number;
+};
+
+const DEFAULT_ENCODING = "gb2312";
+const USER_AGENT =
+  "Mozilla/5.0 (compatible; NoloMarxistsOfflineBook/1.0; +https://nolo.chat)";
+
+const normalizeBookBaseUrl = (startUrl: string): URL => {
+  const parsed = new URL(startUrl);
+  if (!/^https?:$/i.test(parsed.protocol)) {
+    throw new Error("startUrl must be an http or https URL.");
+  }
+  return new URL("./", parsed);
+};
+
+const decodeBytes = (bytes: ArrayBuffer, encoding: string): string => {
+  try {
+    return new TextDecoder(encoding).decode(bytes);
+  } catch {
+    return new TextDecoder(DEFAULT_ENCODING).decode(bytes);
+  }
+};
+
+const fetchBytes = async (
+  url: string,
+  fetchImpl: typeof fetch,
+): Promise<ArrayBuffer> => {
+  const response = await fetchImpl(url, {
+    headers: {
+      "user-agent": USER_AGENT,
+      accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+    },
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to fetch ${url}: HTTP ${response.status}`);
+  }
+  return response.arrayBuffer();
+};
+
+const extractTitle = (html: string): string => {
+  return (
+    html.match(/<title>([\s\S]*?)<\/title>/i)?.[1]
+      ?.replace(/<[^>]+>/g, " ")
+      .replace(/\s+/g, " ")
+      .trim() || ""
+  );
+};
+
+const extractBody = (html: string): string => {
+  return html.match(/<body[^>]*>([\s\S]*?)<\/body>/i)?.[1] ?? html;
+};
+
+export const discoverMarxistsBookPageNames = (
+  indexHtml: string,
+  maxPages = 80,
+): string[] => {
+  const pageNames = [...indexHtml.matchAll(/href=["']?([^"' >#]+\.htm)(#[^"' >]*)?["']?/gi)]
+    .map((match) => match[1])
+    .filter((href) => !href.includes("/") && !href.startsWith(".."))
+    .map((href) => href.trim())
+    .filter(Boolean)
+    .sort();
+
+  const uniqueNames = Array.from(new Set(["index.htm", ...pageNames]));
+  if (uniqueNames.length <= 1) {
+    throw new Error("No same-directory .htm chapter links were found in index.htm.");
+  }
+  if (uniqueNames.length > maxPages) {
+    throw new Error(
+      `Refusing to download ${uniqueNames.length} pages; maxPages is ${maxPages}.`,
+    );
+  }
+  return uniqueNames;
+};
+
+const extractStylesheetHref = (html: string): string | null => {
+  return (
+    html.match(/<link[^>]+href=["']([^"']+\.css)["'][^>]*>/i)?.[1] ?? null
+  );
+};
+
+const guessMimeType = (url: string): string => {
+  const pathname = new URL(url).pathname.toLowerCase();
+  if (pathname.endsWith(".gif")) return "image/gif";
+  if (pathname.endsWith(".png")) return "image/png";
+  if (pathname.endsWith(".jpg") || pathname.endsWith(".jpeg")) return "image/jpeg";
+  if (pathname.endsWith(".webp")) return "image/webp";
+  if (pathname.endsWith(".css")) return "text/css";
+  return "application/octet-stream";
+};
+
+export const inlineCssUrlAssets = async (args: {
+  css: string;
+  cssUrl: string;
+  fetchImpl: typeof fetch;
+}): Promise<string> => {
+  const replacements = new Map<string, string>();
+  const matches = [...args.css.matchAll(/url\((['"]?)([^)'"]+)\1\)/gi)];
+
+  for (const match of matches) {
+    const rawRef = match[2].trim();
+    if (!rawRef || /^(data:|https?:)/i.test(rawRef)) continue;
+    const assetUrl = new URL(rawRef, args.cssUrl).toString();
+    if (!replacements.has(rawRef)) {
+      const bytes = await fetchBytes(assetUrl, args.fetchImpl);
+      const base64 = Buffer.from(bytes).toString("base64");
+      replacements.set(
+        rawRef,
+        `data:${guessMimeType(assetUrl)};base64,${base64}`,
+      );
+    }
+  }
+
+  return args.css.replace(/url\((['"]?)([^)'"]+)\1\)/gi, (full, quote, rawRef) => {
+    const replacement = replacements.get(String(rawRef).trim());
+    return replacement ? `url('${replacement}')` : full;
+  });
+};
+
+const rewriteLocalChapterLinks = (body: string): string => {
+  return body.replace(
+    /href=["']([^"']+\.htm)(#[^"']*)?["']/gi,
+    (_full, href: string, hash: string | undefined) => {
+      const anchor = href.replace(/\.htm$/i, "");
+      return `href="#${anchor}${hash ? `-${hash.replace(/^#/, "")}` : ""}"`;
+    },
+  );
+};
+
+const buildSingleHtml = (args: {
+  title: string;
+  css: string;
+  pages: Array<MarxistsOfflineBookPage & { body: string }>;
+}): string => {
+  const sections = args.pages.map((page) => {
+    const anchor = page.name.replace(/\.htm$/i, "");
+    return `<section class="chapter" id="${anchor}"><div class="chapter-source">${page.title}</div>${rewriteLocalChapterLinks(page.body)}</section>`;
+  });
+
+  return `<!doctype html>
+<html lang="zh-CN">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${args.title}</title>
+<style>
+${args.css}
+body { margin: 0 10px; }
+.table1 { max-width: 960px; width: min(960px, calc(100vw - 20px)); }
+.chapter { page-break-after: always; break-after: page; }
+.chapter-source { display: none; }
+@media screen and (max-width: 700px) {
+  html { margin-left: 8px !important; margin-right: 8px !important; }
+  body { margin-left: 8px !important; margin-right: 8px !important; }
+  .table1 { width: 100% !important; max-width: 100% !important; }
+  table { max-width: 100% !important; }
+}
+@media print {
+  .chapter { page-break-after: always; }
+}
+</style>
+</head>
+<body id="top">
+${sections.join("\n")}
+</body>
+</html>`;
+};
+
+export async function convertMarxistsBookToOfflineHtml(
+  args: ConvertMarxistsBookArgs,
+): Promise<MarxistsOfflineBookResult> {
+  const startUrl = args.startUrl?.trim();
+  if (!startUrl) throw new Error("startUrl is required.");
+
+  const fetchImpl = args.fetchImpl ?? fetch;
+  const encoding = args.encoding || DEFAULT_ENCODING;
+  const bookBaseUrl = normalizeBookBaseUrl(startUrl);
+  const indexUrl = new URL("index.htm", bookBaseUrl).toString();
+  const indexHtml = decodeBytes(await fetchBytes(indexUrl, fetchImpl), encoding);
+  const pageNames = discoverMarxistsBookPageNames(indexHtml, args.maxPages);
+
+  const pages: Array<MarxistsOfflineBookPage & { body: string }> = [];
+  for (const name of pageNames) {
+    const pageUrl = new URL(name, bookBaseUrl).toString();
+    const html = decodeBytes(await fetchBytes(pageUrl, fetchImpl), encoding);
+    pages.push({
+      name,
+      url: pageUrl,
+      title: extractTitle(html),
+      body: extractBody(html),
+    });
+  }
+
+  const stylesheetHref =
+    extractStylesheetHref(indexHtml) ||
+    pages.map((page) => extractStylesheetHref(page.body)).find(Boolean) ||
+    "../../MIA01.css";
+  const stylesheetUrl = stylesheetHref
+    ? new URL(stylesheetHref, indexUrl).toString()
+    : null;
+  const rawCss = stylesheetUrl
+    ? decodeBytes(await fetchBytes(stylesheetUrl, fetchImpl), encoding)
+    : "";
+  const css = stylesheetUrl
+    ? await inlineCssUrlAssets({ css: rawCss, cssUrl: stylesheetUrl, fetchImpl })
+    : rawCss;
+
+  const title = extractTitle(indexHtml) || pages[0]?.title || "Offline Book";
+  const html = buildSingleHtml({ title, css, pages });
+  const byteLength = new TextEncoder().encode(html).byteLength;
+
+  return {
+    title,
+    startUrl,
+    indexUrl,
+    stylesheetUrl,
+    pages: pages.map(({ body: _body, ...page }) => page),
+    html,
+    validation: {
+      pageCount: pages.length,
+      hasEmbeddedAssets: html.includes("data:image/"),
+      hasNetworkUrls: /https?:\/\//i.test(html),
+      hasUtf8Meta: html.includes('<meta charset="utf-8">'),
+      byteLength,
+    },
+  };
+}