refactor(cli): apply cleanup review to app-target elicitation

- exempt -v from elicitation: Vite and tsdown are cac-based and use
  -v, --version, so vp build -v now reaches the tool instead of the
  picker; the help/version predicate moves next to the other foreign-flag
  knowledge in help.rs
- add FieldMap::contains for presence checks without cloning the field
  value; use it in the pack-runnable rule
- store PackageRow name/path as Str, deleting the Str->String->Str
  round-trip; flatten the picker branch and the AppTarget dispatch into
  one exhaustive match; inline the one-line should_enable_picker wrapper;
  test and comment tidying

Author: fengmk2

crates/vite_global_cli/src/command_picker.rs

@@ -117,7 +117,7 @@ const COMMANDS: &[CommandEntry] = &[
 pub fn pick_top_level_command_if_interactive(
     cwd: &AbsolutePath,
 ) -> io::Result<TopLevelCommandPick> {
-    if !should_enable_picker() {
+    if !vite_shared::is_interactive_terminal() {
         return Ok(TopLevelCommandPick::Skipped);
     }
 
@@ -129,10 +129,6 @@ pub fn pick_top_level_command_if_interactive(
     })
 }
 
-fn should_enable_picker() -> bool {
-    vite_shared::is_interactive_terminal()
-}
-
 fn run_picker(command_order: &[usize]) -> io::Result<Option<PickedCommand>> {
     let mut stdout = io::stdout();
     let mut selected_position = 0usize;

crates/vite_static_config/src/lib.rs

@@ -69,6 +69,17 @@ impl FieldMap {
             }
         }
     }
+
+    /// Presence check with the same semantics as [`get`](Self::get) returning
+    /// `Some`, without cloning the field's value. In an open map (spread or
+    /// computed keys) every key may exist and therefore counts as present.
+    #[must_use]
+    pub fn contains(&self, key: &str) -> bool {
+        match &self.0 {
+            FieldMapInner::Closed(map) => map.contains_key(key),
+            FieldMapInner::Open(_) => true,
+        }
+    }
 }
 
 /// Config file names to try, in priority order.

packages/cli/binding/src/cli/app_target.rs

@@ -26,8 +26,8 @@ pub(super) enum AppTarget {
 }
 
 struct PackageRow {
-    name: String,
-    path: String,
+    name: vite_str::Str,
+    path: vite_str::Str,
     absolute: AbsolutePathBuf,
     runnable: bool,
 }
