Skip to content

An open-source, privacy-first, self-hosted knowledge workspace where humans and AI agents work together 开源、隐私优先、自托管的知识工作空间,让人与智能体在此协作

17.1 KB
Raw Blame
// SiYuan - https://github.com/siyuan-note/siyuan
// Copyright (c) 2020-present, b3log.org
// SPDX-License-Identifier: AGPL-3.0-or-later

package cmd

import (
	"encoding/json"
	"fmt"
	"io"
	"os"
	"strings"
	"text/tabwriter"

	"github.com/siyuan-note/siyuan/kernel/filesys"
	"github.com/siyuan-note/siyuan/kernel/model"
	"github.com/siyuan-note/siyuan/kernel/treenode"
	"github.com/siyuan-note/siyuan/kernel/util"

	"github.com/spf13/cobra"
)

var blockCmd = &cobra.Command{
	Use:   "block",
	Short: "Block operations",
}

// ─── Read ──────────────────────────────────────────────────────────────────────

var blockGetCmd = &cobra.Command{
	Use:   "get --id <id>",
	Short: "Get block info",
	RunE: func(cmd *cobra.Command, args []string) error {
		id, _ := cmd.Flags().GetString("id")
		if id == "" {
			return fmt.Errorf("--id is required")
		}
		block, err := model.GetBlock(id, nil)
		if err != nil {
			return err
		}
		switch outputFormat {
		case "json":
			data, _ := json.MarshalIndent(block, "", "  ")
			fmt.Println(string(data))
		default:
			fmt.Printf("ID:       %s\n", block.ID)
			fmt.Printf("Type:     %s\n", block.Type)
			fmt.Printf("Name:     %s\n", block.Name)
			fmt.Printf("Box:      %s\n", block.Box)
			fmt.Printf("HPath:    %s\n", block.HPath)
			if block.Content != "" {
				fmt.Printf("Content:  %s\n", truncate(block.Content, 200))
			}
			if block.Markdown != "" {
				fmt.Printf("Markdown: %s\n", truncate(block.Markdown, 200))
			}
		}
		return nil
	},
}

var blockChildrenCmd = &cobra.Command{
	Use:   "children --id <id>",
	Short: "Get child blocks",
	RunE: func(cmd *cobra.Command, args []string) error {
		id, _ := cmd.Flags().GetString("id")
		if id == "" {
			return fmt.Errorf("--id is required")
		}
		children := model.GetChildBlocks(id)
		switch outputFormat {
		case "json":
			data, _ := json.MarshalIndent(children, "", "  ")
			fmt.Println(string(data))
		default:
			w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
			fmt.Fprintln(w, "ID\tTYPE\tCONTENT")
			for _, c := range children {
				fmt.Fprintf(w, "%s\t%s\t%s\n", c.ID, c.Type, truncate(c.Content, 80))
			}
			w.Flush()
		}
		return nil
	},
}

var blockBreadcrumbCmd = &cobra.Command{
	Use:   "breadcrumb --id <id>",
	Short: "Get block breadcrumb",
	RunE: func(cmd *cobra.Command, args []string) error {
		id, _ := cmd.Flags().GetString("id")
		if id == "" {
			return fmt.Errorf("--id is required")
		}
		paths, err := model.BuildBlockBreadcrumb(id, nil)
		if err != nil {
			return err
		}
		switch outputFormat {
		case "json":
			data, _ := json.MarshalIndent(paths, "", "  ")
			fmt.Println(string(data))
		default:
			w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
			fmt.Fprintln(w, "ID\tNAME\tTYPE")
			for _, p := range paths {
				fmt.Fprintf(w, "%s\t%s\t%s\n", p.ID, p.Name, p.Type)
			}
			w.Flush()
		}
		return nil
	},
}

var blockDomCmd = &cobra.Command{
	Use:   "dom --id <id>",
	Short: "Get block DOM",
	RunE: func(cmd *cobra.Command, args []string) error {
		id, _ := cmd.Flags().GetString("id")
		if id == "" {
			return fmt.Errorf("--id is required")
		}
		fmt.Print(model.GetBlockDOM(id))
		return nil
	},
}

