refactor: VeryFastCompile for Task list

* feat: warn when enabling inactive experiments

* feat: TASK_ environment prefix

* feat: calculate experiment enabled/active instead of storing

* refactor: rename GetTaskVar to GetTaskEnv

* feat: experiments tests

.editorconfig

@@ -8,6 +8,6 @@ charset = utf-8
 trim_trailing_whitespace = true
 indent_style = tab
 
-[*.{md,mdx,yml,yaml,json,toml,htm,html,js,css,svg,sh,bash,fish}]
+[*.{md,mdx,yml,yaml,json,toml,htm,html,js,ts,css,svg,sh,bash,fish}]
 indent_style = space
 indent_size = 2

.github/CODE_OF_CONDUCT.md

@@ -34,7 +34,7 @@ This Code of Conduct applies both within project spaces and in public spaces whe
 
 ## Enforcement
 
-Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at andrey@nering.com.br. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at task@taskfile.dev. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
 
 Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.
 

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,20 +0,0 @@
----
-name: Bug Report
-about: Use this to report bugs and issues
----
-
-<!--
-
-Thanks for your bug report!
-
-Before submitting this issue, please make sure the same problem was not
-already reported by someone else.
-
-Please describe the bug you're facing. Consider pasting example Taskfiles
-showing how to reproduce the problem.
-
--->
-
-- Task version:
-- Operating system:
-- Experiments enabled:

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,69 @@
+name: '🐞 Bug Report'
+description: Report a bug in Task.
+labels: ['state: needs-triage']
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thanks for your bug report!
+
+        Before submitting, please check the list of [existing issues](https://github.com/go-task/task/issues) and make sure the same bug was not already reported by someone else.
+
+  - type: textarea
+    id: description
+    attributes:
+      label: Description
+      description: Describe the bug you're seeing.
+      placeholder: |
+        - What did you do?
+        - What did you expect to happen?
+        - What happened instead?
+    validations:
+      required: true
+
+  - type: input
+    id: version
+    attributes:
+      label: Version
+      description: What version(s) of Task is the issue occurring on?
+    validations:
+      required: true
+
+  - type: input
+    id: os
+    attributes:
+      label: Operating system
+      description: What operating system(s) is the issue occurring on?
+    validations:
+      required: true
+
+  - type: dropdown
+    id: experiments
+    attributes:
+      label: Experiments Enabled
+      description: Do you have any experiments enabled? You can check by running `task --experiments`.
+      multiple: true
+      options:
+        - Env Precedence
+        - Gentle Force
+        - Map Variables (1)
+        - Map Variables (2)
+        - Remote Taskfiles
+    validations:
+      required: false
+
+  - type: textarea
+    id: logs
+    attributes:
+      label: Example Taskfile
+      description: |
+        If you have a Taskfile that reproduces the issue, please paste it here.
+        This will be automatically formatted into code, so no need for backticks.
+      render: YAML
+      placeholder: |
+        version: '3'
+
+        tasks:
+          default:
+            cmds:
+              - 'echo "This Taskfile is buggy :("'

.github/ISSUE_TEMPLATE/config.yml

@@ -1,11 +1,11 @@
 blank_issues_enabled: false
 contact_links:
-  - name: Extension for Visual Studio Code
+  - name: '🔌 Task for Visual Studio Code'
     url: https://github.com/go-task/vscode-task
-    about: Issues related to the Visual Studio Code extension should be opened here.
-  - name: Help forum on Discord
-    url: https://discord.gg/6TY36E39UK
-    about: 'The Discord #help channel is the best way to get help from the community.'
-  - name: Questions, Ideas and General Discussions
+    about: 'Issues related to the Visual Studio Code extension should be opened here.'
+  - name: '💬 Help forum on Discord'
+    url: https://discord.com/channels/974121106208354339/1025054680289660989
+    about: 'The #help channel on our Discord is the best way to get help from the community.'
+  - name: '❓ Questions, Ideas and General Discussions'
     url: https://github.com/go-task/task/discussions
-    about: Ask questions and discuss general ideas with the community.
+    about: 'Ask questions and discuss general ideas with the community.'

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,15 +0,0 @@
----
-name: Feature Request
-about: Use this to make feature requests
----
-
-<!--
-
-Describe in detail what feature do you want to see in Task.
-Give examples if possible.
-
-Please, search if this wasn't proposed before, and if this is more like an idea
-than a strong feature request, consider opening a
-[discussion](https://github.com/go-task/task/discussions) instead.
-
--->

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -0,0 +1,23 @@
+name: '✨ Feature Request'
+description: Suggest a new feature or enhancement for Task.
+labels: ['state: needs-triage']
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thanks for your feature request!
+
+        Before submitting, please check the list of [existing issues](https://github.com/go-task/task/issues) and make sure the same change was not already requested by someone else.
+        If your request is more of an idea than a feature request, consider opening a [discussion](https://github.com/go-task/task/discussions) instead.
+
+  - type: textarea
+    id: description
+    attributes:
+      label: Description
+      description: Describe the feature/enhancement you want to see in Task.
+      placeholder: |
+        - Give a general overview of the feature/enhancement.
+        - Explain problem is the change trying to solve.
+        - Give examples of how you would use the feature.
+    validations:
+      required: true

.github/dependabot.yml

@@ -1,24 +0,0 @@
-version: 2
-
-updates:
-  - package-ecosystem: gomod
-    directory: /
-    schedule:
-      interval: weekly
-      day: saturday
-      time: '08:00'
-      timezone: America/Sao_Paulo
-    labels:
-      - "area: dependencies"
-      - "lang: go"
-
-  - package-ecosystem: npm
-    directory: /
-    schedule:
-      interval: weekly
-      day: saturday
-      time: '08:00'
-      timezone: America/Sao_Paulo
-    labels:
-      - "area: dependencies"
-      - "lang: javascript"

.github/renovate.json

@@ -3,46 +3,23 @@
   "extends": [
     "config:recommended",
     "group:allNonMajor",
-    "schedule:monthly"
+    "schedule:weekly",
+    ":semanticCommitTypeAll(chore)"
   ],
   "mode": "full",
-  "reviewers": ["team:developer"],
+  "addLabels":["area: dependencies"],
   "packageRules": [
     {
       "matchManagers": ["github-actions"],
-      "groupName": "Github Action",
-      "labels": ["area: github actions", "area: dependencies"],
-      "matchPackageNames": [
-        "*"
-      ],
-      "matchUpdateTypes": [
-        "minor",
-        "patch"
-      ]
+      "addLabels": ["area: github actions"]
     },
     {
-      "matchManagers": ["npm", "nvm"],
-      "groupName": "Website",
-      "labels": ["lang: javascript", "area: dependencies"],
-      "matchPackageNames": [
-        "*"
-      ],
-      "matchUpdateTypes": [
-        "minor",
-        "patch"
-      ]
+      "matchCategories": ["js", "node"],
+      "addLabels": ["lang: javascript"]
     },
     {
-      "matchManagers": ["gomod"],
-      "groupName": "golang",
-      "labels": ["lang: go", "area: dependencies"],
-      "matchPackageNames": [
-        "*"
-      ],
-      "matchUpdateTypes": [
-        "minor",
-        "patch"
-      ]
+      "matchCategories": ["golang"],
+      "addLabels": ["lang: go"]
     }
   ]
 }

.github/workflows/issue-awaiting-response.yml

@@ -8,7 +8,7 @@ jobs:
   issue-awaiting-response:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/github-script@v6
+      - uses: actions/github-script@v7
         with:
           github-token: ${{secrets.GH_PAT}}
           script: |

.github/workflows/issue-closed.yml

@@ -8,7 +8,7 @@ jobs:
   issue-closed:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/github-script@v6
+      - uses: actions/github-script@v7
         with:
           github-token: ${{secrets.GH_PAT}}
           script: |

.github/workflows/issue-experiment.yml

@@ -9,7 +9,7 @@ jobs:
     if: github.event.label.name == format('experiment{0} proposed', ':')
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/github-script@v6
+      - uses: actions/github-script@v7
         with:
           github-token: ${{secrets.GH_PAT}}
           script: |
@@ -23,7 +23,7 @@ jobs:
     if: github.event.label.name == format('experiment{0} draft', ':')
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/github-script@v6
+      - uses: actions/github-script@v7
         with:
           github-token: ${{secrets.GH_PAT}}
           script: |
@@ -37,7 +37,7 @@ jobs:
     if: github.event.label.name == format('experiment{0} candidate', ':')
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/github-script@v6
+      - uses: actions/github-script@v7
         with:
           github-token: ${{secrets.GH_PAT}}
           script: |
@@ -51,7 +51,7 @@ jobs:
     if: github.event.label.name == format('experiment{0} stable', ':')
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/github-script@v6
+      - uses: actions/github-script@v7
         with:
           github-token: ${{secrets.GH_PAT}}
           script: |
@@ -65,7 +65,7 @@ jobs:
     if: github.event.label.name == format('experiment{0} released', ':')
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/github-script@v6
+      - uses: actions/github-script@v7
         with:
           github-token: ${{secrets.GH_PAT}}
           script: |
@@ -85,7 +85,7 @@ jobs:
     if: github.event.label.name == format('experiment{0} abandoned', ':')
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/github-script@v6
+      - uses: actions/github-script@v7
         with:
           github-token: ${{secrets.GH_PAT}}
           script: |
@@ -105,7 +105,7 @@ jobs:
     if: github.event.label.name == format('experiment{0} superseded', ':')
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/github-script@v6
+      - uses: actions/github-script@v7
         with:
           github-token: ${{secrets.GH_PAT}}
           script: |

.github/workflows/issue-needs-triage.yml

@@ -8,7 +8,7 @@ jobs:
   issue-needs-triage:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/github-script@v6
+      - uses: actions/github-script@v7
         with:
           github-token: ${{secrets.GH_PAT}}
           script: |

.github/workflows/lint.yml

@@ -47,7 +47,7 @@ jobs:
       - uses: actions/checkout@v4
       - name: Get changed files in the docs folder
         id: changed-files-specific
-        uses: tj-actions/changed-files@v44
+        uses: tj-actions/changed-files@v45
         with:
           files: website/versioned_docs/**
 

.github/workflows/release.yml

@@ -18,7 +18,7 @@ jobs:
           go-version: 1.22.x
 
       - name: Run GoReleaser
-        uses: goreleaser/goreleaser-action@v2
+        uses: goreleaser/goreleaser-action@v6
         with:
           version: latest
           args: release --clean

.golangci.yml

@@ -5,11 +5,28 @@
 
 linters:
   enable:
+    - depguard
     - goimports
     - gofmt
     - gofumpt
+    - misspell
+    - noctx
+    - paralleltest
+    - tenv
+    - thelper
+    - tparallel
 
 linters-settings:
+  depguard:
+    rules:
+      main:
+        files:
+          - "$all"
+          - "!$test"
+          - "!**/errors/*.go"
+        deny:
+          - pkg: "errors"
+            desc: "Use github.com/go-task/task/v3/errors instead"
   goimports:
     local-prefixes: github.com/go-task
   gofmt:

.goreleaser.yml

@@ -49,7 +49,7 @@ release:
   draft: true
 
 snapshot:
-  version_template: "{{.Tag}}"
+  version_template: "{{.Version}}"
 
 checksum:
   name_template: "task_checksums.txt"
@@ -57,7 +57,7 @@ checksum:
 nfpms:
   - vendor: Task
     homepage: https://taskfile.dev
-    maintainer: Andrey Nering <andrey@nering.com.br>
+    maintainer: The Task authors <task@taskfile.dev>
     description: Simple task runner written in Go
     license: MIT
     conflicts:

.nvmrc

@@ -1 +1 @@
-18.12.1
+22.13.1

CHANGELOG.md

@@ -1,5 +1,87 @@
 # Changelog
 
+## Unreleased
+
+- Made `--init` less verbose by default and respect `--silent` and `--verbose`
+  flags (#2009, #2011 by @HeCorr).
+- Fix a bug where an HTTP node's location was being mutated incorrectly (#2007
+  by @jeongukjae).
+- Fixed a bug where allowed values didn't work with dynamic var (#2032, #2033 by
+  @vmaerten).
+- Use only the relevant checker (timestamp or checksum) to improve performance
+  (#2029, #2031 by @vmaerten).
+- Print warnings when attempting to enable an inactive experiment or an active
+  experiment with an invalid value (#1979, #2049 by @pd93).
+- Refactored the experiments package and added tests (#2049 by @pd93).
+
+## v3.41.0 - 2025-01-18
+
+- Fixed an issue where dynamic variables were not properly logged in verbose
+  mode (#1920, #1921 by @mgbowman).
+- Support `silent` for defer statements (#1877, #1879 by @danilobuerger).
+- Added an option to exclude some tasks from being included (#1859 by
+  @vmaerten).
+- Fixed an issue where a required variable was incorrectly handled in a template
+  function (#1950, #1962 by @vmaerten).
+- Expose a new `TASK_DIR` special variable, which will contain the absolute path
+  of task directory. (#1959, #1961 by @vmaerten).
+- Fixed fatal bugs that caused concurrent map writes (#1605, #1972, #1974 by
+  @pd93, @GrahamDennis and @trim21).
+- Refactored internal ordered map implementation to use
+  [github.com/elliotchance/orderedmap](https://github.com/elliotchance/orderedmap)
+  (#1797 by @pd93).
+- Fixed a bug where variables defined at the task level were being ignored in
+  the `requires` section. (#1960, #1955, #1768 by @vmaerten and @mokeko)
+- The `CHECKSUM` and `TIMESTAMP` variables are now accessible within `cmds`
+  (#1872 by @niklasr22).
+- Updated [installation docs](https://taskfile.dev/installation) and added pip
+  installation method (#935, #1989 by @pd93).
+- Fixed a bug where dynamic variables could not access environment variables
+  (#630, #1869 by @rohm1 and @pd93).
+- Disable version check for use as an external library (#1938 by @leaanthony).
+
+## v3.40.1 - 2024-12-06
+
+- Fixed a security issue in `git-urls` by switching to the maintained fork
+  `chainguard-dev/git-urls` (#1917 by @AlekSi).
+- Added missing `platforms` property to `cmds` that use `for` (#1915 by
+  @dkarter).
+- Added misspell linter to check for misspelled English words (#1883 by
+  @christiandins).
+
+## v3.40.0 - 2024-11-05
+
+- Fixed output of some functions (e.g. `splitArgs`/`splitLines`) not working in
+  for loops (#1822, #1823 by @stawii).
+- Added a new `TASK_OFFLINE` environment variable to configure the `--offline`
+  flag and expose it as a special variable in the templating system (#1470,
+  #1716 by @vmaerten and @pd93).
+- Fixed a bug where multiple remote includes caused all prompts to display
+  without waiting for user input (#1832, #1833 by @vmaerten and @pd93).
+- When using the
+  "[Remote Taskfiles](https://taskfile.dev/experiments/remote-taskfiles/)".
+  experiment, you can now include Taskfiles from Git repositories (#1652 by
+  @vmaerten).
+- Improved the error message when a dotenv file cannot be parsed (#1842 by
+  @pbitty).
+- Fix issue with directory when using the remote experiment (#1757 by @pbitty).
+- Fixed an issue where a special variable was used in combination with a dotenv
+  file (#1232, #1810 by @vmaerten).
+- Refactor the way Task reads Taskfiles to improve readability (#1771 by
+  @pbitty).
+- Added a new option to ensure variable is within the list of values (#1827 by
+  @vmaerten).
+- Allow multiple prompts to be specified for a task (#1861, #1866 by @mfbmina).
+- Added new template function: `numCPU`, which returns the number of logical
+  CPUs usable (#1890, #1887 by @Amoghrd).
+- Fixed a bug where non-nil, empty dynamic variables are returned as an empty
+  interface (#1903, #1904 by @pd93).
+
+## v3.39.2 - 2024-09-19
+
+- Fix dynamic variables not working properly for a defer: statement (#1803,
+  #1818 by @vmaerten).
+
 ## v3.39.1 - 2024-09-18
 
 - Added Renovate configuration to automatically create PRs to keep dependencies
@@ -259,8 +341,8 @@
 - Added the
   [Remote Taskfiles experiment](https://taskfile.dev/experiments/remote-taskfiles)
   as a draft (#1152, #1317 by @pd93).
-- Improve performance of content checksuming on `sources:` by replacing md5 with
-  [XXH3](https://xxhash.com/) which is much faster. This is a soft breaking
+- Improve performance of content checksumming on `sources:` by replacing md5
+  with [XXH3](https://xxhash.com/) which is much faster. This is a soft breaking
   change because checksums will be invalidated when upgrading to this release
   (#1325 by @ReillyBrogan).
 
@@ -319,7 +401,7 @@
 - Deprecated `version: 2` schema. This will be removed in the next major release
   (#1197, #1198, #1199 by @pd93).
 - Added a new `prompt:` prop to set a warning prompt to be shown before running
-  a potential dangurous task (#100, #1163 by @MaxCheetham,
+  a potential dangerous task (#100, #1163 by @MaxCheetham,
   [Documentation](https://taskfile.dev/usage/#warning-prompts)).
 - Added support for single command task syntax. With this change, it's now
   possible to declare just `cmd:` in a task, avoiding the more complex
@@ -334,7 +416,7 @@
   percentage (#1173 by @misitebao).
 - Starting on this release, official binaries for FreeBSD will be available to
   download (#1068 by @andreynering).
-- Fix some errors being unintendedly supressed (#1134 by @clintmod).
+- Fix some errors being unintendedly suppressed (#1134 by @clintmod).
 - Fix a nil pointer error when `version` is omitted from a Taskfile (#1148,
   #1149 by @pd93).
 - Fix duplicate error message when a task does not exists (#1141, #1144 by
@@ -407,8 +489,8 @@ it a go and let us know what you think via a
 - Fixed a bug where tasks were sometimes incorrectly marked as internal (#1007
   by @pd93).
 - Update to Go 1.20 (bump minimum version to 1.19) (#1010 by @pd93)
-- Added environment variable `FORCE_COLOR` support to force color output.
-  Usefull for environments without TTY (#1003 by @automation-stack)
+- Added environment variable `FORCE_COLOR` support to force color output. Useful
+  for environments without TTY (#1003 by @automation-stack)
 
 ## v3.20.0 - 2023-01-14
 
@@ -763,7 +845,7 @@ it a go and let us know what you think via a
 
 - Fix error code for the `--help` flag (#300, #330).
 - Print version to stdout instead of stderr (#299, #329).
-- Supress `context` errors when using the `--watch` flag (#313, #317).
+- Suppress `context` errors when using the `--watch` flag (#313, #317).
 - Support templating on description (#276, #283).
 
 ## v2.8.0 - 2019-12-07
@@ -772,7 +854,7 @@ it a go and let us know what you think via a
   parallel (#266).
 - Fixed bug where calling the `task` CLI only informing global vars would not
   execute the `default` task.
-- Add hability to silent all tasks by adding `silent: true` a the root of the
+- Add ability to silent all tasks by adding `silent: true` a the root of the
   Taskfile.
 
 ## v2.7.1 - 2019-11-10
@@ -914,7 +996,7 @@ document, since it describes in depth what changed for this version.
 ## v1.4.3 - 2017-09-07
 
 - Allow assigning variables to tasks at run time via CLI (#33)
-- Added suport for multiline variables from sh (#64)
+- Added support for multiline variables from sh (#64)
 - Fixes env: remove square braces and evaluate shell (#62)
 - Watch: change watch library and few fixes and improvements
 - When use watching, cancel and restart long running process on file change (#59
@@ -974,7 +1056,7 @@ document, since it describes in depth what changed for this version.
 - More tests and Travis integration
 - Watch a task (experimental)
 - Possibility to call another task
-- Fix "=" not being reconized in variables/environment variables
+- Fix "=" not being recognized in variables/environment variables
 - Tasks can now have a description, and help will print them (#10)
 - Task dependencies now run concurrently
 - Support for a default task (#16)

README.md

@@ -10,6 +10,18 @@
   </p>
 
   <p>
-    <a href="https://taskfile.dev/installation/">Installation</a> | <a href="https://taskfile.dev/usage/">Documentation</a> | <a href="https://twitter.com/taskfiledev">Twitter</a> | <a href="https://fosstodon.org/@task">Mastodon</a> | <a href="https://discord.gg/6TY36E39UK">Discord</a>
+    <a href="https://taskfile.dev/installation/">Installation</a> | <a href="https://taskfile.dev/usage/">Documentation</a> | <a href="https://twitter.com/taskfiledev">Twitter</a> | <a href="https://bsky.app/profile/taskfile.dev">Bluesky</a> | <a href="https://fosstodon.org/@task">Mastodon</a> | <a href="https://discord.gg/6TY36E39UK">Discord</a>
   </p>
+
+  <h1>Gold Sponsors</h1>
+
+  <table>
+    <tr>
+      <td align="center" valign="middle">
+        <a target="_blank" href="https://devowl.io">
+          <img src="/website/static/img/devowl.io.svg" height="100px" title="devowl.io" />
+        </a>
+      </td>
+    </tr>
+  </table>
 </div>

Taskfile.yml

@@ -98,21 +98,17 @@ tasks:
   test:
     desc: Runs test suite
     aliases: [t]
-    deps: [install]
+    sources:
+      - "**/*.go"
+      - "testdata/**/*"
     cmds:
-      - go test {{catLines .GO_PACKAGES}}
-    vars:
-      GO_PACKAGES:
-        sh: go list ./...
+      - go test ./...
 
   test:all:
     desc: Runs test suite with signals and watch tests included
-    deps: [install, sleepit:build]
+    deps: [sleepit:build]
     cmds:
-      - go test {{catLines .GO_PACKAGES}} -tags 'signals watch'
-    vars:
-      GO_PACKAGES:
-        sh: go list ./...
+      - go test -tags 'signals watch' ./...
 
   goreleaser:test:
     desc: Tests release process without publishing
@@ -122,7 +118,7 @@ tasks:
   goreleaser:install:
     desc: Installs goreleaser
     cmds:
-      - go install github.com/goreleaser/goreleaser@latest
+      - go install github.com/goreleaser/goreleaser/v2@latest
 
   release:*:
     desc: Prepare the project for a new release
@@ -176,11 +172,3 @@ tasks:
     desc: Publish release to npm
     cmds:
       - npm publish --access=public
-
-  packages:
-    cmds:
-      - echo '{{.GO_PACKAGES}}'
-    vars:
-      GO_PACKAGES:
-        sh: go list ./...
-    silent: true

args/args.go

@@ -9,7 +9,7 @@ import (
 // Parse parses command line argument: tasks and global variables
 func Parse(args ...string) ([]*ast.Call, *ast.Vars) {
 	calls := []*ast.Call{}
-	globals := &ast.Vars{}
+	globals := ast.NewVars()
 
 	for _, arg := range args {
 		if !strings.Contains(arg, "=") {

args/args_test.go

@@ -7,11 +7,12 @@ import (
 	"github.com/stretchr/testify/assert"
 
 	"github.com/go-task/task/v3/args"
-	"github.com/go-task/task/v3/internal/omap"
 	"github.com/go-task/task/v3/taskfile/ast"
 )
 
 func TestArgs(t *testing.T) {
+	t.Parallel()
+
 	tests := []struct {
 		Args            []string
 		ExpectedCalls   []*ast.Call
@@ -32,30 +33,40 @@ func TestArgs(t *testing.T) {
 				{Task: "task-b"},
 				{Task: "task-c"},
 			},
-			ExpectedGlobals: &ast.Vars{
-				OrderedMap: omap.FromMapWithOrder(
-					map[string]ast.Var{
-						"FOO": {Value: "bar"},
-						"BAR": {Value: "baz"},
-						"BAZ": {Value: "foo"},
+			ExpectedGlobals: ast.NewVars(
+				&ast.VarElement{
+					Key: "FOO",
+					Value: ast.Var{
+						Value: "bar",
 					},
-					[]string{"FOO", "BAR", "BAZ"},
-				),
-			},
+				},
+				&ast.VarElement{
+					Key: "BAR",
+					Value: ast.Var{
+						Value: "baz",
+					},
+				},
+				&ast.VarElement{
+					Key: "BAZ",
+					Value: ast.Var{
+						Value: "foo",
+					},
+				},
+			),
 		},
 		{
 			Args: []string{"task-a", "CONTENT=with some spaces"},
 			ExpectedCalls: []*ast.Call{
 				{Task: "task-a"},
 			},
-			ExpectedGlobals: &ast.Vars{
-				OrderedMap: omap.FromMapWithOrder(
-					map[string]ast.Var{
-						"CONTENT": {Value: "with some spaces"},
+			ExpectedGlobals: ast.NewVars(
+				&ast.VarElement{
+					Key: "CONTENT",
+					Value: ast.Var{
+						Value: "with some spaces",
 					},
-					[]string{"CONTENT"},
-				),
-			},
+				},
+			),
 		},
 		{
 			Args: []string{"FOO=bar", "task-a", "task-b"},
@@ -63,14 +74,14 @@ func TestArgs(t *testing.T) {
 				{Task: "task-a"},
 				{Task: "task-b"},
 			},
-			ExpectedGlobals: &ast.Vars{
-				OrderedMap: omap.FromMapWithOrder(
-					map[string]ast.Var{
-						"FOO": {Value: "bar"},
+			ExpectedGlobals: ast.NewVars(
+				&ast.VarElement{
+					Key: "FOO",
+					Value: ast.Var{
+						Value: "bar",
 					},
-					[]string{"FOO"},
-				),
-			},
+				},
+			),
 		},
 		{
 			Args:          nil,
@@ -83,25 +94,32 @@ func TestArgs(t *testing.T) {
 		{
 			Args:          []string{"FOO=bar", "BAR=baz"},
 			ExpectedCalls: []*ast.Call{},
-			ExpectedGlobals: &ast.Vars{
-				OrderedMap: omap.FromMapWithOrder(
-					map[string]ast.Var{
-						"FOO": {Value: "bar"},
-						"BAR": {Value: "baz"},
+			ExpectedGlobals: ast.NewVars(
+				&ast.VarElement{
+					Key: "FOO",
+					Value: ast.Var{
+						Value: "bar",
 					},
-					[]string{"FOO", "BAR"},
-				),
-			},
+				},
+				&ast.VarElement{
+					Key: "BAR",
+					Value: ast.Var{
+						Value: "baz",
+					},
+				},
+			),
 		},
 	}
 
 	for i, test := range tests {
 		t.Run(fmt.Sprintf("TestArgs%d", i+1), func(t *testing.T) {
+			t.Parallel()
+
 			calls, globals := args.Parse(test.Args...)
 			assert.Equal(t, test.ExpectedCalls, calls)
 			if test.ExpectedGlobals.Len() > 0 || globals.Len() > 0 {
-				assert.Equal(t, test.ExpectedGlobals.Keys(), globals.Keys())
-				assert.Equal(t, test.ExpectedGlobals.Values(), globals.Values())
+				assert.Equal(t, test.ExpectedGlobals, globals)
+				assert.Equal(t, test.ExpectedGlobals, globals)
 			}
 		})
 	}

cmd/release/main.go

@@ -1,7 +1,6 @@
 package main
 
 import (
-	"errors"
 	"fmt"
 	"os"
 	"os/exec"
@@ -12,6 +11,8 @@ import (
 	"github.com/Masterminds/semver/v3"
 	"github.com/otiai10/copy"
 	"github.com/spf13/pflag"
+
+	"github.com/go-task/task/v3/errors"
 )
 
 const (

cmd/sleepit/sleepit.go

@@ -159,7 +159,7 @@ func worker(
 	return workerDone
 }
 
-// Do some work and then return, so that the caller can decide wether to continue or not.
+// Do some work and then return, so that the caller can decide whether to continue or not.
 // Return true when all work is done.
 func doSomeWork(deadline time.Time) bool {
 	if time.Now().After(deadline) {

cmd/task/task.go

@@ -44,7 +44,7 @@ func main() {
 }
 
 func run() error {
-	logger := &logger.Logger{
+	log := &logger.Logger{
 		Stdout:  os.Stdout,
 		Stderr:  os.Stderr,
 		Verbose: flags.Verbose,
@@ -69,7 +69,7 @@ func run() error {
 	}
 
 	if flags.Experiments {
-		return experiments.List(logger)
+		return log.PrintExperiments()
 	}
 
 	if flags.Init {
@@ -77,9 +77,18 @@ func run() error {
 		if err != nil {
 			return err
 		}
+
 		if err := task.InitTaskfile(os.Stdout, wd); err != nil {
 			return err
 		}
+
+		if !flags.Silent {
+			if flags.Verbose {
+				log.Outf(logger.Default, "%s\n", task.DefaultTaskfile)
+			}
+			log.Outf(logger.Green, "%s created in the current directory\n", task.DefaultTaskFilename)
+		}
+
 		return nil
 	}
 
@@ -100,6 +109,10 @@ func run() error {
 		dir = home
 	}
 
+	if err := experiments.Validate(); err != nil {
+		log.Warnf("%s\n", err.Error())
+	}
+
 	var taskSorter sort.TaskSorter
 	switch flags.TaskSort {
 	case "none":
@@ -132,8 +145,9 @@ func run() error {
 		Stdout: os.Stdout,
 		Stderr: os.Stderr,
 
-		OutputStyle: flags.Output,
-		TaskSorter:  taskSorter,
+		OutputStyle:        flags.Output,
+		TaskSorter:         taskSorter,
+		EnableVersionCheck: true,
 	}
 	listOptions := task.NewListOptions(flags.List, flags.ListAll, flags.ListJson, flags.NoStatus)
 	if err := listOptions.Validate(); err != nil {
@@ -144,9 +158,6 @@ func run() error {
 	if err != nil {
 		return err
 	}
-	if experiments.AnyVariables.Enabled {
-		logger.Warnf("The 'Any Variables' experiment flag is no longer required to use non-map variable types. If you wish to use map variables, please use 'TASK_X_MAP_VARIABLES' instead. See https://github.com/go-task/task/issues/1585\n")
-	}
 
 	// If the download flag is specified, we should stop execution as soon as
 	// taskfile is downloaded
@@ -198,6 +209,7 @@ func run() error {
 	globals.Set("CLI_FORCE", ast.Var{Value: flags.Force || flags.ForceAll})
 	globals.Set("CLI_SILENT", ast.Var{Value: flags.Silent})
 	globals.Set("CLI_VERBOSE", ast.Var{Value: flags.Verbose})
+	globals.Set("CLI_OFFLINE", ast.Var{Value: flags.Offline})
 	e.Taskfile.Vars.Merge(globals, nil)
 
 	if !flags.Watch {

errors/errors.go

@@ -32,6 +32,7 @@ const (
 	CodeTaskCalledTooManyTimes
 	CodeTaskCancelled
 	CodeTaskMissingRequiredVars
+	CodeTaskNotAllowedVars
 )
 
 // TaskError extends the standard error interface with a Code method. This code will

errors/errors_task.go

@@ -158,3 +158,29 @@ func (err *TaskMissingRequiredVars) Error() string {
 func (err *TaskMissingRequiredVars) Code() int {
 	return CodeTaskMissingRequiredVars
 }
+
+type NotAllowedVar struct {
+	Value string
+	Enum  []string
+	Name  string
+}
+
+type TaskNotAllowedVars struct {
+	TaskName       string
+	NotAllowedVars []NotAllowedVar
+}
+
+func (err *TaskNotAllowedVars) Error() string {
+	var builder strings.Builder
+
+	builder.WriteString(fmt.Sprintf("task: Task %q cancelled because it is missing required variables:\n", err.TaskName))
+	for _, s := range err.NotAllowedVars {
+		builder.WriteString(fmt.Sprintf("  - %s has an invalid value : '%s' (allowed values : %v)\n", s.Name, s.Value, s.Enum))
+	}
+
+	return builder.String()
+}
+
+func (err *TaskNotAllowedVars) Code() int {
+	return CodeTaskNotAllowedVars
+}

go.mod

@@ -4,36 +4,59 @@ go 1.22.0
 
 require (
 	github.com/Ladicle/tabwriter v1.0.0
-	github.com/Masterminds/semver/v3 v3.3.0
-	github.com/alecthomas/chroma/v2 v2.14.0
+	github.com/Masterminds/semver/v3 v3.3.1
+	github.com/alecthomas/chroma/v2 v2.15.0
+	github.com/chainguard-dev/git-urls v1.0.2
 	github.com/davecgh/go-spew v1.1.1
 	github.com/dominikbraun/graph v0.23.0
-	github.com/fatih/color v1.17.0
+	github.com/elliotchance/orderedmap/v2 v2.7.0
+	github.com/fatih/color v1.18.0
+	github.com/go-git/go-billy/v5 v5.6.2
+	github.com/go-git/go-git/v5 v5.13.2
 	github.com/go-task/slim-sprig/v3 v3.0.0
 	github.com/go-task/template v0.1.0
 	github.com/joho/godotenv v1.5.1
 	github.com/mattn/go-zglob v0.0.6
 	github.com/mitchellh/hashstructure/v2 v2.0.2
-	github.com/otiai10/copy v1.14.0
+	github.com/otiai10/copy v1.14.1
 	github.com/radovskyb/watcher v1.0.7
 	github.com/sajari/fuzzy v1.0.0
 	github.com/spf13/pflag v1.0.5
-	github.com/stretchr/testify v1.9.0
+	github.com/stretchr/testify v1.10.0
 	github.com/zeebo/xxh3 v1.0.2
-	golang.org/x/sync v0.8.0
-	golang.org/x/term v0.24.0
+	golang.org/x/sync v0.10.0
+	golang.org/x/term v0.28.0
 	gopkg.in/yaml.v3 v3.0.1
-	mvdan.cc/sh/v3 v3.9.0
+	mvdan.cc/sh/v3 v3.10.0
 )
 
 require (
-	github.com/dlclark/regexp2 v1.11.0 // indirect
-	github.com/klauspost/cpuid/v2 v2.0.9 // indirect
+	dario.cat/mergo v1.0.0 // indirect
+	github.com/Microsoft/go-winio v0.6.1 // indirect
+	github.com/ProtonMail/go-crypto v1.1.5 // indirect
+	github.com/cloudflare/circl v1.3.7 // indirect
+	github.com/cyphar/filepath-securejoin v0.3.6 // indirect
+	github.com/dlclark/regexp2 v1.11.4 // indirect
+	github.com/emirpasic/gods v1.18.1 // indirect
+	github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 // indirect
+	github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect
+	github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 // indirect
+	github.com/kevinburke/ssh_config v1.2.0 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.7 // indirect
 	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/muesli/cancelreader v0.2.2 // indirect
+	github.com/otiai10/mint v1.6.3 // indirect
+	github.com/pjbgf/sha1cd v0.3.2 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
+	github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3 // indirect
+	github.com/skeema/knownhosts v1.3.0 // indirect
 	github.com/stretchr/objx v0.5.2 // indirect
-	golang.org/x/sys v0.25.0 // indirect
-	gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 // indirect
+	github.com/xanzy/ssh-agent v0.3.3 // indirect
+	golang.org/x/crypto v0.32.0 // indirect
+	golang.org/x/mod v0.18.0 // indirect
+	golang.org/x/net v0.34.0 // indirect
+	golang.org/x/sys v0.29.0 // indirect
+	golang.org/x/tools v0.22.0 // indirect
+	gopkg.in/warnings.v0 v0.1.2 // indirect
 )

go.sum

@@ -1,39 +1,92 @@
+dario.cat/mergo v1.0.0 h1:AGCNq9Evsj31mOgNPcLyXc+4PNABt905YmuqPYYpBWk=
+dario.cat/mergo v1.0.0/go.mod h1:uNxQE+84aUszobStD9th8a29P2fMDhsBdgRYvZOxGmk=
 github.com/Ladicle/tabwriter v1.0.0 h1:DZQqPvMumBDwVNElso13afjYLNp0Z7pHqHnu0r4t9Dg=
 github.com/Ladicle/tabwriter v1.0.0/go.mod h1:c4MdCjxQyTbGuQO/gvqJ+IA/89UEwrsD6hUCW98dyp4=
-github.com/Masterminds/semver/v3 v3.3.0 h1:B8LGeaivUe71a5qox1ICM/JLl0NqZSW5CHyL+hmvYS0=
-github.com/Masterminds/semver/v3 v3.3.0/go.mod h1:4V+yj/TJE1HU9XfppCwVMZq3I84lprf4nC11bSS5beM=
+github.com/Masterminds/semver/v3 v3.3.1 h1:QtNSWtVZ3nBfk8mAOu/B6v7FMJ+NHTIgUPi7rj+4nv4=
+github.com/Masterminds/semver/v3 v3.3.1/go.mod h1:4V+yj/TJE1HU9XfppCwVMZq3I84lprf4nC11bSS5beM=
+github.com/Microsoft/go-winio v0.5.2/go.mod h1:WpS1mjBmmwHBEWmogvA2mj8546UReBk4v8QkMxJ6pZY=
+github.com/Microsoft/go-winio v0.6.1 h1:9/kr64B9VUZrLm5YYwbGtUJnMgqWVOdUAXu6Migciow=
+github.com/Microsoft/go-winio v0.6.1/go.mod h1:LRdKpFKfdobln8UmuiYcKPot9D2v6svN5+sAH+4kjUM=
+github.com/ProtonMail/go-crypto v1.1.3 h1:nRBOetoydLeUb4nHajyO2bKqMLfWQ/ZPwkXqXxPxCFk=
+github.com/ProtonMail/go-crypto v1.1.3/go.mod h1:rA3QumHc/FZ8pAHreoekgiAbzpNsfQAosU5td4SnOrE=
+github.com/ProtonMail/go-crypto v1.1.5 h1:eoAQfK2dwL+tFSFpr7TbOaPNUbPiJj4fLYwwGE1FQO4=
+github.com/ProtonMail/go-crypto v1.1.5/go.mod h1:rA3QumHc/FZ8pAHreoekgiAbzpNsfQAosU5td4SnOrE=
 github.com/alecthomas/assert/v2 v2.7.0 h1:QtqSACNS3tF7oasA8CU6A6sXZSBDqnm7RfpLl9bZqbE=
 github.com/alecthomas/assert/v2 v2.7.0/go.mod h1:Bze95FyfUr7x34QZrjL+XP+0qgp/zg8yS+TtBj1WA3k=
 github.com/alecthomas/chroma/v2 v2.14.0 h1:R3+wzpnUArGcQz7fCETQBzO5n9IMNi13iIs46aU4V9E=
 github.com/alecthomas/chroma/v2 v2.14.0/go.mod h1:QolEbTfmUHIMVpBqxeDnNBj2uoeI4EbYP4i6n68SG4I=
+github.com/alecthomas/chroma/v2 v2.15.0 h1:LxXTQHFoYrstG2nnV9y2X5O94sOBzf0CIUpSTbpxvMc=
+github.com/alecthomas/chroma/v2 v2.15.0/go.mod h1:gUhVLrPDXPtp/f+L1jo9xepo9gL4eLwRuGAunSZMkio=
 github.com/alecthomas/repr v0.4.0 h1:GhI2A8MACjfegCPVq9f1FLvIBS+DrQ2KQBFZP1iFzXc=
 github.com/alecthomas/repr v0.4.0/go.mod h1:Fr0507jx4eOXV7AlPV6AVZLYrLIuIeSOWtW57eE/O/4=
-github.com/creack/pty v1.1.21 h1:1/QdRyBaHHJP61QkWMXlOIBfsgdDeeKfK8SYVUWJKf0=
-github.com/creack/pty v1.1.21/go.mod h1:MOBLtS5ELjhRRrroQr9kyvTxUAFNvYEK993ew/Vr4O4=
+github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be h1:9AeTilPcZAjCFIImctFaOjnTIavg87rW78vTPkQqLI8=
+github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be/go.mod h1:ySMOLuWl6zY27l47sB3qLNK6tF2fkHG55UZxx8oIVo4=
+github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5 h1:0CwZNZbxp69SHPdPJAN/hZIm0C4OItdklCFmMRWYpio=
+github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5/go.mod h1:wHh0iHkYZB8zMSxRWpUBQtwG5a7fFgvEO+odwuTv2gs=
+github.com/chainguard-dev/git-urls v1.0.2 h1:pSpT7ifrpc5X55n4aTTm7FFUE+ZQHKiqpiwNkJrVcKQ=
+github.com/chainguard-dev/git-urls v1.0.2/go.mod h1:rbGgj10OS7UgZlbzdUQIQpT0k/D4+An04HJY7Ol+Y/o=
+github.com/cloudflare/circl v1.3.7 h1:qlCDlTPz2n9fu58M0Nh1J/JzcFpfgkFHHX3O35r5vcU=
+github.com/cloudflare/circl v1.3.7/go.mod h1:sRTcRWXGLrKw6yIGJ+l7amYJFfAXbZG0kBSc8r4zxgA=
+github.com/creack/pty v1.1.23 h1:4M6+isWdcStXEf15G/RbrMPOQj1dZ7HPZCGwE4kOeP0=
+github.com/creack/pty v1.1.23/go.mod h1:08sCNb52WyoAwi2QDyzUCTgcvVFhUzewun7wtTfvcwE=
+github.com/cyphar/filepath-securejoin v0.3.6 h1:4d9N5ykBnSp5Xn2JkhocYDkOpURL/18CYMpo6xB9uWM=
+github.com/cyphar/filepath-securejoin v0.3.6/go.mod h1:Sdj7gXlvMcPZsbhwhQ33GguGLDGQL7h7bg04C/+u9jI=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/dlclark/regexp2 v1.11.0 h1:G/nrcoOa7ZXlpoa/91N3X7mM3r8eIlMBBJZvsz/mxKI=
 github.com/dlclark/regexp2 v1.11.0/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
+github.com/dlclark/regexp2 v1.11.4 h1:rPYF9/LECdNymJufQKmri9gV604RvvABwgOA8un7yAo=
+github.com/dlclark/regexp2 v1.11.4/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
 github.com/dominikbraun/graph v0.23.0 h1:TdZB4pPqCLFxYhdyMFb1TBdFxp8XLcJfTTBQucVPgCo=
 github.com/dominikbraun/graph v0.23.0/go.mod h1:yOjYyogZLY1LSG9E33JWZJiq5k83Qy2C6POAuiViluc=
-github.com/fatih/color v1.17.0 h1:GlRw1BRJxkpqUCBKzKOw098ed57fEsKeNjpTe3cSjK4=
-github.com/fatih/color v1.17.0/go.mod h1:YZ7TlrGPkiz6ku9fK3TLD/pl3CpsiFyu8N92HLgmosI=
+github.com/elazarl/goproxy v1.2.3 h1:xwIyKHbaP5yfT6O9KIeYJR5549MXRQkoQMRXGztz8YQ=
+github.com/elazarl/goproxy v1.2.3/go.mod h1:YfEbZtqP4AetfO6d40vWchF3znWX7C7Vd6ZMfdL8z64=
+github.com/elliotchance/orderedmap/v2 v2.7.0 h1:WHuf0DRo63uLnldCPp9ojm3gskYwEdIIfAUVG5KhoOc=
+github.com/elliotchance/orderedmap/v2 v2.7.0/go.mod h1:85lZyVbpGaGvHvnKa7Qhx7zncAdBIBq6u56Hb1PRU5Q=
+github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc=
+github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ=
+github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM=
+github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU=
+github.com/gliderlabs/ssh v0.3.8 h1:a4YXD1V7xMF9g5nTkdfnja3Sxy1PVDCj1Zg4Wb8vY6c=
+github.com/gliderlabs/ssh v0.3.8/go.mod h1:xYoytBv1sV0aL3CavoDuJIQNURXkkfPA/wxQ1pL1fAU=
+github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 h1:+zs/tPmkDkHx3U66DAb0lQFJrpS6731Oaa12ikc+DiI=
+github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376/go.mod h1:an3vInlBmSxCcxctByoQdvwPiA7DTK7jaaFDBTtu0ic=
+github.com/go-git/go-billy/v5 v5.6.1 h1:u+dcrgaguSSkbjzHwelEjc0Yj300NUevrrPphk/SoRA=
+github.com/go-git/go-billy/v5 v5.6.1/go.mod h1:0AsLr1z2+Uksi4NlElmMblP5rPcDZNRCD8ujZCRR2BE=
+github.com/go-git/go-billy/v5 v5.6.2 h1:6Q86EsPXMa7c3YZ3aLAQsMA0VlWmy43r6FHqa/UNbRM=
+github.com/go-git/go-billy/v5 v5.6.2/go.mod h1:rcFC2rAsp/erv7CMz9GczHcuD0D32fWzH+MJAU+jaUU=
+github.com/go-git/go-git-fixtures/v4 v4.3.2-0.20231010084843-55a94097c399 h1:eMje31YglSBqCdIqdhKBW8lokaMrL3uTkpGYlE2OOT4=
+github.com/go-git/go-git-fixtures/v4 v4.3.2-0.20231010084843-55a94097c399/go.mod h1:1OCfN199q1Jm3HZlxleg+Dw/mwps2Wbk9frAWm+4FII=
+github.com/go-git/go-git/v5 v5.13.1 h1:DAQ9APonnlvSWpvolXWIuV6Q6zXy2wHbN4cVlNR5Q+M=
+github.com/go-git/go-git/v5 v5.13.1/go.mod h1:qryJB4cSBoq3FRoBRf5A77joojuBcmPJ0qu3XXXVixc=
+github.com/go-git/go-git/v5 v5.13.2 h1:7O7xvsK7K+rZPKW6AQR1YyNhfywkv7B8/FsP3ki6Zv0=
+github.com/go-git/go-git/v5 v5.13.2/go.mod h1:hWdW5P4YZRjmpGHwRH2v3zkWcNl6HeXaXQEMGb3NJ9A=
 github.com/go-quicktest/qt v1.101.0 h1:O1K29Txy5P2OK0dGo59b7b0LR6wKfIhttaAhHUyn7eI=
 github.com/go-quicktest/qt v1.101.0/go.mod h1:14Bz/f7NwaXPtdYEgzsx46kqSxVwTbzVZsDC26tQJow=
 github.com/go-task/slim-sprig/v3 v3.0.0 h1:sUs3vkvUymDpBKi3qH1YSqBQk9+9D/8M2mN1vB6EwHI=
 github.com/go-task/slim-sprig/v3 v3.0.0/go.mod h1:W848ghGpv3Qj3dhTPRyJypKRiqCdHZiAzKg9hl15HA8=
 github.com/go-task/template v0.1.0 h1:ym/r2G937RZA1bsgiWedNnY9e5kxDT+3YcoAnuIetTE=
 github.com/go-task/template v0.1.0/go.mod h1:RgwRaZK+kni/hJJ7/AaOE2lPQFPbAdji/DyhC6pxo4k=
+github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da h1:oI5xCqsCo564l8iNU+DwB5epxmsaqB+rhGL0m5jtYqE=
+github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
 github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
 github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
 github.com/hexops/gotextdiff v1.0.3 h1:gitA9+qJrrTCsiCl7+kh75nPqQt1cx4ZkudSTLoUqJM=
 github.com/hexops/gotextdiff v1.0.3/go.mod h1:pSWU5MAI3yDq+fZBTazCSJysOMbxWL1BSow5/V2vxeg=
+github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 h1:BQSFePA1RWJOlocH6Fxy8MmwDt+yVQYULKfN0RoTN8A=
+github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99/go.mod h1:1lJo3i6rXxKeerYnT8Nvf0QmHCRC1n8sfWVwXF2Frvo=
 github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
 github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
-github.com/klauspost/cpuid/v2 v2.0.9 h1:lgaqFMSdTdQYdZ04uHyN2d/eKdOMyi2YLSvlQIBFYa4=
-github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
+github.com/kevinburke/ssh_config v1.2.0 h1:x584FjTGwHzMwvHx18PXxbBVzfnxogHaAReU4gf13a4=
+github.com/kevinburke/ssh_config v1.2.0/go.mod h1:CT57kijsi8u/K/BOFA39wgDQJ9CxiF4nAY/ojJ6r6mM=
+github.com/klauspost/cpuid/v2 v2.2.7 h1:ZWSB3igEs+d0qvnxR/ZBzXVmxkgt8DdzP6m9pfuVLDM=
+github.com/klauspost/cpuid/v2 v2.2.7/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws=
+github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
 github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
 github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
+github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
@@ -47,40 +100,99 @@ github.com/mitchellh/hashstructure/v2 v2.0.2 h1:vGKWl0YJqUNxE8d+h8f6NJLcCJrgbhC4
 github.com/mitchellh/hashstructure/v2 v2.0.2/go.mod h1:MG3aRVU/N29oo/V/IhBX8GR/zz4kQkprJgF2EVszyDE=
 github.com/muesli/cancelreader v0.2.2 h1:3I4Kt4BQjOR54NavqnDogx/MIoWBFa0StPA8ELUXHmA=
 github.com/muesli/cancelreader v0.2.2/go.mod h1:3XuTXfFS2VjM+HTLZY9Ak0l6eUKfijIfMUZ4EgX0QYo=
+github.com/onsi/gomega v1.34.1 h1:EUMJIKUjM8sKjYbtxQI9A4z2o+rruxnzNvpknOXie6k=
+github.com/onsi/gomega v1.34.1/go.mod h1:kU1QgUvBDLXBJq618Xvm2LUX6rSAfRaFRTcdOeDLwwY=
 github.com/otiai10/copy v1.14.0 h1:dCI/t1iTdYGtkvCuBG2BgR6KZa83PTclw4U5n2wAllU=
 github.com/otiai10/copy v1.14.0/go.mod h1:ECfuL02W+/FkTWZWgQqXPWZgW9oeKCSQ5qVfSc4qc4w=
+github.com/otiai10/copy v1.14.1 h1:5/7E6qsUMBaH5AnQ0sSLzzTg1oTECmcCmT6lvF45Na8=
+github.com/otiai10/copy v1.14.1/go.mod h1:oQwrEDDOci3IM8dJF0d8+jnbfPDllW6vUjNc3DoZm9I=
 github.com/otiai10/mint v1.5.1 h1:XaPLeE+9vGbuyEHem1JNk3bYc7KKqyI/na0/mLd/Kks=
 github.com/otiai10/mint v1.5.1/go.mod h1:MJm72SBthJjz8qhefc4z1PYEieWmy8Bku7CjcAqyUSM=
+github.com/otiai10/mint v1.6.3 h1:87qsV/aw1F5as1eH1zS/yqHY85ANKVMgkDrf9rcxbQs=
+github.com/otiai10/mint v1.6.3/go.mod h1:MJm72SBthJjz8qhefc4z1PYEieWmy8Bku7CjcAqyUSM=
+github.com/pjbgf/sha1cd v0.3.0 h1:4D5XXmUUBUl/xQ6IjCkEAbqXskkq/4O7LmGn0AqMDs4=
+github.com/pjbgf/sha1cd v0.3.0/go.mod h1:nZ1rrWOcGJ5uZgEEVL1VUM9iRQiZvWdbZjkKyFzPPsI=
+github.com/pjbgf/sha1cd v0.3.2 h1:a9wb0bp1oC2TGwStyn0Umc/IGKQnEgF0vVaZ8QF8eo4=
+github.com/pjbgf/sha1cd v0.3.2/go.mod h1:zQWigSxVmsHEZow5qaLtPYxpcKMMQpa09ixqBxuCS6A=
+github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/radovskyb/watcher v1.0.7 h1:AYePLih6dpmS32vlHfhCeli8127LzkIgwJGcwwe8tUE=
 github.com/radovskyb/watcher v1.0.7/go.mod h1:78okwvY5wPdzcb1UYnip1pvrZNIVEIh/Cm+ZuvsUYIg=
-github.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU5NdKM8=
-github.com/rogpeppe/go-internal v1.12.0/go.mod h1:E+RYuTGaKKdloAfM02xzb0FW3Paa99yedzYV+kq4uf4=
+github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
+github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
 github.com/sajari/fuzzy v1.0.0 h1:+FmwVvJErsd0d0hAPlj4CxqxUtQY/fOoY0DwX4ykpRY=
 github.com/sajari/fuzzy v1.0.0/go.mod h1:OjYR6KxoWOe9+dOlXeiCJd4dIbED4Oo8wpS89o0pwOo=
+github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3 h1:n661drycOFuPLCN3Uc8sB6B/s6Z4t2xvBgU1htSHuq8=
+github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3/go.mod h1:A0bzQcvG0E7Rwjx0REVgAGH58e96+X0MeOfepqsbeW4=
+github.com/sirupsen/logrus v1.7.0/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0=
+github.com/skeema/knownhosts v1.3.0 h1:AM+y0rI04VksttfwjkSTNQorvGqmwATnvnAHpSgc0LY=
+github.com/skeema/knownhosts v1.3.0/go.mod h1:sPINvnADmT/qYH1kfv+ePMmOBTH6Tbl7b5LvTDjFK7M=
 github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
 github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY=
 github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
-github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
-github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
+github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
+github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
+github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/xanzy/ssh-agent v0.3.3 h1:+/15pJfg/RsTxqYcX6fHqOXZwwMP+2VyYWJeWM2qQFM=
+github.com/xanzy/ssh-agent v0.3.3/go.mod h1:6dzNDKs0J9rVPHPhaGCukekBHKqfl+L3KghI1Bc68Uw=
 github.com/zeebo/assert v1.3.0 h1:g7C04CbJuIDKNPFHmsk4hwZDO5O+kntRxzaUoNXj+IQ=
 github.com/zeebo/assert v1.3.0/go.mod h1:Pq9JiuJQpG8JLJdtkwrJESF0Foym2/D9XMU5ciN/wJ0=
 github.com/zeebo/xxh3 v1.0.2 h1:xZmwmqxHZA8AI603jOQ0tMqmBr9lPeFwGg6d+xy9DC0=
 github.com/zeebo/xxh3 v1.0.2/go.mod h1:5NWz9Sef7zIDm2JHfFlcQvNekmcEl9ekUZQQKCYaDcA=
-golang.org/x/sync v0.8.0 h1:3NFvSEYkUoMifnESzZl15y791HH1qU2xm6eCJU5ZPXQ=
-golang.org/x/sync v0.8.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
+golang.org/x/crypto v0.31.0 h1:ihbySMvVjLAeSH1IbfcRTkD/iNscyz8rGzjF/E5hV6U=
+golang.org/x/crypto v0.31.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk=
+golang.org/x/crypto v0.32.0 h1:euUpcYgM8WcP71gNpTqQCn6rC2t6ULUPiOzfWaXVVfc=
+golang.org/x/crypto v0.32.0/go.mod h1:ZnnJkOaASj8g0AjIduWNlq2NRxL0PlBrbKVyZ6V/Ugc=
+golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56 h1:2dVuKD2vS7b0QIHQbpyTISPd0LeHDbnYEryqj5Q1ug8=
+golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56/go.mod h1:M4RDyNAINzryxdtnbRXRL/OHtkFuWGRjvuhBJpk2IlY=
+golang.org/x/mod v0.18.0 h1:5+9lSbEzPSdWkH32vYPBwEpX8KwDbM52Ud9xBUvNlb0=
+golang.org/x/mod v0.18.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
+golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+golang.org/x/net v0.33.0 h1:74SYHlV8BIgHIFC/LrYkOGIwL19eTYXQ5wc6TBuO36I=
+golang.org/x/net v0.33.0/go.mod h1:HXLR5J+9DxmrqMwG9qjGCxZ+zKXxBru04zlTvWlWuN4=
+golang.org/x/net v0.34.0 h1:Mb7Mrk043xzHgnRM88suvJFwzVrRfHEHJEl5/71CKw0=
+golang.org/x/net v0.34.0/go.mod h1:di0qlW3YNM5oh6GqDGQr92MyTozJPmybPK4Ev/Gm31k=
+golang.org/x/sync v0.10.0 h1:3NQrjDixjgGwUOCaF8w2+VYHv0Ve/vGYSbdkTa98gmQ=
+golang.org/x/sync v0.10.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.25.0 h1:r+8e+loiHxRqhXVl6ML1nO3l1+oFoWbnlu2Ehimmi34=
-golang.org/x/sys v0.25.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/term v0.24.0 h1:Mh5cbb+Zk2hqqXNO7S1iTjEphVL+jb8ZWaqh/g+JWkM=
-golang.org/x/term v0.24.0/go.mod h1:lOBK/LVxemqiMij05LGJ0tzNr8xlmwBRJ81PX6wVLH8=
+golang.org/x/sys v0.28.0 h1:Fksou7UEQUWlKvIdsqzJmUmCX3cZuD2+P3XyyzwMhlA=
+golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.29.0 h1:TPYlXGxvx1MGTn2GiZDhnjPA9wZzZeGKHHmKhHYvgaU=
+golang.org/x/sys v0.29.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/term v0.27.0 h1:WP60Sv1nlK1T6SupCHbXzSaN0b9wUmsPoRS9b61A23Q=
+golang.org/x/term v0.27.0/go.mod h1:iMsnZpn0cago0GOrHO2+Y7u7JPn5AylBrcoWkElMTSM=
+golang.org/x/term v0.28.0 h1:/Ts8HFuMR2E6IP/jlo7QVLZHggjKQbhu/7H0LJFr3Gg=
+golang.org/x/term v0.28.0/go.mod h1:Sw/lC2IAUZ92udQNf3WodGtn4k/XoLyZoh8v/8uiwek=
+golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo=
+golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.22.0 h1:gqSGLZqv+AI9lIQzniJ0nZDRG5GBPsSi+DRNHWNz6yA=
+golang.org/x/tools v0.22.0/go.mod h1:aCwcsjqvq7Yqt6TNyX7QMU2enbQ/Gt0bo6krSeEri+c=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
-gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
+gopkg.in/warnings.v0 v0.1.2 h1:wFXVbFY8DY5/xOe1ECiWdKCzZlxgshcYVNkBHstARME=
+gopkg.in/warnings.v0 v0.1.2/go.mod h1:jksf8JmL6Qr/oQM2OXTHunEvvTAsrWBLb6OOjuVWRNI=
+gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-mvdan.cc/sh/v3 v3.9.0 h1:it14fyjCdQUk4jf/aYxLO3FG8jFarR9GzMCtnlvvD7c=
-mvdan.cc/sh/v3 v3.9.0/go.mod h1:cdBk8bgoiBI7lSZqK5JhUuq7OB64VQ7fgm85xelw3Nk=
+mvdan.cc/sh/v3 v3.10.0 h1:v9z7N1DLZ7owyLM/SXZQkBSXcwr2IGMm2LY2pmhVXj4=
+mvdan.cc/sh/v3 v3.10.0/go.mod h1:z/mSSVyLFGZzqb3ZIKojjyqIx/xbmz/UHdCSv9HmqXY=

init.go

@@ -1,7 +1,6 @@
 package task
 
 import (
-	"fmt"
 	"io"
 	"os"
 
@@ -9,7 +8,7 @@ import (
 	"github.com/go-task/task/v3/internal/filepathext"
 )
 
-const defaultTaskfile = `# https://taskfile.dev
+const DefaultTaskfile = `# https://taskfile.dev
 
 version: '3'
 
@@ -23,19 +22,19 @@ tasks:
     silent: true
 `
 
-const defaultTaskfileName = "Taskfile.yml"
+const DefaultTaskFilename = "Taskfile.yml"
 
-// InitTaskfile Taskfile creates a new Taskfile
+// InitTaskfile creates a new Taskfile
 func InitTaskfile(w io.Writer, dir string) error {
-	f := filepathext.SmartJoin(dir, defaultTaskfileName)
+	f := filepathext.SmartJoin(dir, DefaultTaskFilename)
 
 	if _, err := os.Stat(f); err == nil {
 		return errors.TaskfileAlreadyExistsError{}
 	}
 
-	if err := os.WriteFile(f, []byte(defaultTaskfile), 0o644); err != nil {
+	if err := os.WriteFile(f, []byte(DefaultTaskfile), 0o644); err != nil {
 		return err
 	}
-	fmt.Fprintf(w, "%s created in the current directory\n", defaultTaskfile)
+
 	return nil
 }

init_test.go

@@ -0,0 +1,31 @@
+package task_test
+
+import (
+	"io"
+	"os"
+	"testing"
+
+	"github.com/go-task/task/v3"
+	"github.com/go-task/task/v3/internal/filepathext"
+)
+
+func TestInit(t *testing.T) {
+	t.Parallel()
+
+	const dir = "testdata/init"
+	file := filepathext.SmartJoin(dir, "Taskfile.yml")
+
+	_ = os.Remove(file)
+	if _, err := os.Stat(file); err == nil {
+		t.Errorf("Taskfile.yml should not exist")
+	}
+
+	if err := task.InitTaskfile(io.Discard, dir); err != nil {
+		t.Error(err)
+	}
+
+	if _, err := os.Stat(file); err != nil {
+		t.Errorf("Taskfile.yml should exist")
+	}
+	_ = os.Remove(file)
+}

internal/compiler/compiler.go

@@ -9,6 +9,7 @@ import (
 	"strings"
 	"sync"
 
+	"github.com/go-task/task/v3/internal/env"
 	"github.com/go-task/task/v3/internal/execext"
 	"github.com/go-task/task/v3/internal/filepathext"
 	"github.com/go-task/task/v3/internal/logger"
@@ -45,14 +46,12 @@ func (c *Compiler) FastGetVariables(t *ast.Task, call *ast.Call) (*ast.Vars, err
 
 func (c *Compiler) getVariables(t *ast.Task, call *ast.Call, evaluateShVars bool) (*ast.Vars, error) {
 	result := GetEnviron()
-	if t != nil {
-		specialVars, err := c.getSpecialVars(t, call)
-		if err != nil {
-			return nil, err
-		}
-		for k, v := range specialVars {
-			result.Set(k, ast.Var{Value: v})
-		}
+	specialVars, err := c.getSpecialVars(t, call)
+	if err != nil {
+		return nil, err
+	}
+	for k, v := range specialVars {
+		result.Set(k, ast.Var{Value: v})
 	}
 
 	getRangeFunc := func(dir string) func(k string, v ast.Var) error {
@@ -75,13 +74,13 @@ func (c *Compiler) getVariables(t *ast.Task, call *ast.Call, evaluateShVars bool
 			if err := cache.Err(); err != nil {
 				return err
 			}
-			// If the variable is not dynamic, we can set it and return
-			if newVar.Value != nil || newVar.Sh == "" {
+			// If the variable is already set, we can set it and return
+			if newVar.Value != nil {
 				result.Set(k, ast.Var{Value: newVar.Value})
 				return nil
 			}
 			// If the variable is dynamic, we need to resolve it first
-			static, err := c.HandleDynamicVar(newVar, dir)
+			static, err := c.HandleDynamicVar(newVar, dir, env.GetFromVars(result))
 			if err != nil {
 				return err
 			}
@@ -133,14 +132,19 @@ func (c *Compiler) getVariables(t *ast.Task, call *ast.Call, evaluateShVars bool
 	return result, nil
 }
 
-func (c *Compiler) HandleDynamicVar(v ast.Var, dir string) (string, error) {
+func (c *Compiler) HandleDynamicVar(v ast.Var, dir string, e []string) (string, error) {
 	c.muDynamicCache.Lock()
 	defer c.muDynamicCache.Unlock()
 
+	// If the variable is not dynamic or it is empty, return an empty string
+	if v.Sh == nil || *v.Sh == "" {
+		return "", nil
+	}
+
 	if c.dynamicCache == nil {
 		c.dynamicCache = make(map[string]string, 30)
 	}
-	if result, ok := c.dynamicCache[v.Sh]; ok {
+	if result, ok := c.dynamicCache[*v.Sh]; ok {
 		return result, nil
 	}
 
@@ -151,10 +155,11 @@ func (c *Compiler) HandleDynamicVar(v ast.Var, dir string) (string, error) {
 
 	var stdout bytes.Buffer
 	opts := &execext.RunCommandOptions{
-		Command: v.Sh,
+		Command: *v.Sh,
 		Dir:     dir,
 		Stdout:  &stdout,
 		Stderr:  c.Logger.Stderr,
+		Env:     e,
 	}
 	if err := execext.RunCommand(context.Background(), opts); err != nil {
 		return "", fmt.Errorf(`task: Command "%s" failed: %s`, opts.Command, err)
@@ -165,13 +170,13 @@ func (c *Compiler) HandleDynamicVar(v ast.Var, dir string) (string, error) {
 	result := strings.TrimSuffix(stdout.String(), "\r\n")
 	result = strings.TrimSuffix(result, "\n")
 
-	c.dynamicCache[v.Sh] = result
-	c.Logger.VerboseErrf(logger.Magenta, "task: dynamic variable: %q result: %q\n", v.Sh, result)
+	c.dynamicCache[*v.Sh] = result
+	c.Logger.VerboseErrf(logger.Magenta, "task: dynamic variable: %q result: %q\n", *v.Sh, result)
 
 	return result, nil
 }
 
-// ResetCache clear the dymanic variables cache
+// ResetCache clear the dynamic variables cache
 func (c *Compiler) ResetCache() {
 	c.muDynamicCache.Lock()
 	defer c.muDynamicCache.Unlock()
@@ -180,15 +185,22 @@ func (c *Compiler) ResetCache() {
 }
 
 func (c *Compiler) getSpecialVars(t *ast.Task, call *ast.Call) (map[string]string, error) {
-	return map[string]string{
-		"TASK":             t.Task,
-		"ALIAS":            call.Task,
+	allVars := map[string]string{
 		"TASK_EXE":         filepath.ToSlash(os.Args[0]),
 		"ROOT_TASKFILE":    filepathext.SmartJoin(c.Dir, c.Entrypoint),
 		"ROOT_DIR":         c.Dir,
-		"TASKFILE":         t.Location.Taskfile,
-		"TASKFILE_DIR":     filepath.Dir(t.Location.Taskfile),
 		"USER_WORKING_DIR": c.UserWorkingDir,
 		"TASK_VERSION":     version.GetVersion(),
-	}, nil
+	}
+	if t != nil {
+		allVars["TASK"] = t.Task
+		allVars["TASK_DIR"] = filepathext.SmartJoin(c.Dir, t.Dir)
+		allVars["TASKFILE"] = t.Location.Taskfile
+		allVars["TASKFILE_DIR"] = filepath.Dir(t.Location.Taskfile)
+	}
+	if call != nil {
+		allVars["ALIAS"] = call.Task
+	}
+
+	return allVars, nil
 }

internal/compiler/env.go

@@ -10,7 +10,7 @@ import (
 // GetEnviron the all return all environment variables encapsulated on a
 // ast.Vars
 func GetEnviron() *ast.Vars {
-	m := &ast.Vars{}
+	m := ast.NewVars()
 	for _, e := range os.Environ() {
 		keyVal := strings.SplitN(e, "=", 2)
 		key, val := keyVal[0], keyVal[1]

internal/deepcopy/deepcopy.go

@@ -2,6 +2,8 @@ package deepcopy
 
 import (
 	"reflect"
+
+	"github.com/elliotchance/orderedmap/v2"
 )
 
 type Copier[T any] interface {
@@ -38,6 +40,21 @@ func Map[K comparable, V any](orig map[K]V) map[K]V {
 	return c
 }
 
+func OrderedMap[K comparable, V any](orig *orderedmap.OrderedMap[K, V]) *orderedmap.OrderedMap[K, V] {
+	if orig.Len() == 0 {
+		return orderedmap.NewOrderedMap[K, V]()
+	}
+	c := orderedmap.NewOrderedMap[K, V]()
+	for pair := orig.Front(); pair != nil; pair = pair.Next() {
+		if copyable, ok := any(pair.Value).(Copier[V]); ok {
+			c.Set(pair.Key, copyable.DeepCopy())
+		} else {
+			c.Set(pair.Key, pair.Value)
+		}
+	}
+	return c
+}
+
 // TraverseStringsFunc runs the given function on every string in the given
 // value by traversing it recursively. If the given value is a string, the
 // function will run on a copy of the string and return it. If the value is a

internal/env/env.go

@@ -8,16 +8,24 @@ import (
 	"github.com/go-task/task/v3/taskfile/ast"
 )
 
+const taskVarPrefix = "TASK_"
+
 func Get(t *ast.Task) []string {
 	if t.Env == nil {
 		return nil
 	}
+
+	return GetFromVars(t.Env)
+}
+
+func GetFromVars(env *ast.Vars) []string {
 	environ := os.Environ()
-	for k, v := range t.Env.ToCacheMap() {
+
+	for k, v := range env.ToCacheMap() {
 		if !isTypeAllowed(v) {
 			continue
 		}
-		if !experiments.EnvPrecedence.Enabled {
+		if !experiments.EnvPrecedence.Enabled() {
 			if _, alreadySet := os.LookupEnv(k); alreadySet {
 				continue
 			}
@@ -36,3 +44,7 @@ func isTypeAllowed(v any) bool {
 		return false
 	}
 }
+
+func GetTaskEnv(key string) string {
+	return os.Getenv(taskVarPrefix + key)
+}

internal/execext/exec.go

@@ -2,7 +2,6 @@ package execext
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"io"
 	"os"
@@ -14,6 +13,8 @@ import (
 	"mvdan.cc/sh/v3/interp"
 	"mvdan.cc/sh/v3/shell"
 	"mvdan.cc/sh/v3/syntax"
+
+	"github.com/go-task/task/v3/errors"
 )
 
 // RunCommandOptions is the options for the RunCommand func

internal/experiments/errors.go

@@ -0,0 +1,32 @@
+package experiments
+
+import (
+	"fmt"
+	"strings"
+)
+
+type InvalidValueError struct {
+	Name          string
+	AllowedValues []string
+	Value         string
+}
+
+func (err InvalidValueError) Error() string {
+	return fmt.Sprintf(
+		"task: Experiment %q has an invalid value %q (allowed values: %s)",
+		err.Name,
+		err.Value,
+		strings.Join(err.AllowedValues, ", "),
+	)
+}
+
+type InactiveError struct {
+	Name string
+}
+
+func (err InactiveError) Error() string {
+	return fmt.Sprintf(
+		"task: Experiment %q is inactive and cannot be enabled",
+		err.Name,
+	)
+}

internal/experiments/experiment.go

@@ -0,0 +1,56 @@
+package experiments
+
+import (
+	"fmt"
+	"slices"
+)
+
+type Experiment struct {
+	Name          string   // The name of the experiment.
+	AllowedValues []string // The values that can enable this experiment.
+	Value         string   // The version of the experiment that is enabled.
+}
+
+// New creates a new experiment with the given name and sets the values that can
+// enable it.
+func New(xName string, allowedValues ...string) Experiment {
+	value := getEnv(xName)
+	x := Experiment{
+		Name:          xName,
+		AllowedValues: allowedValues,
+		Value:         value,
+	}
+	xList = append(xList, x)
+	return x
+}
+
+func (x *Experiment) Enabled() bool {
+	return slices.Contains(x.AllowedValues, x.Value)
+}
+
+func (x *Experiment) Active() bool {
+	return len(x.AllowedValues) > 0
+}
+
+func (x Experiment) Valid() error {
+	if !x.Active() && x.Value != "" {
+		return &InactiveError{
+			Name: x.Name,
+		}
+	}
+	if !x.Enabled() && x.Value != "" {
+		return &InvalidValueError{
+			Name:          x.Name,
+			AllowedValues: x.AllowedValues,
+			Value:         x.Value,
+		}
+	}
+	return nil
+}
+
+func (x Experiment) String() string {
+	if x.Enabled() {
+		return fmt.Sprintf("on (%s)", x.Value)
+	}
+	return "off"
+}

internal/experiments/experiment_test.go

@@ -0,0 +1,74 @@
+package experiments_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/go-task/task/v3/internal/experiments"
+)
+
+func TestNew(t *testing.T) {
+	const (
+		exampleExperiment    = "EXAMPLE"
+		exampleExperimentEnv = "TASK_X_EXAMPLE"
+	)
+	tests := []struct {
+		name          string
+		allowedValues []string
+		value         string
+		wantEnabled   bool
+		wantActive    bool
+		wantValid     error
+	}{
+		{
+			name:        `[] allowed, value=""`,
+			wantEnabled: false,
+			wantActive:  false,
+		},
+		{
+			name:        `[] allowed, value="1"`,
+			value:       "1",
+			wantEnabled: false,
+			wantActive:  false,
+			wantValid: &experiments.InactiveError{
+				Name: exampleExperiment,
+			},
+		},
+		{
+			name:          `[1] allowed, value=""`,
+			allowedValues: []string{"1"},
+			wantEnabled:   false,
+			wantActive:    true,
+		},
+		{
+			name:          `[1] allowed, value="1"`,
+			allowedValues: []string{"1"},
+			value:         "1",
+			wantEnabled:   true,
+			wantActive:    true,
+		},
+		{
+			name:          `[1] allowed, value="2"`,
+			allowedValues: []string{"1"},
+			value:         "2",
+			wantEnabled:   false,
+			wantActive:    true,
+			wantValid: &experiments.InvalidValueError{
+				Name:          exampleExperiment,
+				AllowedValues: []string{"1"},
+				Value:         "2",
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Setenv(exampleExperimentEnv, tt.value)
+			x := experiments.New(exampleExperiment, tt.allowedValues...)
+			assert.Equal(t, exampleExperiment, x.Name)
+			assert.Equal(t, tt.wantEnabled, x.Enabled())
+			assert.Equal(t, tt.wantActive, x.Active())
+			assert.Equal(t, tt.wantValid, x.Valid())
+		})
+	}
+}

internal/experiments/experiments.go

@@ -2,28 +2,17 @@ package experiments
 
 import (
 	"fmt"
-	"io"
 	"os"
 	"path/filepath"
-	"slices"
 	"strings"
 
-	"github.com/Ladicle/tabwriter"
 	"github.com/joho/godotenv"
 	"github.com/spf13/pflag"
-
-	"github.com/go-task/task/v3/internal/logger"
 )
 
 const envPrefix = "TASK_X_"
 
-type Experiment struct {
-	Name    string
-	Enabled bool
-	Value   string
-}
-
-// A list of experiments.
+// A set of experiments that can be enabled or disabled.
 var (
 	GentleForce     Experiment
 	RemoteTaskfiles Experiment
@@ -32,32 +21,31 @@ var (
 	EnvPrecedence   Experiment
 )
 
+// An internal list of all the initialized experiments used for iterating.
+var xList []Experiment
+
 func init() {
 	readDotEnv()
-	GentleForce = New("GENTLE_FORCE")
-	RemoteTaskfiles = New("REMOTE_TASKFILES")
-	AnyVariables = New("ANY_VARIABLES", "1", "2")
+	GentleForce = New("GENTLE_FORCE", "1")
+	RemoteTaskfiles = New("REMOTE_TASKFILES", "1")
+	AnyVariables = New("ANY_VARIABLES")
 	MapVariables = New("MAP_VARIABLES", "1", "2")
-	EnvPrecedence = New("ENV_PRECEDENCE")
+	EnvPrecedence = New("ENV_PRECEDENCE", "1")
 }
 
-func New(xName string, enabledValues ...string) Experiment {
-	if len(enabledValues) == 0 {
-		enabledValues = []string{"1"}
-	}
-	value := getEnv(xName)
-	return Experiment{
-		Name:    xName,
-		Enabled: slices.Contains(enabledValues, value),
-		Value:   value,
+// Validate checks if any experiments have been enabled while being inactive.
+// If one is found, the function returns an error.
+func Validate() error {
+	for _, x := range List() {
+		if err := x.Valid(); err != nil {
+			return err
+		}
 	}
+	return nil
 }
 
-func (x Experiment) String() string {
-	if x.Enabled {
-		return fmt.Sprintf("on (%s)", x.Value)
-	}
-	return "off"
+func List() []Experiment {
+	return xList
 }
 
 func getEnv(xName string) string {
@@ -95,18 +83,3 @@ func readDotEnv() {
 		}
 	}
 }
-
-func printExperiment(w io.Writer, l *logger.Logger, x Experiment) {
-	l.FOutf(w, logger.Yellow, "* ")
-	l.FOutf(w, logger.Green, x.Name)
-	l.FOutf(w, logger.Default, ": \t%s\n", x.String())
-}
-
-func List(l *logger.Logger) error {
-	w := tabwriter.NewWriter(os.Stdout, 0, 8, 0, ' ', 0)
-	printExperiment(w, l, GentleForce)
-	printExperiment(w, l, RemoteTaskfiles)
-	printExperiment(w, l, MapVariables)
-	printExperiment(w, l, EnvPrecedence)
-	return w.Flush()
-}

internal/fingerprint/sources_checksum_test.go

@@ -7,6 +7,8 @@ import (
 )
 
 func TestNormalizeFilename(t *testing.T) {
+	t.Parallel()
+
 	tests := []struct {
 		In, Out string
 	}{

internal/fingerprint/task_test.go

@@ -26,6 +26,8 @@ import (
 // | false             | true               | false              |
 // | false             | false              | false              |
 func TestIsTaskUpToDate(t *testing.T) {
+	t.Parallel()
+
 	tests := []struct {
 		name                    string
 		task                    *ast.Task
@@ -150,6 +152,8 @@ func TestIsTaskUpToDate(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
 			mockStatusChecker := mocks.NewStatusCheckable(t)
 			if tt.setupMockStatusChecker != nil {
 				tt.setupMockStatusChecker(mockStatusChecker)

internal/flags/flags.go

@@ -1,13 +1,16 @@
 package flags
 
 import (
-	"errors"
+	"cmp"
 	"log"
 	"os"
+	"strconv"
 	"time"
 
 	"github.com/spf13/pflag"
 
+	"github.com/go-task/task/v3/errors"
+	"github.com/go-task/task/v3/internal/env"
 	"github.com/go-task/task/v3/internal/experiments"
 	"github.com/go-task/task/v3/taskfile/ast"
 )
@@ -77,7 +80,10 @@ func init() {
 		log.Print(usage)
 		pflag.PrintDefaults()
 	}
-
+	offline, err := strconv.ParseBool(cmp.Or(env.GetTaskEnv("OFFLINE"), "false"))
+	if err != nil {
+		offline = false
+	}
 	pflag.BoolVar(&Version, "version", false, "Show Task version.")
 	pflag.BoolVarP(&Help, "help", "h", false, "Shows Task usage.")
 	pflag.BoolVarP(&Init, "init", "i", false, "Creates a new Taskfile.yml in the current folder.")
@@ -104,13 +110,13 @@ func init() {
 	pflag.StringVar(&Output.Group.End, "output-group-end", "", "Message template to print after a task's grouped output.")
 	pflag.BoolVar(&Output.Group.ErrorOnly, "output-group-error-only", false, "Swallow output from successful tasks.")
 	pflag.BoolVarP(&Color, "color", "c", true, "Colored output. Enabled by default. Set flag to false or use NO_COLOR=1 to disable.")
-	pflag.IntVarP(&Concurrency, "concurrency", "C", 0, "Limit number tasks to run concurrently.")
+	pflag.IntVarP(&Concurrency, "concurrency", "C", 0, "Limit number of tasks to run concurrently.")
 	pflag.DurationVarP(&Interval, "interval", "I", 0, "Interval to watch for changes.")
 	pflag.BoolVarP(&Global, "global", "g", false, "Runs global Taskfile, from $HOME/{T,t}askfile.{yml,yaml}.")
 	pflag.BoolVar(&Experiments, "experiments", false, "Lists all the available experiments and whether or not they are enabled.")
 
 	// Gentle force experiment will override the force flag and add a new force-all flag
-	if experiments.GentleForce.Enabled {
+	if experiments.GentleForce.Enabled() {
 		pflag.BoolVarP(&Force, "force", "f", false, "Forces execution of the directly called task.")
 		pflag.BoolVar(&ForceAll, "force-all", false, "Forces execution of the called task and all its dependant tasks.")
 	} else {
@@ -118,9 +124,9 @@ func init() {
 	}
 
 	// Remote Taskfiles experiment will adds the "download" and "offline" flags
-	if experiments.RemoteTaskfiles.Enabled {
+	if experiments.RemoteTaskfiles.Enabled() {
 		pflag.BoolVar(&Download, "download", false, "Downloads a cached version of a remote Taskfile.")
-		pflag.BoolVar(&Offline, "offline", false, "Forces Task to only use local or cached Taskfiles.")
+		pflag.BoolVar(&Offline, "offline", offline, "Forces Task to only use local or cached Taskfiles.")
 		pflag.DurationVar(&Timeout, "timeout", time.Second*10, "Timeout for downloading remote Taskfiles.")
 		pflag.BoolVar(&ClearCache, "clear-cache", false, "Clear the remote cache.")
 	}

internal/logger/logger.go

@@ -8,9 +8,12 @@ import (
 	"strconv"
 	"strings"
 
+	"github.com/Ladicle/tabwriter"
 	"github.com/fatih/color"
 
 	"github.com/go-task/task/v3/errors"
+	"github.com/go-task/task/v3/internal/env"
+	"github.com/go-task/task/v3/internal/experiments"
 	"github.com/go-task/task/v3/internal/term"
 )
 
@@ -19,70 +22,86 @@ var (
 	ErrNoTerminal      = errors.New("no terminal")
 )
 
+var (
+	attrsReset       = envColor("COLOR_RESET", color.Reset)
+	attrsFgBlue      = envColor("COLOR_BLUE", color.FgBlue)
+	attrsFgGreen     = envColor("COLOR_GREEN", color.FgGreen)
+	attrsFgCyan      = envColor("COLOR_CYAN", color.FgCyan)
+	attrsFgYellow    = envColor("COLOR_YELLOW", color.FgYellow)
+	attrsFgMagenta   = envColor("COLOR_MAGENTA", color.FgMagenta)
+	attrsFgRed       = envColor("COLOR_RED", color.FgRed)
+	attrsFgHiBlue    = envColor("COLOR_BRIGHT_BLUE", color.FgHiBlue)
+	attrsFgHiGreen   = envColor("COLOR_BRIGHT_GREEN", color.FgHiGreen)
+	attrsFgHiCyan    = envColor("COLOR_BRIGHT_CYAN", color.FgHiCyan)
+	attrsFgHiYellow  = envColor("COLOR_BRIGHT_YELLOW", color.FgHiYellow)
+	attrsFgHiMagenta = envColor("COLOR_BRIGHT_MAGENTA", color.FgHiMagenta)
+	attrsFgHiRed     = envColor("COLOR_BRIGHT_RED", color.FgHiRed)
+)
+
 type (
 	Color     func() PrintFunc
 	PrintFunc func(io.Writer, string, ...any)
 )
 
 func Default() PrintFunc {
-	return color.New(envColor("TASK_COLOR_RESET", color.Reset)...).FprintfFunc()
+	return color.New(attrsReset...).FprintfFunc()
 }
 
 func Blue() PrintFunc {
-	return color.New(envColor("TASK_COLOR_BLUE", color.FgBlue)...).FprintfFunc()
+	return color.New(attrsFgBlue...).FprintfFunc()
 }
 
 func Green() PrintFunc {
-	return color.New(envColor("TASK_COLOR_GREEN", color.FgGreen)...).FprintfFunc()
+	return color.New(attrsFgGreen...).FprintfFunc()
 }
 
 func Cyan() PrintFunc {
-	return color.New(envColor("TASK_COLOR_CYAN", color.FgCyan)...).FprintfFunc()
+	return color.New(attrsFgCyan...).FprintfFunc()
 }
 
 func Yellow() PrintFunc {
-	return color.New(envColor("TASK_COLOR_YELLOW", color.FgYellow)...).FprintfFunc()
+	return color.New(attrsFgYellow...).FprintfFunc()
 }
 
 func Magenta() PrintFunc {
-	return color.New(envColor("TASK_COLOR_MAGENTA", color.FgMagenta)...).FprintfFunc()
+	return color.New(attrsFgMagenta...).FprintfFunc()
 }
 
 func Red() PrintFunc {
-	return color.New(envColor("TASK_COLOR_RED", color.FgRed)...).FprintfFunc()
+	return color.New(attrsFgRed...).FprintfFunc()
 }
 
 func BrightBlue() PrintFunc {
-	return color.New(envColor("TASK_COLOR_BRIGHT_BLUE", color.FgHiBlue)...).FprintfFunc()
+	return color.New(attrsFgHiBlue...).FprintfFunc()
 }
 
 func BrightGreen() PrintFunc {
-	return color.New(envColor("TASK_COLOR_BRIGHT_GREEN", color.FgHiGreen)...).FprintfFunc()
+	return color.New(attrsFgHiGreen...).FprintfFunc()
 }
 
 func BrightCyan() PrintFunc {
-	return color.New(envColor("TASK_COLOR_BRIGHT_CYAN", color.FgHiCyan)...).FprintfFunc()
+	return color.New(attrsFgHiCyan...).FprintfFunc()
 }
 
 func BrightYellow() PrintFunc {
-	return color.New(envColor("TASK_COLOR_BRIGHT_YELLOW", color.FgHiYellow)...).FprintfFunc()
+	return color.New(attrsFgHiYellow...).FprintfFunc()
 }
 
 func BrightMagenta() PrintFunc {
-	return color.New(envColor("TASK_COLOR_BRIGHT_MAGENTA", color.FgHiMagenta)...).FprintfFunc()
+	return color.New(attrsFgHiMagenta...).FprintfFunc()
 }
 
 func BrightRed() PrintFunc {
-	return color.New(envColor("TASK_COLOR_BRIGHT_RED", color.FgHiRed)...).FprintfFunc()
+	return color.New(attrsFgHiRed...).FprintfFunc()
 }
 
-func envColor(env string, defaultColor color.Attribute) []color.Attribute {
+func envColor(name string, defaultColor color.Attribute) []color.Attribute {
 	if os.Getenv("FORCE_COLOR") != "" {
 		color.NoColor = false
 	}
 
 	// Fetch the environment variable
-	override := os.Getenv(env)
+	override := env.GetTaskEnv(name)
 
 	// First, try splitting the string by commas (RGB shortcut syntax) and if it
 	// matches, then prepend the 256-color foreground escape sequence.
@@ -195,3 +214,16 @@ func (l *Logger) Prompt(color Color, prompt string, defaultValue string, continu
 
 	return nil
 }
+
+func (l *Logger) PrintExperiments() error {
+	w := tabwriter.NewWriter(l.Stdout, 0, 8, 0, ' ', 0)
+	for _, x := range experiments.List() {
+		if !x.Active() {
+			continue
+		}
+		l.FOutf(w, Yellow, "* ")
+		l.FOutf(w, Green, x.Name)
+		l.FOutf(w, Default, ": \t%s\n", x.String())
+	}
+	return w.Flush()
+}

internal/omap/orderedmap.go

@@ -1,164 +0,0 @@
-package omap
-
-import (
-	"cmp"
-	"fmt"
-	"slices"
-
-	"gopkg.in/yaml.v3"
-
-	"github.com/go-task/task/v3/internal/deepcopy"
-	"github.com/go-task/task/v3/internal/exp"
-)
-
-// An OrderedMap is a wrapper around a regular map that maintains an ordered
-// list of the map's keys. This allows you to run deterministic and ordered
-// operations on the map such as printing/serializing/iterating.
-type OrderedMap[K cmp.Ordered, V any] struct {
-	s []K
-	m map[K]V
-}
-
-// New will create a new OrderedMap of the given type and return it.
-func New[K cmp.Ordered, V any]() OrderedMap[K, V] {
-	return OrderedMap[K, V]{
-		s: make([]K, 0),
-		m: make(map[K]V),
-	}
-}
-
-// FromMap will create a new OrderedMap from the given map. Since Golang maps
-// are unordered, the order of the created OrderedMap will be random.
-func FromMap[K cmp.Ordered, V any](m map[K]V) OrderedMap[K, V] {
-	om := New[K, V]()
-	om.m = m
-	om.s = exp.Keys(m)
-	return om
-}
-
-func FromMapWithOrder[K cmp.Ordered, V any](m map[K]V, order []K) OrderedMap[K, V] {
-	om := New[K, V]()
-	if len(m) != len(order) {
-		panic("length of map and order must be equal")
-	}
-	om.m = m
-	om.s = order
-	for key := range om.m {
-		if !slices.Contains(om.s, key) {
-			panic("order keys must match map keys")
-		}
-	}
-	return om
-}
-
-// Len will return the number of items in the map.
-func (om *OrderedMap[K, V]) Len() int {
-	return len(om.s)
-}
-
-// Set will set the value for a given key.
-func (om *OrderedMap[K, V]) Set(key K, value V) {
-	if om.m == nil {
-		om.m = make(map[K]V)
-	}
-	if _, ok := om.m[key]; !ok {
-		om.s = append(om.s, key)
-	}
-	om.m[key] = value
-}
-
-// Get will return the value for a given key.
-// If the key does not exist, it will return the zero value of the value type.
-func (om *OrderedMap[K, V]) Get(key K) V {
-	value, ok := om.m[key]
-	if !ok {
-		var zero V
-		return zero
-	}
-	return value
-}
-
-// Exists will return whether or not the given key exists.
-func (om *OrderedMap[K, V]) Exists(key K) bool {
-	_, ok := om.m[key]
-	return ok
-}
-
-// Sort will sort the map.
-func (om *OrderedMap[K, V]) Sort() {
-	slices.Sort(om.s)
-}
-
-// SortFunc will sort the map using the given function.
-func (om *OrderedMap[K, V]) SortFunc(less func(i, j K) int) {
-	slices.SortFunc(om.s, less)
-}
-
-// Keys will return a slice of the map's keys in order.
-func (om *OrderedMap[K, V]) Keys() []K {
-	return om.s
-}
-
-// Values will return a slice of the map's values in order.
-func (om *OrderedMap[K, V]) Values() []V {
-	var values []V
-	for _, key := range om.s {
-		values = append(values, om.m[key])
-	}
-	return values
-}
-
-// Range will iterate over the map and call the given function for each key/value.
-func (om *OrderedMap[K, V]) Range(fn func(key K, value V) error) error {
-	for _, key := range om.s {
-		if err := fn(key, om.m[key]); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-// Merge merges the given Vars into the caller one
-func (om *OrderedMap[K, V]) Merge(other OrderedMap[K, V]) {
-	// nolint: errcheck
-	other.Range(func(key K, value V) error {
-		om.Set(key, value)
-		return nil
-	})
-}
-
-func (om *OrderedMap[K, V]) DeepCopy() OrderedMap[K, V] {
-	return OrderedMap[K, V]{
-		s: deepcopy.Slice(om.s),
-		m: deepcopy.Map(om.m),
-	}
-}
-
-func (om *OrderedMap[K, V]) UnmarshalYAML(node *yaml.Node) error {
-	switch node.Kind {
-	// Even numbers contain the keys
-	// Odd numbers contain the values
-	case yaml.MappingNode:
-		for i := 0; i < len(node.Content); i += 2 {
-			// Decode the key
-			keyNode := node.Content[i]
-			var k K
-			if err := keyNode.Decode(&k); err != nil {
-				return err
-			}
-
-			// Decode the value
-			valueNode := node.Content[i+1]
-			var v V
-			if err := valueNode.Decode(&v); err != nil {
-				return err
-			}
-
-			// Set the key and value
-			om.Set(k, v)
-		}
-		return nil
-	}
-
-	return fmt.Errorf("yaml: line %d: cannot unmarshal %s into variables", node.Line, node.ShortTag())
-}

internal/omap/orderedmap_test.go

@@ -1,121 +0,0 @@
-package omap
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"gopkg.in/yaml.v3"
-)
-
-func TestFromMap(t *testing.T) {
-	m := map[int]string{3: "three", 1: "one", 2: "two"}
-	om := FromMap(m)
-	assert.Len(t, om.m, 3)
-	assert.Len(t, om.s, 3)
-	assert.ElementsMatch(t, []int{1, 2, 3}, om.s)
-	for key, value := range m {
-		assert.Equal(t, om.Get(key), value)
-	}
-}
-
-func TestSetGetExists(t *testing.T) {
-	om := New[int, string]()
-	assert.False(t, om.Exists(1))
-	assert.Equal(t, "", om.Get(1))
-	om.Set(1, "one")
-	assert.True(t, om.Exists(1))
-	assert.Equal(t, "one", om.Get(1))
-}
-
-func TestSort(t *testing.T) {
-	om := New[int, string]()
-	om.Set(3, "three")
-	om.Set(1, "one")
-	om.Set(2, "two")
-	om.Sort()
-	assert.Equal(t, []int{1, 2, 3}, om.s)
-}
-
-func TestSortFunc(t *testing.T) {
-	om := New[int, string]()
-	om.Set(3, "three")
-	om.Set(1, "one")
-	om.Set(2, "two")
-	om.SortFunc(func(a, b int) int {
-		return b - a
-	})
-	assert.Equal(t, []int{3, 2, 1}, om.s)
-}
-
-func TestKeysValues(t *testing.T) {
-	om := New[int, string]()
-	om.Set(3, "three")
-	om.Set(1, "one")
-	om.Set(2, "two")
-	assert.Equal(t, []int{3, 1, 2}, om.Keys())
-	assert.Equal(t, []string{"three", "one", "two"}, om.Values())
-}
-
-func Range(t *testing.T) {
-	om := New[int, string]()
-	om.Set(3, "three")
-	om.Set(1, "one")
-	om.Set(2, "two")
-
-	expectedKeys := []int{3, 1, 2}
-	expectedValues := []string{"three", "one", "two"}
-
-	keys := make([]int, 0, len(expectedKeys))
-	values := make([]string, 0, len(expectedValues))
-
-	err := om.Range(func(key int, value string) error {
-		keys = append(keys, key)
-		values = append(values, value)
-		return nil
-	})
-
-	assert.NoError(t, err)
-	assert.ElementsMatch(t, expectedKeys, keys)
-	assert.ElementsMatch(t, expectedValues, values)
-}
-
-func TestOrderedMapMerge(t *testing.T) {
-	om1 := New[string, int]()
-	om1.Set("a", 1)
-	om1.Set("b", 2)
-
-	om2 := New[string, int]()
-	om2.Set("b", 3)
-	om2.Set("c", 4)
-
-	om1.Merge(om2)
-
-	expectedKeys := []string{"a", "b", "c"}
-	expectedValues := []int{1, 3, 4}
-
-	assert.Equal(t, len(expectedKeys), len(om1.s))
-	assert.Equal(t, len(expectedKeys), len(om1.m))
-
-	for i, key := range expectedKeys {
-		assert.True(t, om1.Exists(key))
-		assert.Equal(t, expectedValues[i], om1.Get(key))
-	}
-}
-
-func TestUnmarshalYAML(t *testing.T) {
-	yamlString := `
-3: three
-1: one
-2: two
-`
-	var om OrderedMap[int, string]
-	err := yaml.Unmarshal([]byte(yamlString), &om)
-	require.NoError(t, err)
-
-	expectedKeys := []int{3, 1, 2}
-	expectedValues := []string{"three", "one", "two"}
-
-	assert.Equal(t, expectedKeys, om.Keys())
-	assert.Equal(t, expectedValues, om.Values())
-}

internal/output/output_test.go

@@ -12,13 +12,14 @@ import (
 	"github.com/stretchr/testify/require"
 
 	"github.com/go-task/task/v3/internal/logger"
-	"github.com/go-task/task/v3/internal/omap"
 	"github.com/go-task/task/v3/internal/output"
 	"github.com/go-task/task/v3/internal/templater"
 	"github.com/go-task/task/v3/taskfile/ast"
 )
 
 func TestInterleaved(t *testing.T) {
+	t.Parallel()
+
 	var b bytes.Buffer
 	var o output.Output = output.Interleaved{}
 	w, _, _ := o.WrapWriter(&b, io.Discard, "", nil)
@@ -30,6 +31,8 @@ func TestInterleaved(t *testing.T) {
 }
 
 func TestGroup(t *testing.T) {
+	t.Parallel()
+
 	var b bytes.Buffer
 	var o output.Output = output.Group{}
 	stdOut, stdErr, cleanup := o.WrapWriter(&b, io.Discard, "", nil)
@@ -48,12 +51,15 @@ func TestGroup(t *testing.T) {
 }
 
 func TestGroupWithBeginEnd(t *testing.T) {
+	t.Parallel()
+
 	tmpl := templater.Cache{
-		Vars: &ast.Vars{
-			OrderedMap: omap.FromMap(map[string]ast.Var{
-				"VAR1": {Value: "example-value"},
-			}),
-		},
+		Vars: ast.NewVars(
+			&ast.VarElement{
+				Key:   "VAR1",
+				Value: ast.Var{Value: "example-value"},
+			},
+		),
 	}
 
 	var o output.Output = output.Group{
@@ -61,6 +67,8 @@ func TestGroupWithBeginEnd(t *testing.T) {
 		End:   "::endgroup::",
 	}
 	t.Run("simple", func(t *testing.T) {
+		t.Parallel()
+
 		var b bytes.Buffer
 		w, _, cleanup := o.WrapWriter(&b, io.Discard, "", &tmpl)
 
@@ -72,6 +80,8 @@ func TestGroupWithBeginEnd(t *testing.T) {
 		assert.Equal(t, "::group::example-value\nfoo\nbar\nbaz\n::endgroup::\n", b.String())
 	})
 	t.Run("no output", func(t *testing.T) {
+		t.Parallel()
+
 		var b bytes.Buffer
 		_, _, cleanup := o.WrapWriter(&b, io.Discard, "", &tmpl)
 		require.NoError(t, cleanup(nil))
@@ -80,6 +90,8 @@ func TestGroupWithBeginEnd(t *testing.T) {
 }
 
 func TestGroupErrorOnlySwallowsOutputOnNoError(t *testing.T) {
+	t.Parallel()
+
 	var b bytes.Buffer
 	var o output.Output = output.Group{
 		ErrorOnly: true,
@@ -94,6 +106,8 @@ func TestGroupErrorOnlySwallowsOutputOnNoError(t *testing.T) {
 }
 
 func TestGroupErrorOnlyShowsOutputOnError(t *testing.T) {
+	t.Parallel()
+
 	var b bytes.Buffer
 	var o output.Output = output.Group{
 		ErrorOnly: true,
@@ -107,7 +121,7 @@ func TestGroupErrorOnlyShowsOutputOnError(t *testing.T) {
 	assert.Equal(t, "std-out\nstd-err\n", b.String())
 }
 
-func TestPrefixed(t *testing.T) {
+func TestPrefixed(t *testing.T) { //nolint:paralleltest // cannot run in parallel
 	var b bytes.Buffer
 	l := &logger.Logger{
 		Color: false,
@@ -116,7 +130,7 @@ func TestPrefixed(t *testing.T) {
 	var o output.Output = output.NewPrefixed(l)
 	w, _, cleanup := o.WrapWriter(&b, io.Discard, "prefix", nil)
 
-	t.Run("simple use cases", func(t *testing.T) {
+	t.Run("simple use cases", func(t *testing.T) { //nolint:paralleltest // cannot run in parallel
 		b.Reset()
 
 		fmt.Fprintln(w, "foo\nbar")
@@ -126,7 +140,7 @@ func TestPrefixed(t *testing.T) {
 		require.NoError(t, cleanup(nil))
 	})
 
-	t.Run("multiple writes for a single line", func(t *testing.T) {
+	t.Run("multiple writes for a single line", func(t *testing.T) { //nolint:paralleltest // cannot run in parallel
 		b.Reset()
 
 		for _, char := range []string{"T", "e", "s", "t", "!"} {
@@ -140,6 +154,8 @@ func TestPrefixed(t *testing.T) {
 }
 
 func TestPrefixedWithColor(t *testing.T) {
+	t.Parallel()
+
 	color.NoColor = false
 
 	var b bytes.Buffer
@@ -155,6 +171,8 @@ func TestPrefixedWithColor(t *testing.T) {
 	}
 
 	t.Run("colors should loop", func(t *testing.T) {
+		t.Parallel()
+
 		for i, w := range writers {
 			b.Reset()
 
@@ -164,7 +182,11 @@ func TestPrefixedWithColor(t *testing.T) {
 			l.FOutf(&prefix, color, fmt.Sprintf("prefix-%d", i))
 
 			fmt.Fprintln(w, "foo\nbar")
-			assert.Equal(t, fmt.Sprintf("[%s] foo\n[%s] bar\n", prefix.String(), prefix.String()), b.String())
+			assert.Equal(
+				t,
+				fmt.Sprintf("[%s] foo\n[%s] bar\n", prefix.String(), prefix.String()),
+				b.String(),
+			)
 		}
 	})
 }

internal/output/prefixed.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"io"
 	"strings"
+	"sync"
 
 	"github.com/go-task/task/v3/internal/logger"
 	"github.com/go-task/task/v3/internal/templater"
@@ -14,20 +15,21 @@ type Prefixed struct {
 	logger  *logger.Logger
 	seen    map[string]uint
 	counter *uint
+	mutex   sync.Mutex
 }
 
-func NewPrefixed(logger *logger.Logger) Prefixed {
+func NewPrefixed(logger *logger.Logger) *Prefixed {
 	var counter uint
 
-	return Prefixed{
+	return &Prefixed{
 		seen:    make(map[string]uint),
 		counter: &counter,
 		logger:  logger,
 	}
 }
 
-func (p Prefixed) WrapWriter(stdOut, _ io.Writer, prefix string, _ *templater.Cache) (io.Writer, io.Writer, CloseFunc) {
-	pw := &prefixWriter{writer: stdOut, prefix: prefix, prefixed: &p}
+func (p *Prefixed) WrapWriter(stdOut, _ io.Writer, prefix string, _ *templater.Cache) (io.Writer, io.Writer, CloseFunc) {
+	pw := &prefixWriter{writer: stdOut, prefix: prefix, prefixed: p}
 	return pw, pw, func(error) error { return pw.close() }
 }
 
@@ -85,6 +87,9 @@ func (pw *prefixWriter) writeLine(line string) error {
 		line += "\n"
 	}
 
+	defer pw.prefixed.mutex.Unlock()
+	pw.prefixed.mutex.Lock()
+
 	idx, ok := pw.prefixed.seen[pw.prefix]
 
 	if !ok {

internal/sort/sorter_test.go

@@ -9,6 +9,8 @@ import (
 )
 
 func TestAlphaNumericWithRootTasksFirst_Sort(t *testing.T) {
+	t.Parallel()
+
 	task1 := &ast.Task{Task: "task1"}
 	task2 := &ast.Task{Task: "task2"}
 	task3 := &ast.Task{Task: "ns1:task3"}
@@ -40,6 +42,8 @@ func TestAlphaNumericWithRootTasksFirst_Sort(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
 			s := &AlphaNumericWithRootTasksFirst{}
 			s.Sort(tt.tasks)
 			assert.Equal(t, tt.want, tt.tasks)
@@ -48,6 +52,8 @@ func TestAlphaNumericWithRootTasksFirst_Sort(t *testing.T) {
 }
 
 func TestAlphaNumeric_Sort(t *testing.T) {
+	t.Parallel()
+
 	task1 := &ast.Task{Task: "task1"}
 	task2 := &ast.Task{Task: "task2"}
 	task3 := &ast.Task{Task: "ns1:task3"}
@@ -69,6 +75,8 @@ func TestAlphaNumeric_Sort(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
 			s := &AlphaNumeric{}
 			s.Sort(tt.tasks)
 			assert.Equal(t, tt.tasks, tt.want)

internal/summary/summary.go

@@ -10,7 +10,9 @@ import (
 func PrintTasks(l *logger.Logger, t *ast.Taskfile, c []*ast.Call) {
 	for i, call := range c {
 		PrintSpaceBetweenSummaries(l, i)
-		PrintTask(l, t.Tasks.Get(call.Task))
+		if task, ok := t.Tasks.Get(call.Task); ok {
+			PrintTask(l, task)
+		}
 	}
 }
 

internal/summary/summary_test.go

@@ -13,6 +13,8 @@ import (
 )
 
 func TestPrintsDependenciesIfPresent(t *testing.T) {
+	t.Parallel()
+
 	buffer, l := createDummyLogger()
 	task := &ast.Task{
 		Deps: []*ast.Dep{
@@ -38,6 +40,8 @@ func createDummyLogger() (*bytes.Buffer, logger.Logger) {
 }
 
 func TestDoesNotPrintDependenciesIfMissing(t *testing.T) {
+	t.Parallel()
+
 	buffer, l := createDummyLogger()
 	task := &ast.Task{
 		Deps: []*ast.Dep{},
@@ -49,6 +53,8 @@ func TestDoesNotPrintDependenciesIfMissing(t *testing.T) {
 }
 
 func TestPrintTaskName(t *testing.T) {
+	t.Parallel()
+
 	buffer, l := createDummyLogger()
 	task := &ast.Task{
 		Task: "my-task-name",
@@ -60,6 +66,8 @@ func TestPrintTaskName(t *testing.T) {
 }
 
 func TestPrintTaskCommandsIfPresent(t *testing.T) {
+	t.Parallel()
+
 	buffer, l := createDummyLogger()
 	task := &ast.Task{
 		Cmds: []*ast.Cmd{
@@ -78,6 +86,8 @@ func TestPrintTaskCommandsIfPresent(t *testing.T) {
 }
 
 func TestDoesNotPrintCommandIfMissing(t *testing.T) {
+	t.Parallel()
+
 	buffer, l := createDummyLogger()
 	task := &ast.Task{
 		Cmds: []*ast.Cmd{},
@@ -89,6 +99,8 @@ func TestDoesNotPrintCommandIfMissing(t *testing.T) {
 }
 
 func TestLayout(t *testing.T) {
+	t.Parallel()
+
 	buffer, l := createDummyLogger()
 	task := &ast.Task{
 		Task:    "sample-task",
@@ -123,6 +135,8 @@ commands:
 }
 
 func TestPrintDescriptionAsFallback(t *testing.T) {
+	t.Parallel()
+
 	buffer, l := createDummyLogger()
 	taskWithoutSummary := &ast.Task{
 		Desc: "description",
@@ -150,13 +164,15 @@ func TestPrintDescriptionAsFallback(t *testing.T) {
 }
 
 func TestPrintAllWithSpaces(t *testing.T) {
+	t.Parallel()
+
 	buffer, l := createDummyLogger()
 
 	t1 := &ast.Task{Task: "t1"}
 	t2 := &ast.Task{Task: "t2"}
 	t3 := &ast.Task{Task: "t3"}
 
-	tasks := ast.Tasks{}
+	tasks := ast.NewTasks()
 	tasks.Set("t1", t1)
 	tasks.Set("t2", t2)
 	tasks.Set("t3", t3)

internal/templater/funcs.go

@@ -17,8 +17,9 @@ var templateFuncs template.FuncMap
 
 func init() {
 	taskFuncs := template.FuncMap{
-		"OS":   func() string { return runtime.GOOS },
-		"ARCH": func() string { return runtime.GOARCH },
+		"OS":     func() string { return runtime.GOOS },
+		"ARCH":   func() string { return runtime.GOARCH },
+		"numCPU": func() int { return runtime.NumCPU() },
 		"catLines": func(s string) string {
 			s = strings.ReplaceAll(s, "\r\n", " ")
 			return strings.ReplaceAll(s, "\n", " ")

internal/templater/templater.go

@@ -140,11 +140,11 @@ func ReplaceVarsWithExtra(vars *ast.Vars, cache *Cache, extra map[string]any) *a
 		return nil
 	}
 
-	var newVars ast.Vars
+	newVars := ast.NewVars()
 	_ = vars.Range(func(k string, v ast.Var) error {
 		newVars.Set(k, ReplaceVarWithExtra(v, cache, extra))
 		return nil
 	})
 
-	return &newVars
+	return newVars
 }

internal/version/version.go

@@ -18,7 +18,9 @@ func init() {
 		if version == "" {
 			version = info.Main.Version
 		}
-		sum = info.Main.Sum
+		if sum == "" {
+			sum = info.Main.Sum
+		}
 	}
 }
 

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@go-task/cli",
-  "version": "3.39.1",
+  "version": "3.41.0",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@go-task/cli",
-  "version": "3.39.1",
+  "version": "3.41.0",
   "description": "A task runner / simpler Make alternative written in Go",
   "scripts": {
     "postinstall": "go-npm install",
@@ -22,7 +22,7 @@
     "build-tool",
     "task-runner"
   ],
-  "author": "Andrey Nering",
+  "author": "The Task authors",
   "license": "MIT",
   "bugs": {
     "url": "https://github.com/go-task/task/issues"

precondition.go

@@ -2,8 +2,8 @@ package task
 
 import (
 	"context"
-	"errors"
 
+	"github.com/go-task/task/v3/errors"
 	"github.com/go-task/task/v3/internal/env"
 	"github.com/go-task/task/v3/internal/execext"
 	"github.com/go-task/task/v3/internal/logger"

requires.go

@@ -1,24 +1,22 @@
 package task
 
 import (
+	"slices"
+
 	"github.com/go-task/task/v3/errors"
 	"github.com/go-task/task/v3/taskfile/ast"
 )
 
-func (e *Executor) areTaskRequiredVarsSet(t *ast.Task, call *ast.Call) error {
+func (e *Executor) areTaskRequiredVarsSet(t *ast.Task) error {
 	if t.Requires == nil || len(t.Requires.Vars) == 0 {
 		return nil
 	}
 
-	vars, err := e.Compiler.GetVariables(t, call)
-	if err != nil {
-		return err
-	}
-
 	var missingVars []string
 	for _, requiredVar := range t.Requires.Vars {
-		if !vars.Exists(requiredVar) {
-			missingVars = append(missingVars, requiredVar)
+		_, ok := t.Vars.Get(requiredVar.Name)
+		if !ok {
+			missingVars = append(missingVars, requiredVar.Name)
 		}
 	}
 
@@ -31,3 +29,33 @@ func (e *Executor) areTaskRequiredVarsSet(t *ast.Task, call *ast.Call) error {
 
 	return nil
 }
+
+func (e *Executor) areTaskRequiredVarsAllowedValuesSet(t *ast.Task) error {
+	if t.Requires == nil || len(t.Requires.Vars) == 0 {
+		return nil
+	}
+
+	var notAllowedValuesVars []errors.NotAllowedVar
+	for _, requiredVar := range t.Requires.Vars {
+		varValue, _ := t.Vars.Get(requiredVar.Name)
+
+		value, isString := varValue.Value.(string)
+		if isString && requiredVar.Enum != nil && !slices.Contains(requiredVar.Enum, value) {
+			notAllowedValuesVars = append(notAllowedValuesVars, errors.NotAllowedVar{
+				Value: value,
+				Enum:  requiredVar.Enum,
+				Name:  requiredVar.Name,
+			})
+		}
+
+	}
+
+	if len(notAllowedValuesVars) > 0 {
+		return &errors.TaskNotAllowedVars{
+			TaskName:       t.Name(),
+			NotAllowedVars: notAllowedValuesVars,
+		}
+	}
+
+	return nil
+}

setup.go

@@ -14,6 +14,7 @@ import (
 
 	"github.com/go-task/task/v3/errors"
 	"github.com/go-task/task/v3/internal/compiler"
+	"github.com/go-task/task/v3/internal/env"
 	"github.com/go-task/task/v3/internal/execext"
 	"github.com/go-task/task/v3/internal/filepathext"
 	"github.com/go-task/task/v3/internal/logger"
@@ -109,13 +110,14 @@ func (e *Executor) setupTempDir() error {
 		return nil
 	}
 
-	if os.Getenv("TASK_TEMP_DIR") == "" {
+	tempDir := env.GetTaskEnv("TEMP_DIR")
+	if tempDir == "" {
 		e.TempDir = TempDir{
 			Remote:      filepathext.SmartJoin(e.Dir, ".task"),
 			Fingerprint: filepathext.SmartJoin(e.Dir, ".task"),
 		}
-	} else if filepath.IsAbs(os.Getenv("TASK_TEMP_DIR")) || strings.HasPrefix(os.Getenv("TASK_TEMP_DIR"), "~") {
-		tempDir, err := execext.Expand(os.Getenv("TASK_TEMP_DIR"))
+	} else if filepath.IsAbs(tempDir) || strings.HasPrefix(tempDir, "~") {
+		tempDir, err := execext.Expand(tempDir)
 		if err != nil {
 			return err
 		}
@@ -128,14 +130,15 @@ func (e *Executor) setupTempDir() error {
 
 	} else {
 		e.TempDir = TempDir{
-			Remote:      filepathext.SmartJoin(e.Dir, os.Getenv("TASK_TEMP_DIR")),
-			Fingerprint: filepathext.SmartJoin(e.Dir, os.Getenv("TASK_TEMP_DIR")),
+			Remote:      filepathext.SmartJoin(e.Dir, tempDir),
+			Fingerprint: filepathext.SmartJoin(e.Dir, tempDir),
 		}
 	}
 
-	if os.Getenv("TASK_REMOTE_DIR") != "" {
-		if filepath.IsAbs(os.Getenv("TASK_REMOTE_DIR")) || strings.HasPrefix(os.Getenv("TASK_REMOTE_DIR"), "~") {
-			remoteTempDir, err := execext.Expand(os.Getenv("TASK_REMOTE_DIR"))
+	remoteDir := env.GetTaskEnv("REMOTE_DIR")
+	if remoteDir != "" {
+		if filepath.IsAbs(remoteDir) || strings.HasPrefix(remoteDir, "~") {
+			remoteTempDir, err := execext.Expand(remoteDir)
 			if err != nil {
 				return err
 			}
@@ -213,7 +216,7 @@ func (e *Executor) readDotEnvFiles() error {
 	}
 
 	err = env.Range(func(key string, value ast.Var) error {
-		if ok := e.Taskfile.Env.Exists(key); !ok {
+		if _, ok := e.Taskfile.Env.Get(key); !ok {
 			e.Taskfile.Env.Set(key, value)
 		}
 		return nil
@@ -246,6 +249,9 @@ func (e *Executor) setupConcurrencyState() {
 }
 
 func (e *Executor) doVersionChecks() error {
+	if !e.EnableVersionCheck {
+		return nil
+	}
 	// Copy the version to avoid modifying the original
 	schemaVersion := &semver.Version{}
 	*schemaVersion = *e.Taskfile.Version

signals.go

@@ -8,20 +8,20 @@ import (
 	"github.com/go-task/task/v3/internal/logger"
 )
 
-const interruptSignalsCount = 3
+const maxInterruptSignals = 3
 
 // NOTE(@andreynering): This function intercepts SIGINT and SIGTERM signals
 // so the Task process is not killed immediately and processes running have
 // time to do cleanup work.
 func (e *Executor) InterceptInterruptSignals() {
-	ch := make(chan os.Signal, interruptSignalsCount)
+	ch := make(chan os.Signal, maxInterruptSignals)
 	signal.Notify(ch, os.Interrupt, syscall.SIGTERM)
 
 	go func() {
-		for i := range interruptSignalsCount {
+		for i := range maxInterruptSignals {
 			sig := <-ch
 
-			if i+1 >= interruptSignalsCount {
+			if i+1 >= maxInterruptSignals {
 				e.Logger.Errf(logger.Red, "task: Signal received for the third time: %q. Forcing shutdown\n", sig)
 				os.Exit(1)
 			}

task.go

@@ -70,12 +70,13 @@ type Executor struct {
 	Stdout io.Writer
 	Stderr io.Writer
 
-	Logger         *logger.Logger
-	Compiler       *compiler.Compiler
-	Output         output.Output
-	OutputStyle    ast.Output
-	TaskSorter     sort.TaskSorter
-	UserWorkingDir string
+	Logger             *logger.Logger
+	Compiler           *compiler.Compiler
+	Output             output.Output
+	OutputStyle        ast.Output
+	TaskSorter         sort.TaskSorter
+	UserWorkingDir     string
+	EnableVersionCheck bool
 
 	fuzzyModel *fuzzy.Model
 
@@ -176,10 +177,19 @@ func (e *Executor) RunTask(ctx context.Context, call *ast.Call) error {
 		return nil
 	}
 
+	if err := e.areTaskRequiredVarsSet(t); err != nil {
+		return err
+	}
+
 	t, err = e.CompiledTask(call)
 	if err != nil {
 		return err
 	}
+
+	if err := e.areTaskRequiredVarsAllowedValuesSet(t); err != nil {
+		return err
+	}
+
 	if !e.Watch && atomic.AddInt32(e.taskCallCount[t.Task], 1) >= MaximumTaskCall {
 		return &errors.TaskCalledTooManyTimesError{
 			TaskName:        t.Task,
@@ -202,10 +212,6 @@ func (e *Executor) RunTask(ctx context.Context, call *ast.Call) error {
 				return err
 			}
 
-			if err := e.areTaskRequiredVarsSet(t, call); err != nil {
-				return err
-			}
-
 			preCondMet, err := e.areTaskPreconditionsMet(ctx, t)
 			if err != nil {
 				return err
@@ -235,13 +241,15 @@ func (e *Executor) RunTask(ctx context.Context, call *ast.Call) error {
 			}
 		}
 
-		if t.Prompt != "" && !e.Dry {
-			if err := e.Logger.Prompt(logger.Yellow, t.Prompt, "n", "y", "yes"); errors.Is(err, logger.ErrNoTerminal) {
-				return &errors.TaskCancelledNoTerminalError{TaskName: call.Task}
-			} else if errors.Is(err, logger.ErrPromptCancelled) {
-				return &errors.TaskCancelledByUserError{TaskName: call.Task}
-			} else if err != nil {
-				return err
+		for _, p := range t.Prompt {
+			if p != "" && !e.Dry {
+				if err := e.Logger.Prompt(logger.Yellow, p, "n", "y", "yes"); errors.Is(err, logger.ErrNoTerminal) {
+					return &errors.TaskCancelledNoTerminalError{TaskName: call.Task}
+				} else if errors.Is(err, logger.ErrPromptCancelled) {
+					return &errors.TaskCancelledByUserError{TaskName: call.Task}
+				} else if err != nil {
+					return err
+				}
 			}
 		}
 
@@ -330,7 +338,7 @@ func (e *Executor) runDeferred(t *ast.Task, call *ast.Call, i int, deferredExitC
 	}
 
 	cmd := t.Cmds[i]
-	vars, _ := e.Compiler.FastGetVariables(origTask, call)
+	vars, _ := e.Compiler.GetVariables(origTask, call)
 	cache := &templater.Cache{Vars: vars}
 	extra := map[string]any{}
 
@@ -381,7 +389,7 @@ func (e *Executor) runCommand(ctx context.Context, t *ast.Task, call *ast.Call,
 		if err != nil {
 			return fmt.Errorf("task: failed to get variables: %w", err)
 		}
-		stdOut, stdErr, close := outputWrapper.WrapWriter(e.Stdout, e.Stderr, t.Prefix, outputTemplater)
+		stdOut, stdErr, closer := outputWrapper.WrapWriter(e.Stdout, e.Stderr, t.Prefix, outputTemplater)
 
 		err = execext.RunCommand(ctx, &execext.RunCommandOptions{
 			Command:   cmd.Cmd,
@@ -393,7 +401,7 @@ func (e *Executor) runCommand(ctx context.Context, t *ast.Task, call *ast.Call,
 			Stdout:    stdOut,
 			Stderr:    stdErr,
 		})
-		if closeErr := close(err); closeErr != nil {
+		if closeErr := closer(err); closeErr != nil {
 			e.Logger.Errf(logger.Red, "task: unable to close writer: %v\n", closeErr)
 		}
 		if _, isExitError := interp.IsExitStatus(err); isExitError && cmd.IgnoreError {
@@ -449,7 +457,7 @@ func (e *Executor) GetTask(call *ast.Call) (*ast.Task, error) {
 	case 0: // Carry on
 	case 1:
 		if call.Vars == nil {
-			call.Vars = &ast.Vars{}
+			call.Vars = ast.NewVars()
 		}
 		call.Vars.Set("MATCH", ast.Var{Value: matchingTasks[0].Wildcards})
 		return matchingTasks[0].Task, nil
@@ -519,7 +527,7 @@ func (e *Executor) GetTaskList(filters ...FilterFunc) ([]*ast.Task, error) {
 	// Compile the list of tasks
 	for i := range tasks {
 		g.Go(func() error {
-			compiledTask, err := e.FastCompiledTask(&ast.Call{Task: tasks[i].Task})
+			compiledTask, err := e.CompiledTaskForTaskList(&ast.Call{Task: tasks[i].Task})
 			if err != nil {
 				return err
 			}

taskfile/ast/cmd.go

@@ -75,11 +75,13 @@ func (c *Cmd) UnmarshalYAML(node *yaml.Node) error {
 
 		// A deferred command
 		var deferredCmd struct {
-			Defer string
+			Defer  string
+			Silent bool
 		}
 		if err := node.Decode(&deferredCmd); err == nil && deferredCmd.Defer != "" {
 			c.Defer = true
 			c.Cmd = deferredCmd.Defer
+			c.Silent = deferredCmd.Silent
 			return nil
 		}
 
@@ -91,6 +93,7 @@ func (c *Cmd) UnmarshalYAML(node *yaml.Node) error {
 			c.Defer = true
 			c.Task = deferredCall.Defer.Task
 			c.Vars = deferredCall.Defer.Vars
+			c.Silent = deferredCall.Defer.Silent
 			return nil
 		}
 

taskfile/ast/for.go

@@ -5,13 +5,12 @@ import (
 
 	"github.com/go-task/task/v3/errors"
 	"github.com/go-task/task/v3/internal/deepcopy"
-	"github.com/go-task/task/v3/internal/omap"
 )
 
 type For struct {
 	From   string
 	List   []any
-	Matrix omap.OrderedMap[string, []any]
+	Matrix *Matrix
 	Var    string
 	Split  string
 	As     string
@@ -38,7 +37,7 @@ func (f *For) UnmarshalYAML(node *yaml.Node) error {
 
 	case yaml.MappingNode:
 		var forStruct struct {
-			Matrix omap.OrderedMap[string, []any]
+			Matrix *Matrix
 			Var    string
 			Split  string
 			As     string

taskfile/ast/include.go

@@ -1,46 +1,128 @@
 package ast
 
 import (
+	"sync"
+
+	"github.com/elliotchance/orderedmap/v2"
 	"gopkg.in/yaml.v3"
 
 	"github.com/go-task/task/v3/errors"
-	omap "github.com/go-task/task/v3/internal/omap"
+	"github.com/go-task/task/v3/internal/deepcopy"
 )
 
-// Include represents information about included taskfiles
-type Include struct {
-	Namespace      string
-	Taskfile       string
-	Dir            string
-	Optional       bool
-	Internal       bool
-	Aliases        []string
-	AdvancedImport bool
-	Vars           *Vars
-	Flatten        bool
+type (
+	// Include represents information about included taskfiles
+	Include struct {
+		Namespace      string
+		Taskfile       string
+		Dir            string
+		Optional       bool
+		Internal       bool
+		Aliases        []string
+		Excludes       []string
+		AdvancedImport bool
+		Vars           *Vars
+		Flatten        bool
+	}
+	// Includes is an ordered map of namespaces to includes.
+	Includes struct {
+		om    *orderedmap.OrderedMap[string, *Include]
+		mutex sync.RWMutex
+	}
+	// An IncludeElement is a key-value pair that is used for initializing an
+	// Includes structure.
+	IncludeElement orderedmap.Element[string, *Include]
+)
+
+// NewIncludes creates a new instance of Includes and initializes it with the
+// provided set of elements, if any. The elements are added in the order they
+// are passed.
+func NewIncludes(els ...*IncludeElement) *Includes {
+	includes := &Includes{
+		om: orderedmap.NewOrderedMap[string, *Include](),
+	}
+	for _, el := range els {
+		includes.Set(el.Key, el.Value)
+	}
+	return includes
 }
 
-// Includes represents information about included tasksfiles
-type Includes struct {
-	omap.OrderedMap[string, *Include]
+// Len returns the number of includes in the Includes map.
+func (includes *Includes) Len() int {
+	if includes == nil || includes.om == nil {
+		return 0
+	}
+	defer includes.mutex.RUnlock()
+	includes.mutex.RLock()
+	return includes.om.Len()
+}
+
+// Get returns the value the the include with the provided key and a boolean
+// that indicates if the value was found or not. If the value is not found, the
+// returned include is a zero value and the bool is false.
+func (includes *Includes) Get(key string) (*Include, bool) {
+	if includes == nil || includes.om == nil {
+		return &Include{}, false
+	}
+	defer includes.mutex.RUnlock()
+	includes.mutex.RLock()
+	return includes.om.Get(key)
+}
+
+// Set sets the value of the include with the provided key to the provided
+// value. If the include already exists, its value is updated. If the include
+// does not exist, it is created.
+func (includes *Includes) Set(key string, value *Include) bool {
+	if includes == nil {
+		includes = NewIncludes()
+	}
+	if includes.om == nil {
+		includes.om = orderedmap.NewOrderedMap[string, *Include]()
+	}
+	defer includes.mutex.Unlock()
+	includes.mutex.Lock()
+	return includes.om.Set(key, value)
+}
+
+// Range calls the provided function for each include in the map. The function
+// receives the include's key and value as arguments. If the function returns
+// an error, the iteration stops and the error is returned.
+func (includes *Includes) Range(f func(k string, v *Include) error) error {
+	if includes == nil || includes.om == nil {
+		return nil
+	}
+	for pair := includes.om.Front(); pair != nil; pair = pair.Next() {
+		if err := f(pair.Key, pair.Value); err != nil {
+			return err
+		}
+	}
+	return nil
 }
 
 // UnmarshalYAML implements the yaml.Unmarshaler interface.
 func (includes *Includes) UnmarshalYAML(node *yaml.Node) error {
+	if includes == nil || includes.om == nil {
+		*includes = *NewIncludes()
+	}
 	switch node.Kind {
 	case yaml.MappingNode:
-		// NOTE(@andreynering): on this style of custom unmarshalling,
-		// even number contains the keys, while odd numbers contains
-		// the values.
+		// NOTE: orderedmap does not have an unmarshaler, so we have to decode
+		// the map manually. We increment over 2 values at a time and assign
+		// them as a key-value pair.
 		for i := 0; i < len(node.Content); i += 2 {
 			keyNode := node.Content[i]
 			valueNode := node.Content[i+1]
 
+			// Decode the value node into an Include struct
 			var v Include
 			if err := valueNode.Decode(&v); err != nil {
 				return errors.NewTaskfileDecodeError(err, node)
 			}
+
+			// Set the include namespace
 			v.Namespace = keyNode.Value
+
+			// Add the include to the ordered map
 			includes.Set(keyNode.Value, &v)
 		}
 		return nil
@@ -49,22 +131,6 @@ func (includes *Includes) UnmarshalYAML(node *yaml.Node) error {
 	return errors.NewTaskfileDecodeError(nil, node).WithTypeMessage("includes")
 }
 
-// Len returns the length of the map
-func (includes *Includes) Len() int {
-	if includes == nil {
-		return 0
-	}
-	return includes.OrderedMap.Len()
-}
-
-// Wrapper around OrderedMap.Set to ensure we don't get nil pointer errors
-func (includes *Includes) Range(f func(k string, v *Include) error) error {
-	if includes == nil {
-		return nil
-	}
-	return includes.OrderedMap.Range(f)
-}
-
 func (include *Include) UnmarshalYAML(node *yaml.Node) error {
 	switch node.Kind {
 
@@ -84,6 +150,7 @@ func (include *Include) UnmarshalYAML(node *yaml.Node) error {
 			Internal bool
 			Flatten  bool
 			Aliases  []string
+			Excludes []string
 			Vars     *Vars
 		}
 		if err := node.Decode(&includedTaskfile); err != nil {
@@ -94,6 +161,7 @@ func (include *Include) UnmarshalYAML(node *yaml.Node) error {
 		include.Optional = includedTaskfile.Optional
 		include.Internal = includedTaskfile.Internal
 		include.Aliases = includedTaskfile.Aliases
+		include.Excludes = includedTaskfile.Excludes
 		include.AdvancedImport = true
 		include.Vars = includedTaskfile.Vars
 		include.Flatten = includedTaskfile.Flatten
@@ -115,6 +183,7 @@ func (include *Include) DeepCopy() *Include {
 		Dir:            include.Dir,
 		Optional:       include.Optional,
 		Internal:       include.Internal,
+		Excludes:       deepcopy.Slice(include.Excludes),
 		AdvancedImport: include.AdvancedImport,
 		Vars:           include.Vars.DeepCopy(),
 		Flatten:        include.Flatten,

taskfile/ast/matrix.go

@@ -0,0 +1,95 @@
+package ast
+
+import (
+	"github.com/elliotchance/orderedmap/v2"
+	"gopkg.in/yaml.v3"
+
+	"github.com/go-task/task/v3/errors"
+	"github.com/go-task/task/v3/internal/deepcopy"
+)
+
+type Matrix struct {
+	om *orderedmap.OrderedMap[string, []any]
+}
+
+type MatrixElement orderedmap.Element[string, []any]
+
+func NewMatrix(els ...*MatrixElement) *Matrix {
+	matrix := &Matrix{
+		om: orderedmap.NewOrderedMap[string, []any](),
+	}
+	for _, el := range els {
+		matrix.Set(el.Key, el.Value)
+	}
+	return matrix
+}
+
+func (matrix *Matrix) Len() int {
+	if matrix == nil || matrix.om == nil {
+		return 0
+	}
+	return matrix.om.Len()
+}
+
+func (matrix *Matrix) Get(key string) ([]any, bool) {
+	if matrix == nil || matrix.om == nil {
+		return nil, false
+	}
+	return matrix.om.Get(key)
+}
+
+func (matrix *Matrix) Set(key string, value []any) bool {
+	if matrix == nil {
+		matrix = NewMatrix()
+	}
+	if matrix.om == nil {
+		matrix.om = orderedmap.NewOrderedMap[string, []any]()
+	}
+	return matrix.om.Set(key, value)
+}
+
+func (matrix *Matrix) Range(f func(k string, v []any) error) error {
+	if matrix == nil || matrix.om == nil {
+		return nil
+	}
+	for pair := matrix.om.Front(); pair != nil; pair = pair.Next() {
+		if err := f(pair.Key, pair.Value); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (matrix *Matrix) DeepCopy() *Matrix {
+	if matrix == nil {
+		return nil
+	}
+	return &Matrix{
+		om: deepcopy.OrderedMap(matrix.om),
+	}
+}
+
+func (matrix *Matrix) UnmarshalYAML(node *yaml.Node) error {
+	switch node.Kind {
+	case yaml.MappingNode:
+		// NOTE: orderedmap does not have an unmarshaler, so we have to decode
+		// the map manually. We increment over 2 values at a time and assign
+		// them as a key-value pair.
+		for i := 0; i < len(node.Content); i += 2 {
+			keyNode := node.Content[i]
+			valueNode := node.Content[i+1]
+
+			// Decode the value node into a Matrix struct
+			var v []any
+			if err := valueNode.Decode(&v); err != nil {
+				return errors.NewTaskfileDecodeError(err, node)
+			}
+
+			// Add the task to the ordered map
+			matrix.Set(keyNode.Value, v)
+		}
+		return nil
+	}
+
+	return errors.NewTaskfileDecodeError(nil, node).WithTypeMessage("matrix")
+}

taskfile/ast/platforms_test.go

@@ -8,6 +8,8 @@ import (
 )
 
 func TestPlatformParsing(t *testing.T) {
+	t.Parallel()
+
 	tests := []struct {
 		Input        string
 		ExpectedOS   string
@@ -34,6 +36,8 @@ func TestPlatformParsing(t *testing.T) {
 
 	for _, test := range tests {
 		t.Run(test.Input, func(t *testing.T) {
+			t.Parallel()
+
 			var p Platform
 			err := p.parsePlatform(test.Input)
 

taskfile/ast/precondition_test.go

@@ -11,6 +11,8 @@ import (
 )
 
 func TestPreconditionParse(t *testing.T) {
+	t.Parallel()
+
 	tests := []struct {
 		content  string
 		v        any

taskfile/ast/prompt.go

@@ -0,0 +1,29 @@
+package ast
+
+import (
+	"gopkg.in/yaml.v3"
+
+	"github.com/go-task/task/v3/errors"
+)
+
+type Prompt []string
+
+func (p *Prompt) UnmarshalYAML(node *yaml.Node) error {
+	switch node.Kind {
+	case yaml.ScalarNode:
+		var str string
+		if err := node.Decode(&str); err != nil {
+			return errors.NewTaskfileDecodeError(err, node)
+		}
+		*p = []string{str}
+		return nil
+	case yaml.SequenceNode:
+		var list []string
+		if err := node.Decode(&list); err != nil {
+			return errors.NewTaskfileDecodeError(err, node)
+		}
+		*p = list
+		return nil
+	}
+	return errors.NewTaskfileDecodeError(nil, node).WithTypeMessage("prompt")
+}

taskfile/ast/requires.go

@@ -1,10 +1,15 @@
 package ast
 
-import "github.com/go-task/task/v3/internal/deepcopy"
+import (
+	"gopkg.in/yaml.v3"
+
+	"github.com/go-task/task/v3/errors"
+	"github.com/go-task/task/v3/internal/deepcopy"
+)
 
 // Requires represents a set of required variables necessary for a task to run
 type Requires struct {
-	Vars []string
+	Vars []*VarsWithValidation
 }
 
 func (r *Requires) DeepCopy() *Requires {
@@ -16,3 +21,47 @@ func (r *Requires) DeepCopy() *Requires {
 		Vars: deepcopy.Slice(r.Vars),
 	}
 }
+
+type VarsWithValidation struct {
+	Name string
+	Enum []string
+}
+
+func (v *VarsWithValidation) DeepCopy() *VarsWithValidation {
+	if v == nil {
+		return nil
+	}
+	return &VarsWithValidation{
+		Name: v.Name,
+		Enum: v.Enum,
+	}
+}
+
+// UnmarshalYAML implements yaml.Unmarshaler interface.
+func (v *VarsWithValidation) UnmarshalYAML(node *yaml.Node) error {
+	switch node.Kind {
+
+	case yaml.ScalarNode:
+		var cmd string
+		if err := node.Decode(&cmd); err != nil {
+			return errors.NewTaskfileDecodeError(err, node)
+		}
+		v.Name = cmd
+		v.Enum = nil
+		return nil
+
+	case yaml.MappingNode:
+		var vv struct {
+			Name string
+			Enum []string
+		}
+		if err := node.Decode(&vv); err != nil {
+			return errors.NewTaskfileDecodeError(err, node)
+		}
+		v.Name = vv.Name
+		v.Enum = vv.Enum
+		return nil
+	}
+
+	return errors.NewTaskfileDecodeError(nil, node).WithTypeMessage("requires")
+}

taskfile/ast/task.go

@@ -18,7 +18,7 @@ type Task struct {
 	Deps          []*Dep
 	Label         string
 	Desc          string
-	Prompt        string
+	Prompt        Prompt
 	Summary       string
 	Requires      *Requires
 	Aliases       []string
@@ -115,7 +115,7 @@ func (t *Task) UnmarshalYAML(node *yaml.Node) error {
 			Deps          []*Dep
 			Label         string
 			Desc          string
-			Prompt        string
+			Prompt        Prompt
 			Summary       string
 			Aliases       []string
 			Sources       []*Glob

taskfile/ast/taskfile.go

@@ -29,7 +29,7 @@ type Taskfile struct {
 	Shopt    []string
 	Vars     *Vars
 	Env      *Vars
-	Tasks    Tasks
+	Tasks    *Tasks
 	Silent   bool
 	Dotenv   []string
 	Run      string
@@ -47,11 +47,17 @@ func (t1 *Taskfile) Merge(t2 *Taskfile, include *Include) error {
 	if t2.Output.IsSet() {
 		t1.Output = t2.Output
 	}
+	if t1.Includes == nil {
+		t1.Includes = NewIncludes()
+	}
 	if t1.Vars == nil {
-		t1.Vars = &Vars{}
+		t1.Vars = NewVars()
 	}
 	if t1.Env == nil {
-		t1.Env = &Vars{}
+		t1.Env = NewVars()
+	}
+	if t1.Tasks == nil {
+		t1.Tasks = NewTasks()
 	}
 	t1.Vars.Merge(t2.Vars, include)
 	t1.Env.Merge(t2.Env, include)
@@ -70,7 +76,7 @@ func (tf *Taskfile) UnmarshalYAML(node *yaml.Node) error {
 			Shopt    []string
 			Vars     *Vars
 			Env      *Vars
-			Tasks    Tasks
+			Tasks    *Tasks
 			Silent   bool
 			Dotenv   []string
 			Run      string
@@ -92,11 +98,17 @@ func (tf *Taskfile) UnmarshalYAML(node *yaml.Node) error {
 		tf.Dotenv = taskfile.Dotenv
 		tf.Run = taskfile.Run
 		tf.Interval = taskfile.Interval
+		if tf.Includes == nil {
+			tf.Includes = NewIncludes()
+		}
 		if tf.Vars == nil {
-			tf.Vars = &Vars{}
+			tf.Vars = NewVars()
 		}
 		if tf.Env == nil {
-			tf.Env = &Vars{}
+			tf.Env = NewVars()
+		}
+		if tf.Tasks == nil {
+			tf.Tasks = NewTasks()
 		}
 		return nil
 	}

taskfile/ast/taskfile_test.go

@@ -7,11 +7,12 @@ import (
 	"github.com/stretchr/testify/require"
 	"gopkg.in/yaml.v3"
 
-	"github.com/go-task/task/v3/internal/omap"
 	"github.com/go-task/task/v3/taskfile/ast"
 )
 
 func TestCmdParse(t *testing.T) {
+	t.Parallel()
+
 	const (
 		yamlCmd      = `echo "a string command"`
 		yamlDep      = `"task-name"`
@@ -38,15 +39,21 @@ vars:
 			yamlTaskCall,
 			&ast.Cmd{},
 			&ast.Cmd{
-				Task: "another-task", Vars: &ast.Vars{
-					OrderedMap: omap.FromMapWithOrder(
-						map[string]ast.Var{
-							"PARAM1": {Value: "VALUE1"},
-							"PARAM2": {Value: "VALUE2"},
+				Task: "another-task",
+				Vars: ast.NewVars(
+					&ast.VarElement{
+						Key: "PARAM1",
+						Value: ast.Var{
+							Value: "VALUE1",
 						},
-						[]string{"PARAM1", "PARAM2"},
-					),
-				},
+					},
+					&ast.VarElement{
+						Key: "PARAM2",
+						Value: ast.Var{
+							Value: "VALUE2",
+						},
+					},
+				),
 			},
 		},
 		{
@@ -58,14 +65,15 @@ vars:
 			yamlDeferredCall,
 			&ast.Cmd{},
 			&ast.Cmd{
-				Task: "some_task", Vars: &ast.Vars{
-					OrderedMap: omap.FromMapWithOrder(
-						map[string]ast.Var{
-							"PARAM1": {Value: "var"},
+				Task: "some_task",
+				Vars: ast.NewVars(
+					&ast.VarElement{
+						Key: "PARAM1",
+						Value: ast.Var{
+							Value: "var",
 						},
-						[]string{"PARAM1"},
-					),
-				},
+					},
+				),
 				Defer: true,
 			},
 		},
@@ -78,15 +86,21 @@ vars:
 			yamlTaskCall,
 			&ast.Dep{},
 			&ast.Dep{
-				Task: "another-task", Vars: &ast.Vars{
-					OrderedMap: omap.FromMapWithOrder(
-						map[string]ast.Var{
-							"PARAM1": {Value: "VALUE1"},
-							"PARAM2": {Value: "VALUE2"},
+				Task: "another-task",
+				Vars: ast.NewVars(
+					&ast.VarElement{
+						Key: "PARAM1",
+						Value: ast.Var{
+							Value: "VALUE1",
 						},
-						[]string{"PARAM1", "PARAM2"},
-					),
-				},
+					},
+					&ast.VarElement{
+						Key: "PARAM2",
+						Value: ast.Var{
+							Value: "VALUE2",
+						},
+					},
+				),
 			},
 		},
 	}

taskfile/ast/tasks.go

@@ -4,32 +4,135 @@ import (
 	"fmt"
 	"slices"
 	"strings"
+	"sync"
 
+	"github.com/elliotchance/orderedmap/v2"
 	"gopkg.in/yaml.v3"
 
 	"github.com/go-task/task/v3/errors"
 	"github.com/go-task/task/v3/internal/filepathext"
-	"github.com/go-task/task/v3/internal/omap"
 )
 
-// Tasks represents a group of tasks
-type Tasks struct {
-	omap.OrderedMap[string, *Task]
+type (
+	// Tasks is an ordered map of task names to Tasks.
+	Tasks struct {
+		om    *orderedmap.OrderedMap[string, *Task]
+		mutex sync.RWMutex
+	}
+	// A TaskElement is a key-value pair that is used for initializing a Tasks
+	// structure.
+	TaskElement orderedmap.Element[string, *Task]
+	// MatchingTask represents a task that matches a given call. It includes the
+	// task itself and a list of wildcards that were matched.
+	MatchingTask struct {
+		Task      *Task
+		Wildcards []string
+	}
+)
+
+// NewTasks creates a new instance of Tasks and initializes it with the provided
+// set of elements, if any. The elements are added in the order they are passed.
+func NewTasks(els ...*TaskElement) *Tasks {
+	tasks := &Tasks{
+		om: orderedmap.NewOrderedMap[string, *Task](),
+	}
+	for _, el := range els {
+		tasks.Set(el.Key, el.Value)
+	}
+	return tasks
 }
 
-type MatchingTask struct {
-	Task      *Task
-	Wildcards []string
+// Len returns the number of variables in the Tasks map.
+func (tasks *Tasks) Len() int {
+	if tasks == nil || tasks.om == nil {
+		return 0
+	}
+	defer tasks.mutex.RUnlock()
+	tasks.mutex.RLock()
+	return tasks.om.Len()
 }
 
+// Get returns the value the the task with the provided key and a boolean that
+// indicates if the value was found or not. If the value is not found, the
+// returned task is a zero value and the bool is false.
+func (tasks *Tasks) Get(key string) (*Task, bool) {
+	if tasks == nil || tasks.om == nil {
+		return &Task{}, false
+	}
+	defer tasks.mutex.RUnlock()
+	tasks.mutex.RLock()
+	return tasks.om.Get(key)
+}
+
+// Set sets the value of the task with the provided key to the provided value.
+// If the task already exists, its value is updated. If the task does not exist,
+// it is created.
+func (tasks *Tasks) Set(key string, value *Task) bool {
+	if tasks == nil {
+		tasks = NewTasks()
+	}
+	if tasks.om == nil {
+		tasks.om = orderedmap.NewOrderedMap[string, *Task]()
+	}
+	defer tasks.mutex.Unlock()
+	tasks.mutex.Lock()
+	return tasks.om.Set(key, value)
+}
+
+// Range calls the provided function for each task in the map. The function
+// receives the task's key and value as arguments. If the function returns an
+// error, the iteration stops and the error is returned.
+func (tasks *Tasks) Range(f func(k string, v *Task) error) error {
+	if tasks == nil || tasks.om == nil {
+		return nil
+	}
+	for pair := tasks.om.Front(); pair != nil; pair = pair.Next() {
+		if err := f(pair.Key, pair.Value); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// Keys returns a slice of all the keys in the Tasks map.
+func (tasks *Tasks) Keys() []string {
+	if tasks == nil {
+		return nil
+	}
+	defer tasks.mutex.RUnlock()
+	tasks.mutex.RLock()
+	var keys []string
+	for pair := tasks.om.Front(); pair != nil; pair = pair.Next() {
+		keys = append(keys, pair.Key)
+	}
+	return keys
+}
+
+// Values returns a slice of all the values in the Tasks map.
+func (tasks *Tasks) Values() []*Task {
+	if tasks == nil {
+		return nil
+	}
+	defer tasks.mutex.RUnlock()
+	tasks.mutex.RLock()
+	var values []*Task
+	for pair := tasks.om.Front(); pair != nil; pair = pair.Next() {
+		values = append(values, pair.Value)
+	}
+	return values
+}
+
+// FindMatchingTasks returns a list of tasks that match the given call. A task
+// matches a call if its name is equal to the call's task name or if it matches
+// a wildcard pattern. The function returns a list of MatchingTask structs, each
+// containing a task and a list of wildcards that were matched.
 func (t *Tasks) FindMatchingTasks(call *Call) []*MatchingTask {
 	if call == nil {
 		return nil
 	}
-	var task *Task
 	var matchingTasks []*MatchingTask
 	// If there is a direct match, return it
-	if task = t.OrderedMap.Get(call.Task); task != nil {
+	if task, ok := t.Get(call.Task); ok {
 		matchingTasks = append(matchingTasks, &MatchingTask{Task: task, Wildcards: nil})
 		return matchingTasks
 	}
@@ -47,7 +150,9 @@ func (t *Tasks) FindMatchingTasks(call *Call) []*MatchingTask {
 	return matchingTasks
 }
 
-func (t1 *Tasks) Merge(t2 Tasks, include *Include, includedTaskfileVars *Vars) error {
+func (t1 *Tasks) Merge(t2 *Tasks, include *Include, includedTaskfileVars *Vars) error {
+	defer t2.mutex.RUnlock()
+	t2.mutex.RLock()
 	err := t2.Range(func(name string, v *Task) error {
 		// We do a deep copy of the task struct here to ensure that no data can
 		// be changed elsewhere once the taskfile is merged.
@@ -56,6 +161,12 @@ func (t1 *Tasks) Merge(t2 Tasks, include *Include, includedTaskfileVars *Vars) e
 		// taskfile are marked as internal
 		task.Internal = task.Internal || (include != nil && include.Internal)
 		taskName := name
+
+		// if the task is in the exclude list, don't add it to the merged taskfile and early return
+		if slices.Contains(include.Excludes, name) {
+			return nil
+		}
+
 		if !include.Flatten {
 			// Add namespaces to task dependencies
 			for _, dep := range task.Deps {
@@ -94,13 +205,13 @@ func (t1 *Tasks) Merge(t2 Tasks, include *Include, includedTaskfileVars *Vars) e
 		if include.AdvancedImport {
 			task.Dir = filepathext.SmartJoin(include.Dir, task.Dir)
 			if task.IncludeVars == nil {
-				task.IncludeVars = &Vars{}
+				task.IncludeVars = NewVars()
 			}
 			task.IncludeVars.Merge(include.Vars, nil)
 			task.IncludedTaskfileVars = includedTaskfileVars.DeepCopy()
 		}
 
-		if t1.Get(taskName) != nil {
+		if _, ok := t1.Get(taskName); ok {
 			return &errors.TaskNameFlattenConflictError{
 				TaskName: taskName,
 				Include:  include.Namespace,
@@ -112,52 +223,53 @@ func (t1 *Tasks) Merge(t2 Tasks, include *Include, includedTaskfileVars *Vars) e
 		return nil
 	})
 
-	// If the included Taskfile has a default task, being not flattened and the parent namespace has
-	// no task with a matching name, we can add an alias so that the user can
-	// run the included Taskfile's default task without specifying its full
-	// name. If the parent namespace has aliases, we add another alias for each
-	// of them.
-	if t2.Get("default") != nil && t1.Get(include.Namespace) == nil && !include.Flatten {
+	// If the included Taskfile has a default task, is not flattened and the
+	// parent namespace has no task with a matching name, we can add an alias so
+	// that the user can run the included Taskfile's default task without
+	// specifying its full name. If the parent namespace has aliases, we add
+	// another alias for each of them.
+	_, t2DefaultExists := t2.Get("default")
+	_, t1NamespaceExists := t1.Get(include.Namespace)
+	if t2DefaultExists && !t1NamespaceExists && !include.Flatten {
 		defaultTaskName := fmt.Sprintf("%s:default", include.Namespace)
-		t1.Get(defaultTaskName).Aliases = append(t1.Get(defaultTaskName).Aliases, include.Namespace)
-		t1.Get(defaultTaskName).Aliases = slices.Concat(t1.Get(defaultTaskName).Aliases, include.Aliases)
+		t1DefaultTask, ok := t1.Get(defaultTaskName)
+		if ok {
+			t1DefaultTask.Aliases = append(t1DefaultTask.Aliases, include.Namespace)
+			t1DefaultTask.Aliases = slices.Concat(t1DefaultTask.Aliases, include.Aliases)
+		}
 	}
+
 	return err
 }
 
 func (t *Tasks) UnmarshalYAML(node *yaml.Node) error {
+	if t == nil || t.om == nil {
+		*t = *NewTasks()
+	}
 	switch node.Kind {
 	case yaml.MappingNode:
-		tasks := omap.New[string, *Task]()
-		if err := node.Decode(&tasks); err != nil {
-			return errors.NewTaskfileDecodeError(err, node)
-		}
+		// NOTE: orderedmap does not have an unmarshaler, so we have to decode
+		// the map manually. We increment over 2 values at a time and assign
+		// them as a key-value pair.
+		for i := 0; i < len(node.Content); i += 2 {
+			keyNode := node.Content[i]
+			valueNode := node.Content[i+1]
 
-		// nolint: errcheck
-		tasks.Range(func(name string, task *Task) error {
-			// Set the task's name
-			if task == nil {
-				task = &Task{
-					Task: name,
-				}
+			// Decode the value node into a Task struct
+			var v Task
+			if err := valueNode.Decode(&v); err != nil {
+				return errors.NewTaskfileDecodeError(err, node)
 			}
-			task.Task = name
 
-			// Set the task's location
-			for _, keys := range node.Content {
-				if keys.Value == name {
-					task.Location = &Location{
-						Line:   keys.Line,
-						Column: keys.Column,
-					}
-				}
+			// Set the task name and location
+			v.Task = keyNode.Value
+			v.Location = &Location{
+				Line:   keyNode.Line,
+				Column: keyNode.Column,
 			}
-			tasks.Set(name, task)
-			return nil
-		})
 
-		*t = Tasks{
-			OrderedMap: tasks,
+			// Add the task to the ordered map
+			t.Set(keyNode.Value, &v)
 		}
 		return nil
 	}

taskfile/ast/var.go

@@ -2,92 +2,180 @@ package ast
 
 import (
 	"strings"
+	"sync"
 
+	"github.com/elliotchance/orderedmap/v2"
 	"gopkg.in/yaml.v3"
 
 	"github.com/go-task/task/v3/errors"
+	"github.com/go-task/task/v3/internal/deepcopy"
 	"github.com/go-task/task/v3/internal/experiments"
-	"github.com/go-task/task/v3/internal/omap"
 )
 
-// Vars is a string[string] variables map.
-type Vars struct {
-	omap.OrderedMap[string, Var]
+type (
+	// Vars is an ordered map of variable names to values.
+	Vars struct {
+		om    *orderedmap.OrderedMap[string, Var]
+		mutex sync.RWMutex
+	}
+	// A VarElement is a key-value pair that is used for initializing a Vars
+	// structure.
+	VarElement orderedmap.Element[string, Var]
+)
+
+// NewVars creates a new instance of Vars and initializes it with the provided
+// set of elements, if any. The elements are added in the order they are passed.
+func NewVars(els ...*VarElement) *Vars {
+	vars := &Vars{
+		om: orderedmap.NewOrderedMap[string, Var](),
+	}
+	for _, el := range els {
+		vars.Set(el.Key, el.Value)
+	}
+	return vars
 }
 
-// ToCacheMap converts Vars to a map containing only the static
+// Len returns the number of variables in the Vars map.
+func (vars *Vars) Len() int {
+	if vars == nil || vars.om == nil {
+		return 0
+	}
+	defer vars.mutex.RUnlock()
+	vars.mutex.RLock()
+	return vars.om.Len()
+}
+
+// Get returns the value the the variable with the provided key and a boolean
+// that indicates if the value was found or not. If the value is not found, the
+// returned variable is a zero value and the bool is false.
+func (vars *Vars) Get(key string) (Var, bool) {
+	if vars == nil || vars.om == nil {
+		return Var{}, false
+	}
+	defer vars.mutex.RUnlock()
+	vars.mutex.RLock()
+	return vars.om.Get(key)
+}
+
+// Set sets the value of the variable with the provided key to the provided
+// value. If the variable already exists, its value is updated. If the variable
+// does not exist, it is created.
+func (vars *Vars) Set(key string, value Var) bool {
+	if vars == nil {
+		vars = NewVars()
+	}
+	if vars.om == nil {
+		vars.om = orderedmap.NewOrderedMap[string, Var]()
+	}
+	defer vars.mutex.Unlock()
+	vars.mutex.Lock()
+	return vars.om.Set(key, value)
+}
+
+// Range calls the provided function for each variable in the map. The function
+// receives the variable's key and value as arguments. If the function returns
+// an error, the iteration stops and the error is returned.
+func (vars *Vars) Range(f func(k string, v Var) error) error {
+	if vars == nil || vars.om == nil {
+		return nil
+	}
+	for pair := vars.om.Front(); pair != nil; pair = pair.Next() {
+		if err := f(pair.Key, pair.Value); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// ToCacheMap converts Vars to an unordered map containing only the static
 // variables
-func (vs *Vars) ToCacheMap() (m map[string]any) {
-	m = make(map[string]any, vs.Len())
-	_ = vs.Range(func(k string, v Var) error {
-		if v.Sh != "" {
+func (vars *Vars) ToCacheMap() (m map[string]any) {
+	defer vars.mutex.RUnlock()
+	vars.mutex.RLock()
+	m = make(map[string]any, vars.Len())
+	for pair := vars.om.Front(); pair != nil; pair = pair.Next() {
+		if pair.Value.Sh != nil && *pair.Value.Sh != "" {
 			// Dynamic variable is not yet resolved; trigger
 			// <no value> to be used in templates.
 			return nil
 		}
-
-		if v.Live != nil {
-			m[k] = v.Live
+		if pair.Value.Live != nil {
+			m[pair.Key] = pair.Value.Live
 		} else {
-			m[k] = v.Value
+			m[pair.Key] = pair.Value.Value
 		}
-		return nil
-	})
+	}
 	return
 }
 
-// Wrapper around OrderedMap.Set to ensure we don't get nil pointer errors
-func (vs *Vars) Range(f func(k string, v Var) error) error {
-	if vs == nil {
-		return nil
-	}
-	return vs.OrderedMap.Range(f)
-}
-
-// Wrapper around OrderedMap.Merge to ensure we don't get nil pointer errors
-func (vs *Vars) Merge(other *Vars, include *Include) {
-	if vs == nil || other == nil {
+// Merge loops over other and merges it values with the variables in vars. If
+// the include parameter is not nil and its it is an advanced import, the
+// directory is set set to the value of the include parameter.
+func (vars *Vars) Merge(other *Vars, include *Include) {
+	if vars == nil || vars.om == nil || other == nil {
 		return
 	}
-	_ = other.Range(func(key string, value Var) error {
+	defer other.mutex.RUnlock()
+	other.mutex.RLock()
+	for pair := other.om.Front(); pair != nil; pair = pair.Next() {
 		if include != nil && include.AdvancedImport {
-			value.Dir = include.Dir
+			pair.Value.Dir = include.Dir
 		}
-		vs.Set(key, value)
-		return nil
-	})
-}
-
-// Wrapper around OrderedMap.Len to ensure we don't get nil pointer errors
-func (vs *Vars) Len() int {
-	if vs == nil {
-		return 0
+		vars.om.Set(pair.Key, pair.Value)
 	}
-	return vs.OrderedMap.Len()
 }
 
-// DeepCopy creates a new instance of Vars and copies
-// data by value from the source struct.
 func (vs *Vars) DeepCopy() *Vars {
 	if vs == nil {
 		return nil
 	}
+	defer vs.mutex.RUnlock()
+	vs.mutex.RLock()
 	return &Vars{
-		OrderedMap: vs.OrderedMap.DeepCopy(),
+		om: deepcopy.OrderedMap(vs.om),
 	}
 }
 
+func (vs *Vars) UnmarshalYAML(node *yaml.Node) error {
+	if vs == nil || vs.om == nil {
+		*vs = *NewVars()
+	}
+	vs.om = orderedmap.NewOrderedMap[string, Var]()
+	switch node.Kind {
+	case yaml.MappingNode:
+		// NOTE: orderedmap does not have an unmarshaler, so we have to decode
+		// the map manually. We increment over 2 values at a time and assign
+		// them as a key-value pair.
+		for i := 0; i < len(node.Content); i += 2 {
+			keyNode := node.Content[i]
+			valueNode := node.Content[i+1]
+
+			// Decode the value node into a Task struct
+			var v Var
+			if err := valueNode.Decode(&v); err != nil {
+				return errors.NewTaskfileDecodeError(err, node)
+			}
+
+			// Add the task to the ordered map
+			vs.Set(keyNode.Value, v)
+		}
+		return nil
+	}
+
+	return errors.NewTaskfileDecodeError(nil, node).WithTypeMessage("vars")
+}
+
 // Var represents either a static or dynamic variable.
 type Var struct {
 	Value any
 	Live  any
-	Sh    string
+	Sh    *string
 	Ref   string
 	Dir   string
 }
 
 func (v *Var) UnmarshalYAML(node *yaml.Node) error {
-	if experiments.MapVariables.Enabled {
+	if experiments.MapVariables.Enabled() {
 
 		// This implementation is not backwards-compatible and replaces the 'sh' key with map variables
 		if experiments.MapVariables.Value == "1" {
@@ -98,7 +186,7 @@ func (v *Var) UnmarshalYAML(node *yaml.Node) error {
 			// If the value is a string and it starts with $, then it's a shell command
 			if str, ok := value.(string); ok {
 				if str, ok = strings.CutPrefix(str, "$"); ok {
-					v.Sh = str
+					v.Sh = &str
 					return nil
 				}
 				if str, ok = strings.CutPrefix(str, "#"); ok {
@@ -118,7 +206,7 @@ func (v *Var) UnmarshalYAML(node *yaml.Node) error {
 				switch key {
 				case "sh", "ref", "map":
 					var m struct {
-						Sh  string
+						Sh  *string
 						Ref string
 						Map any
 					}
@@ -150,7 +238,7 @@ func (v *Var) UnmarshalYAML(node *yaml.Node) error {
 		switch key {
 		case "sh", "ref":
 			var m struct {
-				Sh  string
+				Sh  *string
 				Ref string
 			}
 			if err := node.Decode(&m); err != nil {

taskfile/dotenv.go

@@ -1,6 +1,7 @@
 package taskfile
 
 import (
+	"fmt"
 	"os"
 
 	"github.com/joho/godotenv"
@@ -21,7 +22,7 @@ func Dotenv(c *compiler.Compiler, tf *ast.Taskfile, dir string) (*ast.Vars, erro
 		return nil, err
 	}
 
-	env := &ast.Vars{}
+	env := ast.NewVars()
 	cache := &templater.Cache{Vars: vars}
 
 	for _, dotEnvPath := range tf.Dotenv {
@@ -37,10 +38,10 @@ func Dotenv(c *compiler.Compiler, tf *ast.Taskfile, dir string) (*ast.Vars, erro
 
 		envs, err := godotenv.Read(dotEnvPath)
 		if err != nil {
-			return nil, err
+			return nil, fmt.Errorf("error reading env file %s: %w", dotEnvPath, err)
 		}
 		for key, value := range envs {
-			if ok := env.Exists(key); !ok {
+			if _, ok := env.Get(key); !ok {
 				env.Set(key, ast.Var{Value: value})
 			}
 		}

taskfile/node.go

@@ -7,6 +7,8 @@ import (
 	"strings"
 	"time"
 
+	giturls "github.com/chainguard-dev/git-urls"
+
 	"github.com/go-task/task/v3/errors"
 	"github.com/go-task/task/v3/internal/experiments"
 	"github.com/go-task/task/v3/internal/logger"
@@ -48,24 +50,39 @@ func NewNode(
 ) (Node, error) {
 	var node Node
 	var err error
-	switch getScheme(entrypoint) {
+	scheme, err := getScheme(entrypoint)
+	if err != nil {
+		return nil, err
+	}
+	switch scheme {
+	case "git":
+		node, err = NewGitNode(entrypoint, dir, insecure, opts...)
 	case "http", "https":
 		node, err = NewHTTPNode(l, entrypoint, dir, insecure, timeout, opts...)
 	default:
-		// If no other scheme matches, we assume it's a file
 		node, err = NewFileNode(l, entrypoint, dir, opts...)
+
 	}
-	if node.Remote() && !experiments.RemoteTaskfiles.Enabled {
+
+	if node.Remote() && !experiments.RemoteTaskfiles.Enabled() {
 		return nil, errors.New("task: Remote taskfiles are not enabled. You can read more about this experiment and how to enable it at https://taskfile.dev/experiments/remote-taskfiles")
 	}
 	return node, err
 }
 
-func getScheme(uri string) string {
-	if i := strings.Index(uri, "://"); i != -1 {
-		return uri[:i]
+func getScheme(uri string) (string, error) {
+	u, err := giturls.Parse(uri)
+	if u == nil {
+		return "", err
 	}
-	return ""
+	if strings.HasSuffix(strings.Split(u.Path, "//")[0], ".git") && (u.Scheme == "git" || u.Scheme == "ssh" || u.Scheme == "https" || u.Scheme == "http") {
+		return "git", nil
+	}
+
+	if i := strings.Index(uri, "://"); i != -1 {
+		return uri[:i], nil
+	}
+	return "", nil
 }
 
 func getDefaultDir(entrypoint, dir string) string {

taskfile/node_file.go

@@ -81,6 +81,9 @@ func (node *FileNode) ResolveEntrypoint(entrypoint string) (string, error) {
 	if strings.Contains(entrypoint, "://") {
 		return entrypoint, nil
 	}
+	if strings.HasPrefix(entrypoint, "git") {
+		return entrypoint, nil
+	}
 
 	path, err := execext.Expand(entrypoint)
 	if err != nil {

taskfile/node_git.go

@@ -0,0 +1,126 @@
+package taskfile
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"net/url"
+	"path/filepath"
+	"strings"
+
+	giturls "github.com/chainguard-dev/git-urls"
+	"github.com/go-git/go-billy/v5/memfs"
+	"github.com/go-git/go-git/v5"
+	"github.com/go-git/go-git/v5/plumbing"
+	"github.com/go-git/go-git/v5/storage/memory"
+
+	"github.com/go-task/task/v3/errors"
+	"github.com/go-task/task/v3/internal/execext"
+	"github.com/go-task/task/v3/internal/filepathext"
+)
+
+// An GitNode is a node that reads a Taskfile from a remote location via Git.
+type GitNode struct {
+	*BaseNode
+	URL    *url.URL
+	rawUrl string
+	ref    string
+	path   string
+}
+
+func NewGitNode(
+	entrypoint string,
+	dir string,
+	insecure bool,
+	opts ...NodeOption,
+) (*GitNode, error) {
+	base := NewBaseNode(dir, opts...)
+	u, err := giturls.Parse(entrypoint)
+	if err != nil {
+		return nil, err
+	}
+
+	basePath, path := func() (string, string) {
+		x := strings.Split(u.Path, "//")
+		return x[0], x[1]
+	}()
+	ref := u.Query().Get("ref")
+
+	rawUrl := u.String()
+
+	u.RawQuery = ""
+	u.Path = basePath
+
+	if u.Scheme == "http" && !insecure {
+		return nil, &errors.TaskfileNotSecureError{URI: entrypoint}
+	}
+	return &GitNode{
+		BaseNode: base,
+		URL:      u,
+		rawUrl:   rawUrl,
+		ref:      ref,
+		path:     path,
+	}, nil
+}
+
+func (node *GitNode) Location() string {
+	return node.rawUrl
+}
+
+func (node *GitNode) Remote() bool {
+	return true
+}
+
+func (node *GitNode) Read(_ context.Context) ([]byte, error) {
+	fs := memfs.New()
+	storer := memory.NewStorage()
+	_, err := git.Clone(storer, fs, &git.CloneOptions{
+		URL:           node.URL.String(),
+		ReferenceName: plumbing.ReferenceName(node.ref),
+		SingleBranch:  true,
+		Depth:         1,
+	})
+	if err != nil {
+		return nil, err
+	}
+	file, err := fs.Open(node.path)
+	if err != nil {
+		return nil, err
+	}
+	// Read the entire response body
+	b, err := io.ReadAll(file)
+	if err != nil {
+		return nil, err
+	}
+
+	return b, nil
+}
+
+func (node *GitNode) ResolveEntrypoint(entrypoint string) (string, error) {
+	dir, _ := filepath.Split(node.path)
+	resolvedEntrypoint := fmt.Sprintf("%s//%s", node.URL, filepath.Join(dir, entrypoint))
+	if node.ref != "" {
+		return fmt.Sprintf("%s?ref=%s", resolvedEntrypoint, node.ref), nil
+	}
+	return resolvedEntrypoint, nil
+}
+
+func (node *GitNode) ResolveDir(dir string) (string, error) {
+	path, err := execext.Expand(dir)
+	if err != nil {
+		return "", err
+	}
+
+	if filepathext.IsAbs(path) {
+		return path, nil
+	}
+
+	// NOTE: Uses the directory of the entrypoint (Taskfile), not the current working directory
+	// This means that files are included relative to one another
+	entrypointDir := filepath.Dir(node.Dir())
+	return filepathext.SmartJoin(entrypointDir, path), nil
+}
+
+func (node *GitNode) FilenameAndLastDir() (string, string) {
+	return filepath.Base(node.path), filepath.Base(filepath.Dir(node.path))
+}

taskfile/node_git_test.go

@@ -0,0 +1,85 @@
+package taskfile
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestGitNode_ssh(t *testing.T) {
+	t.Parallel()
+
+	node, err := NewGitNode("git@github.com:foo/bar.git//Taskfile.yml?ref=main", "", false)
+	assert.NoError(t, err)
+	assert.Equal(t, "main", node.ref)
+	assert.Equal(t, "Taskfile.yml", node.path)
+	assert.Equal(t, "ssh://git@github.com/foo/bar.git//Taskfile.yml?ref=main", node.rawUrl)
+	assert.Equal(t, "ssh://git@github.com/foo/bar.git", node.URL.String())
+	entrypoint, err := node.ResolveEntrypoint("common.yml")
+	assert.NoError(t, err)
+	assert.Equal(t, "ssh://git@github.com/foo/bar.git//common.yml?ref=main", entrypoint)
+}
+
+func TestGitNode_sshWithDir(t *testing.T) {
+	t.Parallel()
+
+	node, err := NewGitNode("git@github.com:foo/bar.git//directory/Taskfile.yml?ref=main", "", false)
+	assert.NoError(t, err)
+	assert.Equal(t, "main", node.ref)
+	assert.Equal(t, "directory/Taskfile.yml", node.path)
+	assert.Equal(t, "ssh://git@github.com/foo/bar.git//directory/Taskfile.yml?ref=main", node.rawUrl)
+	assert.Equal(t, "ssh://git@github.com/foo/bar.git", node.URL.String())
+	entrypoint, err := node.ResolveEntrypoint("common.yml")
+	assert.NoError(t, err)
+	assert.Equal(t, "ssh://git@github.com/foo/bar.git//directory/common.yml?ref=main", entrypoint)
+}
+
+func TestGitNode_https(t *testing.T) {
+	t.Parallel()
+
+	node, err := NewGitNode("https://github.com/foo/bar.git//Taskfile.yml?ref=main", "", false)
+	assert.NoError(t, err)
+	assert.Equal(t, "main", node.ref)
+	assert.Equal(t, "Taskfile.yml", node.path)
+	assert.Equal(t, "https://github.com/foo/bar.git//Taskfile.yml?ref=main", node.rawUrl)
+	assert.Equal(t, "https://github.com/foo/bar.git", node.URL.String())
+	entrypoint, err := node.ResolveEntrypoint("common.yml")
+	assert.NoError(t, err)
+	assert.Equal(t, "https://github.com/foo/bar.git//common.yml?ref=main", entrypoint)
+}
+
+func TestGitNode_httpsWithDir(t *testing.T) {
+	t.Parallel()
+
+	node, err := NewGitNode("https://github.com/foo/bar.git//directory/Taskfile.yml?ref=main", "", false)
+	assert.NoError(t, err)
+	assert.Equal(t, "main", node.ref)
+	assert.Equal(t, "directory/Taskfile.yml", node.path)
+	assert.Equal(t, "https://github.com/foo/bar.git//directory/Taskfile.yml?ref=main", node.rawUrl)
+	assert.Equal(t, "https://github.com/foo/bar.git", node.URL.String())
+	entrypoint, err := node.ResolveEntrypoint("common.yml")
+	assert.NoError(t, err)
+	assert.Equal(t, "https://github.com/foo/bar.git//directory/common.yml?ref=main", entrypoint)
+}
+
+func TestGitNode_FilenameAndDir(t *testing.T) {
+	t.Parallel()
+
+	node, err := NewGitNode("https://github.com/foo/bar.git//directory/Taskfile.yml?ref=main", "", false)
+	assert.NoError(t, err)
+	filename, dir := node.FilenameAndLastDir()
+	assert.Equal(t, "Taskfile.yml", filename)
+	assert.Equal(t, "directory", dir)
+
+	node, err = NewGitNode("https://github.com/foo/bar.git//Taskfile.yml?ref=main", "", false)
+	assert.NoError(t, err)
+	filename, dir = node.FilenameAndLastDir()
+	assert.Equal(t, "Taskfile.yml", filename)
+	assert.Equal(t, ".", dir)
+
+	node, err = NewGitNode("https://github.com/foo/bar.git//multiple/directory/Taskfile.yml?ref=main", "", false)
+	assert.NoError(t, err)
+	filename, dir = node.FilenameAndLastDir()
+	assert.Equal(t, "Taskfile.yml", filename)
+	assert.Equal(t, "directory", dir)
+}

taskfile/node_http.go

@@ -17,9 +17,10 @@ import (
 // An HTTPNode is a node that reads a Taskfile from a remote location via HTTP.
 type HTTPNode struct {
 	*BaseNode
-	URL     *url.URL
-	logger  *logger.Logger
-	timeout time.Duration
+	URL        *url.URL // stores url pointing actual remote file. (e.g. with Taskfile.yml)
+	entrypoint string   // stores entrypoint url. used for building graph vertices.
+	logger     *logger.Logger
+	timeout    time.Duration
 }
 
 func NewHTTPNode(
@@ -40,15 +41,16 @@ func NewHTTPNode(
 	}
 
 	return &HTTPNode{
-		BaseNode: base,
-		URL:      url,
-		timeout:  timeout,
-		logger:   l,
+		BaseNode:   base,
+		URL:        url,
+		entrypoint: entrypoint,
+		timeout:    timeout,
+		logger:     l,
 	}, nil
 }
 
 func (node *HTTPNode) Location() string {
-	return node.URL.String()
+	return node.entrypoint
 }
 
 func (node *HTTPNode) Remote() bool {
@@ -74,7 +76,6 @@ func (node *HTTPNode) Read(ctx context.Context) ([]byte, error) {
 		return nil, errors.TaskfileFetchFailedError{URI: node.URL.String()}
 	}
 	defer resp.Body.Close()
-
 	if resp.StatusCode != http.StatusOK {
 		return nil, errors.TaskfileFetchFailedError{
 			URI:            node.URL.String(),
@@ -111,11 +112,15 @@ func (node *HTTPNode) ResolveDir(dir string) (string, error) {
 
 	// NOTE: Uses the directory of the entrypoint (Taskfile), not the current working directory
 	// This means that files are included relative to one another
-	entrypointDir := filepath.Dir(node.Dir())
-	return filepathext.SmartJoin(entrypointDir, path), nil
+	parent := node.Dir()
+	if node.Parent() != nil {
+		parent = node.Parent().Dir()
+	}
+
+	return filepathext.SmartJoin(parent, path), nil
 }
 
 func (node *HTTPNode) FilenameAndLastDir() (string, string) {
-	dir, filename := filepath.Split(node.URL.Path)
+	dir, filename := filepath.Split(node.entrypoint)
 	return filepath.Base(dir), filename
 }

taskfile/node_test.go

@@ -0,0 +1,24 @@
+package taskfile
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestScheme(t *testing.T) {
+	t.Parallel()
+
+	scheme, err := getScheme("https://github.com/foo/bar.git")
+	assert.NoError(t, err)
+	assert.Equal(t, "git", scheme)
+	scheme, err = getScheme("https://github.com/foo/bar.git?ref=v1//taskfile/common.yml")
+	assert.NoError(t, err)
+	assert.Equal(t, "git", scheme)
+	scheme, err = getScheme("git@github.com:foo/bar.git?ref=main//Taskfile.yml")
+	assert.NoError(t, err)
+	assert.Equal(t, "git", scheme)
+	scheme, err = getScheme("https://github.com/foo/common.yml")
+	assert.NoError(t, err)
+	assert.Equal(t, "https", scheme)
+}

taskfile/reader.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 	"os"
+	"sync"
 	"time"
 
 	"github.com/dominikbraun/graph"
@@ -30,14 +31,15 @@ Continue?`
 // A Reader will recursively read Taskfiles from a given source using a directed
 // acyclic graph (DAG).
 type Reader struct {
-	graph    *ast.TaskfileGraph
-	node     Node
-	insecure bool
-	download bool
-	offline  bool
-	timeout  time.Duration
-	tempDir  string
-	logger   *logger.Logger
+	graph       *ast.TaskfileGraph
+	node        Node
+	insecure    bool
+	download    bool
+	offline     bool
+	timeout     time.Duration
+	tempDir     string
+	logger      *logger.Logger
+	promptMutex sync.Mutex
 }
 
 func NewReader(
@@ -50,14 +52,15 @@ func NewReader(
 	logger *logger.Logger,
 ) *Reader {
 	return &Reader{
-		graph:    ast.NewTaskfileGraph(),
-		node:     node,
-		insecure: insecure,
-		download: download,
-		offline:  offline,
-		timeout:  timeout,
-		tempDir:  tempDir,
-		logger:   logger,
+		graph:       ast.NewTaskfileGraph(),
+		node:        node,
+		insecure:    insecure,
+		download:    download,
+		offline:     offline,
+		timeout:     timeout,
+		tempDir:     tempDir,
+		logger:      logger,
+		promptMutex: sync.Mutex{},
 	}
 }
 
@@ -112,6 +115,7 @@ func (r *Reader) include(node Node) error {
 				Flatten:        include.Flatten,
 				Aliases:        include.Aliases,
 				AdvancedImport: include.AdvancedImport,
+				Excludes:       include.Excludes,
 				Vars:           include.Vars,
 			}
 			if err := cache.Err(); err != nil {
@@ -181,88 +185,9 @@ func (r *Reader) include(node Node) error {
 }
 
 func (r *Reader) readNode(node Node) (*ast.Taskfile, error) {
-	var b []byte
-	var err error
-	var cache *Cache
-
-	if node.Remote() {
-		cache, err = NewCache(r.tempDir)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	// If the file is remote and we're in offline mode, check if we have a cached copy
-	if node.Remote() && r.offline {
-		if b, err = cache.read(node); errors.Is(err, os.ErrNotExist) {
-			return nil, &errors.TaskfileCacheNotFoundError{URI: node.Location()}
-		} else if err != nil {
-			return nil, err
-		}
-		r.logger.VerboseOutf(logger.Magenta, "task: [%s] Fetched cached copy\n", node.Location())
-	} else {
-
-		downloaded := false
-		ctx, cf := context.WithTimeout(context.Background(), r.timeout)
-		defer cf()
-
-		// Read the file
-		b, err = node.Read(ctx)
-		var taskfileNetworkTimeoutError *errors.TaskfileNetworkTimeoutError
-		// If we timed out then we likely have a network issue
-		if node.Remote() && errors.As(err, &taskfileNetworkTimeoutError) {
-			// If a download was requested, then we can't use a cached copy
-			if r.download {
-				return nil, &errors.TaskfileNetworkTimeoutError{URI: node.Location(), Timeout: r.timeout}
-			}
-			// Search for any cached copies
-			if b, err = cache.read(node); errors.Is(err, os.ErrNotExist) {
-				return nil, &errors.TaskfileNetworkTimeoutError{URI: node.Location(), Timeout: r.timeout, CheckedCache: true}
-			} else if err != nil {
-				return nil, err
-			}
-			r.logger.VerboseOutf(logger.Magenta, "task: [%s] Network timeout. Fetched cached copy\n", node.Location())
-		} else if err != nil {
-			return nil, err
-		} else {
-			downloaded = true
-		}
-
-		// If the node was remote, we need to check the checksum
-		if node.Remote() && downloaded {
-			r.logger.VerboseOutf(logger.Magenta, "task: [%s] Fetched remote copy\n", node.Location())
-
-			// Get the checksums
-			checksum := checksum(b)
-			cachedChecksum := cache.readChecksum(node)
-
-			var prompt string
-			if cachedChecksum == "" {
-				// If the checksum doesn't exist, prompt the user to continue
-				prompt = fmt.Sprintf(taskfileUntrustedPrompt, node.Location())
-			} else if checksum != cachedChecksum {
-				// If there is a cached hash, but it doesn't match the expected hash, prompt the user to continue
-				prompt = fmt.Sprintf(taskfileChangedPrompt, node.Location())
-			}
-			if prompt != "" {
-				if err := r.logger.Prompt(logger.Yellow, prompt, "n", "y", "yes"); err != nil {
-					return nil, &errors.TaskfileNotTrustedError{URI: node.Location()}
-				}
-			}
-
-			// If the hash has changed (or is new)
-			if checksum != cachedChecksum {
-				// Store the checksum
-				if err := cache.writeChecksum(node, checksum); err != nil {
-					return nil, err
-				}
-				// Cache the file
-				r.logger.VerboseOutf(logger.Magenta, "task: [%s] Caching downloaded file\n", node.Location())
-				if err = cache.write(node, b); err != nil {
-					return nil, err
-				}
-			}
-		}
+	b, err := r.loadNodeContent(node)
+	if err != nil {
+		return nil, err
 	}
 
 	var tf ast.Taskfile
@@ -295,3 +220,93 @@ func (r *Reader) readNode(node Node) (*ast.Taskfile, error) {
 
 	return &tf, nil
 }
+
+func (r *Reader) loadNodeContent(node Node) ([]byte, error) {
+	if !node.Remote() {
+		ctx, cf := context.WithTimeout(context.Background(), r.timeout)
+		defer cf()
+		return node.Read(ctx)
+	}
+
+	cache, err := NewCache(r.tempDir)
+	if err != nil {
+		return nil, err
+	}
+
+	if r.offline {
+		// In offline mode try to use cached copy
+		cached, err := cache.read(node)
+		if errors.Is(err, os.ErrNotExist) {
+			return nil, &errors.TaskfileCacheNotFoundError{URI: node.Location()}
+		} else if err != nil {
+			return nil, err
+		}
+		r.logger.VerboseOutf(logger.Magenta, "task: [%s] Fetched cached copy\n", node.Location())
+
+		return cached, nil
+	}
+
+	ctx, cf := context.WithTimeout(context.Background(), r.timeout)
+	defer cf()
+
+	b, err := node.Read(ctx)
+	if errors.Is(err, &errors.TaskfileNetworkTimeoutError{}) {
+		// If we timed out then we likely have a network issue
+
+		// If a download was requested, then we can't use a cached copy
+		if r.download {
+			return nil, &errors.TaskfileNetworkTimeoutError{URI: node.Location(), Timeout: r.timeout}
+		}
+
+		// Search for any cached copies
+		cached, err := cache.read(node)
+		if errors.Is(err, os.ErrNotExist) {
+			return nil, &errors.TaskfileNetworkTimeoutError{URI: node.Location(), Timeout: r.timeout, CheckedCache: true}
+		} else if err != nil {
+			return nil, err
+		}
+		r.logger.VerboseOutf(logger.Magenta, "task: [%s] Network timeout. Fetched cached copy\n", node.Location())
+
+		return cached, nil
+
+	} else if err != nil {
+		return nil, err
+	}
+	r.logger.VerboseOutf(logger.Magenta, "task: [%s] Fetched remote copy\n", node.Location())
+
+	// Get the checksums
+	checksum := checksum(b)
+	cachedChecksum := cache.readChecksum(node)
+
+	var prompt string
+	if cachedChecksum == "" {
+		// If the checksum doesn't exist, prompt the user to continue
+		prompt = fmt.Sprintf(taskfileUntrustedPrompt, node.Location())
+	} else if checksum != cachedChecksum {
+		// If there is a cached hash, but it doesn't match the expected hash, prompt the user to continue
+		prompt = fmt.Sprintf(taskfileChangedPrompt, node.Location())
+	}
+
+	if prompt != "" {
+		if err := func() error {
+			r.promptMutex.Lock()
+			defer r.promptMutex.Unlock()
+			return r.logger.Prompt(logger.Yellow, prompt, "n", "y", "yes")
+		}(); err != nil {
+			return nil, &errors.TaskfileNotTrustedError{URI: node.Location()}
+		}
+
+		// Store the checksum
+		if err := cache.writeChecksum(node, checksum); err != nil {
+			return nil, err
+		}
+
+		// Cache the file
+		r.logger.VerboseOutf(logger.Magenta, "task: [%s] Caching downloaded file\n", node.Location())
+		if err = cache.write(node, b); err != nil {
+			return nil, err
+		}
+	}
+
+	return b, nil
+}

taskfile/taskfile.go

@@ -43,13 +43,13 @@ var (
 // found, an error will be returned.
 func RemoteExists(ctx context.Context, l *logger.Logger, u *url.URL, timeout time.Duration) (*url.URL, error) {
 	// Create a new HEAD request for the given URL to check if the resource exists
-	req, err := http.NewRequest("HEAD", u.String(), nil)
+	req, err := http.NewRequestWithContext(ctx, "HEAD", u.String(), nil)
 	if err != nil {
 		return nil, errors.TaskfileFetchFailedError{URI: u.String()}
 	}
 
 	// Request the given URL
-	resp, err := http.DefaultClient.Do(req.WithContext(ctx))
+	resp, err := http.DefaultClient.Do(req)
 	if err != nil {
 		if errors.Is(ctx.Err(), context.DeadlineExceeded) {
 			return nil, &errors.TaskfileNetworkTimeoutError{URI: u.String(), Timeout: timeout}

testdata/cmds_vars/Taskfile.yml

@@ -0,0 +1,16 @@
+version: '3'
+
+tasks:
+  build-checksum:
+    sources:
+      - ./source.txt
+    cmds:
+      - echo "{{.CHECKSUM}}"
+
+  build-ts:
+    method: timestamp
+    sources:
+      - ./source.txt
+    cmds:
+      - echo '{{.TIMESTAMP.Unix}}'
+      - echo '{{.TIMESTAMP}}'

testdata/cmds_vars/source.txt

@@ -0,0 +1 @@
+Hello, World!

testdata/deferred/Taskfile.yml

@@ -1,12 +1,14 @@
-version: "3"
+version: '3'
 
 tasks:
   task-1:
     - echo 'task-1 ran {{.PARAM}}'
 
   task-2:
-    - defer: { task: "task-1", vars: { PARAM: "successfully" } }
+    - defer: { task: 'task-1', vars: { PARAM: 'successfully' } }
+    - defer: { task: 'task-1', vars: { PARAM: 'successfully' }, silent: true }
     - defer: echo 'echo ran'
+      silent: true
     - defer: echo 'failing' && exit 2
     - echo 'cmd ran'
     - exit 1

testdata/dotenv/parse_error/.env-with-error

@@ -0,0 +1,2 @@
+#intentional parse error
+SOME_VAR

testdata/dotenv/parse_error/Taskfile.yml

@@ -0,0 +1,8 @@
+version: '3'
+
+dotenv: ['.env-with-error']
+
+tasks:
+  default:
+    cmd: "true"
+

testdata/env/Taskfile.yml

@@ -15,8 +15,9 @@ tasks:
     cmds:
       - task: local
       - task: global
-      - task: not-overriden
+      - task: not-overridden
       - task: multiple_type
+      - task: dynamic
 
   local:
     vars:
@@ -31,7 +32,7 @@ tasks:
 
   global:
     env:
-      BAR: overriden
+      BAR: overridden
     cmds:
       - echo "FOO='$FOO' BAR='$BAR' BAZ='$BAZ'" > global.txt
 
@@ -43,10 +44,18 @@ tasks:
     cmds:
       - echo "FOO='$FOO' BAR='$BAR' BAZ='$BAZ'" > multiple_type.txt
 
-  not-overriden:
+  not-overridden:
     cmds:
-      - echo "QUX='$QUX'" > not-overriden.txt
+      - echo "QUX='$QUX'" > not-overridden.txt
 
-  overriden:
+  overridden:
     cmds:
-      - echo "QUX='$QUX'" > overriden.txt
+      - echo "QUX='$QUX'" > overridden.txt
+
+  dynamic:
+    silent: true
+    vars:
+      DYNAMIC_FOO:
+        sh: echo $FOO
+    cmds:
+      - echo "{{ .DYNAMIC_FOO }}" > dynamic.txt

testdata/exit_code/Taskfile.yml

@@ -9,13 +9,17 @@ tasks:
   exit-zero:
     vars:
       FOO: bar
+      DYNAMIC_FOO:
+        sh: echo 'bar'
     cmds:
-      - defer: echo FOO={{.FOO}} - {{.PREFIX}}{{.EXIT_CODE}}
+      - defer: echo FOO={{.FOO}} - DYNAMIC_FOO={{.DYNAMIC_FOO}} - {{.PREFIX}}{{.EXIT_CODE}}
       - exit 0
 
   exit-one:
     vars:
       FOO: bar
+      DYNAMIC_FOO:
+        sh: echo 'bar'
     cmds:
-      - defer: echo FOO={{.FOO}} - {{.PREFIX}}{{.EXIT_CODE}}
+      - defer: echo FOO={{.FOO}} - DYNAMIC_FOO={{.DYNAMIC_FOO}} - {{.PREFIX}}{{.EXIT_CODE}}
       - exit 1

testdata/exit_immediately/Taskfile.yml

@@ -3,4 +3,4 @@ version: '3'
 tasks:
   default: |
     this_should_fail
-    echo "This shoudn't be print"
+    echo "This shouldn't be print"

testdata/includes_http/child-taskfile2.yml

@@ -0,0 +1,9 @@
+version: '3'
+
+includes:
+  third-with-dir-1:
+    taskfile: "{{.INCLUDE_ROOT}}/child-taskfile3.yml"
+    dir: ./dir-1
+  third-with-dir-2:
+    taskfile: "{{.INCLUDE_ROOT}}/child-taskfile3.yml"
+    dir: ./dir-2

testdata/includes_http/child-taskfile3.yml

@@ -0,0 +1,4 @@
+version: '3'
+
+tasks:
+  default: "true"

testdata/includes_http/root-taskfile-remotefile-empty-dir-1st.yml

@@ -0,0 +1,8 @@
+version: '3'
+
+includes:
+  second-no-dir:
+      taskfile: "{{.INCLUDE_ROOT}}/child-taskfile2.yml"
+  second-with-dir-1:
+    taskfile: "{{.INCLUDE_ROOT}}/child-taskfile2.yml"
+    dir: ./dir-1

testdata/includes_http/root-taskfile-remotefile-empty-dir-2nd.yml

@@ -0,0 +1,8 @@
+version: '3'
+
+includes:
+  second-with-dir-1:
+    taskfile: "{{.INCLUDE_ROOT}}/child-taskfile2.yml"
+    dir: ./dir-1
+  second-no-dir:
+    taskfile: "{{.INCLUDE_ROOT}}/child-taskfile2.yml"

testdata/includes_remote/.gitignore

@@ -0,0 +1 @@
+*.txt

testdata/includes_remote/Taskfile.yml

@@ -0,0 +1,4 @@
+version: '3'
+
+includes:
+  first: "{{.FIRST_REMOTE_URL}}"

testdata/includes_remote/first/Taskfile.yml

@@ -0,0 +1,11 @@
+version: '3'
+
+includes:
+  second: "{{.SECOND_REMOTE_URL}}"
+
+tasks:
+  write-file:
+    requires:
+      vars: [CONTENT, OUTPUT_FILE]
+    cmd: |
+      echo "{{.CONTENT}}" > "{{.OUTPUT_FILE}}"