feat(tasks): monorepo vars and per-task vars

halms · halms · commit 8a44cafd235f · 2026-02-18T23:29:46.000+01:00
diff --git a/docs/tasks/monorepo.md b/docs/tasks/monorepo.md
@@ -175,14 +175,17 @@ mise '//...:test*'
 mise //.../frontend:build
 ```
 
-## Tool and Environment Layering
+## Tool, Environment, and Vars Layering
 
 Subdirectory tasks automatically use tools and environment variables from parent config files in the hierarchy. However, each subdirectory can also define its own tools and environment variables in its config_root. This allows you to:
 
 1. Define common tools and environment at the monorepo root
 2. Override tools or environment in specific subdirectories
 3. Add additional tools or environment in subdirectories
 
+`vars` follow the same hierarchy for task templating, so child config vars are available when
+running subdirectory tasks from the monorepo root.
+
 ### Layering Example
 
 ```toml
diff --git a/docs/tasks/task-configuration.md b/docs/tasks/task-configuration.md
@@ -485,6 +485,14 @@ e2e_args = '--headless'
 run = './scripts/test-e2e.sh {{vars.e2e_args}}'
 ```
 
+Tasks can also define task-local vars that override config vars for that task:
+
+```mise-toml
+[tasks.test]
+vars = { e2e_args = "--headed" }
+run = './scripts/test-e2e.sh {{vars.e2e_args}}'
+```
+
 Like most configuration in mise, vars can be defined across several files. So for example, you could
 put some vars in your global mise config `~/.config/mise/config.toml`, use them in a task at
 `~/src/work/myproject/mise.toml`. You can also override those vars in "later" config files such
@@ -532,6 +540,7 @@ task3 = "echo task3"
 
 [task4]
 run = "echo task4"
+vars = { target = "linux" }
 ```
 
 :::
@@ -616,6 +625,7 @@ passed as environment variables to the scripts. They are defined in the `vars` s
 e2e_args = '--headless'
 [tasks.test]
 run = './scripts/test-e2e.sh {{vars.e2e_args}}'
