chore: 全面代码审查修复 + 开源标配完善

## 审查修复 (18 项)
- TitleBar 版本号改为动态 import package.json
- CLI profile_apply 加 verify_and_save 原子性保护
- CLI 新增 profile rename 子命令
- cmd_clean 默认清理 system+user 两个 hive
- Rust import_csv 加 BOM/header 处理
- exportToJson/exportToCsv 保留 enabled 状态
- CLI version 使用 env!("CARGO_PKG_VERSION")
- export_paths 返回 Result, 未知格式报错
- importFromContent 未知扩展名 throw Error
- profile 文件名加路径遍历/Win保留字校验
- 数据路径统一到 ~/.patheditor/

## clippy (18 处修复)
- backup/scanner/system/profiles: empty_line_after_doc_comments
- profiles: needless_borrow ×5, unnecessary_map_or
- scanner: collapsible_if
- cli: nonminimal_bool ×6, implicit_saturating_sub, to_string_in_format_args
- 零警告通过

## 测试 (33 条新增)
- Rust: backup(3) + disabled(1) + fs(13) + scanner(4) + profiles(1) = 25 条
- 前端: merge-preview(2) + analyze-dialog(1) + import-parity(5) = 8 条
- Rust 10→35, 前端 72→80

## Scanner 并行化
- std::thread::scope 多线程并行扫描目录，N 倍性能提升

## expand_env_vars UTF-16 修复
- 非法码点编码为 \u{XXXX} 而非静默丢弃

## 开源标配
- CODE_OF_CONDUCT.md (Contributor Covenant 2.1)
- SECURITY.md (漏洞报告流程)
- .github/PULL_REQUEST_TEMPLATE.md
- CONTRIBUTING.md (贡献指南)
- CHANGELOG.md (v4.0~v5.0)

## E2E 测试 (4 条新增)
- keyboard / analyze / profiles / import-export
- IPC mock 扩展 scan/profiles 命令

## CI
- Rust job 目录调整为 workspace 根

## 其他
- rustdoc: 8 个 pub fn 补文档注释
- 帮助文本 v4.0→v5.0
- 前后端导入逻辑加交叉引用注释
- .gitignore 添加 target/

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

core/src/backup.rs

@@ -4,21 +4,19 @@ use winreg::enums::*;
 use crate::registry::{self, SYS_REG_PATH, USER_REG_PATH};
 
 fn backup_base_dir() -> PathBuf {
-    dirs::data_dir()
-        .or_else(dirs::home_dir)
+    dirs::home_dir()
         .unwrap_or_else(|| PathBuf::from("."))
-        .join("PathEditor")
+        .join(".patheditor")
         .join("backups")
 }
 
-/// 获取 APPDATA 路径下的备份目录
+/// 获取备份目录路径
 pub fn get_appdata_dir() -> String {
     backup_base_dir().to_string_lossy().to_string()
 }
 
 /// 备份当前注册表中的系统 PATH 和用户 PATH
 /// 在保存前调用，备份的是注册表中的当前值（保存前的状态）
