1495 lines
53 KiB
Rust
1495 lines
53 KiB
Rust
use crate::app::AppState;
|
||
use crate::context::RequestContext;
|
||
use crate::error::WebError;
|
||
use crate::routes::query_support::resolve_effective_workspace_id;
|
||
use crate::routes::{local_folder_source, local_search_index};
|
||
use axum::extract::{Extension, State};
|
||
use axum::http::{HeaderMap, HeaderValue, StatusCode};
|
||
use axum::Json;
|
||
use core_protocol::{
|
||
EvidenceBBox, EvidenceLocator, EvidenceOpenAction, EvidenceOpenRequest, EvidenceRange,
|
||
EvidenceReadRequest, EvidenceResourceKind, EvidenceSearchMode, EvidenceSearchRequest,
|
||
EvidenceSearchResponse, EvidenceSearchResult, ResourceSourceMap, SourceMapBlock,
|
||
SourceMapTextItem, EVIDENCE_LOCATOR_SCHEMA,
|
||
};
|
||
use serde_json::Map;
|
||
use serde_json::{json, Value};
|
||
use std::path::{Component, Path};
|
||
|
||
pub async fn search(
|
||
State(state): State<AppState>,
|
||
Extension(context): Extension<RequestContext>,
|
||
Json(body): Json<EvidenceSearchRequest>,
|
||
) -> Result<(StatusCode, HeaderMap, Json<Value>), WebError> {
|
||
let response = search_payload(&state, &context, body).await?;
|
||
let mut headers = HeaderMap::new();
|
||
headers.insert("content-type", HeaderValue::from_static("application/json"));
|
||
Ok((StatusCode::OK, headers, Json(response)))
|
||
}
|
||
|
||
pub(crate) async fn search_payload(
|
||
state: &AppState,
|
||
context: &RequestContext,
|
||
body: EvidenceSearchRequest,
|
||
) -> Result<Value, WebError> {
|
||
let effective_workspace_id =
|
||
resolve_effective_workspace_id(context, Some(body.scope.workspace_id.as_str()), true)?
|
||
.expect("workspace_required 已确保存在");
|
||
let root_uri = body.scope.root_uri.trim().to_string();
|
||
if root_uri.is_empty() {
|
||
return Err(
|
||
WebError::bad_request_code("evidence_root_required", "证据搜索缺少 rootUri")
|
||
.with_context(context),
|
||
);
|
||
}
|
||
let root_path = local_folder_source::ensure_local_workspace_read_access_with_state(
|
||
state, context, &root_uri,
|
||
)
|
||
.map_err(|error| error.with_context(context))?;
|
||
let page_id = body.scope.target_document_id.as_deref();
|
||
let evidence_owner_filter = if body.scope.include_resources || body.scope.include_ocr {
|
||
None
|
||
} else {
|
||
page_id
|
||
};
|
||
let query = body.query.trim().to_string();
|
||
if matches!(body.mode, EvidenceSearchMode::Graph) {
|
||
if let Some(mut results) = local_search_index::query_evidence_graph_results(
|
||
&root_path,
|
||
&query,
|
||
evidence_owner_filter,
|
||
body.top_k,
|
||
)? {
|
||
enrich_citation_links(&mut results);
|
||
return Ok(json!(EvidenceSearchResponse {
|
||
ok: true,
|
||
results,
|
||
diagnostics: None
|
||
}));
|
||
}
|
||
}
|
||
if let Some(mut results) = local_search_index::query_evidence_sqlite_results_with_mode(
|
||
&root_path,
|
||
&query,
|
||
evidence_owner_filter,
|
||
body.top_k,
|
||
false,
|
||
)? {
|
||
enrich_sqlite_evidence_results(&mut results, &root_path, &query);
|
||
enrich_citation_links(&mut results);
|
||
if !results.is_empty() || !query.is_empty() {
|
||
let diagnostics = Some(evidence_search_diagnostics(
|
||
&query,
|
||
&results,
|
||
"evidence_sqlite",
|
||
));
|
||
let response = EvidenceSearchResponse {
|
||
ok: true,
|
||
results,
|
||
diagnostics,
|
||
};
|
||
return Ok(json!(response));
|
||
}
|
||
}
|
||
let search = local_search_index::query_local_search_index(
|
||
&root_path,
|
||
&root_uri,
|
||
&effective_workspace_id,
|
||
&query,
|
||
page_id,
|
||
body.top_k.max(1),
|
||
false,
|
||
false,
|
||
body.scope.include_ocr,
|
||
)?;
|
||
let response = EvidenceSearchResponse {
|
||
ok: true,
|
||
results: {
|
||
let mut results = evidence_results_from_local_search(
|
||
&search, &root_path, &root_uri, body.mode, &query,
|
||
);
|
||
enrich_citation_links(&mut results);
|
||
results
|
||
},
|
||
diagnostics: None,
|
||
};
|
||
Ok(json!(response))
|
||
}
|
||
|
||
fn enrich_sqlite_evidence_results(
|
||
results: &mut [EvidenceSearchResult],
|
||
root_path: &Path,
|
||
query: &str,
|
||
) {
|
||
for result in results {
|
||
let Some(source_map_path) = result.source.source_map_path.clone() else {
|
||
continue;
|
||
};
|
||
let Some(hit) = read_source_map_hit(root_path, &source_map_path, query) else {
|
||
continue;
|
||
};
|
||
if result.source.page.is_none() {
|
||
result.source.page = hit.page;
|
||
}
|
||
if result.source.bbox.is_none() {
|
||
result.source.bbox = hit.bbox.clone();
|
||
}
|
||
if result.source.block_id.is_none() {
|
||
result.source.block_id = hit.block_id.clone();
|
||
}
|
||
if result.source.char_range.is_none() {
|
||
result.source.char_range = hit.char_range.clone();
|
||
}
|
||
if let Some(params) = result.source.open_action.params.as_object_mut() {
|
||
if let Some(page) = result.source.page {
|
||
params.insert("page".into(), json!(page));
|
||
}
|
||
if let Some(bbox) = &result.source.bbox {
|
||
params.insert("bbox".into(), json!(bbox));
|
||
}
|
||
if let Some(block_id) = &result.source.block_id {
|
||
params.insert("blockId".into(), json!(block_id));
|
||
}
|
||
if let Some(char_range) = &result.source.char_range {
|
||
params.insert("charRange".into(), json!(char_range));
|
||
}
|
||
params.insert("query".into(), json!(query));
|
||
params.insert("sourceMapPath".into(), json!(source_map_path));
|
||
}
|
||
}
|
||
}
|
||
|
||
fn enrich_citation_links(results: &mut [EvidenceSearchResult]) {
|
||
for result in results {
|
||
let citation_url = citation_url_for_locator(&result.source);
|
||
result.source.open_action.url = citation_url.clone();
|
||
result.citation_label = Some(citation_label_for_locator(&result.source));
|
||
result.citation_markdown = Some(citation_markdown_for_locator(&result.source));
|
||
result.citation_url = Some(citation_url);
|
||
}
|
||
}
|
||
|
||
fn evidence_search_diagnostics(
|
||
query: &str,
|
||
results: &[EvidenceSearchResult],
|
||
backend: &str,
|
||
) -> Value {
|
||
let query_tokens = evidence_query_tokens(query);
|
||
let strong_match_count = results
|
||
.iter()
|
||
.filter(|result| result.match_info.as_ref().is_some_and(|info| info.strong))
|
||
.count();
|
||
let weak_match_count = results.len().saturating_sub(strong_match_count);
|
||
let reason = if results.is_empty() {
|
||
"no_evidence_match"
|
||
} else if strong_match_count == 0 {
|
||
"only_weak_partial_matches"
|
||
} else {
|
||
"ranked_evidence_matches"
|
||
};
|
||
json!({
|
||
"backend": backend,
|
||
"queryTokens": query_tokens,
|
||
"resultCount": results.len(),
|
||
"strongMatchCount": strong_match_count,
|
||
"weakMatchCount": weak_match_count,
|
||
"reason": reason,
|
||
"suggestedQueries": suggested_evidence_queries(query),
|
||
})
|
||
}
|
||
|
||
fn evidence_query_tokens(query: &str) -> Vec<String> {
|
||
query
|
||
.split(|ch: char| {
|
||
ch.is_whitespace()
|
||
|| matches!(
|
||
ch,
|
||
',' | ';'
|
||
| ':'
|
||
| '，'
|
||
| '；'
|
||
| '：'
|
||
| '。'
|
||
| '、'
|
||
| '('
|
||
| ')'
|
||
| '['
|
||
| ']'
|
||
| '{'
|
||
| '}'
|
||
)
|
||
})
|
||
.map(str::trim)
|
||
.filter(|value| !value.is_empty())
|
||
.map(ToOwned::to_owned)
|
||
.collect()
|
||
}
|
||
|
||
fn suggested_evidence_queries(query: &str) -> Vec<String> {
|
||
let tokens = evidence_query_tokens(query);
|
||
let mut suggestions = Vec::new();
|
||
if tokens.len() > 1 {
|
||
suggestions.push(tokens.join(" "));
|
||
}
|
||
for token in tokens {
|
||
if token.chars().count() >= 3 {
|
||
suggestions.push(token.chars().take(2).collect::<String>());
|
||
}
|
||
}
|
||
suggestions.sort();
|
||
suggestions.dedup();
|
||
suggestions
|
||
}
|
||
|
||
fn citation_markdown_for_locator(locator: &EvidenceLocator) -> String {
|
||
let label = citation_label_for_locator(locator);
|
||
let url = citation_url_for_locator(locator);
|
||
format!(
|
||
"[{}]({})",
|
||
markdown_link_label_escape(&label),
|
||
url.replace(')', "%29")
|
||
)
|
||
}
|
||
|
||
fn citation_label_for_locator(locator: &EvidenceLocator) -> String {
|
||
let source_path = locator
|
||
.resource_path
|
||
.as_deref()
|
||
.filter(|value| !value.trim().is_empty())
|
||
.unwrap_or(locator.owner_document_path.as_str());
|
||
let name = source_path
|
||
.rsplit('/')
|
||
.find(|part| !part.trim().is_empty())
|
||
.unwrap_or(source_path)
|
||
.trim();
|
||
let mut parts = vec![if name.is_empty() {
|
||
"证据".to_string()
|
||
} else {
|
||
name.to_string()
|
||
}];
|
||
if let Some(page) = locator.page {
|
||
parts.push(format!("p.{page}"));
|
||
}
|
||
if let Some(section) = locator
|
||
.section_path
|
||
.last()
|
||
.filter(|value| !value.trim().is_empty())
|
||
{
|
||
parts.push(section.to_string());
|
||
}
|
||
parts.join(" · ")
|
||
}
|
||
|
||
fn citation_url_for_locator(locator: &EvidenceLocator) -> String {
|
||
let owner_document_id = locator.owner_document_id.trim();
|
||
let mut url = if owner_document_id.is_empty() {
|
||
let existing = locator.open_action.url.trim();
|
||
if existing.is_empty() {
|
||
"/".to_string()
|
||
} else {
|
||
existing.to_string()
|
||
}
|
||
} else {
|
||
format!("/documents/{owner_document_id}")
|
||
};
|
||
append_query_param(&mut url, "sourceKind", "local_folder");
|
||
append_query_param(&mut url, "rootUri", locator.root_uri.trim());
|
||
if let Some(resource_path) = locator
|
||
.resource_path
|
||
.as_deref()
|
||
.filter(|value| !value.trim().is_empty())
|
||
{
|
||
append_query_param(
|
||
&mut url,
|
||
"resourceTab",
|
||
&format!(
|
||
"resource:file:{}:{}",
|
||
locator.root_uri.trim(),
|
||
resource_path
|
||
),
|
||
);
|
||
append_query_param(&mut url, "resourcePath", resource_path);
|
||
}
|
||
if let Some(page) = locator.page {
|
||
append_query_param(&mut url, "page", &page.to_string());
|
||
}
|
||
if let Some(bbox) = &locator.bbox {
|
||
append_query_param(
|
||
&mut url,
|
||
"bbox",
|
||
&format!("{},{},{},{}", bbox.x0, bbox.y0, bbox.x1, bbox.y1),
|
||
);
|
||
}
|
||
if let Some(block_id) = locator.block_id.as_deref() {
|
||
append_query_param(&mut url, "blockId", block_id);
|
||
}
|
||
if let Some(source_map_path) = locator.source_map_path.as_deref() {
|
||
append_query_param(&mut url, "sourceMapPath", source_map_path);
|
||
}
|
||
if let Some(line_range) = &locator.line_range {
|
||
append_query_param(
|
||
&mut url,
|
||
"lineRange",
|
||
&format!("{}-{}", line_range.start, line_range.end),
|
||
);
|
||
}
|
||
if let Some(char_range) = &locator.char_range {
|
||
append_query_param(
|
||
&mut url,
|
||
"charRange",
|
||
&format!("{}-{}", char_range.start, char_range.end),
|
||
);
|
||
}
|
||
url
|
||
}
|
||
|
||
fn append_query_param(url: &mut String, key: &str, value: &str) {
|
||
let value = value.trim();
|
||
if value.is_empty() {
|
||
return;
|
||
}
|
||
let separator = if url.contains('?') { '&' } else { '?' };
|
||
url.push(separator);
|
||
url.push_str(&encode_query_component(key));
|
||
url.push('=');
|
||
url.push_str(&encode_query_component(value));
|
||
}
|
||
|
||
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 markdown_link_label_escape(value: &str) -> String {
|
||
value
|
||
.replace('\\', "\\\\")
|
||
.replace('[', "\\[")
|
||
.replace(']', "\\]")
|
||
}
|
||
|
||
pub async fn read(
|
||
State(state): State<AppState>,
|
||
Extension(context): Extension<RequestContext>,
|
||
Json(body): Json<EvidenceReadRequest>,
|
||
) -> Result<(StatusCode, HeaderMap, Json<Value>), WebError> {
|
||
let response = read_payload(&state, &context, body).await?;
|
||
let mut headers = HeaderMap::new();
|
||
headers.insert("content-type", HeaderValue::from_static("application/json"));
|
||
Ok((StatusCode::OK, headers, Json(response)))
|
||
}
|
||
|
||
pub(crate) async fn read_payload(
|
||
state: &AppState,
|
||
context: &RequestContext,
|
||
body: EvidenceReadRequest,
|
||
) -> Result<Value, WebError> {
|
||
let root_uri = body.locator.root_uri.trim().to_string();
|
||
if root_uri.is_empty() {
|
||
return Err(
|
||
WebError::bad_request_code("evidence_root_required", "证据读回缺少 rootUri")
|
||
.with_context(context),
|
||
);
|
||
}
|
||
let root_path = local_folder_source::ensure_local_workspace_read_access_with_state(
|
||
state, context, &root_uri,
|
||
)
|
||
.map_err(|error| error.with_context(context))?;
|
||
if let Some(mut results) = read_source_map_context(
|
||
&root_path,
|
||
&body.locator,
|
||
body.context.before_blocks,
|
||
body.context.after_blocks,
|
||
) {
|
||
enrich_citation_links(&mut results);
|
||
let quote = results
|
||
.iter()
|
||
.find(|item| locator_matches(&item.source, &body.locator))
|
||
.or_else(|| results.first())
|
||
.map(|item| item.quote.clone())
|
||
.unwrap_or_default();
|
||
let section_path = results
|
||
.iter()
|
||
.find(|item| !item.source.section_path.is_empty())
|
||
.map(|item| item.source.section_path.clone())
|
||
.unwrap_or_default();
|
||
let response = json!({
|
||
"ok": true,
|
||
"locator": body.locator,
|
||
"quote": quote,
|
||
"sectionPath": section_path,
|
||
"citationUrl": citation_url_for_locator(&body.locator),
|
||
"citationLabel": citation_label_for_locator(&body.locator),
|
||
"citationMarkdown": citation_markdown_for_locator(&body.locator),
|
||
"contextBlocks": results,
|
||
});
|
||
return Ok(response);
|
||
}
|
||
if let Some(mut results) = local_search_index::read_evidence_sqlite_context(
|
||
&root_path,
|
||
&body.locator,
|
||
body.context.before_blocks,
|
||
body.context.after_blocks,
|
||
)? {
|
||
if !results.is_empty() {
|
||
enrich_citation_links(&mut results);
|
||
let quote = results
|
||
.iter()
|
||
.find(|item| locator_matches(&item.source, &body.locator))
|
||
.or_else(|| results.first())
|
||
.map(|item| item.quote.clone())
|
||
.unwrap_or_default();
|
||
let response = json!({
|
||
"ok": true,
|
||
"locator": body.locator,
|
||
"quote": quote,
|
||
"citationUrl": citation_url_for_locator(&body.locator),
|
||
"citationLabel": citation_label_for_locator(&body.locator),
|
||
"citationMarkdown": citation_markdown_for_locator(&body.locator),
|
||
"contextBlocks": results,
|
||
});
|
||
return Ok(response);
|
||
}
|
||
}
|
||
let page_id = Some(body.locator.owner_document_id.as_str());
|
||
let query = body
|
||
.locator
|
||
.block_id
|
||
.clone()
|
||
.or_else(|| body.locator.page.map(|page| page.to_string()))
|
||
.unwrap_or_default();
|
||
let workspace_id = local_folder_source::local_workspace_id_from_root_uri(&root_uri)
|
||
.unwrap_or_else(|_| "default".to_string());
|
||
let search = local_search_index::query_local_search_index(
|
||
&root_path,
|
||
&root_uri,
|
||
&workspace_id,
|
||
&query,
|
||
page_id,
|
||
(body.context.before_blocks + body.context.after_blocks + 1).max(1),
|
||
false,
|
||
false,
|
||
true,
|
||
)?;
|
||
let mut results = evidence_results_from_local_search(
|
||
&search,
|
||
&root_path,
|
||
&root_uri,
|
||
EvidenceSearchMode::Tree,
|
||
&query,
|
||
);
|
||
enrich_citation_links(&mut results);
|
||
let quote = results
|
||
.first()
|
||
.map(|item| item.quote.clone())
|
||
.unwrap_or_default();
|
||
let response = json!({
|
||
"ok": true,
|
||
"locator": body.locator,
|
||
"quote": quote,
|
||
"citationUrl": citation_url_for_locator(&body.locator),
|
||
"citationLabel": citation_label_for_locator(&body.locator),
|
||
"citationMarkdown": citation_markdown_for_locator(&body.locator),
|
||
"contextBlocks": results,
|
||
});
|
||
Ok(response)
|
||
}
|
||
|
||
fn read_source_map_context(
|
||
root_path: &Path,
|
||
locator: &EvidenceLocator,
|
||
before_blocks: u32,
|
||
after_blocks: u32,
|
||
) -> Option<Vec<EvidenceSearchResult>> {
|
||
let source_map_path = locator.source_map_path.as_deref()?;
|
||
if !is_safe_relative_path(source_map_path) {
|
||
return None;
|
||
}
|
||
let source_map = std::fs::read_to_string(root_path.join(source_map_path)).ok()?;
|
||
let source_map: ResourceSourceMap = serde_json::from_str(&source_map).ok()?;
|
||
let mut blocks = Vec::new();
|
||
for page in &source_map.pages {
|
||
for block in &page.blocks {
|
||
let section_path = source_map_section_path_for_block(&source_map, &block.id);
|
||
blocks.push((page.page, block, section_path));
|
||
}
|
||
}
|
||
if blocks.is_empty() {
|
||
return None;
|
||
}
|
||
let anchor_index = blocks.iter().position(|(page, block, _)| {
|
||
locator
|
||
.block_id
|
||
.as_deref()
|
||
.is_some_and(|block_id| block_id == block.id)
|
||
|| locator
|
||
.page
|
||
.is_some_and(|locator_page| locator_page == *page)
|
||
&& locator
|
||
.char_range
|
||
.as_ref()
|
||
.zip(block.char_range.as_ref())
|
||
.is_some_and(|(left, right)| left.start == right.start && left.end == right.end)
|
||
})?;
|
||
let anchor_section = blocks[anchor_index].2.clone();
|
||
let start = anchor_index.saturating_sub(before_blocks as usize);
|
||
let end = (anchor_index + after_blocks as usize + 1).min(blocks.len());
|
||
let mut selected = blocks[start..end]
|
||
.iter()
|
||
.enumerate()
|
||
.map(|(offset, (page, block, section_path))| {
|
||
source_map_block_result(
|
||
locator,
|
||
source_map_path,
|
||
*page,
|
||
block,
|
||
section_path.clone(),
|
||
if start + offset == anchor_index {
|
||
1.0
|
||
} else {
|
||
0.8
|
||
},
|
||
)
|
||
})
|
||
.collect::<Vec<_>>();
|
||
if !anchor_section.is_empty() {
|
||
for (page, block, section_path) in
|
||
blocks.iter().filter(|(_, _, path)| *path == anchor_section)
|
||
{
|
||
if selected
|
||
.iter()
|
||
.any(|item| item.source.block_id.as_deref() == Some(block.id.as_str()))
|
||
{
|
||
continue;
|
||
}
|
||
selected.push(source_map_block_result(
|
||
locator,
|
||
source_map_path,
|
||
*page,
|
||
block,
|
||
section_path.clone(),
|
||
0.7,
|
||
));
|
||
}
|
||
}
|
||
Some(selected)
|
||
}
|
||
|
||
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_result(
|
||
locator: &EvidenceLocator,
|
||
source_map_path: &str,
|
||
page: u32,
|
||
block: &SourceMapBlock,
|
||
section_path: Vec<String>,
|
||
score: f64,
|
||
) -> EvidenceSearchResult {
|
||
let mut source = locator.clone();
|
||
source.page = Some(page);
|
||
source.bbox = block.bbox.clone();
|
||
source.block_id = Some(block.id.clone());
|
||
source.char_range = block.char_range.clone();
|
||
source.section_path = section_path;
|
||
source.source_map_path = Some(source_map_path.to_string());
|
||
if let Some(params) = source.open_action.params.as_object_mut() {
|
||
params.insert("page".into(), json!(page));
|
||
if let Some(bbox) = &source.bbox {
|
||
params.insert("bbox".into(), json!(bbox));
|
||
}
|
||
params.insert("blockId".into(), json!(block.id));
|
||
if let Some(char_range) = &source.char_range {
|
||
params.insert("charRange".into(), json!(char_range));
|
||
}
|
||
params.insert("sourceMapPath".into(), json!(source_map_path));
|
||
}
|
||
EvidenceSearchResult {
|
||
evidence_id: format!("{}#{}", locator.owner_document_id, block.id),
|
||
quote: block.text.clone(),
|
||
score,
|
||
source,
|
||
match_info: None,
|
||
citation_url: None,
|
||
citation_label: None,
|
||
citation_markdown: None,
|
||
}
|
||
}
|
||
|
||
fn locator_matches(left: &EvidenceLocator, right: &EvidenceLocator) -> bool {
|
||
right
|
||
.block_id
|
||
.as_deref()
|
||
.is_some_and(|block_id| left.block_id.as_deref() == Some(block_id))
|
||
|| left.owner_document_id == right.owner_document_id
|
||
&& left.resource_path == right.resource_path
|
||
&& left.source_map_path == right.source_map_path
|
||
}
|
||
|
||
pub async fn open(
|
||
State(state): State<AppState>,
|
||
Extension(context): Extension<RequestContext>,
|
||
Json(body): Json<EvidenceOpenRequest>,
|
||
) -> Result<(StatusCode, HeaderMap, Json<Value>), WebError> {
|
||
let response = open_payload(&state, &context, body).await?;
|
||
let mut headers = HeaderMap::new();
|
||
headers.insert("content-type", HeaderValue::from_static("application/json"));
|
||
Ok((StatusCode::OK, headers, Json(response)))
|
||
}
|
||
|
||
pub(crate) async fn open_payload(
|
||
state: &AppState,
|
||
context: &RequestContext,
|
||
body: EvidenceOpenRequest,
|
||
) -> Result<Value, WebError> {
|
||
let mut locator = body.locator;
|
||
let citation_url = citation_url_for_locator(&locator);
|
||
locator.open_action.url = citation_url.clone();
|
||
let root_uri = locator.root_uri.trim().to_string();
|
||
if root_uri.is_empty() {
|
||
return Err(
|
||
WebError::bad_request_code("evidence_root_required", "证据打开缺少 rootUri")
|
||
.with_context(context),
|
||
);
|
||
}
|
||
let _ = local_folder_source::ensure_local_workspace_read_access_with_state(
|
||
state, context, &root_uri,
|
||
)
|
||
.map_err(|error| error.with_context(context))?;
|
||
let response = json!({
|
||
"ok": true,
|
||
"locator": locator.clone(),
|
||
"openAction": locator.open_action,
|
||
"citationUrl": citation_url,
|
||
"citationLabel": citation_label_for_locator(&locator),
|
||
"citationMarkdown": citation_markdown_for_locator(&locator),
|
||
});
|
||
Ok(response)
|
||
}
|
||
|
||
pub(crate) fn evidence_results_from_local_search(
|
||
payload: &Value,
|
||
root_path: &Path,
|
||
root_uri: &str,
|
||
mode: EvidenceSearchMode,
|
||
query: &str,
|
||
) -> Vec<EvidenceSearchResult> {
|
||
let results = payload
|
||
.get("results")
|
||
.and_then(Value::as_array)
|
||
.cloned()
|
||
.unwrap_or_default();
|
||
results
|
||
.into_iter()
|
||
.enumerate()
|
||
.map(|(index, result)| {
|
||
let owner_document_id = result
|
||
.get("documentId")
|
||
.and_then(Value::as_str)
|
||
.unwrap_or_default()
|
||
.to_string();
|
||
let owner_document_path = result
|
||
.get("path")
|
||
.and_then(Value::as_str)
|
||
.unwrap_or_default()
|
||
.to_string();
|
||
let source_map_path = result
|
||
.get("sourceMapPath")
|
||
.and_then(Value::as_str)
|
||
.map(str::to_string)
|
||
.or_else(|| {
|
||
result
|
||
.get("ocrEvidence")
|
||
.and_then(|value| value.get("ocrRootRelativePath"))
|
||
.and_then(Value::as_str)
|
||
.and_then(path_source_map_path)
|
||
});
|
||
let source_map_hit = source_map_path
|
||
.as_deref()
|
||
.and_then(|path| read_source_map_hit(root_path, path, query));
|
||
let resource_path = result
|
||
.get("ocrEvidence")
|
||
.and_then(|value| value.get("sourceRootRelativePath"))
|
||
.and_then(Value::as_str)
|
||
.map(str::to_string)
|
||
.or_else(|| {
|
||
if owner_document_path.is_empty() {
|
||
None
|
||
} else {
|
||
Some(owner_document_path.clone())
|
||
}
|
||
});
|
||
let resource_kind = infer_resource_kind(
|
||
result
|
||
.get("resourceType")
|
||
.and_then(Value::as_str)
|
||
.unwrap_or("markdown"),
|
||
resource_path.as_deref(),
|
||
);
|
||
let public_path = result
|
||
.get("publicPath")
|
||
.and_then(Value::as_str)
|
||
.unwrap_or("/")
|
||
.to_string();
|
||
let page = result
|
||
.get("page")
|
||
.and_then(Value::as_u64)
|
||
.and_then(|page| u32::try_from(page).ok())
|
||
.or_else(|| source_map_hit.as_ref().and_then(|hit| hit.page));
|
||
let bbox = result
|
||
.get("bbox")
|
||
.and_then(Value::as_array)
|
||
.and_then(|bbox| {
|
||
if bbox.len() != 4 {
|
||
return None;
|
||
}
|
||
Some(EvidenceBBox {
|
||
x0: bbox[0].as_f64()?,
|
||
y0: bbox[1].as_f64()?,
|
||
x1: bbox[2].as_f64()?,
|
||
y1: bbox[3].as_f64()?,
|
||
})
|
||
})
|
||
.or_else(|| source_map_hit.as_ref().and_then(|hit| hit.bbox.clone()));
|
||
let block_id = result
|
||
.get("blockId")
|
||
.and_then(Value::as_str)
|
||
.map(str::to_string)
|
||
.or_else(|| {
|
||
result
|
||
.get("ocrEvidence")
|
||
.and_then(|_| source_map_hit.as_ref().and_then(|hit| hit.block_id.clone()))
|
||
})
|
||
.or_else(|| source_map_hit.as_ref().and_then(|hit| hit.block_id.clone()));
|
||
let line_range = result.get("lineRange").and_then(evidence_range_from_value);
|
||
let char_range = source_map_hit
|
||
.as_ref()
|
||
.and_then(|hit| hit.char_range.clone())
|
||
.or_else(|| result.get("charRange").and_then(evidence_range_from_value));
|
||
let open_action_params = evidence_open_action_params(
|
||
&result,
|
||
query,
|
||
&mode,
|
||
page,
|
||
bbox.clone(),
|
||
block_id.clone(),
|
||
line_range.clone(),
|
||
char_range.clone(),
|
||
source_map_path.clone(),
|
||
);
|
||
let locator = EvidenceLocator {
|
||
schema: EVIDENCE_LOCATOR_SCHEMA.into(),
|
||
root_uri: root_uri.to_string(),
|
||
owner_document_id,
|
||
owner_document_path,
|
||
resource_path,
|
||
resource_kind,
|
||
page,
|
||
bbox: bbox.clone(),
|
||
section_path: result
|
||
.get("sectionPath")
|
||
.and_then(Value::as_array)
|
||
.map(|items| {
|
||
items
|
||
.iter()
|
||
.filter_map(Value::as_str)
|
||
.map(str::to_string)
|
||
.collect::<Vec<_>>()
|
||
})
|
||
.unwrap_or_default(),
|
||
line_range,
|
||
char_range,
|
||
block_id,
|
||
source_map_path: source_map_path.clone(),
|
||
open_action: EvidenceOpenAction {
|
||
action_type: "mnote.open_resource_locator".into(),
|
||
url: public_path.clone(),
|
||
params: Value::Object(open_action_params),
|
||
},
|
||
};
|
||
EvidenceSearchResult {
|
||
evidence_id: result
|
||
.get("id")
|
||
.and_then(Value::as_str)
|
||
.map(str::to_string)
|
||
.unwrap_or_else(|| format!("evidence_{index}")),
|
||
quote: result
|
||
.get("snippet")
|
||
.and_then(Value::as_str)
|
||
.unwrap_or_default()
|
||
.to_string(),
|
||
score: result.get("score").and_then(Value::as_f64).unwrap_or(0.0),
|
||
source: locator,
|
||
match_info: result
|
||
.get("evidence")
|
||
.and_then(|value| value.get("matchInfo"))
|
||
.cloned()
|
||
.and_then(|value| serde_json::from_value(value).ok()),
|
||
citation_url: None,
|
||
citation_label: None,
|
||
citation_markdown: None,
|
||
}
|
||
})
|
||
.collect()
|
||
}
|
||
|
||
fn evidence_open_action_params(
|
||
result: &Value,
|
||
query: &str,
|
||
mode: &EvidenceSearchMode,
|
||
page: Option<u32>,
|
||
bbox: Option<EvidenceBBox>,
|
||
block_id: Option<String>,
|
||
line_range: Option<EvidenceRange>,
|
||
char_range: Option<EvidenceRange>,
|
||
source_map_path: Option<String>,
|
||
) -> Map<String, Value> {
|
||
let mut params = Map::new();
|
||
params.insert("query".into(), json!(query));
|
||
params.insert("mode".into(), json!(evidence_mode_label(mode)));
|
||
if let Some(resource_path) = result
|
||
.get("ocrEvidence")
|
||
.and_then(|value| value.get("sourceRootRelativePath"))
|
||
.and_then(Value::as_str)
|
||
{
|
||
params.insert("resourcePath".into(), json!(resource_path));
|
||
}
|
||
if let Some(page) = page {
|
||
params.insert("page".into(), json!(page));
|
||
}
|
||
if let Some(bbox) = bbox {
|
||
params.insert("bbox".into(), json!(bbox));
|
||
}
|
||
if let Some(block_id) = block_id {
|
||
params.insert("blockId".into(), json!(block_id));
|
||
}
|
||
if let Some(line_range) = line_range {
|
||
params.insert("lineRange".into(), json!(line_range));
|
||
}
|
||
if let Some(char_range) = char_range {
|
||
params.insert("charRange".into(), json!(char_range));
|
||
}
|
||
if let Some(source_map_path) = source_map_path {
|
||
params.insert("sourceMapPath".into(), json!(source_map_path));
|
||
}
|
||
params
|
||
}
|
||
|
||
fn evidence_range_from_value(value: &Value) -> Option<EvidenceRange> {
|
||
if let Some(map) = value.as_object() {
|
||
let start = map.get("start")?.as_u64()?;
|
||
let end = map.get("end")?.as_u64()?;
|
||
return Some(EvidenceRange { start, end });
|
||
}
|
||
let text = value.as_str()?.trim();
|
||
let (start, end) = text.split_once('-')?;
|
||
Some(EvidenceRange {
|
||
start: start.trim().parse().ok()?,
|
||
end: end.trim().parse().ok()?,
|
||
})
|
||
}
|
||
|
||
fn infer_resource_kind(resource_type: &str, resource_path: Option<&str>) -> EvidenceResourceKind {
|
||
let extension = resource_path
|
||
.and_then(|path| Path::new(path).extension())
|
||
.and_then(|value| value.to_str());
|
||
match extension {
|
||
Some("pdf") => EvidenceResourceKind::Pdf,
|
||
Some("png") | Some("jpg") | Some("jpeg") | Some("webp") => EvidenceResourceKind::Image,
|
||
Some("doc") | Some("docx") | Some("xls") | Some("xlsx") | Some("ppt") | Some("pptx") => {
|
||
EvidenceResourceKind::Office
|
||
}
|
||
Some("md") => EvidenceResourceKind::Markdown,
|
||
Some("mm") | Some("mindmap") => EvidenceResourceKind::Mindmap,
|
||
_ => match resource_type {
|
||
"markdown" => EvidenceResourceKind::Markdown,
|
||
"mindmap" => EvidenceResourceKind::Mindmap,
|
||
"office" => EvidenceResourceKind::Office,
|
||
"pdf" => EvidenceResourceKind::Pdf,
|
||
"image" => EvidenceResourceKind::Image,
|
||
"raw_file" => EvidenceResourceKind::RawFile,
|
||
_ => EvidenceResourceKind::RawFile,
|
||
},
|
||
}
|
||
}
|
||
|
||
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
|
||
}
|
||
|
||
#[derive(Debug, Clone)]
|
||
struct SourceMapHit {
|
||
page: Option<u32>,
|
||
block_id: Option<String>,
|
||
bbox: Option<EvidenceBBox>,
|
||
char_range: Option<core_protocol::EvidenceRange>,
|
||
}
|
||
|
||
fn read_source_map_hit(
|
||
root_path: &Path,
|
||
source_map_path: &str,
|
||
query: &str,
|
||
) -> Option<SourceMapHit> {
|
||
if !is_safe_relative_path(source_map_path) {
|
||
return None;
|
||
}
|
||
let source_map = std::fs::read_to_string(root_path.join(source_map_path)).ok()?;
|
||
let source_map: ResourceSourceMap = serde_json::from_str(&source_map).ok()?;
|
||
find_source_map_hit(&source_map, query)
|
||
}
|
||
|
||
fn find_source_map_hit(source_map: &ResourceSourceMap, query: &str) -> Option<SourceMapHit> {
|
||
let normalized_query = query.trim().to_lowercase();
|
||
for page in &source_map.pages {
|
||
if let Some(block) = find_block_hit(&page.blocks, &normalized_query) {
|
||
return Some(SourceMapHit {
|
||
page: Some(page.page),
|
||
block_id: Some(block.id.clone()),
|
||
bbox: block.bbox.clone(),
|
||
char_range: block.char_range.clone(),
|
||
});
|
||
}
|
||
if let Some(item) = find_text_item_hit(&page.text_items, &normalized_query) {
|
||
return Some(SourceMapHit {
|
||
page: Some(page.page),
|
||
block_id: Some(item.id.clone()),
|
||
bbox: item.bbox.clone(),
|
||
char_range: item.char_range.clone(),
|
||
});
|
||
}
|
||
}
|
||
None
|
||
}
|
||
|
||
fn find_block_hit<'a>(
|
||
blocks: &'a [SourceMapBlock],
|
||
normalized_query: &str,
|
||
) -> Option<&'a SourceMapBlock> {
|
||
blocks
|
||
.iter()
|
||
.find(|block| source_map_text_matches(&block.text, normalized_query))
|
||
.or_else(|| blocks.first())
|
||
}
|
||
|
||
fn find_text_item_hit<'a>(
|
||
items: &'a [SourceMapTextItem],
|
||
normalized_query: &str,
|
||
) -> Option<&'a SourceMapTextItem> {
|
||
items
|
||
.iter()
|
||
.find(|item| source_map_text_matches(&item.text, normalized_query))
|
||
.or_else(|| items.first())
|
||
}
|
||
|
||
fn source_map_text_matches(text: &str, normalized_query: &str) -> bool {
|
||
if normalized_query.is_empty() {
|
||
return true;
|
||
}
|
||
text.to_lowercase().contains(normalized_query)
|
||
}
|
||
|
||
fn is_safe_relative_path(path: &str) -> bool {
|
||
let path = Path::new(path);
|
||
!path.is_absolute()
|
||
&& path
|
||
.components()
|
||
.all(|component| matches!(component, Component::Normal(_)))
|
||
}
|
||
|
||
fn evidence_mode_label(mode: &EvidenceSearchMode) -> &'static str {
|
||
match mode {
|
||
EvidenceSearchMode::Keyword => "keyword",
|
||
EvidenceSearchMode::Tree => "tree",
|
||
EvidenceSearchMode::Hybrid => "hybrid",
|
||
EvidenceSearchMode::Graph => "graph",
|
||
}
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::*;
|
||
use crate::app::{build_app, AppConfig, AppState};
|
||
use axum::body::{to_bytes, Body};
|
||
use axum::http::{Request, StatusCode};
|
||
use core_protocol::{EvidenceOpenAction, RESOURCE_SOURCE_MAP_SCHEMA};
|
||
use std::fs;
|
||
use tower::util::ServiceExt;
|
||
|
||
#[test]
|
||
fn evidence_results_from_local_search_uses_locator_contract() {
|
||
let payload = json!({
|
||
"results": [{
|
||
"id": "doc-1",
|
||
"documentId": "local-md:docs~2FPage.md",
|
||
"title": "Page",
|
||
"path": "docs/Page.md",
|
||
"resourceType": "markdown",
|
||
"sourceKind": "local_folder",
|
||
"rootUri": "file:///workspace",
|
||
"snippet": "hello world",
|
||
"publicPath": "/documents/local-md:docs~2FPage.md?sourceKind=local_folder&rootUri=file%3A%2F%2F%2Fworkspace"
|
||
}]
|
||
});
|
||
|
||
let results = evidence_results_from_local_search(
|
||
&payload,
|
||
Path::new("/workspace"),
|
||
"file:///workspace",
|
||
EvidenceSearchMode::Hybrid,
|
||
"hello",
|
||
);
|
||
|
||
assert_eq!(results.len(), 1);
|
||
assert_eq!(results[0].quote, "hello world");
|
||
assert_eq!(results[0].source.schema, EVIDENCE_LOCATOR_SCHEMA);
|
||
assert_eq!(
|
||
results[0].source.resource_kind,
|
||
EvidenceResourceKind::Markdown
|
||
);
|
||
assert_eq!(
|
||
results[0].source.open_action,
|
||
EvidenceOpenAction {
|
||
action_type: "mnote.open_resource_locator".into(),
|
||
url: "/documents/local-md:docs~2FPage.md?sourceKind=local_folder&rootUri=file%3A%2F%2F%2Fworkspace".into(),
|
||
params: json!({"query":"hello","mode":"hybrid"})
|
||
}
|
||
);
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn evidence_search_route_prefers_sqlite_index() {
|
||
let root = std::env::temp_dir().join(format!(
|
||
"mnote-evidence-route-sqlite-{}-{}",
|
||
std::process::id(),
|
||
std::time::SystemTime::now()
|
||
.duration_since(std::time::UNIX_EPOCH)
|
||
.expect("system time")
|
||
.as_nanos()
|
||
));
|
||
let _ = fs::remove_dir_all(&root);
|
||
fs::create_dir_all(root.join(".mnote")).expect("metadata");
|
||
fs::write(
|
||
root.join(".mnote").join("workspace.json"),
|
||
r#"{"workspaceId":"local-ws-evidence-route","ownerId":"user_test","createdAt":"2026-05-19T00:00:00Z","capabilities":["local_files"]}"#,
|
||
)
|
||
.expect("manifest");
|
||
fs::write(
|
||
root.join("README.md"),
|
||
"# Evidence Route\nSqliteRouteToken should come from evidence.sqlite.\n",
|
||
)
|
||
.expect("readme");
|
||
let root_uri = format!("file://{}", root.display());
|
||
local_search_index::write_local_index_settings(
|
||
&root,
|
||
&[String::from(".")],
|
||
None,
|
||
None,
|
||
None,
|
||
None,
|
||
)
|
||
.expect("settings");
|
||
local_search_index::refresh_local_search_index(&root, &root_uri, "local-ws-evidence-route")
|
||
.expect("refresh");
|
||
fs::write(
|
||
root.join(".mnote").join("index").join("search-index.json"),
|
||
serde_json::to_string_pretty(&json!({
|
||
"version": 1,
|
||
"builtAt": 1,
|
||
"rootUri": root_uri,
|
||
"workspaceId": "local-ws-evidence-route",
|
||
"documents": [],
|
||
"resources": []
|
||
}))
|
||
.expect("stale search index"),
|
||
)
|
||
.expect("overwrite search index");
|
||
|
||
let app = build_app(AppState::new(AppConfig {
|
||
service_name: "mnote-web".into(),
|
||
service_version: "0.1.0".into(),
|
||
bind_addr: "127.0.0.1:0".into(),
|
||
public_bind_addr: "127.0.0.1:3000".into(),
|
||
legacy_next_base_url: Some("http://127.0.0.1:3100".into()),
|
||
enable_legacy_next_compat: true,
|
||
enable_debug_shell_routes: false,
|
||
enable_editor_actor: true,
|
||
hermes_base_path: "/api/hermes".into(),
|
||
compat_next_base_path: "/api/compat/next".into(),
|
||
convex_url: None,
|
||
convex_admin_key: None,
|
||
allow_dev_fixtures: true,
|
||
query_fixtures_json: None,
|
||
mutation_fixtures_json: None,
|
||
dev_user_id: "dev-user".into(),
|
||
dev_user_name: "开发用户".into(),
|
||
dev_user_email: "dev@mnote.local".into(),
|
||
}));
|
||
let response = app
|
||
.oneshot(
|
||
Request::builder()
|
||
.method("POST")
|
||
.uri("/api/evidence/search")
|
||
.header("content-type", "application/json")
|
||
.header("x-mnote-actor-id", "user_test")
|
||
.header("x-mnote-actor-type", "user")
|
||
.body(Body::from(
|
||
json!({
|
||
"query": "SqliteRouteToken",
|
||
"scope": {
|
||
"workspaceId": "local-ws-evidence-route",
|
||
"rootUri": root_uri,
|
||
"targetDocumentId": "local-md:missing.md",
|
||
"includeResources": true,
|
||
"includeOcr": true
|
||
},
|
||
"mode": "hybrid",
|
||
"topK": 5
|
||
})
|
||
.to_string(),
|
||
))
|
||
.expect("request"),
|
||
)
|
||
.await
|
||
.expect("response");
|
||
|
||
assert_eq!(response.status(), StatusCode::OK);
|
||
let body = to_bytes(response.into_body(), usize::MAX)
|
||
.await
|
||
.expect("body");
|
||
let payload: Value = serde_json::from_slice(&body).expect("json");
|
||
let first = payload["results"]
|
||
.as_array()
|
||
.and_then(|items| items.first())
|
||
.expect("sqlite evidence result");
|
||
assert_eq!(
|
||
first["source"]["ownerDocumentPath"].as_str(),
|
||
Some("README.md")
|
||
);
|
||
assert_eq!(
|
||
first["source"]["schema"].as_str(),
|
||
Some("mnote.evidence_locator.v1")
|
||
);
|
||
fs::remove_dir_all(&root).ok();
|
||
}
|
||
|
||
#[test]
|
||
fn evidence_results_from_ocr_search_uses_source_map_locator() {
|
||
let root = std::env::temp_dir().join(format!(
|
||
"mnote-evidence-test-{}-{}",
|
||
std::process::id(),
|
||
std::time::SystemTime::now()
|
||
.duration_since(std::time::UNIX_EPOCH)
|
||
.expect("system time")
|
||
.as_nanos()
|
||
));
|
||
fs::create_dir_all(root.join("docs/Page.ocr")).expect("source map dir");
|
||
fs::write(
|
||
root.join("docs/Page.ocr/photo.png.source-map.json"),
|
||
serde_json::to_string_pretty(&json!({
|
||
"schema": RESOURCE_SOURCE_MAP_SCHEMA,
|
||
"provider": "mineru",
|
||
"ownerDocumentPath": "docs/Page.md",
|
||
"sourceRootRelativePath": "docs/Page.assets/photo.png",
|
||
"sourceHash": "size:3:mtime:1",
|
||
"pageCount": 1,
|
||
"pages": [{
|
||
"page": 1,
|
||
"textItems": [],
|
||
"blocks": [{
|
||
"id": "p1_b1",
|
||
"blockType": "paragraph",
|
||
"text": "OCR-only-token 识别正文",
|
||
"bbox": { "x0": 10.0, "y0": 20.0, "x1": 110.0, "y1": 40.0 },
|
||
"charRange": { "start": 0, "end": 18 }
|
||
}]
|
||
}],
|
||
"sections": []
|
||
}))
|
||
.expect("source map json"),
|
||
)
|
||
.expect("write source map");
|
||
let payload = json!({
|
||
"results": [{
|
||
"id": "local-md:docs~2FPage.md#ocr:docs/Page.assets/photo.png",
|
||
"documentId": "local-md:docs~2FPage.md",
|
||
"title": "Page",
|
||
"path": "docs/Page.md",
|
||
"resourceType": "markdown",
|
||
"snippet": "OCR-only-token 识别正文",
|
||
"ocrEvidence": {
|
||
"sourceRootRelativePath": "docs/Page.assets/photo.png",
|
||
"ocrRootRelativePath": "docs/Page.ocr/photo.png.ocr.md",
|
||
"provider": "mineru",
|
||
"status": "done"
|
||
},
|
||
"publicPath": "/documents/local-md:docs~2FPage.md?sourceKind=local_folder&rootUri=file%3A%2F%2F%2Fworkspace"
|
||
}]
|
||
});
|
||
|
||
let mut results = evidence_results_from_local_search(
|
||
&payload,
|
||
&root,
|
||
"file:///workspace",
|
||
EvidenceSearchMode::Hybrid,
|
||
"OCR-only-token",
|
||
);
|
||
enrich_citation_links(&mut results);
|
||
|
||
fs::remove_dir_all(&root).ok();
|
||
|
||
assert_eq!(results.len(), 1);
|
||
let locator = &results[0].source;
|
||
assert_eq!(locator.resource_kind, EvidenceResourceKind::Image);
|
||
assert_eq!(
|
||
locator.resource_path.as_deref(),
|
||
Some("docs/Page.assets/photo.png")
|
||
);
|
||
assert_eq!(
|
||
locator.source_map_path.as_deref(),
|
||
Some("docs/Page.ocr/photo.png.source-map.json")
|
||
);
|
||
assert_eq!(locator.page, Some(1));
|
||
assert_eq!(locator.block_id.as_deref(), Some("p1_b1"));
|
||
assert_eq!(locator.bbox.as_ref().map(|bbox| bbox.x0), Some(10.0));
|
||
assert_eq!(locator.char_range.as_ref().map(|range| range.end), Some(18));
|
||
assert_eq!(
|
||
locator.open_action.params["sourceMapPath"].as_str(),
|
||
Some("docs/Page.ocr/photo.png.source-map.json")
|
||
);
|
||
let citation_url = results[0].citation_url.as_deref().unwrap_or_default();
|
||
assert!(citation_url.starts_with("/documents/local-md:docs~2FPage.md?"));
|
||
assert!(citation_url.contains("resourceTab=resource%3Afile%3Afile%3A%2F%2F%2Fworkspace%3Adocs%2FPage.assets%2Fphoto.png"));
|
||
assert!(citation_url.contains("page=1"));
|
||
assert!(citation_url.contains("blockId=p1_b1"));
|
||
assert!(results[0]
|
||
.citation_markdown
|
||
.as_deref()
|
||
.unwrap_or_default()
|
||
.contains("photo.png"));
|
||
}
|
||
|
||
#[test]
|
||
fn sqlite_evidence_results_are_enriched_from_source_map() {
|
||
let root = std::env::temp_dir().join(format!(
|
||
"mnote-evidence-sqlite-enrich-{}-{}",
|
||
std::process::id(),
|
||
std::time::SystemTime::now()
|
||
.duration_since(std::time::UNIX_EPOCH)
|
||
.expect("system time")
|
||
.as_nanos()
|
||
));
|
||
fs::create_dir_all(root.join("docs/Page.ocr")).expect("source map dir");
|
||
fs::write(
|
||
root.join("docs/Page.ocr/spec.pdf.source-map.json"),
|
||
serde_json::to_string_pretty(&json!({
|
||
"schema": RESOURCE_SOURCE_MAP_SCHEMA,
|
||
"provider": "mineru",
|
||
"ownerDocumentPath": "docs/Page.md",
|
||
"sourceRootRelativePath": "docs/Page.assets/spec.pdf",
|
||
"sourceHash": "size:3:mtime:1",
|
||
"pageCount": 2,
|
||
"pages": [{
|
||
"page": 2,
|
||
"textItems": [],
|
||
"blocks": [{
|
||
"id": "p2_b7",
|
||
"blockType": "paragraph",
|
||
"text": "NeedleToken 原文定位",
|
||
"bbox": { "x0": 72.0, "y0": 220.0, "x1": 510.0, "y1": 268.0 },
|
||
"charRange": { "start": 5, "end": 16 }
|
||
}]
|
||
}],
|
||
"sections": []
|
||
}))
|
||
.expect("source map json"),
|
||
)
|
||
.expect("write source map");
|
||
|
||
let mut locator = EvidenceLocator::new(
|
||
"file:///workspace",
|
||
"local-md:docs~2FPage.md",
|
||
"docs/Page.md",
|
||
EvidenceResourceKind::Pdf,
|
||
EvidenceOpenAction {
|
||
action_type: "mnote.open_resource_locator".into(),
|
||
url: "/documents/local-md:docs~2FPage.md".into(),
|
||
params: json!({"resourcePath":"docs/Page.assets/spec.pdf"}),
|
||
},
|
||
);
|
||
locator.resource_path = Some("docs/Page.assets/spec.pdf".into());
|
||
locator.source_map_path = Some("docs/Page.ocr/spec.pdf.source-map.json".into());
|
||
let mut results = vec![EvidenceSearchResult {
|
||
evidence_id: "ev_spec".into(),
|
||
quote: "NeedleToken 原文定位".into(),
|
||
score: 1.0,
|
||
source: locator,
|
||
match_info: None,
|
||
citation_url: None,
|
||
citation_label: None,
|
||
citation_markdown: None,
|
||
}];
|
||
|
||
enrich_sqlite_evidence_results(&mut results, &root, "NeedleToken");
|
||
enrich_citation_links(&mut results);
|
||
fs::remove_dir_all(&root).ok();
|
||
|
||
let locator = &results[0].source;
|
||
assert_eq!(locator.page, Some(2));
|
||
assert_eq!(locator.block_id.as_deref(), Some("p2_b7"));
|
||
assert_eq!(locator.bbox.as_ref().map(|bbox| bbox.y0), Some(220.0));
|
||
assert_eq!(
|
||
locator.char_range.as_ref().map(|range| range.start),
|
||
Some(5)
|
||
);
|
||
assert_eq!(locator.open_action.params["page"].as_u64(), Some(2));
|
||
assert_eq!(
|
||
locator.open_action.params["blockId"].as_str(),
|
||
Some("p2_b7")
|
||
);
|
||
assert!(results[0]
|
||
.citation_url
|
||
.as_deref()
|
||
.unwrap_or_default()
|
||
.contains("sourceMapPath=docs%2FPage.ocr%2Fspec.pdf.source-map.json"));
|
||
assert!(results[0]
|
||
.citation_markdown
|
||
.as_deref()
|
||
.unwrap_or_default()
|
||
.contains("spec.pdf"));
|
||
}
|
||
|
||
#[test]
|
||
fn evidence_search_diagnostics_marks_partial_matches() {
|
||
let results = vec![EvidenceSearchResult {
|
||
evidence_id: "ev1".into(),
|
||
quote: "羧酸需要被保护".into(),
|
||
score: 0.7,
|
||
source: EvidenceLocator::new(
|
||
"file:///workspace",
|
||
"local-md:docs~2FPage.md",
|
||
"docs/Page.md",
|
||
EvidenceResourceKind::Markdown,
|
||
EvidenceOpenAction {
|
||
action_type: "mnote.open_resource_locator".into(),
|
||
url: "/documents/local-md:docs~2FPage.md".into(),
|
||
params: json!({}),
|
||
},
|
||
),
|
||
match_info: Some(core_protocol::EvidenceSearchMatchInfo {
|
||
rank: Some(1),
|
||
matched_terms: vec!["羧酸".into(), "保护".into()],
|
||
missing_terms: vec!["保护基".into()],
|
||
match_mode: "cjk_partial".into(),
|
||
match_scope: "block".into(),
|
||
strong: false,
|
||
}),
|
||
citation_url: None,
|
||
citation_label: None,
|
||
citation_markdown: None,
|
||
}];
|
||
|
||
let diagnostics = evidence_search_diagnostics("羧酸 保护基", &results, "evidence_sqlite");
|
||
assert_eq!(diagnostics["backend"].as_str(), Some("evidence_sqlite"));
|
||
assert_eq!(diagnostics["queryTokens"].as_array().map(Vec::len), Some(2));
|
||
assert_eq!(diagnostics["strongMatchCount"].as_u64(), Some(0));
|
||
assert_eq!(diagnostics["weakMatchCount"].as_u64(), Some(1));
|
||
assert_eq!(
|
||
diagnostics["reason"].as_str(),
|
||
Some("only_weak_partial_matches")
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn evidence_read_uses_source_map_context_and_section_blocks() {
|
||
let root = std::env::temp_dir().join(format!(
|
||
"mnote-evidence-read-source-map-{}-{}",
|
||
std::process::id(),
|
||
std::time::SystemTime::now()
|
||
.duration_since(std::time::UNIX_EPOCH)
|
||
.expect("system time")
|
||
.as_nanos()
|
||
));
|
||
fs::create_dir_all(root.join("docs/Page.ocr")).expect("source map dir");
|
||
fs::write(
|
||
root.join("docs/Page.ocr/spec.pdf.source-map.json"),
|
||
serde_json::to_string_pretty(&json!({
|
||
"schema": RESOURCE_SOURCE_MAP_SCHEMA,
|
||
"provider": "liteparse",
|
||
"ownerDocumentPath": "docs/Page.md",
|
||
"sourceRootRelativePath": "docs/Page.assets/spec.pdf",
|
||
"sourceHash": "sha256:demo",
|
||
"pageCount": 1,
|
||
"pages": [{
|
||
"page": 1,
|
||
"textItems": [],
|
||
"blocks": [
|
||
{"id": "p1_b1", "blockType": "paragraph", "text": "同节前文", "charRange": {"start": 0, "end": 4}},
|
||
{"id": "p1_b2", "blockType": "paragraph", "text": "AnchorToken 命中原文", "bbox": {"x0": 1.0, "y0": 2.0, "x1": 3.0, "y1": 4.0}, "charRange": {"start": 5, "end": 16}},
|
||
{"id": "p1_b3", "blockType": "paragraph", "text": "同节后文", "charRange": {"start": 17, "end": 21}}
|
||
]
|
||
}],
|
||
"sections": [{
|
||
"id": "sec_1",
|
||
"title": "解除条件",
|
||
"path": ["合同", "解除条件"],
|
||
"pageStart": 1,
|
||
"pageEnd": 1,
|
||
"blockIds": ["p1_b1", "p1_b2", "p1_b3"]
|
||
}]
|
||
}))
|
||
.expect("source map json"),
|
||
)
|
||
.expect("write source map");
|
||
let mut locator = EvidenceLocator::new(
|
||
"file:///workspace",
|
||
"local-md:docs~2FPage.md",
|
||
"docs/Page.md",
|
||
EvidenceResourceKind::Pdf,
|
||
EvidenceOpenAction {
|
||
action_type: "mnote.open_resource_locator".into(),
|
||
url: "/documents/local-md:docs~2FPage.md".into(),
|
||
params: json!({"resourcePath":"docs/Page.assets/spec.pdf"}),
|
||
},
|
||
);
|
||
locator.resource_path = Some("docs/Page.assets/spec.pdf".into());
|
||
locator.source_map_path = Some("docs/Page.ocr/spec.pdf.source-map.json".into());
|
||
locator.block_id = Some("p1_b2".into());
|
||
|
||
let results = read_source_map_context(&root, &locator, 0, 0).expect("source map context");
|
||
fs::remove_dir_all(&root).ok();
|
||
|
||
assert!(results
|
||
.iter()
|
||
.any(|item| item.quote == "AnchorToken 命中原文"));
|
||
assert!(results.iter().any(|item| item.quote == "同节前文"));
|
||
assert!(results.iter().any(|item| item.quote == "同节后文"));
|
||
let anchor = results
|
||
.iter()
|
||
.find(|item| item.source.block_id.as_deref() == Some("p1_b2"))
|
||
.expect("anchor");
|
||
assert_eq!(anchor.source.section_path, vec!["合同", "解除条件"]);
|
||
assert_eq!(anchor.source.bbox.as_ref().map(|bbox| bbox.y0), Some(2.0));
|
||
}
|
||
}
|