fix(plan): preserve command array item boundaries

Normalize task commands to arrays before planning so each command item is parsed independently, and include command_item_index in task cache keys to avoid collisions between array items.

Author: jong-kyung

crates/vite_task_graph/run-config.ts

@@ -20,9 +20,57 @@ export type InputBase = "package" | "workspace";
 
 export type Task = { 
 /**
- * Command string or sequence of command strings to run for the task.
+ * Command string to run for the task.
  */
-command: TaskCommand, 
+command: string, 
+/**
+ * The working directory for the task, relative to the package root (not workspace root).
+ */
+cwd?: string, 
+/**
+ * Dependencies of this task. Use `package-name#task-name` to refer to tasks in other packages.
+ */
+dependsOn?: Array<string>, } & ({ 
+/**
+ * Whether to cache the task
+ */
+cache?: true, 
+/**
+ * Environment variable names to be fingerprinted and passed to the task.
+ */
+env?: Array<string>, 
+/**
+ * Environment variable names to be passed to the task without fingerprinting.
+ */
+untrackedEnv?: Array<string>, 
+/**
+ * Files to include in the cache fingerprint.
+ *
+ * - Omitted: automatically tracks which files the task reads
+ * - `[]` (empty): disables file tracking entirely
+ * - Glob patterns (e.g. `"src/**"`) select specific files, relative to the package directory
+ * - `{pattern: "...", base: "workspace" | "package"}` specifies a glob with an explicit base directory
+ * - `{auto: true}` enables automatic file tracking
+ * - Negative patterns (e.g. `"!dist/**"`) exclude matched files
+ */
+input?: Array<string | GlobWithBase | AutoInput>, 
+/**
+ * Output files to archive after a successful run and restore on cache hit.
+ *
+ * - Omitted or `[]` (empty): no output archiving (default)
+ * - Glob patterns (e.g. `"dist/**"`) select specific output files, relative to the package directory
+ * - `{pattern: "...", base: "workspace" | "package"}` specifies a glob with an explicit base directory
+ * - Negative patterns (e.g. `"!dist/cache/**"`) exclude matched files
+ */
+output?: Array<string | GlobWithBase>, } | { 
+/**
+ * Whether to cache the task
+ */
+cache: false, }) | { 
+/**
+ * Command strings to run for the task.
+ */
+command: Array<string>, 
 /**
  * The working directory for the task, relative to the package root (not workspace root).
  */
@@ -68,9 +116,7 @@ output?: Array<string | GlobWithBase>, } | {
  */
 cache: false, });
 
