fix(cli): address Codex review round 3

- vpr -C <dir> <task> works on both entry points: the global vpr dispatch
  consumes the flag before delegating to run, and the local bin/vpr shim
  inserts 'run' after the -C tokens
- the workspace root needs a stronger runnable signal than members: a
  shared root vite.config.ts (lint/fmt/tasks) no longer makes the root an
  app target for dev/build/preview; root index.html still does
- pack ranking requires an explicitly declared pack block (get_declared),
  so a spread-only config cannot be auto-selected into a tsdown run;
  FieldMap::contains is gone with its last caller
- add --assetsDir/--assetsInlineLimit/--filter to the required-value flag
  list per vite's CLI docs

Regression fixtures: a shared config at the listing fixture's root and a
spread-only package in pack_default_entry, both pinned by unchanged
snapshots.

Author: fengmk2

crates/vite_cli_snapshots/tests/cli_snapshots/fixtures/app_root_listing/vite.config.ts

@@ -0,0 +1,4 @@
+// Shared workspace config (lint/fmt style): must NOT make the root an app target.
+export default {
+  lint: {},
+};

crates/vite_cli_snapshots/tests/cli_snapshots/fixtures/pack_default_entry/packages/spread-only/package.json

@@ -0,0 +1 @@
+{ "name": "spread-only", "private": true }

crates/vite_cli_snapshots/tests/cli_snapshots/fixtures/pack_default_entry/packages/spread-only/vite.config.ts

@@ -0,0 +1,5 @@
+const base = {};
+
+export default {
+  ...base,
+};

crates/vite_global_cli/src/commands/vpr.rs

