The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.
TypeScript code-editorcross-platformdapdatabase-clientdebuggerdesktop-appdeveloper-toolsgithttp-clientideintellijlsprusttauriterminal
feat(diff): compare directories and synchronize entries (#661)
l0ng-ai1716f3e062fb
diff --git a/crates/ide-host/src/ops/fs.rs b/crates/ide-host/src/ops/fs.rsindex 10681ca31..fb55f6f0f 100644--- a/crates/ide-host/src/ops/fs.rs+++ b/crates/ide-host/src/ops/fs.rs@@ -1,8 +1,73 @@+use super::Channel;use crate::Host;-use ide_core::IdeResult;+use ide_core::{IdeResult, RequestId};use ide_vfs::FileEntry;use std::path::PathBuf;+pub async fn entry_kind(host: &Host, path: PathBuf) -> IdeResult<ide_vfs::EntryKind> {+ host.blocking(move || {+ let meta = std::fs::metadata(path)?;+ Ok(if meta.is_dir() { ide_vfs::EntryKind::Dir } else { ide_vfs::EntryKind::File })+ })+ .await+}++pub async fn compare_directories(+ host: &Host,+ window: &str,+ left: PathBuf,+ right: PathBuf,+ request: RequestId,+ on_progress: Channel<ide_vfs::DirectoryCompareProgress>,+) -> IdeResult<Vec<ide_vfs::DirectoryCompareEntry>> {+ let project = host.project(window)?;+ let cancel = host.begin_request(request);+ let result = host+ .blocking(move || {+ let last = std::cell::Cell::new(std::time::Instant::now() - std::time::Duration::from_secs(1));+ ide_vfs::compare_directories(&left, &right, Some(&project.root), &project.exclude_globs(), &cancel, |p| {+ // Bound IPC traffic even when hashing multi-gigabyte files.+ if last.get().elapsed() >= std::time::Duration::from_millis(80) || p.total == Some(p.compared) {+ let _ = on_progress.send(p);+ last.set(std::time::Instant::now());+ }+ })+ })+ .await;+ host.end_request(request);+ result+}++pub async fn copy_merge(+ host: &Host,+ window: &str,+ source_root: PathBuf,+ destination_root: PathBuf,+ path: PathBuf,+ overwrite: bool,+) -> IdeResult<()> {+ if path.as_os_str().is_empty() || path.components().any(|c| !matches!(c, std::path::Component::Normal(_))) {+ return Err(ide_core::IdeError::invalid("expected a relative comparison entry path"));+ }+ let project = host.project(window)?;+ host.blocking(move || {+ let from = source_root.join(&path);+ let to = destination_root.join(&path);+ if overwrite {+ project.history.record_deletion(&to, DELETE_SNAPSHOT_LIMIT);+ }+ ide_vfs::copy_merge(+ &from,+ &to,+ overwrite,+ Some(&project.root),+ &project.exclude_globs(),+ (&source_root, &destination_root),+ )+ })+ .await+}+/// Files of a deleted folder snapshotted in Local History.const DELETE_SNAPSHOT_LIMIT: usize = 2000;diff --git a/crates/ide-host/src/rpc.rs b/crates/ide-host/src/rpc.rsindex e34db1e4a..78605b1e0 100644--- a/crates/ide-host/src/rpc.rs+++ b/crates/ide-host/src/rpc.rs@@ -179,6 +179,7 @@ impl Dispatcher {}).add("cancel_task", |c| async move { Ok(ide_core::task::cancel(c.arg::<TaskId>("id")?)) }).add("fs_read_dir", |c| async move { ops::fs::read_dir(&c.host, &c.window, c.arg("path")?) })+ .add("fs_entry_kind", |c| async move { ops::fs::entry_kind(&c.host, c.arg("path")?).await }).add("fs_create_file", |c| async move { ops::fs::create_file(&c.host, &c.window, c.arg("path")?) }).add("fs_create_file_bytes", |c| async move {ops::fs::create_file_bytes(&c.host, c.arg("path")?, c.arg("data")?).await@@ -190,6 +191,28 @@ impl Dispatcher {}).add("fs_delete", |c| async move { ops::fs::delete(&c.host, &c.window, c.arg("path")?).await }).add("fs_copy", |c| async move { ops::fs::copy(&c.host, c.arg("from")?, c.arg("to")?).await })+ .add("fs_copy_merge", |c| async move {+ ops::fs::copy_merge(+ &c.host,+ &c.window,+ c.arg("sourceRoot")?,+ c.arg("destinationRoot")?,+ c.arg("path")?,+ c.arg("overwrite")?,+ )+ .await+ })+ .add("fs_compare_directories", |c| async move {+ ops::fs::compare_directories(+ &c.host,+ &c.window,+ c.arg("left")?,+ c.arg("right")?,+ c.arg("request")?,+ c.sender("onProgress")?,+ )+ .await+ }).add("fs_read_text", |c| async move { ops::fs::read_text(&c.host, &c.window, c.arg("path")?).await }).add("doc_open", |c| async move { ops::doc::open(&c.host, &c.window, c.arg("path")?).await }).add("doc_close", |c| async move { ops::doc::close(&c.host, &c.window, c.arg("doc")?) })diff --git a/crates/ide-host/tests/rpc.rs b/crates/ide-host/tests/rpc.rsindex d16f408fc..58e4ede39 100644--- a/crates/ide-host/tests/rpc.rs+++ b/crates/ide-host/tests/rpc.rs@@ -94,6 +94,39 @@ async fn serves_projects_files_documents_search_and_runs() {let entries = invoke(&peer, "fs_read_dir", json!({ "path": project })).await.unwrap();assert!(entries.as_array().unwrap().iter().any(|e| e["name"] == "src"), "{entries}");+ // Directory comparisons, streamed progress and confirmed copies share the remote filesystem.+ let left = project.join("compare-left");+ let right = project.join("compare-right");+ std::fs::create_dir_all(&left).unwrap();+ std::fs::create_dir_all(&right).unwrap();+ std::fs::write(left.join("中文.bin"), [0, 255, 1]).unwrap();+ std::fs::write(right.join("中文.bin"), [0, 254, 1]).unwrap();+ assert_eq!(invoke(&peer, "fs_entry_kind", json!({"path": left})).await.unwrap(), "dir");+ assert_eq!(invoke(&peer, "fs_entry_kind", json!({"path": left.join("中文.bin")})).await.unwrap(), "file");+ let compare_args =+ |request| json!({"left": left, "right": right, "request": request, "onProgress": {"$channel": 520}});+ let rows = invoke(&peer, "fs_compare_directories", compare_args(520)).await.unwrap();+ assert_eq!(rows[0]["status"], "different");+ assert!(client.channels.lock().iter().any(|c| c.id == 520 && c.data["compared"] == 1));+ let copy_args =+ |overwrite| json!({"sourceRoot": left, "destinationRoot": right, "path": "中文.bin", "overwrite": overwrite});+ let error = invoke(&peer, "fs_copy_merge", copy_args(false)).await.unwrap_err();+ assert_eq!(error.kind, ide_core::error::ErrorKind::AlreadyExists);+ invoke(&peer, "fs_copy_merge", copy_args(true)).await.unwrap();+ let rows = invoke(&peer, "fs_compare_directories", compare_args(521)).await.unwrap();+ assert_eq!(rows[0]["status"], "equal");+ invoke(&peer, "cancel_request", json!({"id": 522})).await.unwrap();+ let error = invoke(&peer, "fs_compare_directories", compare_args(522)).await.unwrap_err();+ assert_eq!(error.kind, ide_core::error::ErrorKind::Cancelled);+ let error = invoke(+ &peer,+ "fs_copy_merge",+ json!({"sourceRoot": left, "destinationRoot": right, "path": "../escape", "overwrite": true}),+ )+ .await+ .unwrap_err();+ assert_eq!(error.kind, ide_core::error::ErrorKind::InvalidInput);+// JVM icons use the same read-only protocol as local windows.let java = project.join("src/Foo.java");let kotlin = project.join("src/Singleton.kt");diff --git a/crates/ide-vfs/src/compare.rs b/crates/ide-vfs/src/compare.rsnew file mode 100644index 000000000..8f29b1008--- /dev/null+++ b/crates/ide-vfs/src/compare.rs@@ -0,0 +1,505 @@+//! Disk comparisons use the same excludes and layered ignore files as the project tree.+use crate::{EntryKind, ExcludeMatcher, rules::GitignoreStack};+use ide_core::{CancellationToken, IdeError, IdeResult};+use serde::{Deserialize, Serialize};+use specta::Type;+use std::collections::BTreeMap;+use std::fs;+use std::io::Read;+use std::path::{Path, PathBuf};++#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]+#[serde(rename_all = "camelCase")]+pub enum DirectoryCompareStatus {+ LeftOnly,+ RightOnly,+ Different,+ Equal,+}++#[derive(Clone, Debug, Serialize, Deserialize, Type)]+#[serde(rename_all = "camelCase")]+pub struct DirectoryCompareEntry {+ pub path: String,+ pub status: DirectoryCompareStatus,+ pub left_kind: Option<EntryKind>,+ pub right_kind: Option<EntryKind>,+ #[specta(optional)]+ pub left_link: Option<String>,+ #[specta(optional)]+ pub right_link: Option<String>,+}++#[derive(Clone, Debug, Default, Serialize, Deserialize, Type)]+#[serde(rename_all = "camelCase")]+pub struct DirectoryCompareProgress {+ pub scanned: u32,+ pub compared: u32,+ pub total: Option<u32>,+ pub bytes_read: f64,+ pub path: String,+}++struct Entry {+ kind: EntryKind,+ size: u64,+ link: Option<PathBuf>,+}++fn check(cancel: &CancellationToken) -> IdeResult<()> {+ if cancel.is_cancelled() { Err(IdeError::cancelled()) } else { Ok(()) }+}++struct Rules {+ base: PathBuf,+ excludes: ExcludeMatcher,+ ignore: GitignoreStack,+}++impl Rules {+ fn new(root: &Path, project: Option<&Path>, excludes: &[String]) -> Self {+ Self {+ base: project.filter(|p| root.starts_with(p)).unwrap_or(root).to_path_buf(),+ excludes: ExcludeMatcher::new(excludes),+ ignore: GitignoreStack::new(root),+ }+ }++ fn excluded(&self, path: &Path, dir: bool) -> bool {+ path.file_name().is_some_and(|n| n == ".git")+ || self.excludes.is_excluded(path.strip_prefix(&self.base).unwrap_or(path))+ || self.ignore.is_ignored(path, dir)+ }+}++fn scan(+ root: &Path,+ rules: &Rules,+ cancel: &CancellationToken,+ progress: &mut DirectoryCompareProgress,+ emit: &impl Fn(DirectoryCompareProgress),+) -> IdeResult<BTreeMap<String, Entry>> {+ if !fs::metadata(root)?.is_dir() {+ return Err(IdeError::invalid(format!("{} is not a directory", root.display())));+ }+ let mut result = BTreeMap::new();+ let mut pending = vec![root.to_path_buf()];+ while let Some(dir) = pending.pop() {+ check(cancel)?;+ for item in fs::read_dir(dir)? {+ check(cancel)?;+ let path = item?.path();+ let meta = fs::symlink_metadata(&path)?;+ if rules.excluded(&path, meta.is_dir()) {+ continue;+ }+ let kind = if meta.file_type().is_symlink() {+ EntryKind::Symlink+ } else if meta.is_dir() {+ pending.push(path.clone());+ EntryKind::Dir+ } else if meta.is_file() {+ EntryKind::File+ } else {+ continue;+ };+ let rel = path.strip_prefix(root).map_err(|e| IdeError::internal(e.to_string()))?;+ let rel = ide_core::ipc_path::to_ipc(rel);+ let link = if kind == EntryKind::Symlink { Some(fs::read_link(&path)?) } else { None };+ result.insert(rel.clone(), Entry { kind, size: meta.len(), link });+ progress.scanned += 1;+ progress.path = rel;+ emit(progress.clone());+ }+ }+ Ok(result)+}++fn hash(+ path: &Path,+ cancel: &CancellationToken,+ progress: &mut DirectoryCompareProgress,+ emit: &impl Fn(DirectoryCompareProgress),+) -> IdeResult<gix::hash::ObjectId> {+ let mut file = fs::File::open(path)?;+ let mut hash = gix::hash::hasher(gix::hash::Kind::Sha256);+ let mut buffer = [0; 64 * 1024];+ loop {+ check(cancel)?;+ let len = file.read(&mut buffer)?;+ if len == 0 {+ break;+ }+ hash.update(&buffer[..len]);+ progress.bytes_read += len as f64;+ emit(progress.clone());+ }+ hash.try_finalize().map_err(|e| IdeError::internal(e.to_string()))+}++/// Size checks avoid reading unequal files. Equal-sized files are hashed in bounded,+/// cancellable chunks; symlinks compare their link text and are never traversed.+pub fn compare_directories(+ left: &Path,+ right: &Path,+ project: Option<&Path>,+ excludes: &[String],+ cancel: &CancellationToken,+ emit: impl Fn(DirectoryCompareProgress),+) -> IdeResult<Vec<DirectoryCompareEntry>> {+ check(cancel)?;+ let mut progress = DirectoryCompareProgress::default();+ emit(progress.clone());+ let l = scan(left, &Rules::new(left, project, excludes), cancel, &mut progress, &emit)?;+ let r = scan(right, &Rules::new(right, project, excludes), cancel, &mut progress, &emit)?;+ let mut paths: Vec<_> = l.keys().chain(r.keys()).cloned().collect();+ paths.sort();+ paths.dedup();+ progress.total = Some(paths.len() as u32);+ let mut rows = BTreeMap::new();+ for path in paths {+ check(cancel)?;+ progress.path.clone_from(&path);+ let status = match (l.get(&path), r.get(&path)) {+ (Some(_), None) => DirectoryCompareStatus::LeftOnly,+ (None, Some(_)) => DirectoryCompareStatus::RightOnly,+ (Some(a), Some(b)) => {+ let equal = a.kind == b.kind+ && match a.kind {+ EntryKind::Dir => true,+ EntryKind::Symlink => a.link == b.link,+ EntryKind::File => {+ a.size == b.size+ && hash(&left.join(&path), cancel, &mut progress, &emit)?+ == hash(&right.join(&path), cancel, &mut progress, &emit)?+ }+ };+ if equal { DirectoryCompareStatus::Equal } else { DirectoryCompareStatus::Different }+ }+ _ => unreachable!(),+ };+ rows.insert(+ path.clone(),+ DirectoryCompareEntry {+ path: path.clone(),+ status,+ left_kind: l.get(&path).map(|e| e.kind),+ right_kind: r.get(&path).map(|e| e.kind),+ left_link: l.get(&path).and_then(|e| e.link.as_ref()).map(|p| p.to_string_lossy().into_owned()),+ right_link: r.get(&path).and_then(|e| e.link.as_ref()).map(|p| p.to_string_lossy().into_owned()),+ },+ );+ progress.compared += 1;+ emit(progress.clone());+ }+ let changed: Vec<_> =+ rows.values().filter(|r| r.status != DirectoryCompareStatus::Equal).map(|r| r.path.clone()).collect();+ for path in changed {+ for parent in Path::new(&path).ancestors().skip(1) {+ if let Some(row) = rows.get_mut(&ide_core::ipc_path::to_ipc(parent))+ && row.status == DirectoryCompareStatus::Equal+ {+ row.status = DirectoryCompareStatus::Different;+ }+ }+ }+ check(cancel)?;+ Ok(rows.into_values().collect())+}++/// Merges a subtree without following links inside the comparison roots. Existing files+/// require explicit overwrite; directory merges preserve destination-only entries.+pub fn copy_merge(+ from: &Path,+ to: &Path,+ overwrite: bool,+ project: Option<&Path>,+ excludes: &[String],+ roots: (&Path, &Path),+) -> IdeResult<()> {+ fn resolve(path: &Path) -> IdeResult<PathBuf> {+ if path.exists() {+ return Ok(dunce::canonicalize(path)?);+ }+ let parent = path.parent().ok_or_else(|| IdeError::invalid("copy requires an absolute path"))?;+ Ok(resolve(parent)?.join(path.file_name().ok_or_else(|| IdeError::invalid("missing file name"))?))+ }+ if !from.is_absolute() || !to.is_absolute() {+ return Err(IdeError::invalid("copy requires absolute paths"));+ }+ if !from.starts_with(roots.0) || !to.starts_with(roots.1) {+ return Err(IdeError::invalid("copy paths must belong to the comparison roots"));+ }+ let source = resolve(from)?;+ let target = resolve(to)?;+ if source.starts_with(&target) || target.starts_with(&source) {+ return Err(IdeError::invalid("cannot copy overlapping paths"));+ }+ for parent in to.ancestors().skip(1) {+ // The user explicitly selected this root; aliases above it (e.g. /tmp+ // on macOS) are valid. Links inside the copied subtree are not followed.+ if to == roots.1 || parent == roots.1 {+ break;+ }+ if fs::symlink_metadata(parent).is_ok_and(|m| m.file_type().is_symlink()) {+ return Err(IdeError::invalid("cannot copy through a destination symlink"));+ }+ }+ let source_base = project.filter(|p| from.starts_with(p)).or(Some(roots.0));+ let target_base = project.filter(|p| to.starts_with(p)).or(Some(roots.1));+ let rules = Rules::new(from, source_base, excludes);+ let target_rules = Rules::new(to, target_base, excludes);+ let mut pending = vec![(from.to_path_buf(), to.to_path_buf())];+ while let Some((src, dst)) = pending.pop() {+ let meta = fs::symlink_metadata(&src)?;+ if rules.excluded(&src, meta.is_dir()) || target_rules.excluded(&dst, meta.is_dir()) {+ continue;+ }+ let existing = fs::symlink_metadata(&dst).ok();+ let merge = meta.is_dir() && existing.as_ref().is_some_and(|m| m.is_dir());+ if existing.is_some() && !merge && !overwrite {+ return Err(std::io::Error::new(std::io::ErrorKind::AlreadyExists, dst.display().to_string()).into());+ }+ if meta.is_dir() {+ if existing.is_some() && !merge {+ crate::delete(&dst)?;+ }+ fs::create_dir_all(&dst)?;+ for entry in fs::read_dir(&src)? {+ let entry = entry?;+ pending.push((entry.path(), dst.join(entry.file_name())));+ }+ } else {+ if let Some(parent) = dst.parent() {+ fs::create_dir_all(parent)?;+ }+ // Stage the complete file before touching its destination.+ static NEXT: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);+ let id = NEXT.fetch_add(1, std::sync::atomic::Ordering::Relaxed);+ let temp = dst.with_file_name(format!(".openidea-copy-{}-{id}", std::process::id()));+ let mut staged = false;+ let result: IdeResult<()> = (|| {+ #[cfg(windows)]+ if meta.file_type().is_symlink() {+ use std::os::windows::fs::{FileTypeExt, symlink_dir, symlink_file};+ let target = fs::read_link(&src)?;+ if meta.file_type().is_symlink_dir() {+ symlink_dir(target, &temp)?;+ } else {+ symlink_file(target, &temp)?;+ }+ } else {+ crate::copy(&src, &temp)?;+ }+ #[cfg(not(windows))]+ crate::copy(&src, &temp)?;+ staged = true;+ // Recheck after staging: another writer may have created the target.+ if fs::symlink_metadata(&dst).is_ok() {+ if !overwrite {+ return Err(+ std::io::Error::new(std::io::ErrorKind::AlreadyExists, dst.display().to_string()).into()+ );+ }+ crate::delete(&dst)?;+ }+ fs::rename(&temp, &dst)?;+ Ok(())+ })();+ if let Err(error) = &result+ && (staged || error.kind != ide_core::error::ErrorKind::AlreadyExists)+ {+ let _ = crate::delete_permanently(&temp);+ }+ result?;+ }+ }+ Ok(())+}++#[cfg(test)]+mod tests {+ use super::*;+ use ide_core::error::ErrorKind;++ fn put(root: &Path, path: &str, content: &[u8]) {+ let path = root.join(path);+ fs::create_dir_all(path.parent().unwrap()).unwrap();+ fs::write(path, content).unwrap();+ }++ #[test]+ fn reports_add_delete_modify_equal_binary_unicode_empty_and_type_conflicts() {+ let tmp = tempfile::tempdir().unwrap();+ let left = tmp.path().join("left");+ let right = tmp.path().join("right");+ put(&left, "子目录/仅左.txt", b"left");+ put(&right, "only-right", b"right");+ for (path, a, b) in [+ ("same", b"same".as_slice(), b"same".as_slice()),+ ("binary", &[0, 255, 10], &[0, 254, 10]),+ ("size", b"a", b"bb"),+ ("conflict", b"file", b""),+ ] {+ put(&left, path, a);+ if path == "conflict" {+ put(&right, "conflict/child", b"child");+ } else {+ put(&right, path, b);+ }+ }+ fs::create_dir(left.join("empty")).unwrap();+ fs::create_dir(right.join("empty")).unwrap();+ let rows = compare_directories(&left, &right, None, &[], &CancellationToken::new(), |_| {}).unwrap();+ let status = |path| rows.iter().find(|r| r.path == path).unwrap().status;+ assert_eq!(status("same"), DirectoryCompareStatus::Equal);+ assert_eq!(status("empty"), DirectoryCompareStatus::Equal);+ for path in ["binary", "size", "conflict"] {+ assert_eq!(status(path), DirectoryCompareStatus::Different);+ }+ assert_eq!(status("子目录/仅左.txt"), DirectoryCompareStatus::LeftOnly);+ assert_eq!(status("only-right"), DirectoryCompareStatus::RightOnly);+ assert_eq!(status("conflict/child"), DirectoryCompareStatus::RightOnly);+ }++ #[test]+ fn applies_project_anchored_excludes_and_layered_ignores() {+ let tmp = tempfile::tempdir().unwrap();+ let left = tmp.path().join("left");+ let right = tmp.path().join("right");+ for root in [&left, &right] {+ put(root, "nested/node_modules/x", b"ignored");+ put(root, "target/x", b"ignored");+ put(root, ".git/config", b"ignored");+ put(root, "generated/x", b"ignored");+ put(root, ".gitignore", b"*.log\n");+ put(root, "nested/debug.log", b"ignored");+ put(root, "kept", b"kept");+ }+ let excludes = ["**/node_modules", "**/target", "/left/generated", "/right/generated"].map(String::from);+ let rows =+ compare_directories(&left, &right, Some(tmp.path()), &excludes, &CancellationToken::new(), |_| {}).unwrap();+ assert!(+ rows.iter()+ .all(|r| !["node_modules", "target", ".git/", "generated", ".log"].iter().any(|p| r.path.contains(p)))+ );+ assert!(rows.iter().any(|r| r.path == "kept"));+ }++ #[test]+ fn cancellation_stops_before_scan_during_scan_and_during_hashing() {+ let tmp = tempfile::tempdir().unwrap();+ let left = tmp.path().join("left");+ let right = tmp.path().join("right");+ put(&left, "big", &vec![1; 1024 * 1024]);+ put(&right, "big", &vec![1; 1024 * 1024]);+ for phase in 0..3 {+ let cancel = CancellationToken::new();+ if phase == 0 {+ cancel.cancel();+ }+ let result = compare_directories(&left, &right, None, &[], &cancel, |p| {+ if phase == 1 && p.scanned > 0 || phase == 2 && p.bytes_read > 0.0 {+ cancel.cancel();+ }+ });+ assert_eq!(result.unwrap_err().kind, ErrorKind::Cancelled);+ }+ }++ #[test]+ fn size_mismatches_are_not_hashed_and_directory_status_tracks_children() {+ let tmp = tempfile::tempdir().unwrap();+ let left = tmp.path().join("left");+ let right = tmp.path().join("right");+ put(&left, "nested/file", b"a");+ put(&right, "nested/file", b"ab");+ let bytes = std::cell::Cell::new(0.0);+ let rows =+ compare_directories(&left, &right, None, &[], &CancellationToken::new(), |p| bytes.set(p.bytes_read))+ .unwrap();+ assert_eq!(bytes.get(), 0.0);+ assert!(rows.iter().all(|r| r.status == DirectoryCompareStatus::Different));+ }++ #[test]+ fn merges_copies_with_explicit_overwrite_and_keeps_destination_only_files() {+ let tmp = tempfile::tempdir().unwrap();+ let left = tmp.path().join("left");+ let right = tmp.path().join("right");+ put(&left, "file", b"new");+ put(&left, "target/ignored", b"ignored");+ put(&right, "file", b"old");+ put(&right, "keep", b"keep");+ assert_eq!(+ copy_merge(&left, &right, false, None, &["target".into()], (&left, &right)).unwrap_err().kind,+ ErrorKind::AlreadyExists+ );+ assert_eq!(fs::read(right.join("file")).unwrap(), b"old");+ copy_merge(&left, &right, true, None, &["target".into()], (&left, &right)).unwrap();+ assert_eq!(fs::read(right.join("file")).unwrap(), b"new");+ assert_eq!(fs::read(right.join("keep")).unwrap(), b"keep");+ assert!(!right.join("target").exists());+ for (from, to) in [(&left, left.clone()), (&left, left.join("child")), (&right, tmp.path().to_path_buf())] {+ assert_eq!(+ copy_merge(from, &to, true, None, &[], (tmp.path(), tmp.path())).unwrap_err().kind,+ ErrorKind::InvalidInput+ );+ }+ }++ #[test]+ fn subtree_copy_keeps_excludes_anchored_to_each_comparison_root() {+ let tmp = tempfile::tempdir().unwrap();+ let left = tmp.path().join("left");+ let right = tmp.path().join("right");+ put(&left, "sub/build/keep", b"included below sub");+ put(&left, "sub/protected", b"do not overwrite");+ put(&right, "sub/protected", b"keep destination");+ put(&right, ".gitignore", b"sub/protected\n");+ copy_merge(&left.join("sub"), &right.join("sub"), true, None, &["/build".into()], (&left, &right)).unwrap();+ assert_eq!(fs::read(right.join("sub/build/keep")).unwrap(), b"included below sub");+ assert_eq!(fs::read(right.join("sub/protected")).unwrap(), b"keep destination");+ }++ #[test]+ fn confirmed_copy_replaces_file_directory_type_conflicts() {+ let tmp = tempfile::tempdir().unwrap();+ let left = tmp.path().join("left");+ let right = tmp.path().join("right");+ put(&left, "file", b"file");+ put(&right, "file/child", b"old directory");+ put(&left, "tree/child", b"new directory");+ put(&right, "tree", b"old file");+ for path in ["file", "tree"] {+ copy_merge(&left.join(path), &right.join(path), true, None, &[], (&left, &right)).unwrap();+ }+ assert_eq!(fs::read(right.join("file")).unwrap(), b"file");+ assert_eq!(fs::read(right.join("tree/child")).unwrap(), b"new directory");+ }++ #[cfg(unix)]+ #[test]+ fn symlinks_compare_link_text_and_are_not_followed_when_copying() {+ use std::os::unix::fs::symlink;+ let tmp = tempfile::tempdir().unwrap();+ let left = tmp.path().join("left");+ let right = tmp.path().join("right");+ fs::create_dir(&left).unwrap();+ fs::create_dir(&right).unwrap();+ symlink(".", left.join("loop")).unwrap();+ symlink("missing", right.join("loop")).unwrap();+ let rows = compare_directories(&left, &right, None, &[], &CancellationToken::new(), |_| {}).unwrap();+ assert_eq!(rows.len(), 1);+ assert_eq!(rows[0].status, DirectoryCompareStatus::Different);+ copy_merge(&left.join("loop"), &right.join("copied"), false, None, &[], (&left, &right)).unwrap();+ assert_eq!(fs::read_link(right.join("copied")).unwrap(), PathBuf::from("."));+ symlink(&right, tmp.path().join("alias")).unwrap();+ assert_eq!(+ copy_merge(&left.join("loop"), &tmp.path().join("alias/new"), true, None, &[], (tmp.path(), tmp.path()))+ .unwrap_err()+ .kind,+ ErrorKind::InvalidInput+ );+ }+}diff --git a/crates/ide-vfs/src/lib.rs b/crates/ide-vfs/src/lib.rsindex 55c28b71b..6ac24e21b 100644--- a/crates/ide-vfs/src/lib.rs+++ b/crates/ide-vfs/src/lib.rs@@ -2,6 +2,7 @@mod archive;mod bytes;+mod compare;mod encoding;mod ops;mod rules;@@ -20,6 +21,9 @@ pub use archive::{read_archive_entry, split_archive_path,};pub use bytes::{ByteRange, FileProbe, MAX_RANGE_LEN, base64, image_mime, probe, read_data_url, read_range};+pub use compare::{+ DirectoryCompareEntry, DirectoryCompareProgress, DirectoryCompareStatus, compare_directories, copy_merge,+};use encoding::SNIFF_LEN;pub use encoding::{LARGE_FILE_THRESHOLD, MAX_OPEN_SIZE, READ_ONLY_THRESHOLD, decode_properties_escapes, encode,diff --git a/src-tauri/src/commands/fs.rs b/src-tauri/src/commands/fs.rsindex 5ff8d0f10..efa29a9b5 100644--- a/src-tauri/src/commands/fs.rs+++ b/src-tauri/src/commands/fs.rs@@ -5,6 +5,38 @@ use ide_vfs::FileEntry;use std::path::PathBuf;use tauri::{State, Window};+#[tauri::command]+#[specta::specta]+pub async fn fs_entry_kind(state: State<'_, AppState>, path: PathBuf) -> IdeResult<ide_vfs::EntryKind> {+ fs::entry_kind(&state.host, path).await+}++#[tauri::command]+#[specta::specta]+pub async fn fs_compare_directories(+ window: Window,+ state: State<'_, AppState>,+ left: PathBuf,+ right: PathBuf,+ request: ide_core::RequestId,+ on_progress: tauri::ipc::Channel<ide_vfs::DirectoryCompareProgress>,+) -> IdeResult<Vec<ide_vfs::DirectoryCompareEntry>> {+ fs::compare_directories(&state.host, window.label(), left, right, request, super::sender(on_progress)).await+}++#[tauri::command]+#[specta::specta]+pub async fn fs_copy_merge(+ window: Window,+ state: State<'_, AppState>,+ source_root: PathBuf,+ destination_root: PathBuf,+ path: PathBuf,+ overwrite: bool,+) -> IdeResult<()> {+ fs::copy_merge(&state.host, window.label(), source_root, destination_root, path, overwrite).await+}+#[tauri::command]#[specta::specta]pub fn fs_read_dir(window: Window, state: State<'_, AppState>, path: PathBuf) -> IdeResult<Vec<FileEntry>> {diff --git a/src-tauri/src/commands/mod.rs b/src-tauri/src/commands/mod.rsindex ab121db65..c71ce8405 100644--- a/src-tauri/src/commands/mod.rs+++ b/src-tauri/src/commands/mod.rs@@ -126,6 +126,7 @@ pub fn builder() -> tauri_specta::Builder<tauri::Wry> {notebook::notebook_interrupt,notebook::notebook_restart,fs::fs_read_dir,+ fs::fs_entry_kind,bytes::fs_probe,bytes::fs_read_range,bytes::fs_read_image,@@ -136,6 +137,8 @@ pub fn builder() -> tauri_specta::Builder<tauri::Wry> {fs::fs_set_writable,fs::fs_delete,fs::fs_copy,+ fs::fs_copy_merge,+ fs::fs_compare_directories,fs::fs_read_text,clipboard::clipboard_file_list,clipboard::clipboard_has_files,diff --git a/src/bindings.ts b/src/bindings.tsindex 79eba7f80..97ce05285 100644--- a/src/bindings.ts+++ b/src/bindings.ts@@ -145,6 +145,7 @@ export const commands = {notebookInterrupt: (id: string) => typedError<null, IdeError>(__TAURI_INVOKE("notebook_interrupt", { id })),notebookRestart: (id: string) => typedError<NotebookSnapshot, IdeError>(__TAURI_INVOKE("notebook_restart", { id })),fsReadDir: (path: string) => typedError<FileEntry[], IdeError>(__TAURI_INVOKE("fs_read_dir", { path })),+ fsEntryKind: (path: string) => typedError<EntryKind, IdeError>(__TAURI_INVOKE("fs_entry_kind", { path })),/** Size and text/binary classification, from the file's head only. */fsProbe: (path: string) => typedError<FileProbe, IdeError>(__TAURI_INVOKE("fs_probe", { path })),/** Up to `len` bytes from `offset` (capped per call), base64-encoded. */@@ -167,6 +168,8 @@ export const commands = {/** Moving to the trash can take a while (large trees): kept off the main thread. */fsDelete: (path: string) => typedError<null, IdeError>(__TAURI_INVOKE("fs_delete", { path })),fsCopy: (from: string, to: string) => typedError<null, IdeError>(__TAURI_INVOKE("fs_copy", { from, to })),+ fsCopyMerge: (sourceRoot: string, destinationRoot: string, path: string, overwrite: boolean) => typedError<null, IdeError>(__TAURI_INVOKE("fs_copy_merge", { sourceRoot, destinationRoot, path, overwrite })),+ fsCompareDirectories: (left: string, right: string, request: RequestId, onProgress: Channel<DirectoryCompareProgress>) => typedError<DirectoryCompareEntry[], IdeError>(__TAURI_INVOKE("fs_compare_directories", { left, right, request, onProgress })),/*** Reads a text file without opening it as a document (previews, quick* definition). Prefers the unsaved buffer when the file is open.@@ -2513,6 +2516,25 @@ export type Diagnostic = {server?: string | null,};+export type DirectoryCompareEntry = {+ path: string,+ status: DirectoryCompareStatus,+ leftKind: EntryKind | null,+ rightKind: EntryKind | null,+ leftLink?: string | null,+ rightLink?: string | null,+};++export type DirectoryCompareProgress = {+ scanned: number,+ compared: number,+ total: number | null,+ bytesRead: number | null,+ path: string,+};++export type DirectoryCompareStatus = "leftOnly" | "rightOnly" | "different" | "equal";+/** Changes under a folder (Show History on a directory). */export type DirectoryHistory = {/** Snapshots of files under the folder and labels, newest first. */diff --git a/src/features/project-tree/contextMenu.test.ts b/src/features/project-tree/contextMenu.test.tsindex 622ddf3b0..d3f18a6d5 100644--- a/src/features/project-tree/contextMenu.test.ts+++ b/src/features/project-tree/contextMenu.test.ts@@ -40,6 +40,7 @@ const OTHER_ACTIONS = ["localHistory.putLabel","diff.compareWith","diff.compareFiles",+ "diff.compareDirectories","vcs.commit","vcs.addToVcs","vcs.annotate",@@ -75,6 +76,14 @@ afterEach(() => {});describe("project view context menu", () => {+ it("offers directory comparison only for two folders and Compare With for a single folder", () => {+ expect(labels(contextMenuItems([node("/p/left", true), node("/p/right", true)]))).toContain("Compare Directories");+ expect(labels(contextMenuItems([node("/p/left", true)]))).toContain("Compare With…");+ const mixed = labels(contextMenuItems([node("/p/left", true), node("/p/a.txt")]));+ for (const label of ["Compare Directories", "Compare Files", "Compare With…"]) expect(mixed).not.toContain(label);+ expect(labels(contextMenuItems([node("/p/a.txt"), node("/p/b.txt")]))).toContain("Compare Files");+ });+it("follows IDEA's order for a file", () => {const items = contextMenuItems([node(`${ROOT}/src/a.py`)]);expect(labels(items)).toEqual([@@ -161,7 +170,7 @@ describe("project view context menu", () => {const l = labels(contextMenuItems([node(`${ROOT}/src`, true)]));expect(l).toContain("Mark Directory as");expect(sub(contextMenuItems([node(`${ROOT}/src`, true)]), "Refactor")).toContain("Move Directory…");- for (const fileOnly of ["Find Usages", "Reformat Code", "Optimize Imports", "Compare With…", "Run 'a'"])+ for (const fileOnly of ["Find Usages", "Reformat Code", "Optimize Imports", "Run 'a'"])expect(l).not.toContain(fileOnly);});diff --git a/src/features/project-tree/contextMenu.ts b/src/features/project-tree/contextMenu.tsindex 1b35cf483..9775c9b4c 100644--- a/src/features/project-tree/contextMenu.ts+++ b/src/features/project-tree/contextMenu.ts@@ -361,7 +361,17 @@ export function contextMenuItems(nodes: ProjectNode[]): MenuItem[] {);}- // IDEA: Compare With… (one file) / Compare Files (two files).+ // Compare selections of the same kind; mixed file/folder selections cannot apply.+ const compareArg = single?.dir ? { path: single.path, directory: true } : single?.path;+ if (nodes.length === 2 && nodes.every((n) => n.dir && !n.placeholder))+ push(+ delegated(+ "diff.compareDirectories",+ nodes.map((n) => n.path),+ "Compare Directories",+ { icon: "diff" },+ ),+ );if (files.length === 2 && nodes.length === 2)push(delegated(@@ -371,9 +381,9 @@ export function contextMenuItems(nodes: ProjectNode[]): MenuItem[] {{ icon: "diff" },),);- else if (singleFile)+ else if (single && !single.placeholder)push(- delegated("diff.compareWith", singleFile.path, "Compare With…", {+ delegated("diff.compareWith", compareArg, "Compare With…", {icon: "diff",shortcut: keyLabel("project.compareWith"),}),diff --git a/src/features/vcs/ComparisonTree.tsx b/src/features/vcs/ComparisonTree.tsxnew file mode 100644index 000000000..e2fd952c6--- /dev/null+++ b/src/features/vcs/ComparisonTree.tsx@@ -0,0 +1,78 @@+import { useState, type ReactNode } from "react";+import { Icon, Tree, fileIconName } from "@/ui";+import { DiffEditor } from "./DiffEditor";+import { diffInput, openDiff, type DiffData } from "./diffInput";+import { dirKeys, type FileTreeNode } from "./fileTree";+import styles from "./common.module.css";++/** Shared changes tree and on-demand diff surface for revisions and disk folders. */+export function ComparisonTree<F>({+ tree,+ current,+ onSelect,+ diffFor,+ renderDetails,+ ariaLabel,+ openOnActivate = false,+ getColor,+ onOpen,+}: {+ tree: FileTreeNode<F>[];+ current: F | null;+ onSelect: (entry: F | null) => void;+ diffFor: (entry: F) => DiffData | null;+ renderDetails: (node: FileTreeNode<F>) => ReactNode;+ ariaLabel: string;+ openOnActivate?: boolean;+ getColor?: (entry: F) => string | undefined;+ onOpen?: () => void;+}) {+ const [selected, setSelected] = useState<ReadonlySet<string>>(new Set());+ const [expanded, setExpanded] = useState<ReadonlySet<string> | null>(null);+ const data = current && diffFor(current);+ const input = data ? diffInput(data) : null;+ return (+ <div className={`${styles.comparison} ${input ? styles.comparisonWithDiff : ""}`}>+ <Tree<FileTreeNode<F>>+ roots={tree}+ getKey={(n) => n.key}+ getLabel={(n) => n.name}+ getChildren={(n) => (n.file ? undefined : n.children)}+ isExpandable={(n) => !n.file}+ expanded={expanded ?? new Set(dirKeys(tree))}+ onExpandedChange={setExpanded}+ selected={selected}+ onSelectionChange={(sel, lead) => {+ setSelected(sel);+ onSelect(lead?.file ?? lead?.directory ?? null);+ }}+ onActivate={(n) => {+ const entry = n.file ?? n.directory;+ if (!entry) return;+ onSelect(entry);+ const diff = diffFor(entry);+ if (openOnActivate && diff) {+ void openDiff(diff);+ onOpen?.();+ }+ }}+ aria-label={ariaLabel}+ className={styles.comparisonTree}+ renderNode={(n) => (+ <span className={styles.fileRow} style={{ flex: 1, padding: 0 }}>+ <Icon name={n.file ? fileIconName(n.name) : "folder"} size={14} />+ <span className={styles.fileName} style={{ color: n.file ? getColor?.(n.file) : undefined }}>+ {n.name}+ </span>+ {renderDetails(n)}+ </span>+ )}+ />+ {input && (+ <div className={styles.comparisonDiff}>+ <DiffEditor key={input.key} input={input} />+ </div>+ )}+ </div>+ );+}diff --git a/src/features/vcs/DiffEditor.tsx b/src/features/vcs/DiffEditor.tsxindex 49a2dc674..f44a47d02 100644--- a/src/features/vcs/DiffEditor.tsx+++ b/src/features/vcs/DiffEditor.tsx@@ -200,6 +200,7 @@ export function DiffEditor({ input }: { input: EditorInput }) {const data = input.data as DiffData;const { path, left, right } = data;const [attached, setAttached] = useState<Attached | null>(null);+ const [binary, setBinary] = useState<boolean | null>(null);/** Text of the sides that are not live documents. */const [statics, setStatics] = useState<{ a: string | null; b: string | null } | null>(null);const [error, setError] = useState<string | null>(null);@@ -263,15 +264,18 @@ export function DiffEditor({ input }: { input: EditorInput }) {const reload = useCallback(async () => {if (!attached) return;try {- const [a, b] = await Promise.all([+ const paths = [sideFile(left, path), sideFile(right, path)].filter((p): p is string => !!p);+ const [a, b, probes] = await Promise.all([attached.a ? null : loadSide(path, left),attached.b ? null : loadSide(path, right),+ Promise.all(paths.map((p) => call(commands.fsProbe(p)).catch(() => null))),]);const prev = staticsRef.current;if (!prev || prev.a !== a || prev.b !== b) {staticsRef.current = { a, b };setStatics({ a, b });}+ setBinary(probes.some((p) => p?.binary));setError(null);} catch (e) {setError(errorMessage(e));@@ -311,9 +315,9 @@ export function DiffEditor({ input }: { input: EditorInput }) {left.rev === "HEAD" &&!left.path &&isWorktree(right);- const editableA = !!attached?.a && !attached.a.readOnly;- const editableB = !!attached?.b && !attached.b.readOnly;- const ready = !!attached && !!statics && lang !== null;+ const editableA = !binary && !!attached?.a && !attached.a.readOnly;+ const editableB = !binary && !!attached?.b && !attached.b.readOnly;+ const ready = !!attached && !!statics && lang !== null && binary !== null;// Read when the views are built; toggling it later goes through `setSync`.const syncScroll = useRef(opts.syncScroll);@@ -983,7 +987,8 @@ export function DiffEditor({ input }: { input: EditorInput }) {<span className={styles.sep} /><IconButton icon="refresh" title="Refresh" size="small" onClick={() => void reload()} /><span className={styles.count}>- {!ready+ {binary && tx("Binary content")}+ {!ready || binary? "": chunkInfo.count === 0? identical@@ -1047,7 +1052,11 @@ export function DiffEditor({ input }: { input: EditorInput }) {/></div>)}- {error ? (+ {binary ? (+ <div className={styles.message}>+ <T>Binary files cannot be shown as text</T>+ </div>+ ) : error ? (<div className={styles.message}>{error}</div>) : !ready ? (<div className={styles.message}>@@ -1061,7 +1070,7 @@ export function DiffEditor({ input }: { input: EditorInput }) {opts.highlight === "none" && styles.noHighlight,opts.mode === "split" && (opts.alignChanges ? !opts.syncScroll && styles.unsynced : styles.unaligned),)}- hidden={!!error || !ready}+ hidden={!!binary || !!error || !ready}aria-label={diffTitle(data)}role="region"onContextMenu={onContextMenu}diff --git a/src/features/vcs/DirectoryCompare.tsx b/src/features/vcs/DirectoryCompare.tsxnew file mode 100644index 000000000..b70e2acad--- /dev/null+++ b/src/features/vcs/DirectoryCompare.tsx@@ -0,0 +1,291 @@+import { useEffect, useMemo, useRef, useState } from "react";+import { Channel } from "@tauri-apps/api/core";+import type { DirectoryCompareEntry, DirectoryCompareProgress, DirectoryCompareStatus } from "@/bindings";+import { call, commands, emitLocalIdeEvent, IpcError, isCancelled, nextRequestId } from "@/platform/ipc";+import { notifyFileOperation } from "@/platform/fileOps";+import { tx } from "@/platform/i18n";+import { Button, Checkbox, Dialog, Input, Spinner, T } from "@/ui";+import { upsertTask } from "@/workbench/tasks";+import { ComparisonTree } from "./ComparisonTree";+import { buildFileTree } from "./fileTree";+import { confirmDialog, openDialog } from "./dialogs";+import { openDiff, type DiffData, type DiffSide } from "./diffInput";+import { compareFilesData } from "./compareData";+import styles from "./common.module.css";++const STATUS: Record<DirectoryCompareStatus, string> = {+ leftOnly: "Only on left",+ rightOnly: "Only on right",+ different: "Contents differ",+ equal: "Identical",+};+const join = (root: string, path: string) => `${root.replace(/\/$/, "")}/${path}`;+const directory = (e: DirectoryCompareEntry) => e.leftKind === "dir" || e.rightKind === "dir";++export function directoryDiff(left: string, right: string, entry: DirectoryCompareEntry): DiffData | null {+ if (directory(entry)) return null;+ const data = compareFilesData(join(left, entry.path), join(right, entry.path));+ const missing = (): DiffSide => ({ type: "text", text: "", label: tx("(does not exist)") });+ return {+ ...data,+ title: entry.path,+ left:+ entry.leftKind === "symlink"+ ? { type: "text", text: entry.leftLink ?? "", label: data.left.label ?? join(left, entry.path) }+ : entry.leftKind+ ? data.left+ : missing(),+ right:+ entry.rightKind === "symlink"+ ? { type: "text", text: entry.rightLink ?? "", label: data.right.label ?? join(right, entry.path) }+ : entry.rightKind+ ? data.right+ : missing(),+ };+}++export function showDirectoryComparison(left: string, right: string) {+ if (left === right) return;+ openDialog((close) => <DirectoryCompareDialog left={left} right={right} onClose={close} />);+}++export function DirectoryCompareDialog({ left, right, onClose }: { left: string; right: string; onClose: () => void }) {+ const [entries, setEntries] = useState<DirectoryCompareEntry[]>([]);+ const [current, setCurrent] = useState<DirectoryCompareEntry | null>(null);+ const [showEqual, setShowEqual] = useState(false);+ const [filter, setFilter] = useState("");+ const [generation, setGeneration] = useState(0);+ const [busy, setBusy] = useState(true);+ const [operating, setOperating] = useState(false);+ const [error, setError] = useState<string | null>(null);+ const [operationError, setOperationError] = useState<string | null>(null);+ const [progress, setProgress] = useState<DirectoryCompareProgress | null>(null);+ const [cancelled, setCancelled] = useState(false);+ const cancel = useRef<() => void>(() => {});+ const mounted = useRef(true);+ useEffect(() => {+ mounted.current = true;+ return () => {+ mounted.current = false;+ };+ }, []);+ useEffect(() => {+ let alive = true;+ let pending = true;+ const request = nextRequestId();+ const task = {+ id: `directory-compare-${request}`,+ title: tx("Comparing directories"),+ message: null as string | null,+ fraction: null as number | null,+ cancel: () => {+ void commands.cancelRequest(request);+ },+ };+ cancel.current = task.cancel;+ upsertTask({ ...task, done: false });+ const channel = new Channel<DirectoryCompareProgress>();+ channel.onmessage = (p) => {+ if (!alive) return;+ setProgress(p);+ task.message = p.path;+ task.fraction = p.total ? p.compared / p.total : null;+ upsertTask({ ...task, done: false });+ };+ void call(commands.fsCompareDirectories(left, right, request, channel))+ .then((rows) => {+ if (!alive) return;+ setEntries(rows);+ setCurrent((prev) => rows.find((e) => e.path === prev?.path) ?? null);+ })+ .catch((e) => {+ if (!alive) return;+ if (isCancelled(e)) setCancelled(true);+ else setError(e instanceof Error ? e.message : String(e));+ })+ .finally(() => {+ pending = false;+ upsertTask({ ...task, done: true });+ if (alive) setBusy(false);+ });+ return () => {+ alive = false;+ if (pending) task.cancel();+ upsertTask({ ...task, done: true });+ };+ }, [left, right, generation]);++ const visible = useMemo(() => {+ const paths = new Set<string>();+ const query = filter.trim().toLocaleLowerCase();+ for (const e of entries) {+ if ((!showEqual && e.status === "equal") || !e.path.toLocaleLowerCase().includes(query)) continue;+ let path = e.path;+ while (path) {+ paths.add(path);+ const slash = path.lastIndexOf("/");+ path = slash < 0 ? "" : path.slice(0, slash);+ }+ }+ return entries.filter((e) => paths.has(e.path));+ }, [entries, showEqual, filter]);+ const tree = useMemo(() => buildFileTree(visible, (e) => e.path, directory), [visible]);+ const selected = cancelled || error ? null : (visible.find((e) => e.path === current?.path) ?? null);+ const diff = selected && directoryDiff(left, right, selected);+ const refresh = () => {+ setBusy(true);+ setCancelled(false);+ setError(null);+ setProgress(null);+ setGeneration((g) => g + 1);+ };++ const operate = async (side: "left" | "right" | "delete") => {+ if (!selected || busy || operating) return;+ setOperating(true);+ setOperationError(null);+ let attempted = false;+ const targetRoot = side === "left" ? left : right;+ try {+ if (side === "delete") {+ if (!!selected.leftKind === !!selected.rightKind) return;+ const path = join(selected.leftKind ? left : right, selected.path);+ if (!(await confirmDialog({ title: "Delete", message: tx`Delete ${path}?`, okLabel: "Delete", danger: true })))+ return;+ attempted = true;+ await call(commands.fsDelete(path));+ notifyFileOperation({ kind: "deleted", paths: [path] });+ emitLocalIdeEvent({ type: "fsChanged", created: [], modified: [], removed: [path] });+ } else {+ const sourceRoot = side === "left" ? right : left;+ const to = join(targetRoot, selected.path);+ try {+ attempted = true;+ await call(commands.fsCopyMerge(sourceRoot, targetRoot, selected.path, false));+ } catch (e) {+ if (!(e instanceof IpcError) || e.kind !== "alreadyExists") throw e;+ if (+ !(await confirmDialog({+ title: "Overwrite files?",+ message: tx`Copy to ${to} and overwrite existing files?`,+ okLabel: "Overwrite",+ danger: true,+ }))+ )+ return;+ await call(commands.fsCopyMerge(sourceRoot, targetRoot, selected.path, true));+ }+ notifyFileOperation({ kind: "created", paths: [to] });+ emitLocalIdeEvent({ type: "fsChanged", created: [to], modified: [to], removed: [] });+ }+ } catch (e) {+ if (mounted.current) setOperationError(e instanceof Error ? e.message : String(e));+ } finally {+ if (mounted.current) {+ setOperating(false);+ if (attempted) refresh();+ }+ }+ };++ return (+ <Dialog+ open+ title="Compare Directories"+ onClose={onClose}+ width={diff ? 1100 : 780}+ buttons={[+ {+ label: "Show Diff",+ disabled: !diff || busy || operating,+ onClick: () => {+ if (diff) {+ void openDiff(diff);+ onClose();+ }+ },+ },+ { label: "Close", role: "cancel" },+ ]}+ >+ <div className={styles.compareNotice}>{tx`Left: ${left}`}</div>+ <div className={styles.compareNotice}>{tx`Right: ${right}`}</div>+ <div className={styles.compareToolbar}>+ <Input+ aria-label="Filter by name"+ placeholder="Filter by name"+ value={filter}+ onChange={(e) => setFilter(e.target.value)}+ />+ <Checkbox label="Show identical files" checked={showEqual} onChange={setShowEqual} />+ <Button size="small" disabled={busy || operating} onClick={refresh}>+ Refresh+ </Button>+ </div>+ <div className={styles.compareToolbar}>+ <Button size="small" disabled={!selected?.rightKind || busy || operating} onClick={() => void operate("left")}>+ Copy to Left+ </Button>+ <Button size="small" disabled={!selected?.leftKind || busy || operating} onClick={() => void operate("right")}>+ Copy to Right+ </Button>+ <Button+ size="small"+ disabled={!selected || !!selected.leftKind === !!selected.rightKind || busy || operating}+ onClick={() => void operate("delete")}+ >+ Delete+ </Button>+ {operating && <Spinner size={14} />}+ </div>+ {error && (+ <div className={styles.error} role="alert">+ {tx(error)}+ </div>+ )}+ {operationError && (+ <div className={styles.error} role="alert">+ {tx(operationError)}+ </div>+ )}+ {busy && (+ <div className={styles.compareToolbar} role="status">+ <Spinner size={14} />+ <span>+ {progress?.total != null+ ? tx`Compared ${progress.compared} of ${progress.total} entries`+ : tx`Scanned ${progress?.scanned ?? 0} entries`}+ </span>+ <Button size="small" onClick={() => cancel.current()}>+ Cancel+ </Button>+ </div>+ )}+ {cancelled && (+ <div className={styles.compareNotice} role="status">+ <T>Comparison cancelled</T>+ </div>+ )}+ {!busy && !cancelled && !error && !visible.length && (+ <div className={styles.empty} role="status">+ <T>No matching differences</T>+ </div>+ )}+ {!!tree.length && (+ <ComparisonTree+ tree={tree}+ current={busy || operating ? null : selected}+ onSelect={setCurrent}+ diffFor={(e) => directoryDiff(left, right, e)}+ openOnActivate={!busy && !operating}+ onOpen={onClose}+ ariaLabel="Compared files"+ renderDetails={(n) => {+ const entry = n.file ?? n.directory;+ return <span className={styles.fileDir}>{entry ? tx(STATUS[entry.status]) : n.count}</span>;+ }}+ />+ )}+ </Dialog>+ );+}diff --git a/src/features/vcs/__tests__/diffToolbar.test.tsx b/src/features/vcs/__tests__/diffToolbar.test.tsxindex 9bd19206f..dbf74852f 100644--- a/src/features/vcs/__tests__/diffToolbar.test.tsx+++ b/src/features/vcs/__tests__/diffToolbar.test.tsx@@ -66,6 +66,21 @@ beforeEach(() => {});describe("Diff toolbar", () => {+ it("shows a binary notice for disk comparisons instead of identical empty text", async () => {+ probe.mockResolvedValue({ status: "ok", data: { size: 3, binary: true, tooLarge: false } });+ const binaryInput = {+ ...input,+ data: { path: "/p/right.bin", left: { type: "file", path: "/p/left.bin" }, right: { type: "worktree" } },+ } as EditorInput;+ render(<DiffEditor input={binaryInput} />);+ expect(await screen.findByText("Binary files cannot be shown as text")).toBeInTheDocument();+ expect(screen.queryByText("Contents are identical")).toBeNull();+ expect(screen.queryByRole("region", { name: /left.bin/ })).toBeNull();+ probe.mockResolvedValue({ status: "ok", data: { size: 3, binary: false, tooLarge: false } });+ fireEvent.click(screen.getByRole("button", { name: "Refresh" }));+ await waitFor(() => expect(screen.queryByText("Binary files cannot be shown as text")).toBeNull());+ });+it("puts Jump to Source right after Next Difference, in the navigation group", async () => {render(<DiffEditor input={input} />);await screen.findByRole("button", { name: "Jump to Source" });diff --git a/src/features/vcs/__tests__/directoryCompare.test.tsx b/src/features/vcs/__tests__/directoryCompare.test.tsxnew file mode 100644index 000000000..896fc57e1--- /dev/null+++ b/src/features/vcs/__tests__/directoryCompare.test.tsx@@ -0,0 +1,179 @@+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";+import { cleanup, fireEvent, render, screen, waitFor } from "@testing-library/react";+import type { DirectoryCompareEntry } from "@/bindings";++const mocks = vi.hoisted(() => ({+ compare: vi.fn(),+ cancel: vi.fn(),+ copy: vi.fn(),+ remove: vi.fn(),+ confirm: vi.fn(),+ open: vi.fn(),+}));+vi.mock("@/platform/ipc", async (original) => {+ const real = await original<typeof import("@/platform/ipc")>();+ return {+ ...real,+ commands: {+ ...real.commands,+ fsCompareDirectories: mocks.compare,+ fsCopyMerge: mocks.copy,+ fsDelete: mocks.remove,+ cancelRequest: mocks.cancel,+ },+ };+});+vi.mock("@tauri-apps/api/core", async (original) => ({+ ...(await original<typeof import("@tauri-apps/api/core")>()),+ Channel: class {+ onmessage = () => {};+ },+}));+vi.mock("../DiffEditor", () => ({+ DiffEditor: ({ input }: { input: unknown }) => <div data-testid="diff">{JSON.stringify(input)}</div>,+}));+vi.mock("../dialogs", () => ({ confirmDialog: mocks.confirm, openDialog: vi.fn(), promptText: vi.fn() }));+vi.mock("../diffInput", async (original) => ({+ ...(await original<typeof import("../diffInput")>()),+ openDiff: mocks.open,+}));+import { DirectoryCompareDialog, directoryDiff } from "../DirectoryCompare";++const row = (+ path: string,+ status: DirectoryCompareEntry["status"],+ leftKind: DirectoryCompareEntry["leftKind"] = "file",+ rightKind: DirectoryCompareEntry["rightKind"] = "file",+): DirectoryCompareEntry => ({ path, status, leftKind, rightKind });+const rows = [+ row("nested", "different", "dir", "dir"),+ row("nested/中文.txt", "different"),+ row("only-left.txt", "leftOnly", "file", null),+ row("only-right.txt", "rightOnly", null, "file"),+ row("same.txt", "equal"),+ row("empty", "leftOnly", "dir", null),+];+const ok = (data: unknown = null) => ({ status: "ok", data });+const setup = () => render(<DirectoryCompareDialog left="/p/left" right="/p/right" onClose={() => {}} />);++beforeEach(() => {+ vi.clearAllMocks();+ mocks.compare.mockResolvedValue(ok(rows));+ mocks.copy.mockResolvedValue(ok());+ mocks.remove.mockResolvedValue(ok());+ mocks.confirm.mockResolvedValue(true);+});+afterEach(cleanup);++describe("disk directory comparison", () => {+ it("reuses the changes tree, filters names and toggles identical files", async () => {+ setup();+ expect(await screen.findByText("中文.txt")).toBeInTheDocument();+ expect(screen.getAllByText("Only on left")).toHaveLength(2);+ expect(screen.getByText("Only on right")).toBeInTheDocument();+ expect(screen.queryByText("same.txt")).toBeNull();+ fireEvent.click(screen.getByRole("checkbox", { name: "Show identical files" }));+ expect(screen.getByText("same.txt")).toBeInTheDocument();+ fireEvent.change(screen.getByRole("textbox", { name: "Filter by name" }), { target: { value: "中文" } });+ expect(screen.queryByText("same.txt")).toBeNull();+ expect(screen.getByText("nested")).toBeInTheDocument();+ fireEvent.mouseDown(screen.getByText("nested"), { button: 0 });+ expect(screen.getByRole("button", { name: "Copy to Right" })).toBeEnabled();+ });++ it("previews on selection and opens the existing diff on double click, including missing sides", async () => {+ setup();+ fireEvent.mouseDown(await screen.findByText("中文.txt"), { button: 0 });+ expect(screen.getByTestId("diff")).toHaveTextContent("/p/left/nested/中文.txt");+ fireEvent.doubleClick(screen.getByText("中文.txt"));+ expect(mocks.open).toHaveBeenCalledWith(expect.objectContaining({ path: "/p/right/nested/中文.txt" }));+ expect(directoryDiff("/l", "/r", rows[2]!)?.right.type).toBe("text");+ expect(directoryDiff("/l", "/r", rows[3]!)?.left.type).toBe("text");+ expect(directoryDiff("/l", "/r", row("type", "different", "file", "dir"))).toBeNull();+ expect(+ directoryDiff("/l", "/r", {+ ...row("link", "different", "symlink", "symlink"),+ leftLink: "one",+ rightLink: "two",+ }),+ ).toMatchObject({+ left: { type: "text", text: "one" },+ right: { type: "text", text: "two" },+ });+ });++ it.each(["Copy to Left", "Copy to Right"])(+ "confirms before overwriting, refreshes and restores selection after %s",+ async (label) => {+ mocks.copy+ .mockResolvedValueOnce({ status: "error", error: { kind: "alreadyExists", message: "exists" } })+ .mockResolvedValueOnce(ok());+ setup();+ fireEvent.mouseDown(await screen.findByText("中文.txt"), { button: 0 });+ fireEvent.click(screen.getByRole("button", { name: label }));+ await waitFor(() =>+ expect(mocks.confirm).toHaveBeenCalledWith(expect.objectContaining({ title: "Overwrite files?" })),+ );+ await waitFor(() => expect(mocks.compare).toHaveBeenCalledTimes(2));+ expect(mocks.copy.mock.calls[0]![3]).toBe(false);+ expect(mocks.copy.mock.calls[1]![3]).toBe(true);+ expect(mocks.copy.mock.calls[0]!.slice(0, 3)).toEqual(+ label === "Copy to Left"+ ? ["/p/right", "/p/left", "nested/中文.txt"]+ : ["/p/left", "/p/right", "nested/中文.txt"],+ );+ expect(screen.getByTestId("diff")).toBeInTheDocument();+ },+ );++ it("does not overwrite when confirmation is declined and reports operation errors", async () => {+ mocks.copy.mockResolvedValue({ status: "error", error: { kind: "alreadyExists", message: "exists" } });+ mocks.confirm.mockResolvedValue(false);+ setup();+ fireEvent.mouseDown(await screen.findByText("中文.txt"), { button: 0 });+ fireEvent.click(screen.getByRole("button", { name: "Copy to Right" }));+ await waitFor(() => expect(mocks.compare).toHaveBeenCalledTimes(2));+ expect(mocks.copy).toHaveBeenCalledTimes(1);+ mocks.copy.mockResolvedValue({ status: "error", error: { kind: "permissionDenied", message: "Cannot write" } });+ fireEvent.click(screen.getByRole("button", { name: "Copy to Right" }));+ expect(await screen.findByRole("alert")).toHaveTextContent("Cannot write");+ });++ it("copies empty and nonempty subdirectories and confirms deletion only for one-sided entries", async () => {+ setup();+ fireEvent.mouseDown(await screen.findByText("nested"), { button: 0 });+ expect(screen.getByRole("button", { name: "Delete" })).toBeDisabled();+ fireEvent.click(screen.getByRole("button", { name: "Copy to Right" }));+ await waitFor(() => expect(mocks.copy).toHaveBeenCalledWith("/p/left", "/p/right", "nested", false));+ await waitFor(() => expect(mocks.compare).toHaveBeenCalledTimes(2));+ fireEvent.mouseDown(screen.getByText("empty"), { button: 0 });+ fireEvent.click(screen.getByRole("button", { name: "Copy to Right" }));+ await waitFor(() => expect(mocks.copy).toHaveBeenCalledWith("/p/left", "/p/right", "empty", false));+ await waitFor(() => expect(mocks.compare).toHaveBeenCalledTimes(3));+ fireEvent.mouseDown(screen.getByText("only-left.txt"), { button: 0 });+ mocks.confirm.mockResolvedValueOnce(false);+ fireEvent.click(screen.getByRole("button", { name: "Delete" }));+ await waitFor(() => expect(mocks.confirm).toHaveBeenCalled());+ expect(mocks.remove).not.toHaveBeenCalled();+ fireEvent.click(screen.getByRole("button", { name: "Delete" }));+ await waitFor(() => expect(mocks.remove).toHaveBeenCalledWith("/p/left/only-left.txt"));+ });++ it("streams progress, cancels on demand and on close, and ignores stale results after refresh", async () => {+ let resolve!: (value: unknown) => void;+ mocks.compare.mockImplementationOnce((_l, _r, _request, channel) => {+ channel.onmessage({ scanned: 20, compared: 5, total: 10, bytesRead: 100, path: "big" });+ return new Promise((r) => {+ resolve = r;+ });+ });+ const view = setup();+ expect(await screen.findByText("Compared 5 of 10 entries")).toBeInTheDocument();+ const request = mocks.compare.mock.calls[0]![2];+ fireEvent.click(screen.getByRole("button", { name: "Cancel" }));+ expect(mocks.cancel).toHaveBeenCalledWith(request);+ view.unmount();+ expect(mocks.cancel).toHaveBeenCalledTimes(2);+ resolve(ok(rows));+ });+});diff --git a/src/features/vcs/__tests__/directoryCompareActions.test.ts b/src/features/vcs/__tests__/directoryCompareActions.test.tsnew file mode 100644index 000000000..4a0d5cbae--- /dev/null+++ b/src/features/vcs/__tests__/directoryCompareActions.test.ts@@ -0,0 +1,95 @@+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";+const mocks = vi.hoisted(() => ({+ show: vi.fn(),+ read: vi.fn(),+ notify: vi.fn(),+ pick: vi.fn(),+ remote: vi.fn(),+ prompt: vi.fn(),+ openDiff: vi.fn(),+}));+vi.mock("../DirectoryCompare", () => ({ showDirectoryComparison: mocks.show }));+vi.mock("../dialogs", () => ({ promptText: mocks.prompt }));+vi.mock("../diffInput", () => ({ openDiff: mocks.openDiff }));+vi.mock("@tauri-apps/plugin-dialog", () => ({ open: mocks.pick }));+vi.mock("@/platform/remote", () => ({ isRemoteWindow: mocks.remote }));+vi.mock("@/platform/ipc", async (original) => ({+ ...(await original<typeof import("@/platform/ipc")>()),+ isTauri: () => true,+ commands: { fsEntryKind: mocks.read },+}));+vi.mock("@/workbench/contributions", async (original) => ({+ ...(await original<typeof import("@/workbench/contributions")>()),+ notifications: () => ({ notify: mocks.notify }),+}));+import { getAction, isActionEnabled } from "@/platform/actions";+import { provideProjectViewSelection } from "@/workbench/contributions";+import { registerCompareActions } from "../compare";++let dispose: () => void;+beforeEach(() => {+ vi.clearAllMocks();+ dispose = registerCompareActions();+ mocks.remote.mockReturnValue(false);+ mocks.read.mockImplementation((path: string) =>+ Promise.resolve({ status: "ok", data: path.endsWith(".txt") ? "file" : "dir" }),+ );+});+afterEach(() => dispose());++describe("directory compare actions", () => {+ it("has a stable searchable action and resolves the selection for Find Action", async () => {+ const unselect = provideProjectViewSelection(() => ["/p/left", "/p/right"]);+ try {+ const action = getAction("diff.compareDirectories")!;+ expect(action.title).toBe("Compare Directories");+ expect(action.hidden).not.toBe(true);+ expect(isActionEnabled(action, { projectOpen: true })).toBe(true);+ await action.run({ ctx: { projectOpen: true } });+ expect(mocks.show).toHaveBeenCalledWith("/p/left", "/p/right");+ await action.run({ ctx: { projectOpen: true }, arg: { paths: ["/x/left", "/x/right"] } });+ expect(mocks.show).toHaveBeenLastCalledWith("/x/left", "/x/right");+ } finally {+ unselect();+ }+ });++ it("rejects mixed selections and does not start a directory comparison", async () => {+ await getAction("diff.compareDirectories")!.run({ ctx: {}, arg: ["/p/left", "/p/file.txt"] });+ expect(mocks.show).not.toHaveBeenCalled();+ expect(mocks.notify).toHaveBeenCalledWith(expect.objectContaining({ title: "Select two directories to compare" }));+ });++ it("uses the native folder picker for Compare With on a local directory", async () => {+ mocks.pick.mockResolvedValue("/p/right");+ await getAction("diff.compareWith")!.run({ ctx: {}, arg: { path: "/p/left", directory: true } });+ expect(mocks.pick).toHaveBeenCalledWith(expect.objectContaining({ directory: true }));+ expect(mocks.show).toHaveBeenCalledWith("/p/left", "/p/right");+ expect(mocks.openDiff).not.toHaveBeenCalled();+ });++ it("uses remote paths and validates the selected directory via the routed filesystem", async () => {+ mocks.remote.mockReturnValue(true);+ mocks.prompt.mockResolvedValue({ value: "/remote/right" });+ const unselect = provideProjectViewSelection(() => ["/remote/left"]);+ try {+ await getAction("diff.compareWith")!.run({ ctx: {} });+ expect(mocks.prompt).toHaveBeenCalledWith(+ expect.objectContaining({ label: "Directory path", initial: "/remote/left" }),+ );+ expect(mocks.pick).not.toHaveBeenCalled();+ expect(mocks.read).toHaveBeenCalledWith("/remote/right");+ expect(mocks.show).toHaveBeenCalledWith("/remote/left", "/remote/right");+ } finally {+ unselect();+ }+ });++ it("leaves file Compare With on the existing diff flow", async () => {+ mocks.pick.mockResolvedValue("/p/b.txt");+ await getAction("diff.compareWith")!.run({ ctx: {}, arg: "/p/a.txt" });+ expect(mocks.pick).toHaveBeenCalledWith(expect.objectContaining({ directory: false }));+ expect(mocks.openDiff).toHaveBeenCalledWith(expect.objectContaining({ path: "/p/b.txt" }));+ expect(mocks.show).not.toHaveBeenCalled();+ });+});diff --git a/src/features/vcs/__tests__/fileTree.test.ts b/src/features/vcs/__tests__/fileTree.test.tsindex c0327edca..158f32829 100644--- a/src/features/vcs/__tests__/fileTree.test.ts+++ b/src/features/vcs/__tests__/fileTree.test.ts@@ -9,4 +9,21 @@ describe("buildFileTree", () => {expect(tree[1]!.children.map((c) => c.name)).toEqual(["a.ts", "b.ts"]);expect(dirKeys(tree)).toEqual(["d:docs/x/y", "d:src/app"]);});++ it("retains explicit empty directories and their entries for subtree operations", () => {+ const entries = [+ { path: "empty", dir: true },+ { path: "src", dir: true },+ { path: "src/nested", dir: true },+ { path: "src/nested/a", dir: false },+ ];+ const tree = buildFileTree(+ entries,+ (e) => e.path,+ (e) => e.dir,+ );+ expect(tree[0]).toMatchObject({ name: "empty", directory: entries[0], children: [], count: 0 });+ expect(tree[1]).toMatchObject({ name: "src", directory: entries[1] });+ expect(tree[1]!.children[0]).toMatchObject({ name: "nested", directory: entries[2] });+ });});diff --git a/src/features/vcs/common.module.css b/src/features/vcs/common.module.cssindex c18a071e9..9e9acc8df 100644--- a/src/features/vcs/common.module.css+++ b/src/features/vcs/common.module.css@@ -310,6 +310,17 @@color: var(--fg-subtle);overflow-wrap: anywhere;}+.compareToolbar {+ display: flex;+ align-items: center;+ flex-wrap: wrap;+ gap: 8px;+ padding: 6px 14px;+}+.compareToolbar > input {+ flex: 1;+ min-width: 140px;+}.compareAdded {color: var(--vcs-added);font-variant-numeric: tabular-nums;diff --git a/src/features/vcs/compare.tsx b/src/features/vcs/compare.tsxindex a2799e617..1437abdbe 100644--- a/src/features/vcs/compare.tsx+++ b/src/features/vcs/compare.tsx@@ -4,10 +4,13 @@*/import { activeEditor } from "@/editor/api";import { registerActions } from "@/platform/actions";-import { isTauri } from "@/platform/ipc";-import { useProject } from "@/platform/project";-import { maybeEditorService, notifications } from "@/workbench/contributions";+import { call, commands, isTauri } from "@/platform/ipc";+import { isRemoteWindow } from "@/platform/remote";+import { maybeEditorService, notifications, projectViewSelection } from "@/workbench/contributions";+import { promptText } from "./dialogs";import { focusedDiffNavigator } from "./diffNavigator";+import { compareFilesData, displayPath } from "./compareData";+export { compareFilesData, displayPath } from "./compareData";import { openDiff, type DiffData } from "./diffInput";import { baseName } from "./model";import { tx } from "@/platform/i18n";@@ -27,20 +30,6 @@ function argPaths(arg: unknown): string[] {return p ? [p] : [];}-/** Project-relative path for labels. */-export function displayPath(path: string, root = useProject.getState().project?.root ?? null): string {- return root && path.startsWith(root + "/") ? path.slice(root.length + 1) : path;-}--/** Diff of two files on disk; both sides are live, editable documents. */-export function compareFilesData(leftPath: string, rightPath: string): DiffData {- return {- path: rightPath,- left: { type: "file", path: leftPath, label: displayPath(leftPath) },- right: { type: "worktree", label: displayPath(rightPath) },- };-}-/** Clipboard ↔ the file (editable) or ↔ the editor selection. */export function clipboardDiffData(path: string, clipboard: string, selection: string | null): DiffData {return {@@ -122,6 +111,29 @@ async function pickComparison(const contextPath = (arg: unknown) => argPath(arg) ?? maybeEditorService()?.activePath() ?? undefined;+async function showDirectories(left: string, right: string) {+ const { showDirectoryComparison } = await import("./DirectoryCompare");+ showDirectoryComparison(left, right);+}++async function isDirectory(path: string): Promise<boolean> {+ try {+ return (await call(commands.fsEntryKind(path))) === "dir";+ } catch {+ return false;+ }+}++async function pickDirectory(near: string): Promise<string | null> {+ if (isRemoteWindow() || !isTauri()) {+ const picked = await promptText({ title: "Compare With", label: "Directory path", initial: near, mono: true });+ return picked?.value ?? null;+ }+ const { open } = await import("@tauri-apps/plugin-dialog");+ const picked = await open({ multiple: false, directory: true, title: tx("Compare With"), defaultPath: near });+ return (Array.isArray(picked) ? picked[0] : picked) ?? null;+}+export function registerCompareActions(): () => void {return registerActions([{@@ -210,10 +222,18 @@ export function registerCompareActions(): () => void {category: "Diff",icon: "diff",when: "projectOpen",- keywords: ["diff", "compare files"],+ keywords: ["diff", "compare files", "compare folders"],run: async ({ arg }) => {- const path = contextPath(arg);+ const path = argPath(arg) ?? projectViewSelection()[0] ?? contextPath(arg);if (!path) return info("Open or select a file to compare");+ const directoryArg = !!arg && typeof arg === "object" && "directory" in arg && arg.directory === true;+ if (directoryArg || (isTauri() && (await isDirectory(path)))) {+ const other = await pickDirectory(path);+ if (!other || other === path) return;+ if (!(await isDirectory(other))) return info("Select a directory to compare");+ await showDirectories(path, other);+ return;+ }const other = await pickComparison(path);if (!other) return;if (other.type === "file") {@@ -228,6 +248,20 @@ export function registerCompareActions(): () => void {}},},+ {+ id: "diff.compareDirectories",+ title: "Compare Directories",+ category: "Diff",+ icon: "diff",+ when: "projectOpen",+ keywords: ["diff", "folders", "compare folders"],+ run: async ({ arg }) => {+ const paths = arg === undefined ? projectViewSelection() : argPaths(arg);+ if (paths.length !== 2 || !(await isDirectory(paths[0]!)) || !(await isDirectory(paths[1]!)))+ return info("Select two directories to compare");+ await showDirectories(paths[0]!, paths[1]!);+ },+ },{id: "diff.compareFiles",title: "Compare Files",diff --git a/src/features/vcs/compareData.ts b/src/features/vcs/compareData.tsnew file mode 100644index 000000000..fc693fce1--- /dev/null+++ b/src/features/vcs/compareData.ts@@ -0,0 +1,16 @@+import { useProject } from "@/platform/project";+import type { DiffData } from "./diffInput";++/** Project-relative path for labels. */+export function displayPath(path: string, root = useProject.getState().project?.root ?? null): string {+ return root && path.startsWith(root + "/") ? path.slice(root.length + 1) : path;+}++/** Diff of two files on disk; both sides are live, editable documents. */+export function compareFilesData(leftPath: string, rightPath: string): DiffData {+ return {+ path: rightPath,+ left: { type: "file", path: leftPath, label: displayPath(leftPath) },+ right: { type: "worktree", label: displayPath(rightPath) },+ };+}diff --git a/src/features/vcs/fileTree.ts b/src/features/vcs/fileTree.tsindex a31265634..72bd576fb 100644--- a/src/features/vcs/fileTree.ts+++ b/src/features/vcs/fileTree.ts@@ -5,15 +5,22 @@ export interface FileTreeNode<F> {/** Directory label (`src/app`) or file name. */name: string;file: F | null;+ /** An explicit directory entry, including empty directories. */+ directory?: F;children: FileTreeNode<F>[];/** Number of files below (1 for a file). */count: number;}-export function buildFileTree<F>(files: readonly F[], relPath: (f: F) => string): FileTreeNode<F>[] {+export function buildFileTree<F>(+ files: readonly F[],+ relPath: (f: F) => string,+ isDirectory?: (f: F) => boolean,+): FileTreeNode<F>[] {interface Dir {dirs: Map<string, Dir>;files: { name: string; file: F; rel: string }[];+ entry?: F;}const root: Dir = { dirs: new Map(), files: [] };for (const f of files) {@@ -26,7 +33,11 @@ export function buildFileTree<F>(files: readonly F[], relPath: (f: F) => string)if (!next) d.dirs.set(p, (next = { dirs: new Map(), files: [] }));d = next;}- d.files.push({ name, file: f, rel });+ if (isDirectory?.(f)) {+ let sub = d.dirs.get(name);+ if (!sub) d.dirs.set(name, (sub = { dirs: new Map(), files: [] }));+ sub.entry = f;+ } else d.files.push({ name, file: f, rel });}const convert = (d: Dir, prefix: string): FileTreeNode<F>[] => {@@ -35,7 +46,7 @@ export function buildFileTree<F>(files: readonly F[], relPath: (f: F) => string)let label = name;let path = prefix ? `${prefix}/${name}` : name;let cur = sub;- while (cur.files.length === 0 && cur.dirs.size === 1) {+ while (!cur.entry && cur.files.length === 0 && cur.dirs.size === 1) {const [n, only] = [...cur.dirs][0]!;label += `/${n}`;path += `/${n}`;@@ -46,6 +57,7 @@ export function buildFileTree<F>(files: readonly F[], relPath: (f: F) => string)key: `d:${path}`,name: label,file: null,+ directory: cur.entry,children,count: children.reduce((n, c) => n + c.count, 0),});diff --git a/src/features/vcs/operations.tsx b/src/features/vcs/operations.tsxindex e0099acd0..b18a7ae1d 100644--- a/src/features/vcs/operations.tsx+++ b/src/features/vcs/operations.tsx@@ -8,7 +8,7 @@ import { useEffect, useMemo, useState } from "react";import type { ChangedFile, Commit, CompareResult, ResetMode, WorkingTreeChange } from "@/bindings";import { executeAction } from "@/platform/actions";import { call, commands, nextRequestId } from "@/platform/ipc";-import { Checkbox, Dialog, Icon, Input, Tree, Spinner, fileIconName, T } from "@/ui";+import { Checkbox, Dialog, Icon, Input, Spinner, T } from "@/ui";import { notifications } from "@/workbench/contributions";import { diffInput, openDiff, type DiffData, type DiffSide } from "./diffInput";import { openDialog, promptText } from "./dialogs";@@ -17,10 +17,10 @@ import { runGitOperation, runOp } from "./ops";import { reloadLog, useGitLog } from "./logStore";import { conflictedFiles, currentRepo, currentRepoRoot, refreshNow, repoName, repoOf, useVcs } from "./store";import styles from "./common.module.css";-import { DiffEditor } from "./DiffEditor";-import { buildFileTree, dirKeys, type FileTreeNode } from "./fileTree";+import { ComparisonTree } from "./ComparisonTree";+import { buildFileTree, type FileTreeNode } from "./fileTree";import { tx } from "@/platform/i18n";-import { displayPath } from "./compare";+import { displayPath } from "./compareData";// ---------------------------------------------------------------------------// Operation in progress@@ -528,8 +528,6 @@ export function ChangesBetweenDialog({const [files, setFiles] = useState<ComparisonFile[] | null>(null);const [result, setResult] = useState<CompareResult | null>(null);const [error, setError] = useState<string | null>(null);- const [selected, setSelected] = useState<ReadonlySet<string>>(new Set());- const [expanded, setExpanded] = useState<ReadonlySet<string> | null>(null);const [current, setCurrent] = useState<ComparisonFile | null>(null);const fromRev = from.rev;const toRev = to?.rev ?? null;@@ -665,52 +663,25 @@ export function ChangesBetweenDialog({</div>) : null}{files && files.length > 0 ? (- <div className={`${styles.comparison} ${input ? styles.comparisonWithDiff : ""}`}>- <Tree<FileTreeNode<ComparisonFile>>- roots={tree}- getKey={(n) => n.key}- getLabel={(n) => n.name}- getChildren={(n) => (n.file ? undefined : n.children)}- isExpandable={(n) => !n.file}- expanded={expanded ?? new Set(dirKeys(tree))}- onExpandedChange={setExpanded}- selected={selected}- onSelectionChange={(sel, lead) => {- setSelected(sel);- if (lead?.file) setCurrent(lead.file);- }}- onActivate={(n) => n.file && setCurrent(n.file)}- aria-label="Changed files"- className={styles.comparisonTree}- renderNode={(n) => (- <span className={styles.fileRow} style={{ flex: 1, padding: 0 }} title={n.file ? n.file.path : n.name}>- <Icon name={n.file ? fileIconName(n.name) : "folder"} size={14} />- <span- className={styles.fileName}- style={- n.file ? { color: KIND_COLOR[n.file.kind === "untracked" ? "added" : n.file.kind] } : undefined- }- >- {n.name}- </span>- {n.file ? (- <>- <span className={styles.fileDir}>{tx(n.file.kind)}</span>- {n.file.added !== undefined && <span className={styles.compareAdded}>+{n.file.added}</span>}- {n.file.removed !== undefined && <span className={styles.compareRemoved}>−{n.file.removed}</span>}- </>- ) : (- <span className={styles.fileDir}>{n.count}</span>- )}- </span>- )}- />- {input && (- <div className={styles.comparisonDiff}>- <DiffEditor key={input.key} input={input} />- </div>- )}- </div>+ <ComparisonTree+ tree={tree}+ current={current}+ onSelect={setCurrent}+ diffFor={diffFor}+ getColor={(f) => KIND_COLOR[f.kind === "untracked" ? "added" : f.kind]}+ ariaLabel="Changed files"+ renderDetails={(n) =>+ n.file ? (+ <>+ <span className={styles.fileDir}>{tx(n.file.kind)}</span>+ {n.file.added !== undefined && <span className={styles.compareAdded}>+{n.file.added}</span>}+ {n.file.removed !== undefined && <span className={styles.compareRemoved}>−{n.file.removed}</span>}+ </>+ ) : (+ <span className={styles.fileDir}>{n.count}</span>+ )+ }+ />) : null}</Dialog>);diff --git a/src/platform/locales/text/zh.json b/src/platform/locales/text/zh.jsonindex 0f69670d7..a7637c16d 100644--- a/src/platform/locales/text/zh.json+++ b/src/platform/locales/text/zh.json@@ -5382,5 +5382,36 @@"in {length} repositories": "在 {length} 个仓库中","No repository in the selection has revision {label}": "所选内容中的仓库均无版本 {label}","{repoName} has no revision {label}": "{repoName} 没有版本 {label}",- "Waiting for language server…": "正在等待语言服务器…"+ "Waiting for language server…": "正在等待语言服务器…",+ "Compare Directories": "比较目录",+ "Select two directories to compare": "选择两个要比较的目录",+ "Select a directory to compare": "选择要比较的目录",+ "Directory path": "目录路径",+ "Only on left": "仅左侧",+ "Only on right": "仅右侧",+ "Contents differ": "内容不同",+ "Comparing directories": "正在比较目录",+ "Filter by name": "按名称过滤",+ "Show identical files": "显示相同文件",+ "Copy to Left": "复制到左侧",+ "Copy to Right": "复制到右侧",+ "Compared files": "比较的文件",+ "Comparison cancelled": "已取消比较",+ "No matching differences": "没有匹配的差异",+ "Overwrite files?": "覆盖文件?",+ "Copy to {to} and overwrite existing files?": "复制到 {to} 并覆盖已有文件?",+ "Left: {left}": "左侧:{left}",+ "Right: {right}": "右侧:{right}",+ "Compared {compared} of {total} entries": "已比较 {compared} / {total} 个条目",+ "Scanned {scanned} entries": "已扫描 {scanned} 个条目",+ "Binary content": "二进制内容",+ "Binary files cannot be shown as text": "二进制文件无法以文本形式显示",+ "Delete {path}?": "删除 {path}?",+ "copy requires an absolute path": "复制需要绝对路径",+ "missing file name": "缺少文件名",+ "copy requires absolute paths": "复制需要绝对路径",+ "copy paths must belong to the comparison roots": "复制路径必须位于比较的根目录内",+ "cannot copy overlapping paths": "无法在相互包含的路径之间复制",+ "cannot copy through a destination symlink": "无法通过目标目录内的符号链接复制",+ "expected a relative comparison entry path": "需要比较条目的相对路径"}