nolo-cli 0.1.23 → 0.1.29

package/create/editor/transforms/fromMarkdown/inline.ts

@@ -0,0 +1,285 @@
+// 路径：create/editor/transforms/inline.ts
+
+// 辅助类型定义
+export interface SlateTextNode {
+  text: string;
+  bold?: boolean;
+  italic?: boolean;
+  strikethrough?: boolean;
+}
+
+export interface SlateElementNode {
+  type: string;
+  url?: string;
+  alt?: string;
+  title?: string;
+  html?: string; // html-inline 或 html-block
+  language?: string; // 代码块语言
+  children: SlateChild[];
+}
+
+// Mention 节点类型
+export interface SlateMentionNode {
+  type: "mention";
+  resourceType: "tool" | "page" | "agent" | "space";
+  resourceId: string;
+  label: string;
+  children: SlateChild[];
+}
+
+export type SlateChild = SlateTextNode | SlateElementNode | SlateMentionNode;
+export type SlateInlineChild = SlateChild;
+
+// 提取 HTML 标签名，例如 "<span>" -> "span"
+function getTagName(html: string): string | null {
+  if (!html) return null;
+  const match = html.trimStart().match(/^<\/?([a-zA-Z0-9]+)/);
+  return match ? match[1].toLowerCase() : null;
+}
+
+// 递归获取 mdast 节点的纯文本内容
+function getRawTextFromNodes(nodes: any[]): string {
+  if (!Array.isArray(nodes)) return "";
+  return nodes
+    .map((node) => {
+      if (!node) return "";
+      if (node.type === "text") return node.value || "";
+      if (Array.isArray(node.children))
+        return getRawTextFromNodes(node.children);
+      if (node.value && typeof node.value === "string") return node.value;
+      return "";
+    })
+    .join("");
+}
+
+// 合并相邻且样式完全一致的文本节点
+function mergeTextNodes(nodes: SlateInlineChild[]): SlateInlineChild[] {
+  const merged: SlateInlineChild[] = [];
+  for (const node of nodes) {
+    if (
+      merged.length > 0 &&
+      "text" in node &&
+      "text" in merged[merged.length - 1]
+    ) {
+      const prev = merged[merged.length - 1] as SlateTextNode;
+      const cur = node as SlateTextNode;
+
+      if (
+        prev.bold === cur.bold &&
+        prev.italic === cur.italic &&
+        prev.strikethrough === cur.strikethrough
+      ) {
+        prev.text += cur.text;
+        continue;
+      }
+    }
+    merged.push(node);
+  }
+  return merged;
+}
+
+/**
+ * 将 mdast 内联节点转换为 Slate 内联节点列表，
+ * 支持加粗、斜体、删除线、链接、图片、内联代码以及内联 HTML。
+ */
+export function processInlineNodes(mdastChildren: any[]): SlateInlineChild[] {
+  if (!Array.isArray(mdastChildren)) return [{ text: "" }];
+
+  const result: SlateInlineChild[] = [];
+
+  // 当前打开的 HTML 标签状态
+  let activeHtmlTag: {
+    startTag: string;
+    tagName: string;
+    contentNodes: any[];
+  } | null = null;
+
+  try {
+    for (const child of mdastChildren) {
+      if (!child || typeof child !== "object") {
+        // 在 HTML 标签内时收集纯文本
+        if (activeHtmlTag && typeof child === "string") {
+          activeHtmlTag.contentNodes.push({ type: "text", value: child });
+        }
+        continue;
+      }
+
+      // 处理 HTML 节点
+      if (child.type === "html" && typeof child.value === "string") {
+        const htmlValue = child.value;
+        const trimmedEnd = htmlValue.trimEnd();
+        const tagName = getTagName(htmlValue);
+
+        // 自闭合标签，例如 <br/>、<img ... />
+        if (trimmedEnd.endsWith("/>") && tagName) {
+          if (activeHtmlTag) {
+            activeHtmlTag.contentNodes.push(child);
+          } else {
+            result.push({
+              type: "html-inline",
+              html: htmlValue,
+              children: [{ text: "" }],
+            });
+          }
+          continue;
+        }
+
+        // 结束标签
+        if (htmlValue.trimStart().startsWith("</") && tagName) {
+          if (activeHtmlTag && activeHtmlTag.tagName === tagName) {
+            const nodes = processInlineNodes(activeHtmlTag.contentNodes);
+            const rawText = getRawTextFromNodes(activeHtmlTag.contentNodes);
+            const children = nodes.length ? nodes : [{ text: "" }];
+
+            result.push({
+              type: "html-inline",
+              html: activeHtmlTag.startTag + rawText + htmlValue,
+              children,
+            });
+            activeHtmlTag = null;
+          } else if (activeHtmlTag) {
+            // 标签不匹配时，继续当作内容收集
+            activeHtmlTag.contentNodes.push(child);
+          } else {
+            // 没有打开标签，但遇到结束标签，当作纯文本
+            result.push({ text: htmlValue });
+          }
+          continue;
+        }
+
+        // 开始标签
+        if (!htmlValue.trimStart().startsWith("</") && tagName) {
+          if (activeHtmlTag) {
+            activeHtmlTag.contentNodes.push(child);
+          } else {
+            activeHtmlTag = {
+              startTag: htmlValue,
+              tagName,
+              contentNodes: [],
+            };
+          }
+          continue;
+        }
+
+        // 非标准 / 无法识别的 HTML
+        if (activeHtmlTag) {
+          activeHtmlTag.contentNodes.push(child);
+        } else {
+          result.push({ text: htmlValue });
+        }
+        continue;
+      }
+
+      // 在 HTML 标签内时，收集内容节点
+      if (activeHtmlTag) {
+        activeHtmlTag.contentNodes.push(child);
+        continue;
+      }
+
+      // 普通节点处理
+      switch (child.type) {
+        case "strong": {
+          const nodes = processInlineNodes(child.children || []);
+          nodes.forEach((n) => "text" in n && (n.bold = true));
+          result.push(...nodes);
+          break;
+        }
+        case "emphasis": {
+          const nodes = processInlineNodes(child.children || []);
+          nodes.forEach((n) => "text" in n && (n.italic = true));
+          result.push(...nodes);
+          break;
+        }
+        case "delete": {
+          const nodes = processInlineNodes(child.children || []);
+          nodes.forEach((n) => "text" in n && (n.strikethrough = true));
+          result.push(...nodes);
+          break;
+        }
+        case "link":
+          result.push({
+            type: "link",
+            url: child.url || "",
+            children: processInlineNodes(child.children || []),
+          });
+          break;
+
+        case "inlineCode":
+          result.push({
+            type: "code-inline",
+            children: [{ text: child.value || "" }],
+          });
+          break;
+
+        case "image": {
+          const img: SlateElementNode = {
+            type: "image",
+            url: child.url || "",
+            alt: child.alt || "",
+            children: [{ text: "" }],
+          };
+          if (child.title) img.title = child.title;
+          result.push(img);
+          break;
+        }
+
+        case "text": {
+          const text = child.value || "";
+          // 识别 @[type:id|label] 格式的 mention 语法
+          const mentionRegex = /@\[(\w+):([^\]|]+)\|([^\]]+)\]/g;
+
+          if (!mentionRegex.test(text)) {
+            result.push({ text });
+            break;
+          }
+
+          // 有 mention，需要拆分文本
+          let lastIndex = 0;
+          let match;
+          mentionRegex.lastIndex = 0;
+
+          while ((match = mentionRegex.exec(text)) !== null) {
+            // 前面的普通文本
+            if (match.index > lastIndex) {
+              result.push({ text: text.slice(lastIndex, match.index) });
+            }
+            // mention 节点
+            result.push({
+              type: "mention",
+              resourceType: match[1] as "tool" | "page" | "agent" | "space",
+              resourceId: match[2],
+              label: match[3],
+              children: [{ text: "" }],
+            });
+            lastIndex = mentionRegex.lastIndex;
+          }
+          // 剩余文本
+          if (lastIndex < text.length) {
+            result.push({ text: text.slice(lastIndex) });
+          }
+          break;
+        }
+
+        default:
+          if (child.value && typeof child.value === "string") {
+            result.push({ text: child.value });
+          }
+      }
+    }
+
+    // 处理未闭合的 HTML 标签：按开始标签 + 内部内容退化
+    if (activeHtmlTag) {
+      result.push({
+        type: "html-inline",
+        html: activeHtmlTag.startTag,
+        children: [{ text: "" }],
+      });
+      result.push(...processInlineNodes(activeHtmlTag.contentNodes));
+    }
+  } catch {
+    return [{ text: "" }];
+  }
+
+  const finalResult = result.length ? result : [{ text: "" }];
+  return mergeTextNodes(finalResult);
+}

