use crate::mcp::machine_codes;
use crate::mcp::schemas::{disposition, finding, severity, verdict, ToolResponse};
use crate::services::patch_analysis as patch_facts;
use crate::tools::helpers::*;
use serde_json::Value;
use std::collections::BTreeMap;
pub fn patch_apply_check(args: &Value) -> ToolResponse {
let budget_ctx = crate::mcp::budget::for_handler(crate::mcp::budget::ToolBudget::MODERATE);
let original_text_val = args.get("original_text");
let original_text = match original_text_val.and_then(|v| v.as_str()) {
Some(s) => s,
None => {
let type_name = match original_text_val {
Some(v) => json_type_name(v),
None => "NoneType",
};
return ToolResponse::error_with_code(
"invalid_arguments",
machine_codes::INVALID_ARGUMENTS,
&format!("original_text must be a string, got {}", type_name),
None,
Some("patch_apply_check"),
);
}
};
let patch_text_val = args.get("patch_text");
let patch_text = match patch_text_val.and_then(|v| v.as_str()) {
Some(s) => s,
None => {
let type_name = match patch_text_val {
Some(v) => json_type_name(v),
None => "NoneType",
};
return ToolResponse::error_with_code(
"invalid_arguments",
machine_codes::INVALID_ARGUMENTS,
&format!("patch_text must be a string, got {}", type_name),
None,
Some("patch_apply_check"),
);
}
};
let strict = args.get("strict").and_then(|v| v.as_bool()).unwrap_or(true);
let return_result_fingerprint = args
.get("return_result_fingerprint")
.and_then(|v| v.as_bool())
.unwrap_or(true);
let return_result_text = args
.get("return_result_text")
.and_then(|v| v.as_bool())
.unwrap_or(false);
const MAX_ORIGINAL_LENGTH: usize = 200_000;
const MAX_PATCH_LENGTH: usize = 100_000;
let original_chars = original_text.chars().count();
if original_chars > MAX_ORIGINAL_LENGTH || original_text.len() > MAX_ORIGINAL_LENGTH {
let length = if original_chars > MAX_ORIGINAL_LENGTH {
format!("{} characters", original_chars)
} else {
format!("{} bytes", original_text.len())
};
return ToolResponse::error_with_code(
"input_too_large",
machine_codes::INPUT_TOO_LARGE,
&format!(
"Original text length {} exceeds maximum of {}",
length, MAX_ORIGINAL_LENGTH
),
Some(vec![format!(
"Maximum original text length is {}",
MAX_ORIGINAL_LENGTH
)]),
Some("patch_apply_check"),
);
}
let patch_chars = patch_text.chars().count();
if patch_chars > MAX_PATCH_LENGTH || patch_text.len() > MAX_PATCH_LENGTH {
let length = if patch_chars > MAX_PATCH_LENGTH {
format!("{} characters", patch_chars)
} else {
format!("{} bytes", patch_text.len())
};
return ToolResponse::error_with_code(
"input_too_large",
machine_codes::INPUT_TOO_LARGE,
&format!(
"Patch text length {} exceeds maximum of {}",
length, MAX_PATCH_LENGTH
),
Some(vec![format!(
"Maximum patch text length is {}",
MAX_PATCH_LENGTH
)]),
Some("patch_apply_check"),
);
}
let result = crate::text::patch_apply_check(
original_text,
patch_text,
strict,
return_result_fingerprint,
return_result_text,
);
if budget_ctx.should_stop() {
return budget_ctx
.check_should_stop("patch_apply_check")
.unwrap_err();
}
let mut findings: Vec<serde_json::Value> = Vec::new();
for msg in &result.findings {
findings.push(finding(
"PATCH_FINDING",
severity::MEDIUM,
msg,
Some(disposition::CAUTION),
None,
));
}
if !result.patch_parse_ok {
findings.push(finding(
"PATCH_PARSE_FAILED",
severity::HIGH,
"Patch failed to parse",
Some(disposition::BLOCKING),
None,
));
} else if !result.applies {
findings.push(finding(
"PATCH_FAILED",
severity::HIGH,
"Patch does not apply cleanly",
Some(disposition::BLOCKING),
None,
));
}
let (response_verdict, machine_code) = if !result.patch_parse_ok || !result.applies {
(verdict::BLOCK, machine_codes::PATCH_FAILED)
} else if result.hunks_failed > 0 {
(verdict::REVIEW, machine_codes::PATCH_FAILED)
} else {
(verdict::ALLOW, machine_codes::EDIT_OK)
};
let mut resp = ToolResponse::success(
serde_json::json!({
"patch_parse_ok": result.patch_parse_ok,
"applies": result.applies,
"hunks_total": result.hunks_total,
"hunks_applied": result.hunks_applied,
"hunks_failed": result.hunks_failed,
"failed_hunks": result.failed_hunks,
"affected_line_ranges": result.affected_line_ranges,
"newline_style_before": result.newline_style_before,
"newline_style_after": result.newline_style_after,
"result_fingerprint": result.result_fingerprint,
"result_text": result.result_text,
"verdict": response_verdict,
"findings": findings,
}),
Some("patch_apply_check"),
)
.with_tool("patch_apply_check")
.with_machine_code(machine_code)
.with_verdict(response_verdict);
if !findings.is_empty() {
resp = resp.with_findings(findings);
}
resp
}
pub fn patch_summary(args: &Value) -> ToolResponse {
let budget_ctx = crate::mcp::budget::for_handler(crate::mcp::budget::ToolBudget::MODERATE);
let patch_text_val = args.get("patch_text");
let patch_text = match patch_text_val.and_then(|v| v.as_str()) {
Some(s) => s,
None => {
let type_name = match patch_text_val {
Some(v) => json_type_name(v),
None => "NoneType",
};
return ToolResponse::error_with_code(
"invalid_arguments",
machine_codes::INVALID_ARGUMENTS,
&format!("patch_text must be a string, got {}", type_name),
None,
Some("patch_summary"),
);
}
};
const MAX_PATCH_LENGTH: usize = 100_000;
if patch_text.chars().count() > MAX_PATCH_LENGTH {
return ToolResponse::error_with_code(
"input_too_large",
machine_codes::INPUT_TOO_LARGE,
&format!(
"Patch text length {} exceeds maximum of {}",
patch_text.chars().count(),
MAX_PATCH_LENGTH
),
None,
Some("patch_summary"),
);
}
let analysis = patch_facts::analyze_patch(patch_text);
if budget_ctx.should_stop() {
return budget_ctx.check_should_stop("patch_summary").unwrap_err();
}
let finding_msgs: Vec<String> = if !analysis.ok {
vec![format!(
"Failed to parse patch: {}",
analysis.error.clone().unwrap_or_default()
)]
} else if analysis.binary_patch_detected {
vec!["Binary patch content detected".to_string()]
} else {
Vec::new()
};
let mut findings: Vec<serde_json::Value> = Vec::new();
for msg in &finding_msgs {
findings.push(finding(
"PATCH_SUMMARY_FINDING",
severity::INFO,
msg,
Some(disposition::INFORMATIONAL),
None,
));
}
let result = analysis;
let has_warnings = result.binary_patch_detected || !result.renames_detected.is_empty();
let response_verdict = if has_warnings {
verdict::REVIEW
} else {
verdict::ALLOW
};
let machine_code = if has_warnings {
machine_codes::PATCH_FAILED
} else {
machine_codes::EDIT_OK
};
let mut resp = ToolResponse::success(
serde_json::json!({
"files_changed": result.files_changed,
"hunks_total": result.hunks_total,
"additions": result.additions,
"deletions": result.deletions,
"renames_detected": result.renames_detected,
"binary_patch_detected": result.binary_patch_detected,
"line_ranges_by_file": result.line_ranges_by_file,
"findings": findings,
"verdict": response_verdict,
}),
Some("patch_summary"),
)
.with_tool("patch_summary")
.with_machine_code(machine_code)
.with_verdict(response_verdict);
if !findings.is_empty() {
resp = resp.with_findings(findings);
}
resp
}
fn derive_primary_machine_code(
findings: &[serde_json::Value],
) -> (&'static str, Option<(&'static str, &'static str)>) {
for f in findings {
let code = match f.get("code").and_then(|v| v.as_str()) {
Some(c) => c,
None => continue,
};
match code {
"PATH_SCOPE_ESCAPE" => {
return (machine_codes::PATH_SCOPE_ESCAPE, None);
}
"INVALID_RANGE" => {
return (machine_codes::LINE_RANGE_INVALID, None);
}
"PATCH_FAILED" | "PATCH_ERROR" => {
return (machine_codes::PATCH_FAILED, None);
}
"NO_MATCH" | "MULTIPLE_MATCHES" => {
return (
machine_codes::AMBIGUOUS_REPLACEMENT,
Some(("text_diff_explain", "literal replacement was ambiguous")),
);
}
"FINGERPRINT_MISMATCH" => {
return (
machine_codes::FINGERPRINT_MISMATCH,
Some(("text_diff_explain", "content fingerprint mismatch")),
);
}
"UNICODE_RISK" => {
return (machine_codes::UNICODE_RISK, None);
}
"NEWLINE_INCONSISTENCY" => {
return (machine_codes::NEWLINE_INCONSISTENCY, None);
}
_ => continue,
}
}
(machine_codes::EDIT_OK, None)
}
fn derive_verdict(
findings: &[serde_json::Value],
_primary_code: &str,
replacement_mode: &str,
) -> (&'static str, bool, String) {
let has_error = findings
.iter()
.any(|f| f.get("severity").and_then(|v| v.as_str()) == Some(severity::HIGH));
let has_warning = findings
.iter()
.any(|f| f.get("severity").and_then(|v| v.as_str()) == Some(severity::MEDIUM));
let ok_to_apply = !has_error;
let response_verdict = if has_error {
verdict::BLOCK
} else if has_warning {
verdict::REVIEW
} else {
verdict::ALLOW
};
let summary = if ok_to_apply {
format!("Edit OK ({} mode)", replacement_mode)
} else {
format!("Edit blocked ({} mode)", replacement_mode)
};
let summary = if findings.is_empty() {
summary
} else {
format!("{}; {} finding(s)", summary, findings.len())
};
(response_verdict, ok_to_apply, summary)
}
pub fn edit_preflight(args: &Value) -> ToolResponse {
let budget_ctx = crate::mcp::budget::for_handler(crate::mcp::budget::ToolBudget::HEAVY);
let original = match args.get("original").and_then(|v| v.as_str()) {
Some(s) => s,
None => {
return ToolResponse::error_with_code(
"invalid_arguments",
machine_codes::INVALID_ARGUMENTS,
"Missing 'original' parameter",
None,
Some("edit_preflight"),
)
}
};
let replacement_mode = args
.get("replacement_mode")
.and_then(|v| v.as_str())
.unwrap_or("literal");
let strict = args.get("strict").and_then(|v| v.as_bool()).unwrap_or(true);
let expected_fingerprint = args.get("expected_fingerprint").and_then(|v| v.as_str());
let file_path = args.get("file_path").and_then(|v| v.as_str());
let workspace_root = args.get("workspace_root").and_then(|v| v.as_str());
let newline_policy = args
.get("newline_policy")
.and_then(|v| v.as_str())
.unwrap_or("skip");
let unicode_policy = args
.get("unicode_policy")
.and_then(|v| v.as_str())
.unwrap_or("skip");
if original.len() > MAX_TEXT_LENGTH {
return ToolResponse::error_with_code(
"input_too_large",
machine_codes::INPUT_TOO_LARGE,
&format!("Original text exceeds {} bytes", MAX_TEXT_LENGTH),
None,
Some("edit_preflight"),
);
}
let valid_modes = ["literal", "patch", "line_range"];
if !valid_modes.contains(&replacement_mode) {
return ToolResponse::error_with_code(
"invalid_arguments",
machine_codes::EDIT_MODE_INVALID,
&format!(
"replacement_mode must be one of: {}",
valid_modes.join(", ")
),
None,
Some("edit_preflight"),
);
}
match replacement_mode {
"literal" => {
let has_old = args.get("old").and_then(|v| v.as_str()).is_some();
let has_new = args.get("new").and_then(|v| v.as_str()).is_some();
if !has_old || !has_new {
let mut missing = Vec::new();
if !has_old {
missing.push("old");
}
if !has_new {
missing.push("new");
}
return ToolResponse::error_with_code(
"invalid_arguments",
machine_codes::EDIT_ARGUMENTS_MISSING,
&format!(
"literal mode requires 'old' and 'new'; missing: {}",
missing.join(", ")
),
None,
Some("edit_preflight"),
);
}
if args.get("patch").and_then(|v| v.as_str()).is_some() {
return ToolResponse::error_with_code(
"invalid_arguments",
machine_codes::EDIT_ARGUMENTS_CONFLICT,
"literal mode does not accept 'patch' argument",
None,
Some("edit_preflight"),
);
}
if args.get("start_line").is_some() || args.get("end_line").is_some() {
return ToolResponse::error_with_code(
"invalid_arguments",
machine_codes::EDIT_ARGUMENTS_CONFLICT,
"literal mode does not accept 'start_line' or 'end_line' arguments",
None,
Some("edit_preflight"),
);
}
}
"patch" => {
if args.get("patch").and_then(|v| v.as_str()).is_none() {
return ToolResponse::error_with_code(
"invalid_arguments",
machine_codes::EDIT_ARGUMENTS_MISSING,
"patch mode requires 'patch'",
None,
Some("edit_preflight"),
);
}
if args.get("old").and_then(|v| v.as_str()).is_some()
|| args.get("new").and_then(|v| v.as_str()).is_some()
{
return ToolResponse::error_with_code(
"invalid_arguments",
machine_codes::EDIT_ARGUMENTS_CONFLICT,
"patch mode does not accept 'old' or 'new' arguments",
None,
Some("edit_preflight"),
);
}
}
"line_range" => {
let has_start = args.get("start_line").and_then(|v| v.as_u64()).is_some();
let has_end = args.get("end_line").and_then(|v| v.as_u64()).is_some();
let has_new = args.get("new").and_then(|v| v.as_str()).is_some();
if !has_start || !has_end || !has_new {
let mut missing = Vec::new();
if !has_start {
missing.push("start_line");
}
if !has_end {
missing.push("end_line");
}
if !has_new {
missing.push("new");
}
return ToolResponse::error_with_code(
"invalid_arguments",
machine_codes::EDIT_ARGUMENTS_MISSING,
&format!(
"line_range mode requires 'start_line', 'end_line', and 'new'; missing: {}",
missing.join(", ")
),
None,
Some("edit_preflight"),
);
}
let start = match args.get("start_line").and_then(|v| v.as_u64()) {
Some(v) => v,
None => {
return ToolResponse::error_with_code(
"invalid_arguments",
machine_codes::EDIT_ARGUMENTS_INVALID,
"Field 'start_line' must be a positive integer",
None,
Some("edit_preflight"),
);
}
};
let end = match args.get("end_line").and_then(|v| v.as_u64()) {
Some(v) => v,
None => {
return ToolResponse::error_with_code(
"invalid_arguments",
machine_codes::EDIT_ARGUMENTS_INVALID,
"Field 'end_line' must be a positive integer",
None,
Some("edit_preflight"),
);
}
};
if start > end {
return ToolResponse::error_with_code(
"invalid_arguments",
machine_codes::LINE_RANGE_INVALID,
&format!("start_line ({}) must be <= end_line ({})", start, end),
None,
Some("edit_preflight"),
);
}
if args.get("old").and_then(|v| v.as_str()).is_some() {
return ToolResponse::error_with_code(
"invalid_arguments",
machine_codes::EDIT_ARGUMENTS_CONFLICT,
"line_range mode does not accept 'old' argument (old text is derived from the range)",
None,
Some("edit_preflight"),
);
}
if args.get("patch").and_then(|v| v.as_str()).is_some() {
return ToolResponse::error_with_code(
"invalid_arguments",
machine_codes::EDIT_ARGUMENTS_CONFLICT,
"line_range mode does not accept 'patch' argument",
None,
Some("edit_preflight"),
);
}
}
_ => {
return ToolResponse::error_with_code(
"invalid_arguments",
machine_codes::EDIT_MODE_INVALID,
&format!("Unsupported replacement_mode: {}", replacement_mode),
None,
Some("edit_preflight"),
);
}
}
if let Some(meta) = args.get("edit_metadata").and_then(|v| v.as_object()) {
for field in &[
"description",
"author",
"source_tool",
"session_id",
"request_id",
] {
if let Some(val) = meta.get(*field).and_then(|v| v.as_str()) {
if val.len() > MAX_METADATA_FIELD_LENGTH {
return ToolResponse::error_with_code(
"metadata_oversize",
machine_codes::EDIT_METADATA_TOO_LARGE,
&format!(
"edit_metadata.{} exceeds {} char limit",
field, MAX_METADATA_FIELD_LENGTH
),
None,
Some("edit_preflight"),
);
}
}
}
}
let mut subresults = serde_json::Map::new();
let mut findings: Vec<serde_json::Value> = Vec::new();
if budget_ctx.should_stop() {
return budget_ctx.check_should_stop("edit_preflight").unwrap_err();
}
match replacement_mode {
"literal" => {
let old = match args.get("old").and_then(|v| v.as_str()) {
Some(v) => v,
None => {
return ToolResponse::error_with_code(
"invalid_arguments",
machine_codes::EDIT_ARGUMENTS_INVALID,
"Field 'old' must be a string",
None,
Some("edit_preflight"),
);
}
};
let new = match args.get("new").and_then(|v| v.as_str()) {
Some(v) => v,
None => {
return ToolResponse::error_with_code(
"invalid_arguments",
machine_codes::EDIT_ARGUMENTS_INVALID,
"Field 'new' must be a string",
None,
Some("edit_preflight"),
);
}
};
match crate::text::replace::text_replace_check(
original, old, new, "exact", None, false, "preserve", false, 2000,
) {
Ok(tr) => {
subresults.insert(
"text_replace_check".to_string(),
serde_json::json!({
"match_count": tr.match_count,
"unique_match": tr.unique_match,
}),
);
if tr.match_count == 0 {
findings.push(finding(
"NO_MATCH",
severity::HIGH,
"old text not found in original",
Some(disposition::BLOCKING),
None,
));
} else if tr.match_count > 1 {
findings.push(finding(
"MULTIPLE_MATCHES",
severity::MEDIUM,
&format!("Found {} matches; use allow_multiple=true", tr.match_count),
Some(disposition::CAUTION),
None,
));
}
}
Err(_) => {
}
}
}
"patch" => {
let patch_text = match args.get("patch").and_then(|v| v.as_str()) {
Some(v) => v,
None => {
return ToolResponse::error_with_code(
"invalid_arguments",
machine_codes::EDIT_ARGUMENTS_INVALID,
"Field 'patch' must be a string",
None,
Some("edit_preflight"),
);
}
};
const MAX_ORIGINAL_LENGTH: usize = 200_000;
const MAX_PATCH_LENGTH: usize = 100_000;
let original_chars = original.chars().count();
let patch_chars = patch_text.chars().count();
if original_chars > MAX_ORIGINAL_LENGTH || original.len() > MAX_ORIGINAL_LENGTH {
findings.push(finding(
"PATCH_ERROR",
severity::HIGH,
&format!("Original text length exceeds maximum of {MAX_ORIGINAL_LENGTH}"),
Some(disposition::BLOCKING),
None,
));
} else if patch_chars > MAX_PATCH_LENGTH || patch_text.len() > MAX_PATCH_LENGTH {
findings.push(finding(
"PATCH_ERROR",
severity::HIGH,
&format!("Patch text length exceeds maximum of {MAX_PATCH_LENGTH}"),
Some(disposition::BLOCKING),
None,
));
} else {
let pa = crate::text::patch_apply_check(original, patch_text, strict, true, false);
subresults.insert(
"patch_apply_check".to_string(),
serde_json::json!({
"patch_parse_ok": pa.patch_parse_ok,
"applies": pa.applies,
"hunks_total": pa.hunks_total,
"hunks_applied": pa.hunks_applied,
"hunks_failed": pa.hunks_failed,
"failed_hunks": pa.failed_hunks,
"affected_line_ranges": pa.affected_line_ranges,
"newline_style_before": pa.newline_style_before,
"newline_style_after": pa.newline_style_after,
"result_fingerprint": pa.result_fingerprint,
"result_text": pa.result_text,
}),
);
if !pa.applies {
findings.push(finding(
"PATCH_FAILED",
severity::HIGH,
"Patch does not apply cleanly",
Some(disposition::BLOCKING),
None,
));
}
}
}
"line_range" => {
let start_line = match args.get("start_line").and_then(|v| v.as_u64()) {
Some(v) => v as usize,
None => {
return ToolResponse::error_with_code(
"invalid_arguments",
machine_codes::EDIT_ARGUMENTS_INVALID,
"Field 'start_line' must be a positive integer",
None,
Some("edit_preflight"),
);
}
};
let end_line = match args.get("end_line").and_then(|v| v.as_u64()) {
Some(v) => v as usize,
None => {
return ToolResponse::error_with_code(
"invalid_arguments",
machine_codes::EDIT_ARGUMENTS_INVALID,
"Field 'end_line' must be a positive integer",
None,
Some("edit_preflight"),
);
}
};
match crate::text::line_range_extract(original, start_line, end_line, 1, false, true) {
Ok(lr) => {
subresults.insert(
"line_range_extract".to_string(),
serde_json::json!({
"valid_range": lr.valid_range,
"fingerprint": lr.fingerprint,
"newline_style": lr.newline_style,
}),
);
if !lr.valid_range {
findings.push(finding(
"INVALID_RANGE",
severity::HIGH,
"Invalid line range",
Some(disposition::BLOCKING),
None,
));
}
}
Err(_) => {
}
}
}
_ => {
return ToolResponse::error_with_code(
"invalid_arguments",
machine_codes::EDIT_MODE_INVALID,
&format!("Unsupported replacement_mode: {}", replacement_mode),
None,
Some("edit_preflight"),
);
}
}
if budget_ctx.should_stop() {
return budget_ctx.check_should_stop("edit_preflight").unwrap_err();
}
let mut fingerprint_result: Option<Value> = None;
if let Some(fp) = expected_fingerprint {
let (actual_fp, fp_source, newline_style) = if replacement_mode == "patch" {
let fp_val = subresults
.get("patch_apply_check")
.and_then(|r| r.get("result_fingerprint"))
.and_then(|v| v.as_str())
.unwrap_or("");
let nl = subresults
.get("patch_apply_check")
.and_then(|r| r.get("newline_style_after"))
.and_then(|v| v.as_str())
.unwrap_or("unknown")
.to_string();
(fp_val.to_string(), "patch_apply_check", nl)
} else if replacement_mode == "line_range" {
let fp_val = subresults
.get("line_range_extract")
.and_then(|r| r.get("fingerprint"))
.and_then(|v| v.as_str())
.unwrap_or("");
let nl = subresults
.get("line_range_extract")
.and_then(|r| r.get("newline_style"))
.and_then(|v| v.as_str())
.unwrap_or("unknown")
.to_string();
(fp_val.to_string(), "line_range_extract", nl)
} else {
let facts = crate::services::fingerprint_facts(original);
subresults.insert(
"text_fingerprint".to_string(),
serde_json::json!({
"sha256": facts.sha256,
"newline_style": facts.newline_style,
}),
);
(facts.sha256, "text_fingerprint", facts.newline_style)
};
fingerprint_result = Some(serde_json::json!({
"sha256": actual_fp,
"newline_style": newline_style,
}));
if actual_fp != fp {
findings.push(finding(
"FINGERPRINT_MISMATCH",
severity::MEDIUM,
&format!("Expected {}, got {} (from {})", fp, actual_fp, fp_source),
Some(disposition::CAUTION),
None,
));
}
}
let mut path_scope_result: Option<Value> = None;
if let (Some(fp), Some(wr)) = (file_path, workspace_root) {
let ps = crate::text::path_scope_check(wr, fp, "posix", true);
{
let inside_root = ps.inside_root;
let normalized_target = Some(ps.target_normalized.clone());
let reason = if !inside_root {
Some("Target path is outside workspace root".to_string())
} else {
None
};
let ps_enhanced = serde_json::json!({
"inside_root": inside_root,
"escapes_via_dotdot": ps.escapes_via_dotdot,
"relative_path": ps.relative_path,
"normalized_target": normalized_target,
"reason": reason,
});
path_scope_result = Some(ps_enhanced.clone());
subresults.insert(
"path_scope_check".to_string(),
serde_json::json!({
"inside_root": ps.inside_root,
"root_normalized": ps.root_normalized,
"target_normalized": ps.target_normalized,
"relative_path": ps.relative_path,
"escapes_via_dotdot": ps.escapes_via_dotdot,
"absolute_target": ps.absolute_target,
"findings": ps.findings,
}),
);
if !inside_root {
findings.push(finding(
"PATH_SCOPE_ESCAPE",
severity::HIGH,
"Target path is outside workspace root",
Some(disposition::BLOCKING),
None,
));
}
}
}
if budget_ctx.should_stop() {
return budget_ctx.check_should_stop("edit_preflight").unwrap_err();
}
let mut newline_check_result: Option<Value> = None;
if newline_policy != "skip" {
let replacement_text: Option<&str> = match replacement_mode {
"literal" => args.get("new").and_then(|v| v.as_str()),
"patch" => args.get("patch").and_then(|v| v.as_str()),
"line_range" => args.get("new").and_then(|v| v.as_str()),
_ => None,
};
let nf = crate::services::newline_facts(original, replacement_text, newline_policy);
let orig_style = nf.original_style.clone();
let repl_style = nf.replacement_style.clone();
let composite_style = nf.style.clone();
let mixed = nf.mixed;
let recommended_normalization = nf.recommended_normalization.clone();
let nc = serde_json::json!({
"style": composite_style,
"original_style": orig_style,
"replacement_style": repl_style,
"mixed": mixed,
"policy": newline_policy,
"recommended_normalization": recommended_normalization,
});
newline_check_result = Some(nc.clone());
subresults.insert("newline_check".to_string(), nc);
if mixed {
let consistent_style_mismatch = orig_style != "mixed"
&& orig_style != "none"
&& repl_style.as_deref().is_some_and(|style| {
style != "mixed" && style != "none" && style != orig_style
});
let (finding_severity, finding_disposition, message) = if consistent_style_mismatch {
(
severity::INFO,
disposition::INFORMATIONAL,
format!(
"Replacement newline style ({}) differs from original ({})",
repl_style.as_deref().unwrap_or("unknown"),
orig_style
),
)
} else {
(
severity::MEDIUM,
disposition::CAUTION,
"File has mixed newline styles (CRLF and LF)".to_string(),
)
};
findings.push(finding(
"NEWLINE_INCONSISTENCY",
finding_severity,
&message,
Some(finding_disposition),
None,
));
}
}
if budget_ctx.should_stop() {
return budget_ctx.check_should_stop("edit_preflight").unwrap_err();
}
let mut unicode_check_result: Option<Value> = None;
if unicode_policy != "skip" {
let inspect_text = match replacement_mode {
"literal" => args
.get("new")
.and_then(|v| v.as_str())
.expect("literal validation guarantees new is present"),
"patch" => args
.get("patch")
.and_then(|v| v.as_str())
.expect("patch validation guarantees patch is present"),
"line_range" => args
.get("new")
.and_then(|v| v.as_str())
.expect("line_range validation guarantees new is present"),
_ => {
return ToolResponse::error_with_code(
"invalid_arguments",
machine_codes::EDIT_MODE_INVALID,
&format!("Unsupported replacement_mode: {}", replacement_mode),
None,
Some("edit_preflight"),
);
}
};
let should_stop = || budget_ctx.should_stop();
match crate::services::inspect_text_security(
inspect_text,
unicode_policy,
"none",
"full",
&should_stop,
) {
Ok(inspection) => {
let us_verdict = inspection.verdict.clone();
let us_machine_code = inspection.machine_code.clone();
let us_findings: Vec<Value> = inspection
.findings
.iter()
.map(|f| {
let mut v = serde_json::json!({
"code": f.code,
"severity": f.severity,
"message": f.message,
});
if let Some(d) = &f.disposition {
v["disposition"] = serde_json::json!(d);
}
v
})
.collect();
let finding_count = us_findings.len();
let uc = serde_json::json!({
"verdict": us_verdict,
"machine_code": us_machine_code,
"finding_count": finding_count,
"findings": us_findings,
});
unicode_check_result = Some(uc.clone());
subresults.insert(
"text_security_inspect".to_string(),
serde_json::json!({
"verdict": inspection.verdict,
"machine_code": inspection.machine_code,
"findings": us_findings,
"normalized_changed": inspection.normalized_changed,
"summary": inspection.summary,
}),
);
if us_verdict == "block" {
findings.push(finding(
"UNICODE_RISK",
severity::HIGH,
"Unicode security check blocked replacement text",
Some(disposition::BLOCKING),
None,
));
} else if us_verdict == "review" {
findings.push(finding(
"UNICODE_RISK",
severity::MEDIUM,
"Unicode security check flagged replacement text for review",
Some(disposition::CAUTION),
None,
));
}
}
Err(_) => {
return budget_ctx.check_should_stop("edit_preflight").unwrap_err();
}
}
}
let (primary_code, next_tool_hint) = derive_primary_machine_code(&findings);
let (response_verdict, ok_to_apply, summary) =
derive_verdict(&findings, primary_code, replacement_mode);
let recommended_next =
next_tool_hint.map(|(name, reason)| ToolResponse::next_tool(name, reason, None));
let mut secondary_codes: Vec<String> = Vec::new();
for f in &findings {
let code = match f.get("code").and_then(|v| v.as_str()) {
Some(c) => c,
None => continue,
};
let mapped = match code {
"PATH_SCOPE_ESCAPE" => machine_codes::PATH_SCOPE_ESCAPE,
"INVALID_RANGE" => machine_codes::LINE_RANGE_INVALID,
"PATCH_FAILED" | "PATCH_ERROR" => machine_codes::PATCH_FAILED,
"NO_MATCH" | "MULTIPLE_MATCHES" => machine_codes::AMBIGUOUS_REPLACEMENT,
"FINGERPRINT_MISMATCH" => machine_codes::FINGERPRINT_MISMATCH,
"UNICODE_RISK" => machine_codes::UNICODE_RISK,
"NEWLINE_INCONSISTENCY" => machine_codes::NEWLINE_INCONSISTENCY,
_ => continue,
};
if mapped != primary_code && !secondary_codes.contains(&mapped.to_string()) {
secondary_codes.push(mapped.to_string());
}
}
let mut result = serde_json::json!({
"ok_to_apply": ok_to_apply,
"verdict": response_verdict,
"mode": replacement_mode,
"findings": findings,
"machine_code": primary_code,
"recommended_next_tool": recommended_next,
"summary": summary,
});
if !secondary_codes.is_empty() {
result["secondary_machine_codes"] = serde_json::json!(secondary_codes);
}
if !subresults.is_empty() {
result["subresults"] = serde_json::Value::Object(subresults);
}
if let Some(ps) = path_scope_result {
result["path_scope"] = ps;
}
if let Some(nc) = newline_check_result {
result["newline_check"] = nc;
}
if let Some(uc) = unicode_check_result {
result["unicode_check"] = uc;
}
if let Some(fp) = fingerprint_result {
result["fingerprint"] = fp;
}
let mut resp =
ToolResponse::success(result, Some("edit_preflight")).with_tool("edit_preflight");
resp = resp
.with_machine_code(primary_code)
.with_verdict(response_verdict);
if !findings.is_empty() {
resp = resp.with_findings(findings.clone());
}
resp
}
pub fn patch_contract_check(args: &Value) -> ToolResponse {
let budget_ctx = crate::mcp::budget::for_handler(crate::mcp::budget::ToolBudget::MODERATE);
let patch_text = match args.get("patch_text").and_then(|v| v.as_str()) {
Some(s) => s,
None => {
return ToolResponse::error_with_code(
"invalid_arguments",
machine_codes::INVALID_ARGUMENTS,
"Missing 'patch_text' parameter",
None,
Some("patch_contract_check"),
)
}
};
let workspace_root = args.get("workspace_root").and_then(|v| v.as_str());
if patch_text.len() > MAX_TEXT_LENGTH {
return ToolResponse::error_with_code(
"input_too_large",
machine_codes::INPUT_TOO_LARGE,
&format!(
"Patch text length {} exceeds maximum of {}",
patch_text.chars().count(),
MAX_TEXT_LENGTH
),
None,
Some("patch_contract_check"),
);
}
let analysis = patch_facts::analyze_patch(patch_text);
if !analysis.ok {
let findings = vec![finding(
machine_codes::PATCH_FAILED,
severity::HIGH,
&analysis
.error
.unwrap_or_else(|| "Patch parse failed".to_string()),
Some(disposition::BLOCKING),
None,
)];
let result = serde_json::json!({
"summary": "Patch failed to parse",
"files_changed": 0,
"categories": [],
"files_by_category": {},
"scope_escape_detected": false,
"large_deletions_detected": false,
"verdict": verdict::BLOCK,
"machine_code": machine_codes::PATCH_FAILED,
});
return ToolResponse::success(result, Some("patch_contract_check"))
.with_tool("patch_contract_check")
.with_machine_code(machine_codes::PATCH_FAILED)
.with_verdict(verdict::BLOCK)
.with_findings(findings);
}
if budget_ctx.should_stop() {
return budget_ctx
.check_should_stop("patch_contract_check")
.unwrap_err();
}
let mut categories: Vec<String> = Vec::new();
let mut files_by_category: BTreeMap<String, Vec<String>> = BTreeMap::new();
let mut findings = Vec::new();
let mut scope_escape_detected = false;
let mut large_deletions_detected = false;
for file in &analysis.files {
let path = file.effective_path.as_str();
if let Some(wr) = workspace_root {
if path != "/dev/null" && !path.is_empty() {
let scope = crate::text::path_scope_check(wr, path, "posix", true);
if !scope.inside_root {
scope_escape_detected = true;
categories.push("scope_escape".to_string());
files_by_category
.entry("scope_escape".to_string())
.or_default()
.push(path.to_string());
findings.push(finding(
machine_codes::PATCH_SCOPE_ESCAPE,
severity::HIGH,
&format!("File path escapes workspace root: {}", path),
Some(disposition::BLOCKING),
None,
));
}
}
}
match file.bucket.as_str() {
"lockfiles" => {
categories.push("lockfile_change".to_string());
files_by_category
.entry("lockfile_change".to_string())
.or_default()
.push(path.to_string());
findings.push(finding(
machine_codes::PATCH_LOCKFILE_CHANGE,
severity::MEDIUM,
&format!("Lockfile changed: {}", path),
Some(disposition::CAUTION),
None,
));
}
"manifests" => {
categories.push("manifest_change".to_string());
files_by_category
.entry("manifest_change".to_string())
.or_default()
.push(path.to_string());
findings.push(finding(
machine_codes::PATCH_MANIFEST_CHANGE,
severity::MEDIUM,
&format!("Manifest changed: {}", path),
Some(disposition::CAUTION),
None,
));
}
"ci" => {
categories.push("ci_change".to_string());
files_by_category
.entry("ci_change".to_string())
.or_default()
.push(path.to_string());
}
"configs" => {
categories.push("config_change".to_string());
files_by_category
.entry("config_change".to_string())
.or_default()
.push(path.to_string());
}
"generated" => {
categories.push("generated_change".to_string());
files_by_category
.entry("generated_change".to_string())
.or_default()
.push(path.to_string());
}
"vendor" => {
categories.push("vendor_change".to_string());
files_by_category
.entry("vendor_change".to_string())
.or_default()
.push(path.to_string());
}
_ => {
categories.push("source_change".to_string());
files_by_category
.entry("source_change".to_string())
.or_default()
.push(path.to_string());
}
}
}
for file in &analysis.files {
if file.deletions > 200 {
large_deletions_detected = true;
findings.push(finding(
machine_codes::PATCH_LARGE_DELETE,
severity::MEDIUM,
&format!(
"Large deletion ({} lines) in {}",
file.deletions, file.effective_path
),
Some(disposition::CAUTION),
None,
));
}
}
categories.sort();
categories.dedup();
let has_blocking = findings.iter().any(|f| {
f.get("severity")
.and_then(|s| s.as_str())
.map(|s| s == "high" || s == "critical")
.unwrap_or(false)
});
let has_review = findings.iter().any(|f| {
f.get("severity")
.and_then(|s| s.as_str())
.map(|s| s == "medium")
.unwrap_or(false)
});
let (contract_verdict, machine_code) = if has_blocking {
(verdict::BLOCK, machine_codes::PATCH_CONTRACT_BLOCK)
} else if has_review {
(verdict::REVIEW, machine_codes::PATCH_CONTRACT_REVIEW)
} else {
(verdict::ALLOW, machine_codes::PATCH_CONTRACT_OK)
};
let summary_str = format!(
"{} files, categories: [{}]",
analysis.files_changed,
categories.join(", ")
);
let result = serde_json::json!({
"summary": summary_str,
"files_changed": analysis.files_changed,
"categories": categories,
"files_by_category": files_by_category,
"scope_escape_detected": scope_escape_detected,
"large_deletions_detected": large_deletions_detected,
"verdict": contract_verdict,
"machine_code": machine_code,
});
let mut resp = ToolResponse::success(result, Some("patch_contract_check"))
.with_tool("patch_contract_check")
.with_machine_code(machine_code)
.with_verdict(contract_verdict);
if !findings.is_empty() {
resp = resp.with_findings(findings);
}
resp
}
pub fn diff_risk_classify(args: &Value) -> ToolResponse {
let patch_text = match args.get("patch_text").and_then(|v| v.as_str()) {
Some(s) => s,
None => {
return ToolResponse::error_with_code(
"invalid_arguments",
machine_codes::INVALID_ARGUMENTS,
"Missing 'patch_text' parameter",
None,
Some("diff_risk_classify"),
)
}
};
let max_patch_chars = args
.get("max_patch_chars")
.and_then(|v| v.as_i64())
.unwrap_or(100_000) as usize;
if patch_text.chars().count() > max_patch_chars {
return ToolResponse::error_with_code(
"input_too_large",
machine_codes::INPUT_TOO_LARGE,
&format!(
"Patch text length {} exceeds max_patch_chars {}",
patch_text.chars().count(),
max_patch_chars
),
None,
Some("diff_risk_classify"),
);
}
let analysis = patch_facts::analyze_patch(patch_text);
if !analysis.ok {
let findings = vec![finding(
machine_codes::PATCH_FAILED,
severity::HIGH,
&analysis
.error
.unwrap_or_else(|| "Patch parse failed".to_string()),
Some(disposition::BLOCKING),
None,
)];
let result = serde_json::json!({
"summary": "Patch failed to parse",
"patch_summary": null,
"risk_categories": [],
"files_by_category": {},
"review_focus": [],
"recommended_next_tool": null,
"verdict": verdict::BLOCK,
"machine_code": machine_codes::PATCH_FAILED,
});
return ToolResponse::success(result, Some("diff_risk_classify"))
.with_tool("diff_risk_classify")
.with_machine_code(machine_codes::PATCH_FAILED)
.with_verdict(verdict::BLOCK)
.with_findings(findings);
}
let policy = args.get("policy").cloned().unwrap_or(serde_json::json!({}));
let review_ci = policy
.get("review_ci_changes")
.and_then(|v| v.as_bool())
.unwrap_or(true);
let review_deps = policy
.get("review_dependency_changes")
.and_then(|v| v.as_bool())
.unwrap_or(true);
let review_security = policy
.get("review_security_sensitive_paths")
.and_then(|v| v.as_bool())
.unwrap_or(true);
let allow_docs_only = policy
.get("allow_docs_only")
.and_then(|v| v.as_bool())
.unwrap_or(true);
let mut risk_categories: Vec<String> = Vec::new();
let mut files_by_category: BTreeMap<String, Vec<String>> = BTreeMap::new();
let mut review_focus: Vec<serde_json::Value> = Vec::new();
let mut findings = Vec::new();
let mut all_paths = Vec::new();
let mut has_source = false;
let mut has_config = false;
let mut has_dependency = false;
let mut has_ci = false;
let mut has_security = false;
let mut has_generated = false;
let mut has_vendor = false;
let mut has_binary = false;
let mut docs_only = true;
for file in &analysis.files {
let path = file.effective_path.as_str();
all_paths.push(path.to_string());
match file.bucket.as_str() {
"manifests" => {
has_dependency = true;
docs_only = false;
risk_categories.push("dependency_change".to_string());
files_by_category
.entry("dependency_change".to_string())
.or_default()
.push(path.to_string());
if review_deps {
review_focus.push(serde_json::json!({
"path": path,
"category": "dependency_change",
"reason": "Dependency manifest changed"
}));
}
}
"lockfiles" => {
has_dependency = true;
docs_only = false;
risk_categories.push("lockfile_change".to_string());
files_by_category
.entry("lockfile_change".to_string())
.or_default()
.push(path.to_string());
if review_deps {
review_focus.push(serde_json::json!({
"path": path,
"category": "lockfile_change",
"reason": "Lockfile changed"
}));
}
}
"ci" => {
has_ci = true;
docs_only = false;
risk_categories.push("ci_change".to_string());
files_by_category
.entry("ci_change".to_string())
.or_default()
.push(path.to_string());
if review_ci {
review_focus.push(serde_json::json!({
"path": path,
"category": "ci_change",
"reason": "CI configuration changed"
}));
}
}
"configs" => {
has_config = true;
docs_only = false;
risk_categories.push("config_change".to_string());
files_by_category
.entry("config_change".to_string())
.or_default()
.push(path.to_string());
}
"tests" => {
risk_categories.push("tests_change".to_string());
files_by_category
.entry("tests_change".to_string())
.or_default()
.push(path.to_string());
}
"docs" => {
risk_categories.push("docs_change".to_string());
files_by_category
.entry("docs_change".to_string())
.or_default()
.push(path.to_string());
}
"generated" => {
has_generated = true;
docs_only = false;
risk_categories.push("generated_change".to_string());
files_by_category
.entry("generated_change".to_string())
.or_default()
.push(path.to_string());
}
"vendor" => {
has_vendor = true;
docs_only = false;
risk_categories.push("vendor_change".to_string());
files_by_category
.entry("vendor_change".to_string())
.or_default()
.push(path.to_string());
}
"scripts" => {
docs_only = false;
risk_categories.push("source_change".to_string());
files_by_category
.entry("source_change".to_string())
.or_default()
.push(path.to_string());
}
_ => {
has_source = true;
docs_only = false;
risk_categories.push("source_change".to_string());
files_by_category
.entry("source_change".to_string())
.or_default()
.push(path.to_string());
}
}
if review_security && file.is_security_sensitive {
has_security = true;
risk_categories.push("security_sensitive".to_string());
files_by_category
.entry("security_sensitive".to_string())
.or_default()
.push(path.to_string());
review_focus.push(serde_json::json!({
"path": path,
"category": "security_sensitive",
"reason": "Path contains security-sensitive keywords"
}));
}
}
if analysis.binary_patch_detected {
has_binary = true;
risk_categories.push("binary_change".to_string());
findings.push(finding(
machine_codes::DIFF_RISK_REVIEW,
severity::MEDIUM,
"Binary patch content detected",
Some(disposition::CAUTION),
None,
));
review_focus.push(serde_json::json!({
"path": "<binary>",
"category": "binary_change",
"reason": "Binary patch content detected"
}));
}
if !analysis.renames_detected.is_empty() {
risk_categories.push("rename".to_string());
}
let total_changes = analysis.additions + analysis.deletions;
if total_changes > 500 {
risk_categories.push("large_diff".to_string());
findings.push(finding(
machine_codes::DIFF_RISK_REVIEW,
severity::LOW,
&format!(
"Large diff: {} additions + {} deletions",
analysis.additions, analysis.deletions
),
Some(disposition::INFORMATIONAL),
None,
));
}
risk_categories.sort();
risk_categories.dedup();
let has_blocking = has_security || has_binary;
let has_review_reasons = has_ci
|| has_dependency
|| has_config
|| has_source
|| has_generated
|| has_vendor
|| (!allow_docs_only && !all_paths.is_empty() && docs_only);
let (diff_verdict, machine_code) = if has_blocking {
(verdict::BLOCK, machine_codes::DIFF_RISK_BLOCK)
} else if has_review_reasons || !review_focus.is_empty() {
(verdict::REVIEW, machine_codes::DIFF_RISK_REVIEW)
} else {
(verdict::ALLOW, machine_codes::DIFF_RISK_OK)
};
if has_dependency && review_deps {
findings.push(finding(
machine_codes::DIFF_RISK_REVIEW,
severity::MEDIUM,
"Dependency manifest or lockfile changed",
Some(disposition::CAUTION),
None,
));
}
if has_ci && review_ci {
findings.push(finding(
machine_codes::DIFF_RISK_REVIEW,
severity::MEDIUM,
"CI configuration changed",
Some(disposition::CAUTION),
None,
));
}
if has_security && review_security {
findings.push(finding(
machine_codes::DIFF_RISK_BLOCK,
severity::HIGH,
"Security-sensitive path changed",
Some(disposition::BLOCKING),
None,
));
}
if has_generated {
findings.push(finding(
machine_codes::DIFF_RISK_REVIEW,
severity::LOW,
"Generated file changed",
Some(disposition::INFORMATIONAL),
None,
));
}
if has_vendor {
findings.push(finding(
machine_codes::DIFF_RISK_REVIEW,
severity::LOW,
"Vendor/dependency file changed",
Some(disposition::INFORMATIONAL),
None,
));
}
let recommended = if has_dependency && review_deps {
Some("dependency_edit_preflight")
} else if has_config {
Some("config_file_inspect")
} else if has_source || has_security {
Some("patch_apply_check")
} else if has_ci {
Some("command_preflight")
} else {
None
};
let summary_str = format!(
"{} files, +{} -{}, risk categories: [{}]",
analysis.files_changed,
analysis.additions,
analysis.deletions,
risk_categories.join(", ")
);
let result = serde_json::json!({
"summary": summary_str,
"patch_summary": {
"files_changed": analysis.files_changed,
"hunks_total": analysis.hunks_total,
"additions": analysis.additions,
"deletions": analysis.deletions,
"renames_detected": analysis.renames_detected,
"binary_patch_detected": analysis.binary_patch_detected,
},
"risk_categories": risk_categories,
"files_by_category": files_by_category,
"review_focus": review_focus,
"recommended_next_tool": recommended,
"verdict": diff_verdict,
"machine_code": machine_code,
});
let mut resp = ToolResponse::success(result, Some("diff_risk_classify"))
.with_tool("diff_risk_classify")
.with_machine_code(machine_code)
.with_verdict(diff_verdict);
if !findings.is_empty() {
resp = resp.with_findings(findings);
}
resp
}