nolo-cli 0.1.23 → 0.1.29

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/types.ts

@@ -0,0 +1,120 @@
+// 基础元素类型常量
+export const ParagraphType = "paragraph";
+export const CodeBlockType = "code-block";
+export const CodeLineType = "code-line";
+export const QuoteType = "quote";
+export const ThematicBreakType = "thematic-break";
+
+// 列表相关类型
+export const ListType = "list";
+export const ListItemType = "list-item";
+
+// 表格相关类型
+export const TableType = "table";
+export const TableRowType = "table-row";
+export const TableCellType = "table-cell";
+
+// 格式化文本类型
+type FormattedText = {
+  text: string;
+  bold?: boolean;
+  italic?: boolean;
+  underline?: boolean;
+  strikethrough?: boolean;
+  code?: boolean;
+};
+
+// 标题类型枚举
+export enum HeadingType {
+  H1 = "heading-one",
+  H2 = "heading-two",
+  H3 = "heading-three",
+  H4 = "heading-four",
+  H5 = "heading-five",
+  H6 = "heading-six",
+}
+
+// 链接元素类型
+export type LinkElement = {
+  type: "link";
+  url: string;
+  children: FormattedText[];
+};
+
+// 文本块元素类型
+export type TextBlockElement = {
+  type:
+  | HeadingType
+  | typeof ParagraphType
+  | typeof QuoteType
+  | typeof ThematicBreakType;
+  align?: "left" | "center" | "right" | "justify";
+  isNested?: boolean;
+  cite?: string; // 用于引用块
+  children: FormattedText[];
+};
+
+// 列表元素类型
+export type ListElement = {
+  type: typeof ListType;
+  ordered?: boolean;
+  children: ListItemElement[];
+};
+
+export type ListItemElement = {
+  type: typeof ListItemType;
+  checked?: boolean; // 用于任务列表
+  indent?: number; // 扁平存储下的列表层级，便于后续按节点拆分/索引
+  children: (FormattedText | TextBlockElement)[];
+};
+
+// 表格元素类型
+export type TableElement = {
+  type: typeof TableType;
+  children: TableRowElement[];
+};
+
+export type TableRowElement = {
+  type: typeof TableRowType;
+  children: TableCellElement[];
+};
+
+export type TableCellElement = {
+  type: typeof TableCellType;
+  header?: boolean;
+  children: FormattedText[];
+};
+
+// 代码块元素类型
+export type CodeBlockElement = {
+  type: typeof CodeBlockType;
+  language?: string;
+  children: CodeLineElement[];
+};
+
+export type CodeLineElement = {
+  type: typeof CodeLineType;
+  children: FormattedText[];
+};
+
+// Mention element type
+export type MentionElement = {
+  type: "mention";
+  resourceType: "tool" | "page" | "agent" | "space";
+  resourceId: string;
+  label: string;
+  children: FormattedText[];
+};
+
+// 统一的元素类型联合
+export type Element =
+  | TextBlockElement
+  | ListElement
+  | ListItemElement
+  | TableElement
+  | TableRowElement
+  | TableCellElement
+  | CodeBlockElement
+  | CodeLineElement
+  | LinkElement
+  | MentionElement;

package/create/editor/utils/editorFactory.ts

@@ -0,0 +1,54 @@
+import {
+    Editor,
+    Element as SlateElement,
+    createEditor,
+} from "slate";
+import { withHistory, History } from "slate-history";
+import {
+    withReact,
+    ReactEditor,
+} from "slate-react";
+
+import { withLayout } from "../plugins/withLayout";
+import { withShortcuts } from "../plugins/withShortcuts";
+import { withLinks } from "../plugins/withLinks";
+import { withTables } from "../plugins/withTables";
+import { withChineseTypography } from "../plugins/withChineseTypography";
+import { withMentions } from "../plugins/withMentions";
+import { withBlockStructure } from "../plugins/withBlockStructure";
+
+// Need CustomEditor type, but it's defined in Editor.tsx.
+// Should separate types or import/copy.
+// I'll define it here locally or import.
+// For now, I'll export CustomEditor from Editor.tsx or define it here if simple.
+// It's `ReactEditor & History & { nodeToDecorations?: Map<SlateElement, Range[]> }`.
+
+export type CustomEditor = ReactEditor &
+    History & {
+        nodeToDecorations?: Map<SlateElement, Range[]>;
+        isInline: (element: SlateElement) => boolean;
+    };
+
+/**
+ * 创建带所有插件的编辑器实例
+ */
+export const createNoloEditor = (): CustomEditor => {
+    const reactEditor = withReact(createEditor() as ReactEditor);
+    const historyEditor = withHistory(reactEditor);
+    const linksEditor = withLinks(historyEditor);
+    const layoutEditor = withLayout(linksEditor);
+    const blockStructureEditor = withBlockStructure(layoutEditor);
+    const shortcutsEditor = withShortcuts(blockStructureEditor);
+    const typographyEditor = withChineseTypography(shortcutsEditor);
+    const tablesEditor = withTables(typographyEditor);
+    const mentionsEditor = withMentions(tablesEditor);
+
+    const baseEditor = mentionsEditor as CustomEditor;
+
+    // 只扩展 code-inline 为 inline；image 不声明为 void，方便 Caption 编辑
+    const { isInline } = baseEditor;
+    baseEditor.isInline = (element: SlateElement) =>
+        (element as any).type === "code-inline" ? true : isInline(element);
+
+    return baseEditor;
+};