-export type TaskCommand = string | Array<string>;
-
-export type TaskDefinition = Task | TaskCommand;
+export type TaskDefinition = Task | string | Array<string>;
 
 export type UserGlobalCacheConfig = boolean | { 
 /**

crates/vite_task_graph/src/config/mod.rs

@@ -6,7 +6,7 @@ use monostate::MustBe;
 use rustc_hash::FxHashSet;
 use serde::Serialize;
 pub use user::{
-    AutoInput, EnabledCacheConfig, GlobWithBase, InputBase, ResolvedGlobalCacheConfig, TaskCommand,
+    AutoInput, EnabledCacheConfig, GlobWithBase, InputBase, ResolvedGlobalCacheConfig,
     UserCacheConfig, UserGlobalCacheConfig, UserInputEntry, UserInputsConfig, UserOutputEntry,
     UserRunConfig, UserTaskConfig, UserTaskDefinition,
 };
@@ -31,7 +31,7 @@ pub struct ResolvedTaskConfig {
     /// The command or commands to run for this task.
     ///
     /// Commands may contain environment variables that need to be expanded later.
-    pub command: TaskCommand,
+    pub commands: Arc<[Str]>,
 
     pub resolved_options: ResolvedTaskOptions,
 }
@@ -360,7 +360,7 @@ impl ResolvedTaskConfig {
         workspace_root: &AbsolutePath,
     ) -> Result<Self, ResolveTaskConfigError> {
         Ok(Self {
-            command: TaskCommand::String(package_json_script.into()),
+            commands: vec![package_json_script.into()].into(),
             resolved_options: ResolvedTaskOptions::resolve(
                 UserTaskOptions::default(),
                 package_dir,
@@ -379,13 +379,10 @@ impl ResolvedTaskConfig {
         package_dir: &Arc<AbsolutePath>,
         workspace_root: &AbsolutePath,
     ) -> Result<Self, ResolveTaskConfigError> {
+        let (commands, options) = user_config.into_parts();
         Ok(Self {
-            command: user_config.command,
-            resolved_options: ResolvedTaskOptions::resolve(
-                user_config.options,
-                package_dir,
-                workspace_root,
-            )?,
+            commands,
+            resolved_options: ResolvedTaskOptions::resolve(options, package_dir, workspace_root)?,
         })
     }
 }

crates/vite_task_graph/src/config/user.rs

@@ -4,7 +4,7 @@ use std::sync::Arc;
 
 use monostate::MustBe;
 use rustc_hash::FxHashMap;
-use serde::{Deserialize, Serialize};
+use serde::Deserialize;
 #[cfg(all(test, not(clippy)))]
 use ts_rs::TS;
 use vite_path::RelativePathBuf;
@@ -193,42 +193,46 @@ impl Default for UserTaskOptions {
     }
 }
 
-/// Task command: a command string or a sequence of command strings.
-#[derive(Debug, Deserialize, Serialize, PartialEq, Eq)]
+/// Full user-defined task configuration in `vite.config.*`, including the command and options.
+#[derive(Debug, Deserialize, PartialEq, Eq)]
 // TS derive macro generates code using std types that clippy disallows; skip derive during linting
-#[cfg_attr(all(test, not(clippy)), derive(TS))]
-#[serde(untagged)]
-pub enum TaskCommand {
-    /// A single command string.
-    String(Str),
-    /// Command strings to run in order.
-    Array(Vec<Str>),
-}
+#[cfg_attr(all(test, not(clippy)), derive(TS), ts(optional_fields, rename = "Task"))]
+#[serde(untagged, rename_all = "camelCase")]
+pub enum UserTaskConfig {
+    /// Task object form with a single command string.
+    String {
+        /// Command string to run for the task.
+        command: Str,
+
+        /// Fields other than the command
+        #[serde(flatten)]
+        options: UserTaskOptions,
+    },
+    /// Task object form with a sequence of command strings.
+    Array {
+        /// Command strings to run for the task.
+        command: Arc<[Str]>,
 
-impl From<&str> for TaskCommand {
-    fn from(value: &str) -> Self {
-        Self::String(value.into())
-    }
+        /// Fields other than the command
+        #[serde(flatten)]
+        options: UserTaskOptions,
+    },
 }
 
-impl From<Str> for TaskCommand {
-    fn from(value: Str) -> Self {
-        Self::String(value)
+impl UserTaskConfig {
+    #[must_use]
+    pub const fn options(&self) -> &UserTaskOptions {
+        match self {
+            Self::String { options, .. } | Self::Array { options, .. } => options,
+        }
     }
-}
 
-/// Full user-defined task configuration in `vite.config.*`, including the command and options.
-#[derive(Debug, Deserialize, PartialEq, Eq)]
-// TS derive macro generates code using std types that clippy disallows; skip derive during linting
-#[cfg_attr(all(test, not(clippy)), derive(TS), ts(optional_fields, rename = "Task"))]
-#[serde(rename_all = "camelCase")]
-pub struct UserTaskConfig {
-    /// Command string or sequence of command strings to run for the task.
-    pub command: TaskCommand,
-
-    /// Fields other than the command
-    #[serde(flatten)]
-    pub options: UserTaskOptions,
+    pub fn into_parts(self) -> (Arc<[Str]>, UserTaskOptions) {
+        match self {
+            Self::String { command, options } => (vec![command].into(), options),
+            Self::Array { command, options } => (command, options),
+        }
+    }
 }
 
 /// User-defined task configuration or command-only shorthand in `vite.config.*`.
@@ -240,7 +244,9 @@ pub enum UserTaskDefinition {
     /// Full task object form.
     Config(UserTaskConfig),
     /// Command-only shorthand form using default task options.
-    Command(TaskCommand),
+    CommandString(Str),
+    /// Command sequence shorthand form using default task options.
+    CommandArray(Arc<[Str]>),
 }
 
 /// Root-level cache configuration.
@@ -449,7 +455,10 @@ mod tests {
         let user_config: UserTaskConfig = serde_json::from_value(user_config_json).unwrap();
         assert_eq!(
             user_config,
-            UserTaskConfig { command: "echo hello".into(), options: UserTaskOptions::default() }
+            UserTaskConfig::String {
+                command: "echo hello".into(),
+                options: UserTaskOptions::default()
+            }
         );
     }
 
@@ -459,11 +468,12 @@ mod tests {
             "command": ["echo one", "echo two", "echo three"]
         });
         let user_config: UserTaskConfig = serde_json::from_value(user_config_json).unwrap();
+        let (commands, options) = user_config.into_parts();
         assert_eq!(
-            user_config.command,
-            TaskCommand::Array(vec!["echo one".into(), "echo two".into(), "echo three".into()])
+            commands,
+            Arc::from(["echo one".into(), "echo two".into(), "echo three".into()])
         );
-        assert_eq!(user_config.options, UserTaskOptions::default());
+        assert_eq!(options, UserTaskOptions::default());
     }
 
     #[test]
@@ -475,7 +485,7 @@ mod tests {
         });
         let mut user_config: UserRunConfig = serde_json::from_value(user_config_json).unwrap();
         let task = user_config.tasks.as_mut().unwrap().remove("build").unwrap();
-        assert_eq!(task, UserTaskDefinition::Command(TaskCommand::String("echo build".into())));
+        assert_eq!(task, UserTaskDefinition::CommandString("echo build".into()));
     }
 
     #[test]
@@ -489,7 +499,7 @@ mod tests {
         let task = user_config.tasks.as_mut().unwrap().remove("build").unwrap();
         assert_eq!(
             task,
-            UserTaskDefinition::Command(TaskCommand::Array(vec![
+            UserTaskDefinition::CommandArray(Arc::from([
                 "echo one".into(),
                 "echo two".into(),
                 "echo three".into()
@@ -506,16 +516,11 @@ mod tests {
             "cache": false
         });
         let user_config: UserTaskConfig = serde_json::from_value(user_config_json).unwrap();
-        assert_eq!(
-            user_config.command,
-            TaskCommand::Array(vec!["echo one".into(), "echo two".into()])
-        );
-        assert_eq!(user_config.options.cwd_relative_to_package.as_ref().unwrap().as_str(), "src");
-        assert_eq!(user_config.options.depends_on.as_ref().unwrap().as_ref(), [Str::from("build")]);
-        assert_eq!(
-            user_config.options.cache_config,
-            UserCacheConfig::Disabled { cache: MustBe!(false) }
-        );
+        let (commands, options) = user_config.into_parts();
+        assert_eq!(commands, Arc::from(["echo one".into(), "echo two".into()]));
+        assert_eq!(options.cwd_relative_to_package.as_ref().unwrap().as_str(), "src");
+        assert_eq!(options.depends_on.as_ref().unwrap().as_ref(), [Str::from("build")]);
+        assert_eq!(options.cache_config, UserCacheConfig::Disabled { cache: MustBe!(false) });
     }
 
     #[test]
@@ -543,7 +548,7 @@ mod tests {
             "cwd": "src"
         });
         let user_config: UserTaskConfig = serde_json::from_value(user_config_json).unwrap();
-        assert_eq!(user_config.options.cwd_relative_to_package.as_ref().unwrap().as_str(), "src");
+        assert_eq!(user_config.options().cwd_relative_to_package.as_ref().unwrap().as_str(), "src");
     }
 
     #[test]
@@ -554,7 +559,7 @@ mod tests {
         });
         let user_config: UserTaskConfig = serde_json::from_value(user_config_json).unwrap();
         assert_eq!(
-            user_config.options.cache_config,
+            user_config.options().cache_config,
             UserCacheConfig::Disabled { cache: MustBe!(false) }
         );
     }

crates/vite_task_graph/src/display.rs

@@ -6,7 +6,7 @@ use serde::Serialize;
 use vite_path::AbsolutePath;
 use vite_str::Str;
 
-use crate::{IndexedTaskGraph, TaskNodeIndex, config::TaskCommand};
+use crate::{IndexedTaskGraph, TaskNodeIndex};
 
 /// struct for printing a task in a human-readable way.
 #[derive(Debug, Clone, Serialize)]
@@ -50,19 +50,19 @@ impl IndexedTaskGraph {
                 let node = &self.task_graph()[idx];
                 TaskListEntry {
                     task_display: node.task_display.clone(),
-                    command: format_command_for_task_list(&node.resolved_config.command),
+                    command: format_command_for_task_list(&node.resolved_config.commands),
                 }
             })
             .collect()
     }
 }
 
 // Display-only formatting for task list/selector descriptions. Execution planning keeps
-// `TaskCommand` structured and must not depend on this joined string.
-fn format_command_for_task_list(command: &TaskCommand) -> Str {
-    match command {
-        TaskCommand::String(command) => command.clone(),
-        TaskCommand::Array(commands) => {
+// command arrays structured and must not depend on this joined string.
+fn format_command_for_task_list(commands: &Arc<[Str]>) -> Str {
+    match commands.len() {
+        1 => commands[0].clone(),
+        _ => {
             let mut display = Str::default();
             for (index, command) in commands.iter().enumerate() {
                 if index > 0 {

crates/vite_task_graph/src/lib.rs

@@ -308,11 +308,14 @@ impl IndexedTaskGraph {
 
                 let task_user_config = match task_user_config {
                     UserTaskDefinition::Config(config) => config,
-                    UserTaskDefinition::Command(command) => {
-                        UserTaskConfig { command, options: UserTaskOptions::default() }
+                    UserTaskDefinition::CommandString(command) => {
+                        UserTaskConfig::String { command, options: UserTaskOptions::default() }
+                    }
+                    UserTaskDefinition::CommandArray(command) => {
+                        UserTaskConfig::Array { command, options: UserTaskOptions::default() }
                     }
                 };
-                let dependency_specifiers = task_user_config.options.depends_on.clone();
+                let dependency_specifiers = task_user_config.options().depends_on.clone();
 
                 // Resolve the task configuration from the user config
                 let resolved_config = ResolvedTaskConfig::resolve(

crates/vite_task_plan/src/cache_metadata.rs

@@ -15,7 +15,9 @@ pub enum ExecutionCacheKey {
     UserTask {
         /// The name of the user-defined task.
         task_name: Str,
-        /// The index of the execution item in the task's command split by `&&`.
+        /// The index of the command item in the task's command array.
+        command_item_index: usize,
+        /// The index of the execution item within the command item split by `&&`.
         /// This is to distinguish multiple execution items from the same task.
         and_item_index: usize,
         /// Extra args provided when invoking the user-defined task (`vp [task_name] [extra_args...]`).