nolo-cli 0.1.23 → 0.1.29

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/editor/utils/txtToSlate.ts

@@ -0,0 +1,40 @@
+import { Descendant } from "slate";
+
+/**
+ * 将纯文本字符串转换为 Slate.js 编辑器兼容的节点数组格式。
+ *
+ * 这个函数会将输入文本按换行符 `\n` 分割，并将每一行文本转换为一个独立的
+ * Slate `paragraph` 节点。这种结构是 Slate.js 用于表示富文本文档的基础。
+ *
+ * @param textContent - 从 .txt 文件或任何其他来源读取的纯文本内容。
+ * @returns Slate.js 格式的节点数组 (Descendant[])。如果输入为空或无效，
+ *          它会返回一个代表空文档的有效 Slate 结构。
+ */
+export const convertTxtToSlate = (textContent: string): Descendant[] => {
+  // 1. 处理边缘情况：
+  // 如果输入是 null、undefined 或者一个空字符串，返回一个标准的 Slate 空文档结构。
+  // 这可以防止下游消费者（如 Slate 编辑器）因接收到无效数据而崩溃。
+  // 一个标准的空文档包含一个空的段落。
+  if (!textContent) {
+    return [{ type: "paragraph", children: [{ text: "" }] }];
+  }
+
+  // 2. 分割文本为行：
+  // 使用换行符 `\n` 作为分隔符，将整个文本块分割成一个字符串数组。
+  // `split` 方法能很好地处理各种情况，包括末尾的换行符。
+  const lines = textContent.split("\n");
+
+  // 3. 将每一行映射为 Slate 段落节点：
+  // 遍历 `lines` 数组，对每一行文本执行转换。
+  // `map` 函数会为每一行返回一个新的对象，这个对象就是 Slate 的 `paragraph` 节点。
+  const slateContent: Descendant[] = lines.map((line) => ({
+    // `type: 'paragraph'` 定义了这个节点的类型。
+    type: "paragraph",
+    // `children` 是一个数组，包含了这个段落内的所有子节点。
+    // 对于纯文本转换，这里只有一个 `text` 节点。
+    children: [{ text: line }],
+  }));
+
+  // 4. 返回最终的 Slate 节点数组
+  return slateContent;
+};

package/create/hooks/category.ts

@@ -0,0 +1,82 @@
+// create/category/useCategories.ts
+import { useState } from "react";
+import { useAppDispatch, useAppSelector } from "../../app/store";
+import { selectUserId } from "../../auth/authSlice";
+import { write } from "../../database/dbSlice";
+import { DataType } from "../types";
+
+interface Category {
+  type: DataType.Category;
+  id: string;
+  name: string;
+  parentId?: string;
+  isCollapsed: boolean;
+  order: number;
+}
+
+interface CategoryConfig {
+  data: Category;
+  userId: string;
+}
+
+interface UseCategoriesResult {
+  create: (name: string, parentId?: string) => Promise<Category>;
+  toggleCollapse: (id: string) => Promise<Category>;
+  isLoading: boolean;
+  error: string | null;
+}
+
+export const useCategories = (): UseCategoriesResult => {
+  const dispatch = useAppDispatch();
+  const currentUserId = useAppSelector(selectUserId);
+
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  const create = async (name: string, parentId?: string): Promise<Category> => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const categoryConfig: CategoryConfig = {
+        data: {
+          type: DataType.Category,
+          name,
+          parentId,
+          isCollapsed: false,
+          order: 0, // You might want to determine this based on existing categories
+        },
+        userId: currentUserId,
+      };
+      const result = await dispatch(write(categoryConfig));
+      return result.payload;
+    } catch (err) {
+      setError("Failed to create category");
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  };
+
+  // const toggleCollapse = async (id: string): Promise<Category> => {
+  //   setIsLoading(true);
+  //   setError(null);
+  //   try {
+  //     const category = await getInfo(id);
+  //     const result = await dispatch(
+  //       patchData({ id, updates: { isCollapsed: !category.isCollapsed } }),
+  //     );
+  //     return result.payload;
+  //   } catch (err) {
+  //     setError("Failed to toggle category collapse");
+  //     throw err;
+  //   } finally {
+  //     setIsLoading(false);
+  //   }
+  // };
+
+  return {
+    create,
+    isLoading,
+    error,
+  };
+};

package/create/routePaths.ts

@@ -0,0 +1,5 @@
+// routePaths.ts
+export enum CreateRoutePaths {
+  CREATE = "create",
+  CREATE_AGENT = "create/agent",
+}

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;
+};