package/create/editor/utils/hasPlainCodeBlock.ts

@@ -0,0 +1,39 @@
+import { Descendant } from "slate";
+import { Element as SlateElement } from "slate";
+import { CodeBlockType } from "../types";
+
+/**
+ * 是否存在需要语法高亮的 code block：
+ * - 节点类型为 code block
+ * - 且 preview !== "true"
+ */
+export function hasPlainCodeBlock(nodes: Descendant[]): boolean {
+  return nodes.some((node) => {
+    if (!SlateElement.isElement(node)) return false;
+    if (node.type === CodeBlockType) {
+      return (node as any).preview !== "true";
+    }
+    const children = (node as any).children as Descendant[] | undefined;
+    return Array.isArray(children) && hasPlainCodeBlock(children);
+  });
+}
+
+/**
+ * 收集需要高亮的 code block 所使用的语言（小写）。
+ * 后续按需加载 Prism 语言包会用到。
+ */
+export function collectCodeBlockLanguages(nodes: Descendant[]): Set<string> {
+  const langs = new Set<string>();
+  const walk = (nodeList: Descendant[]) => {
+    nodeList.forEach((node) => {
+      if (!SlateElement.isElement(node)) return;
+      if (node.type === CodeBlockType && (node as any).preview !== "true") {
+        langs.add(((node as any).language || "plain").toLowerCase());
+      }
+      const children = (node as any).children as Descendant[] | undefined;
+      if (Array.isArray(children)) walk(children);
+    });
+  };
+  walk(nodes);
+  return langs;
+}

package/create/editor/utils/linkCommands.ts

@@ -0,0 +1,63 @@
+// utils/editor/linkCommands.ts
+import { Editor, Transforms, Element, Range } from "slate";
+import { LinkElement } from "../types"; // 假设你的类型定义在 a/types.ts
+
+// 检查当前选区是否已存在链接
+const isLinkActive = (editor: Editor) => {
+  const [link] = Editor.nodes(editor, {
+    match: (n) =>
+      !Editor.isEditor(n) && Element.isElement(n) && n.type === "link",
+  });
+  return !!link;
+};
+
+// 移除链接（将 link 元素扁平化为纯文本）
+const unwrapLink = (editor: Editor) => {
+  Transforms.unwrapNodes(editor, {
+    match: (n) =>
+      !Editor.isEditor(n) && Element.isElement(n) && n.type === "link",
+  });
+};
+
+// 包裹链接
+const wrapLink = (editor: Editor, url: string) => {
+  if (isLinkActive(editor)) {
+    unwrapLink(editor);
+  }
+
+  const { selection } = editor;
+  const isCollapsed = selection && Range.isCollapsed(selection);
+  const link: LinkElement = {
+    type: "link",
+    url,
+    children: isCollapsed ? [{ text: url }] : [],
+  };
+
+  if (isCollapsed) {
+    Transforms.insertNodes(editor, link);
+  } else {
+    Transforms.wrapNodes(editor, link, { split: true });
+    Transforms.collapse(editor, { edge: "end" });
+  }
+};
+
+// 主入口函数，用于切换链接状态
+export const toggleLink = (editor: Editor, url?: string) => {
+  if (!url) {
+    if (isLinkActive(editor)) {
+      unwrapLink(editor);
+    }
+    return;
+  }
+
+  // 如果有选区，则直接包裹
+  const { selection } = editor;
+  if (!selection) return;
+
+  wrapLink(editor, url);
+};
+
+export const LinkCommands = {
+  isLinkActive,
+  toggleLink,
+};