package/create/editor/transforms/fromMarkdown/table.ts

@@ -0,0 +1,130 @@
+// 路径：create/editor/transforms/table.ts
+
+import { Element as SlateElement } from "slate";
+import { processInlineNodes } from "./inline";
+
+// MDAST 类型（简化）
+type MdastNode = { [key: string]: any };
+
+type MdastTableCell = {
+  type: "tableCell";
+  children: MdastNode[];
+};
+
+type MdastTableRow = {
+  type: "tableRow";
+  children: MdastTableCell[];
+};
+
+type MdastTable = {
+  type: "table";
+  align: (string | null)[];
+  children: MdastTableRow[];
+};
+
+// Slate 表格相关类型
+export type SlateTableCell = SlateElement & { header?: boolean };
+type SlateTableRow = SlateElement & { children: SlateTableCell[] };
+type SlateTableColumn = { align: string; width: null | number };
+
+export type SlateTable = SlateElement & {
+  columns: SlateTableColumn[];
+  children: SlateTableRow[];
+};
+
+/**
+ * 创建一个 Slate table-cell 节点。
+ * @param mdastCell - 输入的 MDAST tableCell 节点。
+ * @param isHeader - 当前单元格是否为表头。
+ */
+function createSlateCell(
+  mdastCell: MdastTableCell,
+  isHeader: boolean
+): SlateTableCell {
+  // 1. 使用行内转换，生成 cell 内的行内子节点
+  let inlineChildren = processInlineNodes(mdastCell.children || []);
+
+  // 2. 确保至少有一个 text 节点
+  if (inlineChildren.length === 0) {
+    inlineChildren = [{ text: "" }];
+  }
+
+  // 3. 包裹在一个 paragraph 中（符合 Slate 表格 schema）
+  const slateCellChildren = [
+    {
+      type: "paragraph",
+      children: inlineChildren,
+    },
+  ];
+
+  const slateCell: SlateTableCell = {
+    type: "table-cell",
+    children: slateCellChildren,
+  };
+
+  if (isHeader) {
+    slateCell.header = true;
+  }
+
+  return slateCell;
+}
+
+/**
+ * 将 MDAST 表格节点转换为 Slate 表格节点。
+ */
+export function transformTable(node: MdastTable): SlateTable | null {
+  if (node.type !== "table" || !node.children || node.children.length === 0) {
+    return null;
+  }
+
+  // 计算表格的最大列数
+  const maxColumns = node.children.reduce(
+    (max, row) => Math.max(max, row.children?.length || 0),
+    0
+  );
+
+  if (maxColumns === 0) return null;
+
+  // 将列数不足的行用空单元格补齐，保证每行列数一致
+  const normalizedRows: MdastTableRow[] = node.children.map((row) => {
+    const cells = row.children || [];
+    const diff = maxColumns - cells.length;
+
+    if (diff > 0) {
+      // 使用 Array.from 避免 fill 带来的同一引用问题
+      const emptyCells: MdastTableCell[] = Array.from({ length: diff }, () => ({
+        type: "tableCell",
+        children: [],
+      }));
+      return { ...row, children: [...cells, ...emptyCells] };
+    }
+
+    return row;
+  });
+
+  // 处理列的对齐信息
+  const align = node.align || [];
+  const columns: SlateTableColumn[] = Array.from(
+    { length: maxColumns },
+    (_, i) => ({
+      align: align[i] || "left",
+      width: null,
+    })
+  );
+
+  // 行 & 单元格转换
+  const slateRows: SlateTableRow[] = normalizedRows.map((row, rowIndex) => {
+    const isHeaderRow = rowIndex === 0;
+
+    return {
+      type: "table-row",
+      children: row.children.map((cell) => createSlateCell(cell, isHeaderRow)),
+    };
+  });
+
+  return {
+    type: "table",
+    columns,
+    children: slateRows,
+  };
+}

