Files
Thing/src-tauri/src/editor/index.rs
T
2026-10-10 14:29:48 +08:00

1457 lines
58 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! 笔记索引:SQLite + FTS5 全文检索、标签、双链。
//!
//! # 索引不是真相
//!
//! 真相永远是库根下的 `.md` 文件(见 `library.rs`)。本模块只是**可随时丢弃重建**
//! 的加速层:删掉 `{库根}/.editor/editor.db` 的唯一后果是下次搜索前要做一次全量扫描。
//! 因此这里不写「强一致」逻辑,只保证「一次同步之后索引与文件一致」——
//! 增量同步靠 `(mtime, size)` 快速筛掉未变文件,变了才读内容算 hash。
//!
//! # 为什么索引放在库根里(而不是 app_data)
//!
//! 库是可切换的(设置里的自定义目录)。索引跟库走有两个好处:换库自然换索引,
//! 不需要维护「库 → 索引文件」的映射;把整个库目录拷走时索引一起走,新机器上
//! 第一次搜索只做增量校验而不是全量重建。
//!
//! 代价是「数据库落在用户看得见的目录里」,所以目录名用点号前缀 `.editor/`:
//! 库扫描(`library::scan`)本来就跳过点号开头的目录,它不会出现在侧栏树里;
//! P2 的 WebDAV 同步也会按约定排除它。
//!
//! # 分词器为什么选 trigram
//!
//! 笔记正文以中文为主,而 FTS5 默认的 `unicode61` 分词器把连续汉字切成**一整个**
//! 词元:搜「会议」匹配不到「周会议纪要」。`trigram` 按 3 字符 n-gram 建索引,
//! 中文任意子串(≥3 字)都能命中;代价是**查询词短于 3 字符时静默返回空**,
//! 所以 [`FTS_MIN_CHARS`] 以下的词回退到 `LIKE` 扫描(笔记库规模下完全够用)。
//! 这与 `terminal/history.rs` 的取舍同源。
use std::path::{Path, PathBuf};
use std::time::UNIX_EPOCH;
use rusqlite::{params, Connection, OptionalExtension};
use serde::{Deserialize, Serialize};
use specta::Type;
use sha2::{Digest, Sha256};
use walkdir::WalkDir;
use super::library::{self, ASSETS_DIR};
/// 库结构版本(与 `PRAGMA user_version` 对应)。
///
/// 索引全部可由文件重建,因此迁移策略取最简的一种:**版本不等就整库 DROP 重建**
/// (与 `translate/history.rs` 同一取舍,而未采用 `terminal/history.rs` 的增量迁移——
/// 那里一条记录是用户敲过的命令,丢了就没了;这里一条记录是 `.md` 文件的投影,
/// 文件还在就什么都没丢)。
const SCHEMA_VERSION: i64 = 1;
/// 走 FTS 索引所需的最小字符数(trigram 的 3 字符下限,见模块头)。
const FTS_MIN_CHARS: usize = 3;
/// 正文入库上限(字节)。
///
/// 索引里的正文只服务于「生成高亮片段」,不用于回显全文。超大文件(用户把日志
/// 改名成 `.md` 之类)截断存储,避免数据库被单篇笔记撑爆;`notes` 表仍记录真实
/// 的 size/hash,改动检测不受影响。
const MAX_BODY_BYTES: usize = 512 * 1024;
/// 单次搜索返回条数上限(前端分页步长 30,500 已远超一屏)。
const MAX_SEARCH_LIMIT: i64 = 200;
/// 高亮片段的分隔标记。
///
/// **刻意不用 `<b>`**:片段要在前端渲染,而笔记正文是用户内容,回传 HTML 就等于
/// 把 XSS 风险引进渲染路径(P2 的导出链路才需要真正的 HTML 渲染 + 消毒)。
/// 用两个 ASCII 控制字符当定界符,前端在文本层切分即可,注入无从发生。
const HL_OPEN: char = '\u{2}';
const HL_CLOSE: char = '\u{3}';
// ===== 对外数据结构 =====
/// 单篇笔记的索引记录(返回给前端的搜索结果项)。
#[derive(Debug, Clone, Serialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct NoteSearchHit {
/// 稳定 ID(front-matter 的 `id`;缺失时为空串)
pub id: String,
/// 相对库根的路径(`/` 分隔)
pub rel_path: String,
/// 显示标题(front-matter 的 `title`,缺失时取首个一级标题,再缺则取文件名)
pub title: String,
/// 命中片段(含 [`HL_OPEN`] / [`HL_CLOSE`] 定界符;无关键词搜索时为空)
pub snippet: String,
/// 标签
pub tags: Vec<String>,
/// 最后修改时间(Unix 毫秒)
pub modified: u64,
}
/// 一次搜索的结果(含总数,供「共 N 条」显示)。
///
/// 名字带 `Note` 前缀不是啰嗦:`tauri-specta` 的类型注册表按**类型名全局唯一**,
/// 重名会让 `export_bindings()` 直接 panic(`terminal/history.rs` 的
/// `TerminalHistoryPage` 就是为这个改的名)。
#[derive(Debug, Clone, Serialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct NoteSearchPage {
pub items: Vec<NoteSearchHit>,
/// 满足条件的总条数(**不受 limit/offset 影响**)
pub total: i64,
}
/// 标签及其笔记数。
#[derive(Debug, Clone, Serialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct NoteTagCount {
pub tag: String,
pub count: i64,
}
/// 一条链接(出链或入链)。
///
/// 出链与入链共用同一个结构,因为面板里展示的信息完全一样(标题 + 路径 + 原始目标)。
/// `resolved` 区分「已解析到库内某篇笔记」与「未解析」(`[[不存在的笔记]]`)——
/// 后者不是错误,而是反链面板里最有价值的提示:用户点一下就能建那篇笔记。
#[derive(Debug, Clone, Serialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct NoteLink {
/// 原始写法(`[[会议纪要]]` 里的 `会议纪要`,或 `[x](notes/a.md)` 里的 `notes/a.md`)
pub target: String,
/// 解析出的库内相对路径(未解析时为空串)
pub rel_path: String,
/// 目标笔记的标题(未解析时为原始 target)
pub title: String,
/// 是否已解析到库内笔记
pub resolved: bool,
/// `wiki` | `md` | `url`
pub kind: String,
}
/// 一篇笔记的链接关系(出链 + 入链)。
#[derive(Debug, Clone, Serialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct NoteBacklinks {
/// 本篇指向别处的链接
pub outgoing: Vec<NoteLink>,
/// 别处指向本篇的链接
pub incoming: Vec<NoteLink>,
/// 入链去重后的来源笔记数(面板标题显示「被 N 篇引用」)
pub incoming_sources: u32,
}
/// 索引状态(设置页展示 / 诊断用)。
#[derive(Debug, Clone, Serialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct NoteIndexStats {
/// 索引中的笔记数
pub note_count: i64,
/// 库中实际存在的 `.md` 文件数
pub file_count: i64,
/// 标签数
pub tag_count: i64,
/// 库结构版本
pub schema_version: i64,
/// 索引文件路径
pub db_path: String,
}
/// 搜索筛选条件。
///
/// 用结构体而不是一长串位置参数:命令层把前端 payload 原样转发,而多个同类型
/// 位置参数在调用点顺序写错时编译器不会报错(`terminal/history.rs` 同一理由)。
#[derive(Debug, Clone, Default, Deserialize, Type)]
#[serde(rename_all = "camelCase", default)]
pub struct NoteSearchQuery {
/// 关键词(空格分隔的多个词按 AND 处理;空串 = 只按标签/目录筛选)
pub keyword: String,
/// 只看带该标签的笔记(空 = 不筛选)
pub tag: String,
/// 只看该目录(含子目录)下的笔记(空 = 全库)
pub dir: String,
/// 分页偏移
pub offset: i64,
/// 分页大小
pub limit: i64,
}
impl NoteSearchQuery {
fn normalized(mut self) -> Self {
if self.limit <= 0 {
self.limit = 50;
}
if self.limit > MAX_SEARCH_LIMIT {
self.limit = MAX_SEARCH_LIMIT;
}
if self.offset < 0 {
self.offset = 0;
}
self
}
}
// ===== front-matter 解析 =====
/// 一篇笔记解析出的元数据(不落盘,只用于写索引)。
struct NoteMeta {
id: String,
title: String,
tags: Vec<String>,
created: String,
updated: String,
body: String,
links: Vec<String>,
}
/// 拆出 front-matter 与正文。
///
/// 只认「文件第一行就是 `---`」的形式(标准 front-matter)。未闭合的 `---` 一律
/// 当作正文:把一篇以 `---` 开头的普通笔记误判成「全是元数据」会让整篇内容从索引里
/// 消失,而反过来只是标题退化成文件名 —— 两种误判代价不对称,这里选代价小的。
fn split_front_matter(content: &str) -> (Option<&str>, &str) {
let normalized = content.strip_prefix('\u{feff}').unwrap_or(content);
let mut lines = normalized.split_inclusive('\n');
let Some(first) = lines.next() else {
return (None, normalized);
};
if first.trim_end() != "---" {
return (None, normalized);
}
let mut offset = first.len();
for line in lines {
let trimmed = line.trim_end();
if trimmed == "---" || trimmed == "..." {
let fm = &normalized[first.len()..offset];
let body = &normalized[offset + line.len()..];
return (Some(fm), body);
}
offset += line.len();
}
(None, normalized)
}
/// 从 YAML 值里取字符串(容忍被引号包住、或写成数字/布尔的情况)。
fn yaml_str(value: &serde_yaml::Value) -> String {
match value {
serde_yaml::Value::String(s) => s.trim().to_string(),
serde_yaml::Value::Number(n) => n.to_string(),
serde_yaml::Value::Bool(b) => b.to_string(),
_ => String::new(),
}
}
/// 解析 `tags` 字段:YAML 里它可能是列表、逗号分隔串、或单个标签。
fn parse_tags(value: Option<&serde_yaml::Value>) -> Vec<String> {
let mut out: Vec<String> = Vec::new();
let mut push = |raw: &str| {
for part in raw.split([',', ',']) {
let tag = part.trim().trim_matches(['[', ']', '"', '\''].as_ref()).trim();
if !tag.is_empty() && !out.iter().any(|t| t == tag) {
out.push(tag.to_string());
}
}
};
match value {
Some(serde_yaml::Value::Sequence(items)) => {
for item in items {
push(&yaml_str(item));
}
}
Some(serde_yaml::Value::String(s)) => push(s),
Some(other) => push(&yaml_str(other)),
None => {}
}
out
}
/// 首个**一级**标题的文本(front-matter 没写 title 时的兜底)。
///
/// 只认 `# `:把第一个碰到的任意级别标题当书名号会让「## 小节」抢走标题位
/// (一篇笔记往往先写小节、再补一级标题)。
fn first_h1(body: &str) -> Option<String> {
body.lines().find_map(|line| {
let trimmed = line.trim_end().trim_start();
// 用 `strip_prefix` 而不是「算 `#` 个数再切片」:后者是字节索引,缩进或多字节
// 字符时容易切到非字符边界上。`?` 在闭包里是「这一行不是 H1」而不是「整篇结束」
// —— `find_map` 的闭包返回 `Option`,`?` 只会让当次迭代返回 `None`。
let title = trimmed.strip_prefix("# ")?.trim();
if title.is_empty() {
None
} else {
Some(title.to_string())
}
})
}
/// 收集正文里的链接目标:`[[wikilink]]` 与 `[text](target)`。
fn collect_links(body: &str) -> Vec<String> {
let mut out: Vec<String> = Vec::new();
let bytes = body.as_bytes();
let mut i = 0usize;
while i < bytes.len() {
// [[wiki]] —— 忽略后面紧跟 `(` 的 `[[`(那是 `[[]](...)` 的少见写法)
if bytes[i] == b'[' && i + 1 < bytes.len() && bytes[i + 1] == b'[' {
if let Some(end) = body[i + 2..].find("]]") {
let target = body[i + 2..i + 2 + end].split('|').next().unwrap_or("").trim();
if !target.is_empty() {
out.push(target.to_string());
}
i += 2 + end + 2;
continue;
}
}
// [text](target)
if bytes[i] == b']' && i + 1 < bytes.len() && bytes[i + 1] == b'(' {
if let Some(end) = body[i + 2..].find(')') {
let target = body[i + 2..i + 2 + end].trim();
let target = target.split_whitespace().next().unwrap_or("");
if !target.is_empty() && !target.starts_with('#') {
out.push(target.to_string());
}
i += 2 + end + 1;
continue;
}
}
i += 1;
}
out
}
/// 解析一篇笔记的元数据与正文(不读磁盘,输入是文件内容)。
fn parse_note(rel_path: &str, content: &str) -> NoteMeta {
let (front, body) = split_front_matter(content);
let mut id = String::new();
let mut title = String::new();
let mut tags: Vec<String> = Vec::new();
let mut created = String::new();
let mut updated = String::new();
if let Some(front) = front {
if let Ok(serde_yaml::Value::Mapping(map)) = serde_yaml::from_str::<serde_yaml::Value>(front)
{
let get = |keys: &[&str]| -> Option<&serde_yaml::Value> {
map.iter().find_map(|(k, v)| {
let key = yaml_str(k);
if keys.iter().any(|want| key.eq_ignore_ascii_case(want)) {
Some(v)
} else {
None
}
})
};
id = get(&["id", "uuid"]).map(yaml_str).unwrap_or_default();
title = get(&["title"]).map(yaml_str).unwrap_or_default();
tags = parse_tags(get(&["tags", "tag"]));
created = get(&["created", "date", "created_at"])
.map(yaml_str)
.unwrap_or_default();
updated = get(&["updated", "modified", "updated_at"])
.map(yaml_str)
.unwrap_or_default();
}
}
if title.trim().is_empty() {
title = first_h1(body).unwrap_or_else(|| {
Path::new(rel_path)
.file_stem()
.map(|s| s.to_string_lossy().to_string())
.unwrap_or_else(|| rel_path.to_string())
});
}
NoteMeta {
id,
title,
tags,
created,
updated,
body: body.to_string(),
links: collect_links(body),
}
}
/// 文件内容 hash(用于「mtime 未变但内容确实变了」之外的改动判定,
/// 以及同步(P2)时的清单比对基准)。取前 16 字节十六进制即可。
pub fn content_hash(bytes: &[u8]) -> String {
let mut hasher = Sha256::new();
hasher.update(bytes);
let digest = hasher.finalize();
let mut out = String::with_capacity(32);
for byte in digest.iter().take(16) {
out.push_str(&format!("{byte:02x}"));
}
out
}
// ===== 索引本体 =====
/// 一次同步的统计结果。
#[derive(Debug, Clone, Default, Serialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct NoteSyncReport {
/// 本次新索引(或内容变化后重索引)的笔记数
pub indexed: i64,
/// 本次从索引中移除的笔记数(文件已删除/改名)
pub removed: i64,
/// 因 (mtime, size) 未变而跳过的笔记数
pub skipped: i64,
}
/// 笔记索引(持有 SQLite 连接 + 当前库根)。
pub struct EditorIndex {
conn: Connection,
/// 索引所属的库根(库切换时整个索引实例被替换)
root: PathBuf,
/// 索引文件绝对路径(诊断展示用)
db_path: PathBuf,
}
impl EditorIndex {
/// 打开(或创建)某个库根对应的索引。
///
/// 库根切换后由命令层用新库根调用本函数重建实例 —— 索引与库一一对应,
/// 不做「一份索引服务多个库」的多态(那需要为每张表加 root 列,得不偿失)。
pub fn open(root: &Path) -> Result<Self, String> {
// 惰性迁移旧私有目录(幂等):索引可重建,但同步基线要跟着搬过去
library::migrate_private_dir(root);
let dir = root.join(library::PRIVATE_DIR);
std::fs::create_dir_all(&dir).map_err(|e| format!("创建索引目录失败: {e}"))?;
let db_path = dir.join("editor.db");
let conn = Connection::open(&db_path).map_err(|e| format!("打开笔记索引失败: {e}"))?;
conn.busy_timeout(std::time::Duration::from_secs(3))
.map_err(|e| format!("设置索引超时失败: {e}"))?;
// WAL:读(搜索)与写(索引同步)互不阻塞,与 terminal / translate 的历史库一致
let _ = conn.pragma_update(None, "journal_mode", "WAL");
let _ = conn.pragma_update(None, "synchronous", "NORMAL");
let mut index = Self {
conn,
root: root.to_path_buf(),
db_path,
};
index.ensure_schema()?;
Ok(index)
}
/// 库根(供调用方判断是否需要换库)。
pub fn root(&self) -> &Path {
&self.root
}
/// 索引文件路径。
pub fn db_path(&self) -> &Path {
&self.db_path
}
/// 建表 + 版本检查(版本不等则整库重建,见 [`SCHEMA_VERSION`])。
fn ensure_schema(&mut self) -> Result<(), String> {
let version: i64 = self
.conn
.query_row("PRAGMA user_version", [], |row| row.get(0))
.unwrap_or(0);
if version != 0 && version != SCHEMA_VERSION {
crate::logger::log_warn(
"editor",
&format!("索引结构版本 {version} → {SCHEMA_VERSION},按文件重建索引"),
);
self.drop_all()?;
}
self.conn
.execute_batch(
"
CREATE TABLE IF NOT EXISTS notes (
rel_path TEXT PRIMARY KEY,
id TEXT NOT NULL DEFAULT '',
title TEXT NOT NULL DEFAULT '',
tags TEXT NOT NULL DEFAULT '',
created TEXT NOT NULL DEFAULT '',
updated TEXT NOT NULL DEFAULT '',
mtime INTEGER NOT NULL DEFAULT 0,
size INTEGER NOT NULL DEFAULT 0,
hash TEXT NOT NULL DEFAULT '',
body TEXT NOT NULL DEFAULT ''
);
CREATE INDEX IF NOT EXISTS idx_notes_mtime ON notes(mtime DESC);
-- 外部内容表:索引只存倒排表,正文只在 notes 里一份。
-- 代价是不会自动感知主表变化,靠下面三个触发器同步。
CREATE VIRTUAL TABLE IF NOT EXISTS notes_fts USING fts5(
title, body,
content='notes', content_rowid='rowid',
tokenize='trigram'
);
CREATE TRIGGER IF NOT EXISTS notes_fts_ai AFTER INSERT ON notes BEGIN
INSERT INTO notes_fts(rowid, title, body) VALUES (new.rowid, new.title, new.body);
END;
CREATE TRIGGER IF NOT EXISTS notes_fts_ad AFTER DELETE ON notes BEGIN
INSERT INTO notes_fts(notes_fts, rowid, title, body)
VALUES ('delete', old.rowid, old.title, old.body);
END;
CREATE TRIGGER IF NOT EXISTS notes_fts_au AFTER UPDATE ON notes BEGIN
INSERT INTO notes_fts(notes_fts, rowid, title, body)
VALUES ('delete', old.rowid, old.title, old.body);
INSERT INTO notes_fts(rowid, title, body) VALUES (new.rowid, new.title, new.body);
END;
CREATE TABLE IF NOT EXISTS tags (
name TEXT PRIMARY KEY
);
CREATE TABLE IF NOT EXISTS note_tags (
rel_path TEXT NOT NULL,
tag TEXT NOT NULL,
PRIMARY KEY (rel_path, tag)
);
CREATE INDEX IF NOT EXISTS idx_note_tags_tag ON note_tags(tag);
-- 双链 / 未解析链接。dst_path 为解析出的库内相对路径(尽力而为),
-- 解析不到时只留原始 target —— 「未解析链接」本身就是反链面板要展示的信息。
CREATE TABLE IF NOT EXISTS links (
src_path TEXT NOT NULL,
target TEXT NOT NULL,
dst_path TEXT NOT NULL DEFAULT '',
kind TEXT NOT NULL DEFAULT 'md'
);
CREATE INDEX IF NOT EXISTS idx_links_src ON links(src_path);
CREATE INDEX IF NOT EXISTS idx_links_dst ON links(dst_path);
",
)
.map_err(|e| format!("初始化笔记索引表失败: {e}"))?;
self.conn
.pragma_update(None, "user_version", SCHEMA_VERSION)
.map_err(|e| format!("写入索引版本失败: {e}"))?;
Ok(())
}
/// 清空全部索引结构(版本迁移用;文件不受影响)。
fn drop_all(&mut self) -> Result<(), String> {
self.conn
.execute_batch(
"DROP TABLE IF EXISTS notes_fts;
DROP TABLE IF EXISTS note_tags;
DROP TABLE IF EXISTS tags;
DROP TABLE IF EXISTS links;
DROP TABLE IF EXISTS notes;",
)
.map_err(|e| format!("重建索引表失败: {e}"))
}
/// 全量重建:清空索引后重新扫描整个库。
pub fn rebuild(&mut self) -> Result<NoteSyncReport, String> {
self.drop_all()?;
self.conn
.pragma_update(None, "user_version", 0)
.map_err(|e| format!("重置索引版本失败: {e}"))?;
self.ensure_schema()?;
self.sync()
}
/// 增量同步:扫描库根,只对「mtime/size 变化或索引里没有」的文件重新解析。
pub fn sync(&mut self) -> Result<NoteSyncReport, String> {
let mut report = NoteSyncReport::default();
let root = self.root.clone();
// 1) 先收集磁盘现状(顺带拿到 (mtime, size) 用于快速筛)
let mut seen: Vec<(String, u64, u64, PathBuf)> = Vec::new();
for entry in WalkDir::new(&root)
.max_depth(library::MAX_DEPTH)
.into_iter()
.filter_map(Result::ok)
{
if !entry.file_type().is_file() {
continue;
}
let path = entry.path();
// 跳过点号目录(含 `.editor/` 自身)与根级 assets/
if skip_path(&root, path) {
continue;
}
let name = entry.file_name().to_string_lossy().to_string();
if !name.to_ascii_lowercase().ends_with(".md") {
continue;
}
let Ok(meta) = entry.metadata() else { continue };
let rel = library::rel_string(&root, path);
seen.push((rel, modified_ms(&meta), meta.len(), path.to_path_buf()));
}
// 2) 文件名 → 相对路径映射(wikilink 按名解析用,见 resolve_link)
let mut stems: std::collections::HashMap<String, String> = std::collections::HashMap::new();
for (rel, ..) in &seen {
if let Some(stem) = Path::new(rel).file_stem() {
stems
.entry(stem.to_string_lossy().to_ascii_lowercase())
.or_insert_with(|| rel.clone());
}
}
// 3) 索引里有、磁盘上没有的 → 删
let existing: Vec<String> = {
let mut stmt = self
.conn
.prepare("SELECT rel_path FROM notes")
.map_err(|e| format!("读取索引清单失败: {e}"))?;
let rows = stmt
.query_map([], |row| row.get::<_, String>(0))
.map_err(|e| format!("读取索引清单失败: {e}"))?;
rows.filter_map(Result::ok).collect()
};
for rel in existing {
if !seen.iter().any(|(path, ..)| *path == rel) {
self.remove_note(&rel)?;
report.removed += 1;
}
}
// 4) 逐个文件:未变跳过,变了重解析
for (rel, mtime, size, path) in seen {
let cached: Option<(i64, i64)> = self
.conn
.query_row(
"SELECT mtime, size FROM notes WHERE rel_path = ?1",
params![rel],
|row| Ok((row.get(0)?, row.get(1)?)),
)
.optional()
.map_err(|e| format!("查询笔记索引失败: {e}"))?;
if let Some((cached_mtime, cached_size)) = cached {
if cached_mtime as u64 == mtime && cached_size as u64 == size {
report.skipped += 1;
continue;
}
}
// 读文件:非 UTF-8 按有损解码 —— 索引里出现替换字符好过整库索引失败
let bytes = match std::fs::read(&path) {
Ok(b) => b,
Err(e) => {
crate::logger::log_warn("editor", &format!("索引读取失败 {rel}: {e}"));
continue;
}
};
let content = String::from_utf8_lossy(&bytes);
self.upsert_note(&rel, &content, mtime, size, &content_hash(&bytes), &stems)?;
report.indexed += 1;
}
Ok(report)
}
/// 写入/更新一篇笔记的索引(含标签与链接)。
///
/// `stems` 供 wikilink 按文件名解析;单篇保存时调用方若不想扫全库,
/// 可以先 `list_notes` 现搭一份小映射(见 `commands.rs`),或传空表退化为
/// 「按相对路径解析」。
pub fn upsert_note(
&mut self,
rel_path: &str,
content: &str,
mtime: u64,
size: u64,
hash: &str,
stems: &std::collections::HashMap<String, String>,
) -> Result<(), String> {
let meta = parse_note(rel_path, content);
let body: String = {
let mut body = meta.body.clone();
if body.len() > MAX_BODY_BYTES {
// 按字符边界截断,避免切出半个 UTF-8 序列
let mut cut = MAX_BODY_BYTES;
while cut > 0 && !body.is_char_boundary(cut) {
cut -= 1;
}
body.truncate(cut);
}
body
};
let tx = self
.conn
.transaction()
.map_err(|e| format!("开启索引事务失败: {e}"))?;
tx.execute(
"INSERT INTO notes (rel_path, id, title, tags, created, updated, mtime, size, hash, body)
VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10)
ON CONFLICT(rel_path) DO UPDATE SET
id = excluded.id, title = excluded.title, tags = excluded.tags,
created = excluded.created, updated = excluded.updated,
mtime = excluded.mtime, size = excluded.size, hash = excluded.hash,
body = excluded.body",
params![
rel_path,
meta.id,
meta.title,
meta.tags.join(","),
meta.created,
meta.updated,
mtime as i64,
size as i64,
hash,
body
],
)
.map_err(|e| format!("写入笔记索引失败: {e}"))?;
// 标签:先删后插(改标签是最常见的编辑动作之一,diff 不值得)
tx.execute("DELETE FROM note_tags WHERE rel_path = ?1", params![rel_path])
.map_err(|e| format!("清理标签失败: {e}"))?;
for tag in &meta.tags {
tx.execute("INSERT OR IGNORE INTO tags (name) VALUES (?1)", params![tag])
.map_err(|e| format!("写入标签失败: {e}"))?;
tx.execute(
"INSERT OR REPLACE INTO note_tags (rel_path, tag) VALUES (?1, ?2)",
params![rel_path, tag],
)
.map_err(|e| format!("关联标签失败: {e}"))?;
}
// 链接:同样先删后插
tx.execute("DELETE FROM links WHERE src_path = ?1", params![rel_path])
.map_err(|e| format!("清理链接失败: {e}"))?;
for link in &meta.links {
let (dst, kind) = resolve_link(rel_path, link, stems);
tx.execute(
"INSERT INTO links (src_path, target, dst_path, kind) VALUES (?1, ?2, ?3, ?4)",
params![rel_path, link, dst, kind],
)
.map_err(|e| format!("写入链接失败: {e}"))?;
}
tx.commit().map_err(|e| format!("提交索引事务失败: {e}"))
}
/// 从索引里移除一篇笔记(文件被删除/改名)。
pub fn remove_note(&mut self, rel_path: &str) -> Result<(), String> {
let tx = self
.conn
.transaction()
.map_err(|e| format!("开启索引事务失败: {e}"))?;
tx.execute("DELETE FROM notes WHERE rel_path = ?1", params![rel_path])
.map_err(|e| format!("删除索引项失败: {e}"))?;
tx.execute("DELETE FROM note_tags WHERE rel_path = ?1", params![rel_path])
.map_err(|e| format!("清理标签失败: {e}"))?;
tx.execute("DELETE FROM links WHERE src_path = ?1", params![rel_path])
.map_err(|e| format!("清理链接失败: {e}"))?;
// 顺手清掉「已无人引用」的标签,避免标签云里堆着一堆 0 计数条目
tx.execute(
"DELETE FROM tags WHERE name NOT IN (SELECT DISTINCT tag FROM note_tags)",
[],
)
.map_err(|e| format!("清理空标签失败: {e}"))?;
tx.commit().map_err(|e| format!("提交索引事务失败: {e}"))
}
/// 全文检索 / 筛选。
pub fn search(&self, query: NoteSearchQuery) -> Result<NoteSearchPage, String> {
let query = query.normalized();
let keyword = query.keyword.trim();
let tag = query.tag.trim();
let dir = query.dir.trim().trim_matches('/');
// 关键词走 FTS 时额外套一层子查询,便于把「筛选条件」与「命中排序」解耦
let use_fts = keyword.chars().count() >= FTS_MIN_CHARS;
let mut joins = String::new();
let mut wheres: Vec<String> = Vec::new();
let mut args: Vec<Box<dyn rusqlite::ToSql>> = Vec::new();
if use_fts {
joins.push_str(" JOIN notes_fts f ON f.rowid = notes.rowid");
wheres.push("notes_fts MATCH ?".to_string());
args.push(Box::new(fts_query(keyword)));
}
if !keyword.is_empty() && !use_fts {
// 短词回退:trigram 对 <3 字符的查询静默返回空,这里退化成子串匹配
wheres.push("(notes.title LIKE ? OR notes.body LIKE ?)".to_string());
let like = format!("%{keyword}%");
args.push(Box::new(like.clone()));
args.push(Box::new(like));
}
if !tag.is_empty() {
wheres.push("EXISTS (SELECT 1 FROM note_tags nt WHERE nt.rel_path = notes.rel_path AND nt.tag = ?)".to_string());
args.push(Box::new(tag.to_string()));
}
if !dir.is_empty() {
// 目录筛选含子目录:'dir/%' 前缀匹配;根目录(空串)已在上面归一化掉
wheres.push("notes.rel_path LIKE ?".to_string());
args.push(Box::new(format!("{dir}/%")));
}
let where_sql = if wheres.is_empty() {
String::new()
} else {
format!(" WHERE {}", wheres.join(" AND "))
};
let total: i64 = {
let sql = format!("SELECT COUNT(*) FROM notes{joins}{where_sql}");
let refs: Vec<&dyn rusqlite::ToSql> = args.iter().map(|b| b.as_ref()).collect();
self.conn
.query_row(&sql, refs.as_slice(), |row| row.get(0))
.map_err(|e| format!("统计检索结果失败: {e}"))?
};
// 片段:走 FTS 时用 snippet()(列索引 `-1` = **让 FTS 自己挑最佳列**)。
//
// 不写死列号的原因:关键词常常命中**标题**(中文笔记尤其如此 —— 「周会」就在
// 标题「周会纪要」里),写死正文列会得到一个与命中位置无关的片段。
// 短词回退 LIKE 时另有 Rust 侧生成的片段(见 `make_snippet`),这里留空。
let snippet_expr = if use_fts {
format!(
"snippet(notes_fts, -1, '{}', '{}', '…', 18)",
HL_OPEN, HL_CLOSE
)
} else {
"''".to_string()
};
let order = if use_fts {
"bm25(notes_fts, 8.0, 1.0)".to_string()
} else {
"notes.mtime DESC".to_string()
};
// 短词回退时一并取回正文,用于生成片段(正文列已在写索引时截断过长度)
let body_expr = if use_fts { "''" } else { "notes.body" };
let sql = format!(
"SELECT notes.rel_path, notes.id, notes.title, notes.tags, notes.mtime, {snippet_expr}, {body_expr}
FROM notes{joins}{where_sql} ORDER BY {order} LIMIT ? OFFSET ?"
);
let mut stmt = self
.conn
.prepare(&sql)
.map_err(|e| format!("准备检索语句失败: {e}"))?;
let mut all: Vec<Box<dyn rusqlite::ToSql>> = args;
all.push(Box::new(query.limit));
all.push(Box::new(query.offset));
let refs: Vec<&dyn rusqlite::ToSql> = all.iter().map(|b| b.as_ref()).collect();
let rows = stmt
.query_map(refs.as_slice(), |row| {
let tags: String = row.get(3)?;
Ok((
NoteSearchHit {
rel_path: row.get(0)?,
id: row.get(1)?,
title: row.get(2)?,
tags: tags
.split(',')
.filter(|s| !s.is_empty())
.map(|s| s.to_string())
.collect(),
modified: row.get::<_, i64>(4)? as u64,
snippet: row.get(5)?,
},
row.get::<_, String>(6)?,
))
})
.map_err(|e| format!("检索失败: {e}"))?;
let mut items: Vec<NoteSearchHit> = Vec::new();
for row in rows.filter_map(Result::ok) {
let (mut hit, body) = row;
if hit.snippet.is_empty() && !keyword.is_empty() {
// 短词回退(LIKE)路径:FTS 不给片段,这里自己截
hit.snippet = make_snippet(&hit.title, &body, keyword);
}
items.push(hit);
}
Ok(NoteSearchPage { items, total })
}
/// 查询一篇笔记的链接关系(出链 + 入链)。
///
/// # 入链为什么按 `dst_path` 匹配
///
/// 写索引时已经把链接目标**尽力解析**成库内相对路径(含 Obsidian 式「全库按名解析」)。
/// 因此「谁引用了我」只需要 `links.dst_path = 本篇路径`。未解析的链接
/// (`dst_path = ''`)自然不会被算作任何一篇的入链 —— 这正是期望行为:
/// 指向不存在笔记的链接不该在别处显示成反链。
///
/// # 出链为什么用 LEFT JOIN
///
/// 出链里既有已解析的(`dst_path` 命中 `notes`)也有未解析的(空串或指向不存在的
/// 目标)。用 LEFT JOIN 一次取回,未解析的那些 `rel_path` 为空、`title` 回退成原始
/// target —— 前端据此把它们渲染成「点一下就能新建」的入口。
pub fn backlinks(&self, rel_path: &str) -> Result<NoteBacklinks, String> {
let outgoing = {
let mut stmt = self
.conn
.prepare(
"SELECT links.target, links.kind,
COALESCE(notes.rel_path, ''), COALESCE(notes.title, '')
FROM links LEFT JOIN notes ON notes.rel_path = links.dst_path
WHERE links.src_path = ?1
ORDER BY links.target",
)
.map_err(|e| format!("准备出链语句失败: {e}"))?;
let rows = stmt
.query_map(params![rel_path], |row| {
let target: String = row.get(0)?;
let kind: String = row.get(1)?;
let dst: String = row.get(2)?;
let title: String = row.get(3)?;
Ok(NoteLink {
title: if title.is_empty() {
target.clone()
} else {
title
},
resolved: !dst.is_empty(),
rel_path: dst,
target,
kind,
})
})
.map_err(|e| format!("查询出链失败: {e}"))?;
rows.filter_map(Result::ok).collect::<Vec<_>>()
};
let incoming = {
let mut stmt = self
.conn
.prepare(
"SELECT links.target, links.kind, links.src_path, COALESCE(notes.title, '')
FROM links LEFT JOIN notes ON notes.rel_path = links.src_path
WHERE links.dst_path = ?1
ORDER BY links.src_path",
)
.map_err(|e| format!("准备入链语句失败: {e}"))?;
let rows = stmt
.query_map(params![rel_path], |row| {
let target: String = row.get(0)?;
let kind: String = row.get(1)?;
let src: String = row.get(2)?;
let title: String = row.get(3)?;
Ok(NoteLink {
title: if title.is_empty() {
src.clone()
} else {
title
},
// 入链的「目标」就是来源笔记本身
resolved: true,
rel_path: src,
target,
kind,
})
})
.map_err(|e| format!("查询入链失败: {e}"))?;
rows.filter_map(Result::ok).collect::<Vec<_>>()
};
let incoming_sources = {
let mut set: Vec<&str> = incoming.iter().map(|l| l.rel_path.as_str()).collect();
set.sort_unstable();
set.dedup();
set.len() as u32
};
Ok(NoteBacklinks {
outgoing,
incoming,
incoming_sources,
})
}
/// 全库链接图(`{ 源路径: [目标路径] }`,只含已解析的内部链接)。
///
/// 供「双链图谱」用。只返回已解析的边:指向不存在笔记的链接在图上没有节点可连。
pub fn link_graph(&self) -> Result<Vec<(String, String)>, String> {
let mut stmt = self
.conn
.prepare(
"SELECT src_path, dst_path FROM links
WHERE dst_path <> '' AND kind <> 'url'
ORDER BY src_path, dst_path",
)
.map_err(|e| format!("准备图谱语句失败: {e}"))?;
let rows = stmt
.query_map([], |row| Ok((row.get::<_, String>(0)?, row.get::<_, String>(1)?)))
.map_err(|e| format!("查询图谱失败: {e}"))?;
Ok(rows.filter_map(Result::ok).collect())
}
/// 快速打开用的轻量清单(只取路径/标题/时间,不带正文与片段)。
pub fn list_notes(&self, limit: i64) -> Result<Vec<NoteSearchHit>, String> {
let limit = limit.clamp(1, 2000);
let mut stmt = self
.conn
.prepare(
"SELECT rel_path, id, title, tags, mtime FROM notes ORDER BY mtime DESC LIMIT ?1",
)
.map_err(|e| format!("准备清单语句失败: {e}"))?;
let rows = stmt
.query_map(params![limit], |row| {
let tags: String = row.get(3)?;
Ok(NoteSearchHit {
rel_path: row.get(0)?,
id: row.get(1)?,
title: row.get(2)?,
tags: tags
.split(',')
.filter(|s| !s.is_empty())
.map(|s| s.to_string())
.collect(),
modified: row.get::<_, i64>(4)? as u64,
snippet: String::new(),
})
})
.map_err(|e| format!("读取笔记清单失败: {e}"))?;
Ok(rows.filter_map(Result::ok).collect())
}
/// 标签及计数(按计数降序、同计数按名称)。
pub fn tags(&self) -> Result<Vec<NoteTagCount>, String> { let mut stmt = self
.conn
.prepare(
"SELECT tag, COUNT(*) AS n FROM note_tags GROUP BY tag ORDER BY n DESC, tag ASC",
)
.map_err(|e| format!("准备标签语句失败: {e}"))?;
let rows = stmt
.query_map([], |row| {
Ok(NoteTagCount {
tag: row.get(0)?,
count: row.get(1)?,
})
})
.map_err(|e| format!("读取标签失败: {e}"))?;
Ok(rows.filter_map(Result::ok).collect())
}
/// 索引状态。
pub fn stats(&self) -> Result<NoteIndexStats, String> {
let note_count: i64 = self
.conn
.query_row("SELECT COUNT(*) FROM notes", [], |row| row.get(0))
.unwrap_or(0);
let tag_count: i64 = self
.conn
.query_row("SELECT COUNT(*) FROM tags", [], |row| row.get(0))
.unwrap_or(0);
let file_count = WalkDir::new(&self.root)
.max_depth(library::MAX_DEPTH)
.into_iter()
.filter_map(Result::ok)
.filter(|e| {
e.file_type().is_file()
&& !skip_path(&self.root, e.path())
&& e.file_name()
.to_string_lossy()
.to_ascii_lowercase()
.ends_with(".md")
})
.count() as i64;
Ok(NoteIndexStats {
note_count,
file_count,
tag_count,
schema_version: SCHEMA_VERSION,
db_path: self.db_path.to_string_lossy().to_string(),
})
}
}
// ===== 辅助 =====
fn modified_ms(meta: &std::fs::Metadata) -> u64 {
meta.modified()
.ok()
.and_then(|t| t.duration_since(UNIX_EPOCH).ok())
.map(|d| d.as_millis() as u64)
.unwrap_or(0)
}
/// 该绝对路径是否应当排除在索引之外(点号目录 / 根级 assets)。
fn skip_path(root: &Path, path: &Path) -> bool {
let rel = library::rel_string(root, path);
if rel.is_empty() {
return false;
}
let parts: Vec<&str> = rel.split('/').collect();
// 任何一层是点号开头 → 排除(`.editor/` 索引自身、`.git/` 等)
if parts.iter().any(|p| p.starts_with('.')) {
return true;
}
// 根级 assets/ 是图片仓库,不是笔记(与 library::scan 的口径一致)
parts.first() == Some(&ASSETS_DIR)
}
/// 为「短词回退 LIKE」路径生成命中片段。
///
/// FTS 的 `snippet()` 只服务于 FTS 查询;短于 3 字符的关键词走 LIKE(trigram 的
/// 下限),那条路径没有片段可拿。若就此返回空片段,用户在结果列表里只看到一个标题、
/// 不知道为什么会命中 —— 于是这里自己截一段上下文。
///
/// # 顺序
///
/// 优先在**正文**里找关键词(正文命中才是「检索」的价值所在),找不到再看标题。
/// 命中处两侧各留 [`SNIPPET_CONTEXT`] 个**字符**(`chars` 而不是字节:中文笔记里按
/// 字节截会切出乱码),并加上高亮定界符。
fn make_snippet(title: &str, body: &str, keyword: &str) -> String {
const SNIPPET_CONTEXT: usize = 24;
if keyword.is_empty() {
return String::new();
}
let Some((source, at)) = find_ci(body, keyword)
.map(|at| (body, at))
.or_else(|| find_ci(title, keyword).map(|at| (title, at)))
else {
return String::new();
};
// 归一化换行:片段是单行展示的,正文里的 `\n` 会让它断成两截
let flat = source.replace(['\n', '\r'], " ");
let chars: Vec<char> = flat.chars().collect();
let keyword_chars = keyword.chars().count();
let at_chars = source[..at].chars().count().min(chars.len());
let start = at_chars.saturating_sub(SNIPPET_CONTEXT);
let end = (at_chars + keyword_chars + SNIPPET_CONTEXT).min(chars.len());
let mut out = String::new();
if start > 0 {
out.push('…');
}
out.extend(&chars[start..at_chars]);
out.push(HL_OPEN);
out.extend(&chars[at_chars..(at_chars + keyword_chars).min(chars.len())]);
out.push(HL_CLOSE);
out.extend(&chars[(at_chars + keyword_chars).min(chars.len())..end]);
if end < chars.len() {
out.push('…');
}
out
}
/// 大小写无关的字节查找(返回字节下标;找不到返回 None)。
fn find_ci(haystack: &str, needle: &str) -> Option<usize> {
haystack
.to_lowercase()
.find(&needle.to_lowercase())
}
/// 把 FTS5 查询串安全地转成「多个短语的 AND」。
/// FTS5 的 `MATCH` 有自己一套查询语法(`-` `*` `(` `^` `"` `:` `+` 都是操作符)。
/// 用户输入是笔记标题里的普通词,直接塞进去轻则语义错、重则整个查询报语法错误。
/// 做法与 `terminal/history.rs` 一致:每个词包成双引号短语、内部引号翻倍,
/// 词与词之间用空格(FTS5 的空格即 AND)。
fn fts_query(keyword: &str) -> String {
keyword
.split_whitespace()
.map(|word| format!("\"{}\"", word.replace('"', "\"\"")))
.collect::<Vec<_>>()
.join(" ")
}
/// 把链接目标尽力解析成「库内相对路径」。
///
/// 解析不了就返回空串 —— 这不是失败,而是「未解析链接」,反链面板要靠它提示用户
/// 目标不存在(`[[不存在的笔记]]` 在 Obsidian 里正是「新建入口」)。
///
/// `stems` 是「文件名(不含扩展名)→ 库内相对路径」的全库映射,专治 `[[笔记名]]`
/// 这种**不带目录**的写法:Obsidian 的 wikilink 语义是「全库按名查」,只按相对路径
/// 猜会把 `[[周会]]` 解析到错的目录去(或干脆解析不到)。
fn resolve_link(
src_rel: &str,
target: &str,
stems: &std::collections::HashMap<String, String>,
) -> (String, String) {
let is_wiki = target.ends_with(".md") || !target.contains('.');
if target.contains("://") {
return (String::new(), "url".to_string());
}
let clean = target.split('#').next().unwrap_or("").trim();
let kind = if is_wiki { "wiki" } else { "md" };
if clean.is_empty() {
return (String::new(), kind.to_string());
}
// wikilink 优先按「全库文件名」解析(Obsidian 语义),命中即用
if is_wiki && !clean.contains('/') {
if let Some(hit) = stems.get(&clean.to_ascii_lowercase()) {
return (hit.clone(), kind.to_string());
}
}
// 相对当前笔记所在目录解析
let base = Path::new(src_rel).parent().unwrap_or(Path::new(""));
let joined = if clean.starts_with('/') {
clean.trim_start_matches('/').to_string()
} else {
let mut parts: Vec<String> = Vec::new();
for part in base.to_string_lossy().replace('\\', "/").split('/') {
if !part.is_empty() {
parts.push(part.to_string());
}
}
for part in clean.replace('\\', "/").split('/') {
match part {
"" | "." => {}
".." => {
parts.pop();
}
other => parts.push(other.to_string()),
}
}
parts.join("/")
};
let with_ext = if joined.to_ascii_lowercase().ends_with(".md") {
joined
} else {
format!("{joined}.md")
};
(with_ext, kind.to_string())
}
// ===== 测试 =====
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn front_matter_split_and_parse() {
let content = "---\nid: abc\ntitle: 会议纪要\ntags: [工作, 周会]\n---\n\n# 会议纪要\n\n正文\n";
let meta = parse_note("2026/09/meeting.md", content);
assert_eq!(meta.id, "abc");
assert_eq!(meta.title, "会议纪要");
assert_eq!(meta.tags, vec!["工作", "周会"]);
assert!(meta.body.contains("正文"));
assert!(!meta.body.contains("id: abc"));
}
#[test]
fn unterminated_front_matter_is_body() {
// 未闭合的 `---` 必须当正文:宁可标题退化,也不能让整篇内容从索引里消失
let content = "---\n这不是元数据\n\n# 标题\n";
let meta = parse_note("a.md", content);
assert!(meta.body.contains("这不是元数据"));
assert_eq!(meta.title, "标题");
}
#[test]
fn title_falls_back_to_h1_then_filename() {
let meta = parse_note("dir/无元数据.md", "## 二级\n\n# 一级标题\n");
assert_eq!(meta.title, "一级标题");
let meta = parse_note("dir/只有文件名.md", "普通正文\n");
assert_eq!(meta.title, "只有文件名");
}
#[test]
fn tags_accept_three_shapes() {
let list = parse_note("a.md", "---\ntags: [a, b]\n---\nx");
assert_eq!(list.tags, vec!["a", "b"]);
let csv = parse_note("a.md", "---\ntags: a, b\n---\nx");
assert_eq!(csv.tags, vec!["a", "b"]);
let one = parse_note("a.md", "---\ntag: 单个\n---\nx");
assert_eq!(one.tags, vec!["单个"]);
}
#[test]
fn links_parsed_from_both_syntaxes() {
let meta = parse_note("notes/a.md", "见 [[另一篇]] 与 [名](notes/b.md#小节)\n");
assert!(meta.links.contains(&"另一篇".to_string()));
assert!(meta.links.contains(&"notes/b.md#小节".to_string()));
}
#[test]
fn resolve_link_uses_source_dir() {
let stems = std::collections::HashMap::new();
let (dst, kind) = resolve_link("notes/2026/a.md", "b", &stems);
assert_eq!(dst, "notes/2026/b.md");
assert_eq!(kind, "wiki");
let (dst, _) = resolve_link("notes/a.md", "../assets/x.png", &stems);
assert_eq!(dst, "assets/x.png.md");
let (dst, kind) = resolve_link("a.md", "https://example.com/x", &stems);
assert!(dst.is_empty());
assert_eq!(kind, "url");
}
#[test]
fn resolve_link_prefers_library_wide_stem() {
// Obsidian 的 wikilink 语义是全库按名查:`[[周会]]` 应当落到真实所在目录,
// 而不是被硬按「相对当前目录」猜错位置
let mut stems = std::collections::HashMap::new();
stems.insert("周会".to_string(), "archive/2025/周会.md".to_string());
let (dst, kind) = resolve_link("notes/today.md", "周会", &stems);
assert_eq!(dst, "archive/2025/周会.md");
assert_eq!(kind, "wiki");
}
#[test]
fn fts_query_neutralizes_operators() {
// 每个词都被包成短语,`-` `*` 这类操作符不会再被解释
assert_eq!(fts_query("a-b"), "\"a-b\"");
assert_eq!(fts_query("会议 纪要"), "\"会议\" \"纪要\"");
assert_eq!(fts_query("he said \"hi\""), "\"he\" \"said\" \"\"\"hi\"\"\"");
}
/// 端到端:真的建一个临时库,落盘 `.md`,同步索引,然后检索。
///
/// 覆盖的是「单测覆盖不到的那一层」:建表语句、触发器、FTS5 MATCH 语法、
/// trigram 中文子串匹配、标签 JOIN —— 这些只有真跑一次 SQLite 才能确认。
#[test]
fn index_roundtrip_search_tags_and_rebuild() {
let root = std::env::temp_dir().join(format!(
"thing-editor-index-test-{}",
std::process::id()
));
let _ = std::fs::remove_dir_all(&root);
std::fs::create_dir_all(root.join("notes")).unwrap();
std::fs::create_dir_all(root.join("assets")).unwrap();
std::fs::write(
root.join("notes/会议纪要.md"),
"---\ntitle: 周会纪要\ntags: [工作, 周会]\n---\n\n本周讨论了三件事,其中一件是检索。\n",
)
.unwrap();
std::fs::write(
root.join("notes/随手记.md"),
"# 随手记\n\n买牛奶。参见 [[会议纪要]] 与 [外链](https://example.com)。\n",
)
.unwrap();
// 非 .md 与点号目录都不该被索引
std::fs::write(root.join("notes/notes.txt"), "不该被索引").unwrap();
// 先打开索引(顺带创建 `.editor/` 目录),再往里塞一个「不该被索引」的 .md
let mut index = EditorIndex::open(&root).unwrap();
std::fs::write(root.join(".editor/ignored.md"), "也不该被索引").unwrap();
let report = index.sync().unwrap();
assert_eq!(report.indexed, 2, "只应索引两篇 .md");
assert_eq!(report.removed, 0);
// 第二次同步:没有任何变化 → 全部跳过
let again = index.sync().unwrap();
assert_eq!(again.indexed, 0);
assert_eq!(again.skipped, 2);
// 中文子串检索(trigram 的价值所在:「周会」要能命中「周会纪要」)
let page = index
.search(NoteSearchQuery {
keyword: "周会".to_string(),
..Default::default()
})
.unwrap();
assert_eq!(page.total, 1, "{:?}", page.items);
assert_eq!(page.items[0].title, "周会纪要");
// 2 字符关键词在 trigram 下**不命中 FTS**(3 字符下限),走 LIKE 回退;
// 片段由 Rust 侧 make_snippet 生成,同样带高亮定界符
assert!(
page.items[0].snippet.contains(HL_OPEN),
"短词命中也应有高亮片段: {:?}",
page.items[0].snippet
);
// 3 字符关键词走 FTS,片段由 snippet() 生成
let fts_page = index
.search(NoteSearchQuery {
keyword: "周会纪".to_string(),
..Default::default()
})
.unwrap();
assert_eq!(fts_page.total, 1);
assert!(
fts_page.items[0].snippet.contains(HL_OPEN),
"FTS 命中的片段应带高亮: {:?}",
fts_page.items[0].snippet
);
// 正文命中(关键词只出现在 body)
let body_hit = index
.search(NoteSearchQuery {
keyword: "检索".to_string(),
..Default::default()
})
.unwrap();
assert_eq!(body_hit.total, 1);
// 短词回退 LIKE(trigram 对 <3 字符静默返回空,必须走 LIKE)
let short = index
.search(NoteSearchQuery {
keyword: "牛奶".to_string(),
..Default::default()
})
.unwrap();
assert_eq!(short.total, 1, "两字关键词应能命中");
assert!(
short.items[0].snippet.contains(HL_OPEN) && short.items[0].snippet.contains("牛奶"),
"短词片段应包含关键词并带高亮: {:?}",
short.items[0].snippet
);
// 标签筛选
let tagged = index
.search(NoteSearchQuery {
tag: "工作".to_string(),
..Default::default()
})
.unwrap();
assert_eq!(tagged.total, 1);
let tag_names: Vec<String> = index.tags().unwrap().into_iter().map(|t| t.tag).collect();
assert!(tag_names.contains(&"工作".to_string()), "{tag_names:?}");
assert!(tag_names.contains(&"周会".to_string()), "{tag_names:?}");
// wikilink 解析:[[会议纪要]] 应解析到真实路径
let dst: String = index
.conn
.query_row(
"SELECT dst_path FROM links WHERE src_path LIKE '%随手记%' AND kind = 'wiki'",
[],
|row| row.get(0),
)
.unwrap();
assert_eq!(dst, "notes/会议纪要.md");
// 删除文件后同步 → 索引里也应消失(含标签清理)
std::fs::remove_file(root.join("notes/随手记.md")).unwrap();
let after_delete = index.sync().unwrap();
assert_eq!(after_delete.removed, 1);
assert_eq!(index.stats().unwrap().note_count, 1);
// 全量重建:索引数应与文件数一致
let rebuilt = index.rebuild().unwrap();
assert_eq!(rebuilt.indexed, 1);
let stats = index.stats().unwrap();
assert_eq!(stats.note_count, 1);
assert_eq!(stats.file_count, 1);
let _ = std::fs::remove_dir_all(&root);
}
/// 诊断用的探针已删除:它验证的结论是「trigram 下 2 字符关键词不命中 FTS」,
/// 该结论现已固化到 [`make_snippet`] 的存在理由里(短词回退 LIKE + 自建片段)。
/// front-matter 里的 `id` / `created` 也要进索引(P2 同步靠它做稳定标识)。
#[test]
fn front_matter_id_and_dates_are_indexed() {
let root = std::env::temp_dir().join(format!(
"thing-editor-index-fm-{}",
std::process::id()
));
let _ = std::fs::remove_dir_all(&root);
std::fs::create_dir_all(root.join("notes")).unwrap();
std::fs::write(
root.join("notes/a.md"),
"---\nid: 01J9Z8\ntitle: 标题\ncreated: 2026-09-30T10:00:00+08:00\nupdated: 2026-09-30T11:20:00+08:00\ntags: 单独\n---\n\n正文\n",
)
.unwrap();
let mut index = EditorIndex::open(&root).unwrap();
index.sync().unwrap();
let page = index
.search(NoteSearchQuery {
keyword: "标题".to_string(),
..Default::default()
})
.unwrap();
assert_eq!(page.items.len(), 1);
assert_eq!(page.items[0].id, "01J9Z8");
assert_eq!(page.items[0].tags, vec!["单独"]);
let _ = std::fs::remove_dir_all(&root);
}
}