nolo-cli 0.1.21 → 0.1.23

package/render/layout/useDevReloadPending.ts

@@ -0,0 +1,30 @@
+// packages/render/layout/useDevReloadPending.ts
+import { useEffect, useState } from "react";
+
+/**
+ * 订阅 window.__DEV_RELOAD_PENDING__
+ * - 有新构建待刷新时返回 true
+ * - 自举保护期（suppress count > 0）内返回 false（静默等待）
+ */
+export const useDevReloadPending = (): boolean => {
+  const [pending, setPending] = useState(false);
+
+  useEffect(() => {
+    if (typeof window === "undefined") return;
+
+    const check = () => {
+      const w = window as any;
+      const isPending = w.__DEV_RELOAD_PENDING__ === true;
+      const suppressed =
+        typeof w.__DEV_RELOAD_SUPPRESS_COUNT__ === "number" &&
+        w.__DEV_RELOAD_SUPPRESS_COUNT__ > 0;
+      setPending(isPending && !suppressed);
+    };
+
+    check();
+    const id = setInterval(check, 500);
+    return () => clearInterval(id);
+  }, []);
+
+  return pending;
+};

package/render/page/createPageAction.ts

@@ -0,0 +1,183 @@
+// 文件路径: render/page/createPageAction.ts
+import { selectUserId } from "auth/authSlice";
+import {
+  addContentToSpace,
+  selectCurrentSpaceId,
+} from "create/space/spaceSlice";
+import { createPageKey } from "database/keys";
+import i18n from "app/i18n";
+import { DataType } from "create/types";
+import type { RootState, AppDispatch } from "app/store";
+import { write } from "database/dbSlice";
+import type { PageData } from "./types";
+import { format } from "date-fns";
+
+// 新增：把 markdown 转为 Slate 的工具 & 类型
+import { markdownToSlate } from "create/editor/transforms/markdownToSlate";
+import {
+  createEmptyParagraph,
+  splitSlateTitleAndBody,
+  type EditorContent,
+} from "create/editor/utils/slateUtils";
+import { slateToRenderMarkdown } from "create/editor/transforms/slateToRenderMarkdown";
+import { parseSkillDocProtocol } from "ai/skills/skillDocProtocol";
+import { buildSkillSummaryMarker } from "ai/skills/skillSummaryMarker";
+
+/**
+ * 归一化 / 过滤 categoryId
+ *
+ * 设计目标：
+ * - 允许正常的、看起来像 ID 的字符串通过；
+ * - 对 AI 乱编的 “读书笔记分类” / “分类一” / 超短数字 等，直接当成 undefined。
+ *
+ * 注意：这里的规则可以按你实际的 ID 生成规则调整。
+ */
+const normalizeCategoryId = (raw?: string): string | undefined => {
+  const trimmed = raw?.trim();
+  if (!trimmed) return undefined;
+
+  // 1) 过滤掉包含空格或非 ASCII 字符的情况
+  //    比如 “读书笔记分类” 会被直接判为无效
+  const asciiNoSpace = /^[\x20-\x7E]+$/; // 可见 ASCII 字符
+  if (!asciiNoSpace.test(trimmed)) return undefined;
+
+  // 2) 简单做个长度下限，避免 "1"、"abc" 这种明显不是 ID 的值
+  //    如果你的真实 ID 很短，可以把 8 调小一点
+  if (trimmed.length < 8) return undefined;
+
+  // 3) 如果你有更具体规则（如 UUID / nanoid），可以在这里再加一层匹配
+  // const idLike = /^[0-9a-zA-Z_-]{10,64}$/;
+  // if (!idLike.test(trimmed)) return undefined;
+
+  return trimmed;
+};
+
+export const createPageAction = async (
+  {
+    categoryId,
+    spaceId: customSpaceId,
+    title: initialTitle,
+    addMomentTag,
+    content,
+    slateData,
+  }: {
+    categoryId?: string;
+    spaceId?: string;
+    title?: string;
+    addMomentTag?: boolean;
+    content?: string; // 这里仍然接收 markdown 文本
+    slateData?: any; // 如果外部已经算好 Slate，可以直接传进来
+  } = {},
+  { dispatch, getState }: { dispatch: AppDispatch; getState: () => RootState }
+): Promise<string> => {
+  const state = getState();
+  const userId = selectUserId(state);
+  if (!userId) throw new Error("User ID not found.");
+
+  // Important:
+  // View-mode-based "create into current space vs no space" is decided by the UI entry
+  // that triggers creation (currently the sidebar-top create button).
+  // This action must preserve explicit caller intent:
+  // - if `spaceId` is provided, use it;
+  // - otherwise only fall back to the current selected space.
+  const spaceId = customSpaceId ?? selectCurrentSpaceId(state);
+  const { dbKey, id } = createPageKey.create(userId);
+
+  const now = new Date();
+  const dateStr = format(now, "yyyy-MM-dd HH:mm");
+  const defaultTitle = i18n.t("page:defaultTitleFormat", {
+    defaultValue: "{{date}} 的笔记",
+    date: dateStr,
+  });
+  let title = initialTitle?.trim() || defaultTitle;
+
+  const tags = addMomentTag ? ["moment"] : undefined;
+  let pageMeta: PageData["meta"] | undefined;
+
+  // ====== 根据 slateData / content 决定真正写入的 Slate 结构 ======
+  let initialSlateData: EditorContent;
+
+  if (slateData) {
+    // 1. 如果外部已经传了 Slate，直接使用（兼容旧调用）
+    initialSlateData = slateData as EditorContent;
+  } else if (content) {
+    const parsedProtocol = parseSkillDocProtocol(content);
+    const normalizedContent = parsedProtocol.content;
+    pageMeta = parsedProtocol.meta;
+    console.log("content", content);
+    // 2. 如果有 markdown content，优先尝试用 markdownToSlate 转成结构化 Slate
+    try {
+      const parsed = markdownToSlate(normalizedContent);
+      console.log("parsed", parsed);
+
+      if (Array.isArray(parsed) && parsed.length > 0) {
+        const split = splitSlateTitleAndBody(parsed, initialTitle);
+        title = initialTitle?.trim() || split.title || defaultTitle;
+        initialSlateData = split.body;
+      } else {
+        // 解析结果为空时，退回到简单的纯文本段落
+        initialSlateData = [
+          { type: "paragraph", children: [{ text: normalizedContent }] },
+        ];
+      }
+    } catch (e) {
+      // 解析失败兜底：仍然保留原始文本，但当成普通段落
+      console.error(
+        "[createPageAction] markdownToSlate failed, fallback to plain text:",
+        e
+      );
+      initialSlateData = [
+        { type: "paragraph", children: [{ text: normalizedContent }] },
+      ];
+    }
+  } else {
+    // 3. 完全没有内容，创建一个空白页面
+    initialSlateData = [createEmptyParagraph()];
+  }
+  // ====== 关键改动结束 ======
+
+  // 关键防御：对传入的 categoryId 做归一化 / 过滤
+  const safeCategoryId = normalizeCategoryId(categoryId);
+
+  const pageData: PageData = {
+    dbKey,
+    id,
+    type: DataType.DOC,
+    title,
+    spaceId,
+    slateData: initialSlateData,
+    // `content` 只作为只读展示缓存 / legacy bridge，真源仍是 `slateData`。
+    content:
+      typeof content === "string"
+        ? parseSkillDocProtocol(content, pageMeta).content ||
+          slateToRenderMarkdown(initialSlateData)
+        : slateToRenderMarkdown(initialSlateData),
+    tags,
+    created: now.toISOString(),
+    ...(pageMeta ? { meta: pageMeta } : {}),
+  };
+
+  const skillSummary = buildSkillSummaryMarker(pageMeta);
+
+  await dispatch(write({ data: pageData, customKey: dbKey })).unwrap();
+
+  if (spaceId) {
+    (dispatch as any)(
+      (addContentToSpace as any)({
+          contentKey: dbKey,
+          type: DataType.DOC,
+          spaceId,
+          title,
+          // 只使用经过 normalize 的 safeCategoryId
+          categoryId: safeCategoryId,
+          ...(skillSummary ? { skillSummary } : {}),
+        })
+      );
+  }
+
+  if (typeof window !== "undefined") {
+    window.dispatchEvent(new Event("nolo-user-data-updated"));
+  }
+
+  return dbKey;
+};

