nolo-cli 0.1.39 → 0.1.41

package/create/editor/transforms/slateToSimplifiedMarkdown.ts

@@ -0,0 +1,224 @@
+type SimplifiedMarkdownOptions = {
+  mentionResolver?: (node: any) => string;
+};
+
+function renderTextNode(node: any): string {
+  if (!node || typeof node.text !== "string") return "";
+
+  let text = node.text;
+  if (!text) return "";
+
+  if (node.bold) text = `**${text}**`;
+  if (node.italic) text = `*${text}*`;
+  if (node.strikethrough) text = `~~${text}~~`;
+  return text;
+}
+
+function renderPlainText(node: any, options: SimplifiedMarkdownOptions = {}): string {
+  if (!node) return "";
+  if (typeof node.text === "string") return renderTextNode(node);
+  if (!Array.isArray(node.children)) return "";
+  return node.children.map((child: any) => renderPlainText(child, options)).join("");
+}
+
+function renderTable(node: any, listDepth: number, options: SimplifiedMarkdownOptions): string {
+  const rows = Array.isArray(node.children) ? node.children : [];
+  if (rows.length === 0) return "";
+
+  const alignments = Array.isArray(node.columns)
+    ? node.columns.map((column: any) => column?.align || "left")
+    : [];
+
+  const renderedRows = rows.map((row: any) =>
+    (Array.isArray(row?.children) ? row.children : []).map((cell: any) => {
+      const content = renderPlainText(cell, options).replace(/\n+/g, " ").trim();
+      return content || " ";
+    })
+  );
+
+  const header = renderedRows[0] || [];
+  const divider = header.map((_, index) => {
+    const align = alignments[index];
+    if (align === "center") return ":---:";
+    if (align === "right") return "---:";
+    return "---";
+  });
+  const body = renderedRows.slice(1);
+
+  const allRows = [header, divider, ...body]
+    .map((cells) => `| ${cells.join(" | ")} |`)
+    .join("\n");
+
+  return `${allRows}\n\n`;
+}
+
+function renderListItem(
+  node: any,
+  listDepth: number,
+  ordered: boolean,
+  start: number,
+  index: number,
+  options: SimplifiedMarkdownOptions = {}
+): string {
+  const indentation = "  ".repeat(listDepth);
+  const marker = node.checked === true
+    ? "- [x]"
+    : node.checked === false
+      ? "- [ ]"
+      : ordered
+        ? `${start + index}.`
+        : "-";
+
+  const segments = Array.isArray(node.children) ? node.children : [];
+  const renderedSegments = segments
+    .map((child: any) => renderNode(child, listDepth + 1, options).trimEnd())
+    .filter(Boolean);
+
+  if (renderedSegments.length === 0) {
+    return `${indentation}${marker}\n`;
+  }
+
+  const [first, ...rest] = renderedSegments;
+  const lines = first.split("\n");
+  const firstLine = lines.shift() || "";
+  const restFirst = lines.map((line) => `${indentation}  ${line}`).join("\n");
+  const restBlocks = rest.map((block) => `${indentation}  ${block}`).join("\n");
+
+  return [
+    `${indentation}${marker} ${firstLine}`,
+    restFirst,
+    restBlocks,
+  ]
+    .filter(Boolean)
+    .join("\n") + "\n";
+}
+
+/**
+ * 递归地把 Slate 节点线性化为“易读 markdown”。
+ * 这里的目标是让 AI / 工具读取时更稳定，不追求展示侧的视觉保真。
+ */
+function renderNode(
+  node: any,
+  listDepth = 0,
+  options: SimplifiedMarkdownOptions = {}
+): string {
+  if (!node) return "";
+  const indentation = "  ".repeat(listDepth);
+
+  switch (node.type) {
+    case "heading-one":
+      return `# ${node.children.map((n: any) => renderNode(n, listDepth, options)).join("")}\n\n`;
+    case "heading-two":
+      return `## ${node.children.map((n: any) => renderNode(n, listDepth, options)).join("")}\n\n`;
+    case "heading-three":
+      return `### ${node.children.map((n: any) => renderNode(n, listDepth, options)).join("")}\n\n`;
+    case "heading-four":
+      return `#### ${node.children.map((n: any) => renderNode(n, listDepth, options)).join("")}\n\n`;
+    case "heading-five":
+      return `##### ${node.children.map((n: any) => renderNode(n, listDepth, options)).join("")}\n\n`;
+    case "heading-six":
+      return `###### ${node.children.map((n: any) => renderNode(n, listDepth, options)).join("")}\n\n`;
+
+    case "paragraph":
+      return `${node.children.map((n: any) => renderNode(n, listDepth, options)).join("")}\n\n`;
+
+    case "list":
+      return node.children
+        .map((item: any, index: number) =>
+          renderListItem(item, listDepth, !!node.ordered, node.start || 1, index, options)
+        )
+        .join("");
+
+    case "list-item":
+      return renderListItem(node, listDepth, false, 1, 0, options);
+
+    case "quote":
+      const content = node.children
+        .map((n: any) => renderNode(n, listDepth, options))
+        .join("")
+        .trim();
+      return `> ${content.replace(/\n/g, "\n> ")}\n\n`;
+
+    case "code-block":
+      const code = node.children
+        .map((line: any) =>
+          (line.children || []).map((text: any) => text.text).join("")
+        )
+        .join("\n");
+      return "```" + (node.language || "") + "\n" + code + "\n```\n\n";
+
+    case "link":
+      const linkText = node.children
+        .map((n: any) => renderNode(n, listDepth, options))
+        .join("");
+      return `[${linkText}](${node.url})`;
+
+    case "table":
+      return renderTable(node, listDepth, options);
+
+    case "code-inline":
+      return `\`${node.children.map((n: any) => renderNode(n, listDepth, options)).join("")}\``;
+
+    case "mention": {
+      if (options.mentionResolver) {
+        return options.mentionResolver(node);
+      }
+      const label = node.label || node.resourceId || "mention";
+      const resourceType = node.resourceType || "unknown";
+      const resourceId = node.resourceId || "unknown";
+      // AI / 工具链仍依赖 mention 的可逆文本表示。
+      return `@[${resourceType}:${resourceId}|${label}]`;
+    }
+
+    case "image": {
+      const alt = node.alt || "";
+      const title = node.title ? ` "${node.title}"` : "";
+      return `![${alt}](${node.url || ""}${title})`;
+    }
+
+    case "html-inline":
+      return typeof node.html === "string" ? node.html : "";
+
+    case "html-block":
+      return typeof node.html === "string" ? `${node.html}\n\n` : "";
+
+    case "thematic-break":
+      return "---\n\n";
+
+    default:
+      return (
+        renderTextNode(node) ||
+        (node.children
+          ? node.children
+            .map((child: any) => renderNode(child, listDepth, options))
+            .join("")
+          : "")
+      );
+  }
+}
+
+/**
+ * 把 Slate 转成给 AI / 工具消费的 markdown 文本。
+ *
+ * 目标：
+ * - 保留结构信息，让模型和工具容易读。
+ * - 保持 mention 等关键语义可逆。
+ *
+ * 非目标：
+ * - 不保证展示侧完全复刻编辑器视觉。
+ * - 不作为只读渲染缓存；展示侧请用 `slateToRenderMarkdown`。
+ */
+export function slateToSimplifiedMarkdown(
+  nodes: any[],
+  options: SimplifiedMarkdownOptions = {}
+): string {
+  if (!nodes || nodes.length === 0) {
+    return "";
+  }
+  return (
+    nodes
+      .map((node) => renderNode(node, 0, options))
+      .join("")
+      .trim() + "\n"
+  );
+}

