nolo-cli 0.1.31 → 0.1.33

package/create/editor/utils/slateUtils.ts

@@ -1,233 +0,0 @@
-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

@@ -1,40 +0,0 @@
-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

@@ -1,82 +0,0 @@
-// 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

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

package/create/space/addSpaceAction.ts

@@ -1,193 +0,0 @@
-// 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;
-};