refactor: simplify VP_HOME matcher, PATH inference, and installer helpers

- implode: normalize source-line args to forward slashes once instead of
  enumerating separator variants per root; drop path_ref_with_backslashes,
  push_path_ref and the env.nu special case; document the matcher's
  multi-install rationale and writer cross-references
- home: share VP_BINARY_NAME from vite_shared (re-exported by vite_setup),
  avoid the per-PATH-entry clone, and drop redundant test guards
- env/setup: reuse render_home_relative_path for the Nu VP_HOME and explain
  why it must stay absolute
- install.sh: reuse abbreviate_path for the shims prompt, simplify
  normalize_existing_dir, use command -v directly
- install.ps1: reuse the USERPROFILE-to-~ display idiom, drop the dead
  .Source fallback and redundant TrimEnd calls

Author: fengmk2

crates/vite_global_cli/src/commands/env/setup.rs

@@ -783,8 +783,10 @@ fn render_env_content(shell: EnvShell, vite_plus_home: &vite_path::AbsolutePath)
             // Nushell requires `~` instead of `$HOME` in string literals — `$HOME` is not
             // expanded at parse time, so PATH entries would contain a literal "$HOME/...".
             let bin_path_ref_nu = bin_path_ref.replace("$HOME/", "~/");
-            let home_path_ref_nu =
-                vite_plus_home.as_path().display().to_string().replace('\\', "/");
+            // `~` is only expanded in Nushell path-literal positions, not general
+            // strings, so a `~/...` VP_HOME would leak literally into the env var;
+            // bake the absolute path instead (`None` skips $HOME-relativization).
+            let home_path_ref_nu = render_home_relative_path(vite_plus_home.as_path(), None);
             ENV_TEMPLATE_NU
                 .replace("__VP_HOME__", &home_path_ref_nu)
                 .replace("__VP_BIN__", &bin_path_ref_nu)