package/create/editor/transforms/slateToText.ts

@@ -0,0 +1,33 @@
+/**
+ * 这是一个递归的辅助函数，用于从单个 Slate 节点及其子节点中提取所有文本内容。
+ * @param node 当前要处理的 Slate 节点。
+ * @returns 提取出的文本字符串。
+ */
+function getNodeText(node: any): string {
+  // 如果是文本节点，直接返回其文本内容
+  if (node.text) {
+    return node.text;
+  }
+
+  // 如果是元素节点（且非空），则递归地处理其所有子节点，
+  // 并将结果用适当的分隔符连接。对于大多数块级元素，换行符是合适的。
+  if (node.children && Array.isArray(node.children)) {
+    return node.children.map(getNodeText).join("\n");
+  }
+
+  // 对于其他情况（如空节点或无子节点的元素），返回空字符串
+  return "";
+}
+
+/**
+ * 将 Slate 节点数组转换为一个单一的、拼接好的纯文本字符串。
+ * @param nodes Slate 节点数组。
+ * @returns 拼接后的纯文本字符串，顶层节点间用双换行符分隔以模拟段落。
+ */
+export function slateToText(nodes: any[]): string {
+  if (!nodes || nodes.length === 0) {
+    return "";
+  }
+
+  return nodes.map(getNodeText).join("\n\n");
+}

