//! Workspace edits — a language server's `WorkspaceEdit` applied to disk, all of it or none. //! //! The file list comes from the server, so it is planned in memory first: every file read, every //! edit placed, and any file outside the project or inside a fetched repository refuses the whole //! edit before a byte is written. Then each changed file is written, and a failed write puts back //! the ones already done. The result counts what actually landed, says what was skipped and which //! resource operations were not applied, and each written file goes through `FileChanged` and the //! read tracker like an `edit` would. use std::path::{Path, PathBuf}; use luxe_core::read_tracker::ReadTracker; use luxe_core::{ToolContext, ToolResultData}; use serde_json::Value; /// Where an applied edit reports to: the call's context and, when wired, the read tracker. #[derive(Clone, Copy)] pub(crate) struct Writes<'a> { pub(crate) cx: &'a ToolContext, pub(crate) tracker: Option<&'a ReadTracker>, } /// A single text edit as `(start_line, start_char, end_line, end_char, new_text)` in LSP coords. type TextEdit = (u32, u32, u32, u32, String); /// What a `WorkspaceEdit` asks for: text edits per file, and the resource operations it carried. struct Requested { files: Vec<(String, Vec)>, operations: Vec, } /// One file's change, worked out in memory before anything is written. struct FilePlan { path: PathBuf, display: String, original: String, updated: String, applied: usize, skipped: usize, } /// Apply a `WorkspaceEdit`, returning a summary plus any context `FileChanged` hooks injected. pub(crate) async fn apply_workspace_edit(edit: &Value, writes: Writes<'_>) -> ToolResultData { let requested = collect_workspace_edits(edit); let plans = match plan(requested.files, &writes.cx.cwd) { Ok(plans) => plans, Err(message) => return ToolResultData::error(&message), }; let changed: Vec<&FilePlan> = plans.iter().filter(|file| file.updated != file.original).collect(); if let Err(message) = write_all(&changed) { return ToolResultData::error(&message); } let mut injected = Vec::new(); for file in &changed { injected.extend(writes.cx.file_changed(&file.path, "edit").await); // after the hook, so a format-on-save rewrite is what counts as read if let Some(tracker) = writes.tracker { tracker.record(&writes.cx.session_id, &file.path); } } ToolResultData::text(summary(&plans, &requested.operations, &injected)) } fn plan(files: Vec<(String, Vec)>, cwd: &Path) -> Result, String> { // one plan per file, or a second entry for it would be placed against the unedited text let mut merged: Vec<(PathBuf, Vec)> = Vec::new(); for (uri, edits) in files { // through the URI parser: a Windows drive or a percent-encoded space breaks a prefix strip let path = crate::uri::to_path(&uri); match merged.iter_mut().find(|(known, _)| *known == path) { Some((_, known)) => known.extend(edits), None => merged.push((path, edits)), } } merged.into_iter().map(|(path, edits)| plan_file(path, edits, cwd)).collect() } fn plan_file(path: PathBuf, edits: Vec, cwd: &Path) -> Result { let display = luxe_core::paths::display(&path); if let Some(reason) = refusal(&path, cwd) { return Err(format!("Error: the edit names {display}, {reason}; nothing was written")); } let original = std::fs::read_to_string(&path) .map_err(|e| format!("Error: read {display}: {e}; nothing was written"))?; let requested = edits.len(); let (updated, applied) = apply_text_edits(&original, edits); Ok(FilePlan { path, display, original, updated, applied, skipped: requested - applied }) } /// Why `path` may not be written from here, if it may not. Canonical on both sides, so a symlink /// cannot lead out of the project. fn refusal(path: &Path, cwd: &Path) -> Option<&'static str> { let canonical = |path: &Path| std::fs::canonicalize(path).unwrap_or_else(|_| path.to_path_buf()); let target = canonical(path); if !luxe_core::paths::contains(&canonical(cwd), &target) { return Some("outside the project"); } luxe_core::fetched::contains(&target).then_some("inside a fetched repository") } /// Write every changed file, or put back the ones already written and say what could not be. fn write_all(changed: &[&FilePlan]) -> Result<(), String> { for (index, file) in changed.iter().enumerate() { let Err(error) = luxe_core::fs_atomic::replace(&file.path, file.updated.as_bytes()) else { continue; }; let unrestored: Vec<&str> = changed[..index] .iter() .filter(|done| { luxe_core::fs_atomic::replace(&done.path, done.original.as_bytes()).is_err() }) .map(|done| done.display.as_str()) .collect(); let after = match unrestored.as_slice() { [] => "the files already written were restored".to_string(), files => format!("could not restore {}", files.join(", ")), }; return Err(format!("Error: write {}: {error}; {after}", file.display)); } Ok(()) } fn summary(plans: &[FilePlan], operations: &[String], injected: &[String]) -> String { let changed: Vec<&FilePlan> = plans.iter().filter(|file| file.applied > 0).collect(); let total: usize = changed.iter().map(|file| file.applied).sum(); let mut out = if total == 0 { "Rename/edit produced no changes\n".to_string() } else { format!("Applied {total} edit(s) across {} file(s):\n", changed.len()) }; for file in &changed { out.push_str(&format!(" {} ({} edit(s))\n", file.display, file.applied)); } let skipped: Vec = plans .iter() .filter(|file| file.skipped > 0) .map(|file| format!("{} ({})", file.display, file.skipped)) .collect(); if !skipped.is_empty() { let count: usize = plans.iter().map(|file| file.skipped).sum(); out.push_str(&format!( "skipped {count} edit(s) outside their file or overlapping another: {}\n", skipped.join(", ") )); } if !operations.is_empty() { out.push_str(&format!( "not applied: {} (file operations are not supported here; use write or bash)\n", operations.join(", ") )); } if !injected.is_empty() { out.push_str(&format!("\n--- Diagnostics ---\n{}", injected.join("\n"))); } out } /// Collect a `WorkspaceEdit`'s per-file edits and resource operations. /// /// `documentChanges` wins when both are present, as the spec says, so an edit sent both ways /// lands once. fn collect_workspace_edits(edit: &Value) -> Requested { let mut requested = Requested { files: Vec::new(), operations: Vec::new() }; if let Some(document_changes) = edit.get("documentChanges").and_then(Value::as_array) { for change in document_changes { match change.get("textDocument").and_then(|d| d.get("uri")).and_then(Value::as_str) { Some(uri) => { let edits = change.get("edits").map(parse_text_edits).unwrap_or_default(); requested.files.push((uri.to_string(), edits)); } None => requested.operations.push(describe_operation(change)), } } } else if let Some(changes) = edit.get("changes").and_then(Value::as_object) { for (uri, edits) in changes { requested.files.push((uri.clone(), parse_text_edits(edits))); } } requested } fn describe_operation(change: &Value) -> String { let path = |key: &str| { change .get(key) .and_then(Value::as_str) .map(|uri| luxe_core::paths::display(&crate::uri::to_path(uri))) .unwrap_or_default() }; match change.get("kind").and_then(Value::as_str).unwrap_or("unknown") { "rename" => format!("rename {} to {}", path("oldUri"), path("newUri")), kind => format!("{kind} {}", path("uri")), } } fn parse_text_edits(edits: &Value) -> Vec { let Some(array) = edits.as_array() else { return Vec::new() }; array .iter() .filter_map(|edit| { let range = edit.get("range")?; let start = range.get("start")?; let end = range.get("end")?; let num = |v: &Value, k: &str| v.get(k).and_then(Value::as_u64).unwrap_or(0) as u32; Some(( num(start, "line"), num(start, "character"), num(end, "line"), num(end, "character"), edit.get("newText").and_then(Value::as_str).unwrap_or("").to_string(), )) }) .collect() } /// Apply LSP text edits to `content`, returning the text and how many edits landed. /// /// Descending start order, so an edit never shifts a range still to come. An edit on a line the /// file does not have, or overlapping one already applied, is skipped rather than guessed at. /// `character` offsets are UTF-16 code units (the LSP default). fn apply_text_edits(content: &str, edits: Vec) -> (String, usize) { let line_starts = line_start_bytes(content); let mut spans: Vec<(usize, usize, usize, String)> = edits .into_iter() .enumerate() .filter_map(|(index, (sl, sc, el, ec, new_text))| { let start = position_to_byte(content, &line_starts, sl, sc)?; let end = position_to_byte(content, &line_starts, el, ec)?; Some((start.min(end), index, start.max(end), new_text)) }) .collect(); // edits sharing a start apply in the order sent, so the later one goes in first spans.sort_by_key(|span| std::cmp::Reverse((span.0, span.1))); let (mut out, mut applied, mut limit) = (content.to_string(), 0, content.len()); for (start, _, end, new_text) in spans { if end <= limit { out.replace_range(start..end, &new_text); applied += 1; limit = start; } } (out, applied) } /// Byte offset of the start of each line (line 0 at 0, then after each `\n`). fn line_start_bytes(content: &str) -> Vec { let mut starts = vec![0]; for (index, byte) in content.bytes().enumerate() { if byte == b'\n' { starts.push(index + 1); } } starts } /// Convert an LSP `(line, character_utf16)` position to a byte offset, clamped to the line's end; /// `None` for a line the file does not have. fn position_to_byte( content: &str, line_starts: &[usize], line: u32, character: u32, ) -> Option { let line_start = *line_starts.get(line as usize)?; let mut byte = line_start; let mut utf16 = 0u32; for ch in content[line_start..].chars() { if ch == '\n' || utf16 >= character { break; } utf16 += ch.len_utf16() as u32; byte += ch.len_utf8(); } Some(byte) } #[cfg(test)] mod tests;