diff --git a/src/lib.rs b/src/lib.rs index f097991..509f690 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -31,6 +31,7 @@ pub mod linalg_ops; pub mod load; pub mod mlsp; pub mod parse; +pub mod repair; pub mod value; #[cfg(feature = "net-host")] pub mod version_check; diff --git a/src/mlsp.rs b/src/mlsp.rs index 23d17e8..e734f97 100644 --- a/src/mlsp.rs +++ b/src/mlsp.rs @@ -13,6 +13,7 @@ //! | `syntax` | 语法问答:关键字/别名 → 构造卡片 | //! | `validate` | 程序校验:结构化诊断数组(parse + 契约 check) | //! | `repair_targets` | 修复靶点:错误 → **有界**修复目标(越界必拒,护栏) | +//! | `repair_apply` | 应用行编辑(全有或全无;越界 ⇒ `mlsp.repair_out_of_scope` abstain) | //! | `schema` | 契约查询(T2.6):单元名 → 形参/返回/字段契约 | use std::path::{Path, PathBuf}; @@ -54,10 +55,11 @@ fn dispatch(req: &Value) -> Result { Some("syntax") => syntax(¶ms), Some("validate") => validate(¶ms), Some("repair_targets") => repair_targets(¶ms), + Some("repair_apply") => repair_apply(¶ms), Some("schema") => schema(¶ms), other => Err(err( "mlsp.unknown_method", - format!("未知方法 {other:?};可用:locate / syntax / validate / repair_targets / schema"), + format!("未知方法 {other:?};可用:locate / syntax / validate / repair_targets / repair_apply / schema"), )), } } @@ -191,6 +193,83 @@ fn repair_targets(params: &Value) -> Result { })) } +/// 应用有界修复(T3.3):行编辑全有或全无;越界 ⇒ `mlsp.repair_out_of_scope`(abstain),源零字节不改。 +fn repair_apply(params: &Value) -> Result { + let source = source_text(params)?; + let ranges = params + .get("ranges") + .and_then(|r| r.as_array()) + .ok_or_else(|| err("mlsp.bad_request", "repair_apply 需要 params.ranges([[起,止],…])"))? + .iter() + .map(|pair| { + let a = pair.as_array()?; + Some((a.first()?.as_u64()? as u32, a.get(1)?.as_u64()? as u32)) + }) + .collect::>>() + .ok_or_else(|| err("mlsp.bad_request", "ranges 必须是 [[起,止],…]"))?; + + let mut edits = Vec::new(); + let edit_list = params + .get("edits") + .and_then(|e| e.as_array()) + .ok_or_else(|| err("mlsp.bad_request", "repair_apply 需要 params.edits"))?; + for e in edit_list { + let line = e + .get("line") + .and_then(|l| l.as_u64()) + .ok_or_else(|| err("mlsp.bad_request", "edit 缺 line"))? as u32; + let text = e.get("text").and_then(|t| t.as_str()).unwrap_or("").to_string(); + edits.push(match e.get("op").and_then(|o| o.as_str()) { + Some("replace") => crate::repair::Edit::Replace { line, text }, + Some("delete") => crate::repair::Edit::Delete { line }, + Some("insert") => crate::repair::Edit::InsertBefore { line, text }, + other => { + return Err(err( + "mlsp.bad_request", + format!("未知编辑 op {other:?}(replace / delete / insert)"), + )) + } + }); + } + + match crate::repair::apply_edits(&source, &ranges, &edits) { + Ok(new_source) => { + if params.get("write").and_then(|w| w.as_bool()).unwrap_or(false) { + let path = params + .get("path") + .and_then(|p| p.as_str()) + .ok_or_else(|| err("mlsp.bad_request", "write=true 需要 params.path"))?; + std::fs::write(path, &new_source) + .map_err(|e| err("mlsp.io_error", format!("写回 {path} 失败: {e}")))?; + } + Ok(json!({"source": new_source, "edits_applied": edits.len()})) + } + Err(oos) => Err(json!({ + "code": "mlsp.repair_out_of_scope", + "message": format!( + "修复越界(abstain):触及行 {:?} 不在靶点范围 {:?} 内;已拒绝全部编辑,源未改动", + oos.lines, oos.ranges + ), + "lines": oos.lines, + "ranges": oos.ranges, + "on_violation": "abstain", + })), + } +} + +/// 取待修源码(source 直给 / path 读取)。 +fn source_text(params: &Value) -> Result { + if let Some(s) = params.get("source").and_then(|s| s.as_str()) { + return Ok(s.to_string()); + } + let path = params + .get("path") + .and_then(|p| p.as_str()) + .ok_or_else(|| err("mlsp.bad_request", "需要 params.source 或 params.path"))?; + std::fs::read_to_string(path) + .map_err(|e| err("mlsp.io_error", format!("读取 {path} 失败: {e}"))) +} + /// 契约查询(T2.6):单元名 → 形参/返回/字段契约。 fn schema(params: &Value) -> Result { let (module, path) = module_from_params(params)?; diff --git a/src/repair.rs b/src/repair.rs new file mode 100644 index 0000000..e9914a4 --- /dev/null +++ b/src/repair.rs @@ -0,0 +1,129 @@ +//! 有界修复(T3.3 护栏的**机械执行面**):锚点局部修复,越界必拒(abstain),全有或全无。 +//! +//! 修复循环三步:诊断(run/check)→ `mlsp repair_targets`(靶点 + 范围)→ `mlsp repair_apply`(改行)。 +//! 护栏不是提示词愿望,而是这里代码强制的: +//! +//! - 只允许三种行编辑:`Replace` / `Delete` / `InsertBefore`; +//! - 被触碰的每一行都必须落在靶点范围内(`InsertBefore` 额外允许紧跟范围末尾追加), +//! 否则**整体拒绝**并报越界行清单——一个字节都不改(全有或全无); +//! - 应用结果交给调用方复验(`validate` / `run`)。 +//! +//! 目标([three-problems.md](../../doc/roadmap/three-problems.md) §5.3):易锚定错误 +//! ≥80% 修复率的同时,**越权范围的改动必拒**、失败后 abstain 而非乱改。 + +use std::collections::{HashMap, HashSet}; + +/// 一行编辑(1-based 行号)。 +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum Edit { + /// 把 `line` 整行换成 `text`。 + Replace { line: u32, text: String }, + /// 删除 `line`。 + Delete { line: u32 }, + /// 在 `line` **之前**插入 `text`(允许 `line == 范围末行 + 1`,即紧跟块尾追加)。 + InsertBefore { line: u32, text: String }, +} + +impl Edit { + /// 被触碰的行(范围检查用)。 + pub fn touched(&self) -> u32 { + match self { + Edit::Replace { line, .. } | Edit::Delete { line } | Edit::InsertBefore { line, .. } => { + *line + } + } + } +} + +/// 越界拒绝(abstain):报告越界行与允许范围,源保持不变。 +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct OutOfScope { + pub lines: Vec, + pub ranges: Vec<(u32, u32)>, +} + +fn in_ranges(ranges: &[(u32, u32)], line: u32) -> bool { + ranges.iter().any(|(s, e)| line >= *s && line <= *e) +} + +fn at_tail(ranges: &[(u32, u32)], line: u32) -> bool { + ranges.iter().any(|(_, e)| line == e + 1) +} + +/// 全有或全无地应用行编辑。 +/// +/// - 任何被触碰行越出 `ranges`(或行号非法)⇒ [`Err`](越界清单),**源不变**; +/// - 同一行被多个编辑触碰时 `Delete` 优先于 `Replace`,同种后者覆盖前者。 +pub fn apply_edits( + source: &str, + ranges: &[(u32, u32)], + edits: &[Edit], +) -> Result { + let lines: Vec<&str> = source.lines().collect(); + let n_lines = lines.len() as u32; + + // ---- 范围检查(先全体验完再动源) ---- + let mut bad = Vec::new(); + for e in edits { + let line = e.touched(); + let legal = match e { + Edit::InsertBefore { .. } => { + (line >= 1 && line <= n_lines + 1) + && (in_ranges(ranges, line) || at_tail(ranges, line)) + } + _ => line >= 1 && line <= n_lines && in_ranges(ranges, line), + }; + if !legal { + bad.push(line); + } + } + bad.sort_unstable(); + bad.dedup(); + if !bad.is_empty() { + return Err(OutOfScope { + lines: bad, + ranges: ranges.to_vec(), + }); + } + + // ---- 应用 ---- + let mut replaced: HashMap = HashMap::new(); + let mut deleted: HashSet = HashSet::new(); + let mut inserts: HashMap> = HashMap::new(); + for e in edits { + match e { + Edit::Replace { line, text } => { + replaced.insert(*line, text.clone()); + } + Edit::Delete { line } => { + deleted.insert(*line); + replaced.remove(line); // Delete 优先 + } + Edit::InsertBefore { line, text } => { + inserts.entry(*line).or_default().push(text.clone()); + } + } + } + + let trailing_newline = source.ends_with('\n'); + let mut out: Vec = Vec::with_capacity(lines.len() + inserts.len()); + for (i, l) in lines.iter().enumerate() { + let n = (i + 1) as u32; + if let Some(texts) = inserts.get(&n) { + out.extend(texts.iter().cloned()); + } + if deleted.contains(&n) { + continue; + } + out.push(replaced.get(&n).cloned().unwrap_or_else(|| l.to_string())); + } + if let Some(texts) = inserts.get(&(n_lines + 1)) { + out.extend(texts.iter().cloned()); + } + + let mut s = out.join("\n"); + if trailing_newline { + s.push('\n'); + } + Ok(s) +} diff --git a/tests/repair_loop.rs b/tests/repair_loop.rs new file mode 100644 index 0000000..9495be5 --- /dev/null +++ b/tests/repair_loop.rs @@ -0,0 +1,362 @@ +//! T3.3 golden:**20 例易锚定错误**的修复循环(护栏机械执行 + 金修复可复现)。 +//! +//! 每例走完整循环: +//! 诊断(含 `span`/`doc_anchor`)→ 推导靶点范围 → 金修复(源 diff 自动推导行编辑, +//! 顺便机器验证「易锚定」= 金编辑全落范围内)→ `mlsp repair_apply` 应用 → 复验通过。 +//! +//! 护栏负例内嵌每例:越界编辑(第 1 行 `# main`,永不在靶点内)必拒 +//! (`mlsp.repair_out_of_scope` + `abstain`),源零字节不改。 +//! 模型实验(≥80% 修复率)只需把 `derive_edits` 的金修复换成模型输出的编辑。 + +use marqdo::diagnostics::Diagnostic; +use marqdo::mlsp::handle_line; +use marqdo::repair::{apply_edits, Edit}; +use marqdo::{run_file, RunOptions}; +use serde_json::{json, Value}; + +fn mcall(req: Value) -> Value { + serde_json::from_str(&handle_line(&req.to_string())).expect("MLSP 响应必须是合法 JSON") +} + +#[derive(Clone, Copy)] +enum Verify { + /// 运行期契约错(四边界):修复后 run 必须成功。 + Run(&'static str), + /// 静态错(check / parse):修复后 validate 零诊断。 + Static(&'static str), +} + +struct Case { + name: String, + broken: String, + gold: String, + verify: Verify, +} + +// ---------- 诊断 ---------- + +fn static_diags(src: &str) -> Vec { + let resp = mcall(json!({"id": 1, "method": "validate", "params": {"source": src}})); + if resp["ok"] == false { + return vec![resp["error"].clone()]; + } + resp["result"]["diagnostics"] + .as_array() + .cloned() + .unwrap_or_default() +} + +fn temp_path(idx: usize) -> std::path::PathBuf { + std::env::temp_dir().join(format!("marqdo_repair_gold_{idx}.mq.md")) +} + +fn run_diag(src: &str, idx: usize) -> Value { + let p = temp_path(idx); + std::fs::write(&p, src).unwrap(); + let err = run_file(&p, &RunOptions::default()) + .expect_err("broken 源必须报契约错"); + match Diagnostic::find(&err) { + Some(d) => d.to_json(), + None => json!({"code": "?", "message": format!("{err:#}")}), + } +} + +fn run_ok(src: &str, idx: usize) { + let p = temp_path(idx); + std::fs::write(&p, src).unwrap(); + run_file(&p, &RunOptions::default()).expect("修复后必须运行成功"); + let _ = std::fs::remove_file(&p); +} + +/// 诊断 JSON → 靶点范围(span 行 + doc_anchor 的 L 范围)。 +fn ranges_of(v: &Value) -> Vec<(u32, u32)> { + let mut rs = Vec::new(); + if let Some(l) = v["span"]["line"].as_u64() { + rs.push((l as u32, l as u32)); + } + if let Some(a) = v["doc_anchor"].as_str() { + if let Some(rest) = a.split('#').nth(1) { + if let Some(rest) = rest.strip_prefix('L') { + if let Some((s, e)) = rest.split_once("-L") { + if let (Ok(s), Ok(e)) = (s.parse(), e.parse()) { + rs.push((s, e)); + } + } + } + } + } + rs +} + +// ---------- 金修复 → 行编辑(前缀/后缀 diff) ---------- + +fn derive_edits(broken: &str, gold: &str) -> Vec { + let b: Vec<&str> = broken.lines().collect(); + let g: Vec<&str> = gold.lines().collect(); + let mut p = 0usize; + while p < b.len() && p < g.len() && b[p] == g[p] { + p += 1; + } + let mut s = 0usize; + while s < b.len() - p + && s < g.len() - p + && b[b.len() - 1 - s] == g[g.len() - 1 - s] + { + s += 1; + } + let mut edits = Vec::new(); + for l in (p + 1)..=(b.len() - s) { + edits.push(Edit::Delete { line: l as u32 }); + } + let at = (b.len() - s + 1) as u32; + for text in &g[p..(g.len() - s)] { + edits.push(Edit::InsertBefore { + line: at, + text: (*text).to_string(), + }); + } + edits +} + +fn apply_via_mlsp(src: &str, ranges: &[(u32, u32)], edits: &[Edit]) -> Value { + let resp = mcall(json!({ + "id": 2, + "method": "repair_apply", + "params": { + "source": src, + "ranges": ranges.iter().map(|(s, e)| json!([s, e])).collect::>(), + "edits": edits.iter().map(|e| match e { + Edit::Replace { line, text } => json!({"op": "replace", "line": line, "text": text}), + Edit::Delete { line } => json!({"op": "delete", "line": line}), + Edit::InsertBefore { line, text } => json!({"op": "insert", "line": line, "text": text}), + }).collect::>(), + } + })); + resp +} + +// ---------- 20 例(10 骨架 × 2 变体) ---------- + +fn cases() -> Vec { + let mut out: Vec = Vec::new(); + let push = |out: &mut Vec, name: &str, broken: String, gold: String, verify: Verify| { + out.push(Case { + name: name.to_string(), + broken, + gold, + verify, + }); + }; + + // 1–2 调用实参:数字形参传了文本(金修复改调用行 = span 侧) + for (v, lit, n) in [("a", "七", 7), ("b", "八", 8)] { + let broken = format!( + "# main\n\n> 加一 \"{lit}\"\n\n## 加一\n\n对于输入变量`n`,期望是数字。\n\n\ + | 参数 | 类型 | 说明 |\n|------|------|------|\n| n | number | 输入值 |\n\n\ + | 返回 | 类型 | 说明 |\n|------|------|------|\n| | number | 结果 |\n\n*n+1*\n" + ); + let gold = broken.replace(&format!("> 加一 \"{lit}\""), &format!("> 加一 {n}")); + push(&mut out, &format!("arg-num-{v}"), broken, gold, Verify::Run("contract.arg_mismatch")); + } + + // 3–4 调用实参:文本形参传了裸数(金修复加引号 = span 侧) + for (v, n) in [("a", 7), ("b", 8)] { + let broken = format!( + "# main\n\n> 转换 {n}\n\n## 转换\n\n对于输入变量`s`,期望是文本。\n\n\ + | 参数 | 类型 | 说明 |\n|------|------|------|\n| s | text | 输入 |\n\n\ + | 返回 | 类型 | 说明 |\n|------|------|------|\n| | text | 结果 |\n\n*s*\n" + ); + let gold = broken.replace(&format!("> 转换 {n}"), &format!("> 转换 \"{n}\"")); + push(&mut out, &format!("arg-text-{v}"), broken, gold, Verify::Run("contract.arg_mismatch")); + } + + // 5–6 返回契约:返回文本却声明 number(金修复改契约行 = anchor 侧) + for (v, lit) in [("a", "七"), ("b", "你好")] { + let broken = format!( + "# main\n\n**结果 = > 转换 \"{lit}\"**\n*结果*\n\n## 转换\n\n对于输入变量`s`,期望是文本。\n\n\ + | 参数 | 类型 | 说明 |\n|------|------|------|\n| s | text | 输入 |\n\n\ + | 返回 | 类型 | 说明 |\n|------|------|------|\n| | number | 结果 |\n\n*s*\n" + ); + let gold = broken.replace("| | number | 结果 |", "| | text | 结果 |"); + push(&mut out, &format!("ret-type-{v}"), broken, gold, Verify::Run("contract.return_mismatch")); + } + + // 7–8 字段类型:数据与字段契约不符(金修复改契约行 = anchor 侧) + { + let broken = "# main\n\n| 字段 | 类型 | 可空 |\n|------|------|------|\n| id | number | |\n| name | text | 是 |\n\n\ + `用户` =\n| id | name |\n|------|------|\n| abc | 小明 |\n\n*`用户`[^name]*\n" + .to_string(); + let gold = broken.replace("| id | number | |", "| id | text | |"); + push(&mut out, "field-type-a", broken, gold, Verify::Run("contract.field_mismatch")); + + let broken = "# main\n\n| 字段 | 类型 | 可空 |\n|------|------|------|\n| id | number | |\n| name | number | 是 |\n\n\ + `用户` =\n| id | name |\n|------|------|\n| 1 | 小明 |\n\n*`用户`[^name]*\n" + .to_string(); + let gold = broken.replace("| name | number | 是 |", "| name | text | 是 |"); + push(&mut out, "field-type-b", broken, gold, Verify::Run("contract.field_mismatch")); + } + + // 9–10 缺字段:数据没有契约要求的非空字段(金修复标可空 = anchor 侧) + { + let broken = "# main\n\n| 字段 | 类型 | 可空 |\n|------|------|------|\n| id | number | |\n| name | text | |\n\n\ + `用户` =\n| id | qq |\n|------|------|\n| 1 | 5 |\n\n*`用户`[^id]*\n" + .to_string(); + let gold = broken.replace("| name | text | |", "| name | text | 是 |"); + push(&mut out, "field-nullable-a", broken, gold, Verify::Run("contract.field_mismatch")); + + let broken = "# main\n\n| 字段 | 类型 | 可空 |\n|------|------|------|\n| id | number | |\n| name | text | |\n\n\ + `用户` =\n| name | qq |\n|------|------|\n| 小明 | 5 |\n\n*`用户`[^name]*\n" + .to_string(); + let gold = broken.replace("| id | number | |", "| id | number | 是 |"); + push(&mut out, "field-nullable-b", broken, gold, Verify::Run("contract.field_mismatch")); + } + + // 11–12 未知键:访问不在契约里的字段(金修复改索引键 = span 侧) + { + let broken = "# main\n\n| 字段 | 类型 | 可空 |\n|------|------|------|\n| id | number | |\n| name | text | 是 |\n\n\ + `用户` =\n| id | name |\n|------|------|\n| 1 | 小明 |\n\n*`用户`[^email]*\n" + .to_string(); + let gold = broken.replace("[^email]", "[^name]"); + let broken_b = broken.replace("[^email]", "[^phone]"); + let gold_b = broken_b.replace("[^phone]", "[^id]"); + push(&mut out, "key-fix-a", broken, gold, Verify::Run("contract.unknown_key")); + push(&mut out, "key-fix-b", broken_b, gold_b, Verify::Run("contract.unknown_key")); + } + + // 13–14 类型名拼错(金修复改正拼写 = anchor 侧) + for (v, typo, fix) in [("a", "nubmer", "number"), ("b", "txt", "text")] { + let broken = format!( + "# main\n\n## 加一\n\n对于输入变量`n`,执行加一。\n\n\ + | 参数 | 类型 | 说明 |\n|------|------|------|\n| n | {typo} | 输入值 |\n\n*n+1*\n" + ); + let gold = broken.replace(typo, fix); + push(&mut out, &format!("type-typo-{v}"), broken, gold, Verify::Static("contract.unknown_type")); + } + + // 15–16 契约行名字错位(金修复改行名 = anchor 侧) + for (v, wrong) in [("a", "nn"), ("b", "nm")] { + let broken = format!( + "# main\n\n## 加一\n\n对于输入变量`n`,执行加一。\n\n\ + | 参数 | 类型 | 说明 |\n|------|------|------|\n| {wrong} | number | 输入值 |\n\n*n+1*\n" + ); + let gold = broken.replace(&format!("| {wrong} | number | 输入值 |"), "| n | number | 输入值 |"); + push(&mut out, &format!("drift-rename-{v}"), broken, gold, Verify::Static("contract.param_drift")); + } + + // 17–18 新升参未被契约覆盖(金修复补契约行 = anchor 侧,插入表尾) + for (v, extra) in [("a", "m"), ("b", "k")] { + let broken = format!( + "# main\n\n## 加一\n\n对于输入变量`n`,临时量`{extra}`。\n\n\ + | 参数 | 类型 | 说明 |\n|------|------|------|\n| n | number | 输入值 |\n\n*n + {extra}*\n" + ); + let gold = broken.replace( + "| n | number | 输入值 |", + &format!("| n | number | 输入值 |\n| {extra} | number | 临时 |"), + ); + push(&mut out, &format!("drift-cover-{v}"), broken, gold, Verify::Static("contract.param_drift")); + } + + // 19–20 两份契约打架(金修复删第二张表 = anchor 侧,纯删除) + { + let broken = "# main\n\n## 加一\n\n对于输入变量`n`,执行加一。\n\n\ + | 参数 | 类型 | 说明 |\n|------|------|------|\n| n | number | 输入值 |\n\n\ + | 参数 | 类型 | 说明 |\n|------|------|------|\n| n | number | 重复 |\n\n*n+1*\n" + .to_string(); + let gold = broken.replace( + "\n| 参数 | 类型 | 说明 |\n|------|------|------|\n| n | number | 重复 |", + "", + ); + push(&mut out, "dup-delete-a", broken, gold, Verify::Static("contract.duplicate")); + + let broken = "# main\n\n## 转换\n\n对于输入变量`s`,期望是文本。\n\n\ + | 参数 | 类型 | 说明 |\n|------|------|------|\n| s | text | 输入 |\n\n\ + | 返回 | 类型 | 说明 |\n|------|------|------|\n| | text | 结果 |\n\n\ + | 返回 | 类型 | 说明 |\n|------|------|------|\n| | text | 同上 |\n\n*s*\n" + .to_string(); + let gold = broken.replace( + "\n| 返回 | 类型 | 说明 |\n|------|------|------|\n| | text | 同上 |", + "", + ); + push(&mut out, "dup-delete-b", broken, gold, Verify::Static("contract.duplicate")); + } + + out +} + +// ---------- 完整修复循环 ---------- + +#[test] +fn golden_repair_loop_all_20() { + let cases = cases(); + assert_eq!(cases.len(), 20, "golden 必须正好 20 例"); + + for (idx, case) in cases.iter().enumerate() { + // 1. 诊断(broken 必须给出期望错误码) + let (code, diags) = match case.verify { + Verify::Run(code) => (code, vec![run_diag(&case.broken, idx)]), + Verify::Static(code) => (code, static_diags(&case.broken)), + }; + assert!( + diags.iter().any(|d| d["code"] == code), + "[{}] 期望诊断 {code},实得 {diags:?}", + case.name + ); + let ranges: Vec<(u32, u32)> = diags.iter().flat_map(ranges_of).collect(); + assert!(!ranges.is_empty(), "[{}] 诊断必须带可锚定范围: {diags:?}", case.name); + + // 2. 金修复 → 行编辑(diff 自动推导);「易锚定」= 全部编辑落在靶点内 + let edits = derive_edits(&case.broken, &case.gold); + assert!(!edits.is_empty(), "[{}] 金修复必须产生编辑", case.name); + let applied = apply_edits(&case.broken, &ranges, &edits).unwrap_or_else(|oos| { + panic!("[{}] 金修复越界(不是易锚定错误): 越界 {:?},范围 {:?}", case.name, oos.lines, oos.ranges) + }); + assert_eq!(applied, case.gold, "[{}] 行编辑结果应与金修复逐字节一致", case.name); + + // 3. 经 MLSP 面应用(护栏所在) + let resp = apply_via_mlsp(&case.broken, &ranges, &edits); + assert_eq!(resp["ok"], true, "[{}] repair_apply 应接受金修复: {resp}", case.name); + assert_eq!(resp["result"]["source"], case.gold, "[{}]", case.name); + + // 4. 复验 + match case.verify { + Verify::Run(_) => run_ok(&case.gold, idx), + Verify::Static(_) => { + let after = static_diags(&case.gold); + assert!(after.is_empty(), "[{}] 修复后必须零诊断: {after:?}", case.name); + } + } + + // 5. 护栏负例:越界编辑(第 1 行 `# main`)必拒 + 源零字节不改 + let bad = vec![Edit::Replace { line: 1, text: "# 被篡改".to_string() }]; + let resp = apply_via_mlsp(&case.broken, &ranges, &bad); + assert_eq!(resp["ok"], false, "[{}] 越界编辑必须被拒: {resp}", case.name); + assert_eq!(resp["error"]["code"], "mlsp.repair_out_of_scope", "[{}]", case.name); + assert_eq!(resp["error"]["on_violation"], "abstain", "[{}]", case.name); + } +} + +#[test] +fn repair_apply_refuses_any_out_of_scope_line() { + // 独立护栏例:部分越界 = 全部拒绝(全有或全无),源零字节不改。 + let src = "# main\n\n| 字段 | 类型 | 可空 |\n|------|------|------|\n| id | number | |\n| name | text | 是 |\n\n*1*\n"; + let ranges = [(3u32, 6u32)]; // 只有字段契约表 + let edits = vec![ + Edit::Replace { line: 5, text: "| id | text | |".to_string() }, // 表内 ✓ + Edit::Delete { line: 1 }, // 越界 ✗ + ]; + let resp = apply_via_mlsp(src, &ranges, &edits); + assert_eq!(resp["ok"], false); + assert_eq!(resp["error"]["code"], "mlsp.repair_out_of_scope"); + assert!(resp["error"]["lines"].as_array().unwrap().contains(&json!(1))); + + // 范围内编辑照常可用(含表尾追加) + let edits = vec![ + Edit::Replace { line: 5, text: "| id | text | |".to_string() }, + Edit::InsertBefore { line: 7, text: "| email | text | 是 |".to_string() }, // end+1 追加 ✓ + ]; + let resp = apply_via_mlsp(src, &ranges, &edits); + assert_eq!(resp["ok"], true, "{resp}"); + let out = resp["result"]["source"].as_str().unwrap(); + assert!(out.contains("| id | text | |")); + assert!(out.contains("| email | text | 是 |")); +}