var blockKramdownCmd = &cobra.Command{
	Use:   "kramdown --id <id>",
	Short: "Get block kramdown",
	RunE: func(cmd *cobra.Command, args []string) error {
		id, _ := cmd.Flags().GetString("id")
		if id == "" {
			return fmt.Errorf("--id is required")
		}
		mode, _ := cmd.Flags().GetString("mode")
		if mode == "" {
			mode = "md"
		}
		fmt.Print(model.GetBlockKramdown(id, mode))
		return nil
	},
}

var blockStatCmd = &cobra.Command{
	Use:   "stat --id <id>",
	Short: "Get block content statistics",
	RunE: func(cmd *cobra.Command, args []string) error {
		id, _ := cmd.Flags().GetString("id")
		if id == "" {
			return fmt.Errorf("--id is required")
		}
		stat := filesys.StatTree(id)
		if stat == nil {
			return fmt.Errorf("document not found or empty")
		}
		switch outputFormat {
		case "json":
			data, _ := json.MarshalIndent(stat, "", "  ")
			fmt.Println(string(data))
		default:
			fmt.Printf("Characters: %d\n", stat.RuneCount)
			fmt.Printf("Words:      %d\n", stat.WordCount)
			fmt.Printf("Blocks:     %d\n", stat.BlockCount)
			fmt.Printf("Links:      %d\n", stat.LinkCount)
			fmt.Printf("Images:     %d\n", stat.ImageCount)
			fmt.Printf("Refs:       %d\n", stat.RefCount)
		}
		return nil
	},
}

// ─── Write ─────────────────────────────────────────────────────────────────────

var blockInsertCmd = &cobra.Command{
	Use:   "insert --parent <id> [--data <markdown> | --file <path>]",
	Short: "Insert block",
	RunE: func(cmd *cobra.Command, args []string) error {
		parentID, _ := cmd.Flags().GetString("parent")
		previousID, _ := cmd.Flags().GetString("previous")
		if parentID == "" {
			return fmt.Errorf("--parent is required")
		}

		if dryRun {
			fmt.Printf("[dry-run] Would insert block under parent %s\n", parentID)
			if previousID != "" {
				fmt.Printf("         after previous sibling %s\n", previousID)
			}
			return nil
		}

		// 仅靠 parentID 定位目标时(无 previousID),目标必须是容器块,否则非法嵌套
		if previousID == "" {
			if err := treenode.CheckContainerParent(parentID); err != nil {
				return err
			}
		}

		data, err := resolveData(cmd)
		if err != nil {
			return err
		}

		dom := markdownToBlockDOM(data)
		operation := &model.Operation{
			Action:     "insert",
			Data:       dom,
			ParentID:   parentID,
			PreviousID: previousID,
		}
		if err = model.PerformTxSync(&model.Transaction{DoOperations: []*model.Operation{operation}}); err != nil {
			return err
		}
		if bt := treenode.GetBlockTree(parentID); bt != nil {
			model.AppendPushReloadProtyleEntry(bt.RootID)
		}
		return printBlockWriteResult(operation.ID)
	},
}

var blockAppendCmd = &cobra.Command{
	Use:   "append --parent <id> [--data <markdown> | --file <path>]",
	Short: "Append block",
	RunE: func(cmd *cobra.Command, args []string) error {
		parentID, _ := cmd.Flags().GetString("parent")
		if parentID == "" {
			return fmt.Errorf("--parent is required")
		}

		if dryRun {
			fmt.Printf("[dry-run] Would append block to parent %s\n", parentID)
			return nil
		}

		// append 只用 parentID 定位目标,目标必须是容器块,否则非法嵌套
		if err := treenode.CheckContainerParent(parentID); err != nil {
			return err
		}

		data, err := resolveData(cmd)
		if err != nil {
			return err
		}

		dom := markdownToBlockDOM(data)
		operation := &model.Operation{
			Action:   "appendInsert",
			Data:     dom,
			ParentID: parentID,
		}
		if err = model.PerformTxSync(&model.Transaction{DoOperations: []*model.Operation{operation}}); err != nil {
			return err
		}
		if bt := treenode.GetBlockTree(parentID); bt != nil {
			model.AppendPushReloadProtyleEntry(bt.RootID)
		}
		return printBlockWriteResult(operation.ID)
	},
}

