feat(tasks): add extend mode for task includes

Author: risu729

docs/tasks/file-tasks.md

@@ -4,9 +4,9 @@ In addition to defining tasks through the configuration, they can also be define
 
 - `mise-tasks/:task_name`
 - `.mise-tasks/:task_name`
-- `mise/tasks/:task_name`
 - `.mise/tasks/:task_name`
 - `.config/mise/tasks/:task_name`
+- `mise/tasks/:task_name`
 
 These are the default file-task directories. If [`task_config.includes`](/tasks/task-configuration.html#task-config-includes)
 is set for the current config scope, mise searches only the paths listed there instead.

docs/tasks/task-configuration.md

@@ -641,6 +641,19 @@ For local and monorepo task discovery, mise uses the nearest config file that de
 That means a child config's `includes` replaces both the defaults and any `includes` defined by parent configs for that directory.
 Global config files are loaded independently, so each global config file uses its own `task_config.includes` or the default directories if `includes` is unset.
 
+Set `task_config.includes_mode = "extend"` on the config file whose `task_config.includes` is selected to add `includes` to the defaults and the other config files for the same task scope:
+
+```toml
+[task_config]
+includes = [
+    "mytasks",
+    "tasks.toml",
+]
+includes_mode = "extend"
+```
+
+With `includes_mode = "extend"`, mise keeps the default file-task directories and merges the `task_config.includes` entries from every config file in that task scope. If `includes_mode = "extend"` is only set on a config file whose `includes` are replaced by another config file, it has no effect.
+
 If using included task toml files, note that they have a different format than the `mise.toml` file. They are just a list of tasks.
 The file should be the same format as the `[tasks]` section of `mise.toml` but without the `[task]` prefix:
 

e2e/tasks/test_task_includes_mode_extend

@@ -0,0 +1,72 @@
+#!/usr/bin/env bash
+
+cat <<'TOML' >mise.toml
+[task_config]
+includes = ["tasks.toml", "root-tasks"]
+includes_mode = "extend"
+TOML
+
+cat <<'TOML' >tasks.toml
+[root-file-task]
+run = 'echo "root file task"'
+TOML
+
+mkdir -p root-tasks
+cat <<'SCRIPT' >root-tasks/root-dir-task
+#!/usr/bin/env bash
+echo "root dir task"
+SCRIPT
+chmod +x root-tasks/root-dir-task
+
+mkdir -p .mise/tasks
+cat <<'SCRIPT' >.mise/tasks/default-task
+#!/usr/bin/env bash
+echo "default task"
+SCRIPT
+chmod +x .mise/tasks/default-task
+
+cat <<'TOML' >mise.local.toml
+[task_config]
+includes = ["tasks.local.toml", "local-tasks"]
+TOML
+
+cat <<'TOML' >tasks.local.toml
+[local-file-task]
+run = 'echo "local file task"'
+TOML
+
+mkdir -p local-tasks
+cat <<'SCRIPT' >local-tasks/local-dir-task
+#!/usr/bin/env bash
+echo "local dir task"
+SCRIPT
+chmod +x local-tasks/local-dir-task
+
+assert_contains "mise tasks ls" "default-task"
+assert_contains "mise tasks ls" "root-file-task"
+assert_contains "mise tasks ls" "root-dir-task"
+assert_contains "mise tasks ls" "local-file-task"
+assert_contains "mise tasks ls" "local-dir-task"
+
+cat <<'TOML' >mise.toml
+[task_config]
+includes = ["tasks.toml", "root-tasks"]
+TOML
+
+assert_not_contains "mise tasks ls" "default-task"
+assert_contains "mise tasks ls" "root-file-task"
+assert_contains "mise tasks ls" "root-dir-task"
+assert_not_contains "mise tasks ls" "local-file-task"
+assert_not_contains "mise tasks ls" "local-dir-task"
+
+cat <<'TOML' >mise.local.toml
+[task_config]
+includes = ["tasks.local.toml", "local-tasks"]
+includes_mode = "extend"
+TOML
+
+assert_not_contains "mise tasks ls" "default-task"
+assert_contains "mise tasks ls" "root-file-task"
+assert_contains "mise tasks ls" "root-dir-task"
+assert_not_contains "mise tasks ls" "local-file-task"
+assert_not_contains "mise tasks ls" "local-dir-task"

e2e/tasks/test_task_remote_git_includes

@@ -131,4 +131,31 @@ assert_contains "mise tasks" "ripgrep"
 assert_succeed "mise run local_task"
 assert_succeed "mise run ripgrep"
 
+mise cache clear # Clear cache to force redownload
+
+#################################################################################
+# Test extend mode with local override and parent remote git include
+#################################################################################
+
+cat <<EOF >mise.toml
+[task_config]
+includes = [
+    "git::${LOCAL_GIT_URL}//xtasks/lint"
+]
+includes_mode = "extend"
+EOF
+
+cat <<'EOF' >mise.local.toml
+[task_config]
+includes = [
+    "local-tasks"
+]
+EOF
+
+# Both local and parent remote tasks should be available in extend mode
+assert_contains "mise tasks" "local_task"
+assert_contains "mise tasks" "ripgrep"
+assert_succeed "mise run local_task"
+assert_succeed "mise run ripgrep"
+
 echo "All tests passed!"

src/config/config_file/mise_toml.rs

@@ -940,7 +940,10 @@ impl Debug for MiseToml {
         if !self.plugins.is_empty() {
             d.field("plugins", &self.plugins);
         }
-        if self.task_config.includes.is_some() {
+        if self.task_config.includes.is_some()
+            || self.task_config.includes_mode != Default::default()
+            || self.task_config.dir.is_some()
+        {
             d.field("task_config", &self.task_config);
         }
         d.finish()

src/config/config_file/mod.rs

@@ -607,9 +607,20 @@ impl Hash for dyn ConfigFile {
     }
 }
 
+#[derive(Clone, Copy, Debug, Default, Deserialize, Eq, PartialEq)]
+#[serde(rename_all = "lowercase")]
+pub enum TaskIncludesMode {
+    #[default]
+    Replace,
+    #[serde(alias = "additive")]
+    Extend,
+}
+
 #[derive(Clone, Debug, Default, Deserialize)]
 pub struct TaskConfig {
     pub includes: Option<Vec<String>>,
+    #[serde(default)]
+    pub includes_mode: TaskIncludesMode,
     pub dir: Option<String>,
 }
 

src/config/mod.rs

@@ -20,7 +20,7 @@ use crate::cli::version;
 use crate::config::config_file::idiomatic_version::IdiomaticVersionFile;
 use crate::config::config_file::min_version::MinVersionSpec;
 use crate::config::config_file::mise_toml::{MiseToml, Tasks};
-use crate::config::config_file::{ConfigFile, config_trust_root};
+use crate::config::config_file::{ConfigFile, TaskIncludesMode, config_trust_root};
 use crate::config::env_directive::{EnvResolveOptions, EnvResults, ToolsFilter};
 use crate::config::tracking::Tracker;
 use crate::env::{MISE_DEFAULT_CONFIG_FILENAME, MISE_DEFAULT_TOOL_VERSIONS_FILENAME};
@@ -2333,11 +2333,16 @@ async fn load_file_tasks(
     cf: Arc<dyn ConfigFile>,
     config_root: &Path,
 ) -> Result<Vec<Task>> {
-    let includes = cf
-        .task_config()
-        .includes
-        .clone()
-        .unwrap_or_else(default_task_includes);
+    let includes = match cf.task_config().includes.clone() {
+        Some(includes) if cf.task_config().includes_mode == TaskIncludesMode::Extend => {
+            default_task_includes()
+                .into_iter()
+                .chain(includes)
+                .collect_vec()
+        }
+        Some(includes) => includes,
+        None => default_task_includes(),
+    };
 
     let mut tasks = vec![];
     let config_root = Arc::new(config_root.to_path_buf());
@@ -2363,27 +2368,9 @@ async fn load_file_tasks(
 }
 
 pub fn task_includes_for_dir(dir: &Path, config_files: &ConfigMap) -> Vec<PathBuf> {
-    let configs = configs_at_root(dir, config_files);
-
-    // Find the first config that has explicit task_config.includes
-    // and resolve paths relative to that config file's directory
-    let (includes, resolve_dir) = configs
-        .iter()
-        .rev()
-        .find_map(|cf| {
-            cf.task_config().includes.clone().map(|includes| {
-                // Resolve relative paths from the config root, not the config file's directory
-                (includes, cf.config_root())
-            })
-        })
-        .unwrap_or_else(|| {
-            // Default includes should be resolved relative to the search directory
-            (default_task_includes(), dir.to_path_buf())
-        });
-
-    includes
+    task_include_specs_for_dir(dir, config_files)
         .into_iter()
-        .flat_map(|p| {
+        .flat_map(|(resolve_dir, p)| {
             // Git URLs are handled by load_file_tasks, not here
             if p.starts_with("git::") {
                 return vec![];
@@ -2394,22 +2381,68 @@ pub fn task_includes_for_dir(dir: &Path, config_files: &ConfigMap) -> Vec<PathBu
         .collect::<Vec<_>>()
 }
 
+fn task_include_specs_for_dir(dir: &Path, config_files: &ConfigMap) -> Vec<(PathBuf, String)> {
+    let configs = configs_at_root(dir, config_files);
+
+    match configs
+        .iter()
+        .rev()
+        .find(|cf| cf.task_config().includes.is_some())
+    {
+        Some(cf) if cf.task_config().includes_mode == TaskIncludesMode::Extend => {
+            let mut includes = default_task_includes()
+                .into_iter()
+                .map(|p| (dir.to_path_buf(), p))
+                .collect_vec();
+
+            for cf in configs.iter().rev() {
+                if let Some(cf_includes) = cf.task_config().includes.as_ref() {
+                    let resolve_dir = cf.config_root();
+                    includes.extend(
+                        cf_includes
+                            .iter()
+                            .cloned()
+                            .map(|p| (resolve_dir.clone(), p)),
+                    );
+                }
+            }
+
+            includes
+        }
+        Some(cf) => {
+            let resolve_dir = cf.config_root();
+            cf.task_config()
+                .includes
+                .clone()
+                .unwrap_or_default()
+                .into_iter()
+                .map(|p| (resolve_dir.clone(), p))
+                .collect_vec()
+        }
+        None => default_task_includes()
+            .into_iter()
+            .map(|p| (dir.to_path_buf(), p))
+            .collect_vec(),
+    }
+}
+
+fn task_git_includes_for_dir(dir: &Path, config_files: &ConfigMap) -> Vec<String> {
+    task_include_specs_for_dir(dir, config_files)
+        .into_iter()
+        .map(|(_, p)| p)
+        .filter(|p| p.starts_with("git::"))
+        .unique()
+        .collect()
+}
+
 pub async fn load_tasks_in_dir(
     config: &Arc<Config>,
     dir: &Path,
     config_files: &ConfigMap,
     templates: &IndexMap<String, TaskTemplate>,
 ) -> Result<Vec<Task>> {
     let configs = configs_at_root(dir, config_files);
-
-    let git_includes: Vec<String> = configs
-        .iter()
-        .rev()
-        .find_map(|cf| cf.task_config().includes.clone())
-        .unwrap_or_default()
-        .into_iter()
-        .filter(|p| p.starts_with("git::"))
-        .collect();
+    let git_includes = task_git_includes_for_dir(dir, config_files);
 
     let mut config_tasks = vec![];
     for cf in &configs {