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 api
import (
"errors"
"time"
"github.com/gin-gonic/gin"
"github.com/siyuan-note/siyuan/kernel/apicontract"
"github.com/siyuan-note/siyuan/kernel/conf"
"github.com/siyuan-note/siyuan/kernel/model"
"github.com/siyuan-note/siyuan/kernel/treenode"
)
func documentAddressingFailure(err error) (apicontract.DocumentAddressingFailure, bool) {
var addressingErr *model.DocumentAddressingError
if errors.As(err, &addressingErr) {
return apicontract.DocumentAddressingFailure{Reason: addressingErr.Reason}, true
}
return apicontract.DocumentAddressingFailure{}, false
}
func documentPathContract(document *treenode.DocumentPath) apicontract.DocumentPath {
segments := make([]apicontract.DocumentPathSegment, 0, len(document.Segments))
for _, segment := range document.Segments {
segments = append(segments, apicontract.DocumentPathSegment{ID: segment.ID, Text: segment.Text, Empty: segment.Empty})
}
return apicontract.DocumentPath{
Notebook: document.Notebook, ID: document.ID, ParentID: document.ParentID, Path: document.Path,
Title: apicontract.DocumentTitle{Format: document.Title.Format, Text: document.Title.Text, Empty: document.Title.Empty},
Segments: segments, Depth: document.Depth, DisplayPath: document.DisplayPath,
Revision: document.Revision,
}
}
func documentTargetContract(target *conf.DocumentTarget) *apicontract.StructuredDocumentTarget {
if target == nil {
return nil
}
return &apicontract.StructuredDocumentTarget{Version: target.Version, Notebook: target.Notebook,
Anchor: apicontract.DocumentTargetAnchor{Kind: target.Anchor.Kind, ID: target.Anchor.ID},
Up: target.Up, Parents: target.Parents, Title: target.Title, OnMissingParent: target.OnMissingParent}
}
func documentTargetModel(target *apicontract.StructuredDocumentTarget) *conf.DocumentTarget {
if target == nil {
return nil
}
return &conf.DocumentTarget{Version: target.Version, Notebook: target.Notebook,
Anchor: conf.DocumentTargetAnchor{Kind: target.Anchor.Kind, ID: target.Anchor.ID},
Up: target.Up, Parents: target.Parents, Title: target.Title, OnMissingParent: target.OnMissingParent}
}
var getDocPaths = contractHandler(apicontract.GetDocPaths, func(c *gin.Context, request apicontract.GetDocPathsRequest) apicontract.Response[apicontract.DocumentPathsResult] {
if err := holdEncryptedBoxRequest(c, request.Notebook); err != nil {
return apicontract.Failure[apicontract.DocumentPathsResult](-1, err.Error())
}
documents, missing, err := model.GetDocPaths(request.Notebook, request.IDs)
if err != nil {
if failure, ok := documentAddressingFailure(err); ok {
return apicontract.GetDocPaths.FailureWithData(-1, err.Error(), apicontract.NewDocumentPathsFailure(failure))
}
return apicontract.Failure[apicontract.DocumentPathsResult](-1, err.Error())
}
data := apicontract.DocumentPathsData{Documents: []apicontract.DocumentPath{}, MissingIDs: missing}
for _, document := range documents {
data.Documents = append(data.Documents, documentPathContract(document))
}
return apicontract.Success(apicontract.NewDocumentPathsResult(data))
})
var resolveDocPath = contractHandler(apicontract.ResolveDocPath, func(c *gin.Context, request apicontract.ResolveDocPathRequest) apicontract.Response[apicontract.ResolveDocPathResult] {
if err := holdEncryptedBoxRequest(c, request.Notebook); err != nil {
return apicontract.Failure[apicontract.ResolveDocPathResult](-1, err.Error())
}
resolved, err := model.ResolveDocPath(request.Notebook, request.Start.Kind, request.Start.ID, request.Segments)
if err != nil {
if failure, ok := documentAddressingFailure(err); ok {
return apicontract.ResolveDocPath.FailureWithData(-1, err.Error(), apicontract.NewResolveDocPathFailure(failure))
}
return apicontract.Failure[apicontract.ResolveDocPathResult](-1, err.Error())
}
data := apicontract.ResolvedDocumentPathData{Status: resolved.Status, NextIndex: resolved.NextIndex,
Start: apicontract.DocumentLocation{Notebook: resolved.Start.Notebook, ID: resolved.Start.ID, Revision: resolved.Start.Revision},
CandidatesTruncated: resolved.CandidatesTruncated, Candidates: []apicontract.DocumentPath{},
NameConditions: []apicontract.DocumentNameCondition{}}
if resolved.Resolved != nil {
document := documentPathContract(resolved.Resolved)
data.Resolved = &document
}
for _, candidate := range resolved.Candidates {
data.Candidates = append(data.Candidates, documentPathContract(candidate))
}
for _, condition := range resolved.NameConditions {
data.NameConditions = append(data.NameConditions, apicontract.DocumentNameCondition{
ParentID: condition.ParentID, Title: condition.Title, ExpectedID: condition.ExpectedID})
}
return apicontract.Success(apicontract.NewResolveDocPathResult(data))
})
var createDocByParent = contractHandler(apicontract.CreateDocByParent, func(c *gin.Context, request apicontract.CreateDocByParentRequest) apicontract.Response[apicontract.CreateDocByParentResult] {
if err := holdEncryptedBoxRequest(c, request.Notebook); err != nil {
return apicontract.Failure[apicontract.CreateDocByParentResult](-1, err.Error())
}
input := model.DocumentCreateRequest{Notebook: request.Notebook, ParentID: request.ParentID, ID: request.ID,
TitleFormat: request.Title.Format, Title: request.Title.Text, Markdown: request.Markdown,
ExpectedParentRevision: request.ExpectedParentRevision, Tags: request.Tags, WithMath: request.WithMath,
ClippingHref: request.ClippingHref, Sorts: request.Sorts, SortTargetID: request.SortTargetID,
SortPosition: request.SortPosition, DocCreateTemplatePath: request.DocCreateTemplatePath, ListDocTree: request.ListDocTree}
if expected := request.ExpectedTarget; expected != nil {
if err := holdEncryptedBoxRequest(c, expected.Notebook); err != nil {
return apicontract.Failure[apicontract.CreateDocByParentResult](-1, err.Error())
}
input.ExpectedTarget = &model.DocumentTargetRevision{Notebook: expected.Notebook, Purpose: expected.Purpose, Revision: expected.Revision}
}
for _, condition := range request.NameConditions {
input.NameConditions = append(input.NameConditions, treenode.DocumentNameCondition{
ParentID: condition.ParentID, Title: condition.Title, ExpectedID: condition.ExpectedID})
}
document, err := model.CreateDocByParent(input)
if err != nil {
var failure *model.DocumentCreateFailure
if errors.As(err, &failure) {
return apicontract.CreateDocByParent.FailureWithData(-1, err.Error(), apicontract.NewCreateDocByParentFailure(
apicontract.DocumentCreateFailure{Reason: failure.Reason, CommitState: failure.CommitState,
ID: failure.ID, Stage: failure.Stage, Completed: failure.Completed}))
}
return apicontract.Failure[apicontract.CreateDocByParentResult](-1, err.Error())
}
return apicontract.Success(apicontract.NewCreateDocByParentResult(apicontract.CreatedDocumentData{
ID: document.ID, Document: documentPathContract(document)}))
})
var getDocCreateTarget = contractHandler(apicontract.GetDocCreateTarget, func(c *gin.Context, request apicontract.GetDocCreateTargetRequest) apicontract.Response[apicontract.DocumentCreateTargetData] {
if err := holdEncryptedBoxRequest(c, request.Notebook); err != nil {
return apicontract.Failure[apicontract.DocumentCreateTargetData](-1, err.Error())
}
value, err := model.GetDocCreateTarget(request.Notebook, request.Purpose)
if err != nil {
return apicontract.Failure[apicontract.DocumentCreateTargetData](-1, err.Error())
}
target := apicontract.LegacyCreateTarget(value.Notebook, value.Path)
if structured := value.Structured; structured != nil {
target = apicontract.StructuredCreateTarget(*documentTargetContract(structured))
}
return apicontract.Success(apicontract.DocumentCreateTargetData{
Target: target, DocCreateTemplatePath: value.DocCreateTemplatePath, Revision: value.Revision})
})
var planDocCreate = contractHandler(apicontract.PlanDocCreate, func(c *gin.Context, request apicontract.PlanDocCreateRequest) apicontract.Response[apicontract.DocumentCreatePlan] {
if err := holdEncryptedBoxRequest(c, request.Notebook); err != nil {
return apicontract.Failure[apicontract.DocumentCreatePlan](-1, err.Error())
}
target, err := model.GetDocCreateTarget(request.Notebook, request.Purpose)
if err != nil {
return apicontract.Failure[apicontract.DocumentCreatePlan](-1, err.Error())
}
if err = holdEncryptedBoxRequest(c, target.Notebook); err != nil {
return apicontract.Failure[apicontract.DocumentCreatePlan](-1, err.Error())
}
input := model.DocumentPlanRequest{Notebook: request.Notebook, Purpose: request.Purpose, ContextID: request.ContextID,
Title: request.Title, ID: request.ID, Placement: request.Placement, Reuse: request.Reuse}
if request.Date != nil {
input.Now, err = time.ParseInLocation("2006-01-02", *request.Date, time.Local)
if err != nil {
return apicontract.Failure[apicontract.DocumentCreatePlan](-1, err.Error())
}
}
plan, err := model.PlanDocumentCreation(input)
if err != nil {
return apicontract.Failure[apicontract.DocumentCreatePlan](-1, err.Error())
}
// 配置可能在读取期间改变,响应实际目标仍须持有租约。
if err = holdEncryptedBoxRequest(c, plan.Notebook); err != nil {
return apicontract.Failure[apicontract.DocumentCreatePlan](-1, err.Error())
}
result := apicontract.DocumentCreatePlan{Notebook: plan.Notebook, Title: plan.Title, ExistingID: plan.ExistingID,
Steps: []apicontract.CreateDocByParentRequest{}}
for _, step := range plan.Steps {
value := apicontract.CreateDocByParentRequest{Notebook: step.Notebook, ParentID: step.ParentID, ID: step.ID,
Title: apicontract.DocumentCreateTitle{Format: step.TitleFormat, Text: step.Title}, Markdown: step.Markdown,
ExpectedParentRevision: step.ExpectedParentRevision, DocCreateTemplatePath: step.DocCreateTemplatePath}
if expected := step.ExpectedTarget; expected != nil {
value.ExpectedTarget = &apicontract.DocumentTargetRevision{Notebook: expected.Notebook, Purpose: expected.Purpose, Revision: expected.Revision}
}
for _, condition := range step.NameConditions {
value.NameConditions = append(value.NameConditions, apicontract.DocumentNameCondition{
ParentID: condition.ParentID, Title: condition.Title, ExpectedID: condition.ExpectedID})
}
result.Steps = append(result.Steps, value)
}
return apicontract.Success(result)
})