An open-source, privacy-first, self-hosted knowledge workspace where humans and AI agents work together 开源、隐私优先、自托管的知识工作空间,让人与智能体在此协作
TypeScript agentic-aiai-agentknowledge-baselocal-firstmarkdownmcpmindmapnote-takingself-hostedsiyuanworkspace
// SiYuan - https://github.com/siyuan-note/siyuan
// Copyright (c) 2020-present, b3log.org
// SPDX-License-Identifier: AGPL-3.0-or-later
package model
import (
"slices"
"github.com/88250/lute/ast"
"github.com/88250/lute/parse"
"github.com/siyuan-note/siyuan/kernel/filesys"
"github.com/siyuan-note/siyuan/kernel/treenode"
"github.com/siyuan-note/siyuan/kernel/util"
)
const (
MergeDocHeadingModeFlat = "flat"
MergeDocHeadingModeTree = "tree"
MergeContentHeadingModePreserve = "preserve"
MergeContentHeadingModeDemote = "demote"
)
type MergeHeadingOptions struct {
DocHeadingMode string
ContentHeadingMode string
}
func mergeHeadingOptionsOrDefault(options []MergeHeadingOptions) (ret MergeHeadingOptions) {
if 0 < len(options) {
ret = options[0]
}
switch ret.DocHeadingMode {
case MergeDocHeadingModeFlat, MergeDocHeadingModeTree:
default:
ret.DocHeadingMode = ""
}
switch ret.ContentHeadingMode {
case MergeContentHeadingModeDemote:
default:
ret.ContentHeadingMode = MergeContentHeadingModePreserve
}
return
}
func mergeSubDocs(rootTree *parse.Tree, options MergeHeadingOptions, addRootTitle bool) (ret *parse.Tree, err error) {
ret = rootTree
if MergeContentHeadingModeDemote == options.ContentHeadingMode && addRootTitle {
demoteMergedContentHeadings(rootTree, 1)
}
rootBlock := &Block{Box: rootTree.Box, ID: rootTree.ID, Path: rootTree.Path, HPath: rootTree.HPath}
if err = buildBlockChildren(rootBlock); err != nil {
return
}
insertPoint := rootTree.Root.LastChild
// 跳过空段落插入点,向上寻找非空段落
for ; nil != insertPoint && ast.NodeParagraph == insertPoint.Type; insertPoint = insertPoint.Previous {
if nil != insertPoint.FirstChild {
break
}
}
// 导出空文档 Word 和 PDF 时合并子文档失败 https://github.com/siyuan-note/siyuan/issues/7429
if nil == insertPoint {
// 如果找不到非空段落,则使用第一个段落作为插入点
insertPoint = rootTree.Root.FirstChild
if nil == insertPoint {
// 如果文档为空,则创建一个空段落作为插入点
insertPoint = treenode.NewParagraph("")
rootTree.Root.AppendChild(insertPoint)
}
}
for {
i := 0
if err = walkBlock(insertPoint, rootBlock, i, options, addRootTitle); err != nil {
return
}
if nil == rootBlock.Children {
break
}
}
if ast.NodeParagraph == insertPoint.Type && nil == insertPoint.FirstChild {
// 删除空段落
// Ignore the last empty paragraph block when exporting merged sub-documents https://github.com/siyuan-note/siyuan/issues/15028
insertPoint.Unlink()
}
return
}
func walkBlock(insertPoint *ast.Node, block *Block, level int, options MergeHeadingOptions, addRootTitle bool) (err error) {
level++
for _, c := range slices.Backward(block.Children) {
if err = walkBlock(insertPoint, c, level, options, addRootTitle); err != nil {
return
}
nodes, loadErr := loadTreeNodes(c.Box, c.Path, level, options, addRootTitle)
if nil != loadErr {
return
}
lastIndex := len(nodes) - 1
for j := lastIndex; -1 < j; j-- {
node := nodes[j]
if j == lastIndex && ast.NodeParagraph == node.Type && nil == node.FirstChild {
// 跳过最后一个空段落块
// Ignore the last empty paragraph block when exporting merged sub-documents https://github.com/siyuan-note/siyuan/issues/15028
continue
}
insertPoint.InsertAfter(node)
}
}
block.Children = nil
return
}
func loadTreeNodes(box string, p string, level int, options MergeHeadingOptions, addRootTitle bool) (ret []*ast.Node, err error) {
luteEngine := NewLute()
tree, err := filesys.LoadTree(box, p, luteEngine)
if err != nil {
return
}
hLevel := mergedDocHeadingLevel(level, options.DocHeadingMode, addRootTitle)
if MergeContentHeadingModeDemote == options.ContentHeadingMode {
demoteMergedContentHeadings(tree, hLevel)
}
heading := &ast.Node{ID: tree.Root.ID, Type: ast.NodeHeading, HeadingLevel: hLevel}
heading.AppendChild(&ast.Node{Type: ast.NodeText, Tokens: []byte(treenode.ReadDocumentTitle(tree.Root).Text)})
tree.Root.PrependChild(heading)
for c := tree.Root.FirstChild; nil != c; c = c.Next {
ret = append(ret, c)
}
return
}
func mergedDocHeadingLevel(depth int, mode string, addRootTitle bool) int {
level := depth
switch mode {
case MergeDocHeadingModeFlat:
level = 1
case MergeDocHeadingModeTree:
if addRootTitle {
level++
}
}
return min(6, max(1, level))
}
func demoteMergedContentHeadings(tree *parse.Tree, docHeadingLevel int) {
headings := collectOutlineHeadings(tree)
topLevel := 7
for _, heading := range headings {
if 0 < heading.HeadingLevel && heading.HeadingLevel < topLevel {
topLevel = heading.HeadingLevel
}
}
if 6 < topLevel {
return
}
delta := docHeadingLevel + 1 - topLevel
if delta <= 0 {
return
}
for _, heading := range headings {
heading.HeadingLevel = min(6, heading.HeadingLevel+delta)
}
}
func buildBlockChildren(block *Block) (err error) {
listPath := block.Path
if IsBoxDoc(block.Box, block.ID) {
listPath = "/"
}
files, _, err := ListDocTree(block.Box, listPath, util.SortModeUnassigned, false, false, Conf.FileTree.Load().MaxListCount)
if err != nil {
return
}
for _, f := range files {
childBlock := &Block{Box: block.Box, ID: f.ID, Path: f.Path}
block.Children = append(block.Children, childBlock)
}
for _, c := range block.Children {
if err = buildBlockChildren(c); err != nil {
return
}
}
return
}