1075 lines
34 KiB
Rust
1075 lines
34 KiB
Rust
use serde::{Deserialize, Serialize};
|
||
use serde_json::Value;
|
||
use std::collections::BTreeMap;
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
|
||
#[serde(rename_all = "snake_case")]
|
||
pub enum KernelNodeType {
|
||
Workspace,
|
||
Folder,
|
||
Page,
|
||
Section,
|
||
Asset,
|
||
Table,
|
||
Book,
|
||
Pdf,
|
||
Mindmap,
|
||
MindmapNode,
|
||
Summary,
|
||
AiNote,
|
||
ReferenceAnchor,
|
||
ContentNode,
|
||
IndexNode,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
|
||
#[serde(rename_all = "snake_case")]
|
||
pub enum KernelEdgeType {
|
||
ParentOf,
|
||
ChildOf,
|
||
Contains,
|
||
References,
|
||
BacklinksTo,
|
||
SourceOf,
|
||
DerivedFrom,
|
||
Summarizes,
|
||
Indexes,
|
||
PointsTo,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
|
||
#[serde(rename_all = "snake_case")]
|
||
pub enum KernelProjectionKind {
|
||
SidebarTree,
|
||
PageTree,
|
||
FileTree,
|
||
Mindmap,
|
||
ReadView,
|
||
SearchResults,
|
||
RagIndex,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
|
||
#[serde(rename_all = "snake_case")]
|
||
pub enum WorkspaceSourceKind {
|
||
LocalFolder,
|
||
ConvexWorkspace,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
|
||
#[serde(rename_all = "kebab-case")]
|
||
pub enum WorkspaceSourceCapability {
|
||
LoadSnapshot,
|
||
Watch,
|
||
PreflightCommand,
|
||
ExecuteCommand,
|
||
ResolvePageAggregate,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct WorkspaceSource {
|
||
pub source_kind: WorkspaceSourceKind,
|
||
pub root_uri: String,
|
||
pub workspace_id: String,
|
||
#[serde(default)]
|
||
pub capabilities: Vec<WorkspaceSourceCapability>,
|
||
}
|
||
|
||
fn default_page_body_content_format() -> String {
|
||
"editorBlocks".into()
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct PageBodyWriteRequest {
|
||
pub document_id: String,
|
||
pub workspace_id: String,
|
||
pub source_kind: WorkspaceSourceKind,
|
||
pub root_uri: String,
|
||
#[serde(
|
||
default,
|
||
alias = "expected_file_version",
|
||
alias = "conflictDetectionKey",
|
||
alias = "conflict_detection_key"
|
||
)]
|
||
pub expected_file_version: Option<String>,
|
||
#[serde(default)]
|
||
pub base_content_hash: Option<String>,
|
||
#[serde(default = "default_page_body_content_format")]
|
||
pub content_format: String,
|
||
pub content: Value,
|
||
#[serde(default)]
|
||
pub editor_source: Option<String>,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
|
||
#[serde(rename_all = "kebab-case")]
|
||
pub enum KernelProjectionCapability {
|
||
Expand,
|
||
Open,
|
||
Drag,
|
||
Drop,
|
||
Select,
|
||
CreateChild,
|
||
Rename,
|
||
Archive,
|
||
Restore,
|
||
ContextMenu,
|
||
Reorder,
|
||
OpenAsset,
|
||
Pick,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
|
||
#[serde(rename_all = "snake_case")]
|
||
pub enum KernelProjectionRowKind {
|
||
Document,
|
||
Index,
|
||
Asset,
|
||
AssetFolder,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
|
||
#[serde(rename_all = "snake_case")]
|
||
pub enum KernelProjectionResourceKind {
|
||
Workspace,
|
||
Document,
|
||
Index,
|
||
Asset,
|
||
AssetFolder,
|
||
Mindmap,
|
||
Attachment,
|
||
OnlyOffice,
|
||
Code,
|
||
Table,
|
||
Book,
|
||
Pdf,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
|
||
#[serde(rename_all = "snake_case")]
|
||
pub enum KernelProjectionAssetKind {
|
||
File,
|
||
Mindmap,
|
||
Table,
|
||
Book,
|
||
Pdf,
|
||
Image,
|
||
Video,
|
||
Audio,
|
||
Unknown,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
|
||
#[serde(rename_all = "snake_case")]
|
||
pub enum KernelObjectKind {
|
||
Page,
|
||
Index,
|
||
Mindmap,
|
||
Attachment,
|
||
OnlyOffice,
|
||
Code,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct KernelObjectIdentity {
|
||
pub object_kind: KernelObjectKind,
|
||
pub document_id: Option<String>,
|
||
pub block_id: Option<String>,
|
||
pub asset_id: Option<String>,
|
||
}
|
||
|
||
/// DocumentBuffer 打开状态 — 表达当前编辑器缓冲区对文件的打开态、dirty 状态和文件版本仲裁。
|
||
///
|
||
/// 五种状态：Clean（未修改）、Dirty（已修改未保存）、Stale（版本过时）、
|
||
/// ExternalModified（外部已修改）、Deleted（外部已删除）。
|
||
///
|
||
/// Phase A2 收口后，tiptap autosave、AI 写入、外部 watcher 均围绕此状态仲裁。
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
|
||
#[serde(rename_all = "snake_case")]
|
||
pub enum DocBufferDirtyState {
|
||
Clean,
|
||
Dirty,
|
||
Stale,
|
||
ExternalModified,
|
||
Deleted,
|
||
}
|
||
|
||
impl Default for DocBufferDirtyState {
|
||
fn default() -> Self {
|
||
Self::Clean
|
||
}
|
||
}
|
||
|
||
/// DocumentBuffer 最小字段模型 — 表示一个已打开文档的缓冲区状态。
|
||
///
|
||
/// 不是持久化结构，而是运行时模型，用于仲裁写入冲突和外部修改检测。
|
||
/// 每个打开的编辑器（tiptap / AI session / external editor）对应一个实例。
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct DocumentBuffer {
|
||
/// 文档在 workspace 中的统一路径身份
|
||
pub workspace_path: ObjectWorkspacePath,
|
||
/// 最后已知文件版本（来自 aggregate.fileVersion 或 disk mtime content-hash）
|
||
pub file_version: Option<String>,
|
||
/// 最后加载/保存时的内容 hash
|
||
pub base_content_hash: Option<String>,
|
||
/// 当前编辑器内容 hash（dirty 时与 base 不同）
|
||
pub current_content_hash: Option<String>,
|
||
/// 缓冲区 dirty 状态
|
||
pub dirty_state: DocBufferDirtyState,
|
||
/// 最后加载时间戳 (ms since epoch)
|
||
pub last_loaded_at: Option<i64>,
|
||
/// 最后保存时间戳 (ms since epoch)
|
||
pub last_saved_at: Option<i64>,
|
||
/// 外部修改者
|
||
pub external_actor: Option<String>,
|
||
}
|
||
|
||
impl DocumentBuffer {
|
||
pub fn is_dirty(&self) -> bool {
|
||
self.dirty_state == DocBufferDirtyState::Dirty
|
||
|| self.dirty_state == DocBufferDirtyState::Stale
|
||
}
|
||
|
||
pub fn mark_dirty(&mut self, content_hash: String) {
|
||
self.current_content_hash = Some(content_hash);
|
||
self.dirty_state = DocBufferDirtyState::Dirty;
|
||
}
|
||
|
||
pub fn mark_saved(&mut self, file_version: String, content_hash: String) {
|
||
self.file_version = Some(file_version);
|
||
self.base_content_hash = Some(content_hash);
|
||
self.current_content_hash = None;
|
||
self.dirty_state = DocBufferDirtyState::Clean;
|
||
self.last_saved_at = Some(
|
||
std::time::SystemTime::now()
|
||
.duration_since(std::time::UNIX_EPOCH)
|
||
.unwrap_or_default()
|
||
.as_millis() as i64,
|
||
);
|
||
}
|
||
|
||
pub fn mark_external_modified(&mut self, actor: Option<String>) {
|
||
self.external_actor = actor;
|
||
if self.is_dirty() {
|
||
self.dirty_state = DocBufferDirtyState::Stale;
|
||
} else {
|
||
self.dirty_state = DocBufferDirtyState::ExternalModified;
|
||
}
|
||
}
|
||
|
||
pub fn mark_deleted(&mut self) {
|
||
self.dirty_state = DocBufferDirtyState::Deleted;
|
||
}
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct KernelBlockAssetRelation {
|
||
pub document_id: String,
|
||
pub block_id: String,
|
||
pub asset_id: String,
|
||
pub asset_kind: KernelProjectionAssetKind,
|
||
}
|
||
|
||
/// 统一 workspace 路径身份 — 表达"哪个 workspace root 下的哪个对象/文件/资源"。
|
||
///
|
||
/// 这是 Phase A1 收口后的主身份类型，用于：
|
||
/// - File Tree / Page Tree / Resource Tree 的 resourceMeta
|
||
/// - 本地文件写入时的身份验证
|
||
/// - 前端 sidebar/filetree 的统一 identity 消费
|
||
///
|
||
/// 相比旧的 `KernelObjectIdentity`，增加了 workspace 上下文：
|
||
/// `workspace_id`、`source_kind`、`root_uri`、`relative_path`。
|
||
///
|
||
/// 所有新代码应优先使用此类型；`KernelObjectIdentity` 保留为内核投影的兼容子集。
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct ObjectWorkspacePath {
|
||
pub workspace_id: String,
|
||
pub source_kind: WorkspaceSourceKind,
|
||
pub root_uri: String,
|
||
pub relative_path: String,
|
||
pub object_identity: KernelObjectIdentity,
|
||
pub resource_kind: Option<String>,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
|
||
#[serde(rename_all = "snake_case")]
|
||
pub enum KernelGraphDirection {
|
||
Outgoing,
|
||
Incoming,
|
||
Both,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct KernelSubtreeRef {
|
||
pub root_node_id: String,
|
||
#[serde(default)]
|
||
pub path: Vec<String>,
|
||
pub depth: Option<u32>,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct KernelNodeMetadata {
|
||
pub title: Option<String>,
|
||
pub icon: Option<String>,
|
||
#[serde(default)]
|
||
pub tags: Vec<String>,
|
||
pub created_at: Option<String>,
|
||
pub updated_at: Option<String>,
|
||
#[serde(default)]
|
||
pub extra: BTreeMap<String, Value>,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct KernelContentPayload {
|
||
pub format: String,
|
||
pub body: Value,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct KernelRefsPayload {
|
||
#[serde(default)]
|
||
pub reference_node_ids: Vec<String>,
|
||
#[serde(default)]
|
||
pub evidence_node_ids: Vec<String>,
|
||
#[serde(default)]
|
||
pub source_node_ids: Vec<String>,
|
||
#[serde(default)]
|
||
pub extra: BTreeMap<String, Value>,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct KernelAuditStamp {
|
||
pub version: u64,
|
||
pub revision: Option<u64>,
|
||
pub request_id: Option<String>,
|
||
pub trace_id: Option<String>,
|
||
pub actor_id: Option<String>,
|
||
}
|
||
|
||
impl Default for KernelAuditStamp {
|
||
fn default() -> Self {
|
||
Self {
|
||
version: 1,
|
||
revision: None,
|
||
request_id: None,
|
||
trace_id: None,
|
||
actor_id: None,
|
||
}
|
||
}
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct KernelNode {
|
||
pub id: String,
|
||
pub node_type: KernelNodeType,
|
||
pub workspace_id: Option<String>,
|
||
pub parent_id: Option<String>,
|
||
pub subtree: Option<KernelSubtreeRef>,
|
||
pub metadata: KernelNodeMetadata,
|
||
pub content: Option<KernelContentPayload>,
|
||
pub refs: Option<KernelRefsPayload>,
|
||
#[serde(default)]
|
||
pub audit: KernelAuditStamp,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct KernelEdge {
|
||
pub id: String,
|
||
pub edge_type: KernelEdgeType,
|
||
pub workspace_id: Option<String>,
|
||
pub from_node_id: String,
|
||
pub to_node_id: String,
|
||
#[serde(default)]
|
||
pub metadata: BTreeMap<String, Value>,
|
||
#[serde(default)]
|
||
pub audit: KernelAuditStamp,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct KernelProjectionFilter {
|
||
#[serde(default)]
|
||
pub node_types: Vec<KernelNodeType>,
|
||
#[serde(default)]
|
||
pub edge_types: Vec<KernelEdgeType>,
|
||
pub query: Option<String>,
|
||
pub max_results: Option<usize>,
|
||
#[serde(default)]
|
||
pub include_deleted: bool,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct KernelGetNode {
|
||
pub node_id: String,
|
||
pub workspace_id: Option<String>,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct KernelGetSubtree {
|
||
pub subtree: KernelSubtreeRef,
|
||
pub workspace_id: Option<String>,
|
||
#[serde(default)]
|
||
pub include_edges: bool,
|
||
#[serde(default)]
|
||
pub filters: KernelProjectionFilter,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct KernelListChildren {
|
||
pub parent_node_id: String,
|
||
pub workspace_id: Option<String>,
|
||
#[serde(default)]
|
||
pub node_types: Vec<KernelNodeType>,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct KernelListEdges {
|
||
pub node_id: String,
|
||
pub workspace_id: Option<String>,
|
||
#[serde(default)]
|
||
pub edge_types: Vec<KernelEdgeType>,
|
||
pub direction: Option<KernelGraphDirection>,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct KernelTraverseGraph {
|
||
pub start_node_id: String,
|
||
pub workspace_id: Option<String>,
|
||
#[serde(default)]
|
||
pub edge_types: Vec<KernelEdgeType>,
|
||
pub max_depth: u32,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct KernelProjectionRequest {
|
||
pub projection: KernelProjectionKind,
|
||
pub workspace_id: Option<String>,
|
||
pub root_node_id: Option<String>,
|
||
pub subtree: Option<KernelSubtreeRef>,
|
||
#[serde(default)]
|
||
pub filters: KernelProjectionFilter,
|
||
#[serde(default)]
|
||
pub include_content: bool,
|
||
#[serde(default)]
|
||
pub include_edges: bool,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct KernelSubtreeResult {
|
||
pub root_node_id: String,
|
||
pub nodes: Vec<KernelNode>,
|
||
pub edges: Vec<KernelEdge>,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct KernelEdgeListResult {
|
||
pub node_id: String,
|
||
pub edges: Vec<KernelEdge>,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct KernelGraphVisit {
|
||
pub node_id: String,
|
||
pub depth: u32,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct KernelGraphTraversalResult {
|
||
pub start_node_id: String,
|
||
pub visited: Vec<KernelGraphVisit>,
|
||
pub edges: Vec<KernelEdge>,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct KernelProjectionItem {
|
||
pub row_id: String,
|
||
pub row_kind: KernelProjectionRowKind,
|
||
pub node_id: String,
|
||
pub parent_node_id: Option<String>,
|
||
pub node_type: KernelNodeType,
|
||
pub projection_kind: KernelProjectionKind,
|
||
pub title: Option<String>,
|
||
pub depth: u32,
|
||
pub position: Option<i64>,
|
||
pub child_count: u32,
|
||
pub expandable: bool,
|
||
pub expanded_by_default: bool,
|
||
#[serde(default)]
|
||
pub capabilities: Vec<KernelProjectionCapability>,
|
||
pub resource_meta: Option<KernelProjectionResourceMeta>,
|
||
pub icon_hint: Option<String>,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct KernelProjectionResourceMeta {
|
||
pub resource_kind: Option<KernelProjectionResourceKind>,
|
||
pub document_id: Option<String>,
|
||
pub asset_id: Option<String>,
|
||
pub workspace_id: Option<String>,
|
||
pub asset_kind: Option<KernelProjectionAssetKind>,
|
||
pub icon_hint: Option<String>,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub object_identity: Option<KernelObjectIdentity>,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub block_asset_relation: Option<KernelBlockAssetRelation>,
|
||
#[serde(default)]
|
||
pub extra: BTreeMap<String, Value>,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct KernelProjectionResult {
|
||
pub projection_id: String,
|
||
pub projection: KernelProjectionKind,
|
||
pub root_node_id: Option<String>,
|
||
pub items: Vec<KernelProjectionItem>,
|
||
pub edges: Vec<KernelEdge>,
|
||
#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
|
||
pub meta: BTreeMap<String, Value>,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
|
||
#[serde(rename_all = "snake_case")]
|
||
pub enum DocumentReadNodeType {
|
||
Page,
|
||
Section,
|
||
ContentNode,
|
||
ReferenceAnchor,
|
||
Mindmap,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct DocumentReadNodeMeta {
|
||
pub title: Option<String>,
|
||
pub text_snippet: Option<String>,
|
||
pub block_type: Option<String>,
|
||
pub heading_level: Option<u32>,
|
||
pub numbering: Option<String>,
|
||
pub child_count: u32,
|
||
pub order: u32,
|
||
#[serde(default)]
|
||
pub path: Vec<String>,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct DocumentReadNode {
|
||
pub id: String,
|
||
pub parent_node_id: Option<String>,
|
||
pub node_type: DocumentReadNodeType,
|
||
pub block_id: Option<String>,
|
||
pub anchor_block_id: Option<String>,
|
||
pub depth: u32,
|
||
pub metadata: DocumentReadNodeMeta,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct DocumentReadSubtree {
|
||
pub root_node_id: String,
|
||
pub nodes: Vec<DocumentReadNode>,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct DocumentReadOutlineEntry {
|
||
pub id: String,
|
||
pub node_id: String,
|
||
pub anchor_block_id: Option<String>,
|
||
pub title: String,
|
||
pub level: u32,
|
||
pub numbering: String,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
|
||
#[serde(rename_all = "snake_case")]
|
||
pub enum DocumentReadEvidenceKind {
|
||
Page,
|
||
Heading,
|
||
Paragraph,
|
||
List,
|
||
Todo,
|
||
Quote,
|
||
Code,
|
||
Media,
|
||
Reference,
|
||
Table,
|
||
Mindmap,
|
||
Text,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct DocumentReadEvidenceItem {
|
||
pub id: String,
|
||
pub node_id: String,
|
||
pub block_id: Option<String>,
|
||
pub kind: DocumentReadEvidenceKind,
|
||
pub snippet: String,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct DocumentReadStats {
|
||
pub block_count: u32,
|
||
pub heading_count: u32,
|
||
pub evidence_count: u32,
|
||
pub max_depth: u32,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct DocumentReadPageSubtree {
|
||
pub projection_id: String,
|
||
pub projection: String,
|
||
pub root_node_id: String,
|
||
pub root_node: DocumentReadNode,
|
||
pub subtree: DocumentReadSubtree,
|
||
#[serde(default)]
|
||
pub outline: Vec<DocumentReadOutlineEntry>,
|
||
#[serde(default)]
|
||
pub evidence: Vec<DocumentReadEvidenceItem>,
|
||
pub stats: DocumentReadStats,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct DocumentContentResult {
|
||
pub content: Value,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub editor_document: Option<Value>,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub tiptap_document: Option<Value>,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub block_document: Option<Value>,
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub block_projection_version: Option<u32>,
|
||
pub revision: u64,
|
||
pub conflict_detection_key: String,
|
||
pub title: Option<String>,
|
||
pub page_subtree: DocumentReadPageSubtree,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct KernelCreateNode {
|
||
pub node: KernelNode,
|
||
pub position: Option<i64>,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct KernelUpdateNode {
|
||
pub node_id: String,
|
||
pub metadata: Option<KernelNodeMetadata>,
|
||
pub content: Option<KernelContentPayload>,
|
||
pub refs: Option<KernelRefsPayload>,
|
||
pub audit: Option<KernelAuditStamp>,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct KernelMoveSubtree {
|
||
pub subtree: KernelSubtreeRef,
|
||
pub new_parent_node_id: Option<String>,
|
||
pub sort_order: Option<i64>,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct KernelAttachEdge {
|
||
pub edge: KernelEdge,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct KernelDetachEdge {
|
||
pub edge_id: Option<String>,
|
||
pub from_node_id: Option<String>,
|
||
pub to_node_id: Option<String>,
|
||
pub edge_type: Option<KernelEdgeType>,
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::*;
|
||
use serde_json::json;
|
||
|
||
#[test]
|
||
fn kernel_projection_request_roundtrip_keeps_subtree_and_filters() {
|
||
let request = KernelProjectionRequest {
|
||
projection: KernelProjectionKind::SidebarTree,
|
||
workspace_id: Some("ws_1".into()),
|
||
root_node_id: Some("page_root".into()),
|
||
subtree: Some(KernelSubtreeRef {
|
||
root_node_id: "page_root".into(),
|
||
path: vec!["page_root".into(), "page_child".into()],
|
||
depth: Some(2),
|
||
}),
|
||
filters: KernelProjectionFilter {
|
||
node_types: vec![KernelNodeType::Page, KernelNodeType::Folder],
|
||
edge_types: vec![KernelEdgeType::ParentOf],
|
||
query: Some("预算".into()),
|
||
max_results: Some(20),
|
||
include_deleted: false,
|
||
},
|
||
include_content: false,
|
||
include_edges: true,
|
||
};
|
||
|
||
let value = serde_json::to_value(&request).expect("request 应可序列化");
|
||
assert_eq!(value["projection"], json!("sidebar_tree"));
|
||
assert_eq!(value["subtree"]["rootNodeId"], json!("page_root"));
|
||
assert_eq!(value["filters"]["query"], json!("预算"));
|
||
assert_eq!(value["filters"]["maxResults"], json!(20));
|
||
|
||
let decoded: KernelProjectionRequest =
|
||
serde_json::from_value(value).expect("request 应可反序列化");
|
||
assert_eq!(decoded, request);
|
||
}
|
||
|
||
#[test]
|
||
fn kernel_node_serializes_content_refs_and_audit_boundaries() {
|
||
let node = KernelNode {
|
||
id: "node_1".into(),
|
||
node_type: KernelNodeType::Summary,
|
||
workspace_id: Some("ws_1".into()),
|
||
parent_id: Some("page_1".into()),
|
||
subtree: Some(KernelSubtreeRef {
|
||
root_node_id: "page_1".into(),
|
||
path: vec!["page_1".into(), "node_1".into()],
|
||
depth: Some(1),
|
||
}),
|
||
metadata: KernelNodeMetadata {
|
||
title: Some("摘要节点".into()),
|
||
icon: None,
|
||
tags: vec!["summary".into()],
|
||
created_at: Some("2026-04-16T00:00:00Z".into()),
|
||
updated_at: Some("2026-04-16T00:00:00Z".into()),
|
||
extra: BTreeMap::new(),
|
||
},
|
||
content: Some(KernelContentPayload {
|
||
format: "markdown".into(),
|
||
body: json!({"text": "摘要正文"}),
|
||
}),
|
||
refs: Some(KernelRefsPayload {
|
||
reference_node_ids: vec!["page_1".into()],
|
||
evidence_node_ids: vec!["asset_1".into()],
|
||
source_node_ids: vec!["pdf_1".into()],
|
||
extra: BTreeMap::new(),
|
||
}),
|
||
audit: KernelAuditStamp {
|
||
version: 3,
|
||
revision: Some(9),
|
||
request_id: Some("req_1".into()),
|
||
trace_id: Some("trace_1".into()),
|
||
actor_id: Some("user_1".into()),
|
||
},
|
||
};
|
||
|
||
let value = serde_json::to_value(&node).expect("node 应可序列化");
|
||
assert_eq!(value["nodeType"], json!("summary"));
|
||
assert_eq!(value["content"]["format"], json!("markdown"));
|
||
assert_eq!(value["refs"]["referenceNodeIds"], json!(["page_1"]));
|
||
assert_eq!(value["audit"]["traceId"], json!("trace_1"));
|
||
}
|
||
|
||
#[test]
|
||
fn kernel_projection_item_serializes_contract_fields() {
|
||
let item = KernelProjectionItem {
|
||
row_id: "asset:page_1".into(),
|
||
row_kind: KernelProjectionRowKind::Asset,
|
||
node_id: "page_1".into(),
|
||
parent_node_id: None,
|
||
node_type: KernelNodeType::Page,
|
||
projection_kind: KernelProjectionKind::FileTree,
|
||
title: Some("页面 1".into()),
|
||
depth: 0,
|
||
position: Some(1),
|
||
child_count: 2,
|
||
expandable: true,
|
||
expanded_by_default: true,
|
||
capabilities: vec![
|
||
KernelProjectionCapability::Expand,
|
||
KernelProjectionCapability::Open,
|
||
KernelProjectionCapability::CreateChild,
|
||
],
|
||
resource_meta: Some(KernelProjectionResourceMeta {
|
||
resource_kind: Some(KernelProjectionResourceKind::Document),
|
||
document_id: Some("page_1".into()),
|
||
asset_id: None,
|
||
workspace_id: Some("ws_1".into()),
|
||
asset_kind: Some(KernelProjectionAssetKind::File),
|
||
icon_hint: Some("page".into()),
|
||
object_identity: None,
|
||
block_asset_relation: None,
|
||
extra: BTreeMap::new(),
|
||
}),
|
||
icon_hint: Some("page".into()),
|
||
};
|
||
|
||
let value = serde_json::to_value(&item).expect("projection item 应可序列化");
|
||
assert_eq!(value["rowId"], json!("asset:page_1"));
|
||
assert_eq!(value["rowKind"], json!("asset"));
|
||
assert_eq!(value["projectionKind"], json!("file_tree"));
|
||
assert_eq!(
|
||
value["capabilities"],
|
||
json!(["expand", "open", "create-child"])
|
||
);
|
||
assert_eq!(value["resourceMeta"]["resourceKind"], json!("document"));
|
||
assert_eq!(value["iconHint"], json!("page"));
|
||
}
|
||
|
||
#[test]
|
||
fn workspace_source_serializes_minimal_command_source_contract() {
|
||
let source = WorkspaceSource {
|
||
source_kind: WorkspaceSourceKind::ConvexWorkspace,
|
||
root_uri: "convex://workspace/ws_1".into(),
|
||
workspace_id: "ws_1".into(),
|
||
capabilities: vec![
|
||
WorkspaceSourceCapability::LoadSnapshot,
|
||
WorkspaceSourceCapability::PreflightCommand,
|
||
WorkspaceSourceCapability::ExecuteCommand,
|
||
],
|
||
};
|
||
|
||
let value = serde_json::to_value(&source).expect("workspace source 应可序列化");
|
||
assert_eq!(value["sourceKind"], json!("convex_workspace"));
|
||
assert_eq!(value["rootUri"], json!("convex://workspace/ws_1"));
|
||
assert_eq!(value["workspaceId"], json!("ws_1"));
|
||
assert_eq!(
|
||
value["capabilities"],
|
||
json!(["load-snapshot", "preflight-command", "execute-command"])
|
||
);
|
||
|
||
let decoded: WorkspaceSource =
|
||
serde_json::from_value(value).expect("workspace source 应可反序列化");
|
||
assert_eq!(decoded, source);
|
||
}
|
||
|
||
#[test]
|
||
fn page_body_write_request_uses_file_version_contract() {
|
||
let request: PageBodyWriteRequest = serde_json::from_value(json!({
|
||
"documentId": "local-md:README.md",
|
||
"workspaceId": "local-ws:user:my-space",
|
||
"sourceKind": "local_folder",
|
||
"rootUri": "file:///mnt/Data1T/Mnote_data/users/user/workspaces/my-space",
|
||
"expectedFileVersion": "local-md:local-md:README.md:1:2:hash",
|
||
"baseContentHash": "sha256:base",
|
||
"contentFormat": "editorBlocks",
|
||
"content": [{"type": "paragraph", "content": [{"type": "text", "text": "正文"}]}],
|
||
"editorSource": "tiptap"
|
||
}))
|
||
.expect("page.body.write request 应可反序列化");
|
||
|
||
assert_eq!(request.document_id, "local-md:README.md");
|
||
assert_eq!(request.source_kind, WorkspaceSourceKind::LocalFolder);
|
||
assert_eq!(
|
||
request.expected_file_version.as_deref(),
|
||
Some("local-md:local-md:README.md:1:2:hash")
|
||
);
|
||
assert_eq!(request.content_format, "editorBlocks");
|
||
assert_eq!(request.editor_source.as_deref(), Some("tiptap"));
|
||
|
||
let value = serde_json::to_value(&request).expect("request 应可序列化");
|
||
assert_eq!(
|
||
value["expectedFileVersion"],
|
||
json!("local-md:local-md:README.md:1:2:hash")
|
||
);
|
||
assert_eq!(value["baseContentHash"], json!("sha256:base"));
|
||
assert_eq!(value["contentFormat"], json!("editorBlocks"));
|
||
assert_eq!(value["editorSource"], json!("tiptap"));
|
||
}
|
||
|
||
#[test]
|
||
fn page_body_write_request_accepts_legacy_conflict_key_alias() {
|
||
let request: PageBodyWriteRequest = serde_json::from_value(json!({
|
||
"documentId": "local-md:README.md",
|
||
"workspaceId": "local-ws:user:my-space",
|
||
"sourceKind": "local_folder",
|
||
"rootUri": "file:///tmp/workspace",
|
||
"conflictDetectionKey": "legacy-key",
|
||
"content": []
|
||
}))
|
||
.expect("legacy compat request 应可反序列化");
|
||
|
||
assert_eq!(request.expected_file_version.as_deref(), Some("legacy-key"));
|
||
assert_eq!(request.content_format, "editorBlocks");
|
||
assert_eq!(request.base_content_hash, None);
|
||
assert_eq!(request.editor_source, None);
|
||
}
|
||
|
||
#[test]
|
||
fn object_workspace_path_round_trip() {
|
||
let path = ObjectWorkspacePath {
|
||
workspace_id: "local-ws:user:my-space".into(),
|
||
source_kind: WorkspaceSourceKind::LocalFolder,
|
||
root_uri: "file:///mnt/Data1T/Mnote_data/users/user/workspaces/my-space".into(),
|
||
relative_path: "docs/README.md".into(),
|
||
object_identity: KernelObjectIdentity {
|
||
object_kind: KernelObjectKind::Page,
|
||
document_id: Some("local-md:docs~2FREADME.md".into()),
|
||
block_id: None,
|
||
asset_id: None,
|
||
},
|
||
resource_kind: Some("document".into()),
|
||
};
|
||
|
||
let value = serde_json::to_value(&path).expect("ObjectWorkspacePath 应可序列化");
|
||
assert_eq!(value["workspaceId"], json!("local-ws:user:my-space"));
|
||
assert_eq!(value["sourceKind"], json!("local_folder"));
|
||
assert_eq!(
|
||
value["rootUri"],
|
||
json!("file:///mnt/Data1T/Mnote_data/users/user/workspaces/my-space")
|
||
);
|
||
assert_eq!(value["relativePath"], json!("docs/README.md"));
|
||
assert_eq!(value["objectIdentity"]["objectKind"], json!("page"));
|
||
assert_eq!(
|
||
value["objectIdentity"]["documentId"],
|
||
json!("local-md:docs~2FREADME.md")
|
||
);
|
||
assert_eq!(value["resourceKind"], json!("document"));
|
||
|
||
let decoded: ObjectWorkspacePath =
|
||
serde_json::from_value(value).expect("ObjectWorkspacePath 应可反序列化");
|
||
assert_eq!(decoded, path);
|
||
}
|
||
|
||
#[test]
|
||
fn object_workspace_path_accepts_resource_kind_null() {
|
||
#[derive(Deserialize)]
|
||
struct Minimal {
|
||
resource_kind: Option<String>,
|
||
}
|
||
let value = serde_json::json!({
|
||
"workspaceId": "ws_1",
|
||
"sourceKind": "convex_workspace",
|
||
"rootUri": "convex://ws",
|
||
"relativePath": "doc.md",
|
||
"objectIdentity": {
|
||
"objectKind": "page",
|
||
"documentId": "doc_1",
|
||
"blockId": null,
|
||
"assetId": null
|
||
}
|
||
});
|
||
let path: ObjectWorkspacePath =
|
||
serde_json::from_value(value).expect("resource_kind null 应接受");
|
||
assert_eq!(path.resource_kind, None);
|
||
}
|
||
|
||
#[test]
|
||
fn document_buffer_round_trip() {
|
||
let identity = KernelObjectIdentity {
|
||
object_kind: KernelObjectKind::Page,
|
||
document_id: Some("local-md:doc.md".into()),
|
||
block_id: None,
|
||
asset_id: None,
|
||
};
|
||
let path = ObjectWorkspacePath {
|
||
workspace_id: "ws_1".into(),
|
||
source_kind: WorkspaceSourceKind::LocalFolder,
|
||
root_uri: "file:///tmp/root".into(),
|
||
relative_path: "doc.md".into(),
|
||
object_identity: identity,
|
||
resource_kind: Some("document".into()),
|
||
};
|
||
let buf = DocumentBuffer {
|
||
workspace_path: path,
|
||
file_version: Some("v1".into()),
|
||
base_content_hash: Some("sha256:abc".into()),
|
||
current_content_hash: None,
|
||
dirty_state: DocBufferDirtyState::Clean,
|
||
last_loaded_at: Some(1_700_000_000_000i64),
|
||
last_saved_at: Some(1_700_000_000_001i64),
|
||
external_actor: None,
|
||
};
|
||
|
||
let value = serde_json::to_value(&buf).expect("DocumentBuffer 应可序列化");
|
||
assert_eq!(value["dirtyState"], json!("clean"));
|
||
assert_eq!(value["fileVersion"], json!("v1"));
|
||
assert_eq!(value["workspacePath"]["relativePath"], json!("doc.md"));
|
||
|
||
let decoded: DocumentBuffer =
|
||
serde_json::from_value(value).expect("DocumentBuffer 应可反序列化");
|
||
assert_eq!(decoded, buf);
|
||
}
|
||
|
||
#[test]
|
||
fn document_buffer_state_transitions() {
|
||
let identity = KernelObjectIdentity {
|
||
object_kind: KernelObjectKind::Page,
|
||
document_id: Some("local-md:doc.md".into()),
|
||
block_id: None,
|
||
asset_id: None,
|
||
};
|
||
let path = ObjectWorkspacePath {
|
||
workspace_id: "ws_1".into(),
|
||
source_kind: WorkspaceSourceKind::LocalFolder,
|
||
root_uri: "file:///tmp/root".into(),
|
||
relative_path: "doc.md".into(),
|
||
object_identity: identity,
|
||
resource_kind: Some("document".into()),
|
||
};
|
||
let mut buf = DocumentBuffer {
|
||
workspace_path: path,
|
||
file_version: Some("v1".into()),
|
||
base_content_hash: Some("sha256:abc".into()),
|
||
current_content_hash: None,
|
||
dirty_state: DocBufferDirtyState::Clean,
|
||
last_loaded_at: None,
|
||
last_saved_at: None,
|
||
external_actor: None,
|
||
};
|
||
|
||
assert!(!buf.is_dirty());
|
||
assert_eq!(buf.dirty_state, DocBufferDirtyState::Clean);
|
||
|
||
buf.mark_dirty("sha256:dirty".into());
|
||
assert!(buf.is_dirty());
|
||
assert_eq!(buf.dirty_state, DocBufferDirtyState::Dirty);
|
||
|
||
buf.mark_external_modified(Some("external-editor".into()));
|
||
assert!(buf.is_dirty());
|
||
assert_eq!(buf.dirty_state, DocBufferDirtyState::Stale);
|
||
assert_eq!(buf.external_actor.as_deref(), Some("external-editor"));
|
||
|
||
buf.mark_saved("v2".into(), "sha256:saved".into());
|
||
assert!(!buf.is_dirty());
|
||
assert_eq!(buf.dirty_state, DocBufferDirtyState::Clean);
|
||
assert_eq!(buf.file_version.as_deref(), Some("v2"));
|
||
|
||
buf.mark_external_modified(None);
|
||
assert_eq!(buf.dirty_state, DocBufferDirtyState::ExternalModified);
|
||
|
||
buf.mark_deleted();
|
||
assert_eq!(buf.dirty_state, DocBufferDirtyState::Deleted);
|
||
}
|
||
}
|