+vars = { e2e_args = '--headed' }
 ```
 
 Like `[env]`, vars can also be read in as a file:
diff --git a/schema/mise-task.json b/schema/mise-task.json
@@ -550,6 +550,9 @@
         "env": {
           "$ref": "#/$defs/env"
         },
+        "vars": {
+          "$ref": "#/$defs/vars"
+        },
         "tools": {
           "description": "tools to install/activate before running this task",
           "additionalProperties": {
@@ -711,6 +714,55 @@
         }
       },
       "type": "object"
+    },
+    "vars": {
+      "description": "variables to set",
+      "type": "object",
+      "properties": {
+        "_": {
+          "description": "vars modules",
+          "additionalProperties": true,
+          "properties": {
+            "file": {
+              "oneOf": [
+                {
+                  "description": "dotenv file to load",
+                  "type": "string"
+                },
+                {
+                  "description": "dotenv files to load",
+                  "items": {
+                    "description": "dotenv file to load",
+                    "type": "string"
+                  },
+                  "type": "array"
+                }
+              ]
+            },
+            "source": {
+              "oneOf": [
+                {
+                  "description": "bash script to load",
+                  "type": "string"
+                },
+                {
+                  "description": "bash scripts to load",
+                  "items": {
+                    "description": "bash script to load",
+                    "type": "string"
+                  },
+                  "type": "array"
+                }
+              ]
+            }
+          },
+          "type": "object"
+        }
+      },
+      "additionalProperties": {
+        "description": "value of variable",
+        "type": "string"
+      }
     }
   },
   "description": "Config file for included mise tasks (https://mise.jdx.dev/tasks/#task-configuration)",
diff --git a/schema/mise.json b/schema/mise.json
@@ -2037,6 +2037,9 @@
         "env": {
           "$ref": "#/$defs/env"
         },
+        "vars": {
+          "$ref": "#/$defs/vars"
+        },
         "tools": {
           "description": "tools to install/activate before running this task",
           "additionalProperties": {
diff --git a/src/config/mod.rs b/src/config/mod.rs
@@ -112,6 +112,7 @@ impl Config {
                 *GLOBAL_CONFIG_FILES.lock().unwrap() = None;
                 *SYSTEM_CONFIG_FILES.lock().unwrap() = None;
                 GLOB_RESULTS.lock().unwrap().clear();
+                crate::task::reset();
                 Ok(())
             },
             Duration::from_secs(5),
@@ -1519,10 +1520,11 @@ fn load_plugins(config_files: &ConfigMap) -> Result<HashMap<String, String>> {
     Ok(plugins)
 }
 
-async fn load_vars(config: &Arc<Config>) -> Result<EnvResults> {
-    time!("load_vars start");
-    let entries = config
-        .config_files
+pub(crate) async fn resolve_vars_from_config_files(
+    config: &Arc<Config>,
+    config_files: &ConfigMap,
+) -> Result<EnvResults> {
+    let entries = config_files
         .iter()
         .rev()
         .map(|(source, cf)| {
@@ -1533,7 +1535,8 @@ async fn load_vars(config: &Arc<Config>) -> Result<EnvResults> {
         .into_iter()
         .flatten()
         .collect();
-    let vars_results = EnvResults::resolve(
+
+    EnvResults::resolve(
         config,
         config.tera_ctx.clone(),
         &env::PRISTINE_ENV,
@@ -1544,7 +1547,12 @@ async fn load_vars(config: &Arc<Config>) -> Result<EnvResults> {
             warn_on_missing_required: false,
         },
     )
-    .await?;
+    .await
+}
+
+async fn load_vars(config: &Arc<Config>) -> Result<EnvResults> {
+    time!("load_vars start");
+    let vars_results = resolve_vars_from_config_files(config, &config.config_files).await?;
     time!("load_vars done");
     if log::log_enabled!(log::Level::Trace) {
         trace!("{vars_results:#?}");
@@ -2435,4 +2443,26 @@ mod tests {
 
         Ok(())
     }
+
+    #[tokio::test]
+    async fn test_load_task_file_supports_per_task_vars() -> Result<()> {
+        let config = Config::reset().await?;
+        let temp_dir = TempDir::new()?;
+        let tasks_toml = temp_dir.path().join("tasks.toml");
+        fs::write(
+            &tasks_toml,
+            r#"
+[build]
+description = "{{vars.target}}"
+run = "echo build"
+vars = { target = "linux" }
+"#,
+        )?;
+
+        let tasks = load_task_file(&config, &tasks_toml, temp_dir.path()).await?;
+        assert_eq!(tasks.len(), 1);
+        assert_eq!(tasks[0].name, "build");
+        assert_eq!(tasks[0].description, "linux");
+        Ok(())
+    }
 }
diff --git a/src/task/mod.rs b/src/task/mod.rs
@@ -32,6 +32,12 @@ use xx::regex;
 
 static FUZZY_MATCHER: Lazy<SkimMatcherV2> =
     Lazy::new(|| SkimMatcherV2::default().use_cache(true).smart_case());
+static TASK_VARS_CACHE: Lazy<std::sync::Mutex<IndexMap<PathBuf, IndexMap<String, String>>>> =
+    Lazy::new(|| std::sync::Mutex::new(IndexMap::new()));
+
+pub(crate) fn reset() {
+    TASK_VARS_CACHE.lock().unwrap().clear();
+}
 
 /// Type alias for tracking failed tasks with their exit codes
 pub type FailedTasks = Arc<std::sync::Mutex<Vec<(Task, Option<i32>)>>>;
@@ -227,6 +233,8 @@ pub struct Task {
     pub wait_for: Vec<TaskDep>,
     #[serde(default)]
     pub env: EnvList,
+    #[serde(default)]
+    pub vars: EnvList,
     /// Env vars inherited from parent tasks at runtime (not used for task identity/deduplication)
     #[serde(skip)]
     pub inherited_env: EnvList,
@@ -848,10 +856,81 @@ impl Task {
     pub async fn tera_ctx(&self, config: &Arc<Config>) -> Result<tera::Context> {
         let ts = config.get_toolset().await?;
         let mut tera_ctx = ts.tera_ctx(config).await?.clone();
+        let mut vars = self.resolve_base_vars(config).await?;
+        tera_ctx.insert("vars", &vars);
+        vars.extend(self.resolve_task_vars(config, &tera_ctx).await?);
+        tera_ctx.insert("vars", &vars);
         tera_ctx.insert("config_root", &self.config_root);
         Ok(tera_ctx)
     }
 
+    async fn resolve_base_vars(&self, config: &Arc<Config>) -> Result<IndexMap<String, String>> {
+        let Some(task_cf) = self.cf(config) else {
+            return Ok(config.vars.clone());
+        };
+
+        if task_cf.project_root() == config.project_root {
+            return Ok(config.vars.clone());
+        }
+
+        let config_path = task_cf.get_path().to_path_buf();
+        if let Some(vars) = TASK_VARS_CACHE.lock().unwrap().get(&config_path) {
+            return Ok(vars.clone());
+        }
+
+        let task_dir = task_cf.get_path().parent().unwrap_or(task_cf.get_path());
+        let config_paths = crate::config::load_config_hierarchy_from_dir(task_dir)?;
+        let task_config_files = crate::config::load_config_files_from_paths(&config_paths).await?;
+        let vars_results =
+            crate::config::resolve_vars_from_config_files(config, &task_config_files).await?;
+        let vars: IndexMap<String, String> = vars_results
+            .vars
+            .iter()
+            .map(|(k, (v, _))| (k.clone(), v.clone()))
+            .collect();
+        TASK_VARS_CACHE
+            .lock()
+            .unwrap()
+            .insert(config_path, vars.clone());
+        Ok(vars)
+    }
+
+    async fn resolve_task_vars(
+        &self,
+        config: &Arc<Config>,
+        tera_ctx: &tera::Context,
+    ) -> Result<IndexMap<String, String>> {
+        if self.vars.0.is_empty() {
+            return Ok(IndexMap::new());
+        }
+
+        let ts = config.get_toolset().await?;
+        let env_map = ts.full_env(config).await?;
+        let results = EnvResults::resolve(
+            config,
+            tera_ctx.clone(),
+            &env_map,
+            self.vars
+                .0
+                .iter()
+                .cloned()
+                .map(|directive| (directive, self.config_source.clone()))
+                .collect(),
+            EnvResolveOptions {
+                vars: true,
+                tools: ToolsFilter::NonToolsOnly,
+                warn_on_missing_required: false,
+            },
+        )
+        .await?;
+
+        Ok(results
+            .vars
+            .iter()
+            .map(|(k, (v, _))| (k.clone(), v.clone()))
+            .collect())
+    }
+
     pub fn cf<'a>(&'a self, config: &'a Config) -> Option<&'a Arc<dyn ConfigFile>> {
         // For monorepo tasks, use the stored config file reference
         if let Some(ref cf) = self.cf {
@@ -1161,6 +1240,7 @@ impl Default for Task {
             depends_post: vec![],
             wait_for: vec![],
             env: Default::default(),
+            vars: Default::default(),
             inherited_env: Default::default(),
             dir: None,
             hide: false,
diff --git a/src/task/task_template.rs b/src/task/task_template.rs
diff --git a/xtasks/render/schema.ts b/xtasks/render/schema.ts