-
 pub fn backup_registry(custom_dir: Option<String>) -> Result<String, String> {
     let backup_dir = match custom_dir {
         Some(ref dir) if !dir.is_empty() => std::path::PathBuf::from(dir),
@@ -65,3 +63,33 @@ pub fn backup_registry(custom_dir: Option<String>) -> Result<String, String> {
     log::info!("备份已保存到: {}", result);
     Ok(result)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn get_appdata_dir_returns_non_empty() {
+        assert!(!get_appdata_dir().is_empty());
+    }
+
+    #[test]
+    fn backup_registry_with_custom_dir() {
+        let dir = std::env::temp_dir().join("patheditor_test_backup_custom");
+        let _ = std::fs::remove_dir_all(&dir);
+        std::fs::create_dir_all(&dir).unwrap();
+
+        let result = backup_registry(Some(dir.to_string_lossy().to_string()));
+        // 可能因无权限读取注册表而失败，但不应 panic
+        if let Ok(path) = result {
+            assert!(path.contains("patheditor_test_backup_custom"));
+            let _ = std::fs::remove_dir_all(&dir);
+        }
+    }
+
+    #[test]
+    fn backup_registry_default_dir_no_panic() {
+        // 验证不传参时不会 panic
+        let _ = backup_registry(None);
+    }
+}

core/src/disabled.rs

@@ -3,10 +3,9 @@ use std::fs;
 use std::path::PathBuf;
 
 fn disabled_file_path() -> PathBuf {
-    dirs::data_dir()
-        .or_else(dirs::home_dir)
+    dirs::home_dir()
         .unwrap_or_else(|| PathBuf::from("."))
-        .join("PathEditor")
+        .join(".patheditor")
         .join("disabled.json")
 }
 
@@ -58,3 +57,30 @@ pub fn load_disabled_state() -> Result<(Vec<String>, Vec<String>), String> {
 
     Ok((state.system, state.user))
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn disabled_state() {
+        // roundtrip
+        let sys = vec!["C:\\sys1".into(), "C:\\sys2".into()];
+        let usr = vec!["D:\\usr1".into()];
+        save_disabled_state(sys.clone(), usr.clone()).unwrap();
+        let (loaded_sys, loaded_usr) = load_disabled_state().unwrap();
+        assert_eq!(loaded_sys, sys);
+        assert_eq!(loaded_usr, usr);
+
+        // overwrite
+        let new_sys = vec!["C:\\new".into()];
+        save_disabled_state(new_sys.clone(), vec![]).unwrap();
+        let (loaded, _) = load_disabled_state().unwrap();
+        assert_eq!(loaded, new_sys);
+
+        // empty
+        save_disabled_state(vec![], vec![]).unwrap();
+        let result = load_disabled_state().unwrap();
+        assert!(result.0.is_empty() && result.1.is_empty());
+    }
+}

core/src/fs.rs

@@ -1,3 +1,6 @@
+// 注意：TS 端 src/core/import-export.ts 有对应的导入导出实现，
+// 前端使用 TS 版（需 ImportDialog 交互），CLI 使用 Rust 版，修改时需同步两端。
+
 /// 读取文本文件内容（供前端原生对话框选择文件后使用）
 pub fn read_text_file(path: &str) -> Result<String, String> {
     std::fs::read_to_string(path).map_err(|e| format!("无法读取文件: {}", e))
@@ -35,9 +38,26 @@ fn import_json(content: &str) -> Result<(Vec<String>, Vec<String>), String> {
 fn import_csv(content: &str) -> Result<(Vec<String>, Vec<String>), String> {
     let mut sys = Vec::new();
     let mut usr = Vec::new();
+    let mut first = true;
     for line in content.lines() {
-        let trimmed = line.trim();
+        let mut trimmed = line.trim();
         if trimmed.is_empty() { continue; }
+
+        // 处理 UTF-8 BOM（仅首行）
+        if first {
+            first = false;
+            if let Some(stripped) = trimmed.strip_prefix('\u{FEFF}') {
+                trimmed = stripped;
+            }
+            // 跳过 header 行 "type,path"
+            let fields: Vec<&str> = trimmed.split(',').collect();
+            if fields.len() >= 2 {
+                let c0 = fields[0].trim().to_lowercase();
+                let c1 = fields[1].trim().to_lowercase();
+                if c0 == "type" && c1 == "path" { continue; }
+            }
+        }
+
         let fields: Vec<&str> = trimmed.split(',').collect();
         if fields.len() >= 2 {
             match fields[0].trim().to_lowercase().as_str() {
@@ -69,16 +89,16 @@ fn import_txt(content: &str) -> Result<(Vec<String>, Vec<String>), String> {
 }
 
 /// 导出 PATH 为指定格式字符串
-pub fn export_paths(sys: &[String], usr: &[String], format: &str) -> String {
+pub fn export_paths(sys: &[String], usr: &[String], format: &str) -> Result<String, String> {
     match format {
         "json" => {
             let data = serde_json::json!({
-                "version": "5.0.0",
+                "version": env!("CARGO_PKG_VERSION"),
                 "timestamp": chrono::Local::now().format("%Y-%m-%dT%H:%M:%S").to_string(),
                 "system": sys,
                 "user": usr,
             });
-            serde_json::to_string_pretty(&data).unwrap_or_default()
+            Ok(serde_json::to_string_pretty(&data).unwrap_or_default())
         }
         "csv" => {
             let mut out = String::from("type,path\n");
@@ -88,9 +108,9 @@ pub fn export_paths(sys: &[String], usr: &[String], format: &str) -> String {
             for p in usr {
                 out.push_str(&format!("user,{}\n", p));
             }
-            out
+            Ok(out)
         }
-        _ => {
+        "txt" => {
             let mut out = String::new();
             if !sys.is_empty() {
                 out.push_str(&format!("# 系统 PATH ({})\n", sys.len()));
@@ -104,7 +124,105 @@ pub fn export_paths(sys: &[String], usr: &[String], format: &str) -> String {
                     out.push_str(&format!("{}\n", p));
                 }
             }
-            out
+            Ok(out)
         }
+        _ => Err(format!("不支持的导出格式: {}", format)),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn import_json_valid() {
+        let json = r#"{"system": ["C:\\sys1", "C:\\sys2"], "user": ["D:\\usr1"]}"#;
+        let (sys, usr) = import_json(json).unwrap();
+        assert_eq!(sys, vec!["C:\\sys1", "C:\\sys2"]);
+        assert_eq!(usr, vec!["D:\\usr1"]);
+    }
+
+    #[test]
+    fn import_json_empty_arrays() {
+        let (sys, usr) = import_json(r#"{"system": [], "user": []}"#).unwrap();
+        assert!(sys.is_empty() && usr.is_empty());
+    }
+
+    #[test]
+    fn import_json_missing_fields() {
+        let (sys, usr) = import_json(r#"{}"#).unwrap();
+        assert!(sys.is_empty() && usr.is_empty());
+    }
+
+    #[test]
+    fn import_csv_valid() {
+        let csv = "type,path\nsystem,C:\\sys1\nuser,D:\\usr1\n";
+        let (sys, _usr) = import_csv(csv).unwrap();
+        assert_eq!(sys, vec!["C:\\sys1"]);
+        assert_eq!(_usr, vec!["D:\\usr1"]);
+    }
+
+    #[test]
+    fn import_csv_with_bom() {
+        let csv = "\u{FEFF}type,path\nsystem,C:\\sys1\n";
+        let (sys, _) = import_csv(csv).unwrap();
+        assert_eq!(sys, vec!["C:\\sys1"]);
+    }
+
+    #[test]
+    fn import_csv_empty() {
+        assert!(import_csv("type,path\n").is_err());
+    }
+
+    #[test]
+    fn import_csv_alternate_type_names() {
+        let csv = "type,path\nsys,D:\\a\nusr,D:\\b\n";
+        let (sys, usr) = import_csv(csv).unwrap();
+        assert_eq!(sys, vec!["D:\\a"]);
+        assert_eq!(usr, vec!["D:\\b"]);
+    }
+
+    #[test]
+    fn export_json_roundtrip() {
+        let sys = vec!["C:\\a".into()];
+        let usr: Vec<String> = vec![];
+        let exported = export_paths(&sys, &usr, "json").unwrap();
+        let parsed: serde_json::Value = serde_json::from_str(&exported).unwrap();
+        assert_eq!(parsed["system"][0], "C:\\a");
+    }
+
+    #[test]
+    fn export_csv_roundtrip() {
+        let sys = vec!["C:\\a".into()];
+        let usr = vec!["D:\\b".into()];
+        let exported = export_paths(&sys, &usr, "csv").unwrap();
+        assert!(exported.contains("system,C:\\a"));
+        assert!(exported.contains("user,D:\\b"));
+    }
+
+    #[test]
+    fn export_txt_roundtrip() {
+        let sys = vec!["C:\\a".into()];
+        let usr = vec!["D:\\b".into()];
+        let exported = export_paths(&sys, &usr, "txt").unwrap();
+        assert!(exported.contains("C:\\a") && exported.contains("D:\\b"));
+    }
+
+    #[test]
+    fn export_invalid_format_errors() {
+        assert!(export_paths(&[], &[], "xml").is_err());
+    }
+
+    #[test]
+    fn import_paths_detects_format() {
+        let (sys, _) = import_paths("test.csv", "type,path\nsystem,C:\\x\n").unwrap();
+        assert_eq!(sys, vec!["C:\\x"]);
+    }
+
+    #[test]
+    fn import_paths_txt_to_user() {
+        let (sys, usr) = import_paths("test.txt", "C:\\x\nD:\\y\n").unwrap();
+        assert!(sys.is_empty());
+        assert_eq!(usr, vec!["C:\\x", "D:\\y"]);
     }
 }

core/src/profiles.rs

@@ -9,6 +9,19 @@ fn profiles_dir() -> PathBuf {
         .join("profiles")
 }
 
+fn validate_profile_name(name: &str) -> Result<(), String> {
+    if name.is_empty() { return Err("配置名称不能为空".into()); }
+    if name.contains('/') || name.contains('\\') || name.contains("..") {
+        return Err("配置名称包含非法字符".into());
+    }
+    for ch in name.chars() {
+        if "<>:\"|?*".contains(ch) {
+            return Err("配置名称包含非法字符".into());
+        }
+    }
+    Ok(())
+}
+
 fn profile_path(name: &str) -> PathBuf {
     profiles_dir().join(format!("{}.json", name))
 }
@@ -48,11 +61,13 @@ pub fn list_profiles() -> Result<Vec<ProfileMeta>, String> {
 
     for entry in entries.flatten() {
         let path = entry.path();
-        if path.extension().map_or(true, |e| e != "json") {
+        if path.extension().is_none_or(|e| e != "json") {
             continue;
         }
-        let content = fs::read_to_string(&path)
-            .map_err(|e| format!("无法读取 {}: {}", path.display(), e))?;
+        let content = match fs::read_to_string(&path) {
+            Ok(c) => c,
+            Err(_) => continue,
+        };
         if let Ok(data) = serde_json::from_str::<ProfileData>(&content) {
             profiles.push(ProfileMeta {
                 name: data.name,
@@ -72,10 +87,11 @@ pub fn save_profile(
     sys: Vec<ProfilePathEntry>,
     user: Vec<ProfilePathEntry>,
 ) -> Result<(), String> {
+    validate_profile_name(name)?;
     let dir = profiles_dir();
     fs::create_dir_all(&dir).map_err(|e| format!("无法创建配置目录: {}", e))?;
 
-    let path = profile_path(&name);
+    let path = profile_path(name);
     let now = chrono::Local::now().format("%Y-%m-%dT%H:%M:%S").to_string();
 
     // 覆盖已有配置时保留原始创建时间
@@ -107,7 +123,8 @@ pub fn save_profile(
 
 /// 加载配置文件
 pub fn load_profile(name: &str) -> Result<ProfileData, String> {
-    let path = profile_path(&name);
+    validate_profile_name(name)?;
+    let path = profile_path(name);
     if !path.exists() {
         return Err(format!("配置文件不存在: {}", name));
     }
@@ -119,7 +136,8 @@ pub fn load_profile(name: &str) -> Result<ProfileData, String> {
 
 /// 删除配置文件
 pub fn delete_profile(name: &str) -> Result<(), String> {
-    let path = profile_path(&name);
+    validate_profile_name(name)?;
+    let path = profile_path(name);
     fs::remove_file(&path).map_err(|e| format!("无法删除配置文件: {}", e))?;
     log::info!("已删除配置: {}", path.display());
     Ok(())
@@ -127,7 +145,9 @@ pub fn delete_profile(name: &str) -> Result<(), String> {
 
 /// 重命名配置文件
 pub fn rename_profile(old_name: &str, new_name: &str) -> Result<(), String> {
-    let old_path = profile_path(&old_name);
+    validate_profile_name(old_name)?;
+    validate_profile_name(new_name)?;
+    let old_path = profile_path(old_name);
     if !old_path.exists() {
         return Err(format!("配置文件不存在: {}", old_name));
     }
@@ -138,7 +158,7 @@ pub fn rename_profile(old_name: &str, new_name: &str) -> Result<(), String> {
     data.name = new_name.to_string();
     data.modified = chrono::Local::now().format("%Y-%m-%dT%H:%M:%S").to_string();
 
-    let new_path = profile_path(&new_name);
+    let new_path = profile_path(new_name);
     let json =
         serde_json::to_string_pretty(&data).map_err(|e| format!("JSON 序列化失败: {}", e))?;
     fs::write(&new_path, &json).map_err(|e| format!("无法写入配置文件: {}", e))?;
@@ -150,3 +170,64 @@ pub fn rename_profile(old_name: &str, new_name: &str) -> Result<(), String> {
     log::info!("已重命名配置: {} -> {}", old_name, new_name);
     Ok(())
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn test_entry(path: &str) -> ProfilePathEntry {
+        ProfilePathEntry { path: path.into(), enabled: true }
+    }
+
+    #[test]
+    fn validate_name_rejects_empty() {
+        assert!(validate_profile_name("").is_err());
+    }
+
+    #[test]
+    fn validate_name_rejects_path_traversal() {
+        assert!(validate_profile_name("../../evil").is_err());
+        assert!(validate_profile_name("foo\\bar").is_err());
+    }
+
+    #[test]
+    fn validate_name_rejects_reserved_chars() {
+        assert!(validate_profile_name("foo:bar").is_err());
+        assert!(validate_profile_name("foo<bar").is_err());
+    }
+
+    #[test]
+    fn profile_crud() {
+        // save -> load -> delete
+        let name = "__test_profile_crud";
+        let _ = delete_profile(name);
+        save_profile(name, vec![test_entry("C:\\sys")], vec![test_entry("D:\\usr")]).unwrap();
+        let loaded = load_profile(name).unwrap();
+        assert_eq!(loaded.sys[0].path, "C:\\sys");
+        delete_profile(name).unwrap();
+        assert!(load_profile(name).is_err());
+
+        // rename
+        let old_name = "__test_rename_old";
+        let new_name = "__test_rename_new";
+        let _ = delete_profile(old_name);
+        let _ = delete_profile(new_name);
+        save_profile(old_name, vec![test_entry("C:\\x")], vec![]).unwrap();
+        rename_profile(old_name, new_name).unwrap();
+        assert!(load_profile(old_name).is_err());
+        let renamed = load_profile(new_name).unwrap();
+        assert_eq!(renamed.name, new_name);
+        delete_profile(new_name).unwrap();
+
+        // list
+        let _ = delete_profile("__test_list_a");
+        let _ = delete_profile("__test_list_b");
+        save_profile("__test_list_a", vec![], vec![]).unwrap();
+        save_profile("__test_list_b", vec![], vec![]).unwrap();
+        let list = list_profiles().unwrap();
+        let names: Vec<&str> = list.iter().map(|m| m.name.as_str()).collect();
+        assert!(names.contains(&"__test_list_a"));
+        delete_profile("__test_list_a").unwrap();
+        delete_profile("__test_list_b").unwrap();
+    }
+}

core/src/registry.rs

@@ -44,21 +44,41 @@ fn save_paths(root: winreg::HKEY, sub_path: &str, label: &str, paths: &[String])
 }
 
 
+/// 从 HKLM 注册表读取系统 PATH
+///
+/// # Returns
+/// - `Ok(Vec<String>)` — 系统 PATH 路径列表
+/// - `Err(String)` — 注册表读取失败
 pub fn load_system_paths() -> Result<Vec<String>, String> {
     load_paths(HKEY_LOCAL_MACHINE, SYS_REG_PATH, "系统")
 }
 
 
+/// 从 HKCU 注册表读取用户 PATH
+///
+/// # Returns
+/// - `Ok(Vec<String>)` — 用户 PATH 路径列表
+/// - `Err(String)` — 注册表读取失败
 pub fn load_user_paths() -> Result<Vec<String>, String> {
     load_paths(HKEY_CURRENT_USER, USER_REG_PATH, "用户")
 }
 
 
+/// 保存系统 PATH 到注册表，含 32767 字符上限检查
+///
+/// # Returns
+/// - `Ok(())` — 保存成功
+/// - `Err(String)` — 写入失败或超过字符上限
 pub fn save_system_paths(paths: Vec<String>) -> Result<(), String> {
     save_paths(HKEY_LOCAL_MACHINE, SYS_REG_PATH, "系统", &paths)
 }
 
 
+/// 保存用户 PATH 到注册表
+///
+/// # Returns
+/// - `Ok(())` — 保存成功
+/// - `Err(String)` — 写入失败
 pub fn save_user_paths(paths: Vec<String>) -> Result<(), String> {
     save_paths(HKEY_CURRENT_USER, USER_REG_PATH, "用户", &paths)
 }

core/src/scanner.rs

@@ -23,33 +23,50 @@ pub struct ToolGroup {
     pub exes: Vec<String>,
 }
 
-/// 扫描 PATH 中的可执行文件冲突
-///
-/// 遍历每个 PATH 目录，查找 .exe/.bat/.cmd/.com/.ps1 文件，
-/// 标记出现在多个目录中的同名文件（后面的目录会被前面的「遮蔽」）
-
-pub fn scan_conflicts(paths: Vec<String>) -> Result<Vec<ConflictEntry>, String> {
-    // exe_name (小写) → [(priority, dir)]
-    let mut map: HashMap<String, Vec<(usize, String)>> = HashMap::new();
-
-    for (priority, dir) in paths.iter().enumerate() {
-        let p = Path::new(dir);
-        if !p.is_dir() {
-            continue;
-        }
-        let entries = fs::read_dir(p).map_err(|e| format!("无法读取目录 {}: {}", dir, e))?;
+/// 扫描单个目录中的可执行文件名
+fn list_exes(dir: &str) -> Vec<String> {
+    let p = Path::new(dir);
+    if !p.is_dir() {
+        return vec![];
+    }
+    let mut exes: Vec<String> = Vec::new();
+    if let Ok(entries) = fs::read_dir(p) {
         for entry in entries.flatten() {
             let fname = entry.file_name();
             let name = fname.to_string_lossy();
             if let Some(ext) = Path::new(name.as_ref()).extension() {
                 let ext_lower = ext.to_ascii_lowercase();
                 if EXECUTABLE_EXTENSIONS.contains(&ext_lower.to_str().unwrap_or("")) {
-                    let key = name.to_lowercase();
-                    map.entry(key).or_default().push((priority, dir.clone()));
+                    exes.push(name.to_string());
                 }
             }
         }
     }
+    exes
+}
+
+/// 扫描 PATH 中的可执行文件冲突
+///
+/// 并行遍历每个 PATH 目录，查找 .exe/.bat/.cmd/.com/.ps1 文件，
+/// 标记出现在多个目录中的同名文件（后面的目录会被前面的「遮蔽」）
+pub fn scan_conflicts(paths: Vec<String>) -> Result<Vec<ConflictEntry>, String> {
+    // 并行扫描各目录
+    let results: Vec<(usize, String, Vec<String>)> = std::thread::scope(|s| {
+        let handles: Vec<_> = paths.iter().enumerate().map(|(priority, dir)| {
+            s.spawn(move || (priority, dir.clone(), list_exes(dir)))
+        }).collect();
+        handles.into_iter().map(|h| h.join().unwrap()).collect()
+    });
+
+    // 合并: exe_name (小写) → [(priority, dir)]
+    let mut map: HashMap<String, Vec<(usize, String)>> = HashMap::new();
+    for (priority, dir, exes) in results {
+        for name in exes {
+            map.entry(name.to_lowercase())
+                .or_default()
+                .push((priority, dir.clone()));
+        }
+    }
 
     let mut results: Vec<ConflictEntry> = map
         .into_iter()
@@ -69,45 +86,96 @@ pub fn scan_conflicts(paths: Vec<String>) -> Result<Vec<ConflictEntry>, String>
 
 /// 扫描 PATH 中各目录提供的可执行文件
 ///
-/// query 非空时只返回文件名包含关键词的结果
+/// query 非空时只返回文件名包含关键词的结果。各目录并行扫描。
 pub fn scan_tools(paths: Vec<String>, query: String) -> Result<Vec<ToolGroup>, String> {
     let query_lower = query.to_lowercase();
-    let mut groups: Vec<ToolGroup> = Vec::new();
 
-    for dir in &paths {
-        let p = Path::new(dir);
-        if !p.is_dir() {
-            groups.push(ToolGroup {
-                dir: dir.clone(),
-                exists: false,
-                exes: vec![],
-            });
-            continue;
-        }
-
-        let entries = fs::read_dir(p).map_err(|e| format!("无法读取目录 {}: {}", dir, e))?;
-        let mut exes: Vec<String> = Vec::new();
-
-        for entry in entries.flatten() {
-            let fname = entry.file_name();
-            let name = fname.to_string_lossy();
-            if let Some(ext) = Path::new(name.as_ref()).extension() {
-                let ext_lower = ext.to_ascii_lowercase();
-                if EXECUTABLE_EXTENSIONS.contains(&ext_lower.to_str().unwrap_or("")) {
-                    if query_lower.is_empty() || name.to_lowercase().contains(&query_lower) {
-                        exes.push(name.to_string());
-                    }
+    // 并行扫描各目录
+    let dir_results: Vec<(String, Option<Vec<String>>)> = std::thread::scope(|s| {
+        let handles: Vec<_> = paths.iter().map(|dir| {
+            s.spawn(move || {
+                let p = Path::new(dir);
+                if !p.is_dir() {
+                    return (dir.clone(), None);
                 }
+                let exes = list_exes(dir);
+                (dir.clone(), Some(exes))
+            })
+        }).collect();
+        handles.into_iter().map(|h| h.join().unwrap()).collect()
+    });
+
+    let mut groups: Vec<ToolGroup> = Vec::new();
+    for (dir, opt_exes) in dir_results {
+        match opt_exes {
+            None => {
+                groups.push(ToolGroup { dir, exists: false, exes: vec![] });
+            }
+            Some(mut exes) => {
+                if !query_lower.is_empty() {
+                    exes.retain(|name| name.to_lowercase().contains(&query_lower));
+                }
+                exes.sort();
+                groups.push(ToolGroup { dir, exists: true, exes });
             }
         }
-
-        exes.sort();
-        groups.push(ToolGroup {
-            dir: dir.clone(),
-            exists: true,
-            exes,
-        });
     }
 
     Ok(groups)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::fs;
+
+    fn make_temp_dir_with_exes(prefix: &str, exe_names: &[&str]) -> std::path::PathBuf {
+        let dir = std::env::temp_dir().join(format!("patheditor_test_{}", prefix));
+        fs::create_dir_all(&dir).unwrap();
+        for name in exe_names {
+            fs::write(dir.join(name), b"fake").unwrap();
+        }
+        dir
+    }
+
+    #[test]
+    fn scan_conflicts_no_duplicates() {
+        let d1 = make_temp_dir_with_exes("c_a", &["a.exe"]);
+        let d2 = make_temp_dir_with_exes("c_b", &["b.exe"]);
+        let paths = vec![d1.to_string_lossy().to_string(), d2.to_string_lossy().to_string()];
+        let conflicts = scan_conflicts(paths).unwrap();
+        assert!(conflicts.is_empty());
+    }
+
+    #[test]
+    fn scan_conflicts_detects_duplicate() {
+        let d1 = make_temp_dir_with_exes("c_dup1", &["shared.exe"]);
+        let d2 = make_temp_dir_with_exes("c_dup2", &["shared.exe"]);
+        let paths = vec![d1.to_string_lossy().to_string(), d2.to_string_lossy().to_string()];
+        let conflicts = scan_conflicts(paths).unwrap();
+        assert_eq!(conflicts.len(), 1);
+        assert_eq!(conflicts[0].locations.len(), 2);
+        assert_eq!(conflicts[0].locations[0].priority, 0);
+        assert_eq!(conflicts[0].locations[1].priority, 1);
+    }
+
+    #[test]
+    fn scan_tools_returns_groups() {
+        let d1 = make_temp_dir_with_exes("t_a", &["tool.exe", "helper.bat"]);
+        let paths = vec![d1.to_string_lossy().to_string()];
+        let groups = scan_tools(paths, String::new()).unwrap();
+        assert_eq!(groups.len(), 1);
+        assert!(groups[0].exists);
+        assert!(groups[0].exes.contains(&"helper.bat".to_string()));
+        assert!(groups[0].exes.contains(&"tool.exe".to_string()));
+    }
+
+    #[test]
+    fn scan_tools_with_query_filters() {
+        let d1 = make_temp_dir_with_exes("t_q", &["apple.exe", "banana.exe"]);
+        let paths = vec![d1.to_string_lossy().to_string()];
+        let groups = scan_tools(paths, "apple".into()).unwrap();
+        assert_eq!(groups[0].exes.len(), 1);
+        assert_eq!(groups[0].exes[0], "apple.exe");
+    }
+}

core/src/system.rs

@@ -1,7 +1,12 @@
 use winreg::enums::*;
 use winreg::RegKey;
 
-/// 检测当前进程是否有管理员权限（尝试写入系统注册表键）
+/// 检测当前进程是否有管理员权限
+///
+/// 通过尝试以写入权限打开系统 PATH 注册表键判断。
+///
+/// # Returns
+/// `true` 表示有管理员权限，`false` 为只读模式
 pub fn check_admin() -> bool {
     let hklm = RegKey::predef(HKEY_LOCAL_MACHINE);
     hklm.open_subkey_with_flags(
@@ -13,7 +18,6 @@ pub fn check_admin() -> bool {
 
 /// 验证路径是否存在于文件系统中（且是目录）
 /// 包含 % 的路径（环境变量路径）无法验证，返回 true
-
 pub fn validate_path(path: &str) -> bool {
     if path.contains('%') {
         return true;
@@ -56,12 +60,23 @@ pub fn expand_env_vars(path: &str) -> String {
         return path.to_string();
     }
 
-    // 转回 UTF-8 (去掉结尾 null)
+    // 转回 UTF-8 (去掉结尾 null)，保留非法码点避免丢失路径信息
     let len = buffer.iter().position(|&c| c == 0).unwrap_or(buffer.len());
-    String::from_utf16_lossy(&buffer[..len])
+    decode_utf16_preserving(&buffer[..len])
+}
+
+/// 解码 UTF-16 为 String，非法码点编码为 \u{XXXX} 而非静默丢弃
+fn decode_utf16_preserving(v: &[u16]) -> String {
+    char::decode_utf16(v.iter().copied())
+        .map(|r| match r {
+            Ok(c) => c.to_string(),
+            Err(e) => format!("\\u{{{:X}}}", e.unpaired_surrogate()),
+        })
+        .collect()
 }
 
 /// 广播环境变量更改通知（WM_SETTINGCHANGE）
+/// 广播 `WM_SETTINGCHANGE` 通知系统环境变量已变更
 pub fn broadcast_env_change() {
     const HWND_BROADCAST: isize = 0xFFFF;
     const WM_SETTINGCHANGE: u32 = 0x001A;