var blockPrependCmd = &cobra.Command{
	Use:   "prepend --parent <id> [--data <markdown> | --file <path>]",
	Short: "Prepend block",
	RunE: func(cmd *cobra.Command, args []string) error {
		parentID, _ := cmd.Flags().GetString("parent")
		if parentID == "" {
			return fmt.Errorf("--parent is required")
		}

		if dryRun {
			fmt.Printf("[dry-run] Would prepend block to parent %s\n", parentID)
			return nil
		}

		// prepend 只用 parentID 定位目标,目标必须是容器块,否则非法嵌套
		if err := treenode.CheckContainerParent(parentID); err != nil {
			return err
		}

		data, err := resolveData(cmd)
		if err != nil {
			return err
		}

		dom := markdownToBlockDOM(data)
		operation := &model.Operation{
			Action:   "prependInsert",
			Data:     dom,
			ParentID: parentID,
		}
		if err = model.PerformTxSync(&model.Transaction{DoOperations: []*model.Operation{operation}}); err != nil {
			return err
		}
		if bt := treenode.GetBlockTree(parentID); bt != nil {
			model.AppendPushReloadProtyleEntry(bt.RootID)
		}
		return printBlockWriteResult(operation.ID)
	},
}

func printBlockWriteResult(id string) error {
	return writeBlockWriteResult(os.Stdout, id)
}

func writeBlockWriteResult(output io.Writer, id string) error {
	if id == "" {
		return fmt.Errorf("block write failed: empty block ID")
	}
	if outputFormat == "json" {
		data, err := json.MarshalIndent(map[string]string{"id": id}, "", "  ")
		if err != nil {
			return err
		}
		_, err = fmt.Fprintln(output, string(data))
		return err
	}
	_, err := fmt.Fprintln(output, id)
	return err
}

var blockUpdateCmd = &cobra.Command{
	Use:   "update --id <id> [--data <markdown> | --file <path>]",
	Short: "Update block",
	RunE: func(cmd *cobra.Command, args []string) error {
		id, _ := cmd.Flags().GetString("id")
		if id == "" {
			return fmt.Errorf("--id is required")
		}

		if dryRun {
			fmt.Printf("[dry-run] Would update block %s\n", id)
			return nil
		}

		data, err := resolveData(cmd)
		if err != nil {
			return err
		}
		lockType, _ := cmd.Flags().GetBool("lock-type")

		_, rootIDs, err := model.PerformBlockUpdates([]model.BlockUpdateInput{{
			ID:       id,
			Data:     data,
			DataType: "markdown",
			LockType: lockType,
		}})
		if err != nil {
			return err
		}

		for _, rootID := range rootIDs {
			model.AppendPushReloadProtyleEntry(rootID)
		}
		fmt.Println("ok")
		return nil
	},
}

var blockDeleteCmd = &cobra.Command{
	Use:   "delete --id <id>",
	Short: "Delete block",
	RunE: func(cmd *cobra.Command, args []string) error {
		id, _ := cmd.Flags().GetString("id")
		if id == "" {
			return fmt.Errorf("--id is required")
		}

		bt := treenode.GetBlockTree(id)
		if bt == nil {
			return fmt.Errorf("block not found: %s", id)
		}
		if bt.Type == "d" {
			return fmt.Errorf("document cannot be deleted as a block [%s]", id)
		}
		if dryRun {
			fmt.Printf("[dry-run] Would delete block %s\n", id)
			return nil
		}

		if _, err := model.PerformBlockOperation(&model.Operation{Action: "delete", ID: id}); err != nil {
			return err
		}

		if bt != nil {
			model.AppendPushReloadProtyleEntry(bt.RootID)
		}
		fmt.Println(id)
		return nil
	},
}