@@ -49,9 +49,8 @@ fn app_command_parts(subcommand: &SynthesizableSubcommand) -> Option<(&'static s
 /// disables elicitation; help/version requests are answered by the underlying
 /// tool and must never be redirected.
 fn is_bare(args: &[String]) -> bool {
-    args.iter().all(|arg| {
-        arg.starts_with('-') && !matches!(arg.as_str(), "-h" | "--help" | "-V" | "--version")
-    })
+    args.iter()
+        .all(|arg| arg.starts_with('-') && !super::help::is_app_tool_help_or_version_flag(arg))
 }
 
 /// Heuristic ranking signal: does `dir` look runnable for `command`?
@@ -62,9 +61,11 @@ fn looks_runnable(dir: &AbsolutePathBuf, command: &str) -> bool {
     match command {
         // Bare `vp pack` succeeds when the config declares a `pack` block or
         // tsdown's default entry exists; a Vite config without `pack` does
-        // not make a package packable.
+        // not make a package packable. `contains` deliberately counts configs
+        // with spreads (`pack` may exist behind them): the right direction
+        // for a never-hide ranking signal.
         "pack" => {
-            vite_static_config::resolve_static_config(dir).get("pack").is_some()
+            vite_static_config::resolve_static_config(dir).contains("pack")
                 || dir.as_path().join("src/index.ts").is_file()
         }
         _ => vite_static_config::has_config_file(dir) || dir.as_path().join("index.html").is_file(),
@@ -107,8 +108,8 @@ fn run_package_picker(command: &str, rows: &[PackageRow]) -> Result<Option<usize
         .iter()
         .map(|row| vite_select::SelectItem {
             label: vite_str::format!("{} {}", row.name, row.path),
-            display_name: vite_str::Str::from(row.name.as_str()),
-            description: vite_str::Str::from(row.path.as_str()),
+            display_name: row.name.clone(),
+            description: row.path.clone(),
             group: None,
         })
         .collect();
@@ -181,8 +182,8 @@ pub(super) fn resolve_app_target(
         .map(|info| {
             let absolute = info.absolute_path.to_absolute_path_buf();
             PackageRow {
-                name: info.package_json.name.to_string(),
-                path: info.path.as_str().to_string(),
+                name: info.package_json.name.clone(),
+                path: vite_str::Str::from(info.path.as_str()),
                 runnable: looks_runnable(&absolute, command),
                 absolute,
             }
@@ -198,14 +199,13 @@ pub(super) fn resolve_app_target(
     // otherwise the fuzzy picker runs.
     if vite_shared::is_interactive_terminal() {
         let single_runnable = rows[0].runnable && rows.get(1).is_none_or(|row| !row.runnable);
-        let row = if single_runnable {
-            &rows[0]
-        } else {
-            match run_package_picker(command, &rows)? {
-                Some(index) => &rows[index],
-                None => return Ok(AppTarget::Exit(ExitStatus(130))),
-            }
+        let picked = if single_runnable { Some(0) } else { run_package_picker(command, &rows)? };
+        let Some(index) = picked else {
+            return Ok(AppTarget::Exit(ExitStatus(130)));
         };
+        let row = &rows[index];
+        // Deliberately stdout via println!: these lines belong to the
+        // command's own output stream, like the tool output that follows.
         println!("Selected package: {} ({})", row.name, row.path);
         println!("Tip: run this directly with `vp -C {} {command}`", row.path);
         return Ok(AppTarget::Dir(row.absolute.clone()));
@@ -244,18 +244,19 @@ mod tests {
         assert!(!is_bare(&to_args(&["--help"])));
         assert!(!is_bare(&to_args(&["-h"])));
         assert!(!is_bare(&to_args(&["--watch", "--version"])));
+        // Vite and tsdown are cac-based and use `-v` for version.
+        assert!(!is_bare(&to_args(&["-v"])));
     }
 
     #[test]
     fn only_app_commands_elicit() {
-        let args = vec![];
         for (subcommand, expected) in [
-            (SynthesizableSubcommand::Dev { args: args.clone() }, Some("dev")),
-            (SynthesizableSubcommand::Build { args: args.clone() }, Some("build")),
-            (SynthesizableSubcommand::Preview { args: args.clone() }, Some("preview")),
-            (SynthesizableSubcommand::Pack { args: args.clone() }, Some("pack")),
-            (SynthesizableSubcommand::Lint { args: args.clone() }, None),
-            (SynthesizableSubcommand::Test { args: args.clone() }, None),
+            (SynthesizableSubcommand::Dev { args: vec![] }, Some("dev")),
+            (SynthesizableSubcommand::Build { args: vec![] }, Some("build")),
+            (SynthesizableSubcommand::Preview { args: vec![] }, Some("preview")),
+            (SynthesizableSubcommand::Pack { args: vec![] }, Some("pack")),
+            (SynthesizableSubcommand::Lint { args: vec![] }, None),
+            (SynthesizableSubcommand::Test { args: vec![] }, None),
         ] {
             assert_eq!(app_command_parts(&subcommand).map(|(name, _)| name), expected);
         }

packages/cli/binding/src/cli/help.rs

@@ -36,6 +36,13 @@ fn is_vitest_help_flag(arg: &str) -> bool {
     matches!(arg, "-h" | "--help")
 }
 
+/// Help/version flags of the forwarded app tools (Vite and tsdown are
+/// cac-based: `-v, --version`; vp's own clap surface uses `-V`). Requests for
+/// these must always reach the tool, never target elicitation.
+pub(super) fn is_app_tool_help_or_version_flag(arg: &str) -> bool {
+    matches!(arg, "-h" | "--help" | "-v" | "-V" | "--version")
+}
+
 fn is_vitest_watch_flag(arg: &str) -> bool {
     matches!(arg, "-w" | "--watch")
 }

packages/cli/binding/src/cli/mod.rs

@@ -51,12 +51,10 @@ async fn execute_direct_subcommand(
     // (defaultPackage, package listing); the command then runs as if invoked
     // in the resolved directory (rfcs/cwd-flag.md).
     let target = app_target::resolve_app_target(&subcommand, cwd)?;
-    if let app_target::AppTarget::Exit(status) = target {
-        return Ok(status);
-    }
     let cwd = match &target {
+        app_target::AppTarget::Exit(status) => return Ok(*status),
         app_target::AppTarget::Dir(dir) => dir,
-        _ => cwd,
+        app_target::AppTarget::CurrentDir => cwd,
     };
 
     let (workspace_root, _) = vite_workspace::find_workspace_root(cwd)?;