package/create/editor/transforms/markdownToSlate.ts

@@ -0,0 +1,24 @@
+// create/editor/transforms/markdownToSlate.ts
+
+import { fromMarkdown } from "mdast-util-from-markdown";
+import { gfmFromMarkdown } from "mdast-util-gfm";
+import { gfm } from "micromark-extension-gfm";
+import { mdastToSlate } from "./fromMarkdown";
+
+/**
+ * 将 Markdown 纯文本字符串转换为 Slate.js 的节点数组。
+ * 1. Markdown 文本 -> MDAST (Markdown 抽象语法树)
+ * 2. MDAST -> Slate.js 节点
+ */
+export function markdownToSlate(markdown: string) {
+  if (!markdown || typeof markdown !== "string") {
+    return null;
+  }
+
+  const mdastTree = fromMarkdown(markdown, {
+    extensions: [gfm()],
+    mdastExtensions: [gfmFromMarkdown()],
+  });
+
+  return mdastToSlate(mdastTree);
+}

package/create/editor/transforms/slateToRenderMarkdown.ts

@@ -0,0 +1,218 @@
+type RenderMarkdownOptions = {
+  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: RenderMarkdownOptions = {}): 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, options: RenderMarkdownOptions): 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);
+
+  return [header, divider, ...body]
+    .map((cells) => `| ${cells.join(" | ")} |`)
+    .join("\n") + "\n\n";
+}
+
+function renderListItem(
+  node: any,
+  listDepth: number,
+  ordered: boolean,
+  start: number,
+  index: number,
+  options: RenderMarkdownOptions = {}
+): 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";
+}
+
+function renderNode(
+  node: any,
+  listDepth = 0,
+  options: RenderMarkdownOptions = {}
+): string {
+  if (!node) return "";
+
+  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, 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";
+      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("")
+          : "")
+      );
+  }
+}
+
+/**
+ * 为只读展示生成 Markdown 缓存。
+ *
+ * 目标：
+ * - 优先保证给 `Bun.markdown.*` 的结构稳定、可渲染。
+ * - 用于只读展示缓存或 legacy `content` 桥接。
+ *
+ * 非目标：
+ * - 不把它当主数据源。页面真源始终是 `slateData`。
+ * - 不承担 AI 摘要 / 工具读取的职责。
+ */
+export function slateToRenderMarkdown(
+  nodes: any[],
+  options: RenderMarkdownOptions = {}
+): string {
+  if (!nodes || nodes.length === 0) return "";
+
+  return (
+    nodes
+      .map((node) => renderNode(node, 0, options))
+      .join("")
+      .trim() + "\n"
+  );
+}