//! External work — where a session edited outside the project, and what was there first. //! //! Git answers "what changed?" for the project, and stops at the worktree boundary. A session that //! edits `~/.config/foo.toml` or a sibling checkout has still done work, and a Changes surface that //! reports only the project is not merely incomplete — it reads as a claim about the whole session. //! //! This is the record that closes that gap. [`ExternalWorkHook`] sits on `BeforeToolUse`, which is //! the same call the `external_directory` permission guard is evaluated on, and retains what a path //! held *before* the tool ran. The collector turns that into a Changes group later; nothing here //! knows about Git, diffs, or rendering. //! //! # What it can and cannot see //! //! Only paths Luxe's own file tools name. A `bash` command that deletes a file elsewhere is //! invisible here, which is why an external path inside a Git worktree is recorded as a *root* //! instead — Git then reports that tree the same way it reports the project, and catches what the //! shell did too. `ExternalWork::roots` is the honest answer for a checkout; `ExternalWork::loose` //! is the best available answer for a file that belongs to no repository. use crate::permission::{external_target, is_mutating_path_tool}; use serde::{Deserialize, Serialize}; use std::{ collections::{BTreeMap, BTreeSet}, path::{Path, PathBuf}, sync::{Arc, Mutex}, }; /// Most bytes retained for one loose file's pre-edit content. /// /// Matches the review loader's untracked-file limit. Past it the file is still recorded — it was /// still changed — but without the content a line count could be derived from. const MAX_RETAINED_BYTES: u64 = 1_048_576; /// Most loose files retained before the record stops growing. /// /// A session that rewrites a thousand files in `/tmp` is not describing itself with a list, and the /// record is read on every workspace refresh. const MAX_LOOSE_FILES: usize = 200; /// What a loose external path held when this session first reached it. #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "snake_case", tag = "kind")] pub enum ExternalBaseline { /// Nothing was there — the session created it. Absent, /// It already existed, and its text was retained so the change can be measured. Text { /// Complete pre-edit content. content: String, }, /// It existed but could not be retained: too large, binary, or unreadable. /// /// Kept as a distinct state rather than folded into [`Self::Absent`], because "created" and /// "changed, and I cannot say by how much" are different claims and only one of them is true. Unretained, } impl ExternalBaseline { /// Lines in the retained content, or `None` when there is none to count. pub fn line_count(&self) -> Option { match self { Self::Absent => Some(0), Self::Text { content } => Some(count_lines(content)), Self::Unretained => None, } } } /// Lines in `text`, counting a final line that carries no newline. fn count_lines(text: &str) -> u64 { if text.is_empty() { return 0; } let newlines = text.bytes().filter(|byte| *byte == b'\n').count() as u64; newlines + u64::from(!text.ends_with('\n')) } /// One loose external file and the state the session found it in. #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] pub struct ExternalFile { /// Absolute path, normalized the way the permission guard normalizes it. pub path: PathBuf, /// What was there before this session touched it. pub baseline: ExternalBaseline, } /// Everything one session has touched outside its project root. #[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)] pub struct ExternalWorkRecord { /// Git worktree roots outside the project, reported by Git like the project itself. pub roots: Vec, /// Files belonging to no worktree, measured against what the session first saw. pub files: Vec, /// Whether files were dropped because the record reached `MAX_LOOSE_FILES`. pub truncated: bool, } impl ExternalWorkRecord { /// Whether this session has done no work outside its project. pub fn is_empty(&self) -> bool { self.roots.is_empty() && self.files.is_empty() } } #[derive(Debug, Default)] struct State { roots: BTreeSet, files: BTreeMap, truncated: bool, } /// A shared, cheaply cloned record of one session's work outside its project. /// /// Cloning shares the record, matching [`crate::lsp::DiagnosticsStore`]: the hook writes to it and /// the workspace collector reads from it, and neither owns it. #[derive(Debug, Clone, Default)] pub struct ExternalWork { state: Arc>, } impl ExternalWork { /// Creates an empty record. pub fn new() -> Self { Self::default() } /// Records that `path` — already known to be outside the project — is about to be changed. /// /// Called *before* the change, so the first call for a path is the only one that can see what /// was there; later calls leave the retained baseline alone. A path inside a Git worktree is /// recorded as its root instead of as a file, because Git can then report that tree completely /// rather than only the parts Luxe touched. pub fn observe(&self, path: &Path) { let Ok(mut state) = self.state.lock() else { return; }; if let Some(root) = worktree_root(path) { state.roots.insert(root); return; } // Its own worktree already covers it; a file listed twice is a file counted twice. if state.roots.iter().any(|root| crate::paths::contains(root, path)) { return; } if state.files.contains_key(path) { return; } if state.files.len() >= MAX_LOOSE_FILES { state.truncated = true; return; } state.files.insert(path.to_path_buf(), capture_baseline(path)); } /// The record as it stands, for a collector or a front-end. pub fn record(&self) -> ExternalWorkRecord { let Ok(state) = self.state.lock() else { return ExternalWorkRecord::default(); }; ExternalWorkRecord { roots: state.roots.iter().cloned().collect(), files: state .files .iter() .map(|(path, baseline)| ExternalFile { path: path.clone(), baseline: baseline.clone(), }) .collect(), truncated: state.truncated, } } /// What `path` held when this session first reached it, for a loose file only. /// /// A path under one of the retained [`ExternalWorkRecord::roots`] answers `None` on purpose: /// Git is the witness there, and it is a better one than a copy of a single file. pub fn baseline(&self, path: impl AsRef) -> Option { let path = path.as_ref(); self.state.lock().ok()?.files.get(path).cloned() } /// Whether anything outside the project has been touched. pub fn is_empty(&self) -> bool { self.state .lock() .map(|state| state.roots.is_empty() && state.files.is_empty()) .unwrap_or(true) } } /// Reads what `path` holds now, classifying anything a line count cannot describe. fn capture_baseline(path: &Path) -> ExternalBaseline { let Ok(metadata) = std::fs::symlink_metadata(path) else { return ExternalBaseline::Absent; }; if !metadata.is_file() || metadata.len() > MAX_RETAINED_BYTES { return ExternalBaseline::Unretained; } match std::fs::read(path) { // NUL first: invalid UTF-8 and binary are the same answer here, and checking the cheap one // first keeps a large blob from being decoded before it is rejected. Ok(bytes) if bytes.contains(&0) => ExternalBaseline::Unretained, Ok(bytes) => match String::from_utf8(bytes) { Ok(content) => ExternalBaseline::Text { content }, Err(_) => ExternalBaseline::Unretained, }, Err(_) => ExternalBaseline::Unretained, } } /// The working copy `path` sits in, found by walking up from its directory. /// /// Shared with [`crate::file_diff`], which has to sort a peeked path into the same two kinds this /// does: a place a VCS can be asked about, and a place only the retained baseline can answer for. /// What counts as a top is [`crate::project`]'s to say. pub(crate) fn worktree_root(path: &Path) -> Option { let mut current = path.parent(); while let Some(directory) = current { if crate::project::is_working_copy(directory) { return Some(directory.to_path_buf()); } current = directory.parent(); } None } /// Records external file work as the agent does it. /// /// Sits on `BeforeToolUse` because that is the last moment the *previous* content of a path still /// exists. `FileChanged` fires after the write, by which time the baseline is gone. #[derive(Debug)] pub struct ExternalWorkHook { project_root: PathBuf, work: ExternalWork, } impl ExternalWorkHook { /// Records work outside `project_root` into `work`. pub fn new(project_root: impl Into, work: ExternalWork) -> Self { Self { project_root: project_root.into(), work } } } #[async_trait::async_trait] impl crate::hook::Hook for ExternalWorkHook { fn name(&self) -> &'static str { "external-work" } fn interest(&self) -> &[crate::hook::HookPoint] { &[crate::hook::HookPoint::BeforeToolUse] } async fn on( &self, _point: crate::hook::HookPoint, event: &crate::hook::HookEvent, _cx: &crate::hook::HookCtx, ) -> crate::hook::HookOutcome { let crate::hook::HookEvent::ToolUse { tool_name, args } = event else { return crate::hook::HookOutcome::Continue; }; if is_mutating_path_tool(tool_name) { if let Some(path) = external_target(tool_name, args, &self.project_root) { // Reading a file to retain it is blocking work on the runtime's thread; the tool is // about to do the same read anyway, and a hook that returns late delays the call. let work = self.work.clone(); let _ = tokio::task::spawn_blocking(move || work.observe(&path)).await; } } crate::hook::HookOutcome::Continue } } #[cfg(test)] mod tests;