feat: interactive task selector for vp run with fuzzy search

When `vp run` is called without a task or with a typo, show an
interactive fuzzy-searchable selector (TTY) or a plain task list (piped).

- Add vite_select crate with crossterm-based interactive widget and
  nucleo-matcher fuzzy search
- Extract RunFlags from RunCommand for flag preservation across selection
- Detect interactive vs non-interactive mode via stdin/stdout is_terminal
- Show 'did you mean' suggestions for typos (including -r/--recursive)
- Add RecursiveTaskNotFound error for recursive queries with no matches
- Only intercept task-not-found at top level (non-empty call stack
  propagates as-is, fixing nested task error hanging)
- Style list items as 'taskName: command' with cyan command color
- E2E tests: list, did-you-mean, interactive select, search, scroll,
  cancel, flag preservation, nested task error propagation

Author: branchseer

Cargo.lock

@@ -85,6 +85,7 @@ memmap2 = "0.9.7"
 monostate = "1.0.2"
 nix = { version = "0.30.1", features = ["dir"] }
 ntapi = "0.4.1"
+nucleo-matcher = "0.3.1"
 once_cell = "1.19"
 os_str_bytes = "7.1.1"
 ouroboros = "0.18.5"
@@ -135,6 +136,7 @@ vec1 = "1.12.1"
 vite_glob = { path = "crates/vite_glob" }
 vite_graph_ser = { path = "crates/vite_graph_ser" }
 vite_path = { path = "crates/vite_path" }
+vite_select = { path = "crates/vite_select" }
 vite_shell = { path = "crates/vite_shell" }
 vite_str = { path = "crates/vite_str" }
 vite_task = { path = "crates/vite_task" }

Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "vite_select"
+version = "0.0.0"
+authors.workspace = true
+edition.workspace = true
+license.workspace = true
+publish = false
+rust-version.workspace = true
+
+[lints]
+workspace = true
+
+[dependencies]
+anyhow = { workspace = true }
+crossterm = { workspace = true }
+nucleo-matcher = { workspace = true }
+vite_str = { path = "../vite_str" }
+
+[dev-dependencies]
+assert2 = { workspace = true }

crates/vite_select/Cargo.toml

@@ -0,0 +1,104 @@
+use nucleo_matcher::{
+    Matcher,
+    pattern::{AtomKind, CaseMatching, Normalization, Pattern},
+};
+
+/// Fuzzy-match `query` against a list of strings.
+///
+/// Returns original indices sorted by score descending (best match first).
+/// When `query` is empty, returns all indices in their original order.
+#[must_use]
+pub fn fuzzy_match(query: &str, items: &[&str]) -> Vec<usize> {
+    if query.is_empty() {
+        return (0..items.len()).collect();
+    }
+
+    let pattern = Pattern::new(query, CaseMatching::Ignore, Normalization::Smart, AtomKind::Fuzzy);
+    let mut matcher = Matcher::new(nucleo_matcher::Config::DEFAULT);
+
+    let mut scored: Vec<(usize, u32)> = items
+        .iter()
+        .enumerate()
+        .filter_map(|(idx, item)| {
+            pattern
+                .score(nucleo_matcher::Utf32Str::Ascii(item.as_bytes()), &mut matcher)
+                .map(|score| (idx, score))
+        })
+        .collect();
+
+    scored.sort_by(|a, b| b.1.cmp(&a.1));
+    scored.into_iter().map(|(idx, _)| idx).collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use assert2::{assert, check};
+
+    use super::*;
+
+    const TASK_NAMES: &[&str] =
+        &["build", "lint", "test", "app#build", "app#lint", "app#test", "lib#build"];
+
+    #[test]
+    fn exact_match_scores_highest() {
+        let results = fuzzy_match("build", TASK_NAMES);
+        assert!(!results.is_empty());
+        // "build" should be the highest-scoring match
+        check!(TASK_NAMES[results[0]] == "build");
+    }
+
+    #[test]
+    fn typo_matches_similar() {
+        let results = fuzzy_match("buid", TASK_NAMES);
+        assert!(!results.is_empty());
+        // Should match "build" and "app#build" and "lib#build" but not "lint" or "test"
+        let matched_names: Vec<&str> = results.iter().map(|&i| TASK_NAMES[i]).collect();
+        check!(matched_names.contains(&"build"));
+        for name in &matched_names {
+            check!(!name.contains("lint"));
+            check!(!name.contains("test"));
+        }
+    }
+
+    #[test]
+    fn empty_query_returns_all() {
+        let results = fuzzy_match("", TASK_NAMES);
+        check!(results.len() == TASK_NAMES.len());
+        // Indices should be in original order
+        for (pos, &idx) in results.iter().enumerate() {
+            check!(idx == pos);
+        }
+    }
+
+    #[test]
+    fn completely_unrelated_query_returns_nothing() {
+        let results = fuzzy_match("zzzzz", TASK_NAMES);
+        check!(results.is_empty());
+    }
+
+    #[test]
+    fn package_qualified_match() {
+        let results = fuzzy_match("app#build", TASK_NAMES);
+        assert!(!results.is_empty());
+        check!(TASK_NAMES[results[0]] == "app#build");
+    }
+
+    #[test]
+    fn lint_matches_lint_tasks() {
+        let results = fuzzy_match("lint", TASK_NAMES);
+        assert!(!results.is_empty());
+        let matched_names: Vec<&str> = results.iter().map(|&i| TASK_NAMES[i]).collect();
+        check!(matched_names.contains(&"lint"));
+        check!(matched_names.contains(&"app#lint"));
+    }
+
+    #[test]
+    fn score_ordering_exact_before_fuzzy() {
+        let results = fuzzy_match("build", TASK_NAMES);
+        assert!(results.len() >= 2);
+        // Exact "build" should appear before "app#build" (higher score = earlier position)
+        let build_pos = results.iter().position(|&i| TASK_NAMES[i] == "build").unwrap();
+        let app_build_pos = results.iter().position(|&i| TASK_NAMES[i] == "app#build").unwrap();
+        check!(build_pos <= app_build_pos);
+    }
+}