package/render/page/docSlice.ts

@@ -0,0 +1,468 @@
+// 文件: render/page/docSlice.ts
+
+import { formatISO } from "date-fns";
+import {
+  asyncThunkCreator,
+  buildCreateSlice,
+  createListenerMiddleware,
+  PayloadAction,
+  createSelector,
+} from "@reduxjs/toolkit";
+import { readAndWait, patch } from "database/dbSlice";
+import { updateContentTitle } from "create/space/spaceSlice";
+import type { EditorContent } from "create/editor/utils/slateUtils";
+import { DataType } from "create/types";
+import { PageData } from "./types";
+import type { PageSkillMetadata } from "ai/skills/skillDocProtocol";
+
+// —— State 接口 ——
+export interface DocState {
+  content: string | null;
+  slateData: EditorContent | null;
+  title: string | null;
+  dbSpaceId: string | null;
+  tags: string[] | null;
+  isReadOnly: boolean;
+  isLoading: boolean;
+  isInitialized: boolean;
+  error: string | null;
+  pageKey: string | null;
+  isSaving: boolean;
+  saveError: string | null;
+  lastSavedAt: string | null;
+  lastSavedSlateData: EditorContent | null;
+  lastSavedTitle: string | null;
+  justSaved: boolean;
+  tools: string[] | null;
+  meta: PageSkillMetadata | null;
+  id: string | null;
+  type: DataType | null;
+  focusContext: {
+    isFocused: boolean;
+    isCollapsed: boolean;
+    anchorPath: number[];
+    anchorOffset: number;
+    focusPath: number[];
+    focusOffset: number;
+    selectedText: string | null;
+    blockType: string | null;
+  } | null;
+}
+
+// —— 初始状态 ——
+const initialState: DocState = {
+  content: null,
+  slateData: null,
+  title: null,
+  dbSpaceId: null,
+  tags: null,
+  isReadOnly: true,
+  isLoading: false,
+  isInitialized: false,
+  error: null,
+  pageKey: null,
+  isSaving: false,
+  saveError: null,
+  lastSavedAt: null,
+  lastSavedSlateData: null,
+  lastSavedTitle: null,
+  justSaved: false,
+  tools: null,
+  meta: null,
+  id: null,
+  type: null,
+  focusContext: null,
+};
+
+const deepEqualEditorContent = (a: any, b: any): boolean => {
+  if (a === b) return true;
+  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 || a.length !== b.length) return false;
+    return a.every((item, index) => deepEqualEditorContent(item, b[index]));
+  }
+
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) return false;
+
+  return keysA.every((key) =>
+    Object.prototype.hasOwnProperty.call(b, key) && deepEqualEditorContent(a[key], b[key])
+  );
+};
+
+const hasSlateContentChanged = (
+  newContent: EditorContent | null,
+  oldContent: EditorContent | null
+) => {
+  if (newContent === oldContent) return false;
+  if (!newContent || !oldContent) return true;
+  if (newContent.length !== oldContent.length) return true;
+  return !deepEqualEditorContent(newContent, oldContent);
+};
+
+interface InitDocArgs {
+  pageKey: string;
+  isReadOnly: boolean;
+}
+
+interface InitDocPayload extends PageData {
+  isReadOnly: boolean;
+}
+
+interface SaveDocArgs {
+  pageKey: string;
+}
+
+const createSliceWithThunks = buildCreateSlice({
+  creators: { asyncThunk: asyncThunkCreator },
+});
+
+export const docSlice = createSliceWithThunks({
+  name: "doc",
+  initialState,
+  reducers: (create): any => ({
+    createDoc: create.asyncThunk(async (args: any, thunkApi: any) => {
+      const { createPageAction } = await import("./createPageAction");
+      return createPageAction(args, thunkApi);
+    }),
+
+    initDoc: create.asyncThunk(
+      async (args: InitDocArgs, { dispatch, rejectWithValue }) => {
+        const { pageKey, isReadOnly } = args;
+        try {
+          const readAction = await (dispatch as any)(readAndWait(pageKey));
+
+          if (readAndWait.fulfilled.match(readAction) && readAction.payload) {
+            const data = readAction.payload as PageData;
+
+            // docSlice 仅处理 DataType.DOC
+            if (data.type !== DataType.DOC) {
+              return rejectWithValue(`加载的内容 ${pageKey} 不是文档类型 (${data.type})`);
+            }
+
+            return { ...data, isReadOnly };
+          } else {
+            const msg =
+              (readAction.payload as any)?.message || `无法加载文档 ${pageKey}`;
+            return rejectWithValue(msg);
+          }
+        } catch (e: any) {
+          return rejectWithValue(e.message || `初始化文档 ${pageKey} 时出错`);
+        }
+      },
+      {
+        pending: (state, action) => {
+          Object.assign(state, initialState);
+          state.isLoading = true;
+          state.pageKey = action.meta.arg.pageKey;
+          state.isReadOnly = action.meta.arg.isReadOnly;
+        },
+        fulfilled: (state, action: PayloadAction<InitDocPayload>) => {
+          state.isLoading = false;
+          state.isInitialized = true;
+          state.error = null;
+          state.content = action.payload.content || null;
+          state.slateData = action.payload.slateData || null;
+          state.lastSavedSlateData = action.payload.slateData || null;
+          state.title = action.payload.title || null;
+          state.lastSavedTitle = action.payload.title || null;
+          state.dbSpaceId = action.payload.spaceId || null;
+          state.tags = action.payload.tags || null;
+          state.isReadOnly = action.payload.isReadOnly;
+          state.pageKey = action.payload.dbKey;
+          state.id = action.payload.id;
+          state.type = action.payload.type;
+          const payload = action.payload as any;
+          state.lastSavedAt = payload.updatedAt || payload.updated_at || null;
+          state.tools = action.payload.tools || null;
+          state.meta = action.payload.meta || null;
+        },
+        rejected: (state, action) => {
+          state.isLoading = false;
+          state.isInitialized = true;
+          state.error =
+            (action.payload as string) ||
+            action.error.message ||
+            "初始化文档时发生未知错误";
+        },
+      }
+    ),
+
+    updateSlate: create.reducer(
+      (state, action: PayloadAction<EditorContent>) => {
+        if (state.isInitialized && !state.isReadOnly) {
+          state.slateData = action.payload;
+          state.justSaved = false;
+        }
+      }
+    ),
+
+    updateTitle: create.reducer((state, action: PayloadAction<string>) => {
+      if (state.isInitialized && !state.isReadOnly) {
+        state.title = action.payload;
+        state.justSaved = false;
+      }
+    }),
+
+    saveDoc: create.asyncThunk(
+      async (arg: SaveDocArgs, { dispatch, getState, rejectWithValue }) => {
+        const requestedPageKey = arg.pageKey;
+        const state = (getState() as any).doc;
+        const { pageKey, slateData, dbSpaceId, meta } = state;
+
+        if (!pageKey || pageKey !== requestedPageKey) {
+          return rejectWithValue("内容已切换，取消保存");
+        }
+
+        if (!slateData) {
+          return rejectWithValue("内容为空，无法保存");
+        }
+
+        const [
+          { extractTitleFromSlate, extractMentionsFromSlate },
+          { slateToRenderMarkdown },
+          { buildSkillSummaryMarker },
+        ] = await Promise.all([
+          import("create/editor/utils/slateUtils"),
+          import("create/editor/transforms/slateToRenderMarkdown"),
+          import("ai/skills/skillSummaryMarker"),
+        ]);
+        const title =
+          (typeof state.title === "string" && state.title.trim()) ||
+          extractTitleFromSlate(slateData) ||
+          "未命名页面";
+        const tools = extractMentionsFromSlate(slateData);
+        const skillSummary = buildSkillSummaryMarker(meta);
+        // `content` 是只读展示缓存，保存时从当前 Slate 重新生成。
+        const content = slateToRenderMarkdown(slateData);
+        const now = new Date();
+        const updatedAt = formatISO(now);
+
+        try {
+          await (dispatch as (action: any) => any)(
+            patch({
+              dbKey: pageKey,
+              changes: {
+                updatedAt,
+                slateData,
+                title,
+                tools,
+                content,
+                ...(meta ? { meta } : {}),
+              },
+            })
+          ).unwrap();
+
+          if (dbSpaceId) {
+            await (dispatch as (action: any) => any)(
+              (updateContentTitle as any)({
+                spaceId: dbSpaceId,
+                contentKey: pageKey,
+                title,
+                skillSummary,
+              })
+            ).unwrap();
+          }
+
+          if (typeof window !== "undefined") {
+            window.dispatchEvent(new Event("nolo-user-data-updated"));
+          }
+
+          return { updatedAt, title, savedContent: slateData, content };
+        } catch (e: any) {
+          return rejectWithValue(e.message || "保存失败");
+        }
+      },
+      {
+        pending: (state) => {
+          state.isSaving = true;
+          state.saveError = null;
+          state.justSaved = false;
+        },
+        fulfilled: (
+          state,
+          action: PayloadAction<{
+            updatedAt: string;
+            title: string;
+            savedContent: any;
+            content: string;
+          }>
+        ) => {
+          state.isSaving = false;
+          state.lastSavedAt = action.payload.updatedAt;
+          state.title = action.payload.title;
+          state.content = action.payload.content;
+          state.lastSavedSlateData = action.payload.savedContent;
+          state.lastSavedTitle = action.payload.title;
+          state.justSaved = true;
+        },
+        rejected: (state, action) => {
+          state.isSaving = false;
+          state.saveError =
+            (action.payload as string) || action.error.message || "未知错误";
+          state.justSaved = false;
+        },
+      }
+    ),
+
+    resetJustSavedStatus: create.reducer((state) => {
+      state.justSaved = false;
+    }),
+
+    setDocFocusContext: create.reducer(
+      (state, action: PayloadAction<DocState["focusContext"]>) => {
+        state.focusContext = action.payload;
+      }
+    ),
+
+    toggleReadOnly: create.reducer((state) => {
+      state.isReadOnly = !state.isReadOnly;
+    }),
+    setReadOnly: create.reducer((state, action: PayloadAction<boolean>) => {
+      state.isReadOnly = action.payload;
+    }),
+    resetDoc: create.reducer((state) => {
+      Object.assign(state, initialState);
+    }),
+    updateDocTags: create.reducer((state, action: PayloadAction<string[]>) => {
+      if (state.isInitialized) state.tags = action.payload;
+    }),
+    previewDoc: create.reducer((state, action: PayloadAction<any>) => {
+      Object.assign(state, initialState);
+      state.isInitialized = true;
+      state.isLoading = false;
+      state.isReadOnly = true;
+      state.slateData = action.payload.slateData;
+      state.title = action.payload.title;
+      state.lastSavedTitle = action.payload.title;
+      state.pageKey = action.payload.dbKey;
+      state.id = action.payload.id;
+      state.type = action.payload.type || DataType.DOC;
+      state.lastSavedSlateData = action.payload.slateData;
+      state.tags = action.payload.tags || null;
+      state.dbSpaceId = action.payload.spaceId;
+      state.content = action.payload.content || null;
+      state.meta = action.payload.meta || null;
+    }),
+  }),
+});
+
+export const {
+  createDoc,
+  initDoc,
+  updateSlate,
+  updateTitle,
+  saveDoc,
+  resetJustSavedStatus,
+  setDocFocusContext,
+  toggleReadOnly,
+  setReadOnly,
+  resetDoc,
+  updateDocTags,
+  previewDoc,
+} = docSlice.actions;
+
+const selectDocState = (state: any) => state.doc;
+
+export const selectDoc = (state: any) => state.doc;
+
+export const selectSlateData = createSelector(
+  [selectDocState],
+  (doc) => doc.slateData
+);
+
+export const selectDocIsLoading = createSelector(
+  [selectDocState],
+  (doc) => doc.isLoading
+);
+
+export const selectIsReadOnly = createSelector(
+  [selectDocState],
+  (doc) => doc.isReadOnly
+);
+
+export const selectDocIsInitialized = createSelector(
+  [selectDocState],
+  (doc) => doc.isInitialized
+);
+
+export const selectDocError = createSelector(
+  [selectDocState],
+  (doc) => doc.error
+);
+
+export const selectIsSaving = createSelector(
+  [selectDocState],
+  (doc) => doc.isSaving
+);
+
+export const selectSaveError = createSelector(
+  [selectDocState],
+  (doc) => doc.saveError
+);
+
+export const selectJustSaved = createSelector(
+  [selectDocState],
+  (doc) => doc.justSaved
+);
+
+export const selectDocTitle = createSelector(
+  [selectDocState],
+  (doc) => doc.title
+);
+
+export const selectHasPendingChanges = createSelector(
+  [
+    selectSlateData,
+    (state: any) => state.doc.lastSavedSlateData,
+    selectDocTitle,
+    (state: any) => state.doc.lastSavedTitle,
+    selectIsReadOnly,
+    selectDocIsInitialized,
+  ],
+  (slateData, lastSavedSlateData, title, lastSavedTitle, isReadOnly, isInitialized) => {
+    if (!isInitialized || isReadOnly) return false;
+    return (
+      hasSlateContentChanged(slateData, lastSavedSlateData) ||
+      (title || "") !== (lastSavedTitle || "")
+    );
+  }
+);
+
+export const selectDocSpaceId = createSelector(
+  [selectDocState],
+  (doc) => doc.dbSpaceId
+);
+
+export const selectDocId = createSelector(
+  [selectDocState],
+  (doc) => doc.id
+);
+
+export const selectDocKey = createSelector(
+  [selectDocState],
+  (doc) => doc.pageKey
+);
+
+export const selectDocTags = createSelector(
+  [selectDocState],
+  (doc) => doc.tags
+);
+
+export const selectDocFocusContext = createSelector(
+  [selectDocState],
+  (doc) => doc.focusContext
+);
+
+export const selectLastSavedAt = createSelector(
+  [selectDocState],
+  (doc) => doc.lastSavedAt
+);
+
+export default docSlice.reducer;
+export const docListenerMiddleware = createListenerMiddleware();