package/create/editor/utils/slateUtils.ts

@@ -0,0 +1,233 @@
+import { Node } from "slate";
+
+// ================ 类型定义 ================
+export type EditorContent = Array<{
+  type: string;
+  children: Array<{ text: string;[key: string]: any }>;
+  [key: string]: any;
+}>;
+
+export const createEmptyParagraph = () => ({
+  type: "paragraph",
+  children: [{ text: "" }],
+});
+
+export const ensureEditorContent = (
+  slateData: EditorContent | null | undefined
+): EditorContent =>
+  Array.isArray(slateData) && slateData.length > 0
+    ? slateData
+    : [createEmptyParagraph()];
+
+// ================ 工具函数 ================
+
+/**
+ * 原生实现的深度比较
+ * 仅考虑普通对象、数组、基本类型，适用于 Slate Node 这类 JSON 结构
+ */
+const deepEqual = (a: any, b: any): boolean => {
+  // 引用相同或值相同（包含基本类型）
+  if (a === b) return true;
+
+  // 其中一个为 null 或 undefined
+  if (a == null || b == null) return false;
+
+  // 类型不同
+  if (typeof a !== "object" || typeof b !== "object") return false;
+
+  // 数组比较
+  const isArrayA = Array.isArray(a);
+  const isArrayB = Array.isArray(b);
+  if (isArrayA || isArrayB) {
+    if (!isArrayA || !isArrayB) return false;
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (!deepEqual(a[i], b[i])) return false;
+    }
+    return true;
+  }
+
+  // 普通对象比较
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) return false;
+
+  for (const key of keysA) {
+    if (!Object.prototype.hasOwnProperty.call(b, key)) return false;
+    if (!deepEqual(a[key], b[key])) return false;
+  }
+
+  return true;
+};
+
+/**
+ * 比较两个 Slate 内容是否相同
+ * @param newContent 新内容
+ * @param oldContent 旧内容
+ * @returns {boolean} true 如果内容不同，false 如果内容相同
+ */
+export const compareSlateContent = (
+  newContent: EditorContent | null,
+  oldContent: EditorContent | null
+): boolean => {
+  // 快速引用检查
+  if (newContent === oldContent) return false; // 内容相同，未发生变化
+
+  // 空值检查
+  if (!newContent || !oldContent) return true; // 内容不同
+
+  // 长度检查 (作为另一层快速检查)
+  if (newContent.length !== oldContent.length) return true; // 内容不同
+
+  // 使用原生 deepEqual 进行深度比较
+  // deepEqual 返回 true 表示内容相同，所以需要取反
+  return !deepEqual(newContent, oldContent);
+};
+
+/**
+ * 从 Slate 数据中提取页面标题
+ * @param slateData Slate 编辑器内容数据
+ * @returns {string} 提取的标题或默认值 "新页面"
+ */
+export const extractTitleFromSlate = (slateData: EditorContent): string => {
+  if (!Array.isArray(slateData) || slateData.length === 0) return "新页面";
+
+  // 优先查找 heading-one 元素作为标题
+  const titleNode = slateData.find((node) => node.type === "heading-one");
+
+  if (titleNode) {
+    // 使用 Slate 内置的 Node.string 工具，可靠地提取所有文本，即使标题中有格式
+    const text = Node.string(titleNode).trim();
+    if (text) {
+      return text;
+    }
+  }
+
+  // 回退到查找第一个包含非空文本的块元素
+  for (const node of slateData) {
+    const text = Node.string(node).trim();
+    if (text) {
+      return text.length > 30 ? `${text.substring(0, 30)}...` : text;
+    }
+  }
+
+  return "新页面";
+};
+
+export const splitSlateTitleAndBody = (
+  slateData: EditorContent | null | undefined,
+  explicitTitle?: string | null
+): { title: string; body: EditorContent } => {
+  const content = ensureEditorContent(slateData);
+  const firstNode = content[0];
+  const normalizedExplicitTitle = explicitTitle?.trim() || "";
+  const firstNonEmptyText = content
+    .map((node) => Node.string(node).trim())
+    .find(Boolean);
+
+  if (firstNode?.type === "heading-one") {
+    const firstText = Node.string(firstNode).trim();
+    const shouldTreatAsTitle =
+      !!firstText &&
+      (!normalizedExplicitTitle || normalizedExplicitTitle === firstText);
+
+    if (shouldTreatAsTitle) {
+      const body = content.slice(1);
+      return {
+        title: firstText,
+        body: ensureEditorContent(body),
+      };
+    }
+  }
+
+  return {
+    title: normalizedExplicitTitle || firstNonEmptyText || "",
+    body: content,
+  };
+};
+
+/**
+ * 从 Slate 数据中提取所有提及 (Mention) 的资源 ID
+ * @param slateData Slate 编辑器内容数据
+ * @returns {string[]} 去重后的资源 ID 列表
+ */
+// Return only tool IDs to maintain backward compatibility with 'tools' DB field
+export const extractMentionsFromSlate = (slateData: EditorContent): string[] => {
+  const tools = new Set<string>();
+
+  const traverse = (nodes: any[]) => {
+    for (const node of nodes) {
+      if (node.type === "mention" && node.resourceId) {
+        // Only collect if it's explicitly a tool, OR if resourceType is missing (legacy assumption?)
+        // Better to be strict: only tools.
+        if (node.resourceType === "tool") {
+          tools.add(node.resourceId);
+        }
+      }
+      if (node.children && Array.isArray(node.children)) {
+        traverse(node.children);
+      }
+    }
+  };
+
+  if (Array.isArray(slateData)) {
+    traverse(slateData);
+  }
+
+  return Array.from(tools);
+};
+
+export interface CategorizedMentions {
+  tools: string[];
+  pages: string[];
+  agents: string[];
+  spaces: string[];
+}
+
+/**
+ * Extract categorized mentions for Context assembly
+ */
+export const extractCategorizedMentions = (slateData: EditorContent): CategorizedMentions => {
+  const result: CategorizedMentions = {
+    tools: [],
+    pages: [],
+    agents: [],
+    spaces: []
+  };
+
+  const traverse = (nodes: any[]) => {
+    for (const node of nodes) {
+      if (node.type === "mention" && node.resourceId && node.resourceType) {
+        switch (node.resourceType) {
+          case "tool":
+            result.tools.push(node.resourceId);
+            break;
+          case "page":
+            result.pages.push(node.resourceId);
+            break;
+          case "agent":
+            result.agents.push(node.resourceId);
+            break;
+          case "space":
+            result.spaces.push(node.resourceId);
+            break;
+        }
+      }
+      if (node.children && Array.isArray(node.children)) {
+        traverse(node.children);
+      }
+    }
+  };
+
+  if (Array.isArray(slateData)) {
+    traverse(slateData);
+  }
+
+  // Deduplicate
+  result.tools = [...new Set(result.tools)];
+  result.pages = [...new Set(result.pages)];
+  result.agents = [...new Set(result.agents)];
+  result.spaces = [...new Set(result.spaces)];
+
+  return result;
+};