@@ -10,11 +10,32 @@ use vite_shared::output;
 ///
 /// Called from shim dispatch when `argv[0]` is `vpr`.
 pub async fn execute_vpr(args: &[String], cwd: &AbsolutePath) -> i32 {
+    // `vpr -C <dir> <task>` mirrors `vp -C <dir> run <task>`: consume the
+    // global flag before treating the rest as run arguments.
+    let mut args = args;
+    let mut cwd_buf = cwd.to_absolute_path_buf();
+    if let Some((dir, consumed)) = crate::parse_leading_chdir(args) {
+        cwd_buf = cwd_buf.join(&dir).clean();
+        if !cwd_buf.as_path().is_dir() {
+            output::raw_stderr(&format!("directory not found: {dir}"));
+            return 1;
+        }
+        if std::env::set_current_dir(cwd_buf.as_path()).is_err() {
+            output::error(&format!("Failed to change directory to {dir}"));
+            return 1;
+        }
+        #[cfg(unix)]
+        // SAFETY: single-threaded startup, before any command logic runs.
+        unsafe {
+            std::env::set_var("PWD", cwd_buf.as_path());
+        }
+        args = &args[consumed..];
+    }
+
     if crate::help::maybe_print_unified_delegate_help("run", args, true) {
         return 0;
     }
 
-    let cwd_buf = cwd.to_absolute_path_buf();
     match super::delegate::execute(cwd_buf, "run", args).await {
         Ok(status) => status.code().unwrap_or(1),
         Err(e) => {

crates/vite_global_cli/src/main.rs

@@ -39,13 +39,14 @@ use crate::cli::{
     try_parse_args_from_with_options,
 };
 
-/// Parse a leading `-C <dir>` / `-C=<dir>` / `-C<dir>` as the first user
-/// argument, mirroring clap's short-option grammar (and bin.ts on the local
-/// path). Returns the directory and how many argv tokens it consumed.
-fn parse_leading_chdir(args: &[String]) -> Option<(String, usize)> {
-    let first = args.get(1)?;
+/// Parse a leading `-C <dir>` / `-C=<dir>` / `-C<dir>` at the start of the
+/// user arguments (argv without the binary name), mirroring clap's
+/// short-option grammar (and bin.ts on the local path). Returns the
+/// directory and how many tokens it consumed.
+pub(crate) fn parse_leading_chdir(user_args: &[String]) -> Option<(String, usize)> {
+    let first = user_args.first()?;
     if first == "-C" {
-        return args.get(2).map(|dir| (dir.clone(), 2));
+        return user_args.get(1).map(|dir| (dir.clone(), 2));
     }
     if let Some(rest) = first.strip_prefix("-C") {
         let dir = rest.strip_prefix('=').unwrap_or(rest);
@@ -329,7 +330,7 @@ async fn main() -> ExitCode {
     // the target directory here too: cwd-sensitive completers (run tasks)
     // should suggest from <dir>, where the completed command will run.
     if env::var_os("VP_COMPLETE").is_some()
-        && let Some((dir, _)) = parse_leading_chdir(&args)
+        && let Some((dir, _)) = parse_leading_chdir(&args[1..])
         && let Ok(current) = vite_path::current_dir()
     {
         let target = current.join(&dir).clean();
@@ -365,7 +366,7 @@ async fn main() -> ExitCode {
     // behave exactly as if vp had been started in <dir>. Setting the process
     // cwd (before any command logic runs) keeps `vite_path::current_dir()`
     // callers deep inside command implementations equivalent to the cd form.
-    if let Some((dir, consumed)) = parse_leading_chdir(&args) {
+    if let Some((dir, consumed)) = parse_leading_chdir(&args[1..]) {
         cwd = cwd.join(&dir).clean();
         if !cwd.as_path().is_dir() {
             output::raw_stderr(&format!("directory not found: {dir}"));
@@ -527,13 +528,13 @@ mod tests {
     fn parse_leading_chdir_accepts_all_clap_short_forms() {
         // `main` consumes these before alias normalization and the picker, so
         // `vp -C dir node --version` normalizes like `cd dir && vp node ...`.
-        assert_eq!(parse_leading_chdir(&s(&["vp", "-C", "apps/web", "dev"])), some_dir(2));
-        assert_eq!(parse_leading_chdir(&s(&["vp", "-Capps/web", "dev"])), some_dir(1));
-        assert_eq!(parse_leading_chdir(&s(&["vp", "-C=apps/web", "dev"])), some_dir(1));
+        assert_eq!(parse_leading_chdir(&s(&["-C", "apps/web", "dev"])), some_dir(2));
+        assert_eq!(parse_leading_chdir(&s(&["-Capps/web", "dev"])), some_dir(1));
+        assert_eq!(parse_leading_chdir(&s(&["-C=apps/web", "dev"])), some_dir(1));
         // Missing or empty value falls through to clap's own error.
-        assert_eq!(parse_leading_chdir(&s(&["vp", "-C"])), None);
-        assert_eq!(parse_leading_chdir(&s(&["vp", "-C="])), None);
-        assert_eq!(parse_leading_chdir(&s(&["vp", "dev"])), None);
+        assert_eq!(parse_leading_chdir(&s(&["-C"])), None);
+        assert_eq!(parse_leading_chdir(&s(&["-C="])), None);
+        assert_eq!(parse_leading_chdir(&s(&["dev"])), None);
     }
 
     fn some_dir(consumed: usize) -> Option<(String, usize)> {

crates/vite_static_config/src/lib.rs

@@ -71,17 +71,6 @@ 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,
-        }
-    }
-
     /// Like [`get`](Self::get), but only for fields the config explicitly
     /// declares. Unlike `get`, an open map (spread, computed keys, or an
     /// unanalyzable config) does NOT report undeclared keys as `NonStatic`:

packages/cli/bin/vpr

@@ -5,5 +5,9 @@ if (module.enableCompileCache) {
   module.enableCompileCache();
 }
 
-process.argv.splice(2, 0, 'run');
+// Insert `run` after a leading global `-C <dir>` so `vpr -C <dir> <task>`
+// behaves like `vp -C <dir> run <task>` (bin.ts consumes -C before dispatch).
+const first = process.argv[2];
+const chdirTokens = first === '-C' ? 2 : first?.startsWith('-C') && first.length > 2 ? 1 : 0;
+process.argv.splice(2 + chdirTokens, 0, 'run');
 await import('../dist/bin.js');

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

@@ -59,6 +59,9 @@ const VALUE_TAKING_FLAGS: &[&str] = &[
     "--port",
     "--base",
     "--outDir",
+    "--assetsDir",
+    "--assetsInlineLimit",
+    "--filter",
     "-d",
     "--out-dir",
     "--target",
@@ -90,17 +93,22 @@ fn is_bare(args: &[String]) -> bool {
 /// Used for ordering and single-candidate auto-selection, never for hiding.
 /// The rules are documented in rfcs/cwd-flag.md ("The likely-runnable
 /// heuristic"); keep both in sync.
-fn looks_runnable(dir: &AbsolutePathBuf, command: &str) -> bool {
+///
+/// The workspace root needs a stronger signal than member packages: a shared
+/// root `vite.config.ts` (lint/fmt/tasks) is the normal monorepo setup and
+/// must not make the root look like an app, or auto-select would run the
+/// silent root build this feature exists to prevent.
+fn looks_runnable(dir: &AbsolutePathBuf, command: &str, is_root: bool) -> 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. `contains` deliberately counts configs
-        // with spreads (`pack` may exist behind them): the right direction
-        // for a never-hide ranking signal.
+        // Bare `vp pack` succeeds when the config explicitly declares a
+        // `pack` block or tsdown's default entry exists. A spread that only
+        // might contain `pack` does not count: auto-select acts on this
+        // signal, so a false positive runs tsdown in a non-packable package.
         "pack" => {
-            vite_static_config::resolve_static_config(dir).contains("pack")
+            vite_static_config::resolve_static_config(dir).get_declared("pack").is_some()
                 || dir.as_path().join("src/index.ts").is_file()
         }
+        _ if is_root => dir.as_path().join("index.html").is_file(),
         _ => vite_static_config::has_config_file(dir) || dir.as_path().join("index.html").is_file(),
     }
 }
@@ -217,8 +225,8 @@ pub(super) fn resolve_app_target(
         .node_weights()
         .filter_map(|info| {
             let absolute = info.absolute_path.to_absolute_path_buf();
-            let runnable = looks_runnable(&absolute, command);
             let is_root = info.path.as_str().is_empty();
+            let runnable = looks_runnable(&absolute, command, is_root);
             // The root itself is a valid target only when it looks runnable;
             // `.` keeps the -C hint and the selection working there.
             if is_root && !runnable {
@@ -284,6 +292,7 @@ mod tests {
         // Known value-taking flags consume their value.
         assert!(is_bare(&to_args(&["--port", "3000"])));
         assert!(is_bare(&to_args(&["--mode", "production", "--minify"])));
+        assert!(is_bare(&to_args(&["--assetsDir", "assets"])));
         assert!(is_bare(&to_args(&["--port=3000"])));
         // A token after an unknown or optional-value flag is ambiguous with a
         // positional target, so it conservatively counts as non-bare.

rfcs/cwd-flag.md

@@ -278,17 +278,17 @@ The global binary also resolves the local `vite-plus` install from `<dir>`, matc
 
 - One row per workspace package: name plus relative path. Nothing is filtered out; likely-runnable packages (rules below) rank first, then by path, so apps surface at the top while everything stays searchable.
 - Fuzzy search over name and path via `vite_select::fuzzy_match`, paging identical to the task picker.
-- A runnable workspace root appears as a `(workspace root)` entry, keeping today's "run at root" behavior one keystroke away.
+- A runnable workspace root appears as a `.` entry, keeping today's "run at root" behavior one keystroke away. The root needs a stronger signal than member packages: an `index.html` for `dev`/`build`/`preview` (a shared root config for lint/fmt/tasks is the normal monorepo setup and does not make the root an app), and the usual explicit-`pack`-or-default-entry rule for `pack`.
 - With exactly one likely-runnable package, the picker auto-selects it, printing only the `Selected package:` line and the tip.
 
 ### The likely-runnable heuristic
 
 Used only for ranking and single-candidate auto-select, never to hide a package: a misjudged package still appears in the picker and listing, just lower. Judged per package directory from file existence and static config extraction; nothing is executed, and parent directories never count.
 
-| Command                     | A package is likely runnable when                                                                                                                                                                          |
-| --------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `dev` / `build` / `preview` | its directory directly contains one of Vite's config file names (`vite.config.{js,mjs,ts,cjs,mts,cts}`, the exact list Vite probes), **or** an `index.html` at the package root (Vite's default app entry) |
-| `pack`                      | its `vite.config.*` declares a `pack` block (read via static extraction; a Vite config without `pack` does not count), **or** `src/index.ts` exists (tsdown's only default entry)                          |
+| Command                     | A package is likely runnable when                                                                                                                                                                                                            |
+| --------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `dev` / `build` / `preview` | its directory directly contains one of Vite's config file names (`vite.config.{js,mjs,ts,cjs,mts,cts}`, the exact list Vite probes), **or** an `index.html` at the package root (Vite's default app entry)                                   |
+| `pack`                      | its `vite.config.*` explicitly declares a `pack` block (read via static extraction; neither a config without `pack` nor one that merely might contain it behind a spread counts), **or** `src/index.ts` exists (tsdown's only default entry) |
 
 Both file-based signals are upstream defaults, not vp inventions: `index.html` at the project root is Vite's entry point ([index.html and Project Root](https://vite.dev/guide/#index-html-and-project-root)), the config file names are the list Vite resolves ([Configuring Vite](https://vite.dev/config/), mirrored by `vite_static_config::CONFIG_FILE_NAMES` with the upstream source link), and `src/index.ts` is tsdown's default entry when none is configured ([tsdown Entry](https://tsdown.dev/options/entry); `src/features/entry.ts` in tsdown resolves exactly this one path).