var blockMoveCmd = &cobra.Command{
	Use:   "move --id <id> --parent <id>",
	Short: "Move block",
	RunE: func(cmd *cobra.Command, args []string) error {
		id, _ := cmd.Flags().GetString("id")
		parentID, _ := cmd.Flags().GetString("parent")
		previousID, _ := cmd.Flags().GetString("previous")
		if id == "" || parentID == "" {
			return fmt.Errorf("--id and --parent are required")
		}

		if err := validateBlockMove(id, parentID, previousID); err != nil {
			return err
		}

		if dryRun {
			fmt.Printf("[dry-run] Would move block %s to parent %s\n", id, parentID)
			if previousID != "" {
				fmt.Printf("         after previous sibling %s\n", previousID)
			}
			return nil
		}

		transaction := &model.Transaction{
			DoOperations: []*model.Operation{{
				Action:     "move",
				ID:         id,
				ParentID:   parentID,
				PreviousID: previousID,
			}},
		}
		if err := model.PerformTxSync(transaction); err != nil {
			return err
		}
		if bt := treenode.GetBlockTree(id); bt != nil {
			model.AppendPushReloadProtyleEntry(bt.RootID)
		}
		fmt.Println("ok")
		return nil
	},
}

func validateBlockMove(id, parentID, previousID string) error {
	bt := treenode.GetBlockTree(id)
	if nil == bt {
		return fmt.Errorf("block not found: %s", id)
	}
	if "d" == bt.Type {
		return fmt.Errorf("document block [%s] cannot be moved with block move; use document move instead", id)
	}

	if "" != previousID {
		previousBt := treenode.GetBlockTree(previousID)
		if nil == previousBt {
			return fmt.Errorf("previous block not found: %s", previousID)
		}
		if "d" == previousBt.Type {
			return fmt.Errorf("document block [%s] cannot be used as a previous sibling; use it as --parent instead", previousID)
		}
		return nil
	}
	if err := treenode.CheckListItemNesting(parentID, id); err != nil {
		return err
	}
	return treenode.CheckContainerParent(parentID)
}

var blockBatchGetCmd = &cobra.Command{
	Use:   "batch-get --ids id1,id2,...",
	Short: "Batch get block info",
	RunE: func(cmd *cobra.Command, args []string) error {
		idsStr, _ := cmd.Flags().GetString("ids")
		if idsStr == "" {
			return fmt.Errorf("--ids is required")
		}
		ids := splitIDs(idsStr)
		if len(ids) == 0 {
			return fmt.Errorf("no valid IDs provided")
		}
		infos := model.GetDocsInfo(ids, false, false)
		switch outputFormat {
		case "json":
			data, _ := json.MarshalIndent(infos, "", "  ")
			fmt.Println(string(data))
		default:
			w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
			fmt.Fprintln(w, "ID\tNAME\tROOTID\tREFCOUNT")
			for _, info := range infos {
				fmt.Fprintf(w, "%s\t%s\t%s\t%d\n", info.ID, info.Name, info.RootID, info.RefCount)
			}
			for _, id := range ids {
				found := false
				for _, info := range infos {
					if info.ID == id {
						found = true
						break
					}
				}
				if !found {
					fmt.Fprintf(w, "%s\tnot found\t\t\n", id)
				}
			}
			w.Flush()
		}
		return nil
	},
}

var blockBatchKramdownCmd = &cobra.Command{
	Use:   "batch-kramdown --ids id1,id2,...",
	Short: "Batch get block kramdown",
	RunE: func(cmd *cobra.Command, args []string) error {
		idsStr, _ := cmd.Flags().GetString("ids")
		if idsStr == "" {
			return fmt.Errorf("--ids is required")
		}
		ids := splitIDs(idsStr)
		if len(ids) == 0 {
			return fmt.Errorf("no valid IDs provided")
		}
		kramdowns := model.GetBlockKramdowns(ids, "md")
		switch outputFormat {
		case "json":
			data, _ := json.MarshalIndent(kramdowns, "", "  ")
			fmt.Println(string(data))
		default:
			var sb strings.Builder
			for _, id := range ids {
				if kd, ok := kramdowns[id]; ok {
					fmt.Fprintf(&sb, "--- %s ---\n%s\n\n", id, kd)
				} else {
					fmt.Fprintf(&sb, "--- %s ---\n(not found)\n\n", id)
				}
			}
			fmt.Print(sb.String())
		}
		return nil
	},
}

func splitIDs(s string) []string {
	parts := strings.Split(s, ",")
	var ids []string
	for _, p := range parts {
		p = strings.TrimSpace(p)
		if p != "" {
			ids = append(ids, p)
		}
	}
	return ids
}

