feat(completion): implement dynamic shell completion with vp run task support

crates/vite_global_cli/Cargo.toml

@@ -15,7 +15,7 @@ path = "src/main.rs"
 base64-simd = { workspace = true }
 chrono = { workspace = true }
 clap = { workspace = true, features = ["derive"] }
-clap_complete = { workspace = true }
+clap_complete = { workspace = true, features = ["unstable-dynamic"] }
 directories = { workspace = true }
 flate2 = { workspace = true }
 serde = { workspace = true }

crates/vite_global_cli/completion-register.bash

@@ -0,0 +1,64 @@
+_clap_reassemble_words() {
+    if [[ "$COMP_WORDBREAKS" != *:* ]]; then
+        return
+    fi
+    local i j=0 line=$COMP_LINE
+    words=()
+    _CLAP_COMPLETE_INDEX=0
+    for ((i = 0; i < ${#COMP_WORDS[@]}; i++)); do
+        if ((i > 0 && j > 0)) && [[ "${COMP_WORDS[i]}" == :* || "${words[j-1]}" == *: ]] && [[ "$line" != [[:blank:]]* ]]; then
+            words[j-1]="${words[j-1]}${COMP_WORDS[i]}"
+        else
+            words[j]="${COMP_WORDS[i]}"
+            ((j++))
+        fi
+        if ((i == COMP_CWORD)); then
+            _CLAP_COMPLETE_INDEX=$((j - 1))
+        fi
+        line=${line#*"${COMP_WORDS[i]}"}
+    done
+}
+
+_clap_trim_completions() {
+    local cur="${words[_CLAP_COMPLETE_INDEX]}"
+    if [[ "$cur" != *:* || "$COMP_WORDBREAKS" != *:* ]]; then
+        return
+    fi
+    local colon_word=${cur%"${cur##*:}"}
+    local i=${#COMPREPLY[*]}
+    while [[ $((--i)) -ge 0 ]]; do
+        COMPREPLY[$i]=${COMPREPLY[$i]#"$colon_word"}
+    done
+}
+
+_clap_complete_vp() {
+    local IFS=$'\013'
+    local _CLAP_COMPLETE_INDEX=${COMP_CWORD}
+    local _CLAP_COMPLETE_COMP_TYPE=${COMP_TYPE}
+    if compopt +o nospace 2> /dev/null; then
+        local _CLAP_COMPLETE_SPACE=false
+    else
+        local _CLAP_COMPLETE_SPACE=true
+    fi
+    local words=("${COMP_WORDS[@]}")
+    _clap_reassemble_words
+    COMPREPLY=( $( \
+        _CLAP_IFS="$IFS" \
+        _CLAP_COMPLETE_INDEX="$_CLAP_COMPLETE_INDEX" \
+        _CLAP_COMPLETE_COMP_TYPE="$_CLAP_COMPLETE_COMP_TYPE" \
+        _CLAP_COMPLETE_SPACE="$_CLAP_COMPLETE_SPACE" \
+        VP_COMPLETE="bash" \
+        "vp" -- "${words[@]}" \
+    ) )
+    if [[ $? != 0 ]]; then
+        unset COMPREPLY
+    elif [[ $_CLAP_COMPLETE_SPACE == false ]] && [[ "${COMPREPLY-}" =~ [=/:]$ ]]; then
+        compopt -o nospace
+    fi
+    _clap_trim_completions
+}
+if [[ "${BASH_VERSINFO[0]}" -eq 4 && "${BASH_VERSINFO[1]}" -ge 4 || "${BASH_VERSINFO[0]}" -gt 4 ]]; then
+    complete -o nospace -o bashdefault -o nosort -F _clap_complete_vp vp
+else
+    complete -o nospace -o bashdefault -F _clap_complete_vp vp
+fi

crates/vite_global_cli/src/cli.rs

@@ -3,9 +3,11 @@
 //! This module defines the CLI structure using clap and routes commands
 //! to their appropriate handlers.
 
-use std::process::ExitStatus;
+use std::{ffi::OsStr, process::ExitStatus};
 
 use clap::{CommandFactory, FromArgMatches, Parser, Subcommand};
+use clap_complete::ArgValueCompleter;
+use tokio::runtime::Runtime;
 use vite_install::commands::{
     add::SaveDependencyType, install::InstallCommandOptions, outdated::Format,
 };
@@ -615,7 +617,7 @@ pub enum Commands {
     #[command(disable_help_flag = true)]
     Run {
         /// Additional arguments
-        #[arg(trailing_var_arg = true, allow_hyphen_values = true)]
+        #[arg(trailing_var_arg = true, allow_hyphen_values = true, add = ArgValueCompleter::new(run_tasks_completions))]
         args: Vec<String>,
     },
 
@@ -1480,6 +1482,46 @@ fn should_force_global_delegate(command: &str, args: &[String]) -> bool {
     }
 }
 
+/// Get available tasks for shell completion.
+///
+/// Delegates to the local vite-plus CLI to run `vp run` without arguments,
+/// which returns a list of available tasks in the format "task_name: description".
+fn run_tasks_completions(current: &OsStr) -> Vec<clap_complete::CompletionCandidate> {
+    let Some(cwd) = std::env::current_dir()
+        .ok()
+        .and_then(AbsolutePathBuf::new)
+        .filter(|p| commands::has_vite_plus_dependency(p))
+    else {
+        return vec![];
+    };
+
+    // Unescape hashtag and trim quotes for better matching
+    let current = current
+        .to_string_lossy()
+        .replace("\\#", "#")
+        .trim_matches(|c| c == '"' || c == '\'')
+        .to_string();
+
+    let output = tokio::task::block_in_place(|| {
+        Runtime::new().ok().and_then(|rt| {
+            rt.block_on(async { commands::delegate::execute_output(cwd, "run", &[]).await.ok() })
+        })
+    });
+
+    output
+        .filter(|o| o.status.success())
+        .map(|output| {
+            String::from_utf8_lossy(&output.stdout)
+                .lines()
+                .filter_map(|line| line.split_once(": ").map(|(name, _)| name.trim()))
+                .filter(|name| !name.is_empty())
+                .filter(|name| name.starts_with(&current) || current.is_empty())
+                .map(|name| clap_complete::CompletionCandidate::new(name.to_string()))
+                .collect()
+        })
+        .unwrap_or_default()
+}
+
 /// Run the CLI command.
 pub async fn run_command(cwd: AbsolutePathBuf, args: Args) -> Result<ExitStatus, Error> {
     run_command_with_options(cwd, args, RenderOptions::default()).await

crates/vite_global_cli/src/commands/delegate.rs

@@ -1,6 +1,6 @@
 //! JavaScript command delegation — resolves local vite-plus first, falls back to global.
 
-use std::process::ExitStatus;
+use std::process::{ExitStatus, Output};
 
 use vite_path::AbsolutePathBuf;
 
@@ -18,6 +18,18 @@ pub async fn execute(
     executor.delegate_to_local_cli(&cwd, &full_args).await
 }
 
+/// Execute a command by delegating to the local `vite-plus` CLI, capturing output.
+pub async fn execute_output(
+    cwd: AbsolutePathBuf,
+    command: &str,
+    args: &[String],
+) -> Result<Output, Error> {
+    let mut executor = JsExecutor::new(None);
+    let mut full_args = vec![command.to_string()];
+    full_args.extend(args.iter().cloned());
+    executor.delegate_to_local_cli_output(&cwd, &full_args).await
+}
+
 /// Execute a command by delegating to the global `vite-plus` CLI.
 pub async fn execute_global(
     cwd: AbsolutePathBuf,