5374 lines
179 KiB
Rust
5374 lines
179 KiB
Rust
use crate::error::WebError;
|
||
use crate::routes::local_folder_source::encode_local_id_segment;
|
||
use crate::routes::local_markdown_parser::{
|
||
parse_markdown_attachment_link, parse_markdown_page, split_frontmatter,
|
||
};
|
||
use crate::routes::local_ocr;
|
||
use control_plane::{ControlPlaneStore, UpsertUserInput, UpsertUserUiPreferenceInput};
|
||
use core_protocol::{
|
||
EvidenceLocator, EvidenceSearchMatchInfo, EvidenceSearchResult, ParsedResourceArtifact,
|
||
ResourceSourceMap, SourceMapBlock, PARSED_RESOURCE_ARTIFACT_SCHEMA,
|
||
};
|
||
use rusqlite::{params, Connection, OptionalExtension};
|
||
use serde::{Deserialize, Serialize};
|
||
use serde_json::{json, Value};
|
||
use std::collections::BTreeSet;
|
||
use std::fs;
|
||
use std::path::{Component, Path, PathBuf};
|
||
use std::time::{SystemTime, UNIX_EPOCH};
|
||
use time::{Date, Duration, Month, OffsetDateTime, Time};
|
||
|
||
const LOCAL_SEARCH_INDEX_VERSION: u32 = 1;
|
||
const LOCAL_INDEX_SETTINGS_SCHEMA: &str = "mnote.local_index.settings.v1";
|
||
const LOCAL_INDEX_SETTINGS_KEY: &str = "localIndex.settings";
|
||
const LOCAL_INDEX_SETTINGS_SCOPE_KIND: &str = "localIndex";
|
||
const LOCAL_INDEX_SOURCE_KIND: &str = "local_folder";
|
||
const DEFAULT_INDEX_SCHEDULE_MODE: &str = "daily";
|
||
const DEFAULT_INDEX_SCHEDULE_TIME: &str = "02:00";
|
||
const EVIDENCE_SQLITE_SCHEMA_VERSION: u32 = 1;
|
||
|
||
fn local_index_scope_id(root_path: &Path) -> String {
|
||
root_path.to_string_lossy().replace('\\', "/")
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||
#[serde(rename_all = "camelCase")]
|
||
struct LocalSearchIndex {
|
||
version: u32,
|
||
built_at: u128,
|
||
root_uri: String,
|
||
workspace_id: String,
|
||
#[serde(default = "default_indexed_paths")]
|
||
indexed_paths: Vec<String>,
|
||
documents: Vec<LocalSearchDocument>,
|
||
#[serde(default)]
|
||
resources: Vec<LocalSearchResource>,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub(crate) struct LocalIndexSettings {
|
||
pub schema: String,
|
||
pub include_paths: Vec<String>,
|
||
#[serde(default = "default_index_schedule_mode")]
|
||
pub schedule_mode: String,
|
||
#[serde(default = "default_index_schedule_time")]
|
||
pub schedule_time: String,
|
||
#[serde(default)]
|
||
pub schedule_date: Option<String>,
|
||
#[serde(default = "default_index_run_on_change")]
|
||
pub run_on_change: bool,
|
||
pub updated_at: u128,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||
#[serde(rename_all = "camelCase")]
|
||
struct LocalSearchDocument {
|
||
document_id: String,
|
||
title: String,
|
||
path: String,
|
||
raw_text: String,
|
||
tags: Vec<String>,
|
||
backlinks: Vec<String>,
|
||
resource_refs: Vec<String>,
|
||
updated_at: u128,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||
#[serde(rename_all = "camelCase")]
|
||
struct LocalSearchResource {
|
||
resource_id: String,
|
||
resource_type: String,
|
||
title: String,
|
||
path: String,
|
||
updated_at: u128,
|
||
}
|
||
|
||
pub(crate) fn query_local_search_index(
|
||
root_path: &Path,
|
||
root_uri: &str,
|
||
workspace_id: &str,
|
||
query: &str,
|
||
page_id: Option<&str>,
|
||
limit: u32,
|
||
title_only: bool,
|
||
exact: bool,
|
||
include_ocr: bool,
|
||
) -> Result<Value, WebError> {
|
||
let settings = read_local_index_settings_or_default(root_path)?;
|
||
query_local_search_index_with_settings(
|
||
root_path,
|
||
root_uri,
|
||
workspace_id,
|
||
&settings,
|
||
&settings,
|
||
query,
|
||
page_id,
|
||
limit,
|
||
title_only,
|
||
exact,
|
||
include_ocr,
|
||
)
|
||
}
|
||
|
||
pub(crate) fn query_local_search_index_with_settings(
|
||
root_path: &Path,
|
||
root_uri: &str,
|
||
workspace_id: &str,
|
||
cache_settings: &LocalIndexSettings,
|
||
result_settings: &LocalIndexSettings,
|
||
query: &str,
|
||
page_id: Option<&str>,
|
||
limit: u32,
|
||
title_only: bool,
|
||
exact: bool,
|
||
include_ocr: bool,
|
||
) -> Result<Value, WebError> {
|
||
let index = load_or_rebuild_local_search_index_with_settings(
|
||
root_path,
|
||
root_uri,
|
||
workspace_id,
|
||
cache_settings,
|
||
)?;
|
||
let normalized_query = normalize_search_text(query);
|
||
let page_id = page_id.map(str::trim).filter(|value| !value.is_empty());
|
||
let page_resource_path = page_id.and_then(local_resource_path_from_document_id);
|
||
let markdown_page_id = if page_resource_path.is_some() {
|
||
None
|
||
} else {
|
||
page_id
|
||
};
|
||
let recent_changes = local_recent_changes_projection(&index.documents, root_uri);
|
||
let mut results = Vec::new();
|
||
for document in index.documents.iter() {
|
||
if !index_relative_path_is_included(&document.path, &result_settings.include_paths) {
|
||
continue;
|
||
}
|
||
if let Some(page_id) = markdown_page_id {
|
||
if document.document_id != page_id {
|
||
continue;
|
||
}
|
||
}
|
||
if !local_search_document_matches(document, &normalized_query, title_only, exact) {
|
||
continue;
|
||
}
|
||
results.push(local_search_document_projection(
|
||
document,
|
||
root_uri,
|
||
&normalized_query,
|
||
));
|
||
if results.len() >= limit.max(1) as usize {
|
||
break;
|
||
}
|
||
}
|
||
if markdown_page_id.is_none() && results.len() < limit.max(1) as usize {
|
||
for resource in index.resources.iter() {
|
||
if !index_relative_path_is_included(&resource.path, &result_settings.include_paths) {
|
||
continue;
|
||
}
|
||
if let Some(resource_path) = page_resource_path.as_deref() {
|
||
if resource.path != resource_path {
|
||
continue;
|
||
}
|
||
}
|
||
if !local_search_resource_matches(resource, &normalized_query, title_only, exact) {
|
||
continue;
|
||
}
|
||
results.push(local_search_resource_projection(resource, root_uri));
|
||
if results.len() >= limit.max(1) as usize {
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
let _ = include_ocr;
|
||
Ok(json!({
|
||
"enqueueAssetIds": [],
|
||
"projectionOwner": "rust-kernel",
|
||
"sourceKind": "local_folder",
|
||
"index": {
|
||
"version": index.version,
|
||
"rootUri": index.root_uri,
|
||
"workspaceId": index.workspace_id,
|
||
"indexedPaths": index.indexed_paths,
|
||
"resultIndexedPaths": result_settings.include_paths,
|
||
"builtAt": index.built_at,
|
||
"documentCount": index.documents.len(),
|
||
"resourceCount": index.resources.len(),
|
||
"includeOcr": include_ocr
|
||
},
|
||
"recentChanges": recent_changes,
|
||
"results": results
|
||
}))
|
||
}
|
||
|
||
#[cfg(test)]
|
||
pub(crate) fn write_local_index_settings(
|
||
root_path: &Path,
|
||
include_paths: &[String],
|
||
schedule_mode: Option<&str>,
|
||
schedule_time: Option<&str>,
|
||
schedule_date: Option<&str>,
|
||
run_on_change: Option<bool>,
|
||
) -> Result<LocalIndexSettings, WebError> {
|
||
let include_paths = normalize_index_include_paths(root_path, include_paths)?;
|
||
let existing = read_local_index_settings_or_default(root_path)
|
||
.unwrap_or_else(|_| default_local_index_settings());
|
||
let schedule_mode =
|
||
normalize_index_schedule_mode(schedule_mode.unwrap_or(&existing.schedule_mode))?;
|
||
let schedule_time =
|
||
normalize_index_schedule_time(schedule_time.unwrap_or(&existing.schedule_time))?;
|
||
let schedule_date =
|
||
normalize_index_schedule_date(schedule_date.or(existing.schedule_date.as_deref()))?;
|
||
let settings = LocalIndexSettings {
|
||
schema: LOCAL_INDEX_SETTINGS_SCHEMA.to_string(),
|
||
include_paths,
|
||
schedule_mode,
|
||
schedule_time,
|
||
schedule_date,
|
||
run_on_change: run_on_change.unwrap_or(existing.run_on_change),
|
||
updated_at: now_ms(),
|
||
};
|
||
write_local_index_settings_cache(root_path, &settings)?;
|
||
Ok(settings)
|
||
}
|
||
|
||
pub(crate) fn read_user_local_index_settings(
|
||
store: &dyn ControlPlaneStore,
|
||
user_id: &str,
|
||
workspace_id: &str,
|
||
root_path: &Path,
|
||
) -> Result<LocalIndexSettings, WebError> {
|
||
let user_id = user_id.trim();
|
||
let scope_id = local_index_scope_id(root_path);
|
||
if user_id.is_empty() || user_id == "anonymous" {
|
||
return Ok(read_local_index_settings_or_default(root_path)
|
||
.unwrap_or_else(|_| default_local_index_settings()));
|
||
}
|
||
let root_preferences = store
|
||
.list_user_ui_preferences_for_scope(
|
||
Some(workspace_id),
|
||
Some(LOCAL_INDEX_SOURCE_KIND),
|
||
LOCAL_INDEX_SETTINGS_SCOPE_KIND,
|
||
&scope_id,
|
||
LOCAL_INDEX_SETTINGS_KEY,
|
||
)
|
||
.map_err(|error| WebError::internal(format!("SQLite 本地索引设置读取失败: {error}")))?;
|
||
let preferences = store
|
||
.list_user_ui_preferences(user_id, Some(workspace_id), Some(LOCAL_INDEX_SOURCE_KIND))
|
||
.map_err(|error| WebError::internal(format!("SQLite 本地索引设置读取失败: {error}")))?;
|
||
let Some(record) = preferences.iter().rev().find(|preference| {
|
||
preference.scope_kind == LOCAL_INDEX_SETTINGS_SCOPE_KIND
|
||
&& preference.scope_id == scope_id
|
||
&& preference.key == LOCAL_INDEX_SETTINGS_KEY
|
||
}) else {
|
||
if root_preferences.is_empty() {
|
||
return Ok(read_local_index_settings_or_default(root_path)
|
||
.unwrap_or_else(|_| default_local_index_settings()));
|
||
}
|
||
return Ok(default_local_index_settings());
|
||
};
|
||
parse_local_index_settings_value(root_path, &record.value_json)
|
||
}
|
||
|
||
pub(crate) fn write_user_local_index_settings(
|
||
store: &dyn ControlPlaneStore,
|
||
user_id: &str,
|
||
workspace_id: &str,
|
||
root_path: &Path,
|
||
include_paths: &[String],
|
||
schedule_mode: Option<&str>,
|
||
schedule_time: Option<&str>,
|
||
schedule_date: Option<&str>,
|
||
run_on_change: Option<bool>,
|
||
) -> Result<LocalIndexSettings, WebError> {
|
||
let user_id = user_id.trim();
|
||
let scope_id = local_index_scope_id(root_path);
|
||
if user_id.is_empty() || user_id == "anonymous" {
|
||
return Err(WebError::bad_request_code(
|
||
"local_index_settings_auth_required",
|
||
"本地索引设置需要登录用户",
|
||
));
|
||
}
|
||
store
|
||
.upsert_user(UpsertUserInput {
|
||
id: Some(user_id.to_string()),
|
||
email: None,
|
||
username: user_id.to_string(),
|
||
display_name: user_id.to_string(),
|
||
role: None,
|
||
password_hash: None,
|
||
})
|
||
.map_err(|error| WebError::internal(format!("SQLite 用户初始化失败: {error}")))?;
|
||
let existing = read_user_local_index_settings(store, user_id, workspace_id, root_path)?;
|
||
let include_paths = normalize_index_include_paths(root_path, include_paths)?;
|
||
let schedule_mode =
|
||
normalize_index_schedule_mode(schedule_mode.unwrap_or(&existing.schedule_mode))?;
|
||
let schedule_time =
|
||
normalize_index_schedule_time(schedule_time.unwrap_or(&existing.schedule_time))?;
|
||
let schedule_date =
|
||
normalize_index_schedule_date(schedule_date.or(existing.schedule_date.as_deref()))?;
|
||
let settings = LocalIndexSettings {
|
||
schema: LOCAL_INDEX_SETTINGS_SCHEMA.to_string(),
|
||
include_paths,
|
||
schedule_mode,
|
||
schedule_time,
|
||
schedule_date,
|
||
run_on_change: run_on_change.unwrap_or(existing.run_on_change),
|
||
updated_at: now_ms(),
|
||
};
|
||
let value_json = serde_json::to_string(&settings)
|
||
.map_err(|error| WebError::internal(format!("本地索引设置序列化失败: {error}")))?;
|
||
store
|
||
.upsert_user_ui_preference(UpsertUserUiPreferenceInput {
|
||
id: None,
|
||
user_id: user_id.to_string(),
|
||
workspace_id: Some(workspace_id.to_string()),
|
||
source_kind: Some(LOCAL_INDEX_SOURCE_KIND.to_string()),
|
||
scope_kind: LOCAL_INDEX_SETTINGS_SCOPE_KIND.to_string(),
|
||
scope_id,
|
||
key: LOCAL_INDEX_SETTINGS_KEY.to_string(),
|
||
value_json,
|
||
})
|
||
.map_err(|error| WebError::internal(format!("SQLite 本地索引设置写入失败: {error}")))?;
|
||
let effective = effective_local_index_settings_for_root(store, workspace_id, root_path)?;
|
||
write_local_index_settings_cache(root_path, &effective)?;
|
||
Ok(settings)
|
||
}
|
||
|
||
pub(crate) fn preview_user_local_index_settings(
|
||
store: &dyn ControlPlaneStore,
|
||
user_id: &str,
|
||
workspace_id: &str,
|
||
root_path: &Path,
|
||
include_paths: &[String],
|
||
schedule_mode: Option<&str>,
|
||
schedule_time: Option<&str>,
|
||
schedule_date: Option<&str>,
|
||
run_on_change: Option<bool>,
|
||
) -> Result<LocalIndexSettings, WebError> {
|
||
let user_id = user_id.trim();
|
||
if user_id.is_empty() || user_id == "anonymous" {
|
||
return Err(WebError::bad_request_code(
|
||
"local_index_settings_auth_required",
|
||
"本地索引设置需要登录用户",
|
||
));
|
||
}
|
||
let existing = read_user_local_index_settings(store, user_id, workspace_id, root_path)?;
|
||
let include_paths = normalize_index_include_paths(root_path, include_paths)?;
|
||
let schedule_mode =
|
||
normalize_index_schedule_mode(schedule_mode.unwrap_or(&existing.schedule_mode))?;
|
||
let schedule_time =
|
||
normalize_index_schedule_time(schedule_time.unwrap_or(&existing.schedule_time))?;
|
||
let schedule_date =
|
||
normalize_index_schedule_date(schedule_date.or(existing.schedule_date.as_deref()))?;
|
||
Ok(LocalIndexSettings {
|
||
schema: LOCAL_INDEX_SETTINGS_SCHEMA.to_string(),
|
||
include_paths,
|
||
schedule_mode,
|
||
schedule_time,
|
||
schedule_date,
|
||
run_on_change: run_on_change.unwrap_or(existing.run_on_change),
|
||
updated_at: now_ms(),
|
||
})
|
||
}
|
||
|
||
pub(crate) fn effective_local_index_settings_for_root(
|
||
store: &dyn ControlPlaneStore,
|
||
workspace_id: &str,
|
||
root_path: &Path,
|
||
) -> Result<LocalIndexSettings, WebError> {
|
||
let scope_id = local_index_scope_id(root_path);
|
||
let records = store
|
||
.list_user_ui_preferences_for_scope(
|
||
Some(workspace_id),
|
||
Some(LOCAL_INDEX_SOURCE_KIND),
|
||
LOCAL_INDEX_SETTINGS_SCOPE_KIND,
|
||
&scope_id,
|
||
LOCAL_INDEX_SETTINGS_KEY,
|
||
)
|
||
.map_err(|error| WebError::internal(format!("SQLite 本地索引设置读取失败: {error}")))?;
|
||
let mut effective = read_local_index_settings_or_default(root_path)
|
||
.unwrap_or_else(|_| default_local_index_settings());
|
||
if records.is_empty() {
|
||
return Ok(effective);
|
||
}
|
||
let mut include_paths = Vec::new();
|
||
let mut run_on_change = false;
|
||
for record in records {
|
||
let settings = parse_local_index_settings_value(root_path, &record.value_json)?;
|
||
include_paths.extend(settings.include_paths);
|
||
run_on_change |= settings.run_on_change;
|
||
}
|
||
effective.include_paths = normalize_index_include_paths(root_path, &include_paths)?;
|
||
effective.run_on_change = run_on_change;
|
||
effective.updated_at = now_ms();
|
||
Ok(effective)
|
||
}
|
||
|
||
pub(crate) fn local_index_any_schedule_due_for_root(
|
||
store: &dyn ControlPlaneStore,
|
||
workspace_id: &str,
|
||
root_path: &Path,
|
||
built_at_ms: u128,
|
||
) -> Result<bool, WebError> {
|
||
let scope_id = local_index_scope_id(root_path);
|
||
let records = store
|
||
.list_user_ui_preferences_for_scope(
|
||
Some(workspace_id),
|
||
Some(LOCAL_INDEX_SOURCE_KIND),
|
||
LOCAL_INDEX_SETTINGS_SCOPE_KIND,
|
||
&scope_id,
|
||
LOCAL_INDEX_SETTINGS_KEY,
|
||
)
|
||
.map_err(|error| WebError::internal(format!("SQLite 本地索引设置读取失败: {error}")))?;
|
||
if records.is_empty() {
|
||
let settings = read_local_index_settings_or_default(root_path)
|
||
.unwrap_or_else(|_| default_local_index_settings());
|
||
return Ok(local_index_schedule_is_due(&settings, built_at_ms));
|
||
}
|
||
for record in records {
|
||
let settings = parse_local_index_settings_value(root_path, &record.value_json)?;
|
||
if local_index_schedule_is_due(&settings, built_at_ms) {
|
||
return Ok(true);
|
||
}
|
||
}
|
||
Ok(false)
|
||
}
|
||
|
||
#[cfg(test)]
|
||
pub(crate) fn local_index_status(
|
||
root_path: &Path,
|
||
root_uri: &str,
|
||
workspace_id: &str,
|
||
) -> Result<Value, WebError> {
|
||
let settings = read_local_index_settings_or_default(root_path)?;
|
||
local_index_status_for_settings(root_path, root_uri, workspace_id, &settings)
|
||
}
|
||
|
||
fn local_index_status_for_settings(
|
||
root_path: &Path,
|
||
root_uri: &str,
|
||
workspace_id: &str,
|
||
settings: &LocalIndexSettings,
|
||
) -> Result<Value, WebError> {
|
||
let index = read_local_search_index(root_path)?;
|
||
let index_path = root_path
|
||
.join(".mnote")
|
||
.join("index")
|
||
.join("search-index.json");
|
||
let evidence_path = evidence_sqlite_path(root_path);
|
||
let mut document_count = 0usize;
|
||
let mut resource_count = 0usize;
|
||
let mut built_at = Value::Null;
|
||
let cache_matches_settings;
|
||
let scheduled_due = if let Some(index) = index.as_ref() {
|
||
document_count = index.documents.len();
|
||
resource_count = index.resources.len();
|
||
built_at = json!(index.built_at);
|
||
cache_matches_settings = index.version == LOCAL_SEARCH_INDEX_VERSION
|
||
&& index.root_uri == root_uri
|
||
&& index.workspace_id == workspace_id
|
||
&& normalized_indexed_paths(&index.indexed_paths) == settings.include_paths;
|
||
local_index_schedule_is_due(&settings, index.built_at)
|
||
} else {
|
||
cache_matches_settings = settings.include_paths.is_empty();
|
||
local_index_schedule_is_due(&settings, 0)
|
||
};
|
||
let evidence_block_count = if evidence_path.exists() {
|
||
count_evidence_blocks(&evidence_path).unwrap_or(0)
|
||
} else {
|
||
0
|
||
};
|
||
Ok(json!({
|
||
"schema": "mnote.local_index.status.v1",
|
||
"rootUri": root_uri,
|
||
"workspaceId": workspace_id,
|
||
"settings": settings,
|
||
"indexPath": ".mnote/index/search-index.json",
|
||
"evidenceIndexPath": ".mnote/index/evidence.sqlite",
|
||
"settingsPath": ".mnote/index/local-index-settings.json",
|
||
"indexExists": index_path.exists(),
|
||
"evidenceIndexExists": evidence_path.exists(),
|
||
"cacheMatchesSettings": cache_matches_settings,
|
||
"scheduledDue": scheduled_due,
|
||
"builtAt": built_at,
|
||
"indexedPaths": index
|
||
.as_ref()
|
||
.map(|index| index.indexed_paths.clone())
|
||
.unwrap_or_default(),
|
||
"documentCount": document_count,
|
||
"resourceCount": resource_count,
|
||
"evidenceBlockCount": evidence_block_count,
|
||
}))
|
||
}
|
||
|
||
pub(crate) fn local_index_status_with_settings(
|
||
root_path: &Path,
|
||
root_uri: &str,
|
||
workspace_id: &str,
|
||
user_settings: &LocalIndexSettings,
|
||
effective_settings: &LocalIndexSettings,
|
||
) -> Result<Value, WebError> {
|
||
let mut status =
|
||
local_index_status_for_settings(root_path, root_uri, workspace_id, effective_settings)?;
|
||
if let Some(object) = status.as_object_mut() {
|
||
object.insert("settings".to_string(), json!(user_settings));
|
||
object.insert("effectiveSettings".to_string(), json!(effective_settings));
|
||
}
|
||
Ok(status)
|
||
}
|
||
|
||
#[cfg(test)]
|
||
#[allow(dead_code)]
|
||
pub(crate) fn local_index_should_refresh_on_change(root_path: &Path) -> bool {
|
||
read_local_index_settings_or_default(root_path)
|
||
.map(|settings| settings.run_on_change)
|
||
.unwrap_or(false)
|
||
}
|
||
|
||
#[cfg(test)]
|
||
#[allow(dead_code)]
|
||
pub(crate) fn refresh_local_search_index_for_change(
|
||
root_path: &Path,
|
||
root_uri: &str,
|
||
workspace_id: &str,
|
||
) -> Result<Option<Value>, WebError> {
|
||
if !local_index_should_refresh_on_change(root_path) {
|
||
return Ok(None);
|
||
}
|
||
refresh_local_search_index(root_path, root_uri, workspace_id).map(Some)
|
||
}
|
||
|
||
pub(crate) fn refresh_local_search_index_for_change_with_store(
|
||
store: &dyn ControlPlaneStore,
|
||
root_path: &Path,
|
||
root_uri: &str,
|
||
workspace_id: &str,
|
||
) -> Result<Option<Value>, WebError> {
|
||
let effective_settings =
|
||
effective_local_index_settings_for_root(store, workspace_id, root_path)?;
|
||
if !effective_settings.run_on_change {
|
||
return Ok(None);
|
||
}
|
||
refresh_local_search_index_with_settings(root_path, root_uri, workspace_id, &effective_settings)
|
||
.map(Some)
|
||
}
|
||
|
||
#[cfg(test)]
|
||
#[allow(dead_code)]
|
||
pub(crate) fn refresh_local_search_index_for_change_path(
|
||
root_path: &Path,
|
||
root_uri: &str,
|
||
workspace_id: &str,
|
||
relative_path: &str,
|
||
) -> Result<Option<Value>, WebError> {
|
||
if !local_index_should_refresh_on_change(root_path) {
|
||
return Ok(None);
|
||
}
|
||
refresh_local_search_index_for_path(root_path, root_uri, workspace_id, relative_path).map(Some)
|
||
}
|
||
|
||
#[cfg(test)]
|
||
#[allow(dead_code)]
|
||
pub(crate) fn refresh_local_search_index_if_scheduled_due(
|
||
root_path: &Path,
|
||
root_uri: &str,
|
||
workspace_id: &str,
|
||
) -> Result<Option<Value>, WebError> {
|
||
let settings = read_local_index_settings_or_default(root_path)?;
|
||
let Some(index) = read_local_search_index(root_path)? else {
|
||
if local_index_schedule_is_due(&settings, 0) {
|
||
return refresh_local_search_index(root_path, root_uri, workspace_id).map(Some);
|
||
}
|
||
return Ok(None);
|
||
};
|
||
if !local_index_schedule_is_due(&settings, index.built_at) {
|
||
return Ok(None);
|
||
}
|
||
refresh_local_search_index(root_path, root_uri, workspace_id).map(Some)
|
||
}
|
||
|
||
pub(crate) fn refresh_local_search_index_for_change_path_with_store(
|
||
store: &dyn ControlPlaneStore,
|
||
root_path: &Path,
|
||
root_uri: &str,
|
||
workspace_id: &str,
|
||
relative_path: &str,
|
||
) -> Result<Option<Value>, WebError> {
|
||
let effective_settings =
|
||
effective_local_index_settings_for_root(store, workspace_id, root_path)?;
|
||
if !effective_settings.run_on_change {
|
||
return Ok(None);
|
||
}
|
||
refresh_local_search_index_for_path_with_settings(
|
||
root_path,
|
||
root_uri,
|
||
workspace_id,
|
||
&effective_settings,
|
||
relative_path,
|
||
)
|
||
.map(Some)
|
||
}
|
||
|
||
pub(crate) fn refresh_local_search_index_if_scheduled_due_with_store(
|
||
store: &dyn ControlPlaneStore,
|
||
root_path: &Path,
|
||
root_uri: &str,
|
||
workspace_id: &str,
|
||
) -> Result<Option<Value>, WebError> {
|
||
let effective_settings =
|
||
effective_local_index_settings_for_root(store, workspace_id, root_path)?;
|
||
let built_at_ms = current_local_search_index_built_at(root_path)?.unwrap_or(0);
|
||
if !local_index_any_schedule_due_for_root(store, workspace_id, root_path, built_at_ms)? {
|
||
return Ok(None);
|
||
}
|
||
refresh_local_search_index_with_settings(root_path, root_uri, workspace_id, &effective_settings)
|
||
.map(Some)
|
||
}
|
||
|
||
#[cfg(test)]
|
||
pub(crate) fn query_evidence_sqlite_results(
|
||
root_path: &Path,
|
||
query: &str,
|
||
owner_document_id: Option<&str>,
|
||
limit: u32,
|
||
) -> Result<Option<Vec<EvidenceSearchResult>>, WebError> {
|
||
query_evidence_sqlite_results_with_mode(root_path, query, owner_document_id, limit, true)
|
||
}
|
||
|
||
pub(crate) fn query_evidence_sqlite_results_with_mode(
|
||
root_path: &Path,
|
||
query: &str,
|
||
owner_document_id: Option<&str>,
|
||
limit: u32,
|
||
exact: bool,
|
||
) -> Result<Option<Vec<EvidenceSearchResult>>, WebError> {
|
||
let path = evidence_sqlite_path(root_path);
|
||
if !path.exists() {
|
||
return Ok(None);
|
||
}
|
||
let normalized_query = query.trim();
|
||
if normalized_query.is_empty() {
|
||
return Ok(Some(Vec::new()));
|
||
}
|
||
let owner_document_id = owner_document_id
|
||
.map(str::trim)
|
||
.filter(|value| !value.is_empty());
|
||
let resource_path = owner_document_id.and_then(local_resource_path_from_document_id);
|
||
let owner_document_id = if resource_path.is_some() {
|
||
None
|
||
} else {
|
||
owner_document_id
|
||
};
|
||
let connection = Connection::open(&path).map_err(|error| {
|
||
WebError::bad_request_code(
|
||
"evidence_index_open_failed",
|
||
format!("无法打开 evidence 索引 {}: {error}", path.display()),
|
||
)
|
||
})?;
|
||
if !exact {
|
||
return Ok(Some(query_evidence_sqlite_fuzzy(
|
||
&connection,
|
||
normalized_query,
|
||
owner_document_id,
|
||
resource_path.as_deref(),
|
||
limit,
|
||
)?));
|
||
}
|
||
let fts_query = evidence_fts_phrase(normalized_query);
|
||
let results = match query_evidence_sqlite_fts(
|
||
&connection,
|
||
&fts_query,
|
||
normalized_query,
|
||
owner_document_id,
|
||
resource_path.as_deref(),
|
||
limit,
|
||
) {
|
||
Ok(results) if results.is_empty() => query_evidence_sqlite_like(
|
||
&connection,
|
||
normalized_query,
|
||
owner_document_id,
|
||
resource_path.as_deref(),
|
||
limit,
|
||
)?,
|
||
Ok(results) => results,
|
||
Err(_) => query_evidence_sqlite_like(
|
||
&connection,
|
||
normalized_query,
|
||
owner_document_id,
|
||
resource_path.as_deref(),
|
||
limit,
|
||
)?,
|
||
};
|
||
Ok(Some(results))
|
||
}
|
||
|
||
pub(crate) fn read_evidence_sqlite_context(
|
||
root_path: &Path,
|
||
locator: &EvidenceLocator,
|
||
before_blocks: u32,
|
||
after_blocks: u32,
|
||
) -> Result<Option<Vec<EvidenceSearchResult>>, WebError> {
|
||
let path = evidence_sqlite_path(root_path);
|
||
if !path.exists() {
|
||
return Ok(None);
|
||
}
|
||
let connection = Connection::open(&path).map_err(|error| {
|
||
WebError::bad_request_code(
|
||
"evidence_index_open_failed",
|
||
format!("无法打开 evidence 索引 {}: {error}", path.display()),
|
||
)
|
||
})?;
|
||
let mut statement = connection
|
||
.prepare(
|
||
"SELECT b.block_id, b.text, b.locator_json \
|
||
FROM evidence_block b \
|
||
JOIN evidence_resource r ON r.resource_id = b.resource_id \
|
||
WHERE r.owner_document_id = ?1 \
|
||
ORDER BY b.rowid",
|
||
)
|
||
.map_err(sqlite_error)?;
|
||
let rows = statement
|
||
.query_map(params![locator.owner_document_id], |row| {
|
||
let block_id: String = row.get(0)?;
|
||
let text: String = row.get(1)?;
|
||
let locator_json: String = row.get(2)?;
|
||
let source =
|
||
serde_json::from_str::<EvidenceLocator>(&locator_json).map_err(|error| {
|
||
rusqlite::Error::FromSqlConversionFailure(
|
||
2,
|
||
rusqlite::types::Type::Text,
|
||
Box::new(error),
|
||
)
|
||
})?;
|
||
Ok((block_id, text, source))
|
||
})
|
||
.map_err(sqlite_error)?
|
||
.collect::<Result<Vec<_>, _>>()
|
||
.map_err(sqlite_error)?;
|
||
if rows.is_empty() {
|
||
return Ok(Some(Vec::new()));
|
||
}
|
||
let Some(anchor_index) = rows
|
||
.iter()
|
||
.position(|(block_id, _, source)| evidence_locator_matches(block_id, source, locator))
|
||
else {
|
||
return Ok(Some(Vec::new()));
|
||
};
|
||
let start = anchor_index.saturating_sub(before_blocks as usize);
|
||
let end = (anchor_index + after_blocks as usize + 1).min(rows.len());
|
||
let results = rows[start..end]
|
||
.iter()
|
||
.map(|(block_id, text, source)| EvidenceSearchResult {
|
||
evidence_id: block_id.clone(),
|
||
quote: text.clone(),
|
||
score: if evidence_locator_matches(block_id, source, locator) {
|
||
1.0
|
||
} else {
|
||
0.8
|
||
},
|
||
source: source.clone(),
|
||
match_info: None,
|
||
citation_url: None,
|
||
citation_label: None,
|
||
citation_markdown: None,
|
||
})
|
||
.collect::<Vec<_>>();
|
||
Ok(Some(results))
|
||
}
|
||
|
||
pub(crate) fn query_evidence_graph_results(
|
||
root_path: &Path,
|
||
query: &str,
|
||
owner_document_id: Option<&str>,
|
||
limit: u32,
|
||
) -> Result<Option<Vec<EvidenceSearchResult>>, WebError> {
|
||
let path = evidence_sqlite_path(root_path);
|
||
if !path.exists() {
|
||
return Ok(None);
|
||
}
|
||
let normalized_query = query.trim().to_ascii_lowercase();
|
||
if normalized_query.is_empty() {
|
||
return Ok(Some(Vec::new()));
|
||
}
|
||
let connection = Connection::open(&path).map_err(|error| {
|
||
WebError::bad_request_code(
|
||
"evidence_index_open_failed",
|
||
format!("无法打开 evidence 索引 {}: {error}", path.display()),
|
||
)
|
||
})?;
|
||
let like_query = format!("%{}%", normalized_query.replace('%', "\\%"));
|
||
let mut statement = if owner_document_id.is_some() {
|
||
connection.prepare(
|
||
"SELECT e.edge_id, e.edge_type, e.from_id, e.to_id, e.source_block_id, b.text, b.locator_json \
|
||
FROM evidence_edge e \
|
||
JOIN evidence_block b ON b.block_id = e.source_block_id \
|
||
JOIN evidence_resource r ON r.resource_id = b.resource_id \
|
||
WHERE r.owner_document_id = ?2 \
|
||
AND (lower(e.edge_type) LIKE ?1 OR lower(e.from_id) LIKE ?1 OR lower(e.to_id) LIKE ?1) \
|
||
ORDER BY e.edge_type, e.from_id, e.to_id \
|
||
LIMIT ?3",
|
||
)
|
||
} else {
|
||
connection.prepare(
|
||
"SELECT e.edge_id, e.edge_type, e.from_id, e.to_id, e.source_block_id, b.text, b.locator_json \
|
||
FROM evidence_edge e \
|
||
JOIN evidence_block b ON b.block_id = e.source_block_id \
|
||
WHERE lower(e.edge_type) LIKE ?1 OR lower(e.from_id) LIKE ?1 OR lower(e.to_id) LIKE ?1 \
|
||
ORDER BY e.edge_type, e.from_id, e.to_id \
|
||
LIMIT ?2",
|
||
)
|
||
}
|
||
.map_err(sqlite_error)?;
|
||
let results = if let Some(owner_document_id) = owner_document_id {
|
||
statement
|
||
.query_map(
|
||
params![like_query, owner_document_id, limit],
|
||
graph_edge_row,
|
||
)
|
||
.map_err(sqlite_error)?
|
||
.collect::<Result<Vec<_>, _>>()
|
||
.map_err(sqlite_error)?
|
||
} else {
|
||
statement
|
||
.query_map(params![like_query, limit], graph_edge_row)
|
||
.map_err(sqlite_error)?
|
||
.collect::<Result<Vec<_>, _>>()
|
||
.map_err(sqlite_error)?
|
||
};
|
||
Ok(Some(results))
|
||
}
|
||
|
||
fn graph_edge_row(row: &rusqlite::Row<'_>) -> rusqlite::Result<EvidenceSearchResult> {
|
||
let edge_id: String = row.get(0)?;
|
||
let edge_type: String = row.get(1)?;
|
||
let from_id: String = row.get(2)?;
|
||
let to_id: String = row.get(3)?;
|
||
let source_block_id: String = row.get(4)?;
|
||
let text: String = row.get(5)?;
|
||
let locator_json: String = row.get(6)?;
|
||
let source = serde_json::from_str::<EvidenceLocator>(&locator_json).map_err(|error| {
|
||
rusqlite::Error::FromSqlConversionFailure(6, rusqlite::types::Type::Text, Box::new(error))
|
||
})?;
|
||
Ok(EvidenceSearchResult {
|
||
evidence_id: edge_id,
|
||
quote: format!("{edge_type}: {from_id} -> {to_id}\n{text}"),
|
||
score: 1.0,
|
||
source: EvidenceLocator {
|
||
block_id: source.block_id.or(Some(source_block_id)),
|
||
..source
|
||
},
|
||
match_info: None,
|
||
citation_url: None,
|
||
citation_label: None,
|
||
citation_markdown: None,
|
||
})
|
||
}
|
||
|
||
fn evidence_locator_matches(
|
||
block_id: &str,
|
||
source: &EvidenceLocator,
|
||
locator: &EvidenceLocator,
|
||
) -> bool {
|
||
locator.block_id.as_deref().is_some_and(|locator_block_id| {
|
||
locator_block_id == block_id || source.block_id.as_deref() == Some(locator_block_id)
|
||
}) || source.owner_document_id == locator.owner_document_id
|
||
&& source.resource_path == locator.resource_path
|
||
&& source.source_map_path == locator.source_map_path
|
||
}
|
||
|
||
fn query_evidence_sqlite_fts(
|
||
connection: &Connection,
|
||
fts_query: &str,
|
||
display_query: &str,
|
||
owner_document_id: Option<&str>,
|
||
resource_path: Option<&str>,
|
||
limit: u32,
|
||
) -> Result<Vec<EvidenceSearchResult>, WebError> {
|
||
let mut sql = String::from(
|
||
"SELECT b.block_id, b.text, b.locator_json, bm25(evidence_fts) AS rank \
|
||
FROM evidence_fts \
|
||
JOIN evidence_block b ON b.block_id = evidence_fts.block_id \
|
||
JOIN evidence_resource r ON r.resource_id = b.resource_id \
|
||
WHERE evidence_fts MATCH ?1",
|
||
);
|
||
if owner_document_id.is_some() {
|
||
sql.push_str(" AND r.owner_document_id = ?2");
|
||
} else if resource_path.is_some() {
|
||
sql.push_str(" AND r.source_root_relative_path = ?2");
|
||
}
|
||
sql.push_str(if owner_document_id.is_some() || resource_path.is_some() {
|
||
" ORDER BY rank LIMIT ?3"
|
||
} else {
|
||
" ORDER BY rank LIMIT ?2"
|
||
});
|
||
let limit = i64::from(limit.max(1));
|
||
let mut statement = connection.prepare(&sql).map_err(sqlite_error)?;
|
||
let rows = if let Some(owner_document_id) = owner_document_id {
|
||
statement
|
||
.query_map(params![fts_query, owner_document_id, limit], |row| {
|
||
evidence_result_from_sqlite_row(row, display_query)
|
||
})
|
||
.map_err(sqlite_error)?
|
||
.collect::<Result<Vec<_>, _>>()
|
||
} else if let Some(resource_path) = resource_path {
|
||
statement
|
||
.query_map(params![fts_query, resource_path, limit], |row| {
|
||
evidence_result_from_sqlite_row(row, display_query)
|
||
})
|
||
.map_err(sqlite_error)?
|
||
.collect::<Result<Vec<_>, _>>()
|
||
} else {
|
||
statement
|
||
.query_map(params![fts_query, limit], |row| {
|
||
evidence_result_from_sqlite_row(row, display_query)
|
||
})
|
||
.map_err(sqlite_error)?
|
||
.collect::<Result<Vec<_>, _>>()
|
||
};
|
||
rows.map_err(sqlite_error)
|
||
}
|
||
|
||
fn query_evidence_sqlite_like(
|
||
connection: &Connection,
|
||
query: &str,
|
||
owner_document_id: Option<&str>,
|
||
resource_path: Option<&str>,
|
||
limit: u32,
|
||
) -> Result<Vec<EvidenceSearchResult>, WebError> {
|
||
let mut sql = String::from(
|
||
"SELECT b.block_id, b.text, b.locator_json, 0.0 AS rank \
|
||
FROM evidence_block b \
|
||
JOIN evidence_resource r ON r.resource_id = b.resource_id \
|
||
WHERE b.text LIKE ?1 ESCAPE '\\'",
|
||
);
|
||
if owner_document_id.is_some() {
|
||
sql.push_str(" AND r.owner_document_id = ?2");
|
||
} else if resource_path.is_some() {
|
||
sql.push_str(" AND r.source_root_relative_path = ?2");
|
||
}
|
||
sql.push_str(if owner_document_id.is_some() || resource_path.is_some() {
|
||
" LIMIT ?3"
|
||
} else {
|
||
" LIMIT ?2"
|
||
});
|
||
let like_query = format!("%{}%", query.replace('%', "\\%").replace('_', "\\_"));
|
||
let limit = i64::from(limit.max(1));
|
||
let mut statement = connection.prepare(&sql).map_err(sqlite_error)?;
|
||
let rows = if let Some(owner_document_id) = owner_document_id {
|
||
statement
|
||
.query_map(params![like_query, owner_document_id, limit], |row| {
|
||
evidence_result_from_sqlite_row(row, query)
|
||
})
|
||
.map_err(sqlite_error)?
|
||
.collect::<Result<Vec<_>, _>>()
|
||
} else if let Some(resource_path) = resource_path {
|
||
statement
|
||
.query_map(params![like_query, resource_path, limit], |row| {
|
||
evidence_result_from_sqlite_row(row, query)
|
||
})
|
||
.map_err(sqlite_error)?
|
||
.collect::<Result<Vec<_>, _>>()
|
||
} else {
|
||
statement
|
||
.query_map(params![like_query, limit], |row| {
|
||
evidence_result_from_sqlite_row(row, query)
|
||
})
|
||
.map_err(sqlite_error)?
|
||
.collect::<Result<Vec<_>, _>>()
|
||
};
|
||
rows.map_err(sqlite_error)
|
||
}
|
||
|
||
fn query_evidence_sqlite_fuzzy(
|
||
connection: &Connection,
|
||
query: &str,
|
||
owner_document_id: Option<&str>,
|
||
resource_path: Option<&str>,
|
||
limit: u32,
|
||
) -> Result<Vec<EvidenceSearchResult>, WebError> {
|
||
let mut sql = String::from(
|
||
"SELECT b.block_id, b.text, b.locator_json, 0.0 AS rank \
|
||
FROM evidence_block b \
|
||
JOIN evidence_resource r ON r.resource_id = b.resource_id",
|
||
);
|
||
let first_char_like = query
|
||
.chars()
|
||
.find(|ch| !ch.is_whitespace())
|
||
.map(|ch| format!("%{}%", ch));
|
||
match (
|
||
owner_document_id.is_some() || resource_path.is_some(),
|
||
first_char_like.is_some(),
|
||
resource_path.is_some(),
|
||
) {
|
||
(true, true, true) => {
|
||
sql.push_str(" WHERE r.source_root_relative_path = ?1 AND b.text LIKE ?2 LIMIT ?3")
|
||
}
|
||
(true, true, false) => {
|
||
sql.push_str(" WHERE r.owner_document_id = ?1 AND b.text LIKE ?2 LIMIT ?3")
|
||
}
|
||
(true, false, true) => sql.push_str(" WHERE r.source_root_relative_path = ?1 LIMIT ?2"),
|
||
(true, false, false) => sql.push_str(" WHERE r.owner_document_id = ?1 LIMIT ?2"),
|
||
(false, true, _) => sql.push_str(" WHERE b.text LIKE ?1 LIMIT ?2"),
|
||
(false, false, _) => sql.push_str(" LIMIT ?1"),
|
||
}
|
||
let mut statement = connection.prepare(&sql).map_err(sqlite_error)?;
|
||
let scan_limit = i64::from(limit.max(1)) * 200;
|
||
let scope_value = owner_document_id.or(resource_path);
|
||
let rows = match (scope_value, first_char_like.as_deref()) {
|
||
(Some(scope_value), Some(first_char_like)) => statement
|
||
.query_map(
|
||
params![scope_value, first_char_like, scan_limit],
|
||
evidence_sqlite_row_parts,
|
||
)
|
||
.map_err(sqlite_error)?
|
||
.collect::<Result<Vec<_>, _>>(),
|
||
(Some(scope_value), None) => statement
|
||
.query_map(params![scope_value, scan_limit], evidence_sqlite_row_parts)
|
||
.map_err(sqlite_error)?
|
||
.collect::<Result<Vec<_>, _>>(),
|
||
(None, Some(first_char_like)) => statement
|
||
.query_map(
|
||
params![first_char_like, scan_limit],
|
||
evidence_sqlite_row_parts,
|
||
)
|
||
.map_err(sqlite_error)?
|
||
.collect::<Result<Vec<_>, _>>(),
|
||
(None, None) => statement
|
||
.query_map(params![scan_limit], evidence_sqlite_row_parts)
|
||
.map_err(sqlite_error)?
|
||
.collect::<Result<Vec<_>, _>>(),
|
||
}
|
||
.map_err(sqlite_error)?;
|
||
let mut scored = rows
|
||
.into_iter()
|
||
.filter_map(|(block_id, text, source)| {
|
||
let text_match = score_evidence_text_match(&text, query)?;
|
||
Some(EvidenceSearchResult {
|
||
evidence_id: block_id,
|
||
quote: ocr_search_snippet_for_terms(&text, query, &text_match.matched_terms),
|
||
score: text_match.score,
|
||
source,
|
||
match_info: Some(text_match.into_match_info(None)),
|
||
citation_url: None,
|
||
citation_label: None,
|
||
citation_markdown: None,
|
||
})
|
||
})
|
||
.collect::<Vec<_>>();
|
||
scored.sort_by(|left, right| {
|
||
right
|
||
.score
|
||
.partial_cmp(&left.score)
|
||
.unwrap_or(std::cmp::Ordering::Equal)
|
||
});
|
||
Ok(scored
|
||
.into_iter()
|
||
.enumerate()
|
||
.map(|(index, mut result)| {
|
||
if let Some(match_info) = result.match_info.as_mut() {
|
||
match_info.rank = Some((index + 1) as u32);
|
||
}
|
||
result
|
||
})
|
||
.take(limit.max(1) as usize)
|
||
.collect())
|
||
}
|
||
|
||
fn evidence_sqlite_row_parts(
|
||
row: &rusqlite::Row<'_>,
|
||
) -> rusqlite::Result<(String, String, EvidenceLocator)> {
|
||
let block_id: String = row.get(0)?;
|
||
let text: String = row.get(1)?;
|
||
let locator_json: String = row.get(2)?;
|
||
let source = serde_json::from_str::<EvidenceLocator>(&locator_json).map_err(|error| {
|
||
rusqlite::Error::FromSqlConversionFailure(2, rusqlite::types::Type::Text, Box::new(error))
|
||
})?;
|
||
Ok((block_id, text, source))
|
||
}
|
||
|
||
fn evidence_result_from_sqlite_row(
|
||
row: &rusqlite::Row<'_>,
|
||
query: &str,
|
||
) -> rusqlite::Result<EvidenceSearchResult> {
|
||
let block_id: String = row.get(0)?;
|
||
let text: String = row.get(1)?;
|
||
let locator_json: String = row.get(2)?;
|
||
let rank: f64 = row.get(3)?;
|
||
let source = serde_json::from_str::<EvidenceLocator>(&locator_json).map_err(|error| {
|
||
rusqlite::Error::FromSqlConversionFailure(2, rusqlite::types::Type::Text, Box::new(error))
|
||
})?;
|
||
let text_match = score_evidence_text_match(&text, query);
|
||
Ok(EvidenceSearchResult {
|
||
evidence_id: block_id,
|
||
quote: text_match
|
||
.as_ref()
|
||
.map(|text_match| ocr_search_snippet_for_terms(&text, query, &text_match.matched_terms))
|
||
.unwrap_or_else(|| ocr_search_snippet(&text, query)),
|
||
score: if rank == 0.0 {
|
||
1.0
|
||
} else {
|
||
1.0 / (1.0 + rank.abs())
|
||
},
|
||
source,
|
||
match_info: text_match.map(|text_match| text_match.into_match_info(None)),
|
||
citation_url: None,
|
||
citation_label: None,
|
||
citation_markdown: None,
|
||
})
|
||
}
|
||
|
||
fn evidence_fts_phrase(query: &str) -> String {
|
||
format!("\"{}\"", query.replace('"', "\"\""))
|
||
}
|
||
|
||
#[cfg(test)]
|
||
pub(crate) fn refresh_local_search_index(
|
||
root_path: &Path,
|
||
root_uri: &str,
|
||
workspace_id: &str,
|
||
) -> Result<Value, WebError> {
|
||
let settings = read_local_index_settings_or_default(root_path)?;
|
||
refresh_local_search_index_with_settings(root_path, root_uri, workspace_id, &settings)
|
||
}
|
||
|
||
pub(crate) fn refresh_local_search_index_with_settings(
|
||
root_path: &Path,
|
||
root_uri: &str,
|
||
workspace_id: &str,
|
||
settings: &LocalIndexSettings,
|
||
) -> Result<Value, WebError> {
|
||
if settings.include_paths.is_empty() {
|
||
clear_local_search_index(root_path)?;
|
||
return Ok(json!({
|
||
"version": LOCAL_SEARCH_INDEX_VERSION,
|
||
"rootUri": root_uri,
|
||
"workspaceId": workspace_id,
|
||
"indexedPaths": [],
|
||
"builtAt": now_ms(),
|
||
"documentCount": 0,
|
||
"resourceCount": 0
|
||
}));
|
||
}
|
||
let index =
|
||
rebuild_local_search_index_with_settings(root_path, root_uri, workspace_id, settings)?;
|
||
Ok(json!({
|
||
"version": index.version,
|
||
"rootUri": index.root_uri,
|
||
"workspaceId": index.workspace_id,
|
||
"indexedPaths": index.indexed_paths,
|
||
"builtAt": index.built_at,
|
||
"documentCount": index.documents.len(),
|
||
"resourceCount": index.resources.len()
|
||
}))
|
||
}
|
||
|
||
#[cfg(test)]
|
||
pub(crate) fn refresh_local_search_index_for_path(
|
||
root_path: &Path,
|
||
root_uri: &str,
|
||
workspace_id: &str,
|
||
relative_path: &str,
|
||
) -> Result<Value, WebError> {
|
||
let settings = read_local_index_settings_or_default(root_path)?;
|
||
refresh_local_search_index_for_path_with_settings(
|
||
root_path,
|
||
root_uri,
|
||
workspace_id,
|
||
&settings,
|
||
relative_path,
|
||
)
|
||
}
|
||
|
||
pub(crate) fn refresh_local_search_index_for_path_with_settings(
|
||
root_path: &Path,
|
||
root_uri: &str,
|
||
workspace_id: &str,
|
||
settings: &LocalIndexSettings,
|
||
relative_path: &str,
|
||
) -> Result<Value, WebError> {
|
||
let relative_path = normalize_index_relative_path(relative_path)?;
|
||
let mut index = match read_local_search_index(root_path) {
|
||
Ok(Some(index))
|
||
if index.version == LOCAL_SEARCH_INDEX_VERSION
|
||
&& index.root_uri == root_uri
|
||
&& index.workspace_id == workspace_id
|
||
&& normalized_indexed_paths(&index.indexed_paths) == settings.include_paths =>
|
||
{
|
||
index
|
||
}
|
||
Ok(_) | Err(_) => {
|
||
return refresh_local_search_index_with_settings(
|
||
root_path,
|
||
root_uri,
|
||
workspace_id,
|
||
settings,
|
||
);
|
||
}
|
||
};
|
||
|
||
index
|
||
.documents
|
||
.retain(|document| document.path != relative_path);
|
||
index
|
||
.resources
|
||
.retain(|resource| resource.path != relative_path);
|
||
let included = index_relative_path_is_included(&relative_path, &settings.include_paths);
|
||
if local_ocr::is_local_ocr_sidecar_relative_path(&relative_path) {
|
||
index.built_at = now_ms();
|
||
write_local_search_index_json(root_path, &index)?;
|
||
let _ = included;
|
||
remove_evidence_sqlite_index_for_path(root_path, &index, &relative_path)?;
|
||
return Ok(json!({
|
||
"version": index.version,
|
||
"rootUri": index.root_uri,
|
||
"workspaceId": index.workspace_id,
|
||
"indexedPaths": index.indexed_paths,
|
||
"builtAt": index.built_at,
|
||
"documentCount": index.documents.len(),
|
||
"resourceCount": index.resources.len()
|
||
}));
|
||
}
|
||
if is_local_evidence_sidecar_relative_path(&relative_path) {
|
||
index.built_at = now_ms();
|
||
write_local_search_index_json(root_path, &index)?;
|
||
return Ok(json!({
|
||
"version": index.version,
|
||
"rootUri": index.root_uri,
|
||
"workspaceId": index.workspace_id,
|
||
"indexedPaths": index.indexed_paths,
|
||
"builtAt": index.built_at,
|
||
"documentCount": index.documents.len(),
|
||
"resourceCount": index.resources.len()
|
||
}));
|
||
}
|
||
let absolute_path = root_path.join(&relative_path);
|
||
if included
|
||
&& absolute_path.exists()
|
||
&& absolute_path.is_file()
|
||
&& is_markdown_path(&absolute_path)
|
||
{
|
||
index
|
||
.documents
|
||
.push(index_markdown_file(root_path, &absolute_path)?);
|
||
} else if included
|
||
&& absolute_path.exists()
|
||
&& absolute_path.is_file()
|
||
&& resource_type_from_path(&absolute_path).is_some()
|
||
{
|
||
index
|
||
.resources
|
||
.push(index_resource_file(root_path, &absolute_path)?);
|
||
}
|
||
index
|
||
.documents
|
||
.sort_by(|left, right| left.path.cmp(&right.path));
|
||
index
|
||
.resources
|
||
.sort_by(|left, right| left.path.cmp(&right.path));
|
||
index.built_at = now_ms();
|
||
write_local_search_index_json(root_path, &index)?;
|
||
if included {
|
||
refresh_evidence_sqlite_index_for_path(root_path, &index, &relative_path)?;
|
||
} else {
|
||
remove_evidence_sqlite_index_for_path(root_path, &index, &relative_path)?;
|
||
}
|
||
Ok(json!({
|
||
"version": index.version,
|
||
"rootUri": index.root_uri,
|
||
"workspaceId": index.workspace_id,
|
||
"indexedPaths": index.indexed_paths,
|
||
"builtAt": index.built_at,
|
||
"documentCount": index.documents.len(),
|
||
"resourceCount": index.resources.len()
|
||
}))
|
||
}
|
||
|
||
#[cfg(test)]
|
||
#[allow(dead_code)]
|
||
pub(crate) fn query_local_backlinks(
|
||
root_path: &Path,
|
||
root_uri: &str,
|
||
workspace_id: &str,
|
||
document_id: &str,
|
||
) -> Result<Value, WebError> {
|
||
let settings = read_local_index_settings_or_default(root_path)?;
|
||
query_local_backlinks_with_settings(
|
||
root_path,
|
||
root_uri,
|
||
workspace_id,
|
||
&settings,
|
||
&settings,
|
||
document_id,
|
||
)
|
||
}
|
||
|
||
pub(crate) fn query_local_backlinks_with_settings(
|
||
root_path: &Path,
|
||
root_uri: &str,
|
||
workspace_id: &str,
|
||
cache_settings: &LocalIndexSettings,
|
||
result_settings: &LocalIndexSettings,
|
||
document_id: &str,
|
||
) -> Result<Value, WebError> {
|
||
let index = load_or_rebuild_local_search_index_with_settings(
|
||
root_path,
|
||
root_uri,
|
||
workspace_id,
|
||
cache_settings,
|
||
)?;
|
||
let Some(target) = index.documents.iter().find(|document| {
|
||
document.document_id == document_id
|
||
&& index_relative_path_is_included(&document.path, &result_settings.include_paths)
|
||
}) else {
|
||
return Ok(json!({
|
||
"documentId": document_id,
|
||
"rootUri": root_uri,
|
||
"workspaceId": workspace_id,
|
||
"backlinks": []
|
||
}));
|
||
};
|
||
let target_keys = normalized_document_targets(target);
|
||
let backlinks = index
|
||
.documents
|
||
.iter()
|
||
.filter(|document| {
|
||
index_relative_path_is_included(&document.path, &result_settings.include_paths)
|
||
})
|
||
.filter(|document| document.document_id != target.document_id)
|
||
.filter_map(|document| {
|
||
let matched_targets = document
|
||
.backlinks
|
||
.iter()
|
||
.filter(|link| target_keys.contains(&normalize_search_text(link)))
|
||
.cloned()
|
||
.collect::<Vec<_>>();
|
||
if matched_targets.is_empty() {
|
||
return None;
|
||
}
|
||
Some(json!({
|
||
"documentId": document.document_id,
|
||
"title": document.title,
|
||
"path": document.path,
|
||
"resourceType": "markdown",
|
||
"matchedTargets": matched_targets,
|
||
"snippet": search_snippet(document, &normalize_search_text(&target.title))
|
||
}))
|
||
})
|
||
.collect::<Vec<_>>();
|
||
Ok(json!({
|
||
"documentId": target.document_id,
|
||
"title": target.title,
|
||
"path": target.path,
|
||
"rootUri": root_uri,
|
||
"workspaceId": workspace_id,
|
||
"backlinks": backlinks
|
||
}))
|
||
}
|
||
|
||
#[cfg(test)]
|
||
#[allow(dead_code)]
|
||
pub(crate) fn query_local_tags(
|
||
root_path: &Path,
|
||
root_uri: &str,
|
||
workspace_id: &str,
|
||
) -> Result<Value, WebError> {
|
||
let settings = read_local_index_settings_or_default(root_path)?;
|
||
query_local_tags_with_settings(root_path, root_uri, workspace_id, &settings, &settings)
|
||
}
|
||
|
||
pub(crate) fn query_local_tags_with_settings(
|
||
root_path: &Path,
|
||
root_uri: &str,
|
||
workspace_id: &str,
|
||
cache_settings: &LocalIndexSettings,
|
||
result_settings: &LocalIndexSettings,
|
||
) -> Result<Value, WebError> {
|
||
let index = load_or_rebuild_local_search_index_with_settings(
|
||
root_path,
|
||
root_uri,
|
||
workspace_id,
|
||
cache_settings,
|
||
)?;
|
||
let mut tags = std::collections::BTreeMap::<String, Vec<&LocalSearchDocument>>::new();
|
||
for document in &index.documents {
|
||
if !index_relative_path_is_included(&document.path, &result_settings.include_paths) {
|
||
continue;
|
||
}
|
||
for tag in &document.tags {
|
||
tags.entry(tag.clone()).or_default().push(document);
|
||
}
|
||
}
|
||
Ok(json!({
|
||
"rootUri": root_uri,
|
||
"workspaceId": workspace_id,
|
||
"tags": tags
|
||
.into_iter()
|
||
.map(|(tag, documents)| {
|
||
json!({
|
||
"tag": tag,
|
||
"count": documents.len(),
|
||
"documents": documents
|
||
.into_iter()
|
||
.map(|document| {
|
||
json!({
|
||
"documentId": document.document_id,
|
||
"title": document.title,
|
||
"path": document.path,
|
||
"resourceType": "markdown"
|
||
})
|
||
})
|
||
.collect::<Vec<_>>()
|
||
})
|
||
})
|
||
.collect::<Vec<_>>()
|
||
}))
|
||
}
|
||
|
||
#[cfg(test)]
|
||
#[allow(dead_code)]
|
||
fn rebuild_local_search_index(
|
||
root_path: &Path,
|
||
root_uri: &str,
|
||
workspace_id: &str,
|
||
) -> Result<LocalSearchIndex, WebError> {
|
||
let settings = read_local_index_settings_or_default(root_path)?;
|
||
rebuild_local_search_index_with_settings(root_path, root_uri, workspace_id, &settings)
|
||
}
|
||
|
||
fn rebuild_local_search_index_with_settings(
|
||
root_path: &Path,
|
||
root_uri: &str,
|
||
workspace_id: &str,
|
||
settings: &LocalIndexSettings,
|
||
) -> Result<LocalSearchIndex, WebError> {
|
||
let mut documents = Vec::new();
|
||
let mut resources = Vec::new();
|
||
for include_path in &settings.include_paths {
|
||
let base_path = if include_path == "." {
|
||
root_path.to_path_buf()
|
||
} else {
|
||
root_path.join(include_path)
|
||
};
|
||
if base_path.exists() {
|
||
collect_markdown_documents(root_path, &base_path, &mut documents, &mut resources)?;
|
||
}
|
||
}
|
||
documents.sort_by(|left, right| left.path.cmp(&right.path));
|
||
documents.dedup_by(|left, right| left.path == right.path);
|
||
resources.sort_by(|left, right| left.path.cmp(&right.path));
|
||
resources.dedup_by(|left, right| left.path == right.path);
|
||
let index = LocalSearchIndex {
|
||
version: LOCAL_SEARCH_INDEX_VERSION,
|
||
built_at: now_ms(),
|
||
root_uri: root_uri.to_string(),
|
||
workspace_id: workspace_id.to_string(),
|
||
indexed_paths: settings.include_paths.clone(),
|
||
documents,
|
||
resources,
|
||
};
|
||
write_local_search_index(root_path, &index)?;
|
||
Ok(index)
|
||
}
|
||
|
||
#[cfg(test)]
|
||
#[allow(dead_code)]
|
||
fn load_or_rebuild_local_search_index(
|
||
root_path: &Path,
|
||
root_uri: &str,
|
||
workspace_id: &str,
|
||
) -> Result<LocalSearchIndex, WebError> {
|
||
let settings = read_local_index_settings_or_default(root_path)?;
|
||
load_or_rebuild_local_search_index_with_settings(root_path, root_uri, workspace_id, &settings)
|
||
}
|
||
|
||
fn load_or_rebuild_local_search_index_with_settings(
|
||
root_path: &Path,
|
||
root_uri: &str,
|
||
workspace_id: &str,
|
||
settings: &LocalIndexSettings,
|
||
) -> Result<LocalSearchIndex, WebError> {
|
||
match read_local_search_index(root_path) {
|
||
Ok(Some(index))
|
||
if index.version == LOCAL_SEARCH_INDEX_VERSION
|
||
&& index.root_uri == root_uri
|
||
&& index.workspace_id == workspace_id
|
||
&& normalized_indexed_paths(&index.indexed_paths) == settings.include_paths =>
|
||
{
|
||
if local_index_schedule_is_due(&settings, index.built_at) {
|
||
return rebuild_local_search_index_with_settings(
|
||
root_path,
|
||
root_uri,
|
||
workspace_id,
|
||
settings,
|
||
);
|
||
}
|
||
ensure_evidence_sqlite_index(root_path, &index)?;
|
||
Ok(index)
|
||
}
|
||
Ok(_) | Err(_) => {
|
||
rebuild_local_search_index_with_settings(root_path, root_uri, workspace_id, settings)
|
||
}
|
||
}
|
||
}
|
||
|
||
fn read_local_search_index(root_path: &Path) -> Result<Option<LocalSearchIndex>, WebError> {
|
||
let index_path = root_path
|
||
.join(".mnote")
|
||
.join("index")
|
||
.join("search-index.json");
|
||
if !index_path.exists() {
|
||
return Ok(None);
|
||
}
|
||
let content = fs::read_to_string(&index_path).map_err(|error| {
|
||
WebError::bad_request_code(
|
||
"local_search_index_read_failed",
|
||
format!("无法读取本地搜索索引 {}: {error}", index_path.display()),
|
||
)
|
||
})?;
|
||
serde_json::from_str::<LocalSearchIndex>(&content)
|
||
.map(Some)
|
||
.map_err(|error| {
|
||
WebError::bad_request_code(
|
||
"local_search_index_invalid",
|
||
format!("本地搜索索引格式非法 {}: {error}", index_path.display()),
|
||
)
|
||
})
|
||
}
|
||
|
||
pub(crate) fn current_local_search_index_built_at(
|
||
root_path: &Path,
|
||
) -> Result<Option<u128>, WebError> {
|
||
Ok(read_local_search_index(root_path)?.map(|index| index.built_at))
|
||
}
|
||
|
||
fn default_indexed_paths() -> Vec<String> {
|
||
vec![".".to_string()]
|
||
}
|
||
|
||
fn local_index_settings_path(root_path: &Path) -> PathBuf {
|
||
root_path
|
||
.join(".mnote")
|
||
.join("index")
|
||
.join("local-index-settings.json")
|
||
}
|
||
|
||
pub(crate) fn read_local_index_settings_or_default(
|
||
root_path: &Path,
|
||
) -> Result<LocalIndexSettings, WebError> {
|
||
let path = local_index_settings_path(root_path);
|
||
if !path.exists() {
|
||
return Ok(default_local_index_settings());
|
||
}
|
||
let content = fs::read_to_string(&path).map_err(|error| {
|
||
WebError::bad_request_code(
|
||
"local_index_settings_read_failed",
|
||
format!("无法读取本地索引设置 {}: {error}", path.display()),
|
||
)
|
||
})?;
|
||
parse_local_index_settings_value(root_path, &content).map_err(|error| {
|
||
if error.code() == "local_index_settings_invalid" {
|
||
WebError::bad_request_code(
|
||
"local_index_settings_invalid",
|
||
format!(
|
||
"本地索引设置格式非法 {}: {}",
|
||
path.display(),
|
||
error.message()
|
||
),
|
||
)
|
||
} else {
|
||
error
|
||
}
|
||
})
|
||
}
|
||
|
||
fn write_local_index_settings_cache(
|
||
root_path: &Path,
|
||
settings: &LocalIndexSettings,
|
||
) -> Result<(), WebError> {
|
||
let path = local_index_settings_path(root_path);
|
||
if let Some(parent) = path.parent() {
|
||
fs::create_dir_all(parent).map_err(|error| {
|
||
WebError::bad_request_code(
|
||
"local_index_settings_create_failed",
|
||
format!("无法创建本地索引设置目录 {}: {error}", parent.display()),
|
||
)
|
||
})?;
|
||
}
|
||
let payload = serde_json::to_string_pretty(settings)
|
||
.map_err(|error| WebError::internal(format!("本地索引设置序列化失败: {error}")))?;
|
||
fs::write(&path, format!("{payload}\n")).map_err(|error| {
|
||
WebError::bad_request_code(
|
||
"local_index_settings_write_failed",
|
||
format!("无法写入本地索引设置 {}: {error}", path.display()),
|
||
)
|
||
})
|
||
}
|
||
|
||
fn parse_local_index_settings_value(
|
||
root_path: &Path,
|
||
value_json: &str,
|
||
) -> Result<LocalIndexSettings, WebError> {
|
||
let raw = serde_json::from_str::<LocalIndexSettings>(value_json).map_err(|error| {
|
||
WebError::bad_request_code(
|
||
"local_index_settings_invalid",
|
||
format!("本地索引设置 JSON 非法: {error}"),
|
||
)
|
||
})?;
|
||
Ok(LocalIndexSettings {
|
||
schema: LOCAL_INDEX_SETTINGS_SCHEMA.to_string(),
|
||
include_paths: normalize_index_include_paths(root_path, &raw.include_paths)?,
|
||
schedule_mode: normalize_index_schedule_mode(&raw.schedule_mode)?,
|
||
schedule_time: normalize_index_schedule_time(&raw.schedule_time)?,
|
||
schedule_date: normalize_index_schedule_date(raw.schedule_date.as_deref())?,
|
||
run_on_change: raw.run_on_change,
|
||
updated_at: raw.updated_at,
|
||
})
|
||
}
|
||
|
||
fn default_local_index_settings() -> LocalIndexSettings {
|
||
LocalIndexSettings {
|
||
schema: LOCAL_INDEX_SETTINGS_SCHEMA.to_string(),
|
||
include_paths: Vec::new(),
|
||
schedule_mode: default_index_schedule_mode(),
|
||
schedule_time: default_index_schedule_time(),
|
||
schedule_date: None,
|
||
run_on_change: default_index_run_on_change(),
|
||
updated_at: 0,
|
||
}
|
||
}
|
||
|
||
fn default_index_schedule_mode() -> String {
|
||
DEFAULT_INDEX_SCHEDULE_MODE.to_string()
|
||
}
|
||
|
||
fn default_index_schedule_time() -> String {
|
||
DEFAULT_INDEX_SCHEDULE_TIME.to_string()
|
||
}
|
||
|
||
fn default_index_run_on_change() -> bool {
|
||
false
|
||
}
|
||
|
||
fn normalize_index_schedule_mode(value: &str) -> Result<String, WebError> {
|
||
let mode = value.trim();
|
||
if mode.is_empty() {
|
||
return Ok(default_index_schedule_mode());
|
||
}
|
||
match mode {
|
||
"daily" | "once" | "manual" => Ok(mode.to_string()),
|
||
_ => Err(WebError::bad_request_code(
|
||
"local_index_schedule_mode_invalid",
|
||
"本地索引调度模式只能是 daily、once 或 manual",
|
||
)),
|
||
}
|
||
}
|
||
|
||
fn normalize_index_schedule_time(value: &str) -> Result<String, WebError> {
|
||
let value = value.trim();
|
||
let (hour, minute) = parse_hh_mm(value)?;
|
||
Ok(format!("{hour:02}:{minute:02}"))
|
||
}
|
||
|
||
fn normalize_index_schedule_date(value: Option<&str>) -> Result<Option<String>, WebError> {
|
||
let Some(value) = value.map(str::trim).filter(|value| !value.is_empty()) else {
|
||
return Ok(None);
|
||
};
|
||
let _ = parse_yyyy_mm_dd(value)?;
|
||
Ok(Some(value.to_string()))
|
||
}
|
||
|
||
fn local_index_schedule_is_due(settings: &LocalIndexSettings, built_at_ms: u128) -> bool {
|
||
let now = OffsetDateTime::now_local().unwrap_or_else(|_| OffsetDateTime::now_utc());
|
||
let Ok((hour, minute)) = parse_hh_mm(&settings.schedule_time) else {
|
||
return false;
|
||
};
|
||
let Ok(schedule_time) = Time::from_hms(hour, minute, 0) else {
|
||
return false;
|
||
};
|
||
let target = match settings.schedule_mode.as_str() {
|
||
"manual" => return false,
|
||
"once" => {
|
||
let Some(date) = settings
|
||
.schedule_date
|
||
.as_deref()
|
||
.and_then(|value| parse_yyyy_mm_dd(value).ok())
|
||
else {
|
||
return false;
|
||
};
|
||
date.with_time(schedule_time).assume_offset(now.offset())
|
||
}
|
||
_ => now
|
||
.date()
|
||
.with_time(schedule_time)
|
||
.assume_offset(now.offset()),
|
||
};
|
||
if now < target {
|
||
return false;
|
||
}
|
||
let built_at = unix_ms_to_local_datetime(built_at_ms);
|
||
built_at.map(|value| value < target).unwrap_or(true)
|
||
}
|
||
|
||
fn unix_ms_to_local_datetime(value: u128) -> Option<OffsetDateTime> {
|
||
let seconds = i64::try_from(value / 1000).ok()?;
|
||
let nanos = u32::try_from((value % 1000) * 1_000_000).ok()?;
|
||
OffsetDateTime::from_unix_timestamp(seconds)
|
||
.ok()
|
||
.map(|datetime| datetime + Duration::nanoseconds(nanos as i64))
|
||
.map(|datetime| {
|
||
datetime.to_offset(
|
||
OffsetDateTime::now_local()
|
||
.unwrap_or_else(|_| OffsetDateTime::now_utc())
|
||
.offset(),
|
||
)
|
||
})
|
||
}
|
||
|
||
fn parse_hh_mm(value: &str) -> Result<(u8, u8), WebError> {
|
||
let parts = value.trim().split(':').collect::<Vec<_>>();
|
||
if parts.len() != 2 {
|
||
return Err(WebError::bad_request_code(
|
||
"local_index_schedule_time_invalid",
|
||
"本地索引时间必须是 HH:MM",
|
||
));
|
||
}
|
||
let hour = parts[0].parse::<u8>().map_err(|_| {
|
||
WebError::bad_request_code(
|
||
"local_index_schedule_time_invalid",
|
||
"本地索引时间必须是 HH:MM",
|
||
)
|
||
})?;
|
||
let minute = parts[1].parse::<u8>().map_err(|_| {
|
||
WebError::bad_request_code(
|
||
"local_index_schedule_time_invalid",
|
||
"本地索引时间必须是 HH:MM",
|
||
)
|
||
})?;
|
||
if hour > 23 || minute > 59 {
|
||
return Err(WebError::bad_request_code(
|
||
"local_index_schedule_time_invalid",
|
||
"本地索引时间必须是 00:00 到 23:59",
|
||
));
|
||
}
|
||
Ok((hour, minute))
|
||
}
|
||
|
||
fn parse_yyyy_mm_dd(value: &str) -> Result<Date, WebError> {
|
||
let parts = value.trim().split('-').collect::<Vec<_>>();
|
||
if parts.len() != 3 {
|
||
return Err(WebError::bad_request_code(
|
||
"local_index_schedule_date_invalid",
|
||
"本地索引日期必须是 YYYY-MM-DD",
|
||
));
|
||
}
|
||
let year = parts[0].parse::<i32>().map_err(|_| {
|
||
WebError::bad_request_code(
|
||
"local_index_schedule_date_invalid",
|
||
"本地索引日期必须是 YYYY-MM-DD",
|
||
)
|
||
})?;
|
||
let month = parts[1].parse::<u8>().map_err(|_| {
|
||
WebError::bad_request_code(
|
||
"local_index_schedule_date_invalid",
|
||
"本地索引日期必须是 YYYY-MM-DD",
|
||
)
|
||
})?;
|
||
let day = parts[2].parse::<u8>().map_err(|_| {
|
||
WebError::bad_request_code(
|
||
"local_index_schedule_date_invalid",
|
||
"本地索引日期必须是 YYYY-MM-DD",
|
||
)
|
||
})?;
|
||
let month = Month::try_from(month).map_err(|_| {
|
||
WebError::bad_request_code(
|
||
"local_index_schedule_date_invalid",
|
||
"本地索引日期必须是 YYYY-MM-DD",
|
||
)
|
||
})?;
|
||
Date::from_calendar_date(year, month, day).map_err(|_| {
|
||
WebError::bad_request_code(
|
||
"local_index_schedule_date_invalid",
|
||
"本地索引日期必须是 YYYY-MM-DD",
|
||
)
|
||
})
|
||
}
|
||
|
||
fn normalize_index_include_paths(
|
||
root_path: &Path,
|
||
include_paths: &[String],
|
||
) -> Result<Vec<String>, WebError> {
|
||
let mut output = Vec::new();
|
||
let root_canonical = root_path
|
||
.canonicalize()
|
||
.unwrap_or_else(|_| root_path.to_path_buf());
|
||
for value in include_paths {
|
||
let trimmed = value.trim();
|
||
if trimmed.is_empty() {
|
||
continue;
|
||
}
|
||
let raw_path = PathBuf::from(trimmed);
|
||
let normalized = if trimmed == "." || trimmed == "/" {
|
||
".".to_string()
|
||
} else if raw_path.is_absolute() {
|
||
let canonical = raw_path.canonicalize().map_err(|error| {
|
||
WebError::bad_request_code(
|
||
"local_index_scope_not_found",
|
||
format!("本地索引范围不存在 {}: {error}", raw_path.display()),
|
||
)
|
||
})?;
|
||
if !canonical.starts_with(&root_canonical) {
|
||
return Err(WebError::bad_request_code(
|
||
"local_index_scope_escape",
|
||
"本地索引目录必须位于当前授权 root 内",
|
||
));
|
||
}
|
||
if !canonical.is_dir() {
|
||
return Err(WebError::bad_request_code(
|
||
"local_index_scope_not_directory",
|
||
"本地索引范围必须是目录",
|
||
));
|
||
}
|
||
canonical
|
||
.strip_prefix(&root_canonical)
|
||
.map_err(|_| {
|
||
WebError::bad_request_code(
|
||
"local_index_scope_escape",
|
||
"本地索引目录必须位于当前授权 root 内",
|
||
)
|
||
})?
|
||
.to_string_lossy()
|
||
.replace('\\', "/")
|
||
} else {
|
||
normalize_index_relative_path(trimmed.trim_start_matches("./"))?
|
||
};
|
||
let normalized = if normalized.is_empty() {
|
||
".".to_string()
|
||
} else {
|
||
normalized
|
||
};
|
||
if normalized.split('/').any(|part| part == ".mnote") {
|
||
return Err(WebError::bad_request_code(
|
||
"local_index_scope_reserved",
|
||
"本地索引目录不能指向 .mnote 内部缓存",
|
||
));
|
||
}
|
||
let absolute = if normalized == "." {
|
||
root_path.to_path_buf()
|
||
} else {
|
||
root_path.join(&normalized)
|
||
};
|
||
if let Ok(canonical) = absolute.canonicalize() {
|
||
if !canonical.starts_with(&root_canonical) {
|
||
return Err(WebError::bad_request_code(
|
||
"local_index_scope_escape",
|
||
"本地索引目录必须位于当前授权 root 内",
|
||
));
|
||
}
|
||
if !canonical.is_dir() {
|
||
return Err(WebError::bad_request_code(
|
||
"local_index_scope_not_directory",
|
||
"本地索引范围必须是目录",
|
||
));
|
||
}
|
||
}
|
||
if output.iter().any(|existing| existing == &normalized) {
|
||
continue;
|
||
}
|
||
output.push(normalized);
|
||
}
|
||
Ok(normalized_indexed_paths(&output))
|
||
}
|
||
|
||
fn normalized_indexed_paths(paths: &[String]) -> Vec<String> {
|
||
let mut values = paths
|
||
.iter()
|
||
.map(|value| value.trim().replace('\\', "/"))
|
||
.filter(|value| !value.is_empty())
|
||
.map(|value| {
|
||
if value == "/" || value == "./" {
|
||
".".to_string()
|
||
} else {
|
||
value
|
||
.trim_start_matches("./")
|
||
.trim_end_matches('/')
|
||
.to_string()
|
||
}
|
||
})
|
||
.map(|value| {
|
||
if value.is_empty() {
|
||
".".to_string()
|
||
} else {
|
||
value
|
||
}
|
||
})
|
||
.collect::<Vec<_>>();
|
||
values.sort();
|
||
values.dedup();
|
||
values
|
||
}
|
||
|
||
fn normalize_index_relative_path(relative_path: &str) -> Result<String, WebError> {
|
||
let normalized = relative_path.trim().replace('\\', "/");
|
||
if normalized.is_empty() {
|
||
return Err(WebError::bad_request_code(
|
||
"local_search_index_path_required",
|
||
"本地搜索索引更新缺少相对路径",
|
||
));
|
||
}
|
||
let path = PathBuf::from(&normalized);
|
||
if path.is_absolute()
|
||
|| path.components().any(|component| {
|
||
matches!(
|
||
component,
|
||
Component::ParentDir | Component::RootDir | Component::Prefix(_)
|
||
)
|
||
})
|
||
{
|
||
return Err(WebError::bad_request_code(
|
||
"local_search_index_path_escape",
|
||
"本地搜索索引相对路径不能越过 root",
|
||
));
|
||
}
|
||
Ok(normalized)
|
||
}
|
||
|
||
fn index_relative_path_is_included(relative_path: &str, include_paths: &[String]) -> bool {
|
||
let relative_path = relative_path.trim().replace('\\', "/");
|
||
include_paths.iter().any(|include| {
|
||
include == "."
|
||
|| relative_path == *include
|
||
|| relative_path
|
||
.strip_prefix(include)
|
||
.map(|rest| rest.starts_with('/'))
|
||
.unwrap_or(false)
|
||
})
|
||
}
|
||
|
||
fn collect_markdown_documents(
|
||
root_path: &Path,
|
||
current: &Path,
|
||
documents: &mut Vec<LocalSearchDocument>,
|
||
resources: &mut Vec<LocalSearchResource>,
|
||
) -> Result<(), WebError> {
|
||
let entries = match fs::read_dir(current) {
|
||
Ok(entries) => entries,
|
||
Err(error) => {
|
||
return Err(WebError::bad_request_code(
|
||
"local_search_index_read_dir_failed",
|
||
format!("无法读取本地搜索索引目录 {}: {error}", current.display()),
|
||
));
|
||
}
|
||
};
|
||
for entry in entries {
|
||
let entry = entry.map_err(|error| {
|
||
WebError::bad_request_code(
|
||
"local_search_index_read_entry_failed",
|
||
format!("无法读取本地搜索索引条目: {error}"),
|
||
)
|
||
})?;
|
||
let path = entry.path();
|
||
let file_name = path
|
||
.file_name()
|
||
.and_then(|value| value.to_str())
|
||
.unwrap_or_default();
|
||
if file_name == ".mnote" {
|
||
continue;
|
||
}
|
||
let file_type = entry.file_type().map_err(|error| {
|
||
WebError::bad_request_code(
|
||
"local_search_index_stat_failed",
|
||
format!("无法读取本地搜索索引文件状态 {}: {error}", path.display()),
|
||
)
|
||
})?;
|
||
if file_type.is_dir() {
|
||
collect_markdown_documents(root_path, &path, documents, resources)?;
|
||
continue;
|
||
}
|
||
if !file_type.is_file() {
|
||
continue;
|
||
}
|
||
let relative_path = path
|
||
.strip_prefix(root_path)
|
||
.unwrap_or(&path)
|
||
.to_string_lossy()
|
||
.replace('\\', "/");
|
||
if is_local_evidence_sidecar_relative_path(&relative_path) {
|
||
continue;
|
||
}
|
||
if is_markdown_path(&path) {
|
||
if local_ocr::is_local_ocr_sidecar_relative_path(&relative_path) {
|
||
continue;
|
||
}
|
||
documents.push(index_markdown_file(root_path, &path)?);
|
||
} else if resource_type_from_path(&path).is_some() {
|
||
resources.push(index_resource_file(root_path, &path)?);
|
||
}
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
fn index_markdown_file(root_path: &Path, path: &Path) -> Result<LocalSearchDocument, WebError> {
|
||
let markdown = fs::read_to_string(path).map_err(|error| {
|
||
WebError::bad_request_code(
|
||
"local_search_index_read_markdown_failed",
|
||
format!("无法读取本地 Markdown 索引文件 {}: {error}", path.display()),
|
||
)
|
||
})?;
|
||
let file_name = path
|
||
.file_name()
|
||
.and_then(|value| value.to_str())
|
||
.unwrap_or("");
|
||
let parsed = parse_markdown_page(&markdown, file_name);
|
||
let relative_path = path
|
||
.strip_prefix(root_path)
|
||
.unwrap_or(path)
|
||
.to_string_lossy()
|
||
.replace('\\', "/");
|
||
let document_id = format!("local-md:{}", encode_local_id_segment(&relative_path));
|
||
let metadata = fs::metadata(path).map_err(|error| {
|
||
WebError::bad_request_code(
|
||
"local_search_index_stat_failed",
|
||
format!(
|
||
"无法读取本地 Markdown 索引文件状态 {}: {error}",
|
||
path.display()
|
||
),
|
||
)
|
||
})?;
|
||
Ok(LocalSearchDocument {
|
||
document_id,
|
||
title: parsed.title,
|
||
path: relative_path,
|
||
raw_text: parsed.body.clone(),
|
||
tags: extract_tags(&markdown),
|
||
backlinks: extract_backlinks(&parsed.body),
|
||
resource_refs: extract_resource_refs(&parsed.body),
|
||
updated_at: metadata
|
||
.modified()
|
||
.ok()
|
||
.and_then(|value| value.duration_since(UNIX_EPOCH).ok())
|
||
.map(|value| value.as_millis())
|
||
.unwrap_or_default(),
|
||
})
|
||
}
|
||
|
||
fn index_resource_file(root_path: &Path, path: &Path) -> Result<LocalSearchResource, WebError> {
|
||
let resource_type = resource_type_from_path(path).ok_or_else(|| {
|
||
WebError::bad_request_code(
|
||
"local_search_index_resource_type_unsupported",
|
||
format!("不支持索引该资源文件 {}", path.display()),
|
||
)
|
||
})?;
|
||
let relative_path = path
|
||
.strip_prefix(root_path)
|
||
.unwrap_or(path)
|
||
.to_string_lossy()
|
||
.replace('\\', "/");
|
||
let title = path
|
||
.file_stem()
|
||
.and_then(|value| value.to_str())
|
||
.unwrap_or("resource")
|
||
.trim()
|
||
.trim_end_matches(".mindmap")
|
||
.to_string();
|
||
let metadata = fs::metadata(path).map_err(|error| {
|
||
WebError::bad_request_code(
|
||
"local_search_index_stat_failed",
|
||
format!("无法读取本地资源索引文件状态 {}: {error}", path.display()),
|
||
)
|
||
})?;
|
||
Ok(LocalSearchResource {
|
||
resource_id: format!("local-resource:{}", relative_path.replace('/', "~2F")),
|
||
resource_type: resource_type.to_string(),
|
||
title,
|
||
path: relative_path,
|
||
updated_at: metadata
|
||
.modified()
|
||
.ok()
|
||
.and_then(|value| value.duration_since(UNIX_EPOCH).ok())
|
||
.map(|value| value.as_millis())
|
||
.unwrap_or_default(),
|
||
})
|
||
}
|
||
|
||
fn write_local_search_index(root_path: &Path, index: &LocalSearchIndex) -> Result<(), WebError> {
|
||
write_local_search_index_json(root_path, index)?;
|
||
write_evidence_sqlite_index(root_path, index)
|
||
}
|
||
|
||
fn write_local_search_index_json(
|
||
root_path: &Path,
|
||
index: &LocalSearchIndex,
|
||
) -> Result<(), WebError> {
|
||
let index_dir = root_path.join(".mnote").join("index");
|
||
fs::create_dir_all(&index_dir).map_err(|error| {
|
||
WebError::bad_request_code(
|
||
"local_search_index_create_failed",
|
||
format!("无法创建本地搜索索引目录 {}: {error}", index_dir.display()),
|
||
)
|
||
})?;
|
||
let index_path = index_dir.join("search-index.json");
|
||
let payload = serde_json::to_string_pretty(index)
|
||
.map_err(|error| WebError::internal(format!("本地搜索索引序列化失败: {error}")))?;
|
||
fs::write(&index_path, format!("{payload}\n")).map_err(|error| {
|
||
WebError::bad_request_code(
|
||
"local_search_index_write_failed",
|
||
format!("无法写入本地搜索索引 {}: {error}", index_path.display()),
|
||
)
|
||
})
|
||
}
|
||
|
||
fn clear_local_search_index(root_path: &Path) -> Result<(), WebError> {
|
||
let index_path = root_path
|
||
.join(".mnote")
|
||
.join("index")
|
||
.join("search-index.json");
|
||
let evidence_path = evidence_sqlite_path(root_path);
|
||
for path in [index_path, evidence_path] {
|
||
match fs::remove_file(&path) {
|
||
Ok(()) => {}
|
||
Err(error) if error.kind() == std::io::ErrorKind::NotFound => {}
|
||
Err(error) => {
|
||
return Err(WebError::bad_request_code(
|
||
"local_search_index_delete_failed",
|
||
format!("无法删除本地搜索索引文件 {}: {error}", path.display()),
|
||
));
|
||
}
|
||
}
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
fn ensure_evidence_sqlite_index(
|
||
root_path: &Path,
|
||
index: &LocalSearchIndex,
|
||
) -> Result<(), WebError> {
|
||
let path = evidence_sqlite_path(root_path);
|
||
if path.exists() {
|
||
return Ok(());
|
||
}
|
||
write_evidence_sqlite_index(root_path, index)
|
||
}
|
||
|
||
fn write_evidence_sqlite_index(root_path: &Path, index: &LocalSearchIndex) -> Result<(), WebError> {
|
||
let Some(parent) = evidence_sqlite_path(root_path)
|
||
.parent()
|
||
.map(Path::to_path_buf)
|
||
else {
|
||
return Ok(());
|
||
};
|
||
fs::create_dir_all(&parent).map_err(|error| {
|
||
WebError::bad_request_code(
|
||
"evidence_index_create_failed",
|
||
format!("无法创建 evidence 索引目录 {}: {error}", parent.display()),
|
||
)
|
||
})?;
|
||
let path = evidence_sqlite_path(root_path);
|
||
let mut connection = Connection::open(&path).map_err(|error| {
|
||
WebError::bad_request_code(
|
||
"evidence_index_open_failed",
|
||
format!("无法打开 evidence 索引 {}: {error}", path.display()),
|
||
)
|
||
})?;
|
||
let tx = connection.transaction().map_err(sqlite_error)?;
|
||
create_evidence_schema(&tx)?;
|
||
tx.execute("DELETE FROM evidence_fts", [])
|
||
.map_err(sqlite_error)?;
|
||
for table in [
|
||
"evidence_edge",
|
||
"evidence_section",
|
||
"evidence_block",
|
||
"evidence_resource",
|
||
] {
|
||
tx.execute(&format!("DELETE FROM {table}"), [])
|
||
.map_err(sqlite_error)?;
|
||
}
|
||
for document in &index.documents {
|
||
insert_document_evidence(&tx, index, document)?;
|
||
}
|
||
for resource in &index.resources {
|
||
insert_resource_evidence(&tx, root_path, index, resource)?;
|
||
}
|
||
for document in &index.documents {
|
||
insert_document_graph_edges(&tx, document)?;
|
||
}
|
||
tx.execute(
|
||
"INSERT OR REPLACE INTO evidence_meta(key, value) VALUES('schema_version', ?1)",
|
||
params![EVIDENCE_SQLITE_SCHEMA_VERSION.to_string()],
|
||
)
|
||
.map_err(sqlite_error)?;
|
||
tx.execute(
|
||
"INSERT OR REPLACE INTO evidence_meta(key, value) VALUES('workspace_id', ?1)",
|
||
params![index.workspace_id],
|
||
)
|
||
.map_err(sqlite_error)?;
|
||
tx.commit().map_err(sqlite_error)
|
||
}
|
||
|
||
fn create_evidence_schema(connection: &Connection) -> Result<(), WebError> {
|
||
connection
|
||
.execute_batch(
|
||
r#"
|
||
CREATE TABLE IF NOT EXISTS evidence_meta(
|
||
key TEXT PRIMARY KEY,
|
||
value TEXT NOT NULL
|
||
);
|
||
CREATE TABLE IF NOT EXISTS evidence_resource(
|
||
resource_id TEXT PRIMARY KEY,
|
||
owner_document_id TEXT NOT NULL,
|
||
owner_document_path TEXT NOT NULL,
|
||
source_root_relative_path TEXT NOT NULL,
|
||
provider TEXT NOT NULL,
|
||
source_hash TEXT NOT NULL,
|
||
artifact_root_relative_path TEXT NOT NULL,
|
||
source_map_root_relative_path TEXT NOT NULL,
|
||
updated_at_ms INTEGER NOT NULL
|
||
);
|
||
CREATE TABLE IF NOT EXISTS evidence_block(
|
||
block_id TEXT PRIMARY KEY,
|
||
resource_id TEXT NOT NULL,
|
||
text TEXT NOT NULL,
|
||
section_path_json TEXT NOT NULL,
|
||
page_start INTEGER,
|
||
page_end INTEGER,
|
||
bbox_json TEXT,
|
||
char_range_json TEXT,
|
||
line_range_json TEXT,
|
||
locator_json TEXT NOT NULL
|
||
);
|
||
CREATE VIRTUAL TABLE IF NOT EXISTS evidence_fts USING fts5(
|
||
block_id UNINDEXED,
|
||
text
|
||
);
|
||
CREATE TABLE IF NOT EXISTS evidence_section(
|
||
section_id TEXT PRIMARY KEY,
|
||
resource_id TEXT NOT NULL,
|
||
title TEXT NOT NULL,
|
||
path_json TEXT NOT NULL,
|
||
summary TEXT,
|
||
page_start INTEGER,
|
||
page_end INTEGER,
|
||
parent_section_id TEXT
|
||
);
|
||
CREATE TABLE IF NOT EXISTS evidence_edge(
|
||
edge_id TEXT PRIMARY KEY,
|
||
from_id TEXT NOT NULL,
|
||
to_id TEXT NOT NULL,
|
||
edge_type TEXT NOT NULL,
|
||
source_block_id TEXT,
|
||
confidence REAL NOT NULL,
|
||
created_by TEXT NOT NULL
|
||
);
|
||
"#,
|
||
)
|
||
.map_err(sqlite_error)
|
||
}
|
||
|
||
fn refresh_evidence_sqlite_index_for_path(
|
||
root_path: &Path,
|
||
index: &LocalSearchIndex,
|
||
relative_path: &str,
|
||
) -> Result<(), WebError> {
|
||
if let Some(parent) = evidence_sqlite_path(root_path)
|
||
.parent()
|
||
.map(Path::to_path_buf)
|
||
{
|
||
fs::create_dir_all(&parent).map_err(|error| {
|
||
WebError::bad_request_code(
|
||
"evidence_index_create_failed",
|
||
format!("无法创建 evidence 索引目录 {}: {error}", parent.display()),
|
||
)
|
||
})?;
|
||
}
|
||
let mut connection = Connection::open(evidence_sqlite_path(root_path)).map_err(|error| {
|
||
WebError::bad_request_code(
|
||
"evidence_index_open_failed",
|
||
format!("无法打开 evidence 索引: {error}"),
|
||
)
|
||
})?;
|
||
let tx = connection.transaction().map_err(sqlite_error)?;
|
||
create_evidence_schema(&tx)?;
|
||
let mut affected_resource_ids = affected_evidence_resource_ids(index, relative_path);
|
||
affected_resource_ids.extend(existing_evidence_resource_ids_for_path(&tx, relative_path)?);
|
||
affected_resource_ids.sort();
|
||
affected_resource_ids.dedup();
|
||
for resource_id in &affected_resource_ids {
|
||
delete_evidence_resource_projection(&tx, resource_id)?;
|
||
}
|
||
if let Some(document) = index
|
||
.documents
|
||
.iter()
|
||
.find(|document| document.path == relative_path)
|
||
{
|
||
insert_document_evidence(&tx, index, document)?;
|
||
insert_document_graph_edges(&tx, document)?;
|
||
}
|
||
if let Some(resource) = index
|
||
.resources
|
||
.iter()
|
||
.find(|resource| resource.path == relative_path)
|
||
{
|
||
insert_resource_evidence(&tx, root_path, index, resource)?;
|
||
}
|
||
tx.execute(
|
||
"INSERT OR REPLACE INTO evidence_meta(key, value) VALUES('schema_version', ?1)",
|
||
params![EVIDENCE_SQLITE_SCHEMA_VERSION.to_string()],
|
||
)
|
||
.map_err(sqlite_error)?;
|
||
tx.execute(
|
||
"INSERT OR REPLACE INTO evidence_meta(key, value) VALUES('workspace_id', ?1)",
|
||
params![index.workspace_id],
|
||
)
|
||
.map_err(sqlite_error)?;
|
||
tx.commit().map_err(sqlite_error)
|
||
}
|
||
|
||
fn remove_evidence_sqlite_index_for_path(
|
||
root_path: &Path,
|
||
index: &LocalSearchIndex,
|
||
relative_path: &str,
|
||
) -> Result<(), WebError> {
|
||
let path = evidence_sqlite_path(root_path);
|
||
if !path.exists() {
|
||
return Ok(());
|
||
}
|
||
let mut connection = Connection::open(&path).map_err(|error| {
|
||
WebError::bad_request_code(
|
||
"evidence_index_open_failed",
|
||
format!("无法打开 evidence 索引 {}: {error}", path.display()),
|
||
)
|
||
})?;
|
||
let tx = connection.transaction().map_err(sqlite_error)?;
|
||
create_evidence_schema(&tx)?;
|
||
let mut affected_resource_ids = affected_evidence_resource_ids(index, relative_path);
|
||
affected_resource_ids.extend(existing_evidence_resource_ids_for_path(&tx, relative_path)?);
|
||
affected_resource_ids.sort();
|
||
affected_resource_ids.dedup();
|
||
for resource_id in &affected_resource_ids {
|
||
delete_evidence_resource_projection(&tx, resource_id)?;
|
||
}
|
||
tx.commit().map_err(sqlite_error)
|
||
}
|
||
|
||
fn affected_evidence_resource_ids(index: &LocalSearchIndex, relative_path: &str) -> Vec<String> {
|
||
let mut ids = Vec::new();
|
||
let document_id = format!("local-md:{}", encode_local_id_segment(relative_path));
|
||
ids.push(document_id.clone());
|
||
ids.push(format!(
|
||
"local-resource:{}",
|
||
relative_path.replace('/', "~2F")
|
||
));
|
||
ids.extend(
|
||
index
|
||
.documents
|
||
.iter()
|
||
.filter(|document| document.path == relative_path)
|
||
.map(|document| document.document_id.clone()),
|
||
);
|
||
ids.extend(
|
||
index
|
||
.resources
|
||
.iter()
|
||
.filter(|resource| resource.path == relative_path)
|
||
.map(|resource| resource.resource_id.clone()),
|
||
);
|
||
if let Some(stripped) = relative_path.strip_suffix(".ocr.md") {
|
||
ids.push(format!("{document_id}#ocr:{stripped}"));
|
||
}
|
||
ids
|
||
}
|
||
|
||
fn existing_evidence_resource_ids_for_path(
|
||
connection: &Connection,
|
||
relative_path: &str,
|
||
) -> Result<Vec<String>, WebError> {
|
||
let mut statement = connection
|
||
.prepare(
|
||
"SELECT resource_id FROM evidence_resource \
|
||
WHERE source_root_relative_path = ?1 \
|
||
OR artifact_root_relative_path = ?1 \
|
||
OR source_map_root_relative_path = ?1",
|
||
)
|
||
.map_err(sqlite_error)?;
|
||
let resource_ids = statement
|
||
.query_map(params![relative_path], |row| row.get::<_, String>(0))
|
||
.map_err(sqlite_error)?
|
||
.collect::<Result<Vec<_>, _>>()
|
||
.map_err(sqlite_error)?;
|
||
Ok(resource_ids)
|
||
}
|
||
|
||
fn delete_evidence_resource_projection(
|
||
connection: &Connection,
|
||
resource_id: &str,
|
||
) -> Result<(), WebError> {
|
||
let mut statement = connection
|
||
.prepare("SELECT block_id FROM evidence_block WHERE resource_id = ?1")
|
||
.map_err(sqlite_error)?;
|
||
let block_ids = statement
|
||
.query_map(params![resource_id], |row| row.get::<_, String>(0))
|
||
.map_err(sqlite_error)?
|
||
.collect::<Result<Vec<_>, _>>()
|
||
.map_err(sqlite_error)?;
|
||
for block_id in &block_ids {
|
||
connection
|
||
.execute(
|
||
"DELETE FROM evidence_fts WHERE block_id = ?1",
|
||
params![block_id],
|
||
)
|
||
.map_err(sqlite_error)?;
|
||
connection
|
||
.execute(
|
||
"DELETE FROM evidence_edge WHERE source_block_id = ?1",
|
||
params![block_id],
|
||
)
|
||
.map_err(sqlite_error)?;
|
||
}
|
||
connection
|
||
.execute(
|
||
"DELETE FROM evidence_edge WHERE from_id = ?1",
|
||
params![resource_id],
|
||
)
|
||
.map_err(sqlite_error)?;
|
||
connection
|
||
.execute(
|
||
"DELETE FROM evidence_section WHERE resource_id = ?1",
|
||
params![resource_id],
|
||
)
|
||
.map_err(sqlite_error)?;
|
||
connection
|
||
.execute(
|
||
"DELETE FROM evidence_block WHERE resource_id = ?1",
|
||
params![resource_id],
|
||
)
|
||
.map_err(sqlite_error)?;
|
||
connection
|
||
.execute(
|
||
"DELETE FROM evidence_resource WHERE resource_id = ?1",
|
||
params![resource_id],
|
||
)
|
||
.map(|_| ())
|
||
.map_err(sqlite_error)
|
||
}
|
||
|
||
fn insert_document_evidence(
|
||
connection: &Connection,
|
||
index: &LocalSearchIndex,
|
||
document: &LocalSearchDocument,
|
||
) -> Result<(), WebError> {
|
||
let resource_id = document.document_id.as_str();
|
||
let artifact = markdown_parsed_artifact(document);
|
||
insert_evidence_resource_from_artifact(connection, resource_id, &artifact)?;
|
||
for section in markdown_evidence_sections(document) {
|
||
insert_markdown_evidence_section(connection, resource_id, §ion)?;
|
||
}
|
||
let blocks = markdown_evidence_blocks(document);
|
||
if blocks.is_empty() {
|
||
let block_id = format!("{resource_id}#line1");
|
||
let line_range = json!({"start": 1, "end": 1});
|
||
let locator = markdown_locator(
|
||
index,
|
||
&document.document_id,
|
||
&document.path,
|
||
&block_id,
|
||
Vec::new(),
|
||
Some(line_range.clone()),
|
||
);
|
||
return insert_evidence_block_with_metadata(
|
||
connection,
|
||
&block_id,
|
||
resource_id,
|
||
&document.raw_text,
|
||
Vec::new(),
|
||
Some(line_range),
|
||
locator,
|
||
);
|
||
}
|
||
for block in blocks {
|
||
let locator = markdown_locator(
|
||
index,
|
||
&document.document_id,
|
||
&document.path,
|
||
&block.block_id,
|
||
block.section_path.clone(),
|
||
Some(block.line_range.clone()),
|
||
);
|
||
insert_evidence_block_with_metadata(
|
||
connection,
|
||
&block.block_id,
|
||
resource_id,
|
||
&block.text,
|
||
block.section_path,
|
||
Some(block.line_range),
|
||
locator,
|
||
)?;
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
fn markdown_parsed_artifact(document: &LocalSearchDocument) -> ParsedResourceArtifact {
|
||
ParsedResourceArtifact {
|
||
schema: PARSED_RESOURCE_ARTIFACT_SCHEMA.into(),
|
||
provider: "markdown".into(),
|
||
model_version: None,
|
||
owner_document_id: document.document_id.clone(),
|
||
owner_document_path: document.path.clone(),
|
||
source_root_relative_path: document.path.clone(),
|
||
source_hash: format!("updated:{}", document.updated_at),
|
||
artifact_root_relative_path: document.path.clone(),
|
||
source_map_root_relative_path: format!("{}.source-map.json", document.path),
|
||
updated_at_ms: document.updated_at as u64,
|
||
}
|
||
}
|
||
|
||
fn insert_evidence_resource_from_artifact(
|
||
connection: &Connection,
|
||
resource_id: &str,
|
||
artifact: &ParsedResourceArtifact,
|
||
) -> Result<(), WebError> {
|
||
insert_evidence_resource(
|
||
connection,
|
||
resource_id,
|
||
&artifact.owner_document_id,
|
||
&artifact.owner_document_path,
|
||
&artifact.source_root_relative_path,
|
||
&artifact.provider,
|
||
&artifact.source_hash,
|
||
&artifact.artifact_root_relative_path,
|
||
&artifact.source_map_root_relative_path,
|
||
artifact.updated_at_ms as u128,
|
||
)
|
||
}
|
||
|
||
fn insert_resource_evidence(
|
||
connection: &Connection,
|
||
root_path: &Path,
|
||
index: &LocalSearchIndex,
|
||
resource: &LocalSearchResource,
|
||
) -> Result<(), WebError> {
|
||
insert_evidence_resource(
|
||
connection,
|
||
&resource.resource_id,
|
||
&resource.resource_id,
|
||
&resource.path,
|
||
&resource.path,
|
||
"resource",
|
||
&format!("updated:{}", resource.updated_at),
|
||
&resource.path,
|
||
"",
|
||
resource.updated_at,
|
||
)?;
|
||
let locator = json!({
|
||
"schema": "mnote.evidence_locator.v1",
|
||
"rootUri": index.root_uri,
|
||
"ownerDocumentId": resource.resource_id,
|
||
"ownerDocumentPath": resource.path,
|
||
"resourcePath": resource.path,
|
||
"resourceKind": evidence_resource_kind_for_type(&resource.resource_type),
|
||
"openAction": {
|
||
"actionType": "mnote.open_resource_locator",
|
||
"url": format!("/?treeView=filetree&sourceKind=local_folder&rootUri={}", encode_query_component(&index.root_uri)),
|
||
"params": {"resourcePath": resource.path}
|
||
}
|
||
});
|
||
insert_evidence_block(
|
||
connection,
|
||
&format!("{}#resource", resource.resource_id),
|
||
&resource.resource_id,
|
||
&format!("{}\n{}", resource.title, resource.path),
|
||
locator,
|
||
)?;
|
||
if let Some(output) = parse_resource_evidence_artifact(root_path, index, resource)? {
|
||
insert_source_map_artifact_evidence(
|
||
connection,
|
||
index,
|
||
&parsed_resource_id(resource),
|
||
&output.artifact,
|
||
&output.source_map,
|
||
&output.markdown,
|
||
)?;
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
fn parse_resource_evidence_artifact(
|
||
_root_path: &Path,
|
||
_index: &LocalSearchIndex,
|
||
_resource: &LocalSearchResource,
|
||
) -> Result<Option<crate::evidence_parse::ParseProviderOutput>, WebError> {
|
||
Ok(None)
|
||
}
|
||
|
||
fn parsed_resource_id(resource: &LocalSearchResource) -> String {
|
||
format!("{}#parse", resource.resource_id)
|
||
}
|
||
|
||
fn insert_source_map_artifact_evidence(
|
||
connection: &Connection,
|
||
index: &LocalSearchIndex,
|
||
resource_id: &str,
|
||
artifact: &ParsedResourceArtifact,
|
||
source_map: &ResourceSourceMap,
|
||
fallback_text: &str,
|
||
) -> Result<(), WebError> {
|
||
insert_evidence_resource_from_artifact(connection, resource_id, artifact)?;
|
||
for section in &source_map.sections {
|
||
insert_source_map_evidence_section(connection, resource_id, section)?;
|
||
}
|
||
let mut inserted = 0_usize;
|
||
for page in &source_map.pages {
|
||
for block in &page.blocks {
|
||
if block.text.trim().is_empty() {
|
||
continue;
|
||
}
|
||
let block_id = format!("{resource_id}#{}", block.id);
|
||
let section_path = source_map_section_path_for_block(source_map, &block.id);
|
||
let locator = source_map_block_locator(
|
||
index,
|
||
artifact,
|
||
&block.id,
|
||
Some(page.page),
|
||
block,
|
||
section_path.clone(),
|
||
);
|
||
insert_evidence_block_with_metadata(
|
||
connection,
|
||
&block_id,
|
||
resource_id,
|
||
&block.text,
|
||
section_path,
|
||
None,
|
||
locator,
|
||
)?;
|
||
inserted += 1;
|
||
}
|
||
}
|
||
if inserted == 0 {
|
||
let block_id = format!("{resource_id}#artifact");
|
||
let fallback_block = empty_source_map_block(fallback_text);
|
||
let locator = source_map_block_locator(
|
||
index,
|
||
artifact,
|
||
&fallback_block.id,
|
||
None,
|
||
&fallback_block,
|
||
Vec::new(),
|
||
);
|
||
insert_evidence_block_with_metadata(
|
||
connection,
|
||
&block_id,
|
||
resource_id,
|
||
fallback_text,
|
||
Vec::new(),
|
||
None,
|
||
locator,
|
||
)?;
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
fn insert_source_map_evidence_section(
|
||
connection: &Connection,
|
||
resource_id: &str,
|
||
section: &core_protocol::SourceMapSection,
|
||
) -> Result<(), WebError> {
|
||
let path_json = serde_json::to_string(§ion.path).map_err(|error| {
|
||
WebError::bad_request_code(
|
||
"evidence_index_section_serialize_failed",
|
||
format!("source-map section path 序列化失败: {error}"),
|
||
)
|
||
})?;
|
||
connection
|
||
.execute(
|
||
"INSERT OR REPLACE INTO evidence_section(section_id, resource_id, title, path_json, summary, page_start, page_end, parent_section_id) VALUES(?1, ?2, ?3, ?4, NULL, ?5, ?6, NULL)",
|
||
params![
|
||
format!("{resource_id}#{}", section.id),
|
||
resource_id,
|
||
section.title,
|
||
path_json,
|
||
section.page_start,
|
||
section.page_end,
|
||
],
|
||
)
|
||
.map(|_| ())
|
||
.map_err(sqlite_error)
|
||
}
|
||
|
||
fn source_map_section_path_for_block(
|
||
source_map: &ResourceSourceMap,
|
||
block_id: &str,
|
||
) -> Vec<String> {
|
||
source_map
|
||
.sections
|
||
.iter()
|
||
.find(|section| section.block_ids.iter().any(|id| id == block_id))
|
||
.map(|section| section.path.clone())
|
||
.unwrap_or_default()
|
||
}
|
||
|
||
fn source_map_block_locator(
|
||
index: &LocalSearchIndex,
|
||
artifact: &ParsedResourceArtifact,
|
||
source_map_block_id: &str,
|
||
page: Option<u32>,
|
||
block: &SourceMapBlock,
|
||
section_path: Vec<String>,
|
||
) -> Value {
|
||
let mut params = json!({
|
||
"resourcePath": artifact.source_root_relative_path,
|
||
"sourceMapPath": artifact.source_map_root_relative_path,
|
||
"blockId": source_map_block_id,
|
||
});
|
||
if let Some(params_object) = params.as_object_mut() {
|
||
if let Some(page) = page {
|
||
params_object.insert("page".into(), json!(page));
|
||
}
|
||
if let Some(bbox) = &block.bbox {
|
||
params_object.insert("bbox".into(), json!(bbox));
|
||
}
|
||
if let Some(char_range) = &block.char_range {
|
||
params_object.insert("charRange".into(), json!(char_range));
|
||
}
|
||
}
|
||
json!({
|
||
"schema": "mnote.evidence_locator.v1",
|
||
"rootUri": index.root_uri,
|
||
"ownerDocumentId": artifact.owner_document_id,
|
||
"ownerDocumentPath": artifact.owner_document_path,
|
||
"resourcePath": artifact.source_root_relative_path,
|
||
"resourceKind": evidence_resource_kind_for_path(&artifact.source_root_relative_path),
|
||
"page": page,
|
||
"bbox": block.bbox,
|
||
"sectionPath": section_path,
|
||
"charRange": block.char_range,
|
||
"blockId": source_map_block_id,
|
||
"sourceMapPath": artifact.source_map_root_relative_path,
|
||
"openAction": {
|
||
"actionType": "mnote.open_resource_locator",
|
||
"url": format!("/documents/{}?sourceKind=local_folder&rootUri={}", artifact.owner_document_id, encode_query_component(&index.root_uri)),
|
||
"params": params
|
||
}
|
||
})
|
||
}
|
||
|
||
fn empty_source_map_block(text: &str) -> SourceMapBlock {
|
||
SourceMapBlock {
|
||
id: "artifact".into(),
|
||
block_type: core_protocol::SourceMapBlockKind::Text,
|
||
text: text.to_string(),
|
||
bbox: None,
|
||
char_range: None,
|
||
}
|
||
}
|
||
|
||
fn insert_evidence_resource(
|
||
connection: &Connection,
|
||
resource_id: &str,
|
||
owner_document_id: &str,
|
||
owner_document_path: &str,
|
||
source_root_relative_path: &str,
|
||
provider: &str,
|
||
source_hash: &str,
|
||
artifact_root_relative_path: &str,
|
||
source_map_root_relative_path: &str,
|
||
updated_at_ms: u128,
|
||
) -> Result<(), WebError> {
|
||
connection
|
||
.execute(
|
||
"INSERT OR REPLACE INTO evidence_resource(resource_id, owner_document_id, owner_document_path, source_root_relative_path, provider, source_hash, artifact_root_relative_path, source_map_root_relative_path, updated_at_ms) VALUES(?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9)",
|
||
params![
|
||
resource_id,
|
||
owner_document_id,
|
||
owner_document_path,
|
||
source_root_relative_path,
|
||
provider,
|
||
source_hash,
|
||
artifact_root_relative_path,
|
||
source_map_root_relative_path,
|
||
updated_at_ms.to_string(),
|
||
],
|
||
)
|
||
.map(|_| ())
|
||
.map_err(sqlite_error)
|
||
}
|
||
|
||
fn insert_evidence_block(
|
||
connection: &Connection,
|
||
block_id: &str,
|
||
resource_id: &str,
|
||
text: &str,
|
||
locator: Value,
|
||
) -> Result<(), WebError> {
|
||
insert_evidence_block_with_metadata(
|
||
connection,
|
||
block_id,
|
||
resource_id,
|
||
text,
|
||
Vec::new(),
|
||
None,
|
||
locator,
|
||
)
|
||
}
|
||
|
||
fn insert_evidence_block_with_metadata(
|
||
connection: &Connection,
|
||
block_id: &str,
|
||
resource_id: &str,
|
||
text: &str,
|
||
section_path: Vec<String>,
|
||
line_range: Option<Value>,
|
||
locator: Value,
|
||
) -> Result<(), WebError> {
|
||
let locator_json = serde_json::to_string(&locator).map_err(|error| {
|
||
WebError::bad_request_code(
|
||
"evidence_index_locator_serialize_failed",
|
||
format!("locator 序列化失败: {error}"),
|
||
)
|
||
})?;
|
||
let section_path_json = serde_json::to_string(§ion_path).map_err(|error| {
|
||
WebError::bad_request_code(
|
||
"evidence_index_section_serialize_failed",
|
||
format!("sectionPath 序列化失败: {error}"),
|
||
)
|
||
})?;
|
||
let line_range_json = line_range
|
||
.map(|value| serde_json::to_string(&value))
|
||
.transpose()
|
||
.map_err(|error| {
|
||
WebError::bad_request_code(
|
||
"evidence_index_line_range_serialize_failed",
|
||
format!("lineRange 序列化失败: {error}"),
|
||
)
|
||
})?;
|
||
connection
|
||
.execute(
|
||
"INSERT OR REPLACE INTO evidence_block(block_id, resource_id, text, section_path_json, page_start, page_end, bbox_json, char_range_json, line_range_json, locator_json) VALUES(?1, ?2, ?3, ?4, NULL, NULL, NULL, NULL, ?5, ?6)",
|
||
params![block_id, resource_id, text, section_path_json, line_range_json, locator_json],
|
||
)
|
||
.map_err(sqlite_error)?;
|
||
connection
|
||
.execute(
|
||
"INSERT INTO evidence_fts(block_id, text) VALUES(?1, ?2)",
|
||
params![block_id, text],
|
||
)
|
||
.map(|_| ())
|
||
.map_err(sqlite_error)
|
||
}
|
||
|
||
#[derive(Debug, Clone)]
|
||
struct MarkdownEvidenceBlock {
|
||
block_id: String,
|
||
text: String,
|
||
section_path: Vec<String>,
|
||
line_range: Value,
|
||
}
|
||
|
||
#[derive(Debug, Clone)]
|
||
struct MarkdownEvidenceSection {
|
||
section_id: String,
|
||
title: String,
|
||
path: Vec<String>,
|
||
line_start: u64,
|
||
parent_section_id: Option<String>,
|
||
}
|
||
|
||
fn markdown_evidence_blocks(document: &LocalSearchDocument) -> Vec<MarkdownEvidenceBlock> {
|
||
let mut headings: Vec<String> = Vec::new();
|
||
let mut blocks = Vec::new();
|
||
for (index, line) in document.raw_text.lines().enumerate() {
|
||
let line_number = (index + 1) as u64;
|
||
let trimmed = line.trim();
|
||
if trimmed.is_empty() {
|
||
continue;
|
||
}
|
||
if let Some((level, title)) = markdown_heading(trimmed) {
|
||
headings.truncate(level.saturating_sub(1));
|
||
headings.push(title);
|
||
}
|
||
blocks.push(MarkdownEvidenceBlock {
|
||
block_id: format!("{}#line{}", document.document_id, line_number),
|
||
text: trimmed.to_string(),
|
||
section_path: headings.clone(),
|
||
line_range: json!({"start": line_number, "end": line_number}),
|
||
});
|
||
}
|
||
blocks
|
||
}
|
||
|
||
fn markdown_evidence_sections(document: &LocalSearchDocument) -> Vec<MarkdownEvidenceSection> {
|
||
let mut headings: Vec<String> = Vec::new();
|
||
let mut sections = Vec::new();
|
||
for (index, line) in document.raw_text.lines().enumerate() {
|
||
let line_number = (index + 1) as u64;
|
||
let Some((level, title)) = markdown_heading(line.trim()) else {
|
||
continue;
|
||
};
|
||
headings.truncate(level.saturating_sub(1));
|
||
headings.push(title.clone());
|
||
let path = headings.clone();
|
||
let parent_section_id = if path.len() > 1 {
|
||
Some(format!(
|
||
"{}#section:{}",
|
||
document.document_id,
|
||
encode_local_id_segment(&path[..path.len() - 1].join("/"))
|
||
))
|
||
} else {
|
||
None
|
||
};
|
||
sections.push(MarkdownEvidenceSection {
|
||
section_id: format!(
|
||
"{}#section:{}",
|
||
document.document_id,
|
||
encode_local_id_segment(&path.join("/"))
|
||
),
|
||
title,
|
||
path,
|
||
line_start: line_number,
|
||
parent_section_id,
|
||
});
|
||
}
|
||
sections
|
||
}
|
||
|
||
fn markdown_heading(line: &str) -> Option<(usize, String)> {
|
||
let trimmed = line.trim_start();
|
||
let marker_count = trimmed.chars().take_while(|value| *value == '#').count();
|
||
if marker_count == 0 || marker_count > 6 {
|
||
return None;
|
||
}
|
||
let rest = trimmed.get(marker_count..)?.trim();
|
||
if rest.is_empty() {
|
||
return None;
|
||
}
|
||
Some((marker_count, rest.trim_matches('#').trim().to_string()))
|
||
}
|
||
|
||
fn insert_markdown_evidence_section(
|
||
connection: &Connection,
|
||
resource_id: &str,
|
||
section: &MarkdownEvidenceSection,
|
||
) -> Result<(), WebError> {
|
||
let path_json = serde_json::to_string(§ion.path).map_err(|error| {
|
||
WebError::bad_request_code(
|
||
"evidence_index_section_serialize_failed",
|
||
format!("section path 序列化失败: {error}"),
|
||
)
|
||
})?;
|
||
connection
|
||
.execute(
|
||
"INSERT OR REPLACE INTO evidence_section(section_id, resource_id, title, path_json, summary, page_start, page_end, parent_section_id) VALUES(?1, ?2, ?3, ?4, NULL, ?5, ?5, ?6)",
|
||
params![
|
||
section.section_id,
|
||
resource_id,
|
||
section.title,
|
||
path_json,
|
||
section.line_start,
|
||
section.parent_section_id,
|
||
],
|
||
)
|
||
.map(|_| ())
|
||
.map_err(sqlite_error)
|
||
}
|
||
|
||
fn insert_document_graph_edges(
|
||
connection: &Connection,
|
||
document: &LocalSearchDocument,
|
||
) -> Result<(), WebError> {
|
||
let source_block_id = first_markdown_evidence_block_id(document);
|
||
for target in &document.backlinks {
|
||
let to_id = markdown_reference_target_id(&document.path, target);
|
||
insert_evidence_edge(
|
||
connection,
|
||
&document.document_id,
|
||
&to_id,
|
||
"markdown_links_to",
|
||
&source_block_id,
|
||
)?;
|
||
}
|
||
for target in &document.resource_refs {
|
||
let to_id = resource_reference_target_id(&document.path, target);
|
||
insert_evidence_edge(
|
||
connection,
|
||
&document.document_id,
|
||
&to_id,
|
||
"resource_refers_to",
|
||
&source_block_id,
|
||
)?;
|
||
insert_evidence_edge(
|
||
connection,
|
||
&document.document_id,
|
||
&to_id,
|
||
"document_contains_resource",
|
||
&source_block_id,
|
||
)?;
|
||
}
|
||
for mention in markdown_mention_edges(document) {
|
||
insert_evidence_edge(
|
||
connection,
|
||
&document.document_id,
|
||
&mention.target_id,
|
||
"mentions",
|
||
&mention.source_block_id,
|
||
)?;
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
fn first_markdown_evidence_block_id(document: &LocalSearchDocument) -> String {
|
||
document
|
||
.raw_text
|
||
.lines()
|
||
.enumerate()
|
||
.find(|(_, line)| !line.trim().is_empty())
|
||
.map(|(index, _)| format!("{}#line{}", document.document_id, index + 1))
|
||
.unwrap_or_else(|| format!("{}#line1", document.document_id))
|
||
}
|
||
|
||
fn insert_evidence_edge(
|
||
connection: &Connection,
|
||
from_id: &str,
|
||
to_id: &str,
|
||
edge_type: &str,
|
||
source_block_id: &str,
|
||
) -> Result<(), WebError> {
|
||
let has_source_locator = connection
|
||
.query_row(
|
||
"SELECT 1 FROM evidence_block WHERE block_id = ?1 AND locator_json <> '' LIMIT 1",
|
||
params![source_block_id],
|
||
|_| Ok(true),
|
||
)
|
||
.optional()
|
||
.map_err(sqlite_error)?
|
||
.unwrap_or(false);
|
||
if !has_source_locator {
|
||
return Ok(());
|
||
}
|
||
let edge_id = format!(
|
||
"{}:{}:{}",
|
||
edge_type,
|
||
encode_local_id_segment(from_id),
|
||
encode_local_id_segment(to_id)
|
||
);
|
||
connection
|
||
.execute(
|
||
"INSERT OR REPLACE INTO evidence_edge(edge_id, from_id, to_id, edge_type, source_block_id, confidence, created_by) VALUES(?1, ?2, ?3, ?4, ?5, 1.0, 'deterministic_markdown')",
|
||
params![edge_id, from_id, to_id, edge_type, source_block_id],
|
||
)
|
||
.map(|_| ())
|
||
.map_err(sqlite_error)
|
||
}
|
||
|
||
fn markdown_reference_target_id(owner_path: &str, target: &str) -> String {
|
||
let target = target.trim();
|
||
if target.starts_with("local-md:") {
|
||
return target.to_string();
|
||
}
|
||
if is_markdown_reference(target) {
|
||
return format!(
|
||
"local-md:{}",
|
||
encode_local_id_segment(&normalize_local_reference_path(owner_path, target))
|
||
);
|
||
}
|
||
format!("markdown-title:{}", encode_local_id_segment(target))
|
||
}
|
||
|
||
fn resource_reference_target_id(owner_path: &str, target: &str) -> String {
|
||
format!(
|
||
"local-resource:{}",
|
||
encode_local_id_segment(&normalize_local_reference_path(owner_path, target))
|
||
)
|
||
}
|
||
|
||
#[derive(Debug, Clone)]
|
||
struct MarkdownMentionEdge {
|
||
target_id: String,
|
||
source_block_id: String,
|
||
}
|
||
|
||
fn markdown_mention_edges(document: &LocalSearchDocument) -> Vec<MarkdownMentionEdge> {
|
||
let mut seen = std::collections::BTreeSet::new();
|
||
let mut mentions = Vec::new();
|
||
for (line_index, line) in document.raw_text.lines().enumerate() {
|
||
let source_block_id = format!("{}#line{}", document.document_id, line_index + 1);
|
||
for mention in extract_line_mentions(line) {
|
||
let target_id = format!("entity:{}", encode_local_id_segment(&mention));
|
||
if seen.insert((target_id.clone(), source_block_id.clone())) {
|
||
mentions.push(MarkdownMentionEdge {
|
||
target_id,
|
||
source_block_id: source_block_id.clone(),
|
||
});
|
||
}
|
||
}
|
||
}
|
||
mentions
|
||
}
|
||
|
||
fn extract_line_mentions(line: &str) -> Vec<String> {
|
||
let chars = line.chars().collect::<Vec<_>>();
|
||
let mut mentions = Vec::new();
|
||
let mut index = 0;
|
||
while index < chars.len() {
|
||
if chars[index] != '@' {
|
||
index += 1;
|
||
continue;
|
||
}
|
||
if index > 0 && chars[index - 1].is_alphanumeric() {
|
||
index += 1;
|
||
continue;
|
||
}
|
||
let mut end = index + 1;
|
||
while end < chars.len()
|
||
&& (chars[end].is_alphanumeric()
|
||
|| chars[end] == '_'
|
||
|| chars[end] == '-'
|
||
|| chars[end] == '.')
|
||
{
|
||
end += 1;
|
||
}
|
||
if end > index + 1 {
|
||
let value = chars[index + 1..end].iter().collect::<String>();
|
||
mentions.push(value);
|
||
}
|
||
index = end.max(index + 1);
|
||
}
|
||
mentions.sort();
|
||
mentions.dedup();
|
||
mentions
|
||
}
|
||
|
||
fn markdown_locator(
|
||
index: &LocalSearchIndex,
|
||
document_id: &str,
|
||
path: &str,
|
||
block_id: &str,
|
||
section_path: Vec<String>,
|
||
line_range: Option<Value>,
|
||
) -> Value {
|
||
json!({
|
||
"schema": "mnote.evidence_locator.v1",
|
||
"rootUri": index.root_uri,
|
||
"ownerDocumentId": document_id,
|
||
"ownerDocumentPath": path,
|
||
"resourcePath": path,
|
||
"resourceKind": "markdown",
|
||
"sectionPath": section_path,
|
||
"lineRange": line_range,
|
||
"blockId": block_id,
|
||
"openAction": {
|
||
"actionType": "mnote.open_resource_locator",
|
||
"url": format!("/documents/{document_id}?sourceKind=local_folder&rootUri={}", encode_query_component(&index.root_uri)),
|
||
"params": {"resourcePath": path, "blockId": block_id, "lineRange": line_range}
|
||
}
|
||
})
|
||
}
|
||
|
||
fn evidence_sqlite_path(root_path: &Path) -> PathBuf {
|
||
root_path
|
||
.join(".mnote")
|
||
.join("index")
|
||
.join("evidence.sqlite")
|
||
}
|
||
|
||
fn count_evidence_blocks(path: &Path) -> Result<u64, WebError> {
|
||
let connection = Connection::open(path).map_err(|error| {
|
||
WebError::bad_request_code(
|
||
"evidence_index_open_failed",
|
||
format!("无法打开 evidence 索引 {}: {error}", path.display()),
|
||
)
|
||
})?;
|
||
connection
|
||
.query_row("SELECT COUNT(*) FROM evidence_block", [], |row| {
|
||
row.get::<_, u64>(0)
|
||
})
|
||
.map_err(sqlite_error)
|
||
}
|
||
|
||
#[allow(dead_code)]
|
||
#[derive(Debug, Clone, Default)]
|
||
pub(crate) struct LocalEvidenceSourceStatuses {
|
||
pub(crate) indexed_paths: BTreeSet<String>,
|
||
pub(crate) failed_paths: BTreeSet<String>,
|
||
}
|
||
|
||
#[allow(dead_code)]
|
||
pub(crate) fn local_evidence_source_statuses(
|
||
root_path: &Path,
|
||
) -> Result<LocalEvidenceSourceStatuses, WebError> {
|
||
let mut statuses = LocalEvidenceSourceStatuses::default();
|
||
let evidence_path = evidence_sqlite_path(root_path);
|
||
if evidence_path.exists() {
|
||
let connection = Connection::open(&evidence_path).map_err(|error| {
|
||
WebError::bad_request_code(
|
||
"evidence_index_open_failed",
|
||
format!(
|
||
"无法打开 evidence 索引 {}: {error}",
|
||
evidence_path.display()
|
||
),
|
||
)
|
||
})?;
|
||
let mut statement = connection
|
||
.prepare(
|
||
"SELECT DISTINCT source_root_relative_path \
|
||
FROM evidence_resource \
|
||
WHERE provider NOT IN ('resource', 'markdown')",
|
||
)
|
||
.map_err(sqlite_error)?;
|
||
let rows = statement
|
||
.query_map([], |row| row.get::<_, String>(0))
|
||
.map_err(sqlite_error)?;
|
||
for row in rows {
|
||
if let Ok(path) = row {
|
||
if !path.trim().is_empty() {
|
||
statuses.indexed_paths.insert(path);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if let Some(index) = read_local_search_index(root_path)? {
|
||
for resource in index.resources {
|
||
if matches!(resource.resource_type.as_str(), "pdf" | "office")
|
||
&& !statuses.indexed_paths.contains(&resource.path)
|
||
{
|
||
statuses.failed_paths.insert(resource.path);
|
||
}
|
||
}
|
||
}
|
||
Ok(statuses)
|
||
}
|
||
|
||
fn evidence_resource_kind_for_type(resource_type: &str) -> &'static str {
|
||
match resource_type {
|
||
"mindmap" => "mindmap",
|
||
"office" => "office",
|
||
"pdf" => "pdf",
|
||
"image" => "image",
|
||
"markdown" => "markdown",
|
||
_ => "raw_file",
|
||
}
|
||
}
|
||
|
||
fn evidence_resource_kind_for_path(path: &str) -> &'static str {
|
||
match Path::new(path)
|
||
.extension()
|
||
.and_then(|value| value.to_str())
|
||
.unwrap_or_default()
|
||
.to_ascii_lowercase()
|
||
.as_str()
|
||
{
|
||
"pdf" => "pdf",
|
||
"png" | "jpg" | "jpeg" | "webp" => "image",
|
||
"doc" | "docx" | "xls" | "xlsx" | "ppt" | "pptx" => "office",
|
||
"md" => "markdown",
|
||
"mm" | "mindmap" => "mindmap",
|
||
_ => "raw_file",
|
||
}
|
||
}
|
||
|
||
fn local_resource_path_from_document_id(document_id: &str) -> Option<String> {
|
||
document_id
|
||
.trim()
|
||
.strip_prefix("local-resource:")
|
||
.map(|value| value.replace("~2F", "/").replace("~2f", "/"))
|
||
.filter(|value| !value.trim().is_empty())
|
||
}
|
||
|
||
#[allow(dead_code)]
|
||
fn path_source_map_path(path: &str) -> Option<String> {
|
||
if let Some(stripped) = path.strip_suffix(".ocr.md") {
|
||
return Some(format!("{stripped}.source-map.json"));
|
||
}
|
||
if let Some(stripped) = path.strip_suffix(".parse.md") {
|
||
return Some(format!("{stripped}.source-map.json"));
|
||
}
|
||
None
|
||
}
|
||
|
||
fn is_local_evidence_sidecar_relative_path(relative_path: &str) -> bool {
|
||
let normalized = relative_path.trim().replace('\\', "/");
|
||
let path = Path::new(&normalized);
|
||
let Some(file_name) = path.file_name().and_then(|value| value.to_str()) else {
|
||
return false;
|
||
};
|
||
let Some(parent_name) = path
|
||
.parent()
|
||
.and_then(|value| value.file_name())
|
||
.and_then(|value| value.to_str())
|
||
else {
|
||
return false;
|
||
};
|
||
parent_name.ends_with(".ocr")
|
||
&& (file_name.ends_with(".parse.md") || file_name.ends_with(".source-map.json"))
|
||
}
|
||
|
||
fn normalize_local_reference_path(owner_path: &str, target: &str) -> String {
|
||
let target = target
|
||
.split('#')
|
||
.next()
|
||
.unwrap_or(target)
|
||
.split('?')
|
||
.next()
|
||
.unwrap_or(target)
|
||
.trim();
|
||
if target.starts_with('/') {
|
||
return target.trim_start_matches('/').replace('\\', "/");
|
||
}
|
||
let owner_parent = Path::new(owner_path)
|
||
.parent()
|
||
.unwrap_or_else(|| Path::new(""));
|
||
normalize_path_components(owner_parent.join(target))
|
||
}
|
||
|
||
fn normalize_path_components(path: PathBuf) -> String {
|
||
let mut parts = Vec::new();
|
||
for component in path.components() {
|
||
match component {
|
||
Component::Normal(value) => parts.push(value.to_string_lossy().to_string()),
|
||
Component::ParentDir => {
|
||
parts.pop();
|
||
}
|
||
Component::CurDir => {}
|
||
_ => {}
|
||
}
|
||
}
|
||
parts.join("/")
|
||
}
|
||
|
||
fn sqlite_error(error: rusqlite::Error) -> WebError {
|
||
WebError::bad_request_code(
|
||
"evidence_index_sqlite_error",
|
||
format!("evidence SQLite 错误: {error}"),
|
||
)
|
||
}
|
||
|
||
fn local_search_document_matches(
|
||
document: &LocalSearchDocument,
|
||
query: &str,
|
||
title_only: bool,
|
||
exact: bool,
|
||
) -> bool {
|
||
if query.is_empty() {
|
||
return false;
|
||
}
|
||
let haystack = if title_only {
|
||
normalize_search_text(&document.title)
|
||
} else {
|
||
normalize_search_text(&format!(
|
||
"{}\n{}\n{}\n{}",
|
||
document.title,
|
||
document.raw_text,
|
||
document.tags.join(" "),
|
||
document.resource_refs.join(" ")
|
||
))
|
||
};
|
||
if exact {
|
||
haystack.contains(query)
|
||
} else {
|
||
token_search_match(&haystack, query)
|
||
}
|
||
}
|
||
|
||
fn local_search_resource_matches(
|
||
resource: &LocalSearchResource,
|
||
query: &str,
|
||
title_only: bool,
|
||
exact: bool,
|
||
) -> bool {
|
||
if query.is_empty() {
|
||
return false;
|
||
}
|
||
let haystack = if title_only {
|
||
normalize_search_text(&resource.title)
|
||
} else {
|
||
normalize_search_text(&format!(
|
||
"{}\n{}\n{}",
|
||
resource.title, resource.path, resource.resource_type
|
||
))
|
||
};
|
||
if exact {
|
||
haystack.contains(query)
|
||
} else {
|
||
token_search_match(&haystack, query)
|
||
}
|
||
}
|
||
|
||
fn local_search_document_projection(
|
||
document: &LocalSearchDocument,
|
||
root_uri: &str,
|
||
query: &str,
|
||
) -> Value {
|
||
let hit = search_document_hit(document, query);
|
||
json!({
|
||
"id": document.document_id,
|
||
"documentId": document.document_id,
|
||
"title": document.title,
|
||
"path": document.path,
|
||
"resourceType": "markdown",
|
||
"sourceKind": "local_folder",
|
||
"rootUri": root_uri,
|
||
"snippet": hit.snippet,
|
||
"blockId": hit.block_id,
|
||
"lineRange": {
|
||
"start": hit.line_number,
|
||
"end": hit.line_number,
|
||
},
|
||
"tags": document.tags,
|
||
"backlinks": document.backlinks,
|
||
"resourceRefs": document.resource_refs,
|
||
"updatedAt": document.updated_at,
|
||
"publicPath": format!(
|
||
"/documents/{}?sourceKind=local_folder&rootUri={}",
|
||
document.document_id,
|
||
encode_query_component(root_uri),
|
||
)
|
||
})
|
||
}
|
||
|
||
fn local_search_resource_projection(resource: &LocalSearchResource, root_uri: &str) -> Value {
|
||
json!({
|
||
"id": resource.resource_id,
|
||
"documentId": resource.resource_id,
|
||
"title": resource.title,
|
||
"path": resource.path,
|
||
"resourceType": resource.resource_type,
|
||
"sourceKind": "local_folder",
|
||
"rootUri": root_uri,
|
||
"updatedAt": resource.updated_at,
|
||
"publicPath": format!(
|
||
"/?treeView=filetree&sourceKind=local_folder&rootUri={}",
|
||
encode_query_component(root_uri),
|
||
)
|
||
})
|
||
}
|
||
|
||
fn encode_query_component(value: &str) -> String {
|
||
let mut encoded = String::with_capacity(value.len());
|
||
for byte in value.as_bytes() {
|
||
if byte.is_ascii_alphanumeric() || matches!(byte, b'-' | b'_' | b'.' | b'~') {
|
||
encoded.push(*byte as char);
|
||
} else {
|
||
encoded.push_str(&format!("%{byte:02X}"));
|
||
}
|
||
}
|
||
encoded
|
||
}
|
||
|
||
fn local_recent_changes_projection(documents: &[LocalSearchDocument], root_uri: &str) -> Value {
|
||
let mut sorted = documents.iter().collect::<Vec<_>>();
|
||
sorted.sort_by(|left, right| right.updated_at.cmp(&left.updated_at));
|
||
Value::Array(
|
||
sorted
|
||
.into_iter()
|
||
.take(20)
|
||
.map(|document| {
|
||
json!({
|
||
"id": document.document_id,
|
||
"documentId": document.document_id,
|
||
"title": document.title,
|
||
"path": document.path,
|
||
"resourceType": "markdown",
|
||
"sourceKind": "local_folder",
|
||
"rootUri": root_uri,
|
||
"updatedAt": document.updated_at
|
||
})
|
||
})
|
||
.collect(),
|
||
)
|
||
}
|
||
|
||
fn normalized_document_targets(
|
||
document: &LocalSearchDocument,
|
||
) -> std::collections::BTreeSet<String> {
|
||
let mut values = std::collections::BTreeSet::new();
|
||
values.insert(normalize_search_text(&document.document_id));
|
||
values.insert(normalize_search_text(&document.path));
|
||
values.insert(normalize_search_text(&document.title));
|
||
if let Some(encoded) = document.document_id.strip_prefix("local-md:") {
|
||
values.insert(normalize_search_text(&encoded.replace("~2F", "/")));
|
||
}
|
||
values
|
||
}
|
||
|
||
fn extract_tags(markdown: &str) -> Vec<String> {
|
||
let Some(frontmatter) = split_frontmatter(markdown).0 else {
|
||
return Vec::new();
|
||
};
|
||
for line in frontmatter.lines() {
|
||
let trimmed = line.trim();
|
||
let Some(value) = trimmed
|
||
.strip_prefix("tags:")
|
||
.or_else(|| trimmed.strip_prefix("tag:"))
|
||
else {
|
||
continue;
|
||
};
|
||
return value
|
||
.trim()
|
||
.trim_matches(['[', ']'])
|
||
.split([',', ' '])
|
||
.map(|item| item.trim().trim_matches(['"', '\'']))
|
||
.filter(|item| !item.is_empty())
|
||
.map(ToOwned::to_owned)
|
||
.collect();
|
||
}
|
||
Vec::new()
|
||
}
|
||
|
||
fn extract_backlinks(markdown: &str) -> Vec<String> {
|
||
let mut values = extract_markdown_links(markdown)
|
||
.into_iter()
|
||
.filter(|target| is_markdown_reference(target))
|
||
.collect::<Vec<_>>();
|
||
let mut rest = markdown;
|
||
while let Some(start) = rest.find("[[") {
|
||
let after_start = &rest[start + 2..];
|
||
let Some(end) = after_start.find("]]") else {
|
||
break;
|
||
};
|
||
let link = after_start[..end].trim();
|
||
if !link.is_empty() {
|
||
values.push(link.to_string());
|
||
}
|
||
rest = &after_start[end + 2..];
|
||
}
|
||
values.sort();
|
||
values.dedup();
|
||
values
|
||
}
|
||
|
||
fn extract_resource_refs(markdown: &str) -> Vec<String> {
|
||
let mut values = markdown
|
||
.lines()
|
||
.filter_map(|line| parse_markdown_attachment_link(line.trim()))
|
||
.map(|(_, target)| target)
|
||
.chain(
|
||
extract_markdown_links(markdown)
|
||
.into_iter()
|
||
.filter(|target| {
|
||
!is_markdown_reference(target) && is_local_resource_reference(target)
|
||
}),
|
||
)
|
||
.collect::<Vec<_>>();
|
||
values.sort();
|
||
values.dedup();
|
||
values
|
||
}
|
||
|
||
fn extract_markdown_links(markdown: &str) -> Vec<String> {
|
||
let mut links = Vec::new();
|
||
let mut rest = markdown;
|
||
while let Some(label_end) = rest.find("](") {
|
||
let after = &rest[label_end + 2..];
|
||
let Some(target_end) = after.find(')') else {
|
||
break;
|
||
};
|
||
let target = after[..target_end].trim();
|
||
if !target.is_empty() {
|
||
links.push(target.to_string());
|
||
}
|
||
rest = &after[target_end + 1..];
|
||
}
|
||
links
|
||
}
|
||
|
||
fn is_markdown_reference(target: &str) -> bool {
|
||
let lower = target.to_lowercase();
|
||
lower.ends_with(".md") || lower.ends_with(".markdown") || lower.starts_with("local-md:")
|
||
}
|
||
|
||
fn is_local_resource_reference(target: &str) -> bool {
|
||
let lower = target.to_lowercase();
|
||
!lower.starts_with("http://")
|
||
&& !lower.starts_with("https://")
|
||
&& !lower.starts_with("mailto:")
|
||
&& !lower.starts_with('#')
|
||
&& Path::new(target).extension().is_some()
|
||
}
|
||
|
||
fn search_snippet(document: &LocalSearchDocument, query: &str) -> String {
|
||
search_document_hit(document, query).snippet
|
||
}
|
||
|
||
#[derive(Debug, Clone)]
|
||
struct SearchDocumentHit {
|
||
snippet: String,
|
||
line_number: usize,
|
||
block_id: String,
|
||
}
|
||
|
||
fn search_document_hit(document: &LocalSearchDocument, query: &str) -> SearchDocumentHit {
|
||
for (line_index, line) in document.raw_text.lines().enumerate() {
|
||
let trimmed = line.trim();
|
||
if trimmed.is_empty() {
|
||
continue;
|
||
}
|
||
if normalize_search_text(trimmed).contains(query) {
|
||
let line_number = line_index + 1;
|
||
return SearchDocumentHit {
|
||
snippet: trimmed.chars().take(180).collect(),
|
||
line_number,
|
||
block_id: format!("{}#line{}", document.document_id, line_number),
|
||
};
|
||
}
|
||
}
|
||
let line_number = document
|
||
.raw_text
|
||
.lines()
|
||
.enumerate()
|
||
.find(|(_, line)| !line.trim().is_empty())
|
||
.map(|(line_index, _)| line_index + 1)
|
||
.unwrap_or(1);
|
||
SearchDocumentHit {
|
||
snippet: document.raw_text.chars().take(180).collect(),
|
||
line_number,
|
||
block_id: format!("{}#line{}", document.document_id, line_number),
|
||
}
|
||
}
|
||
|
||
#[derive(Debug, Clone)]
|
||
struct EvidenceQueryTerm {
|
||
display: String,
|
||
normalized: String,
|
||
alternatives: Vec<String>,
|
||
}
|
||
|
||
#[derive(Debug, Clone)]
|
||
struct EvidenceTextMatch {
|
||
score: f64,
|
||
matched_terms: Vec<String>,
|
||
missing_terms: Vec<String>,
|
||
match_mode: String,
|
||
strong: bool,
|
||
}
|
||
|
||
impl EvidenceTextMatch {
|
||
fn into_match_info(self, rank: Option<u32>) -> EvidenceSearchMatchInfo {
|
||
EvidenceSearchMatchInfo {
|
||
rank,
|
||
matched_terms: self.matched_terms,
|
||
missing_terms: self.missing_terms,
|
||
match_mode: self.match_mode,
|
||
match_scope: "block".into(),
|
||
strong: self.strong,
|
||
}
|
||
}
|
||
}
|
||
|
||
fn score_evidence_text_match(text: &str, query: &str) -> Option<EvidenceTextMatch> {
|
||
let normalized_text = normalize_search_text(text);
|
||
let normalized_query = normalize_search_text(query);
|
||
if normalized_query.is_empty() {
|
||
return None;
|
||
}
|
||
let terms = evidence_query_terms(&normalized_query);
|
||
if terms.is_empty() {
|
||
return None;
|
||
}
|
||
let phrase_exact = normalized_text.contains(&normalized_query);
|
||
let mut matched_terms = Vec::new();
|
||
let mut missing_terms = Vec::new();
|
||
let mut exact_count = 0usize;
|
||
let mut partial_count = 0usize;
|
||
let mut positions = Vec::new();
|
||
|
||
for term in &terms {
|
||
if let Some(index) = normalized_text.find(&term.normalized) {
|
||
exact_count += 1;
|
||
positions.push(index);
|
||
push_unique(&mut matched_terms, term.display.clone());
|
||
continue;
|
||
}
|
||
let partial_matches = term
|
||
.alternatives
|
||
.iter()
|
||
.filter_map(|alternative| {
|
||
normalized_text
|
||
.find(alternative)
|
||
.map(|index| (alternative.clone(), index))
|
||
})
|
||
.collect::<Vec<_>>();
|
||
let partial_allowed = !partial_matches.is_empty()
|
||
&& if terms.len() > 1 {
|
||
true
|
||
} else {
|
||
partial_matches.len() >= 2
|
||
};
|
||
if partial_allowed {
|
||
partial_count += 1;
|
||
if let Some((_, index)) = partial_matches.first() {
|
||
positions.push(*index);
|
||
}
|
||
for (alternative, _) in partial_matches {
|
||
push_unique(&mut matched_terms, alternative);
|
||
}
|
||
push_unique(&mut missing_terms, term.display.clone());
|
||
} else {
|
||
return None;
|
||
}
|
||
}
|
||
|
||
let term_count = terms.len().max(1) as f64;
|
||
let coverage = (exact_count as f64 + partial_count as f64 * 0.45) / term_count;
|
||
let proximity = if positions.len() > 1 {
|
||
let min = positions.iter().min().copied().unwrap_or(0);
|
||
let max = positions.iter().max().copied().unwrap_or(min);
|
||
let span = max.saturating_sub(min);
|
||
if span <= 80 {
|
||
0.1
|
||
} else if span <= 240 {
|
||
0.05
|
||
} else {
|
||
0.0
|
||
}
|
||
} else {
|
||
0.0
|
||
};
|
||
let score = if phrase_exact {
|
||
1.0
|
||
} else {
|
||
(coverage * 0.85 + proximity).min(0.95)
|
||
};
|
||
let match_mode = if phrase_exact {
|
||
"exact_phrase"
|
||
} else if partial_count == 0 {
|
||
"all_terms"
|
||
} else {
|
||
"cjk_partial"
|
||
};
|
||
Some(EvidenceTextMatch {
|
||
score,
|
||
matched_terms,
|
||
missing_terms,
|
||
match_mode: match_mode.into(),
|
||
strong: phrase_exact || partial_count == 0 && exact_count == terms.len(),
|
||
})
|
||
}
|
||
|
||
fn evidence_query_terms(query: &str) -> Vec<EvidenceQueryTerm> {
|
||
split_search_query_tokens(query)
|
||
.into_iter()
|
||
.filter(|token| !token.is_empty())
|
||
.map(|token| {
|
||
let alternatives = cjk_token_bigrams(&token)
|
||
.into_iter()
|
||
.filter(|alternative| alternative != &token)
|
||
.collect::<Vec<_>>();
|
||
EvidenceQueryTerm {
|
||
display: token.clone(),
|
||
normalized: token,
|
||
alternatives,
|
||
}
|
||
})
|
||
.collect()
|
||
}
|
||
|
||
fn split_search_query_tokens(query: &str) -> Vec<String> {
|
||
let mut tokens = Vec::new();
|
||
let mut current = String::new();
|
||
for ch in query.chars() {
|
||
if ch.is_whitespace() || is_search_separator(ch) {
|
||
if !current.is_empty() {
|
||
tokens.push(std::mem::take(&mut current));
|
||
}
|
||
} else {
|
||
current.push(ch);
|
||
}
|
||
}
|
||
if !current.is_empty() {
|
||
tokens.push(current);
|
||
}
|
||
tokens
|
||
}
|
||
|
||
fn is_search_separator(ch: char) -> bool {
|
||
matches!(
|
||
ch,
|
||
',' | ';' | ':' | '，' | '；' | '：' | '。' | '、' | '(' | ')' | '[' | ']' | '{' | '}'
|
||
)
|
||
}
|
||
|
||
fn cjk_token_bigrams(token: &str) -> Vec<String> {
|
||
let chars = token.chars().collect::<Vec<_>>();
|
||
if chars.len() < 3 || !chars.iter().any(|ch| is_cjk_char(*ch)) {
|
||
return Vec::new();
|
||
}
|
||
chars
|
||
.windows(2)
|
||
.filter_map(|window| {
|
||
if window.iter().any(|ch| is_cjk_stop_char(*ch)) {
|
||
return None;
|
||
}
|
||
Some(window.iter().collect::<String>())
|
||
})
|
||
.collect()
|
||
}
|
||
|
||
fn is_cjk_char(ch: char) -> bool {
|
||
matches!(
|
||
ch as u32,
|
||
0x3400..=0x4DBF | 0x4E00..=0x9FFF | 0xF900..=0xFAFF
|
||
)
|
||
}
|
||
|
||
fn is_cjk_stop_char(ch: char) -> bool {
|
||
matches!(
|
||
ch,
|
||
'的' | '了' | '和' | '与' | '及' | '在' | '是' | '为' | '对' | '中'
|
||
)
|
||
}
|
||
|
||
fn push_unique(values: &mut Vec<String>, value: String) {
|
||
if !value.is_empty() && !values.iter().any(|existing| existing == &value) {
|
||
values.push(value);
|
||
}
|
||
}
|
||
|
||
fn ocr_search_snippet(body: &str, query: &str) -> String {
|
||
let normalized_body = body.replace('\n', " ");
|
||
let normalized_query = query.trim();
|
||
if normalized_query.is_empty() {
|
||
return normalized_body.chars().take(160).collect();
|
||
}
|
||
let lower = normalized_body.to_ascii_lowercase();
|
||
let lower_query = normalized_query.to_ascii_lowercase();
|
||
if let Some(byte_index) = lower.find(&lower_query) {
|
||
let start = normalized_body[..byte_index]
|
||
.char_indices()
|
||
.rev()
|
||
.nth(40)
|
||
.map(|(idx, _)| idx)
|
||
.unwrap_or(0);
|
||
normalized_body[start..].chars().take(160).collect()
|
||
} else if let Some(byte_index) = fuzzy_search_start_byte(&normalized_body, normalized_query) {
|
||
let start = normalized_body[..byte_index]
|
||
.char_indices()
|
||
.rev()
|
||
.nth(40)
|
||
.map(|(idx, _)| idx)
|
||
.unwrap_or(0);
|
||
normalized_body[start..].chars().take(180).collect()
|
||
} else {
|
||
normalized_body.chars().take(160).collect()
|
||
}
|
||
}
|
||
|
||
fn ocr_search_snippet_for_terms(body: &str, query: &str, terms: &[String]) -> String {
|
||
let normalized_body = body.replace('\n', " ");
|
||
let normalized_query = query.trim();
|
||
if !normalized_query.is_empty() {
|
||
let lower = normalized_body.to_lowercase();
|
||
let lower_query = normalized_query.to_lowercase();
|
||
if let Some(byte_index) = lower.find(&lower_query) {
|
||
return snippet_from_byte_index(&normalized_body, byte_index, 180);
|
||
}
|
||
}
|
||
let lower = normalized_body.to_lowercase();
|
||
for term in terms {
|
||
let term = term.trim().to_lowercase();
|
||
if term.is_empty() {
|
||
continue;
|
||
}
|
||
if let Some(byte_index) = lower.find(&term) {
|
||
return snippet_from_byte_index(&normalized_body, byte_index, 180);
|
||
}
|
||
}
|
||
ocr_search_snippet(body, query)
|
||
}
|
||
|
||
fn snippet_from_byte_index(body: &str, byte_index: usize, len: usize) -> String {
|
||
let start = body[..byte_index]
|
||
.char_indices()
|
||
.rev()
|
||
.nth(40)
|
||
.map(|(idx, _)| idx)
|
||
.unwrap_or(0);
|
||
body[start..].chars().take(len).collect()
|
||
}
|
||
|
||
fn fuzzy_search_start_byte(haystack: &str, query: &str) -> Option<usize> {
|
||
if query.is_empty() {
|
||
return None;
|
||
}
|
||
let query_chars = query
|
||
.chars()
|
||
.filter(|ch| !ch.is_whitespace())
|
||
.collect::<Vec<_>>();
|
||
if query_chars.is_empty() {
|
||
return None;
|
||
}
|
||
let haystack_chars = haystack.char_indices().collect::<Vec<_>>();
|
||
for (start_index, (byte_index, ch)) in haystack_chars.iter().enumerate() {
|
||
if ch != &query_chars[0] {
|
||
continue;
|
||
}
|
||
let mut query_index = 1usize;
|
||
for (_, next_ch) in haystack_chars.iter().skip(start_index + 1) {
|
||
if next_ch.is_whitespace() {
|
||
continue;
|
||
}
|
||
if query_index < query_chars.len() && next_ch == &query_chars[query_index] {
|
||
query_index += 1;
|
||
if query_index >= query_chars.len() {
|
||
return Some(*byte_index);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
None
|
||
}
|
||
|
||
fn token_search_match(haystack: &str, query: &str) -> bool {
|
||
score_evidence_text_match(haystack, query).is_some()
|
||
}
|
||
|
||
fn is_markdown_path(path: &Path) -> bool {
|
||
path.extension()
|
||
.and_then(|value| value.to_str())
|
||
.map(|value| value.eq_ignore_ascii_case("md") || value.eq_ignore_ascii_case("markdown"))
|
||
.unwrap_or(false)
|
||
}
|
||
|
||
fn resource_type_from_path(path: &Path) -> Option<&'static str> {
|
||
let file_name = path
|
||
.file_name()
|
||
.and_then(|value| value.to_str())
|
||
.unwrap_or_default()
|
||
.to_lowercase();
|
||
if file_name.ends_with(".mindmap.json") {
|
||
return Some("mindmap");
|
||
}
|
||
let extension = path
|
||
.extension()
|
||
.and_then(|value| value.to_str())
|
||
.unwrap_or_default()
|
||
.to_lowercase();
|
||
match extension.as_str() {
|
||
"png" | "jpg" | "jpeg" | "webp" | "bmp" | "gif" | "tif" | "tiff" | "svg" => Some("image"),
|
||
"pdf" => Some("pdf"),
|
||
"doc" | "docx" | "odt" | "ppt" | "pptx" | "odp" | "xls" | "xlsx" | "ods" => Some("office"),
|
||
_ => None,
|
||
}
|
||
}
|
||
|
||
fn normalize_search_text(value: &str) -> String {
|
||
value.trim().to_lowercase()
|
||
}
|
||
|
||
fn now_ms() -> u128 {
|
||
SystemTime::now()
|
||
.duration_since(UNIX_EPOCH)
|
||
.map(|value| value.as_millis())
|
||
.unwrap_or_default()
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::*;
|
||
use control_plane::SqliteControlPlaneStore;
|
||
use std::path::PathBuf;
|
||
use std::sync::{Mutex, OnceLock};
|
||
|
||
fn env_lock() -> &'static Mutex<()> {
|
||
static LOCK: OnceLock<Mutex<()>> = OnceLock::new();
|
||
LOCK.get_or_init(|| Mutex::new(()))
|
||
}
|
||
|
||
fn temp_root(name: &str) -> PathBuf {
|
||
let root = std::env::temp_dir().join(format!("{name}-{}", std::process::id()));
|
||
let _ = fs::remove_dir_all(&root);
|
||
fs::create_dir_all(root.join("docs")).expect("create root");
|
||
root
|
||
}
|
||
|
||
#[test]
|
||
fn local_search_index_extracts_backlinks_resource_refs_and_tags() {
|
||
let root = temp_root("mnote-local-search-index");
|
||
fs::write(
|
||
root.join("README.md"),
|
||
"---\ntitle: Home\ntags: [alpha, beta]\n---\n# Home\nSee [[Daily]] and [Child](docs/child.md).\n[Spec](assets/spec.pdf)\n[Map](maps/idea.mindmap.json)\n[Sheet](office/report.xlsx)\n\n",
|
||
)
|
||
.expect("write readme");
|
||
fs::write(
|
||
root.join("docs").join("child.md"),
|
||
"---\nmnote_id: child-page\ntitle: Child\n---\nChild body with alpha and office.xlsx\n",
|
||
)
|
||
.expect("write child");
|
||
fs::create_dir_all(root.join("maps")).expect("create maps");
|
||
fs::create_dir_all(root.join("office")).expect("create office");
|
||
fs::write(
|
||
root.join("maps").join("idea.mindmap.json"),
|
||
r#"{"title":"Idea Map","nodes":[]}"#,
|
||
)
|
||
.expect("write mindmap");
|
||
fs::create_dir_all(root.join("assets")).expect("create assets");
|
||
fs::write(root.join("assets").join("spec.pdf"), b"%PDF-1.4\n").expect("write pdf");
|
||
fs::write(root.join("assets").join("diagram.png"), b"png").expect("write image");
|
||
fs::write(root.join("office").join("report.xlsx"), b"office bytes").expect("write office");
|
||
write_local_index_settings(&root, &[String::from(".")], None, None, None, None)
|
||
.expect("settings");
|
||
|
||
let projection = query_local_search_index(
|
||
&root,
|
||
&format!("file://{}", root.display()),
|
||
"local-ws-test",
|
||
"alpha",
|
||
None,
|
||
10,
|
||
false,
|
||
false,
|
||
false,
|
||
)
|
||
.expect("projection");
|
||
let results = projection["results"].as_array().expect("results");
|
||
let home = results
|
||
.iter()
|
||
.find(|item| item["documentId"].as_str() == Some("local-md:README.md"))
|
||
.expect("home result");
|
||
assert!(home["tags"]
|
||
.as_array()
|
||
.unwrap()
|
||
.iter()
|
||
.any(|tag| tag.as_str() == Some("alpha")));
|
||
assert!(home["backlinks"]
|
||
.as_array()
|
||
.unwrap()
|
||
.iter()
|
||
.any(|link| link.as_str() == Some("Daily")));
|
||
assert!(home["backlinks"]
|
||
.as_array()
|
||
.unwrap()
|
||
.iter()
|
||
.any(|link| link.as_str() == Some("docs/child.md")));
|
||
assert!(home["resourceRefs"]
|
||
.as_array()
|
||
.unwrap()
|
||
.iter()
|
||
.any(|reference| reference.as_str() == Some("assets/spec.pdf")));
|
||
assert!(home["resourceRefs"]
|
||
.as_array()
|
||
.unwrap()
|
||
.iter()
|
||
.any(|reference| reference.as_str() == Some("maps/idea.mindmap.json")));
|
||
assert!(home["resourceRefs"]
|
||
.as_array()
|
||
.unwrap()
|
||
.iter()
|
||
.any(|reference| reference.as_str() == Some("office/report.xlsx")));
|
||
assert!(home["publicPath"]
|
||
.as_str()
|
||
.is_some_and(|path| path.starts_with(
|
||
"/documents/local-md:README.md?sourceKind=local_folder&rootUri=file%3A%2F%2F"
|
||
)));
|
||
let evidence_db = root.join(".mnote").join("index").join("evidence.sqlite");
|
||
let connection = Connection::open(&evidence_db).expect("open evidence sqlite");
|
||
let markdown_edge_count: i64 = connection
|
||
.query_row(
|
||
"SELECT COUNT(*) FROM evidence_edge WHERE edge_type = 'markdown_links_to'",
|
||
[],
|
||
|row| row.get(0),
|
||
)
|
||
.expect("markdown edge count");
|
||
let resource_edge_count: i64 = connection
|
||
.query_row(
|
||
"SELECT COUNT(*) FROM evidence_edge WHERE edge_type = 'resource_refers_to'",
|
||
[],
|
||
|row| row.get(0),
|
||
)
|
||
.expect("resource edge count");
|
||
let contains_edge_count: i64 = connection
|
||
.query_row(
|
||
"SELECT COUNT(*) FROM evidence_edge WHERE edge_type = 'document_contains_resource'",
|
||
[],
|
||
|row| row.get(0),
|
||
)
|
||
.expect("contains edge count");
|
||
assert!(markdown_edge_count >= 2);
|
||
assert!(resource_edge_count >= 4);
|
||
assert!(contains_edge_count >= 4);
|
||
|
||
// 含 mnote_id 的 Markdown 仍返回路径型 documentId，不应出现 local-mdid:
|
||
let child_search = query_local_search_index(
|
||
&root,
|
||
&format!("file://{}", root.display()),
|
||
"local-ws-test",
|
||
"office.xlsx",
|
||
None,
|
||
10,
|
||
false,
|
||
false,
|
||
false,
|
||
)
|
||
.expect("child search");
|
||
let child_result = child_search["results"]
|
||
.as_array()
|
||
.unwrap()
|
||
.iter()
|
||
.find(|item| item["path"].as_str() == Some("docs/child.md"))
|
||
.expect("child in search results");
|
||
assert_eq!(
|
||
child_result["documentId"].as_str(),
|
||
Some("local-md:docs~2Fchild.md")
|
||
);
|
||
assert_ne!(
|
||
child_result["documentId"].as_str(),
|
||
Some("local-mdid:child-page")
|
||
);
|
||
|
||
assert!(root
|
||
.join(".mnote")
|
||
.join("index")
|
||
.join("search-index.json")
|
||
.exists());
|
||
let mindmap_projection = query_local_search_index(
|
||
&root,
|
||
&format!("file://{}", root.display()),
|
||
"local-ws-test",
|
||
"idea.mindmap",
|
||
None,
|
||
10,
|
||
false,
|
||
false,
|
||
false,
|
||
)
|
||
.expect("mindmap projection");
|
||
assert!(mindmap_projection["results"]
|
||
.as_array()
|
||
.unwrap()
|
||
.iter()
|
||
.any(|item| item["resourceType"].as_str() == Some("mindmap")
|
||
&& item["path"].as_str() == Some("maps/idea.mindmap.json")
|
||
&& item["publicPath"]
|
||
.as_str()
|
||
.is_some_and(|path| path
|
||
.starts_with("/?treeView=filetree&sourceKind=local_folder&rootUri="))
|
||
&& item["publicPath"]
|
||
.as_str()
|
||
.is_some_and(|path| !path.starts_with("/tree?"))));
|
||
let office_projection = query_local_search_index(
|
||
&root,
|
||
&format!("file://{}", root.display()),
|
||
"local-ws-test",
|
||
"report.xlsx",
|
||
None,
|
||
10,
|
||
false,
|
||
false,
|
||
false,
|
||
)
|
||
.expect("office projection");
|
||
assert!(office_projection["results"]
|
||
.as_array()
|
||
.unwrap()
|
||
.iter()
|
||
.any(|item| item["resourceType"].as_str() == Some("office")
|
||
&& item["path"].as_str() == Some("office/report.xlsx")));
|
||
let pdf_projection = query_local_search_index(
|
||
&root,
|
||
&format!("file://{}", root.display()),
|
||
"local-ws-test",
|
||
"spec.pdf",
|
||
None,
|
||
10,
|
||
false,
|
||
false,
|
||
false,
|
||
)
|
||
.expect("pdf projection");
|
||
assert!(pdf_projection["results"]
|
||
.as_array()
|
||
.unwrap()
|
||
.iter()
|
||
.any(|item| item["resourceType"].as_str() == Some("pdf")
|
||
&& item["path"].as_str() == Some("assets/spec.pdf")));
|
||
let image_projection = query_local_search_index(
|
||
&root,
|
||
&format!("file://{}", root.display()),
|
||
"local-ws-test",
|
||
"diagram.png",
|
||
None,
|
||
10,
|
||
false,
|
||
false,
|
||
false,
|
||
)
|
||
.expect("image projection");
|
||
assert!(image_projection["results"]
|
||
.as_array()
|
||
.unwrap()
|
||
.iter()
|
||
.any(|item| item["resourceType"].as_str() == Some("image")
|
||
&& item["path"].as_str() == Some("assets/diagram.png")));
|
||
let _ = fs::remove_dir_all(&root);
|
||
}
|
||
|
||
#[test]
|
||
fn local_search_two_char_cjk_query_requires_real_match() {
|
||
assert!(score_evidence_text_match("13. N -甲基吗啉 N -氧化物", "吗啉").is_some());
|
||
assert!(score_evidence_text_match("Scope Alpha SOURCE SCOPE RAG", "吗啉").is_none());
|
||
}
|
||
|
||
#[test]
|
||
fn local_index_settings_restricts_search_and_evidence_scope() {
|
||
let root = temp_root("mnote-local-index-settings-scope");
|
||
fs::create_dir_all(root.join("docs").join("included")).expect("create included");
|
||
fs::create_dir_all(root.join("docs").join("excluded")).expect("create excluded");
|
||
fs::write(
|
||
root.join("docs").join("included").join("keep.md"),
|
||
"# Keep\nScopedToken\n",
|
||
)
|
||
.expect("write included");
|
||
fs::write(
|
||
root.join("docs").join("excluded").join("skip.md"),
|
||
"# Skip\nExcludedToken\n",
|
||
)
|
||
.expect("write excluded");
|
||
let root_uri = format!("file://{}", root.display());
|
||
write_local_index_settings(
|
||
&root,
|
||
&[String::from("docs/included")],
|
||
None,
|
||
None,
|
||
None,
|
||
None,
|
||
)
|
||
.expect("settings");
|
||
refresh_local_search_index(&root, &root_uri, "local-ws-scope").expect("refresh");
|
||
|
||
let included = query_local_search_index(
|
||
&root,
|
||
&root_uri,
|
||
"local-ws-scope",
|
||
"ScopedToken",
|
||
None,
|
||
10,
|
||
false,
|
||
false,
|
||
false,
|
||
)
|
||
.expect("included query");
|
||
assert_eq!(included["results"].as_array().unwrap().len(), 1);
|
||
let excluded = query_local_search_index(
|
||
&root,
|
||
&root_uri,
|
||
"local-ws-scope",
|
||
"ExcludedToken",
|
||
None,
|
||
10,
|
||
false,
|
||
false,
|
||
false,
|
||
)
|
||
.expect("excluded query");
|
||
assert_eq!(excluded["results"].as_array().unwrap().len(), 0);
|
||
let evidence = query_evidence_sqlite_results(&root, "ScopedToken", None, 10)
|
||
.expect("evidence query")
|
||
.expect("evidence index");
|
||
assert_eq!(evidence.len(), 1);
|
||
let status = local_index_status(&root, &root_uri, "local-ws-scope").expect("status");
|
||
assert_eq!(
|
||
status["settings"]["includePaths"].as_array().unwrap()[0].as_str(),
|
||
Some("docs/included")
|
||
);
|
||
assert_eq!(status["documentCount"].as_u64(), Some(1));
|
||
let _ = fs::remove_dir_all(&root);
|
||
}
|
||
|
||
#[test]
|
||
fn local_index_settings_accepts_absolute_path_under_root_as_frozen_scope() {
|
||
let root = temp_root("mnote-local-index-settings-absolute");
|
||
fs::create_dir_all(root.join("docs").join("absolute")).expect("create absolute dir");
|
||
let absolute_scope = root.join("docs").join("absolute");
|
||
|
||
let settings = write_local_index_settings(
|
||
&root,
|
||
&[absolute_scope.to_string_lossy().to_string()],
|
||
None,
|
||
None,
|
||
None,
|
||
None,
|
||
)
|
||
.expect("absolute scope under root");
|
||
|
||
assert_eq!(settings.include_paths, vec![String::from("docs/absolute")]);
|
||
let _ = fs::remove_dir_all(&root);
|
||
}
|
||
|
||
#[test]
|
||
fn user_local_index_empty_scope_deletes_index_files() {
|
||
let root = temp_root("mnote-local-index-empty-delete");
|
||
fs::write(
|
||
root.join("docs").join("keep.md"),
|
||
"# Keep\nDeleteIndexToken\n",
|
||
)
|
||
.expect("write doc");
|
||
let root_uri = format!("file://{}", root.display());
|
||
let workspace_id = "local-ws-empty-delete";
|
||
let store = SqliteControlPlaneStore::in_memory().expect("init control plane");
|
||
|
||
write_user_local_index_settings(
|
||
&store,
|
||
"alice",
|
||
workspace_id,
|
||
&root,
|
||
&[String::from("docs")],
|
||
Some("manual"),
|
||
Some("02:00"),
|
||
None,
|
||
Some(false),
|
||
)
|
||
.expect("write indexed scope");
|
||
let effective = effective_local_index_settings_for_root(&store, workspace_id, &root)
|
||
.expect("effective indexed");
|
||
refresh_local_search_index_with_settings(&root, &root_uri, workspace_id, &effective)
|
||
.expect("refresh indexed");
|
||
assert!(root.join(".mnote/index/search-index.json").exists());
|
||
assert!(root.join(".mnote/index/evidence.sqlite").exists());
|
||
|
||
write_user_local_index_settings(
|
||
&store,
|
||
"alice",
|
||
workspace_id,
|
||
&root,
|
||
&[],
|
||
Some("manual"),
|
||
Some("02:00"),
|
||
None,
|
||
Some(false),
|
||
)
|
||
.expect("delete indexed scopes");
|
||
let empty_effective = effective_local_index_settings_for_root(&store, workspace_id, &root)
|
||
.expect("effective empty");
|
||
assert!(empty_effective.include_paths.is_empty());
|
||
refresh_local_search_index_with_settings(&root, &root_uri, workspace_id, &empty_effective)
|
||
.expect("clear index files");
|
||
|
||
assert!(!root.join(".mnote/index/search-index.json").exists());
|
||
assert!(!root.join(".mnote/index/evidence.sqlite").exists());
|
||
let status = local_index_status_with_settings(
|
||
&root,
|
||
&root_uri,
|
||
workspace_id,
|
||
&empty_effective,
|
||
&empty_effective,
|
||
)
|
||
.expect("status");
|
||
assert_eq!(status["cacheMatchesSettings"].as_bool(), Some(true));
|
||
let _ = fs::remove_dir_all(&root);
|
||
}
|
||
|
||
#[test]
|
||
fn local_index_settings_rejects_escape_and_internal_cache_scope() {
|
||
let root = temp_root("mnote-local-index-settings-escape");
|
||
let escape = write_local_index_settings(
|
||
&root,
|
||
&[String::from("../outside")],
|
||
None,
|
||
None,
|
||
None,
|
||
None,
|
||
)
|
||
.expect_err("escape should fail");
|
||
assert_eq!(escape.code(), "local_search_index_path_escape");
|
||
let internal = write_local_index_settings(
|
||
&root,
|
||
&[String::from(".mnote/index")],
|
||
None,
|
||
None,
|
||
None,
|
||
None,
|
||
)
|
||
.expect_err("internal cache should fail");
|
||
assert_eq!(internal.code(), "local_index_scope_reserved");
|
||
let _ = fs::remove_dir_all(&root);
|
||
}
|
||
|
||
#[test]
|
||
fn local_index_settings_defaults_and_schedule_are_persisted() {
|
||
let root = temp_root("mnote-local-index-settings-schedule");
|
||
let root_uri = format!("file://{}", root.display());
|
||
let initial_status =
|
||
local_index_status(&root, &root_uri, "local-ws-schedule").expect("initial status");
|
||
assert_eq!(
|
||
initial_status["settings"]["scheduleMode"].as_str(),
|
||
Some("daily")
|
||
);
|
||
assert_eq!(
|
||
initial_status["settings"]["scheduleTime"].as_str(),
|
||
Some("02:00")
|
||
);
|
||
assert_eq!(
|
||
initial_status["settings"]["runOnChange"].as_bool(),
|
||
Some(false)
|
||
);
|
||
assert_eq!(
|
||
initial_status["settings"]["includePaths"]
|
||
.as_array()
|
||
.map(Vec::len),
|
||
Some(0),
|
||
"默认不应索引工作区根目录；用户新增范围后才开始索引"
|
||
);
|
||
assert_eq!(initial_status["cacheMatchesSettings"].as_bool(), Some(true));
|
||
|
||
let settings = write_local_index_settings(
|
||
&root,
|
||
&[String::from("docs")],
|
||
Some("once"),
|
||
Some("08:30"),
|
||
Some("2026-06-04"),
|
||
Some(true),
|
||
)
|
||
.expect("write schedule settings");
|
||
assert_eq!(settings.include_paths, vec![String::from("docs")]);
|
||
assert_eq!(settings.schedule_mode, "once");
|
||
assert_eq!(settings.schedule_time, "08:30");
|
||
assert_eq!(settings.schedule_date.as_deref(), Some("2026-06-04"));
|
||
assert!(settings.run_on_change);
|
||
|
||
let status = local_index_status(&root, &root_uri, "local-ws-schedule").expect("status");
|
||
assert_eq!(status["settings"]["scheduleMode"].as_str(), Some("once"));
|
||
assert_eq!(status["settings"]["scheduleTime"].as_str(), Some("08:30"));
|
||
assert_eq!(
|
||
status["settings"]["scheduleDate"].as_str(),
|
||
Some("2026-06-04")
|
||
);
|
||
assert_eq!(status["settings"]["runOnChange"].as_bool(), Some(true));
|
||
let _ = fs::remove_dir_all(&root);
|
||
}
|
||
|
||
#[test]
|
||
fn local_index_settings_rejects_invalid_schedule() {
|
||
let root = temp_root("mnote-local-index-settings-invalid-schedule");
|
||
let invalid_mode = write_local_index_settings(
|
||
&root,
|
||
&[String::from(".")],
|
||
Some("weekly"),
|
||
None,
|
||
None,
|
||
None,
|
||
)
|
||
.expect_err("invalid mode should fail");
|
||
assert_eq!(invalid_mode.code(), "local_index_schedule_mode_invalid");
|
||
|
||
let invalid_time = write_local_index_settings(
|
||
&root,
|
||
&[String::from(".")],
|
||
Some("daily"),
|
||
Some("24:00"),
|
||
None,
|
||
None,
|
||
)
|
||
.expect_err("invalid time should fail");
|
||
assert_eq!(invalid_time.code(), "local_index_schedule_time_invalid");
|
||
|
||
let invalid_date = write_local_index_settings(
|
||
&root,
|
||
&[String::from(".")],
|
||
Some("once"),
|
||
Some("02:00"),
|
||
Some("2026-13-01"),
|
||
None,
|
||
)
|
||
.expect_err("invalid date should fail");
|
||
assert_eq!(invalid_date.code(), "local_index_schedule_date_invalid");
|
||
let _ = fs::remove_dir_all(&root);
|
||
}
|
||
|
||
#[test]
|
||
fn local_index_schedule_due_respects_modes() {
|
||
let today = OffsetDateTime::now_local()
|
||
.unwrap_or_else(|_| OffsetDateTime::now_utc())
|
||
.date();
|
||
let yesterday = today - Duration::days(1);
|
||
let tomorrow = today + Duration::days(1);
|
||
let yesterday = format!(
|
||
"{:04}-{:02}-{:02}",
|
||
yesterday.year(),
|
||
u8::from(yesterday.month()),
|
||
yesterday.day()
|
||
);
|
||
let tomorrow = format!(
|
||
"{:04}-{:02}-{:02}",
|
||
tomorrow.year(),
|
||
u8::from(tomorrow.month()),
|
||
tomorrow.day()
|
||
);
|
||
let mut settings = default_local_index_settings();
|
||
|
||
settings.schedule_mode = "manual".to_string();
|
||
assert!(!local_index_schedule_is_due(&settings, 0));
|
||
|
||
settings.schedule_mode = "once".to_string();
|
||
settings.schedule_time = "00:00".to_string();
|
||
settings.schedule_date = Some(yesterday);
|
||
assert!(local_index_schedule_is_due(&settings, 0));
|
||
|
||
settings.schedule_date = Some(tomorrow);
|
||
assert!(!local_index_schedule_is_due(&settings, 0));
|
||
|
||
settings.schedule_mode = "daily".to_string();
|
||
settings.schedule_date = None;
|
||
settings.schedule_time = "00:00".to_string();
|
||
assert!(local_index_schedule_is_due(&settings, 0));
|
||
assert!(!local_index_schedule_is_due(&settings, now_ms()));
|
||
}
|
||
|
||
#[test]
|
||
fn multi_user_local_index_settings_share_one_cache_and_filter_results() {
|
||
let root = temp_root("mnote-local-index-multi-user");
|
||
fs::create_dir_all(root.join("docs").join("alice")).expect("create alice dir");
|
||
fs::create_dir_all(root.join("docs").join("bob")).expect("create bob dir");
|
||
fs::write(
|
||
root.join("docs").join("alice").join("keep.md"),
|
||
"# Alice\nAliceScopedToken\n",
|
||
)
|
||
.expect("write alice doc");
|
||
fs::write(
|
||
root.join("docs").join("bob").join("keep.md"),
|
||
"# Bob\nBobScopedToken\n",
|
||
)
|
||
.expect("write bob doc");
|
||
let root_uri = format!("file://{}", root.display());
|
||
let workspace_id = "local-ws-multi-user";
|
||
let store = SqliteControlPlaneStore::in_memory().expect("init control plane");
|
||
|
||
write_user_local_index_settings(
|
||
&store,
|
||
"alice",
|
||
workspace_id,
|
||
&root,
|
||
&[String::from("docs/alice")],
|
||
Some("manual"),
|
||
Some("02:00"),
|
||
None,
|
||
Some(false),
|
||
)
|
||
.expect("write alice settings");
|
||
write_user_local_index_settings(
|
||
&store,
|
||
"bob",
|
||
workspace_id,
|
||
&root,
|
||
&[String::from("docs/bob")],
|
||
Some("manual"),
|
||
Some("02:00"),
|
||
None,
|
||
Some(true),
|
||
)
|
||
.expect("write bob settings");
|
||
|
||
let sqlite_records = store
|
||
.list_user_ui_preferences_for_scope(
|
||
Some(workspace_id),
|
||
Some(LOCAL_INDEX_SOURCE_KIND),
|
||
LOCAL_INDEX_SETTINGS_SCOPE_KIND,
|
||
&local_index_scope_id(&root),
|
||
LOCAL_INDEX_SETTINGS_KEY,
|
||
)
|
||
.expect("read raw sqlite preference rows");
|
||
assert_eq!(sqlite_records.len(), 2);
|
||
let alice_sqlite_record = sqlite_records
|
||
.iter()
|
||
.find(|record| record.user_id == "alice")
|
||
.expect("alice sqlite preference row");
|
||
let alice_sqlite_value: serde_json::Value =
|
||
serde_json::from_str(&alice_sqlite_record.value_json).expect("alice sqlite json");
|
||
assert_eq!(
|
||
alice_sqlite_value["includePaths"],
|
||
serde_json::json!(["docs/alice"]),
|
||
"索引范围必须写入 SQLite user_ui_preferences.value_json"
|
||
);
|
||
|
||
let alice_settings =
|
||
read_user_local_index_settings(&store, "alice", workspace_id, &root).expect("alice");
|
||
let bob_settings =
|
||
read_user_local_index_settings(&store, "bob", workspace_id, &root).expect("bob");
|
||
let effective = effective_local_index_settings_for_root(&store, workspace_id, &root)
|
||
.expect("effective");
|
||
|
||
assert_eq!(
|
||
effective.include_paths,
|
||
vec![String::from("docs/alice"), String::from("docs/bob")]
|
||
);
|
||
assert!(effective.run_on_change);
|
||
|
||
refresh_local_search_index_with_settings(&root, &root_uri, workspace_id, &effective)
|
||
.expect("refresh shared index");
|
||
|
||
let alice_results = query_local_search_index_with_settings(
|
||
&root,
|
||
&root_uri,
|
||
workspace_id,
|
||
&effective,
|
||
&alice_settings,
|
||
"AliceScopedToken",
|
||
None,
|
||
10,
|
||
false,
|
||
false,
|
||
false,
|
||
)
|
||
.expect("alice query");
|
||
assert_eq!(alice_results["results"].as_array().map(Vec::len), Some(1));
|
||
|
||
let alice_hidden = query_local_search_index_with_settings(
|
||
&root,
|
||
&root_uri,
|
||
workspace_id,
|
||
&effective,
|
||
&alice_settings,
|
||
"BobScopedToken",
|
||
None,
|
||
10,
|
||
false,
|
||
false,
|
||
false,
|
||
)
|
||
.expect("alice hidden query");
|
||
assert_eq!(alice_hidden["results"].as_array().map(Vec::len), Some(0));
|
||
|
||
let bob_results = query_local_search_index_with_settings(
|
||
&root,
|
||
&root_uri,
|
||
workspace_id,
|
||
&effective,
|
||
&bob_settings,
|
||
"BobScopedToken",
|
||
None,
|
||
10,
|
||
false,
|
||
false,
|
||
false,
|
||
)
|
||
.expect("bob query");
|
||
assert_eq!(bob_results["results"].as_array().map(Vec::len), Some(1));
|
||
|
||
let status = local_index_status_with_settings(
|
||
&root,
|
||
&root_uri,
|
||
workspace_id,
|
||
&alice_settings,
|
||
&effective,
|
||
)
|
||
.expect("status");
|
||
assert_eq!(
|
||
status["settings"]["includePaths"].as_array().map(Vec::len),
|
||
Some(1)
|
||
);
|
||
assert_eq!(
|
||
status["effectiveSettings"]["includePaths"]
|
||
.as_array()
|
||
.map(Vec::len),
|
||
Some(2)
|
||
);
|
||
|
||
let _ = fs::remove_dir_all(&root);
|
||
}
|
||
|
||
#[test]
|
||
fn local_index_schedule_due_uses_any_user_schedule() {
|
||
let root = temp_root("mnote-local-index-schedule-any-user");
|
||
let workspace_id = "local-ws-schedule-any-user";
|
||
let store = SqliteControlPlaneStore::in_memory().expect("init control plane");
|
||
let today = OffsetDateTime::now_local()
|
||
.unwrap_or_else(|_| OffsetDateTime::now_utc())
|
||
.date();
|
||
let yesterday = today - Duration::days(1);
|
||
let yesterday = format!(
|
||
"{:04}-{:02}-{:02}",
|
||
yesterday.year(),
|
||
u8::from(yesterday.month()),
|
||
yesterday.day()
|
||
);
|
||
|
||
write_user_local_index_settings(
|
||
&store,
|
||
"alice",
|
||
workspace_id,
|
||
&root,
|
||
&[String::from(".")],
|
||
Some("manual"),
|
||
Some("02:00"),
|
||
None,
|
||
Some(false),
|
||
)
|
||
.expect("write alice settings");
|
||
write_user_local_index_settings(
|
||
&store,
|
||
"bob",
|
||
workspace_id,
|
||
&root,
|
||
&[String::from(".")],
|
||
Some("once"),
|
||
Some("00:00"),
|
||
Some(&yesterday),
|
||
Some(false),
|
||
)
|
||
.expect("write bob settings");
|
||
|
||
assert!(
|
||
local_index_any_schedule_due_for_root(&store, workspace_id, &root, 0)
|
||
.expect("schedule due"),
|
||
"任一用户到期就应该触发共享索引重建"
|
||
);
|
||
|
||
let _ = fs::remove_dir_all(&root);
|
||
}
|
||
|
||
#[test]
|
||
fn refresh_local_search_index_for_change_path_with_store_uses_sqlite_effective_settings() {
|
||
let root = temp_root("mnote-local-index-change-with-store");
|
||
fs::create_dir_all(root.join("docs").join("included")).expect("create included");
|
||
fs::create_dir_all(root.join("docs").join("excluded")).expect("create excluded");
|
||
fs::write(
|
||
root.join("docs").join("included").join("keep.md"),
|
||
"# Keep\nKeepScopedToken\n",
|
||
)
|
||
.expect("write included");
|
||
fs::write(
|
||
root.join("docs").join("excluded").join("skip.md"),
|
||
"# Skip\nSkipScopedToken\n",
|
||
)
|
||
.expect("write excluded");
|
||
let root_uri = format!("file://{}", root.display());
|
||
let workspace_id = "local-ws-change-with-store";
|
||
let store = SqliteControlPlaneStore::in_memory().expect("init control plane");
|
||
|
||
write_local_index_settings(
|
||
&root,
|
||
&[String::from("docs/excluded")],
|
||
Some("manual"),
|
||
Some("02:00"),
|
||
None,
|
||
Some(false),
|
||
)
|
||
.expect("write stale cache settings");
|
||
write_user_local_index_settings(
|
||
&store,
|
||
"alice",
|
||
workspace_id,
|
||
&root,
|
||
&[String::from("docs/included")],
|
||
Some("manual"),
|
||
Some("02:00"),
|
||
None,
|
||
Some(true),
|
||
)
|
||
.expect("write sqlite settings");
|
||
|
||
let refreshed = refresh_local_search_index_for_change_path_with_store(
|
||
&store,
|
||
&root,
|
||
&root_uri,
|
||
workspace_id,
|
||
"docs/included/keep.md",
|
||
)
|
||
.expect("refresh")
|
||
.expect("refresh result");
|
||
assert_eq!(refreshed["documentCount"].as_u64(), Some(1));
|
||
|
||
let keep_results = query_local_search_index_with_settings(
|
||
&root,
|
||
&root_uri,
|
||
workspace_id,
|
||
&effective_local_index_settings_for_root(&store, workspace_id, &root)
|
||
.expect("effective"),
|
||
&read_user_local_index_settings(&store, "alice", workspace_id, &root).expect("alice"),
|
||
"KeepScopedToken",
|
||
None,
|
||
10,
|
||
false,
|
||
false,
|
||
false,
|
||
)
|
||
.expect("keep query");
|
||
assert_eq!(keep_results["results"].as_array().map(Vec::len), Some(1));
|
||
|
||
let skip_results = query_local_search_index_with_settings(
|
||
&root,
|
||
&root_uri,
|
||
workspace_id,
|
||
&effective_local_index_settings_for_root(&store, workspace_id, &root)
|
||
.expect("effective"),
|
||
&read_user_local_index_settings(&store, "alice", workspace_id, &root).expect("alice"),
|
||
"SkipScopedToken",
|
||
None,
|
||
10,
|
||
false,
|
||
false,
|
||
false,
|
||
)
|
||
.expect("skip query");
|
||
assert_eq!(skip_results["results"].as_array().map(Vec::len), Some(0));
|
||
|
||
let _ = fs::remove_dir_all(&root);
|
||
}
|
||
|
||
#[test]
|
||
fn local_search_index_incrementally_updates_single_markdown_path() {
|
||
let root = temp_root("mnote-local-search-index-incremental");
|
||
let root_uri = format!("file://{}", root.display());
|
||
let workspace_id = "local-ws-incremental";
|
||
fs::write(root.join("README.md"), "# Home\nRoot body.\n").expect("write home");
|
||
fs::write(
|
||
root.join("docs").join("child.md"),
|
||
"---\ntitle: Child\n---\n# Child\nOriginal body.\n",
|
||
)
|
||
.expect("write child");
|
||
|
||
write_local_index_settings(&root, &[String::from(".")], None, None, None, None)
|
||
.expect("settings");
|
||
refresh_local_search_index(&root, &root_uri, workspace_id).expect("initial refresh");
|
||
fs::write(
|
||
root.join("docs").join("child.md"),
|
||
"---\ntitle: Child Updated\n---\n# Child Updated\nChangedToken body.\n",
|
||
)
|
||
.expect("update child");
|
||
refresh_local_search_index_for_path(&root, &root_uri, workspace_id, "docs/child.md")
|
||
.expect("incremental update");
|
||
let index = read_local_search_index(&root)
|
||
.expect("read index")
|
||
.expect("index exists");
|
||
assert!(index
|
||
.documents
|
||
.iter()
|
||
.any(|document| document.path == "README.md"));
|
||
let child = index
|
||
.documents
|
||
.iter()
|
||
.find(|document| document.path == "docs/child.md")
|
||
.expect("child document");
|
||
// 本地 Markdown 的树标题统一来自文件名；frontmatter/H1 只进入正文和索引文本。
|
||
assert_eq!(child.title, "child");
|
||
assert!(child.raw_text.contains("ChangedToken"));
|
||
let changed_evidence = query_evidence_sqlite_results(&root, "ChangedToken", None, 10)
|
||
.expect("changed evidence")
|
||
.expect("sqlite exists");
|
||
assert_eq!(changed_evidence.len(), 1);
|
||
assert_eq!(
|
||
changed_evidence[0].source.owner_document_path,
|
||
"docs/child.md"
|
||
);
|
||
let original_evidence = query_evidence_sqlite_results(&root, "Original body", None, 10)
|
||
.expect("original evidence")
|
||
.expect("sqlite exists");
|
||
assert!(original_evidence.is_empty());
|
||
|
||
fs::remove_file(root.join("docs").join("child.md")).expect("remove child");
|
||
refresh_local_search_index_for_path(&root, &root_uri, workspace_id, "docs/child.md")
|
||
.expect("incremental remove");
|
||
let index = read_local_search_index(&root)
|
||
.expect("read index")
|
||
.expect("index exists");
|
||
assert!(!index
|
||
.documents
|
||
.iter()
|
||
.any(|document| document.path == "docs/child.md"));
|
||
assert!(index
|
||
.documents
|
||
.iter()
|
||
.any(|document| document.path == "README.md"));
|
||
let removed_evidence = query_evidence_sqlite_results(&root, "ChangedToken", None, 10)
|
||
.expect("removed evidence")
|
||
.expect("sqlite exists");
|
||
assert!(removed_evidence.is_empty());
|
||
let root_evidence = query_evidence_sqlite_results(&root, "Root body", None, 10)
|
||
.expect("root evidence")
|
||
.expect("sqlite exists");
|
||
assert_eq!(root_evidence.len(), 1);
|
||
let _ = fs::remove_dir_all(&root);
|
||
}
|
||
|
||
#[test]
|
||
fn local_search_ocr_sidecar_is_hidden_after_lightrag_retirement() {
|
||
let root = temp_root("mnote-local-search-ocr");
|
||
let root_uri = format!("file://{}", root.display());
|
||
let workspace_id = "local-ws-ocr";
|
||
fs::write(root.join("docs").join("Page.md"), "# Page\n正文\n").expect("page");
|
||
fs::create_dir_all(root.join("docs").join("Page.assets")).expect("assets");
|
||
fs::write(
|
||
root.join("docs").join("Page.assets").join("photo.png"),
|
||
b"png",
|
||
)
|
||
.expect("photo");
|
||
fs::create_dir_all(root.join("docs").join("Page.ocr")).expect("ocr dir");
|
||
fs::write(
|
||
root.join("docs").join("Page.ocr").join("photo.png.ocr.md"),
|
||
"---\nmnote_ocr_version: 1\nprovider: mock\nmodel_version: vlm\nowner_document: ../Page.md\nsource_path: ./Page.assets/photo.png\nsource_root_relative_path: docs/Page.assets/photo.png\nsource_size: 3\nsource_mtime_ms: 1\nstatus: done\ncreated_at: 1\nupdated_at: 1\n---\n\nOCR-only-token 识别正文\n",
|
||
)
|
||
.expect("ocr markdown");
|
||
fs::write(
|
||
root.join("docs").join("Page.ocr").join("photo.png-704905.ocr.md"),
|
||
"---\nmnote_ocr_version: 1\nprovider: mock\nmodel_version: vlm\nowner_document: ../Page.md\nsource_path: ./Page.assets/photo.png\nsource_root_relative_path: docs/Page.assets/photo.png\nsource_size: 3\nsource_mtime_ms: 2\nstatus: done\ncreated_at: 2\nupdated_at: 2\n---\n\nOCR-hash-token 识别正文\n",
|
||
)
|
||
.expect("hashed ocr markdown");
|
||
fs::create_dir_all(root.join(".mnote")).expect("mnote dir");
|
||
fs::write(
|
||
root.join(".mnote").join("ocr-index.json"),
|
||
serde_json::to_string_pretty(&json!({
|
||
"version": 1,
|
||
"entries": {
|
||
"docs/Page.assets/photo.png": {
|
||
"jobId": "ocr_test",
|
||
"ownerDocumentId": "local-md:docs~2FPage.md",
|
||
"ownerDocumentPath": "docs/Page.md",
|
||
"sourceRootRelativePath": "docs/Page.assets/photo.png",
|
||
"ocrRootRelativePath": "docs/Page.ocr/photo.png.ocr.md",
|
||
"provider": "mock",
|
||
"modelVersion": "vlm",
|
||
"status": "done",
|
||
"sourceSize": 3,
|
||
"sourceMtimeMs": 1,
|
||
"createdAtMs": 1,
|
||
"updatedAtMs": 1,
|
||
"plainTextPreview": "OCR-only-token 识别正文"
|
||
}
|
||
}
|
||
}))
|
||
.expect("serialize index"),
|
||
)
|
||
.expect("ocr index");
|
||
write_local_index_settings(&root, &[String::from(".")], None, None, None, None)
|
||
.expect("settings");
|
||
|
||
let without_ocr = query_local_search_index(
|
||
&root,
|
||
&root_uri,
|
||
workspace_id,
|
||
"OCR-only-token",
|
||
None,
|
||
10,
|
||
false,
|
||
false,
|
||
false,
|
||
)
|
||
.expect("without ocr");
|
||
assert_eq!(without_ocr["results"].as_array().map(Vec::len), Some(0));
|
||
let without_hashed_ocr = query_local_search_index(
|
||
&root,
|
||
&root_uri,
|
||
workspace_id,
|
||
"OCR-hash-token",
|
||
None,
|
||
10,
|
||
false,
|
||
false,
|
||
false,
|
||
)
|
||
.expect("without hashed ocr");
|
||
assert_eq!(
|
||
without_hashed_ocr["results"].as_array().map(Vec::len),
|
||
Some(0)
|
||
);
|
||
|
||
let with_ocr = query_local_search_index(
|
||
&root,
|
||
&root_uri,
|
||
workspace_id,
|
||
"OCR-only-token",
|
||
None,
|
||
10,
|
||
false,
|
||
false,
|
||
true,
|
||
)
|
||
.expect("with ocr");
|
||
assert_eq!(with_ocr["results"].as_array().map(Vec::len), Some(0));
|
||
let index = read_local_search_index(&root)
|
||
.expect("read search index")
|
||
.expect("search index");
|
||
assert!(!index
|
||
.documents
|
||
.iter()
|
||
.any(|document| document.path == "docs/Page.ocr/photo.png.ocr.md"));
|
||
assert!(!index
|
||
.documents
|
||
.iter()
|
||
.any(|document| document.path == "docs/Page.ocr/photo.png-704905.ocr.md"));
|
||
refresh_local_search_index_for_path(
|
||
&root,
|
||
&root_uri,
|
||
workspace_id,
|
||
"docs/Page.ocr/photo.png-704905.ocr.md",
|
||
)
|
||
.expect("refresh hashed ocr sidecar");
|
||
let refreshed_index = read_local_search_index(&root)
|
||
.expect("read refreshed search index")
|
||
.expect("refreshed search index");
|
||
assert!(!refreshed_index
|
||
.documents
|
||
.iter()
|
||
.any(|document| document.path == "docs/Page.ocr/photo.png-704905.ocr.md"));
|
||
let refreshed_evidence = query_evidence_sqlite_results(&root, "OCR-hash-token", None, 10)
|
||
.expect("query refreshed evidence")
|
||
.unwrap_or_default();
|
||
assert!(refreshed_evidence.is_empty());
|
||
let _ = fs::remove_dir_all(&root);
|
||
}
|
||
|
||
#[test]
|
||
fn local_search_query_reads_existing_index_without_rebuilding() {
|
||
let root = temp_root("mnote-local-search-query-cache");
|
||
let root_uri = format!("file://{}", root.display());
|
||
let workspace_id = "local-ws-query-cache";
|
||
let child_path = root.join("docs").join("child.md");
|
||
fs::write(
|
||
&child_path,
|
||
"---\ntitle: Child\n---\n# Child\nOriginalToken body.\n",
|
||
)
|
||
.expect("write child");
|
||
write_local_index_settings(&root, &[String::from(".")], None, None, None, None)
|
||
.expect("settings");
|
||
|
||
let first_projection = query_local_search_index(
|
||
&root,
|
||
&root_uri,
|
||
workspace_id,
|
||
"OriginalToken",
|
||
None,
|
||
10,
|
||
false,
|
||
false,
|
||
false,
|
||
)
|
||
.expect("first query");
|
||
assert_eq!(
|
||
first_projection["results"].as_array().map(Vec::len),
|
||
Some(1)
|
||
);
|
||
|
||
fs::write(
|
||
&child_path,
|
||
"---\ntitle: Child\n---\n# Child\nUnindexedToken body.\n",
|
||
)
|
||
.expect("update child without refresh");
|
||
|
||
let stale_projection = query_local_search_index(
|
||
&root,
|
||
&root_uri,
|
||
workspace_id,
|
||
"UnindexedToken",
|
||
None,
|
||
10,
|
||
false,
|
||
false,
|
||
false,
|
||
)
|
||
.expect("query existing index");
|
||
assert_eq!(
|
||
stale_projection["results"].as_array().map(Vec::len),
|
||
Some(0)
|
||
);
|
||
|
||
refresh_local_search_index_for_path(&root, &root_uri, workspace_id, "docs/child.md")
|
||
.expect("incremental refresh");
|
||
let refreshed_projection = query_local_search_index(
|
||
&root,
|
||
&root_uri,
|
||
workspace_id,
|
||
"UnindexedToken",
|
||
None,
|
||
10,
|
||
false,
|
||
false,
|
||
false,
|
||
)
|
||
.expect("query refreshed index");
|
||
assert_eq!(
|
||
refreshed_projection["results"].as_array().map(Vec::len),
|
||
Some(1)
|
||
);
|
||
let _ = fs::remove_dir_all(&root);
|
||
}
|
||
|
||
#[test]
|
||
fn evidence_sqlite_query_returns_locator_results() {
|
||
let root = temp_root("mnote-evidence-sqlite-query");
|
||
let root_uri = format!("file://{}", root.display());
|
||
let workspace_id = "local-ws-evidence-sqlite";
|
||
fs::write(
|
||
root.join("README.md"),
|
||
"# Home\nIntro body.\n## Evidence Section\nEvidenceToken root body.\nAsk @Reasonix for citation.\n",
|
||
)
|
||
.expect("write home");
|
||
fs::write(
|
||
root.join("docs").join("child.md"),
|
||
"# Child\nEvidenceToken child body.\n",
|
||
)
|
||
.expect("write child");
|
||
|
||
write_local_index_settings(&root, &[String::from(".")], None, None, None, None)
|
||
.expect("settings");
|
||
refresh_local_search_index(&root, &root_uri, workspace_id).expect("refresh");
|
||
|
||
let results = query_evidence_sqlite_results(&root, "EvidenceToken", None, 10)
|
||
.expect("sqlite query")
|
||
.expect("sqlite exists");
|
||
assert!(results.len() >= 2);
|
||
assert!(results
|
||
.iter()
|
||
.any(|result| result.source.owner_document_path == "README.md"));
|
||
assert!(results
|
||
.iter()
|
||
.any(|result| result.source.owner_document_path == "docs/child.md"));
|
||
assert!(results
|
||
.iter()
|
||
.all(|result| result.source.schema == "mnote.evidence_locator.v1"));
|
||
let home_result = results
|
||
.iter()
|
||
.find(|result| result.source.owner_document_path == "README.md")
|
||
.expect("home evidence result");
|
||
assert_eq!(
|
||
home_result.source.section_path,
|
||
vec!["Home".to_string(), "Evidence Section".to_string()]
|
||
);
|
||
assert_eq!(
|
||
home_result
|
||
.source
|
||
.line_range
|
||
.as_ref()
|
||
.map(|range| range.start),
|
||
Some(4)
|
||
);
|
||
assert_eq!(
|
||
home_result.source.block_id.as_deref(),
|
||
Some("local-md:README.md#line4")
|
||
);
|
||
|
||
let scoped = query_evidence_sqlite_results(
|
||
&root,
|
||
"EvidenceToken",
|
||
Some("local-md:docs~2Fchild.md"),
|
||
10,
|
||
)
|
||
.expect("scoped sqlite query")
|
||
.expect("sqlite exists");
|
||
assert_eq!(scoped.len(), 1);
|
||
assert_eq!(scoped[0].source.owner_document_path, "docs/child.md");
|
||
|
||
let connection =
|
||
Connection::open(root.join(".mnote").join("index").join("evidence.sqlite"))
|
||
.expect("open evidence sqlite");
|
||
let section_count: i64 = connection
|
||
.query_row("SELECT COUNT(*) FROM evidence_section", [], |row| {
|
||
row.get(0)
|
||
})
|
||
.expect("section count");
|
||
assert!(section_count >= 3);
|
||
let mention_source_block: String = connection
|
||
.query_row(
|
||
"SELECT source_block_id FROM evidence_edge WHERE edge_type = 'mentions' AND to_id = 'entity:Reasonix'",
|
||
[],
|
||
|row| row.get(0),
|
||
)
|
||
.expect("mention edge");
|
||
assert_eq!(mention_source_block, "local-md:README.md#line5");
|
||
let mention_locator: String = connection
|
||
.query_row(
|
||
"SELECT locator_json FROM evidence_block WHERE block_id = ?1",
|
||
rusqlite::params![mention_source_block],
|
||
|row| row.get(0),
|
||
)
|
||
.expect("mention source locator");
|
||
assert!(mention_locator.contains("mnote.evidence_locator.v1"));
|
||
let graph_results = query_evidence_graph_results(&root, "Reasonix", None, 10)
|
||
.expect("graph query")
|
||
.expect("sqlite exists");
|
||
let mention_result = graph_results
|
||
.iter()
|
||
.find(|result| result.evidence_id.contains("mentions"))
|
||
.expect("mention graph result");
|
||
assert!(mention_result.quote.contains("mentions:"));
|
||
assert_eq!(
|
||
mention_result.source.block_id.as_deref(),
|
||
Some("local-md:README.md#line5")
|
||
);
|
||
connection
|
||
.execute("DELETE FROM evidence_edge", [])
|
||
.expect("delete graph projection");
|
||
let search_after_graph_delete =
|
||
query_evidence_sqlite_results(&root, "EvidenceToken", None, 10)
|
||
.expect("sqlite query after graph delete")
|
||
.expect("sqlite exists");
|
||
assert!(!search_after_graph_delete.is_empty());
|
||
|
||
let _ = fs::remove_dir_all(&root);
|
||
}
|
||
|
||
#[test]
|
||
fn evidence_sqlite_fuzzy_uses_cjk_terms_without_overrequiring_suffix() {
|
||
let root = temp_root("mnote-evidence-sqlite-cjk-fuzzy");
|
||
let root_uri = format!("file://{}", root.display());
|
||
let workspace_id = "local-ws-evidence-cjk";
|
||
fs::write(
|
||
root.join("README.md"),
|
||
"# 有机合成\n羧酸需要被保护有许多原因，常见做法是形成稳定酯类后再脱保护。\n",
|
||
)
|
||
.expect("write home");
|
||
|
||
write_local_index_settings(&root, &[String::from(".")], None, None, None, None)
|
||
.expect("settings");
|
||
refresh_local_search_index(&root, &root_uri, workspace_id).expect("refresh");
|
||
|
||
let exact = query_evidence_sqlite_results_with_mode(&root, "羧酸 保护基", None, 10, true)
|
||
.expect("exact sqlite query")
|
||
.expect("sqlite exists");
|
||
assert!(exact.is_empty(), "精确短语不应伪造不存在的同串命中");
|
||
|
||
let fuzzy = query_evidence_sqlite_results_with_mode(&root, "羧酸 保护基", None, 10, false)
|
||
.expect("fuzzy sqlite query")
|
||
.expect("sqlite exists");
|
||
assert_eq!(fuzzy.len(), 1);
|
||
let info = fuzzy[0].match_info.as_ref().expect("match info");
|
||
assert_eq!(info.match_mode, "cjk_partial");
|
||
assert!(!info.strong);
|
||
assert!(info.matched_terms.iter().any(|term| term == "羧酸"));
|
||
assert!(info.matched_terms.iter().any(|term| term == "保护"));
|
||
assert!(info.missing_terms.iter().any(|term| term == "保护基"));
|
||
assert!(fuzzy[0].quote.contains("羧酸"));
|
||
|
||
let projection = query_local_search_index(
|
||
&root,
|
||
&root_uri,
|
||
workspace_id,
|
||
"羧酸 保护基",
|
||
None,
|
||
10,
|
||
false,
|
||
false,
|
||
false,
|
||
)
|
||
.expect("local search projection");
|
||
assert_eq!(projection["results"].as_array().map(Vec::len), Some(1));
|
||
|
||
let _ = fs::remove_dir_all(&root);
|
||
}
|
||
|
||
#[test]
|
||
fn evidence_sqlite_read_context_returns_anchor_block() {
|
||
let root = temp_root("mnote-evidence-sqlite-read-context");
|
||
let root_uri = format!("file://{}", root.display());
|
||
let workspace_id = "local-ws-evidence-read";
|
||
fs::write(
|
||
root.join("README.md"),
|
||
"# Home\nReadContextToken root body.\n",
|
||
)
|
||
.expect("write home");
|
||
|
||
write_local_index_settings(&root, &[String::from(".")], None, None, None, None)
|
||
.expect("settings");
|
||
refresh_local_search_index(&root, &root_uri, workspace_id).expect("refresh");
|
||
let results = query_evidence_sqlite_results(&root, "ReadContextToken", None, 10)
|
||
.expect("sqlite query")
|
||
.expect("sqlite exists");
|
||
let locator = results
|
||
.first()
|
||
.map(|item| item.source.clone())
|
||
.expect("locator");
|
||
|
||
let context = read_evidence_sqlite_context(&root, &locator, 1, 1)
|
||
.expect("read context")
|
||
.expect("sqlite exists");
|
||
|
||
assert_eq!(context.len(), 2);
|
||
assert!(context
|
||
.iter()
|
||
.all(|item| item.source.owner_document_path == "README.md"));
|
||
assert!(context
|
||
.iter()
|
||
.any(|item| item.quote.contains("ReadContextToken")));
|
||
|
||
let _ = fs::remove_dir_all(&root);
|
||
}
|
||
|
||
#[test]
|
||
#[cfg(unix)]
|
||
fn evidence_index_does_not_parse_resource_body_with_retired_liteparse_sidecar() {
|
||
use std::os::unix::fs::PermissionsExt;
|
||
|
||
let _guard = env_lock().lock().expect("env lock");
|
||
let root = temp_root("mnote-evidence-resource-liteparse");
|
||
let root_uri = format!("file://{}", root.display());
|
||
let workspace_id = "local-ws-evidence-resource";
|
||
fs::create_dir_all(root.join("docs").join("Page.assets")).expect("assets");
|
||
fs::write(
|
||
root.join("docs").join("Page.md"),
|
||
"# Page\n[Spec](./Page.assets/spec.pdf)\n",
|
||
)
|
||
.expect("write owner");
|
||
fs::write(
|
||
root.join("docs").join("Page.assets").join("spec.pdf"),
|
||
b"%PDF-1.4",
|
||
)
|
||
.expect("write pdf");
|
||
let lit = root.join("fake-lit");
|
||
fs::write(
|
||
&lit,
|
||
r#"#!/usr/bin/env bash
|
||
cat <<'JSON'
|
||
{
|
||
"version": "liteparse-index-test",
|
||
"pages": [{
|
||
"page": 2,
|
||
"width": 612,
|
||
"height": 792,
|
||
"blocks": [
|
||
{"id": "b1", "type": "heading", "level": 1, "text": "配方要求", "bbox": [72, 90, 180, 120]},
|
||
{"id": "b2", "type": "text", "text": "ResourceBodyToken 来自 PDF 正文", "bbox": [72, 130, 330, 160]}
|
||
]
|
||
}]
|
||
}
|
||
JSON
|
||
"#,
|
||
)
|
||
.expect("fake lit");
|
||
let mut permissions = fs::metadata(&lit).expect("fake lit metadata").permissions();
|
||
permissions.set_mode(0o755);
|
||
fs::set_permissions(&lit, permissions).expect("chmod fake lit");
|
||
let old_bin = std::env::var("MNOTE_LITEPARSE_BIN").ok();
|
||
std::env::set_var("MNOTE_LITEPARSE_BIN", &lit);
|
||
|
||
write_local_index_settings(&root, &[String::from(".")], None, None, None, None)
|
||
.expect("settings");
|
||
refresh_local_search_index(&root, &root_uri, workspace_id).expect("refresh");
|
||
|
||
if let Some(value) = old_bin {
|
||
std::env::set_var("MNOTE_LITEPARSE_BIN", value);
|
||
} else {
|
||
std::env::remove_var("MNOTE_LITEPARSE_BIN");
|
||
}
|
||
|
||
let results = query_evidence_sqlite_results(&root, "ResourceBodyToken", None, 10)
|
||
.expect("sqlite query")
|
||
.expect("sqlite exists");
|
||
assert!(
|
||
!results
|
||
.iter()
|
||
.any(|result| result.quote.contains("ResourceBodyToken")),
|
||
"LiteParse resource body fallback is retired from active evidence indexing"
|
||
);
|
||
let resource_scoped = query_evidence_sqlite_results_with_mode(
|
||
&root,
|
||
"ResourceBodyToken",
|
||
Some("local-resource:docs~2FPage.assets~2Fspec.pdf"),
|
||
10,
|
||
true,
|
||
)
|
||
.expect("resource scoped sqlite query")
|
||
.expect("sqlite exists");
|
||
assert!(
|
||
resource_scoped.is_empty(),
|
||
"retired LiteParse sidecar must not create resource-scoped evidence hits"
|
||
);
|
||
assert!(!root
|
||
.join("docs")
|
||
.join("Page.ocr")
|
||
.join("spec.pdf.parse.md")
|
||
.exists());
|
||
assert!(!root
|
||
.join("docs")
|
||
.join("Page.ocr")
|
||
.join("spec.pdf.source-map.json")
|
||
.exists());
|
||
|
||
let _ = fs::remove_dir_all(&root);
|
||
}
|
||
}
|