func resolveData(cmd *cobra.Command) (string, error) {
	data, _ := cmd.Flags().GetString("data")
	if data != "" {
		return data, nil
	}

	filePath, _ := cmd.Flags().GetString("file")
	if filePath == "-" {
		stdinData, err := io.ReadAll(os.Stdin)
		if err != nil {
			return "", err
		}
		return string(stdinData), nil
	}
	if filePath != "" {
		fileData, err := os.ReadFile(filePath)
		if err != nil {
			return "", err
		}
		return string(fileData), nil
	}

	stdinData, err := io.ReadAll(os.Stdin)
	if err != nil {
		return "", err
	}
	return string(stdinData), nil
}

func markdownToBlockDOM(md string) string {
	luteEngine := util.NewLute()
	luteEngine.SetHTMLTag2TextMark(true)
	dom, _ := luteEngine.Md2BlockDOMTree(md, true)
	if dom == "" {
		dom = "<div data-type=\"NodeParagraph\" data-node-id=\"\"><div data-type=\"NodeText\"></div></div>"
	}
	return dom
}

func init() {
	blockGetCmd.Flags().String("id", "", "block ID")
	blockChildrenCmd.Flags().String("id", "", "parent block ID")
	blockBreadcrumbCmd.Flags().String("id", "", "block ID")
	blockDomCmd.Flags().String("id", "", "block ID")
	blockKramdownCmd.Flags().String("id", "", "block ID")
	blockKramdownCmd.Flags().String("mode", "md", "export mode: md | textmark")
	blockStatCmd.Flags().String("id", "", "block ID")

	blockInsertCmd.Flags().String("parent", "", "parent block ID")
	blockInsertCmd.Flags().String("data", "", "markdown content")
	blockInsertCmd.Flags().String("file", "", "read content from file path (- for stdin)")
	blockInsertCmd.Flags().String("previous", "", "previous sibling block ID")

	blockAppendCmd.Flags().String("parent", "", "parent block ID")
	blockAppendCmd.Flags().String("data", "", "markdown content")
	blockAppendCmd.Flags().String("file", "", "read content from file path (- for stdin)")

	blockPrependCmd.Flags().String("parent", "", "parent block ID")
	blockPrependCmd.Flags().String("data", "", "markdown content")
	blockPrependCmd.Flags().String("file", "", "read content from file path (- for stdin)")

	blockUpdateCmd.Flags().String("id", "", "block ID")
	blockUpdateCmd.Flags().String("data", "", "markdown content")
	blockUpdateCmd.Flags().String("file", "", "read content from file path (- for stdin)")
	blockUpdateCmd.Flags().Bool("lock-type", false, "reject update when the parsed block type differs from the existing block type")

	blockDeleteCmd.Flags().String("id", "", "block ID")

	blockMoveCmd.Flags().String("id", "", "block ID")
	blockMoveCmd.Flags().String("parent", "", "target parent block ID")
	blockMoveCmd.Flags().String("previous", "", "target previous sibling block ID")

	blockBatchGetCmd.Flags().String("ids", "", "comma-separated block IDs")
	blockBatchKramdownCmd.Flags().String("ids", "", "comma-separated block IDs")

	rootCmd.AddCommand(blockCmd)
	blockCmd.AddCommand(blockGetCmd)
	blockCmd.AddCommand(blockChildrenCmd)
	blockCmd.AddCommand(blockBreadcrumbCmd)
	blockCmd.AddCommand(blockDomCmd)
	blockCmd.AddCommand(blockKramdownCmd)
	blockCmd.AddCommand(blockStatCmd)
	blockCmd.AddCommand(blockInsertCmd)
	blockCmd.AddCommand(blockAppendCmd)
	blockCmd.AddCommand(blockPrependCmd)
	blockCmd.AddCommand(blockUpdateCmd)
	blockCmd.AddCommand(blockDeleteCmd)
	blockCmd.AddCommand(blockMoveCmd)
	blockCmd.AddCommand(blockBatchGetCmd)
	blockCmd.AddCommand(blockBatchKramdownCmd)
}