package/create/space/addSpaceAction.ts

@@ -0,0 +1,193 @@
+// app/space/addSpaceAction.ts
+
+import { SpaceMemberWithSpaceInfo } from "../../app/types";
+import {
+  MemberRole,
+  SpaceVisibility,
+  SpaceData,
+  SpaceContent,
+} from "../../app/types";
+import { selectUserId } from "../../auth/authSlice";
+import { DataType } from "../types";
+import { fetchUserData } from "../../database/client/fetchUserData";
+import { ulid } from "ulid";
+import { patch, write } from "../../database/dbSlice";
+import { createSpaceKey } from "../space/spaceKeys";
+import { CreateSpaceRequest, selectAllMemberSpaces } from "./spaceSlice";
+import type { AppDispatch, RootState } from "../../app/store";
+
+//
+// Helper: 一次性读取本地用户数据
+//
+interface BaseItem {
+  id: string;
+  type: DataType;
+  userId: string;
+  createdAt?: string | number;
+  updatedAt?: string | number;
+  [key: string]: any;
+}
+
+interface GetUserDataOptions {
+  types: DataType | DataType[];
+  userId: string;
+  limit: number;
+  isLoggedIn?: boolean;
+  currentUserId?: string;
+  db: any;
+}
+
+async function getUserDataOnce({
+  types,
+  userId,
+  limit,
+  isLoggedIn = false,
+  currentUserId,
+  db,
+}: GetUserDataOptions): Promise<{
+  data: BaseItem[];
+  error?: Error;
+}> {
+  try {
+    const typeArray = Array.isArray(types) ? types : [types];
+    const effectiveUserId =
+      userId === "local" && isLoggedIn && currentUserId
+        ? currentUserId
+        : userId;
+    const localResults = await fetchUserData(db, typeArray, effectiveUserId);
+    const localData = Object.values(localResults).flat();
+    return { data: localData };
+  } catch (err) {
+    const error =
+      err instanceof Error ? err : new Error("Unknown error occurred");
+    return { data: [], error };
+  }
+}
+
+const targetTypes: DataType[] = [DataType.DIALOG, DataType.DOC];
+
+const getCurrentPathForLog = () =>
+  typeof window !== "undefined" &&
+  typeof window.location?.pathname === "string"
+    ? window.location.pathname
+    : undefined;
+
+/**
+ * 新增 Space，包括首次迁移旧侧边栏数据到 Space.contents
+ */
+export const addSpaceAction = async (
+  input: CreateSpaceRequest,
+  thunkAPI: { dispatch: AppDispatch; getState: () => RootState; extra: { db: any } }
+): Promise<SpaceMemberWithSpaceInfo> => {
+  const {
+    name,
+    description = "",
+    visibility = SpaceVisibility.PRIVATE,
+  } = input;
+  const { dispatch, getState, extra } = thunkAPI;
+  const state = getState();
+  const userId = selectUserId(state);
+  if (!userId) throw new Error("User is not logged in.");
+
+  const spaceId = ulid();
+  const now = Date.now();
+  const nowISO = new Date(now).toISOString();
+
+  // 基本 Space 数据
+  const spaceData: SpaceData = {
+    id: spaceId,
+    name,
+    description,
+    ownerId: userId,
+    visibility,
+    members: [userId],
+    categories: {},
+    contents: {},
+    createdAt: now,
+    updatedAt: now,
+    type: DataType.SPACE,
+  };
+
+  const spaces = selectAllMemberSpaces(state);
+  const hasSpace = spaces.length > 0;
+
+  console.info("[space/create] addSpaceAction", {
+    userId,
+    name,
+    visibility,
+    memberSpaceCount: spaces.length,
+    currentPath: getCurrentPathForLog(),
+  });
+
+  if (!hasSpace) {
+    // 首次创建 Space 时尝试迁移旧侧边栏数据
+    const { data: oldItems = [] } = await getUserDataOnce({
+      types: targetTypes,
+      userId,
+      limit: 100,
+      db: extra.db,
+    });
+
+    const hasOldSideData = oldItems.length > 0;
+    if (hasOldSideData) {
+      const contents: Record<string, SpaceContent> = {};
+      const updatePromises: Promise<any>[] = [];
+
+      for (const item of oldItems) {
+        if (!item.id || !item.type) continue;
+        const stableContentKey =
+          typeof item.dbKey === "string" && item.dbKey.trim()
+            ? item.dbKey
+            : item.id;
+        contents[stableContentKey] = {
+          title: item.title || "",
+          type: item.type,
+          contentKey: stableContentKey,
+          categoryId: "",
+          pinned: false,
+          createdAt: item.createdAt ?? now,
+          updatedAt: item.updatedAt ?? now,
+          order: item.order,
+        };
+        if (item.dbKey) {
+          updatePromises.push(
+            dispatch(
+              patch({
+                dbKey: item.dbKey,
+                changes: { spaceId, updatedAt: now },
+              })
+            )
+          );
+        }
+      }
+      spaceData.contents = contents;
+      await Promise.all(updatePromises);
+    }
+  }
+
+  // 写入 Space
+  const spaceKey = createSpaceKey.space(spaceId);
+  await dispatch(write({ data: spaceData, customKey: spaceKey })).unwrap();
+
+  // 写入 SpaceMember
+  const spaceMemberKey = createSpaceKey.member(userId, spaceId);
+  const spaceMemberData: SpaceMemberWithSpaceInfo = {
+    dbKey: spaceMemberKey,
+    type: DataType.SPACE,
+    userId,
+    role: MemberRole.OWNER,
+    joinedAt: now,
+    spaceId,
+    spaceName: name,
+    ownerId: userId,
+    visibility,
+    createdAt: nowISO,
+    updatedAt: nowISO,
+  };
+
+  await dispatch(
+    write({ data: spaceMemberData, customKey: spaceMemberKey })
+  ).unwrap();
+
+  return spaceMemberData;
+};