268 lines
8.3 KiB
Rust
268 lines
8.3 KiB
Rust
use crate::command::{CommandExecutor, EditorCommand};
|
|
use crate::error::{CoreError, CoreResult};
|
|
use crate::markdown::{import_markdown, import_plain_text};
|
|
use crate::model::{BlockType, DocumentBlock, DocumentModel};
|
|
use crate::projection::VisibilitySnapshot;
|
|
use serde::{Deserialize, Serialize};
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
|
|
#[serde(rename_all = "snake_case")]
|
|
pub enum EditorInputKind {
|
|
PlainText,
|
|
Markdown,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
|
|
#[serde(rename_all = "snake_case")]
|
|
pub enum EditorAiScenario {
|
|
MeetingNotesToTodos,
|
|
LongParagraphToTitle,
|
|
PageReorder,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct EditorPipelineRequest {
|
|
pub kind: EditorInputKind,
|
|
pub scenario: EditorAiScenario,
|
|
pub input: String,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct BlockSnapshot {
|
|
pub block_id: String,
|
|
pub block_type: String,
|
|
pub text: String,
|
|
pub parent_id: Option<String>,
|
|
pub indent: u16,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct CommandAuditRecord {
|
|
pub command: String,
|
|
pub target_block_id: Option<String>,
|
|
pub before: Option<BlockSnapshot>,
|
|
pub after: Option<BlockSnapshot>,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct EditorChangeReport {
|
|
pub created_blocks: Vec<String>,
|
|
pub updated_blocks: Vec<String>,
|
|
pub moved_blocks: Vec<String>,
|
|
pub removed_blocks: Vec<String>,
|
|
pub notes: Vec<String>,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct EditorPipelineResult {
|
|
pub ok: bool,
|
|
pub scenario: EditorAiScenario,
|
|
pub input_kind: EditorInputKind,
|
|
pub document: DocumentModel,
|
|
pub audit: Vec<CommandAuditRecord>,
|
|
pub change_report: EditorChangeReport,
|
|
pub visible_block_ids: Vec<String>,
|
|
pub outline_titles: Vec<String>,
|
|
pub markdown: String,
|
|
}
|
|
|
|
pub fn apply_ai_pipeline(request: EditorPipelineRequest) -> CoreResult<EditorPipelineResult> {
|
|
let mut document = match request.kind {
|
|
EditorInputKind::PlainText => import_plain_text(&request.input)?,
|
|
EditorInputKind::Markdown => import_markdown(&request.input)?,
|
|
};
|
|
if document.blocks().is_empty() {
|
|
document.push(DocumentBlock::new("block_1", BlockType::Paragraph).with_text(""));
|
|
}
|
|
|
|
let mut audit = Vec::new();
|
|
let mut change_report = EditorChangeReport {
|
|
created_blocks: Vec::new(),
|
|
updated_blocks: Vec::new(),
|
|
moved_blocks: Vec::new(),
|
|
removed_blocks: Vec::new(),
|
|
notes: Vec::new(),
|
|
};
|
|
|
|
match request.scenario {
|
|
EditorAiScenario::MeetingNotesToTodos => {
|
|
apply_meeting_notes_to_todos(&mut document, &mut audit, &mut change_report)?
|
|
}
|
|
EditorAiScenario::LongParagraphToTitle => {
|
|
apply_long_paragraph_to_title(&mut document, &mut audit, &mut change_report)?
|
|
}
|
|
EditorAiScenario::PageReorder => {
|
|
apply_page_reorder(&mut document, &mut audit, &mut change_report)?
|
|
}
|
|
}
|
|
|
|
let projection = VisibilitySnapshot::derive(&document);
|
|
let markdown = crate::markdown::export_markdown(&document);
|
|
let outline_titles = projection
|
|
.outline
|
|
.iter()
|
|
.map(|entry| entry.title.clone())
|
|
.collect();
|
|
Ok(EditorPipelineResult {
|
|
ok: true,
|
|
scenario: request.scenario,
|
|
input_kind: request.kind,
|
|
document,
|
|
audit,
|
|
change_report,
|
|
visible_block_ids: projection.visible_block_ids,
|
|
outline_titles,
|
|
markdown,
|
|
})
|
|
}
|
|
|
|
fn apply_meeting_notes_to_todos(
|
|
document: &mut DocumentModel,
|
|
audit: &mut Vec<CommandAuditRecord>,
|
|
report: &mut EditorChangeReport,
|
|
) -> CoreResult<()> {
|
|
for index in 0..document.blocks().len() {
|
|
let is_note = document.blocks()[index].block_type == BlockType::Paragraph
|
|
&& document.blocks()[index].content.text.contains('待')
|
|
&& document.blocks()[index].content.text.contains('办');
|
|
if is_note {
|
|
let block_id = document.blocks()[index].id.clone();
|
|
let before = snapshot_block(document.blocks()[index].clone());
|
|
CommandExecutor::apply(
|
|
document,
|
|
EditorCommand::SetBlockType {
|
|
block_id: block_id.clone(),
|
|
block_type: BlockType::Todo,
|
|
},
|
|
)?;
|
|
let block = document
|
|
.block(&block_id)
|
|
.ok_or_else(|| CoreError::BlockNotFound(block_id.clone()))?;
|
|
let after = snapshot_block(block.clone());
|
|
audit.push(CommandAuditRecord {
|
|
command: "set_block_type".into(),
|
|
target_block_id: Some(block_id.clone()),
|
|
before: Some(before),
|
|
after: Some(after),
|
|
});
|
|
report.updated_blocks.push(block_id);
|
|
}
|
|
}
|
|
report.notes.push("已将疑似会议待办段落转为 todo".into());
|
|
Ok(())
|
|
}
|
|
|
|
fn apply_long_paragraph_to_title(
|
|
document: &mut DocumentModel,
|
|
audit: &mut Vec<CommandAuditRecord>,
|
|
report: &mut EditorChangeReport,
|
|
) -> CoreResult<()> {
|
|
let Some(first_id) = document.blocks().first().map(|block| block.id.clone()) else {
|
|
return Ok(());
|
|
};
|
|
let before = snapshot_block(
|
|
document
|
|
.block(&first_id)
|
|
.cloned()
|
|
.ok_or_else(|| CoreError::BlockNotFound(first_id.clone()))?,
|
|
);
|
|
let title = document
|
|
.block(&first_id)
|
|
.map(|block| {
|
|
block
|
|
.content
|
|
.text
|
|
.split_whitespace()
|
|
.take(8)
|
|
.collect::<Vec<_>>()
|
|
.join(" ")
|
|
})
|
|
.unwrap_or_default();
|
|
CommandExecutor::apply(
|
|
document,
|
|
EditorCommand::SetBlockType {
|
|
block_id: first_id.clone(),
|
|
block_type: BlockType::Heading,
|
|
},
|
|
)?;
|
|
if let Some(block) = document.block_mut(&first_id) {
|
|
block.heading_level = Some(1);
|
|
block.content.text = if title.is_empty() {
|
|
"提炼标题".into()
|
|
} else {
|
|
title
|
|
};
|
|
}
|
|
let after = snapshot_block(
|
|
document
|
|
.block(&first_id)
|
|
.cloned()
|
|
.ok_or_else(|| CoreError::BlockNotFound(first_id.clone()))?,
|
|
);
|
|
audit.push(CommandAuditRecord {
|
|
command: "set_block_type".into(),
|
|
target_block_id: Some(first_id.clone()),
|
|
before: Some(before),
|
|
after: Some(after),
|
|
});
|
|
report.updated_blocks.push(first_id);
|
|
report.notes.push("已将长段落提炼为标题".into());
|
|
Ok(())
|
|
}
|
|
|
|
fn apply_page_reorder(
|
|
document: &mut DocumentModel,
|
|
audit: &mut Vec<CommandAuditRecord>,
|
|
report: &mut EditorChangeReport,
|
|
) -> CoreResult<()> {
|
|
if document.blocks().len() < 2 {
|
|
report.notes.push("块数不足，跳过重排".into());
|
|
return Ok(());
|
|
}
|
|
let first = document.blocks()[0].id.clone();
|
|
let second = document.blocks()[1].id.clone();
|
|
let before_first = snapshot_block(
|
|
document
|
|
.block(&first)
|
|
.cloned()
|
|
.ok_or_else(|| CoreError::BlockNotFound(first.clone()))?,
|
|
);
|
|
CommandExecutor::apply(
|
|
document,
|
|
EditorCommand::MoveBlock {
|
|
block_id: first.clone(),
|
|
after_block_id: Some(second.clone()),
|
|
},
|
|
)?;
|
|
let after_first = snapshot_block(
|
|
document
|
|
.block(&first)
|
|
.cloned()
|
|
.ok_or_else(|| CoreError::BlockNotFound(first.clone()))?,
|
|
);
|
|
audit.push(CommandAuditRecord {
|
|
command: "move_block".into(),
|
|
target_block_id: Some(first.clone()),
|
|
before: Some(before_first),
|
|
after: Some(after_first),
|
|
});
|
|
report.moved_blocks.push(first);
|
|
report.notes.push("已执行页面重排".into());
|
|
Ok(())
|
|
}
|
|
|
|
fn snapshot_block(block: DocumentBlock) -> BlockSnapshot {
|
|
BlockSnapshot {
|
|
block_id: block.id,
|
|
block_type: block.block_type.as_editor_label().into(),
|
|
text: block.content.text,
|
|
parent_id: block.parent_id,
|
|
indent: block.indent,
|
|
}
|
|
}
|