@@ -1206,13 +1208,9 @@ mod tests {
         create_env_files(&home).await.unwrap();
 
         let cmd_content = tokio::fs::read_to_string(bin_dir.join("vp-use.cmd")).await.unwrap();
-        let vp_home_index =
-            cmd_content.find("set VP_HOME=%~dp0..").expect("vp-use.cmd should set VP_HOME");
-        let env_use_index = cmd_content.find("for /f").expect("vp-use.cmd should run env use");
-
         assert!(
-            vp_home_index < env_use_index,
-            "vp-use.cmd should set VP_HOME before invoking vp env use"
+            cmd_content.contains("set VP_HOME=%~dp0..\r\nfor /f"),
+            "vp-use.cmd should set VP_HOME before invoking vp env use, got: {cmd_content}"
         );
         assert!(
             cmd_content.contains("%~dp0..\\current\\bin\\vp.exe env use %*"),

crates/vite_global_cli/src/commands/implode.rs

@@ -106,10 +106,9 @@ fn collect_affected_profiles(
 
         // Read directly — if the file doesn't exist, read_to_string returns Err
         // which .ok().filter() handles gracefully (no redundant exists() check).
-        if let Some(content) = std::fs::read_to_string(&path)
-            .ok()
-            .filter(|c| contains_vite_plus_source_line(c, source_matcher, profile.env_file))
-        {
+        if let Some(content) = std::fs::read_to_string(&path).ok().filter(|c| {
+            c.lines().any(|line| source_matcher.is_vite_plus_source_line(line, profile.env_file))
+        }) {
             if matches!(profile.kind, ShellProfileKind::Snippet) {
                 affected.push(AffectedProfile { name, path, kind: AffectedProfileKind::Snippet });
                 continue;
@@ -273,81 +272,57 @@ fn spawn_deferred_delete(trash_path: &std::path::Path) -> std::io::Result<std::p
         .spawn()
 }
 
+/// Matches shell-profile `source` lines that reference *this* install's env
+/// files, so a second Vite+ install's lines are left untouched.
+///
+/// The recognized home spellings must mirror what the writers emit:
+/// `install.sh`/`install.ps1` (shell PATH setup) and `render_env_content` in
+/// `env/setup.rs`. `env/doctor.rs::check_profile_files` derives the same
+/// variants for its profile scan; keep them in sync.
 struct VitePlusSourceMatcher {
+    /// Home-dir spellings with forward-slash separators: the absolute path,
+    /// plus `$HOME`- and `~`-relative forms when the home is under `$HOME`.
     roots: Vec<Str>,
 }
 
 impl VitePlusSourceMatcher {
     fn new(home_dir: &AbsolutePathBuf, user_home: &AbsolutePathBuf) -> Self {
-        Self { roots: vite_plus_home_refs(home_dir, user_home) }
+        let mut roots = vec![normalize_path_separators(&home_dir.as_path().display().to_string())];
+
+        if let Ok(Some(suffix)) = home_dir.strip_prefix(user_home) {
+            // `RelativePathBuf` guarantees forward-slash separators.
+            let suffix = vite_str::format!("{suffix}");
+            if suffix.is_empty() {
+                roots.push(Str::from("$HOME"));
+                roots.push(Str::from("~"));
+            } else {
+                roots.push(vite_str::format!("$HOME/{suffix}"));
+                roots.push(vite_str::format!("~/{suffix}"));
+            }
+        }
+
+        Self { roots }
     }
 
     fn is_vite_plus_source_line(&self, line: &str, env_file: &str) -> bool {
         let Some(arg) = source_line_arg(line) else {
             return false;
         };
 
-        self.roots.iter().any(|root| {
-            let path = join_path_ref(root, env_file);
-            arg == &*path || (env_file == "env.nu" && arg == &*path_ref_with_backslashes(&path))
-        })
-    }
-}
-
-fn vite_plus_home_refs(home_dir: &AbsolutePathBuf, user_home: &AbsolutePathBuf) -> Vec<Str> {
-    let mut refs = Vec::new();
-    push_path_ref(&mut refs, vite_str::format!("{}", home_dir.as_path().display()));
-    push_path_ref(&mut refs, normalize_path_separators(&home_dir.as_path().display().to_string()));
-
-    if let Ok(Some(suffix)) = home_dir.strip_prefix(user_home) {
-        let suffix = normalize_path_separators(&vite_str::format!("{suffix}"));
-        if suffix.is_empty() {
-            push_path_ref(&mut refs, Str::from("$HOME"));
-            push_path_ref(&mut refs, Str::from("~"));
-        } else {
-            push_path_ref(&mut refs, vite_str::format!("$HOME/{suffix}"));
-            push_path_ref(&mut refs, vite_str::format!("~/{suffix}"));
-        }
-    }
-
-    refs
-}
-
-fn push_path_ref(paths: &mut Vec<Str>, path: Str) {
-    if !paths.iter().any(|existing| existing == &path) {
-        paths.push(path);
+        // Windows profiles may spell the path with backslashes (e.g. Nushell's
+        // `source '~\.vite-plus\env.nu'`); compare in forward-slash form.
+        let arg = normalize_path_separators(arg);
+        self.roots.iter().any(|root| arg == join_path_ref(root, env_file))
     }
 }
 
 fn join_path_ref(root: &str, env_file: &str) -> Str {
-    let separator = if root.ends_with('/') || root.ends_with('\\') { "" } else { "/" };
+    let separator = if root.ends_with('/') { "" } else { "/" };
     vite_str::format!("{root}{separator}{env_file}")
 }
 
-#[expect(clippy::disallowed_types)]
 fn normalize_path_separators(path: &str) -> Str {
-    let mut normalized = String::with_capacity(path.len());
-    for ch in path.chars() {
-        normalized.push(if ch == '\\' { '/' } else { ch });
-    }
-    Str::from(normalized)
-}
-
-#[expect(clippy::disallowed_types)]
-fn path_ref_with_backslashes(path: &str) -> Str {
-    let mut normalized = String::with_capacity(path.len());
-    for ch in path.chars() {
-        normalized.push(if ch == '/' { '\\' } else { ch });
-    }
-    Str::from(normalized)
-}
-
-fn contains_vite_plus_source_line(
-    content: &str,
-    source_matcher: &VitePlusSourceMatcher,
-    env_file: &str,
-) -> bool {
-    content.lines().any(|line| source_matcher.is_vite_plus_source_line(line, env_file))
+    Str::from(path.replace('\\', "/"))
 }
 
 fn source_line_arg(line: &str) -> Option<&str> {
@@ -459,13 +434,6 @@ mod tests {
         VitePlusSourceMatcher::new(&home_dir, &user_home)
     }
 
-    fn source_matcher_for(
-        home_dir: &AbsolutePathBuf,
-        user_home: &AbsolutePathBuf,
-    ) -> VitePlusSourceMatcher {
-        VitePlusSourceMatcher::new(home_dir, user_home)
-    }
-
     #[test]
     fn test_remove_vite_plus_lines_posix() {
         let matcher = default_source_matcher();
@@ -486,7 +454,7 @@ mod tests {
     fn test_remove_vite_plus_lines_absolute_path() {
         let user_home = default_user_home();
         let home_dir = user_home.join(".vite-plus");
-        let matcher = source_matcher_for(&home_dir, &user_home);
+        let matcher = VitePlusSourceMatcher::new(&home_dir, &user_home);
         let env_path = shell_path(&home_dir.join("env"));
         let content = vite_str::format!("# existing\n. \"{env_path}\"\n");
         let result = remove_vite_plus_lines(&content, &matcher, "env");
@@ -497,7 +465,7 @@ mod tests {
     fn test_remove_vite_plus_lines_custom_absolute_path() {
         let user_home = custom_user_home();
         let home_dir = user_home.join("tools").join("vp");
-        let matcher = source_matcher_for(&home_dir, &user_home);
+        let matcher = VitePlusSourceMatcher::new(&home_dir, &user_home);
         let env_path = shell_path(&home_dir.join("env"));
         let content = vite_str::format!("# existing\n. \"{env_path}\"\n");
         let result = remove_vite_plus_lines(&content, &matcher, "env");
@@ -508,7 +476,7 @@ mod tests {
     fn test_remove_vite_plus_lines_custom_home_relative_path() {
         let user_home = custom_user_home();
         let home_dir = user_home.join("tools").join("vp");
-        let matcher = source_matcher_for(&home_dir, &user_home);
+        let matcher = VitePlusSourceMatcher::new(&home_dir, &user_home);
         let content = "# existing\n. \"$HOME/tools/vp/env\"\n";
         let result = remove_vite_plus_lines(content, &matcher, "env");
         assert_eq!(&*result, "# existing\n");
@@ -518,7 +486,7 @@ mod tests {
     fn test_remove_vite_plus_lines_custom_tilde_path() {
         let user_home = custom_user_home();
         let home_dir = user_home.join("tools").join("vp");
-        let matcher = source_matcher_for(&home_dir, &user_home);
+        let matcher = VitePlusSourceMatcher::new(&home_dir, &user_home);
         let content = "# existing\nsource '~/tools/vp/env.nu'\n";
         let result = remove_vite_plus_lines(content, &matcher, "env.nu");
         assert_eq!(&*result, "# existing\n");
@@ -577,7 +545,7 @@ mod tests {
         let temp_dir = tempfile::tempdir().unwrap();
         let temp_path = AbsolutePathBuf::new(temp_dir.path().to_path_buf()).unwrap();
         let home_dir = temp_path.join(".vite-plus");
-        let matcher = source_matcher_for(&home_dir, &temp_path);
+        let matcher = VitePlusSourceMatcher::new(&home_dir, &temp_path);
         let profile_path = temp_path.join(".zshrc");
         let original = "# my config\nexport FOO=bar\n\n# Vite+ bin (https://viteplus.dev)\n. \"$HOME/.vite-plus/env\"\n";
         std::fs::write(&profile_path, original).unwrap();
@@ -647,7 +615,7 @@ mod tests {
         let temp_dir = tempfile::tempdir().unwrap();
         let home = AbsolutePathBuf::new(temp_dir.path().to_path_buf()).unwrap();
         let home_dir = home.join(".vite-plus");
-        let matcher = source_matcher_for(&home_dir, &home);
+        let matcher = VitePlusSourceMatcher::new(&home_dir, &home);
 
         // Clear env overrides so the test environment doesn't affect results
         let _guard = ProfileEnvGuard::new(None, None, None);
@@ -674,7 +642,7 @@ mod tests {
         let temp_dir = tempfile::tempdir().unwrap();
         let home = AbsolutePathBuf::new(temp_dir.path().to_path_buf()).unwrap();
         let home_dir = home.join("tools/vp");
-        let matcher = source_matcher_for(&home_dir, &home);
+        let matcher = VitePlusSourceMatcher::new(&home_dir, &home);
 
         let _guard = ProfileEnvGuard::new(None, None, None);
 
@@ -760,7 +728,7 @@ mod tests {
         std::fs::write(zdotdir.join(".zshenv"), ". \"$HOME/.vite-plus/env\"\n").unwrap();
 
         let _guard = ProfileEnvGuard::new(Some(&zdotdir), None, None);
-        let matcher = source_matcher_for(&home.join(".vite-plus"), &home);
+        let matcher = VitePlusSourceMatcher::new(&home.join(".vite-plus"), &home);
 
         let profiles = collect_affected_profiles(&home, &matcher);
         let zdotdir_profiles: Vec<_> =
@@ -784,7 +752,7 @@ mod tests {
             .unwrap();
 
         let _guard = ProfileEnvGuard::new(None, Some(&xdg_config), None);
-        let matcher = source_matcher_for(&home.join(".vite-plus"), &home);
+        let matcher = VitePlusSourceMatcher::new(&home.join(".vite-plus"), &home);
 
         let profiles = collect_affected_profiles(&home, &matcher);
         let xdg_profiles: Vec<_> =
@@ -807,7 +775,7 @@ mod tests {
         std::fs::write(nushell_dir.join("vite-plus.nu"), "source '~/.vite-plus/env.nu'\n").unwrap();
 
         let _guard = ProfileEnvGuard::new(None, None, Some(&xdg_data));
-        let matcher = source_matcher_for(&home.join(".vite-plus"), &home);
+        let matcher = VitePlusSourceMatcher::new(&home.join(".vite-plus"), &home);
 
         let profiles = collect_affected_profiles(&home, &matcher);
         let xdg_profiles: Vec<_> =

crates/vite_setup/src/lib.rs

@@ -24,5 +24,4 @@ pub mod registry;
 /// Maximum number of old versions to keep.
 pub const MAX_VERSIONS_KEEP: usize = 3;
 
-/// Platform-specific binary name for the `vp` CLI.
-pub const VP_BINARY_NAME: &str = if cfg!(windows) { "vp.exe" } else { "vp" };
+pub use vite_shared::VP_BINARY_NAME;

crates/vite_shared/src/home.rs

@@ -1,4 +1,4 @@
-use std::{env, path::PathBuf};
+use std::env;
 
 use directories::BaseDirs;
 use vite_path::{AbsolutePathBuf, current_dir};
@@ -8,6 +8,9 @@ use crate::EnvConfig;
 /// Default `VP_HOME` directory name
 const VITE_PLUS_HOME_DIR: &str = ".vite-plus";
 
+/// Platform-specific binary name for the `vp` CLI.
+pub const VP_BINARY_NAME: &str = if cfg!(windows) { "vp.exe" } else { "vp" };
+
 /// Get the vite-plus home directory.
 ///
 /// Uses `EnvConfig::get().vite_plus_home` if set,
@@ -50,7 +53,11 @@ fn infer_vp_home_from_path() -> std::io::Result<Option<AbsolutePathBuf>> {
             continue;
         }
 
-        let bin_dir = absolute_path_entry(path_entry)?;
+        let bin_dir = if path_entry.is_absolute() {
+            AbsolutePathBuf::new(path_entry).unwrap()
+        } else {
+            current_dir()?.join(path_entry)
+        };
         if bin_dir.as_path().file_name().is_none_or(|name| name != "bin") {
             continue;
         }
@@ -65,23 +72,9 @@ fn infer_vp_home_from_path() -> std::io::Result<Option<AbsolutePathBuf>> {
     Ok(None)
 }
 
-fn absolute_path_entry(path: PathBuf) -> std::io::Result<AbsolutePathBuf> {
-    if let Some(path) = AbsolutePathBuf::new(path.clone()) {
-        return Ok(path);
-    }
-
-    Ok(current_dir()?.join(path))
-}
-
 fn is_vp_home_layout(bin_dir: &vite_path::AbsolutePath, home: &vite_path::AbsolutePath) -> bool {
-    let vp_bin = if cfg!(windows) { bin_dir.join("vp.exe") } else { bin_dir.join("vp") };
-    let current_vp = if cfg!(windows) {
-        home.join("current").join("bin").join("vp.exe")
-    } else {
-        home.join("current").join("bin").join("vp")
-    };
-
-    vp_bin.as_path().is_file() && current_vp.as_path().is_file()
+    bin_dir.join(VP_BINARY_NAME).as_path().is_file()
+        && home.join("current").join("bin").join(VP_BINARY_NAME).as_path().is_file()
 }
 
 #[cfg(test)]
@@ -102,13 +95,6 @@ mod tests {
             unsafe { std::env::set_var(name, value) };
             guard
         }
-
-        fn remove(name: &'static str) -> Self {
-            let guard = Self { name, original: std::env::var_os(name) };
-            // SAFETY: these serial tests own process environment mutations and restore them on drop.
-            unsafe { std::env::remove_var(name) };
-            guard
-        }
     }
 
     impl Drop for EnvVarGuard {
@@ -172,31 +158,21 @@ mod tests {
     #[test]
     #[serial_test::serial]
     fn test_get_vp_home_without_vp_home_infers_from_vp_on_path() {
-        let temp_dir = PathBuf::from(
-            std::env::temp_dir().join(format!("vp-test-vp-path-{}", std::process::id())),
-        );
+        let temp_dir = std::env::temp_dir().join(format!("vp-test-vp-path-{}", std::process::id()));
         let vite_plus_home = temp_dir.join(".vite-plus");
         let bin_dir = vite_plus_home.join("bin");
         let current_bin_dir = vite_plus_home.join("current").join("bin");
         std::fs::create_dir_all(&bin_dir).unwrap();
         std::fs::create_dir_all(&current_bin_dir).unwrap();
 
-        #[cfg(windows)]
-        let vp_path = bin_dir.join("vp.exe");
-        #[cfg(not(windows))]
-        let vp_path = bin_dir.join("vp");
-        write_executable(&vp_path);
-
-        #[cfg(windows)]
-        let current_vp_path = current_bin_dir.join("vp.exe");
-        #[cfg(not(windows))]
-        let current_vp_path = current_bin_dir.join("vp");
-        write_executable(&current_vp_path);
+        write_executable(&bin_dir.join(VP_BINARY_NAME));
+        write_executable(&current_bin_dir.join(VP_BINARY_NAME));
 
         let path = std::env::join_paths([bin_dir.as_os_str()]).unwrap();
         let _path_guard = EnvVarGuard::set("PATH", path);
-        let _vp_home_guard = EnvVarGuard::remove(crate::env_vars::VP_HOME);
 
+        // `EnvConfig::for_test()` leaves `vite_plus_home` unset, so `get_vp_home`
+        // ignores any real `VP_HOME` env var and exercises the PATH inference.
         EnvConfig::test_scope(EnvConfig::for_test(), || {
             let home = get_vp_home().unwrap();
             assert_eq!(home.as_path(), vite_plus_home.as_path());
@@ -208,23 +184,17 @@ mod tests {
     #[test]
     #[serial_test::serial]
     fn test_get_vp_home_without_vp_home_ignores_relative_bin_without_current_vp() {
-        let temp_dir = PathBuf::from(
-            std::env::temp_dir().join(format!("vp-test-relative-bin-{}", std::process::id())),
-        );
+        let temp_dir =
+            std::env::temp_dir().join(format!("vp-test-relative-bin-{}", std::process::id()));
         let project_dir = temp_dir.join("project");
         let bin_dir = project_dir.join("tools").join("bin");
         std::fs::create_dir_all(&bin_dir).unwrap();
 
-        #[cfg(windows)]
-        let vp_path = bin_dir.join("vp.exe");
-        #[cfg(not(windows))]
-        let vp_path = bin_dir.join("vp");
-        write_executable(&vp_path);
+        write_executable(&bin_dir.join(VP_BINARY_NAME));
 
         let _cwd_guard = CurrentDirGuard::set(&project_dir);
         let path = std::env::join_paths([std::path::Path::new("tools/bin")]).unwrap();
         let _path_guard = EnvVarGuard::set("PATH", path);
-        let _vp_home_guard = EnvVarGuard::remove(crate::env_vars::VP_HOME);
 
         EnvConfig::test_scope(EnvConfig::for_test(), || {
             let home = get_vp_home().unwrap();