v3.37.1

* chore: release blog post

* chore: rename blog post to any-variables

* chore: update the release version in the blog

* chore: update blog date

.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@gmail.com. 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 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.
 
 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/CONTRIBUTING.md

@@ -1,6 +1,14 @@
-* Bug reports and feature requests are welcome in [the issues][issues]
-* Pull Requests are welcome. For more complex changes and features it's
-  recommended to open an issue with the feature request first
-* Documentation contributions are as important as code contributions
+## You can find our [contribution guide on our website][contributing]
 
+- Please read it carefully before opening a PR.
+- If you have any questions, you can:
+  - [Open an issue][issues]
+  - [Create a discussion][discussions]
+  - [Chat to us on Discord][discord]
+
+<!-- prettier-ignore-start -->
+[contributing]: https://taskfile.dev/contributing
 [issues]: https://github.com/go-task/task/issues
+[discussions]: https://github.com/go-task/task/discussions
+[discord]: https://discord.gg/6TY36E39UK
+<!-- prettier-ignore-end -->

.github/ISSUE_TEMPLATE/bug_report.md

@@ -3,13 +3,18 @@ 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.
+<!--
+
+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:
+- Operating system:
+- Experiments enabled:

.github/ISSUE_TEMPLATE/config.yml

@@ -1,7 +1,10 @@
 blank_issues_enabled: false
 contact_links:
+  - name: Extension 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.com/channels/974121106208354339/1025054680289660989
+    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
     url: https://github.com/go-task/task/discussions

.github/ISSUE_TEMPLATE/feature_request.md

@@ -3,9 +3,13 @@ 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.
+<!--
+
+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/dependabot.yml

@@ -8,3 +8,17 @@ updates:
       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/workflows/issue-awaiting-response.yml

@@ -31,13 +31,13 @@ jobs:
                 repo: context.repo.repo,
               }
             )
-            if (labels.find(label => label.name === 'awaiting response')) {
+            if (labels.find(label => label.name === 'state: awaiting response')) {
               if (comments[comments.length-1].user?.login === issue.data.user?.login) {
                 github.rest.issues.removeLabel({
                   owner: context.repo.owner,
                   repo: context.repo.repo,
                   issue_number: context.issue.number,
-                  name: 'awaiting response'
+                  name: 'state: awaiting response'
                 })
               }
             }

.github/workflows/issue-closed.yml

@@ -19,11 +19,11 @@ jobs:
                 repo: context.repo.repo,
               }
             )
-            if (labels.find(label => label.name === 'needs triage')) {
+            if (labels.find(label => label.name === 'state: needs triage')) {
               github.rest.issues.removeLabel({
                 owner: context.repo.owner,
                 repo: context.repo.repo,
                 issue_number: context.issue.number,
-                name: 'needs triage'
+                name: 'state: needs triage'
               })
             }

.github/workflows/issue-experiment.yml

@@ -0,0 +1,123 @@
+name: issue experiment
+
+on:
+  issues:
+    types: [labeled]
+
+jobs:
+  issue-experiment-proposed:
+    if: github.event.label.name == format('experiment{0} proposed', ':')
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/github-script@v6
+        with:
+          github-token: ${{secrets.GH_PAT}}
+          script: |
+            github.rest.issues.createComment({
+              issue_number: context.issue.number,
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              body: 'This issue has been marked as an experiment proposal! :test_tube: It will now enter a period of consultation during which we encourage the community to provide feedback on the proposed design. Please see the [experiment workflow documentation](https://taskfile.dev/experiments#workflow) for more information on how we release experiments.'
+            })
+  issue-experiment-draft:
+    if: github.event.label.name == format('experiment{0} draft', ':')
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/github-script@v6
+        with:
+          github-token: ${{secrets.GH_PAT}}
+          script: |
+            github.rest.issues.createComment({
+              issue_number: context.issue.number,
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              body: 'This experiment has been marked as a draft! :sparkles: This means that an initial implementation has been added to the latest release of Task! You can find information about this experiment and how to enable it in our [experiments documentation](https://taskfile.dev/experiments). Please see the [experiment workflow documentation](https://taskfile.dev/experiments#workflow) for more information on how we release experiments.'
+            })
+  issue-experiment-candidate:
+    if: github.event.label.name == format('experiment{0} candidate', ':')
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/github-script@v6
+        with:
+          github-token: ${{secrets.GH_PAT}}
+          script: |
+            github.rest.issues.createComment({
+              issue_number: context.issue.number,
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              body: 'This experiment has been marked as a candidate! :fire: This means that the  implementation is nearing completion and we are entering a period for final comments and feedback! You can find information about this experiment and how to enable it in our [experiments documentation](https://taskfile.dev/experiments). Please see the [experiment workflow documentation](https://taskfile.dev/experiments#workflow) for more information on how we release experiments.'
+            })
+  issue-experiment-stable:
+    if: github.event.label.name == format('experiment{0} stable', ':')
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/github-script@v6
+        with:
+          github-token: ${{secrets.GH_PAT}}
+          script: |
+            github.rest.issues.createComment({
+              issue_number: context.issue.number,
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              body: 'This experiment has been marked as stable! :metal: This means that the  implementation is now final and ready to be released. No more changes will be made and the experiment is safe to use in production! You can find information about this experiment and how to enable it in our [experiments documentation](https://taskfile.dev/experiments). Please see the [experiment workflow documentation](https://taskfile.dev/experiments#workflow) for more information on how we release experiments.'
+            })
+  issue-experiment-released:
+    if: github.event.label.name == format('experiment{0} released', ':')
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/github-script@v6
+        with:
+          github-token: ${{secrets.GH_PAT}}
+          script: |
+            github.rest.issues.createComment({
+              issue_number: context.issue.number,
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              body: 'This experiment has been released! :rocket: This means that it is no longer an experiment and is available in the latest major version of Task. Please see the [experiment workflow documentation](https://taskfile.dev/experiments#workflow) for more information on how we release experiments.'
+            })
+            github.rest.issues.update({
+              issue_number: context.issue.number,
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              state: 'closed'
+            })
+  issue-experiment-abandoned:
+    if: github.event.label.name == format('experiment{0} abandoned', ':')
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/github-script@v6
+        with:
+          github-token: ${{secrets.GH_PAT}}
+          script: |
+            github.rest.issues.createComment({
+              issue_number: context.issue.number,
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              body: 'This experiment has been abandoned. :disappointed: This means that this feature will not be added to Task and any experimental functionality will be removed. Please see the [experiment workflow documentation](https://taskfile.dev/experiments#workflow) for more information on how we release experiments.'
+            })
+            github.rest.issues.update({
+              issue_number: context.issue.number,
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              state: 'closed'
+            })
+  issue-experiment-superseded:
+    if: github.event.label.name == format('experiment{0} superseded', ':')
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/github-script@v6
+        with:
+          github-token: ${{secrets.GH_PAT}}
+          script: |
+            github.rest.issues.createComment({
+              issue_number: context.issue.number,
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              body: 'This experiment has been superseded. :seedling: This means that another experiment has replaced this one. Please see the [experiment workflow documentation](https://taskfile.dev/experiments#workflow) for more information on how we release experiments.'
+            })
+            github.rest.issues.update({
+              issue_number: context.issue.number,
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              state: 'closed'
+            })

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

@@ -24,6 +24,6 @@ jobs:
                 issue_number: context.issue.number,
                 owner: context.repo.owner,
                 repo: context.repo.repo,
-                labels: ['needs triage']
+                labels: ['state: needs triage']
               })
             }

.github/workflows/lint.yml

@@ -6,19 +6,38 @@ on:
     tags:
       - v*
     branches:
-      - master
+      - main
 
 jobs:
   lint:
+    name: Lint
+    strategy:
+      matrix:
+        go-version: [1.21.x, 1.22.x]
     runs-on: ubuntu-latest
     steps:
       - uses: actions/setup-go@v3
         with:
-          go-version: 1.18.x
+          go-version: ${{matrix.go-version}}
 
       - uses: actions/checkout@v3
 
       - name: golangci-lint
         uses: golangci/golangci-lint-action@v3
         with:
-          version: v1.46.1
+          version: v1.55.2
+
+  lint-jsonschema:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/setup-python@v5
+        with:
+          python-version: 3.12
+
+      - uses: actions/checkout@v3
+
+      - name: install check-jsonschema
+        run: python -m pip install 'check-jsonschema==0.27.3'
+
+      - name: check-jsonschema (metaschema)
+        run: check-jsonschema --check-metaschema website/static/schema.json

.github/workflows/release.yml

@@ -3,7 +3,7 @@ name: goreleaser
 on:
   push:
     tags:
-      - '*'
+      - 'v*'
 
 jobs:
   goreleaser:
@@ -15,12 +15,12 @@ jobs:
       - name: Set up Go
         uses: actions/setup-go@v3
         with:
-          go-version: 1.19.x
+          go-version: 1.21.x
 
       - name: Run GoReleaser
         uses: goreleaser/goreleaser-action@v2
         with:
           version: latest
-          args: release --rm-dist
+          args: release --clean
         env:
           GITHUB_TOKEN: ${{secrets.GH_PAT}}

.github/workflows/test.yml

@@ -6,14 +6,14 @@ on:
     tags:
       - v*
     branches:
-      - master
+      - main
 
 jobs:
   test:
     name: Test
     strategy:
       matrix:
-        go-version: [1.18.x, 1.19.x]
+        go-version: [1.21.x, 1.22.x]
         platform: [ubuntu-latest, macos-latest, windows-latest]
     runs-on: ${{matrix.platform}}
     steps:

.github/workflows/upload-source-documents.yml

@@ -0,0 +1,38 @@
+name: Upload Source Documents
+
+on:
+  push:
+    branches:
+      - main
+  workflow_dispatch:
+
+jobs:
+  push_files_to_crowdin:
+    name: Push files to Crowdin
+    if: github.repository == 'go-task/task'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Verify changed files
+        id: changed-files
+        uses: tj-actions/changed-files@v41
+        with:
+          files: |
+            website/docs
+            website/blog
+            website/i18n/en
+            website/src/pages
+
+      - name: Install Task
+        uses: arduino/setup-task@v1
+        with:
+          version: 3.x
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Upload source documents
+        if: steps.changed-files.outputs.any_changed == 'true'
+        run: task crowdin:push
+        env:
+          CROWDIN_PERSONAL_TOKEN: ${{ secrets.CROWDIN_PERSONAL_TOKEN }}
+        working-directory: ./website

.github/workflows/website-deploy.yml

@@ -1,35 +0,0 @@
-name: Website Deploy
-
-on:
-  push:
-    branches:
-      - master
-
-jobs:
-  website-deploy:
-    name: Website Deploy
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-
-      - uses: actions/setup-node@v3
-        with:
-          node-version: 16.x
-          cache: yarn
-          cache-dependency-path: ./docs/yarn.lock
-
-      - name: Install dependencies
-        run: yarn install --frozen-lockfile
-        working-directory: ./docs
-
-      - name: Build website
-        run: yarn build
-        working-directory: ./docs
-
-      - name: Website Deploy
-        uses: peaceiris/actions-gh-pages@v3
-        with:
-          github_token: ${{ secrets.GITHUB_TOKEN }}
-          publish_dir: ./docs/build
-          user_name: task-bot
-          user_email: 106601941+task-bot@users.noreply.github.com

.github/workflows/website-test.yml

@@ -1,27 +0,0 @@
-name: Website Test
-
-on:
-  pull_request:
-    branches:
-      - master
-
-jobs:
-  website-test:
-    name: Website Test
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-
-      - uses: actions/setup-node@v3
-        with:
-          node-version: 16.x
-          cache: yarn
-          cache-dependency-path: ./docs/yarn.lock
-
-      - name: Install dependencies
-        run: yarn install --frozen-lockfile
-        working-directory: ./docs
-
-      - name: Test build website
-        run: yarn build
-        working-directory: ./docs

.gitignore

@@ -10,6 +10,9 @@
 # Output of the go coverage tool, specifically when used with LiteIDE
 *.out
 
+# Graphvis files
+*.gv
+
 # Project-local glide cache, RE: https://github.com/Masterminds/glide/issues/736
 .glide/
 
@@ -21,7 +24,8 @@ dist/
 
 # editors
 .idea/
-.vscode/
+.vscode/*
+!.vscode/*-sample.json
 .fleet/
 
 # exuberant ctags

.golangci.yml

@@ -6,7 +6,13 @@
 linters:
   enable:
     - goimports
+    - gofmt
+    - gofumpt
 
 linters-settings:
   goimports:
-    local-prefixes: github.com/go-task/task
+    local-prefixes: github.com/go-task
+  gofmt:
+    rewrite-rules:
+      - pattern: 'interface{}'
+        replacement: 'any'

.goreleaser.yml

@@ -1,27 +1,28 @@
-build:
-  binary: task
-  main: ./cmd/task
-  goos:
-    - windows
-    - darwin
-    - linux
-  goarch:
-    - 386
-    - amd64
-    - arm
-    - arm64
-  goarm:
-    - 6
-  ignore:
-    - goos: darwin
-      goarch: 386
-  env:
-    - CGO_ENABLED=0
-  mod_timestamp: '{{ .CommitTimestamp }}'
-  flags:
-    - -trimpath
-  ldflags:
-    - -s -w # Don't set main.version.
+builds:
+  - binary: task
+    main: ./cmd/task
+    goos:
+      - windows
+      - darwin
+      - linux
+      - freebsd
+    goarch:
+      - '386'
+      - amd64
+      - arm
+      - arm64
+    goarm:
+      - '6'
+    ignore:
+      - goos: darwin
+        goarch: '386'
+    env:
+      - CGO_ENABLED=0
+    mod_timestamp: '{{ .CommitTimestamp }}'
+    flags:
+      - -trimpath
+    ldflags:
+      - -s -w # Don't set main.version.
 
 gomod:
   proxy: true
@@ -70,8 +71,8 @@ brews:
     description: Task runner / simpler Make alternative written in Go
     license: MIT
     homepage: https://taskfile.dev
-    folder: Formula
-    tap:
+    directory: Formula
+    repository:
       owner: go-task
       name: homebrew-tap
     test:
@@ -84,3 +85,41 @@ brews:
     commit_author:
       name: task-bot
       email: 106601941+task-bot@users.noreply.github.com
+
+winget:
+  - name: Task
+    publisher: Task
+    short_description: A task runner / simpler Make alternative written in Go
+    description: Task is a task runner / build tool that aims to be simpler and easier to use than, for example, GNU Make.
+    license: MIT
+    homepage: https://taskfile.dev/
+    publisher_url: https://taskfile.dev/
+    publisher_support_url: https://github.com/go-task/task/issues
+    package_identifier: Task.Task
+    commit_author:
+      name: task-bot
+      email: 106601941+task-bot@users.noreply.github.com
+    commit_msg_template: "chore: bump {{.PackageIdentifier}} to {{.Tag}}"
+    release_notes_url: https://github.com/go-task/task/releases/tag/{{.Tag}}
+    tags:
+      - build
+      - build-tool
+      - devops
+      - go
+      - make
+      - makefile
+      - runner
+      - task
+      - task-runner
+      - taskfile
+      - tool
+    skip_upload: true
+    repository:
+      owner: microsoft
+      name: winget-pkgs
+      pull_request:
+        enabled: true
+        base:
+          owner: go-task
+          name: winget-pkgs
+          branch: "bump-task-to-{{.Tag}}"

.mockery.yaml

@@ -0,0 +1,4 @@
+with-expecter: true
+keeptree: true
+case: underscore
+output: ./internal/mocks

.prettierrc.yml

@@ -0,0 +1,7 @@
+trailingComma: none
+singleQuote: true
+overrides:
+  - files: "*.md"
+    options:
+      printWidth: 80
+      proseWrap: always

.vscode/settings-sample.json

@@ -0,0 +1,17 @@
+{
+  "yaml.schemas": {
+    "./website/static/schema.json": [
+      "Taskfile.yml",
+      "tmp/**/*.yml"
+    ]
+  },
+  "search.exclude": {
+    "**/versioned_docs": true,
+    "**/versioned_sidesbars": true,
+    "**/i18n": true
+  },
+  "gopls": {
+      "formatting.local": "github.com/go-task"
+  },
+  "go.formatTool": "gofumpt"
+}

README.md

@@ -1,6 +1,6 @@
 <div align="center">
   <a href="https://taskfile.dev">
-    <img src="docs/static/img/logo.svg" width="200px" height="200px" />
+    <img src="website/static/img/logo.svg" width="200px" height="200px" />
   </a>
 
   <h1>Task</h1>
@@ -13,15 +13,3 @@
     <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>
   </p>
 </div>
-
-## Gold Sponsors
-
-<div align="center">
-
-| [Appwrite][appwrite] |
-| - |
-| [![Appwrite](/docs/static/img/appwrite.svg)][appwrite] |
-
-</div>
-
-[appwrite]: https://appwrite.io/?utm_source=task_github&utm_medium=social&utm_campaign=task_oss_fund

Taskfile.yml

@@ -1,10 +1,13 @@
 version: '3'
 
 includes:
-  docs:
-    aliases: [d]
-    taskfile: ./docs
-    dir: ./docs
+  website:
+    aliases: [w, docs, d]
+    taskfile: ./website
+    dir: ./website
+
+vars:
+  BIN: "{{.ROOT_DIR}}/bin"
 
 env:
   CGO_ENABLED: '0'
@@ -21,10 +24,30 @@ tasks:
     sources:
       - './**/*.go'
     cmds:
-      - go install -v -ldflags="-w -s -X main.version={{.GIT_COMMIT}}" ./cmd/task
+      - go install -v ./cmd/task
+
+  generate:
+    desc: Runs Go generate to create mocks
+    aliases: [gen, g]
+    deps: [install:mockery]
+    sources:
+      - "internal/fingerprint/checker.go"
+    generates:
+      - "internal/mocks/*.go"
+    cmds:
+      - "{{.BIN}}/mockery --dir ./internal/fingerprint --name SourcesCheckable"
+      - "{{.BIN}}/mockery --dir ./internal/fingerprint --name StatusCheckable"
+
+  install:mockery:
+    desc: Installs mockgen; a tool to generate mock files
     vars:
-      GIT_COMMIT:
-        sh: git log -n 1 --format=%h
+      MOCKERY_VERSION: v2.24.0
+    env:
+      GOBIN: "{{.BIN}}"
+    status:
+      - go version -m {{.BIN}}/mockery | grep github.com/vektra/mockery | grep {{.MOCKERY_VERSION}}
+    cmds:
+      - go install github.com/vektra/mockery/v2@{{.MOCKERY_VERSION}}
 
   mod:
     desc: Downloads and tidy Go modules
@@ -47,20 +70,28 @@ tasks:
     cmds:
       - golangci-lint run
 
+  lint:fix:
+    desc: Runs golangci-lint and fixes any issues
+    sources:
+      - './**/*.go'
+      - .golangci.yml
+    cmds:
+      - golangci-lint run --fix
+
   sleepit:build:
     desc: Builds the sleepit test helper
     sources:
       - ./cmd/sleepit/**/*.go
     generates:
-      - ./bin/sleepit
+      - "{{.BIN}}/sleepit"
     cmds:
-      - go build -o ./bin/sleepit{{exeExt}} ./cmd/sleepit
+      - go build -o {{.BIN}}/sleepit{{exeExt}} ./cmd/sleepit
 
   sleepit:run:
     desc: Builds the sleepit test helper
     deps: [sleepit:build]
     cmds:
-      - ./bin/sleepit {{.CLI_ARGS}}
+      - "{{.BIN}}/sleepit {{.CLI_ARGS}}"
     silent: true
 
   test:
@@ -82,23 +113,20 @@ tasks:
       GO_PACKAGES:
         sh: go list ./...
 
-  test-release:
+  goreleaser:test:
     desc: Tests release process without publishing
     cmds:
-      - goreleaser --snapshot --rm-dist
+      - goreleaser --snapshot --clean
 
-  docs:changelog:
-    desc: Copy CHANGELOG.md to the documentation website
-    vars:
-      FILE: docs/docs/changelog.md
+  goreleaser:install:
+    desc: Installs goreleaser
     cmds:
-      - rm {{.FILE}}
-      - 'echo "---" >> {{.FILE}}'
-      - 'echo "slug: /changelog/" >> {{.FILE}}'
-      - 'echo "sidebar_position: 7" >> {{.FILE}}'
-      - 'echo "---" >> {{.FILE}}'
-      - 'echo "" >> {{.FILE}}'
-      - 'cat CHANGELOG.md >> {{.FILE}}'
+      - go install github.com/goreleaser/goreleaser@latest
+
+  release:
+    desc: Prepare the project for a new release
+    cmds:
+      - go run ./cmd/release {{.CLI_ARGS}}
 
   npm:publish:
     desc: Publish release to npm

args/args.go

@@ -3,56 +3,22 @@ package args
 import (
 	"strings"
 
-	"github.com/go-task/task/v3/taskfile"
+	"github.com/go-task/task/v3/taskfile/ast"
 )
 
-// ParseV3 parses command line argument: tasks and global variables
-func ParseV3(args ...string) ([]taskfile.Call, *taskfile.Vars) {
-	var calls []taskfile.Call
-	var globals = &taskfile.Vars{}
+// Parse parses command line argument: tasks and global variables
+func Parse(args ...string) ([]*ast.Call, *ast.Vars) {
+	calls := []*ast.Call{}
+	globals := &ast.Vars{}
 
 	for _, arg := range args {
 		if !strings.Contains(arg, "=") {
-			calls = append(calls, taskfile.Call{Task: arg})
+			calls = append(calls, &ast.Call{Task: arg})
 			continue
 		}
 
 		name, value := splitVar(arg)
-		globals.Set(name, taskfile.Var{Static: value})
-	}
-
-	if len(calls) == 0 {
-		calls = append(calls, taskfile.Call{Task: "default"})
-	}
-
-	return calls, globals
-}
-
-// ParseV2 parses command line argument: tasks and vars of each task
-func ParseV2(args ...string) ([]taskfile.Call, *taskfile.Vars) {
-	var calls []taskfile.Call
-	var globals = &taskfile.Vars{}
-
-	for _, arg := range args {
-		if !strings.Contains(arg, "=") {
-			calls = append(calls, taskfile.Call{Task: arg})
-			continue
-		}
-
-		if len(calls) < 1 {
-			name, value := splitVar(arg)
-			globals.Set(name, taskfile.Var{Static: value})
-		} else {
-			if calls[len(calls)-1].Vars == nil {
-				calls[len(calls)-1].Vars = &taskfile.Vars{}
-			}
-			name, value := splitVar(arg)
-			calls[len(calls)-1].Vars.Set(name, taskfile.Var{Static: value})
-		}
-	}
-
-	if len(calls) == 0 {
-		calls = append(calls, taskfile.Call{Task: "default"})
+		globals.Set(name, ast.Var{Value: value})
 	}
 
 	return calls, globals

args/args_test.go

@@ -7,18 +7,19 @@ import (
 	"github.com/stretchr/testify/assert"
 
 	"github.com/go-task/task/v3/args"
-	"github.com/go-task/task/v3/taskfile"
+	"github.com/go-task/task/v3/internal/omap"
+	"github.com/go-task/task/v3/taskfile/ast"
 )
 
-func TestArgsV3(t *testing.T) {
+func TestArgs(t *testing.T) {
 	tests := []struct {
 		Args            []string
-		ExpectedCalls   []taskfile.Call
-		ExpectedGlobals *taskfile.Vars
+		ExpectedCalls   []*ast.Call
+		ExpectedGlobals *ast.Vars
 	}{
 		{
 			Args: []string{"task-a", "task-b", "task-c"},
-			ExpectedCalls: []taskfile.Call{
+			ExpectedCalls: []*ast.Call{
 				{Task: "task-a"},
 				{Task: "task-b"},
 				{Task: "task-c"},
@@ -26,184 +27,82 @@ func TestArgsV3(t *testing.T) {
 		},
 		{
 			Args: []string{"task-a", "FOO=bar", "task-b", "task-c", "BAR=baz", "BAZ=foo"},
-			ExpectedCalls: []taskfile.Call{
+			ExpectedCalls: []*ast.Call{
 				{Task: "task-a"},
 				{Task: "task-b"},
 				{Task: "task-c"},
 			},
-			ExpectedGlobals: &taskfile.Vars{
-				Keys: []string{"FOO", "BAR", "BAZ"},
-				Mapping: map[string]taskfile.Var{
-					"FOO": taskfile.Var{Static: "bar"},
-					"BAR": taskfile.Var{Static: "baz"},
-					"BAZ": taskfile.Var{Static: "foo"},
-				},
+			ExpectedGlobals: &ast.Vars{
+				OrderedMap: omap.FromMapWithOrder(
+					map[string]ast.Var{
+						"FOO": {Value: "bar"},
+						"BAR": {Value: "baz"},
+						"BAZ": {Value: "foo"},
+					},
+					[]string{"FOO", "BAR", "BAZ"},
+				),
 			},
 		},
 		{
 			Args: []string{"task-a", "CONTENT=with some spaces"},
-			ExpectedCalls: []taskfile.Call{
+			ExpectedCalls: []*ast.Call{
 				{Task: "task-a"},
 			},
-			ExpectedGlobals: &taskfile.Vars{
-				Keys: []string{"CONTENT"},
-				Mapping: map[string]taskfile.Var{
-					"CONTENT": taskfile.Var{Static: "with some spaces"},
-				},
+			ExpectedGlobals: &ast.Vars{
+				OrderedMap: omap.FromMapWithOrder(
+					map[string]ast.Var{
+						"CONTENT": {Value: "with some spaces"},
+					},
+					[]string{"CONTENT"},
+				),
 			},
 		},
 		{
 			Args: []string{"FOO=bar", "task-a", "task-b"},
-			ExpectedCalls: []taskfile.Call{
+			ExpectedCalls: []*ast.Call{
 				{Task: "task-a"},
 				{Task: "task-b"},
 			},
-			ExpectedGlobals: &taskfile.Vars{
-				Keys: []string{"FOO"},
-				Mapping: map[string]taskfile.Var{
-					"FOO": {Static: "bar"},
-				},
+			ExpectedGlobals: &ast.Vars{
+				OrderedMap: omap.FromMapWithOrder(
+					map[string]ast.Var{
+						"FOO": {Value: "bar"},
+					},
+					[]string{"FOO"},
+				),
 			},
 		},
 		{
-			Args: nil,
-			ExpectedCalls: []taskfile.Call{
-				{Task: "default"},
-			},
+			Args:          nil,
+			ExpectedCalls: []*ast.Call{},
 		},
 		{
-			Args: []string{},
-			ExpectedCalls: []taskfile.Call{
-				{Task: "default"},
-			},
+			Args:          []string{},
+			ExpectedCalls: []*ast.Call{},
 		},
 		{
-			Args: []string{"FOO=bar", "BAR=baz"},
-			ExpectedCalls: []taskfile.Call{
-				{Task: "default"},
-			},
-			ExpectedGlobals: &taskfile.Vars{
-				Keys: []string{"FOO", "BAR"},
-				Mapping: map[string]taskfile.Var{
-					"FOO": {Static: "bar"},
-					"BAR": {Static: "baz"},
-				},
+			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"},
+					},
+					[]string{"FOO", "BAR"},
+				),
 			},
 		},
 	}
 
 	for i, test := range tests {
 		t.Run(fmt.Sprintf("TestArgs%d", i+1), func(t *testing.T) {
-			calls, globals := args.ParseV3(test.Args...)
+			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, globals)
+				assert.Equal(t, test.ExpectedGlobals.Keys(), globals.Keys())
+				assert.Equal(t, test.ExpectedGlobals.Values(), globals.Values())
 			}
 		})
 	}
 }
-
-func TestArgsV2(t *testing.T) {
-	tests := []struct {
-		Args            []string
-		ExpectedCalls   []taskfile.Call
-		ExpectedGlobals *taskfile.Vars
-	}{
-		{
-			Args: []string{"task-a", "task-b", "task-c"},
-			ExpectedCalls: []taskfile.Call{
-				{Task: "task-a"},
-				{Task: "task-b"},
-				{Task: "task-c"},
-			},
-		},
-		{
-			Args: []string{"task-a", "FOO=bar", "task-b", "task-c", "BAR=baz", "BAZ=foo"},
-			ExpectedCalls: []taskfile.Call{
-				{
-					Task: "task-a",
-					Vars: &taskfile.Vars{
-						Keys: []string{"FOO"},
-						Mapping: map[string]taskfile.Var{
-							"FOO": taskfile.Var{Static: "bar"},
-						},
-					},
-				},
-				{Task: "task-b"},
-				{
-					Task: "task-c",
-					Vars: &taskfile.Vars{
-						Keys: []string{"BAR", "BAZ"},
-						Mapping: map[string]taskfile.Var{
-							"BAR": taskfile.Var{Static: "baz"},
-							"BAZ": taskfile.Var{Static: "foo"},
-						},
-					},
-				},
-			},
-		},
-		{
-			Args: []string{"task-a", "CONTENT=with some spaces"},
-			ExpectedCalls: []taskfile.Call{
-				{
-					Task: "task-a",
-					Vars: &taskfile.Vars{
-						Keys: []string{"CONTENT"},
-						Mapping: map[string]taskfile.Var{
-							"CONTENT": taskfile.Var{Static: "with some spaces"},
-						},
-					},
-				},
-			},
-		},
-		{
-			Args: []string{"FOO=bar", "task-a", "task-b"},
-			ExpectedCalls: []taskfile.Call{
-				{Task: "task-a"},
-				{Task: "task-b"},
-			},
-			ExpectedGlobals: &taskfile.Vars{
-				Keys: []string{"FOO"},
-				Mapping: map[string]taskfile.Var{
-					"FOO": {Static: "bar"},
-				},
-			},
-		},
-		{
-			Args: nil,
-			ExpectedCalls: []taskfile.Call{
-				{Task: "default"},
-			},
-		},
-		{
-			Args: []string{},
-			ExpectedCalls: []taskfile.Call{
-				{Task: "default"},
-			},
-		},
-		{
-			Args: []string{"FOO=bar", "BAR=baz"},
-			ExpectedCalls: []taskfile.Call{
-				{Task: "default"},
-			},
-			ExpectedGlobals: &taskfile.Vars{
-				Keys: []string{"FOO", "BAR"},
-				Mapping: map[string]taskfile.Var{
-					"FOO": {Static: "bar"},
-					"BAR": {Static: "baz"},
-				},
-			},
-		},
-	}
-
-	for i, test := range tests {
-		t.Run(fmt.Sprintf("TestArgs%d", i+1), func(t *testing.T) {
-			calls, globals := args.ParseV2(test.Args...)
-			assert.Equal(t, test.ExpectedCalls, calls)
-			if test.ExpectedGlobals.Len() > 0 || globals.Len() > 0 {
-				assert.Equal(t, test.ExpectedGlobals, globals)
-			}
-
-		})
-	}
-}

cmd/release/main.go

@@ -0,0 +1,154 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"regexp"
+	"strings"
+	"time"
+
+	"github.com/Masterminds/semver/v3"
+	"github.com/otiai10/copy"
+)
+
+const (
+	changelogSource = "CHANGELOG.md"
+	changelogTarget = "website/docs/changelog.mdx"
+	docsSource      = "website/docs"
+	docsTarget      = "website/versioned_docs/version-latest"
+)
+
+var (
+	changelogReleaseRegex = regexp.MustCompile(`## Unreleased`)
+	versionRegex          = regexp.MustCompile(`(?m)^  "version": "\d+\.\d+\.\d+",$`)
+)
+
+func main() {
+	if err := release(); err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+}
+
+func release() error {
+	if len(os.Args) != 2 {
+		return errors.New("error: expected version number")
+	}
+
+	version, err := getVersion()
+	if err != nil {
+		return err
+	}
+
+	if err := bumpVersion(version, os.Args[1]); err != nil {
+		return err
+	}
+
+	fmt.Println(version)
+
+	if err := changelog(version); err != nil {
+		return err
+	}
+
+	if err := setJSONVersion("package.json", version); err != nil {
+		return err
+	}
+
+	if err := setJSONVersion("package-lock.json", version); err != nil {
+		return err
+	}
+
+	if err := docs(); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func getVersion() (*semver.Version, error) {
+	cmd := exec.Command("git", "describe", "--tags", "--abbrev=0")
+	b, err := cmd.Output()
+	if err != nil {
+		return nil, err
+	}
+
+	return semver.NewVersion(strings.TrimSpace(string(b)))
+}
+
+func bumpVersion(version *semver.Version, verb string) error {
+	switch verb {
+	case "major":
+		*version = version.IncMajor()
+	case "minor":
+		*version = version.IncMinor()
+	case "patch":
+		*version = version.IncPatch()
+	default:
+		*version = *semver.MustParse(verb)
+	}
+	return nil
+}
+
+func changelog(version *semver.Version) error {
+	// Open changelog target file
+	b, err := os.ReadFile(changelogTarget)
+	if err != nil {
+		return err
+	}
+
+	// Get the current frontmatter
+	currentChangelog := string(b)
+	sections := strings.SplitN(currentChangelog, "---", 3)
+	if len(sections) != 3 {
+		return errors.New("error: invalid frontmatter")
+	}
+	frontmatter := strings.TrimSpace(sections[1])
+
+	// Open changelog source file
+	b, err = os.ReadFile(changelogSource)
+	if err != nil {
+		return err
+	}
+	changelog := string(b)
+	date := time.Now().Format("2006-01-02")
+
+	// Replace "Unreleased" with the new version and date
+	changelog = changelogReleaseRegex.ReplaceAllString(changelog, fmt.Sprintf("## v%s - %s", version, date))
+
+	// Write the changelog to the source file
+	if err := os.WriteFile(changelogSource, []byte(changelog), 0o644); err != nil {
+		return err
+	}
+
+	// Add the frontmatter to the changelog
+	changelog = fmt.Sprintf("---\n%s\n---\n\n%s", frontmatter, changelog)
+
+	// Write the changelog to the target file
+	return os.WriteFile(changelogTarget, []byte(changelog), 0o644)
+}
+
+func setJSONVersion(fileName string, version *semver.Version) error {
+	// Read the JSON file
+	b, err := os.ReadFile(fileName)
+	if err != nil {
+		return err
+	}
+
+	// Replace the version
+	new := versionRegex.ReplaceAllString(string(b), fmt.Sprintf(`  "version": "%s",`, version.String()))
+
+	// Write the JSON file
+	return os.WriteFile(fileName, []byte(new), 0o644)
+}
+
+func docs() error {
+	if err := os.RemoveAll(docsTarget); err != nil {
+		return err
+	}
+	if err := copy.Copy(docsSource, docsTarget); err != nil {
+		return err
+	}
+	return nil
+}

cmd/sleepit/sleepit.go

@@ -19,10 +19,8 @@ Commands
   handle      Handle signals: on reception of SIGINT perform cleanup before exiting
   version     Show the sleepit version`
 
-var (
-	// Filled by the linker.
-	fullVersion = "unknown" // example: v0.0.9-8-g941583d027-dirty
-)
+// Filled by the linker.
+var fullVersion = "unknown" // example: v0.0.9-8-g941583d027-dirty
 
 func main() {
 	os.Exit(run(os.Args[1:]))

cmd/task/task.go

@@ -3,236 +3,195 @@ package main
 import (
 	"context"
 	"fmt"
-	"log"
 	"os"
-	"path/filepath"
-	"runtime/debug"
 	"strings"
-	"time"
 
 	"github.com/spf13/pflag"
 	"mvdan.cc/sh/v3/syntax"
 
 	"github.com/go-task/task/v3"
 	"github.com/go-task/task/v3/args"
+	"github.com/go-task/task/v3/errors"
+	"github.com/go-task/task/v3/internal/experiments"
+	"github.com/go-task/task/v3/internal/flags"
 	"github.com/go-task/task/v3/internal/logger"
-	"github.com/go-task/task/v3/taskfile"
+	"github.com/go-task/task/v3/internal/sort"
+	ver "github.com/go-task/task/v3/internal/version"
+	"github.com/go-task/task/v3/taskfile/ast"
 )
 
-var (
-	version = ""
-)
-
-const usage = `Usage: task [-ilfwvsd] [--init] [--list] [--force] [--watch] [--verbose] [--silent] [--dir] [--taskfile] [--dry] [--summary] [task...]
-
-Runs the specified task(s). Falls back to the "default" task if no task name
-was specified, or lists all tasks if an unknown task name was specified.
-
-Example: 'task hello' with the following 'Taskfile.yml' file will generate an
-'output.txt' file with the content "hello".
-
-'''
-version: '3'
-tasks:
-  hello:
-    cmds:
-      - echo "I am going to write a file named 'output.txt' now."
-      - echo "hello" > output.txt
-    generates:
-      - output.txt
-'''
-
-Options:
-`
-
 func main() {
-	log.SetFlags(0)
-	log.SetOutput(os.Stderr)
+	if err := run(); err != nil {
+		l := &logger.Logger{
+			Stdout:  os.Stdout,
+			Stderr:  os.Stderr,
+			Verbose: flags.Verbose,
+			Color:   flags.Color,
+		}
+		if err, ok := err.(*errors.TaskRunError); ok && flags.ExitCode {
+			l.Errf(logger.Red, "%v\n", err)
+			os.Exit(err.TaskExitCode())
+		}
+		if err, ok := err.(errors.TaskError); ok {
+			l.Errf(logger.Red, "%v\n", err)
+			os.Exit(err.Code())
+		}
+		l.Errf(logger.Red, "%v\n", err)
+		os.Exit(errors.CodeUnknown)
+	}
+	os.Exit(errors.CodeOk)
+}
 
-	pflag.Usage = func() {
-		log.Print(usage)
-		pflag.PrintDefaults()
+func run() error {
+	logger := &logger.Logger{
+		Stdout:  os.Stdout,
+		Stderr:  os.Stderr,
+		Verbose: flags.Verbose,
+		Color:   flags.Color,
 	}
 
-	var (
-		versionFlag bool
-		helpFlag    bool
-		init        bool
-		list        bool
-		listAll     bool
-		listJson    bool
-		status      bool
-		force       bool
-		watch       bool
-		verbose     bool
-		silent      bool
-		dry         bool
-		summary     bool
-		exitCode    bool
-		parallel    bool
-		concurrency int
-		dir         string
-		entrypoint  string
-		output      taskfile.Output
-		color       bool
-		interval    time.Duration
-	)
-
-	pflag.BoolVar(&versionFlag, "version", false, "show Task version")
-	pflag.BoolVarP(&helpFlag, "help", "h", false, "shows Task usage")
-	pflag.BoolVarP(&init, "init", "i", false, "creates a new Taskfile.yaml in the current folder")
-	pflag.BoolVarP(&list, "list", "l", false, "lists tasks with description of current Taskfile")
-	pflag.BoolVarP(&listAll, "list-all", "a", false, "lists tasks with or without a description")
-	pflag.BoolVarP(&listJson, "json", "j", false, "formats task list as json")
-	pflag.BoolVar(&status, "status", false, "exits with non-zero exit code if any of the given tasks is not up-to-date")
-	pflag.BoolVarP(&force, "force", "f", false, "forces execution even when the task is up-to-date")
-	pflag.BoolVarP(&watch, "watch", "w", false, "enables watch of the given task")
-	pflag.BoolVarP(&verbose, "verbose", "v", false, "enables verbose mode")
-	pflag.BoolVarP(&silent, "silent", "s", false, "disables echoing")
-	pflag.BoolVarP(&parallel, "parallel", "p", false, "executes tasks provided on command line in parallel")
-	pflag.BoolVarP(&dry, "dry", "n", false, "compiles and prints tasks in the order that they would be run, without executing them")
-	pflag.BoolVar(&summary, "summary", false, "show summary about a task")
-	pflag.BoolVarP(&exitCode, "exit-code", "x", false, "pass-through the exit code of the task command")
-	pflag.StringVarP(&dir, "dir", "d", "", "sets directory of execution")
-	pflag.StringVarP(&entrypoint, "taskfile", "t", "", `choose which Taskfile to run. Defaults to "Taskfile.yml"`)
-	pflag.StringVarP(&output.Name, "output", "o", "", "sets output style: [interleaved|group|prefixed]")
-	pflag.StringVar(&output.Group.Begin, "output-group-begin", "", "message template to print before a task's grouped output")
-	pflag.StringVar(&output.Group.End, "output-group-end", "", "message template to print after a task's grouped output")
-	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.DurationVarP(&interval, "interval", "I", 0, "interval to watch for changes")
-	pflag.Parse()
-
-	if versionFlag {
-		fmt.Printf("Task version: %s\n", getVersion())
-		return
+	if err := flags.Validate(); err != nil {
+		return err
 	}
 
-	if helpFlag {
+	dir := flags.Dir
+	entrypoint := flags.Entrypoint
+
+	if flags.Version {
+		fmt.Printf("Task version: %s\n", ver.GetVersion())
+		return nil
+	}
+
+	if flags.Help {
 		pflag.Usage()
-		return
+		return nil
 	}
 
-	if init {
+	if flags.Experiments {
+		return experiments.List(logger)
+	}
+
+	if flags.Init {
 		wd, err := os.Getwd()
 		if err != nil {
-			log.Fatal(err)
+			return err
 		}
 		if err := task.InitTaskfile(os.Stdout, wd); err != nil {
-			log.Fatal(err)
+			return err
 		}
-		return
+		return nil
 	}
 
-	if dir != "" && entrypoint != "" {
-		log.Fatal("task: You can't set both --dir and --taskfile")
-		return
-	}
-	if entrypoint != "" {
-		dir = filepath.Dir(entrypoint)
-		entrypoint = filepath.Base(entrypoint)
+	if flags.Global {
+		home, err := os.UserHomeDir()
+		if err != nil {
+			return fmt.Errorf("task: Failed to get user home directory: %w", err)
+		}
+		dir = home
 	}
 
-	if output.Name != "group" {
-		if output.Group.Begin != "" {
-			log.Fatal("task: You can't set --output-group-begin without --output=group")
-			return
-		}
-		if output.Group.End != "" {
-			log.Fatal("task: You can't set --output-group-end without --output=group")
-			return
-		}
+	var taskSorter sort.TaskSorter
+	switch flags.TaskSort {
+	case "none":
+		taskSorter = &sort.Noop{}
+	case "alphanumeric":
+		taskSorter = &sort.AlphaNumeric{}
 	}
 
 	e := task.Executor{
-		Force:       force,
-		Watch:       watch,
-		Verbose:     verbose,
-		Silent:      silent,
 		Dir:         dir,
-		Dry:         dry,
 		Entrypoint:  entrypoint,
-		Summary:     summary,
-		Parallel:    parallel,
-		Color:       color,
-		Concurrency: concurrency,
-		Interval:    interval,
+		Force:       flags.Force,
+		ForceAll:    flags.ForceAll,
+		Insecure:    flags.Insecure,
+		Download:    flags.Download,
+		Offline:     flags.Offline,
+		Timeout:     flags.Timeout,
+		Watch:       flags.Watch,
+		Verbose:     flags.Verbose,
+		Silent:      flags.Silent,
+		AssumeYes:   flags.AssumeYes,
+		Dry:         flags.Dry || flags.Status,
+		Summary:     flags.Summary,
+		Parallel:    flags.Parallel,
+		Color:       flags.Color,
+		Concurrency: flags.Concurrency,
+		Interval:    flags.Interval,
 
 		Stdin:  os.Stdin,
 		Stdout: os.Stdout,
 		Stderr: os.Stderr,
 
-		OutputStyle: output,
+		OutputStyle: flags.Output,
+		TaskSorter:  taskSorter,
 	}
 
-	var listOptions = task.NewListOptions(list, listAll, listJson)
+	listOptions := task.NewListOptions(flags.List, flags.ListAll, flags.ListJson, flags.NoStatus)
 	if err := listOptions.Validate(); err != nil {
-		log.Fatal(err)
-	}
-
-	if (listOptions.ShouldListTasks()) && silent {
-		e.ListTaskNames(listAll)
-		return
+		return err
 	}
 
 	if err := e.Setup(); err != nil {
-		log.Fatal(err)
+		return err
 	}
-	v, err := e.Taskfile.ParsedVersion()
-	if err != nil {
-		log.Fatal(err)
-		return
+
+	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
+	if flags.Download {
+		return nil
+	}
+
+	if (listOptions.ShouldListTasks()) && flags.Silent {
+		return e.ListTaskNames(flags.ListAll)
 	}
 
 	if listOptions.ShouldListTasks() {
-		if foundTasks, err := e.ListTasks(listOptions); !foundTasks || err != nil {
-			os.Exit(1)
+		foundTasks, err := e.ListTasks(listOptions)
+		if err != nil {
+			return err
 		}
-		return
+		if !foundTasks {
+			os.Exit(errors.CodeUnknown)
+		}
+		return nil
 	}
 
 	var (
-		calls   []taskfile.Call
-		globals *taskfile.Vars
+		calls   []*ast.Call
+		globals *ast.Vars
 	)
 
 	tasksAndVars, cliArgs, err := getArgs()
 	if err != nil {
-		log.Fatal(err)
+		return err
 	}
 
-	if v >= 3.0 {
-		calls, globals = args.ParseV3(tasksAndVars...)
-	} else {
-		calls, globals = args.ParseV2(tasksAndVars...)
+	calls, globals = args.Parse(tasksAndVars...)
+
+	// If there are no calls, run the default task instead
+	if len(calls) == 0 {
+		calls = append(calls, &ast.Call{Task: "default"})
 	}
 
-	globals.Set("CLI_ARGS", taskfile.Var{Static: cliArgs})
-	e.Taskfile.Vars.Merge(globals)
+	globals.Set("CLI_ARGS", ast.Var{Value: cliArgs})
+	globals.Set("CLI_FORCE", ast.Var{Value: flags.Force || flags.ForceAll})
+	e.Taskfile.Vars.Merge(globals, nil)
 
-	if !watch {
+	if !flags.Watch {
 		e.InterceptInterruptSignals()
 	}
 
 	ctx := context.Background()
 
-	if status {
-		if err := e.Status(ctx, calls...); err != nil {
-			log.Fatal(err)
-		}
-		return
+	if flags.Status {
+		return e.Status(ctx, calls...)
 	}
 
-	if err := e.Run(ctx, calls...); err != nil {
-		e.Logger.Errf(logger.Red, "%v", err)
-
-		if exitCode {
-			if err, ok := err.(*task.TaskRunError); ok {
-				os.Exit(err.ExitCode())
-			}
-		}
-		os.Exit(1)
-	}
+	return e.Run(ctx, calls...)
 }
 
 func getArgs() ([]string, string, error) {
@@ -255,21 +214,3 @@ func getArgs() ([]string, string, error) {
 	}
 	return args[:doubleDashPos], strings.Join(quotedCliArgs, " "), nil
 }
-
-func getVersion() string {
-	if version != "" {
-		return version
-	}
-
-	info, ok := debug.ReadBuildInfo()
-	if !ok || info.Main.Version == "" {
-		return "unknown"
-	}
-
-	version = info.Main.Version
-	if info.Main.Sum != "" {
-		version += fmt.Sprintf(" (%s)", info.Main.Sum)
-	}
-
-	return version
-}

completion/fish/task.fish

@@ -10,7 +10,7 @@ function __task_get_tasks --description "Prints all available tasks with their d
   end
 
   # Grab names and descriptions (if any) of the tasks
-  set -l output (echo $rawOutput | sed '1d; s/\* \(.*\):\s*\(.*\)/\1\t\2/' | string split0)
+  set -l output (echo $rawOutput | sed -e '1d; s/\* \(.*\):\s*\(.*\)\s*(aliases.*/\1\t\2/' -e 's/\* \(.*\):\s*\(.*\)/\1\t\2/'| string split0)
   if test $output
     echo $output
   end

completion/ps/task.ps1

@@ -1,8 +1,28 @@
-$scriptBlock = {
-	param($commandName, $parameterName, $wordToComplete, $commandAst, $fakeBoundParameters )
-	$reg = "\* ($commandName.+?):"
-	$listOutput = $(task --list-all)
-	$listOutput | Select-String $reg -AllMatches | ForEach-Object { $_.Matches.Groups[1].Value }
-}
+using namespace System.Management.Automation
 
-Register-ArgumentCompleter -CommandName task -ScriptBlock $scriptBlock
+Register-ArgumentCompleter -CommandName task -ScriptBlock {
+	param($commandName, $parameterName, $wordToComplete, $commandAst, $fakeBoundParameters)
+
+	if ($commandName.StartsWith('-')) {
+		$completions = @(
+			[CompletionResult]::new('--list-all ', '--list-all ', [CompletionResultType]::ParameterName, 'list all tasks'),
+			[CompletionResult]::new('--color ', '--color', [CompletionResultType]::ParameterName, '--color'),
+			[CompletionResult]::new('--concurrency=', '--concurrency=', [CompletionResultType]::ParameterName, 'concurrency'),
+			[CompletionResult]::new('--interval=', '--interval=', [CompletionResultType]::ParameterName, 'interval'),
+			[CompletionResult]::new('--output=interleaved ', '--output=interleaved', [CompletionResultType]::ParameterName, '--output='),
+			[CompletionResult]::new('--output=group ', '--output=group', [CompletionResultType]::ParameterName, '--output='),
+			[CompletionResult]::new('--output=prefixed ', '--output=prefixed', [CompletionResultType]::ParameterName, '--output='),
+			[CompletionResult]::new('--dry ', '--dry', [CompletionResultType]::ParameterName, '--dry'),
+			[CompletionResult]::new('--force ', '--force', [CompletionResultType]::ParameterName, '--force'),
+			[CompletionResult]::new('--parallel ', '--parallel', [CompletionResultType]::ParameterName, '--parallel'),
+			[CompletionResult]::new('--silent ', '--silent', [CompletionResultType]::ParameterName, '--silent'),
+			[CompletionResult]::new('--status ', '--status', [CompletionResultType]::ParameterName, '--status'),
+			[CompletionResult]::new('--verbose ', '--verbose', [CompletionResultType]::ParameterName, '--verbose'),
+			[CompletionResult]::new('--watch ', '--watch', [CompletionResultType]::ParameterName, '--watch')
+		)
+
+		return $completions.Where{ $_.CompletionText.StartsWith($commandName) }
+	}
+
+	return 	$(task --list-all --silent) | Where-Object { $_.StartsWith($commandName) } | ForEach-Object { return $_ + " " }
+}

completion/zsh/_task

@@ -12,13 +12,15 @@ function __task_list() {
     local taskfile item task desc
 
     cmd=(task)
-    taskfile="${(v)opt_args[(i)-t|--taskfile]}"
+    taskfile=${(Qv)opt_args[(i)-t|--taskfile]}
+    taskfile=${taskfile//\~/$HOME}
+
 
     if [[ -n "$taskfile" && -f "$taskfile" ]]; then
         enabled=1
         cmd+=(--taskfile "$taskfile")
     else
-        for taskfile in Taskfile{,.dist}.{yaml,yml}; do
+        for taskfile in {T,t}askfile{,.dist}.{yaml,yml}; do
             if [[ -f "$taskfile" ]]; then
                 enabled=1
                 break
@@ -56,7 +58,7 @@ _arguments \
     + '(operation)' \
         {-l,--list}'[list describable tasks]' \
         {-a,--list-all}'[list all tasks]' \
-        {-i,--init}'[create new Taskfile.yaml]' \
+        {-i,--init}'[create new Taskfile.yml]' \
         '(-*)'{-h,--help}'[show help]' \
         '(-*)--version[show version and exit]' \
         '*: :__task_list'

docs/babel.config.js

@@ -1,3 +0,0 @@
-module.exports = {
-  presets: [require.resolve('@docusaurus/core/lib/babel/preset')],
-};

docs/constants.js

@@ -1,13 +0,0 @@
-const GITHUB_URL = 'https://github.com/go-task/task';
-const TWITTER_URL = 'https://twitter.com/taskfiledev';
-const MASTODON_URL = 'https://fosstodon.org/@task';
-const DISCORD_URL = 'https://discord.gg/6TY36E39UK';
-const CHINESE_URL = 'https://task-zh.readthedocs.io/zh_CN/latest/';
-
-module.exports = {
-  CHINESE_URL,
-  DISCORD_URL,
-  GITHUB_URL,
-  MASTODON_URL,
-  TWITTER_URL
-};

docs/docs/api_reference.md

@@ -1,253 +0,0 @@
----
-slug: /api/
-sidebar_position: 4
----
-
-# API Reference
-
-## CLI
-
-Task command line tool has the following syntax:
-
-```bash
-task [--flags] [tasks...] [-- CLI_ARGS...]
-```
-
-:::tip
-
-If `--` is given, all remaning arguments will be assigned to a special `CLI_ARGS`
-variable
-
-:::
-
-| Short | Flag | Type | Default | Description |
-| - | - | - | - | - |
-| `-c` | `--color` | `bool` | `true` | Colored output. Enabled by default. Set flag to `false` or use `NO_COLOR=1` to disable. |
-| `-C` | `--concurrency` | `int` | `0` | Limit number tasks to run concurrently. Zero means unlimited. |
-| `-d` | `--dir` | `string` | Working directory | Sets directory of execution. |
-| `-n` | `--dry` | `bool` | `false` | Compiles and prints tasks in the order that they would be run, without executing them. |
-| `-x` | `--exit-code` | `bool` | `false` | Pass-through the exit code of the task command. |
-| `-f` | `--force` | `bool` | `false` | Forces execution even when the task is up-to-date. |
-| `-h` | `--help` | `bool` | `false` | Shows Task usage. |
-| `-i` | `--init` | `bool` | `false` | Creates a new Taskfile.yaml in the current folder. |
-| `-I` | `--interval` | `string` | `5s` | Sets a different watch interval when using `--watch`, the default being 5 seconds. This string should be a valid [Go Duration](https://pkg.go.dev/time#ParseDuration). |
-| `-l` | `--list` | `bool` | `false` | Lists tasks with description of current Taskfile. |
-| `-a` | `--list-all` | `bool` | `false` | Lists tasks with or without a description. |
-| `-o` | `--output` | `string` | Default set in the Taskfile or `intervealed` | Sets output style: [`interleaved`/`group`/`prefixed`]. |
-|      | `--output-group-begin` | `string` | | Message template to print before a task's grouped output. |
-|      | `--output-group-end` | `string` | | Message template to print after a task's grouped output. |
-| `-p` | `--parallel` | `bool` | `false` | Executes tasks provided on command line in parallel. |
-| `-s` | `--silent` | `bool` | `false` | Disables echoing. |
-|      | `--status` | `bool` | `false` | Exits with non-zero exit code if any of the given tasks is not up-to-date. |
-|      | `--summary` | `bool` | `false` | Show summary about a task. |
-| `-t` | `--taskfile` | `string` | `Taskfile.yml` or `Taskfile.yaml` | |
-| `-v` | `--verbose` | `bool` | `false` | Enables verbose mode. |
-|      | `--version` | `bool` | `false` | Show Task version. |
-| `-w` | `--watch` | `bool` | `false` | Enables watch of the given task. |
-
-## Special Variables
-
-There are some special variables that is available on the templating system:
-
-| Var | Description |
-| - | - |
-| `CLI_ARGS` | Contain all extra arguments passed after `--` when calling Task through the CLI. |
-| `TASK` | The name of the current task. |
-| `ROOT_DIR` | The absolute path of the root Taskfile. |
-| `TASKFILE_DIR` | The absolute path of the included Taskfile. |
-| `USER_WORKING_DIR` | The absolute path of the directory `task` was called from. |
-| `CHECKSUM` | The checksum of the files listed in `sources`. Only available within the `status` prop and if method is set to `checksum`. |
-| `TIMESTAMP` | The date object of the greatest timestamp of the files listes in `sources`. Only available within the `status` prop and if method is set to `timestamp`. |
-
-## ENV
-
-Some environment variables can be overriden to adjust Task behavior.
-
-| ENV | Default | Description |
-| - | - | - |
-| `TASK_TEMP_DIR` | `.task` | Location of the temp dir. Can relative to the project like `tmp/task` or absolute like `/tmp/.task` or `~/.task`. |
-| `TASK_COLOR_RESET` | `0` | Color used for white. |
-| `TASK_COLOR_BLUE` | `34` | Color used for blue. |
-| `TASK_COLOR_GREEN` | `32` | Color used for green. |
-| `TASK_COLOR_CYAN` | `36` | Color used for cyan. |
-| `TASK_COLOR_YELLOW` | `33` | Color used for yellow. |
-| `TASK_COLOR_MAGENTA` | `35` | Color used for magenta. |
-| `TASK_COLOR_RED` | `31` | Color used for red. |
-
-## Schema
-
-### Taskfile
-
-| Attribute | Type | Default | Description |
-| - | - | - | - |
-| `version` | `string` | | Version of the Taskfile. The current version is `3`. |
-| `output` | `string` | `interleaved` | Output mode. Available options: `interleaved`, `group` and `prefixed`. |
-| `method` | `string` | `checksum` | Default method in this Taskfile. Can be overriden in a task by task basis. Available options: `checksum`, `timestamp` and `none`. |
-| `includes` | [`map[string]Include`](#include) | | Additional Taskfiles to be included. |
-| `vars` | [`map[string]Variable`](#variable) | | A set of global variables. |
-| `env` | [`map[string]Variable`](#variable) | | A set of global environment variables. |
-| `tasks` | [`map[string]Task`](#task) | | A set of task definitions. |
-| `silent` | `bool` | `false` | Default 'silent' options for this Taskfile. If `false`, can be overidden with `true` in a task by task basis. |
-| `dotenv` | `[]string` | | A list of `.env` file paths to be parsed. |
-| `run` | `string` | `always` | Default 'run' option for this Taskfile. Available options: `always`, `once` and `when_changed`. |
-| `interval` | `string` | `5s` | Sets a different watch interval when using `--watch`, the default being 5 seconds. This string should be a valid [Go Duration](https://pkg.go.dev/time#ParseDuration). |
-| `set` | `[]string` | | Specify options for the [`set` builtin](https://www.gnu.org/software/bash/manual/html_node/The-Set-Builtin.html). |
-| `shopt` | `[]string` | | Specify option for the [`shopt` builtin](https://www.gnu.org/software/bash/manual/html_node/The-Shopt-Builtin.html). |
-
-### Include
-
-| Attribute | Type | Default | Description |
-| - | - | - | - |
-| `taskfile` | `string` | | The path for the Taskfile or directory to be included. If a directory, Task will look for files named `Taskfile.yml` or `Taskfile.yaml` inside that directory. If a relative path, resolved relative to the directory containing the including Taskfile. |
-| `dir` | `string` | The parent Taskfile directory | The working directory of the included tasks when run. |
-| `optional` | `bool` | `false` | If `true`, no errors will be thrown if the specified file does not exist. |
-| `internal` | `bool` | `false` | Stops any task in the included Taskfile from being callable on the command line. These commands will also be omitted from the output when used with `--list`. |
-| `aliases` | `[]string` | | Alternative names for the namespace of the included Taskfile. |
-| `vars` | `map[string]Variable` | | A set of variables to apply to the included Taskfile. |
-
-:::info
-
-Informing only a string like below is equivalent to setting that value to the `taskfile` attribute.
-
-```yaml
-includes:
-  foo: ./path
-```
-
-:::
-
-### Task
-
-| Attribute | Type | Default | Description |
-| - | - | - | - |
-| `cmds` | [`[]Command`](#command) | | A list of shell commands to be executed. |
-| `deps` | [`[]Dependency`](#dependency) | | A list of dependencies of this task. Tasks defined here will run in parallel before this task. |
-| `label` | `string` | | Overrides the name of the task in the output when a task is run. Supports variables. |
-| `desc` | `string` | | A short description of the task. This is displayed when calling `task --list`. |
-| `summary` | `string` | | A longer description of the task. This is displayed when calling `task --summary [task]`. |
-| `aliases` | `[]string` | | A list of alternative names by which the task can be called. |
-| `sources` | `[]string` | | A list of sources to check before running this task. Relevant for `checksum` and `timestamp` methods. Can be file paths or star globs. |
-| `generates` | `[]string` | | A list of files meant to be generated by this task. Relevant for `timestamp` method. Can be file paths or star globs. |
-| `status` | `[]string` | | A list of commands to check if this task should run. The task is skipped otherwise. This overrides `method`, `sources` and `generates`. |
-| `preconditions` | [`[]Precondition`](#precondition) | | A list of commands to check if this task should run. If a condition is not met, the task will error. |
-| `dir` | `string` | | The directory in which this task should run. Defaults to the current working directory. |
-| `vars` | [`map[string]Variable`](#variable) | | A set of variables that can be used in the task. |
-| `env` | [`map[string]Variable`](#variable) | | A set of environment variables that will be made available to shell commands. |
-| `dotenv` | `[]string` | | A list of `.env` file paths to be parsed. |
-| `silent` | `bool` | `false` | Hides task name and command from output. The command's output will still be redirected to `STDOUT` and `STDERR`. When combined with the `--list` flag, task descriptions will be hidden. |
-| `interactive` | `bool` | `false` | Tells task that the command is interactive. |
-| `internal` | `bool` | `false` | Stops a task from being callable on the command line. It will also be omitted from the output when used with `--list`. |
-| `method` | `string` | `checksum` | Defines which method is used to check the task is up-to-date. `timestamp` will compare the timestamp of the sources and generates files. `checksum` will check the checksum (You probably want to ignore the .task folder in your .gitignore file). `none` skips any validation and always run the task. |
-| `prefix` | `string` | | Defines a string to prefix the output of tasks running in parallel. Only used when the output mode is `prefixed`. |
-| `ignore_error` | `bool` | `false` | Continue execution if errors happen while executing commands. |
-| `run` | `string` | The one declared globally in the Taskfile or `always` | Specifies whether the task should run again or not if called more than once. Available options: `always`, `once` and `when_changed`. |
-| `platforms` | `[]string` | All platforms | Specifies which platforms the task should be run on. [Valid GOOS and GOARCH values allowed](https://github.com/golang/go/blob/master/src/go/build/syslist.go). Task will be skipped otherwise. |
-| `set` | `[]string` | | Specify options for the [`set` builtin](https://www.gnu.org/software/bash/manual/html_node/The-Set-Builtin.html). |
-| `shopt` | `[]string` | | Specify option for the [`shopt` builtin](https://www.gnu.org/software/bash/manual/html_node/The-Shopt-Builtin.html). |
-
-:::info
-
-These alternative syntaxes are available. They will set the given values to
-`cmds` and everything else will be set to their default values:
-
-```yaml
-tasks:
-  foo: echo "foo"
-
-  foobar:
-    - echo "foo"
-    - echo "bar"
-
-  baz:
-    cmd: echo "baz"
-```
-
-:::
-
-### Dependency
-
-| Attribute | Type | Default | Description |
-| - | - | - | - |
-| `task` | `string` | | The task to be execute as a dependency. |
-| `vars` | [`map[string]Variable`](#variable) | | Optional additional variables to be passed to this task. |
-
-:::tip
-
-If you don't want to set additional variables, it's enough to declare the
-dependency as a list of strings (they will be assigned to `task`):
-
-```yaml
-tasks:
-  foo:
-    deps: [foo, bar]
-```
-
-:::
-
-### Command
-
-| Attribute | Type | Default | Description |
-| - | - | - | - |
-| `cmd` | `string` | | The shell command to be executed. |
-| `silent` | `bool` | `false` | Skips some output for this command. Note that STDOUT and STDERR of the commands will still be redirected. |
-| `task` | `string` | | Set this to trigger execution of another task instead of running a command. This cannot be set together with `cmd`. |
-| `vars` | [`map[string]Variable`](#variable) | | Optional additional variables to be passed to the referenced task. Only relevant when setting `task` instead of `cmd`. |
-| `ignore_error` | `bool` | `false` | Continue execution if errors happen while executing the command. |
-| `defer` | `string` | | Alternative to `cmd`, but schedules the command to be executed at the end of this task instead of immediately. This cannot be used together with `cmd`. |
-| `platforms` | `[]string` | All platforms | Specifies which platforms the command should be run on. [Valid GOOS and GOARCH values allowed](https://github.com/golang/go/blob/master/src/go/build/syslist.go). Command will be skipped otherwise. |
-| `set` | `[]string` | | Specify options for the [`set` builtin](https://www.gnu.org/software/bash/manual/html_node/The-Set-Builtin.html). |
-| `shopt` | `[]string` | | Specify option for the [`shopt` builtin](https://www.gnu.org/software/bash/manual/html_node/The-Shopt-Builtin.html). |
-
-:::info
-
-If given as a a string, the value will be assigned to `cmd`:
-
-```yaml
-tasks:
-  foo:
-    cmds:
-      - echo "foo"
-      - echo "bar"
-```
-
-:::
-
-### Variable
-
-| Attribute | Type | Default | Description |
-| - | - | - | - |
-| *itself* | `string` | | A static value that will be set to the variable. |
-| `sh` | `string` | | A shell command. The output (`STDOUT`) will be assigned to the variable. |
-
-:::info
-
-Static and dynamic variables have different syntaxes, like below:
-
-```yaml
-vars:
-  STATIC: static
-  DYNAMIC:
-    sh: echo "dynamic"
-```
-
-:::
-
-### Precondition
-
-| Attribute | Type | Default | Description |
-| - | - | - | - |
-| `sh` | `string` | | Command to be executed. If a non-zero exit code is returned, the task errors without executing its commands. |
-| `msg` | `string` | | Optional message to print if the precondition isn't met. |
-
-:::tip
-
-If you don't want to set a different message, you can declare a precondition
-like this and the value will be assigned to `sh`:
-
-```yaml
-tasks:
-  foo:
-    precondition: test -f Taskfile.yml
-```
-
-:::

docs/docs/changelog.md

@@ -1,648 +0,0 @@
----
-slug: /changelog/
-sidebar_position: 7
----
-
-# Changelog
-
-## v3.20.0 - 2023-01-14
-
-- Improve behavior and performance of status checking when using the
-  `timestamp` mode
-  ([#976](https://github.com/go-task/task/issues/976), [#977](https://github.com/go-task/task/pull/977) by @aminya).
-- Performance optimizations were made for large Taskfiles
-  ([#982](https://github.com/go-task/task/pull/982) by @pd93).
-- Add ability to configure options for the [`set`](https://www.gnu.org/software/bash/manual/html_node/The-Set-Builtin.html)
-  and [`shopt`](https://www.gnu.org/software/bash/manual/html_node/The-Shopt-Builtin.html) builtins
-  ([#908](https://github.com/go-task/task/issues/908), [#929](https://github.com/go-task/task/pull/929) by @pd93, [Documentation](http://taskfile.dev/usage/#set-and-shopt)).
-- Add new `platforms:` attribute to `task` and `cmd`, so it's now possible to
-  choose in which platforms that given task or command will be run on. Possible
-  values are operating system (GOOS), architecture (GOARCH) or a combination of
-  the two. Example: `platforms: [linux]`, `platforms: [amd64]` or
-  `platforms: [linux/amd64]`. Other platforms will be skipped
-  ([#978](https://github.com/go-task/task/issues/978), [#980](https://github.com/go-task/task/pull/980) by @leaanthony).
-
-## v3.19.1 - 2022-12-31
-
-- Small bug fix: closing `Taskfile.yml` once we're done reading it
-  ([#963](https://github.com/go-task/task/issues/963), [#964](https://github.com/go-task/task/pull/964) by @HeCorr).
-- Fixes a bug in v2 that caused a panic when using a `Taskfile_{{OS}}.yml` file
-  ([#961](https://github.com/go-task/task/issues/961), [#971](https://github.com/go-task/task/pull/971) by @pd93).
-- Fixed a bug where watch intervals set in the Taskfile were not being respected ([#969](https://github.com/go-task/task/pull/969), [#970](https://github.com/go-task/task/pull/970) by @pd93)
-- Add `--json` flag (alias `-j`) with the intent to improve support for code
-  editors and add room to other possible integrations. This is basic for now,
-  but we plan to add more info in the near future
-  ([#936](https://github.com/go-task/task/pull/936) by @davidalpert, [#764](https://github.com/go-task/task/issues/764)).
-
-## v3.19.0 - 2022-12-05
-
-- Installation via npm now supports [pnpm](https://pnpm.io/) as well
-  ([go-task/go-npm#2](https://github.com/go-task/go-npm/issues/2), [go-task/go-npm#3](https://github.com/go-task/go-npm/pull/3)).
-- It's now possible to run Taskfiles from subdirectories! A new `USER_WORKING_DIR` special
-  variable was added to add even more flexibility for monorepos
-  ([#289](https://github.com/go-task/task/issues/289), [#920](https://github.com/go-task/task/pull/920)).
-- Add task-level `dotenv` support
-  ([#389](https://github.com/go-task/task/issues/389), [#904](https://github.com/go-task/task/pull/904)).
-- It's now possible to use global level variables on `includes`
-  ([#942](https://github.com/go-task/task/issues/942), [#943](https://github.com/go-task/task/pull/943)).
-- The website got a brand new [translation to Chinese](https://task-zh.readthedocs.io/zh_CN/latest/)
-  by [@DeronW](https://github.com/DeronW). Thanks!
-
-## v3.18.0 - 2022-11-12
-
-- Show aliases on `task --list --silent` (`task --ls`). This means that aliases
-  will be completed by the completion scripts
-  ([#919](https://github.com/go-task/task/pull/919)).
-- Tasks in the root Taskfile will now be displayed first in `--list`/`--list-all`
-  output ([#806](https://github.com/go-task/task/pull/806), [#890](https://github.com/go-task/task/pull/890)).
-- It's now possible to call a `default` task in an included Taskfile by using
-  just the namespace. For example: `docs:default` is now automatically
-  aliased to `docs`
-  ([#661](https://github.com/go-task/task/issues/661), [#815](https://github.com/go-task/task/pull/815)).
-
-## v3.17.0 - 2022-10-14
-
-- Add a "Did you mean ...?" suggestion when a task does not exits another one
-  with a similar name is found
-  ([#867](https://github.com/go-task/task/issues/867), [#880](https://github.com/go-task/task/pull/880)).
-- Now YAML parse errors will print which Taskfile failed to parse
-  ([#885](https://github.com/go-task/task/issues/885), [#887](https://github.com/go-task/task/pull/887)).
-- Add ability to set `aliases` for tasks and namespaces ([#268](https://github.com/go-task/task/pull/268), [#340](https://github.com/go-task/task/pull/340), [#879](https://github.com/go-task/task/pull/879)).
-- Improvements to Fish shell completion
-  ([#897](https://github.com/go-task/task/pull/897)).
-- Added ability to set a different watch interval by setting
-  `interval: '500ms'` or using the `--interval=500ms` flag
-  ([#813](https://github.com/go-task/task/issues/813), [#865](https://github.com/go-task/task/pull/865)).
-- Add colored output to `--list`, `--list-all` and `--summary` flags ([#845](https://github.com/go-task/task/pull/845), [#874](https://github.com/go-task/task/pull/874)).
-- Fix unexpected behavior where `label:` was being shown instead of the task
-  name on `--list`
-  ([#603](https://github.com/go-task/task/issues/603), [#877](https://github.com/go-task/task/pull/877)).
-
-## v3.16.0 - 2022-09-29
-
-- Add `npm` as new installation method: `npm i -g @go-task/cli`
-  ([#870](https://github.com/go-task/task/issues/870), [#871](https://github.com/go-task/task/pull/871), [npm package](https://www.npmjs.com/package/@go-task/cli)).
-- Add support to marking tasks and includes as internal, which will hide them
-  from `--list` and `--list-all`
-  ([#818](https://github.com/go-task/task/pull/818)).
-
-## v3.15.2 - 2022-09-08
-
-- Fix error when using variable in `env:` introduced in the previous release
-  ([#858](https://github.com/go-task/task/issues/858), [#866](https://github.com/go-task/task/pull/866)).
-- Fix handling of `CLI_ARGS` (`--`) in Bash completion
-  ([#863](https://github.com/go-task/task/pull/863)).
-- On zsh completion, add ability to replace `--list-all` with `--list` as
-  already possible on the Bash completion
-  ([#861](https://github.com/go-task/task/pull/861)).
-
-## v3.15.0 - 2022-09-03
-
-- Add new special variables `ROOT_DIR` and `TASKFILE_DIR`. This was a highly
-  requested feature
-  ([#215](https://github.com/go-task/task/issues/215), [#857](https://github.com/go-task/task/pull/857), [Documentation](https://taskfile.dev/api/#special-variables)).
-- Follow symlinks on `sources`
-  ([#826](https://github.com/go-task/task/issues/826), [#831](https://github.com/go-task/task/pull/831)).
-- Improvements and fixes to Bash completion
-  ([#835](https://github.com/go-task/task/pull/835), [#844](https://github.com/go-task/task/pull/844)).
-
-## v3.14.1 - 2022-08-03
-
-- Always resolve relative include paths relative to the including Taskfile
-  ([#822](https://github.com/go-task/task/issues/822), [#823](https://github.com/go-task/task/pull/823)).
-- Fix ZSH and PowerShell completions to consider all tasks instead of just the
-  public ones (those with descriptions)
-  ([#803](https://github.com/go-task/task/pull/803)).
-
-## v3.14.0 - 2022-07-08
-
-- Add ability to override the `.task` directory location with the
-  `TASK_TEMP_DIR` environment variable.
-- Allow to override Task colors using environment variables:
-  `TASK_COLOR_RESET`, `TASK_COLOR_BLUE`, `TASK_COLOR_GREEN`,
-  `TASK_COLOR_CYAN`, `TASK_COLOR_YELLOW`, `TASK_COLOR_MAGENTA`
-  and `TASK_COLOR_RED`
-  ([#568](https://github.com/go-task/task/pull/568), [#792](https://github.com/go-task/task/pull/792)).
-- Fixed bug when using the `output: group` mode where STDOUT and STDERR were
-  being print in separated blocks instead of in the right order
-  ([#779](https://github.com/go-task/task/issues/779)).
-- Starting on this release, ARM architecture binaries are been released to Snap
-  as well
-  ([#795](https://github.com/go-task/task/issues/795)).
-- i386 binaries won't be available anymore on Snap because Ubuntu removed the support
-  for this architecture.
-- Upgrade mvdan.cc/sh, which fixes a bug with associative arrays
-  ([#785](https://github.com/go-task/task/issues/785), [mvdan/sh#884](https://github.com/mvdan/sh/issues/884), [mvdan/sh#893](https://github.com/mvdan/sh/pull/893)).
-
-## v3.13.0 - 2022-06-13
-
-- Added `-n` as an alias to `--dry`
-  ([#776](https://github.com/go-task/task/issues/776), [#777](https://github.com/go-task/task/pull/777)).
-- Fix behavior of interrupt (SIGINT, SIGTERM) signals. Task will now give time
-  for the processes running to do cleanup work
-  ([#458](https://github.com/go-task/task/issues/458), [#479](https://github.com/go-task/task/pull/479), [#728](https://github.com/go-task/task/issues/728), [#769](https://github.com/go-task/task/pull/769)).
-- Add new `--exit-code` (`-x`) flag that will pass-through the exit form the
-  command being ran
-  ([#755](https://github.com/go-task/task/pull/755)).
-
-## v3.12.1 - 2022-05-10
-
-- Fixed bug where, on Windows, variables were ending with `\r` because we were
-  only removing the final `\n` but not `\r\n`
-  ([#717](https://github.com/go-task/task/issues/717)).
-
-## v3.12.0 - 2022-03-31
-
-- The `--list` and `--list-all` flags can now be combined with the `--silent`
-  flag to print the task names only, without their description
-  ([#691](https://github.com/go-task/task/pull/691)).
-- Added support for multi-level inclusion of Taskfiles. This means that
-  included Taskfiles can also include other Taskfiles. Before this was limited
-  to one level
-  ([#390](https://github.com/go-task/task/issues/390), [#623](https://github.com/go-task/task/discussions/623), [#656](https://github.com/go-task/task/pull/656)).
-- Add ability to specify vars when including a Taskfile.
-  [Check out the documentation](https://taskfile.dev/#/usage?id=vars-of-included-taskfiles)
-  for more information.
-  ([#677](https://github.com/go-task/task/pull/677)).
-
-## v3.11.0 - 2022-02-19
-
-- Task now supports printing begin and end messages when using the `group`
-  output mode, useful for grouping tasks in CI systems.
-  [Check out the documentation](http://taskfile.dev/#/usage?id=output-syntax) for more information
-  ([#647](https://github.com/go-task/task/issues/647), [#651](https://github.com/go-task/task/pull/651)).
-- Add `Taskfile.dist.yml` and `Taskfile.dist.yaml` to the supported file
-  name list. [Check out the documentation](https://taskfile.dev/#/usage?id=supported-file-names) for more information
-  ([#498](https://github.com/go-task/task/issues/498), [#666](https://github.com/go-task/task/pull/666)).
-
-## v3.10.0 - 2022-01-04
-
-- A new `--list-all` (alias `-a`) flag is now available. It's similar to the
-  exiting `--list` (`-l`) but prints all tasks, even those without a
-  description
-  ([#383](https://github.com/go-task/task/issues/383), [#401](https://github.com/go-task/task/pull/401)).
-- It's now possible to schedule cleanup commands to run once a task finishes
-  with the `defer:` keyword
-  ([Documentation](https://taskfile.dev/#/usage?id=doing-task-cleanup-with-defer), [#475](https://github.com/go-task/task/issues/475), [#626](https://github.com/go-task/task/pull/626)).
-- Remove long deprecated and undocumented `$` variable prefix and `^` command
-  prefix
-  ([#642](https://github.com/go-task/task/issues/642), [#644](https://github.com/go-task/task/issues/644), [#645](https://github.com/go-task/task/pull/645)).
-- Add support for `.yaml` extension (as an alternative to `.yml`).
-  This was requested multiple times throughout the years. Enjoy!
-  ([#183](https://github.com/go-task/task/issues/183), [#184](https://github.com/go-task/task/pull/184), [#369](https://github.com/go-task/task/issues/369), [#584](https://github.com/go-task/task/issues/584), [#621](https://github.com/go-task/task/pull/621)).
-- Fixed error when computing a variable when the task directory do not exist
-  yet
-  ([#481](https://github.com/go-task/task/issues/481), [#579](https://github.com/go-task/task/pull/579)).
-
-## v3.9.2 - 2021-12-02
-
-- Upgrade [mvdan/sh](https://github.com/mvdan/sh) which contains a fix a for
-  a important regression on Windows
-  ([#619](https://github.com/go-task/task/issues/619), [mvdan/sh#768](https://github.com/mvdan/sh/issues/768), [mvdan/sh#769](https://github.com/mvdan/sh/pull/769)).
-
-## v3.9.1 - 2021-11-28
-
-- Add logging in verbose mode for when a task starts and finishes
-  ([#533](https://github.com/go-task/task/issues/533), [#588](https://github.com/go-task/task/pull/588)).
-- Fix an issue with preconditions and context errors
-  ([#597](https://github.com/go-task/task/issues/597), [#598](https://github.com/go-task/task/pull/598)).
-- Quote each `{{.CLI_ARGS}}` argument to prevent one with spaces to become many
-  ([#613](https://github.com/go-task/task/pull/613)).
-- Fix  nil pointer when `cmd:` was left empty
-  ([#612](https://github.com/go-task/task/issues/612), [#614](https://github.com/go-task/task/pull/614)).
-- Upgrade [mvdan/sh](https://github.com/mvdan/sh) which contains two
-  relevant fixes:
-  - Fix quote of empty strings in `shellQuote`
-    ([#609](https://github.com/go-task/task/issues/609), [mvdan/sh#763](https://github.com/mvdan/sh/issues/763)).
-  - Fix issue of wrong environment variable being picked when there's another
-    very similar one
-    ([#586](https://github.com/go-task/task/issues/586), [mvdan/sh#745](https://github.com/mvdan/sh/pull/745)).
-- Install shell completions automatically when installing via Homebrew
-  ([#264](https://github.com/go-task/task/issues/264), [#592](https://github.com/go-task/task/pull/592), [go-task/homebrew-tap#2](https://github.com/go-task/homebrew-tap/pull/2)).
-
-## v3.9.0 - 2021-10-02
-
-- A new `shellQuote` function was added to the template system
-  (`{{shellQuote "a string"}}`) to ensure a string is safe for use in shell
-  ([mvdan/sh#727](https://github.com/mvdan/sh/pull/727), [mvdan/sh#737](https://github.com/mvdan/sh/pull/737), [Documentation](https://pkg.go.dev/mvdan.cc/sh/v3@v3.4.0/syntax#Quote))
-- In this version [mvdan.cc/sh](https://github.com/mvdan/sh) was upgraded
-  with some small fixes and features
-  - The `read -p` flag is now supported
-    ([#314](https://github.com/go-task/task/issues/314), [mvdan/sh#551](https://github.com/mvdan/sh/issues/551), [mvdan/sh#772](https://github.com/mvdan/sh/pull/722))
-  - The `pwd -P` and `pwd -L` flags are now supported
-    ([#553](https://github.com/go-task/task/issues/553), [mvdan/sh#724](https://github.com/mvdan/sh/issues/724), [mvdan/sh#728](https://github.com/mvdan/sh/pull/728))
-  - The `$GID` environment variable is now correctly being set
-    ([#561](https://github.com/go-task/task/issues/561), [mvdan/sh#723](https://github.com/mvdan/sh/pull/723))
-
-## v3.8.0 - 2021-09-26
-
-- Add `interactive: true` setting to improve support for interactive CLI apps
-  ([#217](https://github.com/go-task/task/issues/217), [#563](https://github.com/go-task/task/pull/563)).
-- Fix some `nil` errors
-  ([#534](https://github.com/go-task/task/issues/534), [#573](https://github.com/go-task/task/pull/573)).
-- Add ability to declare an included Taskfile as optional
-  ([#519](https://github.com/go-task/task/issues/519), [#552](https://github.com/go-task/task/pull/552)).
-- Add support for including Taskfiles in the home directory by using `~`
-  ([#539](https://github.com/go-task/task/issues/539), [#557](https://github.com/go-task/task/pull/557)).
-
-## v3.7.3 - 2021-09-04
-
-- Add official support to Apple M1 ([#564](https://github.com/go-task/task/pull/564), [#567](https://github.com/go-task/task/pull/567)).
-- Our [official Homebrew tap](https://github.com/go-task/homebrew-tap) will
-  support more platforms, including Apple M1
-
-## v3.7.0 - 2021-07-31
-
-- Add `run:` setting to control if tasks should run multiple times or not.
-  Available options are `always` (the default), `when_changed` (if a variable
-  modified the task) and `once` (run only once no matter what).
-  This is a long time requested feature. Enjoy!
-  ([#53](https://github.com/go-task/task/issues/53), [#359](https://github.com/go-task/task/pull/359)).
-
-## v3.6.0 - 2021-07-10
-
-- Allow using both `sources:` and `status:` in the same task
-  ([#411](https://github.com/go-task/task/issues/411), [#427](https://github.com/go-task/task/issues/427), [#477](https://github.com/go-task/task/pull/477)).
-- Small optimization and bug fix: don't compute variables if not needed for
-  `dotenv:` ([#517](https://github.com/go-task/task/issues/517)).
-
-## v3.5.0 - 2021-07-04
-
-- Add support for interpolation in `dotenv:`
-  ([#433](https://github.com/go-task/task/discussions/433), [#434](https://github.com/go-task/task/issues/434), [#453](https://github.com/go-task/task/pull/453)).
-
-## v3.4.3 - 2021-05-30
-
-- Add support for the `NO_COLOR` environment variable.
-  ([#459](https://github.com/go-task/task/issues/459), [fatih/color#137](https://github.com/fatih/color/pull/137)).
-- Fix bug where sources were not considering the right directory
-  in `--watch` mode
-  ([#484](https://github.com/go-task/task/issues/484), [#485](https://github.com/go-task/task/pull/485)).
-
-## v3.4.2 - 2021-04-23
-
-- On watch, report which file failed to read
-  ([#472](https://github.com/go-task/task/pull/472)).
-- Do not try to catch SIGKILL signal, which are not actually possible
-  ([#476](https://github.com/go-task/task/pull/476)).
-- Improve version reporting when building Task from source using Go Modules
-  ([#462](https://github.com/go-task/task/pull/462), [#473](https://github.com/go-task/task/pull/473)).
-
-## v3.4.1 - 2021-04-17
-
-- Improve error reporting when parsing YAML: in some situations where you
-  would just see an generic error, you'll now see the actual error with
-  more detail: the YAML line the failed to parse, for example
-  ([#467](https://github.com/go-task/task/issues/467)).
-- A JSON Schema was published [here](https://json.schemastore.org/taskfile.json)
-  and is automatically being used by some editors like Visual Studio Code
-  ([#135](https://github.com/go-task/task/issues/135)).
-- Print task name before the command in the log output
-  ([#398](https://github.com/go-task/task/pull/398)).
-
-## v3.3.0 - 2021-03-20
-
-- Add support for delegating CLI arguments to commands with `--` and a
-  special `CLI_ARGS` variable
-  ([#327](https://github.com/go-task/task/issues/327)).
-- Add a `--concurrency` (alias `-C`) flag, to limit the number of tasks that
-  run concurrently. This is useful for heavy workloads.
-  ([#345](https://github.com/go-task/task/pull/345)).
-
-## v3.2.2 - 2021-01-12
-
-- Improve performance of `--list` and `--summary` by skipping running shell
-  variables for these flags
-  ([#332](https://github.com/go-task/task/issues/332)).
-- Fixed a bug where an environment in a Taskfile was not always overridable
-  by the system environment
-  ([#425](https://github.com/go-task/task/issues/425)).
-- Fixed environment from .env files not being available as variables
-  ([#379](https://github.com/go-task/task/issues/379)).
-- The install script is now working for ARM platforms
-  ([#428](https://github.com/go-task/task/pull/428)).
-
-## v3.2.1 - 2021-01-09
-
-- Fixed some bugs and regressions regarding dynamic variables and directories
-  ([#426](https://github.com/go-task/task/issues/426)).
-- The [slim-sprig](https://github.com/go-task/slim-sprig) package was updated
-  with the upstream [sprig](https://github.com/Masterminds/sprig).
-
-## v3.2.0 - 2021-01-07
-
-- Fix the `.task` directory being created in the task directory instead of the
-  Taskfile directory
-  ([#247](https://github.com/go-task/task/issues/247)).
-- Fix a bug where dynamic variables (those declared with `sh:`) were not
-  running in the task directory when the task has a custom dir or it was
-  in an included Taskfile
-  ([#384](https://github.com/go-task/task/issues/384)).
-- The watch feature (via the `--watch` flag) got a few different bug fixes and
-  should be more stable now
-  ([#423](https://github.com/go-task/task/pull/423), [#365](https://github.com/go-task/task/issues/365)).
-
-## v3.1.0 - 2021-01-03
-
-- Fix a bug when the checksum up-to-date resolution is used by a task
-  with a custom `label:` attribute
-  ([#412](https://github.com/go-task/task/issues/412)).
-- Starting from this release, we're releasing official ARMv6 and ARM64 binaries
-  for Linux
-  ([#375](https://github.com/go-task/task/issues/375), [#418](https://github.com/go-task/task/issues/418)).
-- Task now respects the order of declaration of included Taskfiles when
-  evaluating variables declaring by them
-  ([#393](https://github.com/go-task/task/issues/393)).
-- `set -e` is now automatically set on every command. This was done to fix an
-  issue where multiline string commands wouldn't really fail unless the
-  sentence was in the last line
-  ([#403](https://github.com/go-task/task/issues/403)).
-
-## v3.0.1 - 2020-12-26
-
-- Allow use as a library by moving the required packages out of the `internal`
-  directory
-  ([#358](https://github.com/go-task/task/pull/358)).
-- Do not error if a specified dotenv file does not exist
-  ([#378](https://github.com/go-task/task/issues/378), [#385](https://github.com/go-task/task/pull/385)).
-- Fix panic when you have empty tasks in your Taskfile
-  ([#338](https://github.com/go-task/task/issues/338), [#362](https://github.com/go-task/task/pull/362)).
-
-## v3.0.0 - 2020-08-16
-
-- On `v3`, all CLI variables will be considered global variables
-  ([#336](https://github.com/go-task/task/issues/336), [#341](https://github.com/go-task/task/pull/341))
-- Add support to `.env` like files
-  ([#324](https://github.com/go-task/task/issues/324), [#356](https://github.com/go-task/task/pull/356)).
-- Add `label:` to task so you can override the task name in the logs
-  ([#321](https://github.com/go-task/task/issues/321]), [#337](https://github.com/go-task/task/pull/337)).
-- Refactor how variables work on version 3
-  ([#311](https://github.com/go-task/task/pull/311)).
-- Disallow `expansions` on v3 since it has no effect.
-- `Taskvars.yml` is not automatically included anymore.
-- `Taskfile_{{OS}}.yml` is not automatically included anymore.
-- Allow interpolation on `includes`, so you can manually include a Taskfile
-  based on operation system, for example.
-- Expose `.TASK` variable in templates with the task name
-  ([#252](https://github.com/go-task/task/issues/252)).
-- Implement short task syntax
-  ([#194](https://github.com/go-task/task/issues/194), [#240](https://github.com/go-task/task/pull/240)).
-- Added option to make included Taskfile run commands on its own directory
-  ([#260](https://github.com/go-task/task/issues/260), [#144](https://github.com/go-task/task/issues/144))
-- Taskfiles in version 1 are not supported anymore
-  ([#237](https://github.com/go-task/task/pull/237)).
-- Added global `method:` option. With this option, you can set a default
-  method to all tasks in a Taskfile
-  ([#246](https://github.com/go-task/task/issues/246)).
-- Changed default method from `timestamp` to `checksum`
-  ([#246](https://github.com/go-task/task/issues/246)).
-- New magic variables are now available when using `status:`:
-  `.TIMESTAMP` which contains the greatest modification date
-  from the files listed in `sources:`, and `.CHECKSUM`, which
-  contains a checksum of all files listed in `status:`.
-  This is useful for manual checking when using external, or even remote,
-  artifacts when using `status:`
-  ([#216](https://github.com/go-task/task/pull/216)).
-- We're now using [slim-sprig](https://github.com/go-task/slim-sprig) instead of
-  [sprig](https://github.com/Masterminds/sprig), which allowed a file size
-  reduction of about 22%
-  ([#219](https://github.com/go-task/task/pull/219)).
-- We now use some colors on Task output to better distinguish message types -
-  commands are green, errors are red, etc
-  ([#207](https://github.com/go-task/task/pull/207)).
-
-## v2.8.1 - 2020-05-20
-
-- Fix error code for the `--help` flag
-  ([#300](https://github.com/go-task/task/issues/300), [#330](https://github.com/go-task/task/pull/330)).
-- Print version to stdout instead of stderr
-  ([#299](https://github.com/go-task/task/issues/299), [#329](https://github.com/go-task/task/pull/329)).
-- Supress `context` errors when using the `--watch` flag
-  ([#313](https://github.com/go-task/task/issues/313), [#317](https://github.com/go-task/task/pull/317)).
-- Support templating on description
-  ([#276](https://github.com/go-task/task/issues/276), [#283](https://github.com/go-task/task/pull/283)).
-
-## v2.8.0 - 2019-12-07
-
-- Add `--parallel` flag (alias `-p`) to run tasks given by the command line in
-  parallel
-  ([#266](https://github.com/go-task/task/pull/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
-  Taskfile.
-
-## v2.7.1 - 2019-11-10
-
-- Fix error being raised when `exit 0` was called
-  ([#251](https://github.com/go-task/task/issues/251)).
-
-## v2.7.0 - 2019-09-22
-
-- Fixed panic bug when assigning a global variable
-  ([#229](https://github.com/go-task/task/issues/229), [#243](https://github.com/go-task/task/issues/234)).
-- A task with `method: checksum` will now re-run if generated files are deleted
-  ([#228](https://github.com/go-task/task/pull/228), [#238](https://github.com/go-task/task/issues/238)).
-
-## v2.6.0 - 2019-07-21
-
-- Fixed some bugs regarding minor version checks on `version:`.
-- Add `preconditions:` to task
-  ([#205](https://github.com/go-task/task/pull/205)).
-- Create directory informed on `dir:` if it doesn't exist
-  ([#209](https://github.com/go-task/task/issues/209), [#211](https://github.com/go-task/task/pull/211)).
-- We now have a `--taskfile` flag (alias `-t`), which can be used to run
-  another Taskfile (other than the default `Taskfile.yml`)
-  ([#221](https://github.com/go-task/task/pull/221)).
-- It's now possible to install Task using Homebrew on Linux
-  ([go-task/homebrew-tap#1](https://github.com/go-task/homebrew-tap/pull/1)).
-
-## v2.5.2 - 2019-05-11
-
-- Reverted YAML upgrade due issues with CRLF on Windows
-  ([#201](https://github.com/go-task/task/issues/201), [go-yaml/yaml#450](https://github.com/go-yaml/yaml/issues/450)).
-- Allow setting global variables through the CLI
-  ([#192](https://github.com/go-task/task/issues/192)).
-
-## 2.5.1 - 2019-04-27
-
-- Fixed some issues with interactive command line tools, where sometimes
-  the output were not being shown, and similar issues
-  ([#114](https://github.com/go-task/task/issues/114), [#190](https://github.com/go-task/task/issues/190), [#200](https://github.com/go-task/task/pull/200)).
-- Upgraded [go-yaml/yaml](https://github.com/go-yaml/yaml) from v2 to v3.
-
-## v2.5.0 - 2019-03-16
-
-- We moved from the taskfile.org domain to the new fancy taskfile.dev domain.
-  While stuff is being redirected, we strongly recommend to everyone that use
-  [this install script](https://taskfile.dev/#/installation?id=install-script)
-  to use the new taskfile.dev domain on scripts from now on.
-- Fixed to the ZSH completion
-  ([#182](https://github.com/go-task/task/pull/182)).
-- Add [`--summary` flag along with `summary:` task attribute](https://taskfile.org/#/usage?id=display-summary-of-task)
-  ([#180](https://github.com/go-task/task/pull/180)).
-
-## v2.4.0 - 2019-02-21
-
-- Allow calling a task of the root Taskfile from an included Taskfile
-  by prefixing it with `:`
-  ([#161](https://github.com/go-task/task/issues/161), [#172](https://github.com/go-task/task/issues/172)),
-- Add flag to override the `output` option
-  ([#173](https://github.com/go-task/task/pull/173));
-- Fix bug where Task was persisting the new checksum on the disk when the Dry
-  Mode is enabled
-  ([#166](https://github.com/go-task/task/issues/166));
-- Fix file timestamp issue when the file name has spaces
-  ([#176](https://github.com/go-task/task/issues/176));
-- Mitigating path expanding issues on Windows
-  ([#170](https://github.com/go-task/task/pull/170)).
-
-## v2.3.0 - 2019-01-02
-
-- On Windows, Task can now be installed using [Scoop](https://scoop.sh/)
-  ([#152](https://github.com/go-task/task/pull/152));
-- Fixed issue with file/directory globing
-  ([#153](https://github.com/go-task/task/issues/153));
-- Added ability to globally set environment variables
-  (
-    [#138](https://github.com/go-task/task/pull/138),
-    [#159](https://github.com/go-task/task/pull/159)
-  ).
-
-## v2.2.1 - 2018-12-09
-
-- This repository now uses Go Modules (#143). We'll still keep the `vendor` directory in sync for some time, though;
-- Fixing a bug when the Taskfile has no tasks but includes another Taskfile (#150);
-- Fix a bug when calling another task or a dependency in an included Taskfile (#151).
-
-## v2.2.0 - 2018-10-25
-
-- Added support for [including other Taskfiles](https://taskfile.org/#/usage?id=including-other-taskfiles) (#98)
-  - This should be considered experimental. For now, only including local files is supported, but support for including remote Taskfiles is being discussed. If you have any feedback, please comment on #98.
-- Task now have a dedicated documentation site: https://taskfile.org
-  - Thanks to [Docsify](https://docsify.js.org/) for making this pretty easy. To check the source code, just take a look at the [docs](https://github.com/go-task/task/tree/master/docs) directory of this repository. Contributions to the documentation is really appreciated.
-
-## v2.1.1 - 2018-09-17
-
-- Fix suggestion to use `task --init` not being shown anymore (when a `Taskfile.yml` is not found)
-- Fix error when using checksum method and no file exists for a source glob (#131)
-- Fix signal handling when the `--watch` flag is given (#132)
-
-## v2.1.0 - 2018-08-19
-
-- Add a `ignore_error` option to task and command (#123)
-- Add a dry run mode (`--dry` flag) (#126)
-
-## v2.0.3 - 2018-06-24
-
-- Expand environment variables on "dir", "sources" and "generates" (#116)
-- Fix YAML merging syntax (#112)
-- Add ZSH completion (#111)
-- Implement new `output` option. Please check out the [documentation](https://github.com/go-task/task#output-syntax)
-
-## v2.0.2 - 2018-05-01
-
-- Fix merging of YAML anchors (#112)
-
-## v2.0.1 - 2018-03-11
-
-- Fixes panic on `task --list`
-
-## v2.0.0 - 2018-03-08
-
-Version 2.0.0 is here, with a new Taskfile format.
-
-Please, make sure to read the [Taskfile versions](https://github.com/go-task/task/blob/master/TASKFILE_VERSIONS.md) document, since it describes in depth what changed for this version.
-
-* New Taskfile version 2 (https://github.com/go-task/task/issues/77)
-* Possibility to have global variables in the `Taskfile.yml` instead of `Taskvars.yml` (https://github.com/go-task/task/issues/66)
-* Small improvements and fixes
-
-## v1.4.4 - 2017-11-19
-
-- Handle SIGINT and SIGTERM (#75);
-- List: print message with there's no task with description;
-- Expand home dir ("~" symbol) on paths (#74);
-- Add Snap as an installation method;
-- Move examples to its own repo;
-- Watch: also walk on tasks called on on "cmds", and not only on "deps";
-- Print logs to stderr instead of stdout (#68);
-- Remove deprecated `set` keyword;
-- Add checksum based status check, alternative to timestamp based.
-
-## 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)
-- 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 and #60)
-
-## v1.4.2 - 2017-07-30
-
-- Flag to set directory of execution
-- Always echo command if is verbose mode
-- Add silent mode to disable echoing of commands
-- Fixes and improvements of variables (#56)
-
-## v1.4.1 - 2017-07-15
-
-- Allow use of YAML for dynamic variables instead of $ prefix
-  - `VAR: {sh: echo Hello}` instead of `VAR: $echo Hello`
-- Add `--list` (or `-l`) flag to print existing tasks
-- OS specific Taskvars file (e.g. `Taskvars_windows.yml`, `Taskvars_linux.yml`, etc)
-- Consider task up-to-date on equal timestamps (#49)
-- Allow absolute path in generates section (#48)
-- Bugfix: allow templating when calling deps (#42)
-- Fix panic for invalid task in cyclic dep detection
-- Better error output for dynamic variables in Taskvars.yml (#41)
-- Allow template evaluation in parameters
-
-## v1.4.0 - 2017-07-06
-
-- Cache dynamic variables
-- Add verbose mode (`-v` flag)
-- Support to task parameters (overriding vars) (#31) (#32)
-- Print command, also when "set:" is specified (#35)
-- Improve task command help text (#35)
-
-## v1.3.1 - 2017-06-14
-
-- Fix glob not working on commands (#28)
-- Add ExeExt template function
-- Add `--init` flag to create a new Taskfile
-- Add status option to prevent task from running (#27)
-- Allow interpolation on `generates` and `sources` attributes (#26)
-
-## v1.3.0 - 2017-04-24
-
-- Migrate from os/exec.Cmd to a native Go sh/bash interpreter
-  - This is a potentially breaking change if you use Windows.
-  - Now, `cmd` is not used anymore on Windows. Always use Bash-like syntax for your commands, even on Windows.
-- Add "ToSlash" and "FromSlash" to template functions
-- Use functions defined on github.com/Masterminds/sprig
-- Do not redirect stdin while running variables commands
-- Using `context` and `errgroup` packages (this will make other tasks to be cancelled, if one returned an error)
-
-## v1.2.0 - 2017-04-02
-
-- More tests and Travis integration
-- Watch a task (experimental)
-- Possibility to call another task
-- Fix "=" not being reconized 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)
-
-## v1.1.0 - 2017-03-08
-
-- Support for YAML, TOML and JSON (#1)
-- Support running command in another directory (#4)
-- `--force` or `-f` flag to force execution of task even when it's up-to-date
-- Detection of cyclic dependencies (#5)
-- Support for variables (#6, #9, #14)
-- Operation System specific commands and variables (#13)
-
-## v1.0.0 - 2017-02-28
-
-- Add LICENSE file

docs/docs/community.md

@@ -1,68 +0,0 @@
----
-slug: /community/
-sidebar_position: 8
----
-
-# Community
-
-Some of the work to improve the Task ecosystem is done by the community, be
-it installation methods or integrations with code editor. I (the author) am
-thankful for everyone that helps me to improve the overall experience.
-
-## Translations
-
-[@DeronW](https://github.com/DeronW) maintains  the
-[Chinese translation](https://task-zh.readthedocs.io/zh_CN/latest/) of the
-website [on this repository](https://github.com/DeronW/task).
-
-## Editor Integrations
-
-### JSON Schema
-
-Initial work on the schema was made by [@KROSF](https://github.com/KROSF)
-on [this Gist](https://gist.github.com/KROSF/c5435acf590acd632f71bb720f685895).
-The schema is currently available at
-https://taskfile.dev/schema.json and linked at https://json.schemastore.org/taskfile.json
-so it is be used automatically many code editors, like VSCode.
-Contributions can be done by editing [this file](https://github.com/go-task/task/blob/master/docs/static/schema.json).
-
-### Visual Studio Code extension
-
-Additionally, there's also some work done by
-[@paulvarache](https://github.com/paulvarache) in making an Visual Studio Code
-extension, which has its code [here](https://github.com/paulvarache/vscode-taskfile)
-and is published [here](https://marketplace.visualstudio.com/items?itemName=paulvarache.vscode-taskfile).
-
-### Sublime Text 4 package
-
-There is a convenience wrapper for initializing and running tasks from Sublime Text's command palette. The package is
-developed by [@biozz](https://github.com/biozz), the source code is available [here](https://github.com/biozz/sublime-taskfile)
-and it is published on Package Control [here](https://packagecontrol.io/packages/Taskfile).
-
-### IntelliJ plugin
-
-There's a JetBrains IntelliJ plugin done by
-[@lechuckroh](https://github.com/lechuckroh), which has its code [here](https://github.com/lechuckroh/task-intellij-plugin)
-and is published [here](https://plugins.jetbrains.com/plugin/17058-taskfile).
-
-## Installation methods
-
-Some installation methods are maintained by third party:
-
-- [GitHub Actions](https://github.com/arduino/setup-task)
-  by [@arduino](https://github.com/arduino)
-- [AUR](https://aur.archlinux.org/packages/go-task-bin)
-  by [@carlsmedstad](https://github.com/carlsmedstad)
-- [Scoop](https://github.com/lukesampson/scoop-extras/blob/master/bucket/task.json)
-- [Fedora](https://packages.fedoraproject.org/pkgs/golang-github-task/go-task/)
-- [NixOS](https://github.com/NixOS/nixpkgs/blob/master/pkgs/development/tools/go-task/default.nix)
-
-## More
-
-Also, thanks for all the [code contributors](https://github.com/go-task/task/graphs/contributors),
-[financial contributors](https://opencollective.com/task), all those who
-[reported bugs](https://github.com/go-task/task/issues?q=is%3Aissue) and
-[answered questions](https://github.com/go-task/task/discussions).
-
-If you know something that is missing in this document, please submit a
-pull request.

docs/docs/contributing.md

@@ -1,124 +0,0 @@
----
-slug: /contributing/
-sidebar_position: 9
----
-
-# Contributing
-
-Contributions to Task are very welcome, but we ask that you read this document
-before submitting a PR.
-
-## Before you start
-
-- **Check existing work** - Is there an existing PR? Are there issues discussing
-the feature/change you want to make? Please make sure you consider/address these
-discussions in your work.
-- **Backwards compatibility** - Will your change break existing Taskfiles? It is
-much more likely that your change will merged if it backwards compatible. Is
-there an approach you can take that maintains this compatibility? If not,
-consider opening an issue first so that API changes can be discussed before you
-invest you time into a PR.
-
-## 1. Setup
-
-- **Go** - Task is written in [Go]. We always support the latest two major Go
-  versions, so make sure your version is recent enough.
-- **Node.js** - [Node.js] is used to host Task's documentation server and is
-  required if you want to run this server locally.
-- **Yarn** - [Yarn] is the Node.js package manager used by Task.
-
-## 2. Making changes
-
-- **Code style** - Try to maintain the existing code style where possible and
-  ensure that code is formatted by `gofmt`. We use `golangci-lint` in our CI to
-  enforce a consistent style and best-practise. There's a `lint` command in
-  the Taskfile to run this locally.
-- **Documentation** - Ensure that you add/update any relevant documentation. See
-  the [updating documentation](#updating-documentation) section below.
-- **Tests** - Ensure that you add/update any relevant tests and that all tests
-  are passing before submitting the PR. See the [writing tests](#writing-tests)
-  section below.
-
-### Running your changes
-
-To run Task with working changes, you can use `go run ./cmd/task`. To run a
-development build of task against a test Taskfile in `testdata`, you can use `go
-run ./cmd/task --dir ./testdata/<my_test_dir> <task_name>`.
-
-### Updating documentation
-
-Task uses [Docusaurus] to host a documentation server. This can be setup and run
-locally by using `task docs:setup` and `task docs:start` respectively (requires
-`nodejs` & `yarn`). All content is written in Markdown and is located in the
-`docs/docs` directory. All Markdown documents should have an 80 character line
-wrap limit.
-
-When making a change, consider whether a change to the [Usage Guide](./usage.md)
-is necessary. This document contains descriptions and examples of how to use
-Task features. If you're adding a new feature, try to find an appropriate place
-to add a new section. If you're updating an existing feature, ensure that the
-documentation and any examples are up-to-date. Ensure that any examples follow
-the [Taskfile Styleguide](./styleguide.md).
-
-If you added a new field, command or flag, ensure that you add it to the [API
-Reference](./api_reference.md). New fields also need to be added to the
-[JSON Schema](../static/schema.json). The descriptions for fields in the API
-reference and the schema should match.
-
-### Writing tests
-
-Most of Task's test are held in the `task_test.go` file in the project root and
-this is where you'll most likely want to add new ones too. Most of these tests
-also have a subdirectory in the `testdata` directory where any Taskfiles/data
-required to run the tests are stored.
-
-When making a changes, consider whether new tests are required. These tests
-should ensure that the functionality you are adding will continue to work in the
-future. Existing tests may also need updating if you have changed Task's
-behaviour.
-
-## 3. Committing your code
-
-Try to write meaningful commit messages and avoid having too many commits on
-the PR. Most PRs should likely have a single commit (although for bigger PRs it
-may be reasonable to split it in a few). Git squash and rebase is your friend!
-
-## 4. Submitting a PR
-
-- **Describe your changes** - Ensure that you provide a comprehensive
-  description of your changes.
-- **Issue/PR links** - Link any previous work such as related issues or PRs.
-  Please describe how your changes differ to/extend this work.
-- **Examples** - Add any examples that you think are useful to demonstrate the
-  effect of your changes.
-- **Draft PRs** - If your changes are incomplete, but you would like to discuss
-  them, open the PR as a draft and add a comment to start a discussion. Using
-  comments rather than the PR description allows the description to be updated
-  later while preserving any discussions.
-
-## FAQ
-
-> I want to contribute, where do I start?
-
-Take a look at the list of [open issues]. We have a [good first issue] label for
-simpler issues that are ideal for first time contributions.
-
-All kinds of contributions are welcome, whether its a typo fix or a shiny new
-feature. You can also contribute by upvoting/commenting on issues, helping to
-answer questions or contributing to other [community projects](./community.md).
-
-> I'm stuck, where can I get help?
-
-If you have questions, feel free to ask them in the `#help` channel on our
-[Discord server].
-
----
-
-[Go]: https://go.dev
-[install version 1.18+]: https://go.dev/doc/install
-[Node.js]: https://nodejs.org/en/
-[Yarn]: https://yarnpkg.com/
-[Docusaurus]: https://docusaurus.io
-[open issues]: https://github.com/go-task/task/issues
-[good first issue]: https://github.com/go-task/task/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22
-[Discord server]: https://discord.gg/6TY36E39UK

docs/docs/releasing.md

@@ -1,60 +0,0 @@
----
-slug: /releasing/
-sidebar_position: 10
----
-
-# Releasing
-
-The release process of Task is done with the help of
-[GoReleaser][goreleaser]. You can test the release process locally by calling
-the `test-release` task of the Taskfile.
-
-[GitHub Actions](https://github.com/go-task/task/actions) should release
-artifacts automatically when a new Git tag is pushed to master
-(raw executables and DEB and RPM packages).
-
-Since v3.15.0, raw executables can also be reproduced and verified locally by
-checking out a specific tag and calling `goreleaser build`, using the Go version
-defined in the above GitHub Actions.
-
-# Homebrew
-
-Goreleaser will automatically push a new commit to the
-[Formula/go-task.rb][gotaskrb] file in the [Homebrew tap][homebrewtap]
-repository to release the new version.
-
-# npm
-
-To release to npm update the version in the [`package.json`][packagejson] file
-and then run `task npm:publish` to push it.
-
-# Snapcraft
-
-The [snap package][snappackage] requires to manual steps to release a new
-version:
-
-* Updating the current version on [snapcraft.yaml][snapcraftyaml].
-* Moving both `amd64`, `armhf` and `arm64` new artifacts to the stable channel on
-the [Snapcraft dashboard][snapcraftdashboard].
-
-# Scoop
-
-Scoop is a command-line package manager for the Windows operating system.
-Scoop package manifests are maintained by the community.
-Scoop owners usually take care of updating versions there by editing [this file](https://github.com/ScoopInstaller/Main/blob/master/bucket/task.json).
-If you think its Task version is outdated, open an issue to let us know.
-
-# Nix
-
-Nix is a community owned installation method. Nix package maintainers usually take care
-of updating versions there by editing
-[this file](https://github.com/NixOS/nixpkgs/blob/nixos-unstable/pkgs/development/tools/go-task/default.nix).
-If you think its Task version is outdated, open an issue to let us know.
-
-[goreleaser]: https://goreleaser.com/
-[homebrewtap]: https://github.com/go-task/homebrew-tap
-[gotaskrb]: https://github.com/go-task/homebrew-tap/blob/master/Formula/go-task.rb
-[packagejson]: https://github.com/go-task/task/blob/master/package.json#L3
-[snappackage]: https://github.com/go-task/snap
-[snapcraftyaml]: https://github.com/go-task/snap/blob/master/snap/snapcraft.yaml#L2
-[snapcraftdashboard]: https://snapcraft.io/task/releases

docs/docusaurus.config.js

@@ -1,200 +0,0 @@
-// @ts-check
-// Note: type annotations allow type checking and IDEs autocompletion
-
-const {
-  CHINESE_URL,
-  DISCORD_URL,
-  GITHUB_URL,
-  MASTODON_URL,
-  TWITTER_URL
-} = require('./constants');
-const lightCodeTheme = require('./src/themes/prismLight');
-const darkCodeTheme = require('./src/themes/prismDark');
-
-/** @type {import('@docusaurus/types').Config} */
-const config = {
-  title: 'Task',
-  tagline: 'A task runner / simpler Make alternative written in Go ',
-  url: 'https://taskfile.dev',
-  baseUrl: '/',
-  onBrokenLinks: 'throw',
-  onBrokenMarkdownLinks: 'throw',
-  favicon: 'img/favicon.ico',
-
-  organizationName: 'go-task',
-  projectName: 'task',
-  deploymentBranch: 'gh-pages',
-
-  i18n: {
-    defaultLocale: 'en',
-    locales: ['en']
-  },
-
-  presets: [
-    [
-      'classic',
-      /** @type {import('@docusaurus/preset-classic').Options} */
-      ({
-        docs: {
-          routeBasePath: '/',
-          sidebarPath: require.resolve('./sidebars.js')
-        },
-        blog: false,
-        theme: {
-          customCss: [
-            require.resolve('./src/css/custom.css'),
-            require.resolve('./src/css/carbon.css')
-          ]
-        },
-        gtag: {
-          trackingID: 'G-4RT25NXQ7N',
-          anonymizeIP: true
-        },
-        sitemap: {
-          changefreq: 'weekly',
-          priority: 0.5,
-          ignorePatterns: ['/tags/**']
-        }
-      })
-    ]
-  ],
-
-  themeConfig:
-    /** @type {import('@docusaurus/preset-classic').ThemeConfig} */
-    ({
-      metadata: [
-        {
-          name: 'og:image',
-          content: 'https://taskfile.dev/img/og-image.png'
-        }
-      ],
-      navbar: {
-        title: 'Task',
-        logo: {
-          alt: 'Task Logo',
-          src: 'img/logo.svg'
-        },
-        items: [
-          {
-            type: 'doc',
-            docId: 'installation',
-            position: 'left',
-            label: 'Installation'
-          },
-          {
-            type: 'doc',
-            docId: 'usage',
-            position: 'left',
-            label: 'Usage'
-          },
-          {
-            type: 'doc',
-            docId: 'api_reference',
-            position: 'left',
-            label: 'API'
-          },
-          {
-            type: 'doc',
-            docId: 'donate',
-            position: 'left',
-            label: 'Donate'
-          },
-          {
-            href: GITHUB_URL,
-            label: 'GitHub',
-            position: 'right'
-          },
-          {
-            href: TWITTER_URL,
-            label: 'Twitter',
-            position: 'right'
-          },
-          {
-            href: MASTODON_URL,
-            label: 'Mastodon',
-            position: 'right'
-          },
-          {
-            href: DISCORD_URL,
-            label: 'Discord',
-            position: 'right'
-          }
-        ]
-      },
-      footer: {
-        style: 'dark',
-        links: [
-          {
-            title: 'Pages',
-            items: [
-              {
-                label: 'Installation',
-                to: '/installation/'
-              },
-              {
-                label: 'Usage',
-                to: '/usage/'
-              },
-              {
-                label: 'Donate',
-                to: '/donate/'
-              }
-            ]
-          },
-          {
-            title: 'Community',
-            items: [
-              {
-                label: 'GitHub',
-                href: GITHUB_URL
-              },
-              {
-                label: 'Twitter',
-                href: TWITTER_URL
-              },
-              {
-                label: 'Mastodon',
-                href: MASTODON_URL
-              },
-              {
-                label: 'Discord',
-                href: DISCORD_URL
-              },
-              {
-                label: 'OpenCollective',
-                href: 'https://opencollective.com/task'
-              }
-            ]
-          },
-          {
-            title: 'Translations',
-            items: [
-              {
-                label: 'Chinese | 中国人',
-                href: CHINESE_URL
-              }
-            ]
-          }
-        ]
-      },
-      prism: {
-        theme: lightCodeTheme,
-        darkTheme: darkCodeTheme
-      },
-      // NOTE(@andreynering): Don't worry, these keys are meant to be public =)
-      algolia: {
-        appId: '7IZIJ13AI7',
-        apiKey: '34b64ae4fc8d9da43d9a13d9710aaddc',
-        indexName: 'taskfile'
-      }
-    }),
-
-  scripts: [
-    {
-      src: '/js/carbon.js',
-      async: true
-    }
-  ]
-};
-
-module.exports = config;

docs/package.json

@@ -1,41 +0,0 @@
-{
-  "name": "taskfile-dev",
-  "version": "0.0.0",
-  "private": true,
-  "scripts": {
-    "docusaurus": "docusaurus",
-    "start": "docusaurus start",
-    "build": "docusaurus build",
-    "swizzle": "docusaurus swizzle",
-    "deploy": "docusaurus deploy",
-    "clear": "docusaurus clear",
-    "serve": "docusaurus serve",
-    "write-translations": "docusaurus write-translations",
-    "write-heading-ids": "docusaurus write-heading-ids"
-  },
-  "dependencies": {
-    "@docusaurus/core": "^2.2.0",
-    "@docusaurus/preset-classic": "^2.2.0",
-    "@mdx-js/react": "^1.6.22",
-    "clsx": "^1.1.1",
-    "prism-react-renderer": "^1.3.1",
-    "raw-loader": "^4.0.2",
-    "react": "^17.0.2",
-    "react-dom": "^17.0.2"
-  },
-  "devDependencies": {
-    "@docusaurus/module-type-aliases": "2.0.0-beta.20"
-  },
-  "browserslist": {
-    "production": [
-      ">0.5%",
-      "not dead",
-      "not op_mini all"
-    ],
-    "development": [
-      "last 1 chrome version",
-      "last 1 firefox version",
-      "last 1 safari version"
-    ]
-  }
-}

docs/prettier.config.js

@@ -1,4 +0,0 @@
-module.exports = {
-  trailingComma: 'none',
-  singleQuote: true
-};

docs/sidebars.js

@@ -1,24 +0,0 @@
-// @ts-check
-
-const { CHINESE_URL } = require('./constants');
-
-/** @type {import('@docusaurus/plugin-content-docs').SidebarsConfig} */
-const sidebars = {
-  tutorialSidebar: [
-    {
-      type: 'autogenerated',
-      dirName: '.'
-    },
-    {
-      type: 'link',
-      label: 'Chinese | 中国人',
-      href: CHINESE_URL
-    },
-    {
-      type: 'html',
-      value: '<div id="sidebar-ads"></div>'
-    }
-  ]
-};
-
-module.exports = sidebars;

docs/src/css/custom.css

@@ -1,38 +0,0 @@
-@import url('https://fonts.googleapis.com/css2?family=Roboto+Mono:ital,wght@0,400;0,700;1,400;1,700&family=Roboto:ital,wght@0,400;0,700;1,400;1,700&display=swap');
-
-:root {
-  --ifm-font-family-base: Roboto, system-ui, -apple-system, Segoe UI, Ubuntu, Cantarell, Noto Sans, sans-serif, BlinkMacSystemFont, 'Segoe UI', Helvetica, Arial, sans-serif;
-  --ifm-font-family-monospace: 'Roboto Mono', SFMono-Regular, Menlo, Monaco, Consolas, 'Liberation Mono', 'Courier New', monospace;
-
-  --ifm-color-primary: #43ABA2 ;
-  --ifm-color-primary-dark: #3AB2A6;
-  --ifm-color-primary-darker: #32B8AB;
-  --ifm-color-primary-darkest: #29BEB0;
-  --ifm-color-primary-light: #4CA59D;
-  --ifm-color-primary-lighter: #559F98;
-  --ifm-color-primary-lightest: #5D9993;
-  --ifm-code-font-size: 95%;
-  --docusaurus-highlighted-code-line-bg: rgba(0, 0, 0, 0.1);
-}
-
-[data-theme='dark'] {
-  --docusaurus-highlighted-code-line-bg: rgba(0, 0, 0, 0.3);
-}
-
-.code-block--max-width {
-  width: 100%;
-}
-
-#carbonads {
-  margin-top: 30px;
-  margin-right: 10px;
-}
-
-.gold-sponsors {
-  display: flex;
-  justify-content: center;
-}
-
-.gold-sponsors table img {
-  width: 200px;
-}

docs/static/js/carbon.js

@@ -1,29 +0,0 @@
-(function () {
-  function attachAd() {
-    var el = document.createElement('script');
-    el.setAttribute('type', 'text/javascript');
-    el.setAttribute('id', '_carbonads_js');
-    el.setAttribute(
-      'src',
-      '//cdn.carbonads.com/carbon.js?serve=CESI65QJ&placement=taskfiledev'
-    );
-    el.setAttribute('async', 'async');
-
-    var wrapper = document.getElementById('sidebar-ads');
-    wrapper.innerHTML = '';
-    wrapper.appendChild(el);
-  }
-
-  setTimeout(function () {
-    attachAd();
-
-    var currentPath = window.location.pathname;
-
-    setInterval(function () {
-      if (currentPath !== window.location.pathname) {
-        currentPath = window.location.pathname;
-        attachAd();
-      }
-    }, 1000);
-  }, 1000);
-})();

docs/static/schema.json

@@ -1,456 +0,0 @@
-{
-  "$schema": "http://json-schema.org/draft-07/schema",
-  "title": "Taskfile YAML Schema",
-  "description": "Schema for Taskfile files.",
-  "definitions": {
-    "3": {
-      "env": {
-        "$ref": "#/definitions/3/vars"
-      },
-      "tasks": {
-        "type": "object",
-        "patternProperties": {
-          "^.*$": {
-            "anyOf": [
-              {
-                "type": "string"
-              },
-              {
-                "type": "array",
-                "items": {
-                  "oneOf": [
-                    {
-                      "type": "string"
-                    },
-                    {
-                      "$ref": "#/definitions/3/task_call"
-                    }
-                  ]
-                }
-              },
-              {
-                "$ref": "#/definitions/3/task"
-              }
-            ]
-          }
-        }
-      },
-      "task": {
-        "type": "object",
-        "additionalProperties": false,
-        "properties": {
-          "cmds": {
-            "description": "A list of commands to be executed.",
-            "$ref": "#/definitions/3/cmds"
-          },
-          "deps": {
-            "description": "A list of dependencies of this task. Tasks defined here will run in parallel before this task.",
-            "type": "array",
-            "items": {
-              "oneOf": [
-                {
-                  "type": "string"
-                },
-                {
-                  "$ref": "#/definitions/3/task_call"
-                }
-              ]
-            }
-          },
-          "label": {
-            "description": "Overrides the name of the task in the output when a task is run. Supports variables.",
-            "type": "string"
-          },
-          "desc": {
-            "description": "A short description of the task. This is displayed when calling `task --list`.",
-            "type": "string"
-          },
-          "summary": {
-            "description": "A longer description of the task. This is displayed when calling `task --summary [task]`.",
-            "type": "string"
-          },
-          "aliases": {
-            "description": "A list of alternative names by which the task can be called.",
-            "type": "array",
-            "items": {
-              "type": "string"
-            }
-          },
-          "sources": {
-            "description": "A list of sources to check before running this task. Relevant for `checksum` and `timestamp` methods. Can be file paths or star globs.",
-            "type": "array",
-            "items": {
-              "type": "string"
-            }
-          },
-          "generates": {
-            "description": "A list of files meant to be generated by this task. Relevant for `timestamp` method. Can be file paths or star globs.",
-            "type": "array",
-            "items": {
-              "type": "string"
-            }
-          },
-          "status": {
-            "description": "A list of commands to check if this task should run. The task is skipped otherwise. This overrides `method`, `sources` and `generates`.",
-            "type": "array",
-            "items": {
-              "type": "string"
-            }
-          },
-          "preconditions": {
-            "description": "A list of commands to check if this task should run. If a condition is not met, the task will error.",
-            "type": "array",
-            "items": {
-              "$ref": "#/definitions/3/precondition"
-            }
-          },
-          "dir": {
-            "description": "The directory in which this task should run. Defaults to the current working directory.",
-            "type": "string"
-          },
-          "set": {
-            "description": "Enables POSIX shell options for all of a task's commands. See https://www.gnu.org/software/bash/manual/html_node/The-Set-Builtin.html",
-            "type": "array",
-            "items": {
-              "$ref": "#/definitions/3/set"
-            }
-          },
-          "shopt": {
-            "description": "Enables Bash shell options for all of a task's commands. See https://www.gnu.org/software/bash/manual/html_node/The-Shopt-Builtin.html",
-            "type": "array",
-            "items": {
-              "$ref": "#/definitions/3/shopt"
-            }
-          },
-          "vars": {
-            "description": "A set of variables that can be used in the task.",
-            "$ref": "#/definitions/3/vars"
-          },
-          "env": {
-            "description": "A set of environment variables that will be made available to shell commands.",
-            "$ref": "#/definitions/3/env"
-          },
-          "dotenv": {
-            "description": "A list of `.env` file paths to be parsed.",
-            "type": "array",
-            "items": {
-              "type": "string"
-            }
-          },
-          "silent": {
-            "description": "Hides task name and command from output. The command's output will still be redirected to `STDOUT` and `STDERR`. When combined with the `--list` flag, task descriptions will be hidden.",
-            "type": "boolean",
-            "default": false
-          },
-          "interactive": {
-            "description": "Tells task that the command is interactive.",
-            "type": "boolean",
-            "default": false
-          },
-          "internal": {
-            "description": "Stops a task from being callable on the command line. It will also be omitted from the output when used with `--list`.",
-            "type": "boolean",
-            "default": false
-          },
-          "method": {
-            "description": "Defines which method is used to check the task is up-to-date. `timestamp` will compare the timestamp of the sources and generates files. `checksum` will check the checksum (You probably want to ignore the .task folder in your .gitignore file). `none` skips any validation and always run the task.",
-            "type": "string",
-            "enum": ["none", "checksum", "timestamp"],
-            "default": "none"
-          },
-          "prefix": {
-            "description": "Defines a string to prefix the output of tasks running in parallel. Only used when the output mode is `prefixed`.",
-            "type": "string"
-          },
-          "ignore_error": {
-            "description": "Continue execution if errors happen while executing commands.",
-            "type": "boolean"
-          },
-          "run": {
-            "description": "Specifies whether the task should run again or not if called more than once. Available options: `always`, `once` and `when_changed`.",
-            "$ref": "#/definitions/3/run"
-          },
-          "platforms": {
-            "description": "Specifies which platforms the task should be run on.",
-            "type": "array",
-            "items": {
-              "type": "string"
-            }
-          }
-        }
-      },
-      "cmds": {
-        "type": "array",
-        "items": {
-          "$ref": "#/definitions/3/cmd"
-        }
-      },
-      "cmd": {
-        "anyOf": [
-          {
-            "type": "string"
-          },
-          {
-            "$ref": "#/definitions/3/cmd_call"
-          },
-          {
-            "$ref": "#/definitions/3/task_call"
-          }
-        ]
-      },
-      "set": {
-        "type": "string",
-        "enum": ["allexport", "a", "errexit", "e", "noexec", "n", "noglob", "f", "nounset", "u", "xtrace", "x", "pipefail"]
-      },
-      "shopt": {
-        "type": "string",
-        "enum": ["expand_aliases", "globstar", "nullglob"]
-      },
-      "vars": {
-        "type": "object",
-        "patternProperties": {
-          "^.*$": {
-            "anyOf": [
-              {
-                "type": ["boolean", "integer", "null", "number", "string"]
-              },
-              {
-                "$ref": "#/definitions/3/dynamic_var"
-              }
-            ]
-          }
-        }
-      },
-      "dynamic_var": {
-        "type": "object",
-        "properties": {
-          "sh": {
-            "type": "string",
-            "description": "The value will be treated as a command and the output assigned"
-          },
-          "additionalProperties": false
-        }
-      },
-      "task_call": {
-        "type": "object",
-        "properties": {
-          "task": {
-            "description": "Name of the task to run",
-            "type": "string"
-          },
-          "vars": {
-            "description": "Values passed to the task called",
-            "$ref": "#/definitions/3/vars"
-          }
-        }
-      },
-      "cmd_call": {
-        "type": "object",
-        "properties": {
-          "cmd": {
-            "description": "Command to run",
-            "type": "string"
-          },
-          "silent": {
-            "description": "Silent mode disables echoing of command before Task runs it",
-            "type": "boolean"
-          },
-          "set": {
-            "description": "Enables POSIX shell options for this command. See https://www.gnu.org/software/bash/manual/html_node/The-Set-Builtin.html",
-            "type": "array",
-            "items": {
-              "$ref": "#/definitions/3/set"
-            }
-          },
-          "shopt": {
-            "description": "Enables Bash shell options for this command. See https://www.gnu.org/software/bash/manual/html_node/The-Shopt-Builtin.html",
-            "type": "array",
-            "items": {
-              "$ref": "#/definitions/3/shopt"
-            }
-          },
-          "ignore_error": {
-            "description": "Prevent command from aborting the execution of task even after receiving a status code of 1",
-            "type": "boolean"
-          },
-          "defer": {
-            "description": "",
-            "type": "boolean"
-          },
-          "platforms": {
-            "description": "Specifies which platforms the command should be run on.",
-            "type": "array",
-            "items": {
-              "type": "string"
-            }
-          }
-        },
-        "additionalProperties": false,
-        "required": ["cmd"]
-      },
-      "precondition": {
-        "anyOf": [
-          {
-            "type": "string"
-          },
-          {
-            "$ref": "#/definitions/3/precondition_obj"
-          }
-        ]
-      },
-      "precondition_obj": {
-        "type": "object",
-        "properties": {
-          "sh": {
-            "description": "Command to run. If that command returns 1, the condition will fail",
-            "type": "string"
-          },
-          "msg": {
-            "description": "Failure message to display when the condition fails",
-            "type": "string"
-          }
-        }
-      },
-      "run": {
-        "type": "string",
-        "enum": ["always", "once", "when_changed"]
-      }
-    }
-  },
-  "allOf": [
-    {
-      "type": "object",
-      "properties": {
-        "version": {
-          "description": "Specify the Taskfile format that this file conforms to.",
-          "anyOf": [
-            {
-              "type": "number",
-              "enum": [3]
-            },
-            {
-              "type": "string",
-              "enum": ["3"]
-            }
-          ]
-        },
-        "output": {
-          "description": "Defines how the STDOUT and STDERR are printed when running tasks in parallel. The interleaved output prints lines in real time (default). The group output will print the entire output of a command once, after it finishes, so you won't have live feedback for commands that take a long time to run. The prefix output will prefix every line printed by a command with [task-name] as the prefix, but you can customize the prefix for a command with the prefix: attribute.",
-          "type": "string",
-          "enum": ["interleaved", "group", "prefixed"],
-          "default": "interleaved"
-        },
-        "method": {
-          "description": "Defines which method is used to check the task is up-to-date. (default: checksum)",
-          "type": "string",
-          "enum": ["none", "checksum", "timestamp"],
-          "default": "checksum"
-        },
-        "includes": {
-          "description": "Imports tasks from the specified taskfiles. The tasks described in the given Taskfiles will be available with the informed namespace.",
-          "type": "object",
-          "patternProperties": {
-            "^.*$": {
-              "anyOf": [
-                {
-                  "type": "string"
-                },
-                {
-                  "type": "object",
-                  "properties": {
-                    "taskfile": {
-                      "description": "The path for the Taskfile or directory to be included. If a directory, Task will look for files named `Taskfile.yml` or `Taskfile.yaml` inside that directory. If a relative path, resolved relative to the directory containing the including Taskfile.",
-                      "type": "string"
-                    },
-                    "dir": {
-                      "description": "The working directory of the included tasks when run.",
-                      "type": "string"
-                    },
-                    "optional": {
-                      "description": "If `true`, no errors will be thrown if the specified file does not exist.",
-                      "type": "boolean"
-                    },
-                    "internal": {
-                      "description": "Stops any task in the included Taskfile from being callable on the command line. These commands will also be omitted from the output when used with `--list`.",
-                      "type": "boolean"
-                    },
-                    "aliases": {
-                      "description": "Alternative names for the namespace of the included Taskfile.",
-                      "type": "array",
-                      "items": {
-                        "type": "string"
-                      }
-                    },
-                    "vars": {
-                      "description": "A set of variables to apply to the included Taskfile.",
-                      "$ref": "#/definitions/3/vars"
-                    }
-                  }
-                }
-              ]
-            }
-          }
-        },
-        "vars": {
-          "description": "A set of global variables.",
-          "$ref": "#/definitions/3/vars"
-        },
-        "env": {
-          "description": "A set of global environment variables.",
-          "$ref": "#/definitions/3/env"
-        },
-        "tasks": {
-          "description": "A set of task definitions.",
-          "$ref": "#/definitions/3/tasks"
-        },
-        "silent": {
-          "description": "Default 'silent' options for this Taskfile. If `false`, can be overidden with `true` in a task by task basis.",
-          "type": "boolean"
-        },
-        "set": {
-          "description": "Enables POSIX shell options for all commands in the Taskfile. See https://www.gnu.org/software/bash/manual/html_node/The-Set-Builtin.html",
-          "type": "array",
-          "items": {
-            "$ref": "#/definitions/3/set"
-          }
-        },
-        "shopt": {
-          "description": "Enables Bash shell options for all commands in the Taskfile. See https://www.gnu.org/software/bash/manual/html_node/The-Shopt-Builtin.html",
-          "type": "array",
-          "items": {
-            "$ref": "#/definitions/3/shopt"
-          }
-        },
-        "dotenv": {
-          "type": "array",
-          "description": "A list of `.env` file paths to be parsed.",
-          "items": {
-            "type": "string"
-          }
-        },
-        "run": {
-          "description": "Default 'run' option for this Taskfile. Available options: `always`, `once` and `when_changed`.",
-          "$ref": "#/definitions/3/run"
-        },
-        "interval": {
-          "description": "Sets a different watch interval when using `--watch`, the default being 5 seconds. This string should be a valid Go duration: https://pkg.go.dev/time#ParseDuration.",
-          "type": "string",
-          "pattern": "^[0-9]+(?:m|s|ms)$"
-        }
-      },
-      "additionalProperties": false,
-      "required": ["version"],
-      "anyOf": [
-        {
-          "required": ["includes"]
-        },
-        {
-          "required": ["tasks"]
-        },
-        {
-          "required": ["includes", "tasks"]
-        }
-      ]
-    }
-  ]
-}

errors.go

@@ -1,80 +0,0 @@
-package task
-
-import (
-	"errors"
-	"fmt"
-	"strings"
-
-	"mvdan.cc/sh/v3/interp"
-)
-
-var (
-	// ErrTaskfileAlreadyExists is returned on creating a Taskfile if one already exists
-	ErrTaskfileAlreadyExists = errors.New("task: A Taskfile already exists")
-)
-
-type taskNotFoundError struct {
-	taskName   string
-	didYouMean string
-}
-
-func (err *taskNotFoundError) Error() string {
-	if err.didYouMean != "" {
-		return fmt.Sprintf(
-			`task: Task %q does not exist. Did you mean %q?`,
-			err.taskName,
-			err.didYouMean,
-		)
-	}
-
-	return fmt.Sprintf(`task: Task %q does not exist`, err.taskName)
-}
-
-type multipleTasksWithAliasError struct {
-	aliasName string
-	taskNames []string
-}
-
-func (err *multipleTasksWithAliasError) Error() string {
-	return fmt.Sprintf(`task: Multiple tasks (%s) with alias %q found`, strings.Join(err.taskNames, ", "), err.aliasName)
-}
-
-type taskInternalError struct {
-	taskName string
-}
-
-func (err *taskInternalError) Error() string {
-	return fmt.Sprintf(`task: Task "%s" is internal`, err.taskName)
-}
-
-type TaskRunError struct {
-	taskName string
-	err      error
-}
-
-func (err *TaskRunError) Error() string {
-	return fmt.Sprintf(`task: Failed to run task %q: %v`, err.taskName, err.err)
-}
-
-func (err *TaskRunError) ExitCode() int {
-	if c, ok := interp.IsExitStatus(err.err); ok {
-		return int(c)
-	}
-
-	return 1
-}
-
-// MaximumTaskCallExceededError is returned when a task is called too
-// many times. In this case you probably have a cyclic dependendy or
-// infinite loop
-type MaximumTaskCallExceededError struct {
-	task string
-}
-
-func (e *MaximumTaskCallExceededError) Error() string {
-	return fmt.Sprintf(
-		`task: maximum task call exceeded (%d) for task %q: probably an cyclic dep or infinite loop`,
-		MaximumTaskCall,
-		e.task,
-	)
-}

errors/errors.go

@@ -0,0 +1,60 @@
+package errors
+
+import "errors"
+
+// General exit codes
+const (
+	CodeOk      int = iota // Used when the program exits without errors
+	CodeUnknown            // Used when no other exit code is appropriate
+)
+
+// Taskfile related exit codes
+const (
+	CodeTaskfileNotFound int = iota + 100
+	CodeTaskfileAlreadyExists
+	CodeTaskfileInvalid
+	CodeTaskfileFetchFailed
+	CodeTaskfileNotTrusted
+	CodeTaskfileNotSecure
+	CodeTaskfileCacheNotFound
+	CodeTaskfileVersionCheckError
+	CodeTaskfileNetworkTimeout
+	_ // CodeTaskfileDuplicateInclude
+	CodeTaskfileCycle
+)
+
+// Task related exit codes
+const (
+	CodeTaskNotFound int = iota + 200
+	CodeTaskRunError
+	CodeTaskInternal
+	CodeTaskNameConflict
+	CodeTaskCalledTooManyTimes
+	CodeTaskCancelled
+	CodeTaskMissingRequiredVars
+)
+
+// TaskError extends the standard error interface with a Code method. This code will
+// be used as the exit code of the program which allows the user to distinguish
+// between different types of errors.
+type TaskError interface {
+	error
+	Code() int
+}
+
+// New returns an error that formats as the given text. Each call to New returns
+// a distinct error value even if the text is identical. This wraps the standard
+// errors.New function so that we don't need to alias that package.
+func New(text string) error {
+	return errors.New(text)
+}
+
+// Is wraps the standard errors.Is function so that we don't need to alias that package.
+func Is(err, target error) bool {
+	return errors.Is(err, target)
+}
+
+// As wraps the standard errors.As function so that we don't need to alias that package.
+func As(err error, target any) bool {
+	return errors.As(err, target)
+}

errors/errors_task.go

@@ -0,0 +1,147 @@
+package errors
+
+import (
+	"fmt"
+	"strings"
+
+	"mvdan.cc/sh/v3/interp"
+)
+
+// TaskNotFoundError is returned when the specified task is not found in the
+// Taskfile.
+type TaskNotFoundError struct {
+	TaskName   string
+	DidYouMean string
+}
+
+func (err *TaskNotFoundError) Error() string {
+	if err.DidYouMean != "" {
+		return fmt.Sprintf(
+			`task: Task %q does not exist. Did you mean %q?`,
+			err.TaskName,
+			err.DidYouMean,
+		)
+	}
+
+	return fmt.Sprintf(`task: Task %q does not exist`, err.TaskName)
+}
+
+func (err *TaskNotFoundError) Code() int {
+	return CodeTaskNotFound
+}
+
+// TaskRunError is returned when a command in a task returns a non-zero exit
+// code.
+type TaskRunError struct {
+	TaskName string
+	Err      error
+}
+
+func (err *TaskRunError) Error() string {
+	return fmt.Sprintf(`task: Failed to run task %q: %v`, err.TaskName, err.Err)
+}
+
+func (err *TaskRunError) Code() int {
+	return CodeTaskRunError
+}
+
+func (err *TaskRunError) TaskExitCode() int {
+	if c, ok := interp.IsExitStatus(err.Err); ok {
+		return int(c)
+	}
+	return err.Code()
+}
+
+// TaskInternalError when the user attempts to invoke a task that is internal.
+type TaskInternalError struct {
+	TaskName string
+}
+
+func (err *TaskInternalError) Error() string {
+	return fmt.Sprintf(`task: Task "%s" is internal`, err.TaskName)
+}
+
+func (err *TaskInternalError) Code() int {
+	return CodeTaskInternal
+}
+
+// TaskNameConflictError is returned when multiple tasks with a matching name or
+// alias are found.
+type TaskNameConflictError struct {
+	Call      string
+	TaskNames []string
+}
+
+func (err *TaskNameConflictError) Error() string {
+	return fmt.Sprintf(`task: Found multiple tasks (%s) that match %q`, strings.Join(err.TaskNames, ", "), err.Call)
+}
+
+func (err *TaskNameConflictError) Code() int {
+	return CodeTaskNameConflict
+}
+
+// TaskCalledTooManyTimesError is returned when the maximum task call limit is
+// exceeded. This is to prevent infinite loops and cyclic dependencies.
+type TaskCalledTooManyTimesError struct {
+	TaskName        string
+	MaximumTaskCall int
+}
+
+func (err *TaskCalledTooManyTimesError) Error() string {
+	return fmt.Sprintf(
+		`task: Maximum task call exceeded (%d) for task %q: probably an cyclic dep or infinite loop`,
+		err.MaximumTaskCall,
+		err.TaskName,
+	)
+}
+
+func (err *TaskCalledTooManyTimesError) Code() int {
+	return CodeTaskCalledTooManyTimes
+}
+
+// TaskCancelledByUserError is returned when the user does not accept an optional prompt to continue.
+type TaskCancelledByUserError struct {
+	TaskName string
+}
+
+func (err *TaskCancelledByUserError) Error() string {
+	return fmt.Sprintf(`task: Task %q cancelled by user`, err.TaskName)
+}
+
+func (err *TaskCancelledByUserError) Code() int {
+	return CodeTaskCancelled
+}
+
+// TaskCancelledNoTerminalError is returned when trying to run a task with a prompt in a non-terminal environment.
+type TaskCancelledNoTerminalError struct {
+	TaskName string
+}
+
+func (err *TaskCancelledNoTerminalError) Error() string {
+	return fmt.Sprintf(
+		`task: Task %q cancelled because it has a prompt and the environment is not a terminal. Use --yes (-y) to run anyway.`,
+		err.TaskName,
+	)
+}
+
+func (err *TaskCancelledNoTerminalError) Code() int {
+	return CodeTaskCancelled
+}
+
+// TaskMissingRequiredVars is returned when a task is missing required variables.
+type TaskMissingRequiredVars struct {
+	TaskName    string
+	MissingVars []string
+}
+
+func (err *TaskMissingRequiredVars) Error() string {
+	return fmt.Sprintf(
+		`task: Task %q cancelled because it is missing required variables: %s`,
+		err.TaskName,
+		strings.Join(err.MissingVars, ", "),
+	)
+}
+
+func (err *TaskMissingRequiredVars) Code() int {
+	return CodeTaskMissingRequiredVars
+}

errors/errors_taskfile.go

@@ -0,0 +1,194 @@
+package errors
+
+import (
+	"fmt"
+	"net/http"
+	"time"
+
+	"github.com/Masterminds/semver/v3"
+)
+
+// TaskfileNotFoundError is returned when no appropriate Taskfile is found when
+// searching the filesystem.
+type TaskfileNotFoundError struct {
+	URI  string
+	Walk bool
+}
+
+func (err TaskfileNotFoundError) Error() string {
+	var walkText string
+	if err.Walk {
+		walkText = " (or any of the parent directories)"
+	}
+	return fmt.Sprintf(`task: No Taskfile found at %q%s`, err.URI, walkText)
+}
+
+func (err TaskfileNotFoundError) Code() int {
+	return CodeTaskfileNotFound
+}
+
+// TaskfileAlreadyExistsError is returned on creating a Taskfile if one already
+// exists.
+type TaskfileAlreadyExistsError struct{}
+
+func (err TaskfileAlreadyExistsError) Error() string {
+	return "task: A Taskfile already exists"
+}
+
+func (err TaskfileAlreadyExistsError) Code() int {
+	return CodeTaskfileAlreadyExists
+}
+
+// TaskfileInvalidError is returned when the Taskfile contains syntax errors or
+// cannot be parsed for some reason.
+type TaskfileInvalidError struct {
+	URI string
+	Err error
+}
+
+func (err TaskfileInvalidError) Error() string {
+	return fmt.Sprintf("task: Failed to parse %s:\n%v", err.URI, err.Err)
+}
+
+func (err TaskfileInvalidError) Code() int {
+	return CodeTaskfileInvalid
+}
+
+// TaskfileFetchFailedError is returned when no appropriate Taskfile is found when
+// searching the filesystem.
+type TaskfileFetchFailedError struct {
+	URI            string
+	HTTPStatusCode int
+}
+
+func (err TaskfileFetchFailedError) Error() string {
+	var statusText string
+	if err.HTTPStatusCode != 0 {
+		statusText = fmt.Sprintf(" with status code %d (%s)", err.HTTPStatusCode, http.StatusText(err.HTTPStatusCode))
+	}
+	return fmt.Sprintf(`task: Download of %q failed%s`, err.URI, statusText)
+}
+
+func (err TaskfileFetchFailedError) Code() int {
+	return CodeTaskfileFetchFailed
+}
+
+// TaskfileNotTrustedError is returned when the user does not accept the trust
+// prompt when downloading a remote Taskfile.
+type TaskfileNotTrustedError struct {
+	URI string
+}
+
+func (err *TaskfileNotTrustedError) Error() string {
+	return fmt.Sprintf(
+		`task: Taskfile %q not trusted by user`,
+		err.URI,
+	)
+}
+
+func (err *TaskfileNotTrustedError) Code() int {
+	return CodeTaskfileNotTrusted
+}
+
+// TaskfileNotSecureError is returned when the user attempts to download a
+// remote Taskfile over an insecure connection.
+type TaskfileNotSecureError struct {
+	URI string
+}
+
+func (err *TaskfileNotSecureError) Error() string {
+	return fmt.Sprintf(
+		`task: Taskfile %q cannot be downloaded over an insecure connection. You can override this by using the --insecure flag`,
+		err.URI,
+	)
+}
+
+func (err *TaskfileNotSecureError) Code() int {
+	return CodeTaskfileNotSecure
+}
+
+// TaskfileCacheNotFoundError is returned when the user attempts to use an offline
+// (cached) Taskfile but the files does not exist in the cache.
+type TaskfileCacheNotFoundError struct {
+	URI string
+}
+
+func (err *TaskfileCacheNotFoundError) Error() string {
+	return fmt.Sprintf(
+		`task: Taskfile %q was not found in the cache. Remove the --offline flag to use a remote copy or download it using the --download flag`,
+		err.URI,
+	)
+}
+
+func (err *TaskfileCacheNotFoundError) Code() int {
+	return CodeTaskfileCacheNotFound
+}
+
+// TaskfileVersionCheckError is returned when the user attempts to run a
+// Taskfile that does not contain a Taskfile schema version key or if they try
+// to use a feature that is not supported by the schema version.
+type TaskfileVersionCheckError struct {
+	URI           string
+	SchemaVersion *semver.Version
+	Message       string
+}
+
+func (err *TaskfileVersionCheckError) Error() string {
+	if err.SchemaVersion == nil {
+		return fmt.Sprintf(
+			`task: Missing schema version in Taskfile %q`,
+			err.URI,
+		)
+	}
+	return fmt.Sprintf(
+		"task: Invalid schema version in Taskfile %q:\nSchema version (%s) %s",
+		err.URI,
+		err.SchemaVersion.String(),
+		err.Message,
+	)
+}
+
+func (err *TaskfileVersionCheckError) Code() int {
+	return CodeTaskfileVersionCheckError
+}
+
+// TaskfileNetworkTimeoutError is returned when the user attempts to use a remote
+// Taskfile but a network connection could not be established within the timeout.
+type TaskfileNetworkTimeoutError struct {
+	URI          string
+	Timeout      time.Duration
+	CheckedCache bool
+}
+
+func (err *TaskfileNetworkTimeoutError) Error() string {
+	var cacheText string
+	if err.CheckedCache {
+		cacheText = " and no offline copy was found in the cache"
+	}
+	return fmt.Sprintf(
+		`task: Network connection timed out after %s while attempting to download Taskfile %q%s`,
+		err.Timeout, err.URI, cacheText,
+	)
+}
+
+func (err *TaskfileNetworkTimeoutError) Code() int {
+	return CodeTaskfileNetworkTimeout
+}
+
+// TaskfileCycleError is returned when we detect that a Taskfile includes a
+// set of Taskfiles that include each other in a cycle.
+type TaskfileCycleError struct {
+	Source      string
+	Destination string
+}
+
+func (err TaskfileCycleError) Error() string {
+	return fmt.Sprintf("task: include cycle detected between %s <--> %s",
+		err.Source,
+		err.Destination,
+	)
+}
+
+func (err TaskfileCycleError) Code() int {
+	return CodeTaskfileCycle
+}

go.mod

@@ -1,29 +1,35 @@
 module github.com/go-task/task/v3
 
+go 1.21.0
+
 require (
-	github.com/fatih/color v1.13.0
-	github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0
-	github.com/joho/godotenv v1.4.0
+	github.com/Masterminds/semver/v3 v3.2.1
+	github.com/davecgh/go-spew v1.1.1
+	github.com/dominikbraun/graph v0.23.0
+	github.com/fatih/color v1.16.0
+	github.com/go-task/slim-sprig/v3 v3.0.0
+	github.com/go-task/template v0.0.0-20240422130016-8f6b279b1e90
+	github.com/joho/godotenv v1.5.1
 	github.com/mattn/go-zglob v0.0.4
 	github.com/mitchellh/hashstructure/v2 v2.0.2
+	github.com/otiai10/copy v1.14.0
 	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.8.1
-	golang.org/x/exp v0.0.0-20220930202632-ec3f01382ef9
-	golang.org/x/sync v0.1.0
+	github.com/stretchr/testify v1.9.0
+	github.com/zeebo/xxh3 v1.0.2
+	golang.org/x/sync v0.7.0
+	golang.org/x/term v0.19.0
 	gopkg.in/yaml.v3 v3.0.1
-	mvdan.cc/sh/v3 v3.6.0
+	mvdan.cc/sh/v3 v3.8.0
 )
 
 require (
-	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/mattn/go-colorable v0.1.9 // indirect
-	github.com/mattn/go-isatty v0.0.14 // indirect
+	github.com/klauspost/cpuid/v2 v2.0.9 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
+	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
-	golang.org/x/sys v0.3.0 // indirect
-	golang.org/x/term v0.3.0 // indirect
+	github.com/stretchr/objx v0.5.2 // indirect
+	golang.org/x/sys v0.19.0 // indirect
 	gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 // indirect
 )
-
-go 1.18

go.sum

@@ -1,60 +1,72 @@
-github.com/creack/pty v1.1.18 h1:n56/Zwd5o6whRC5PMGretI4IdRLlmBXYNjScPaBgsbY=
-github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/Masterminds/semver/v3 v3.2.1 h1:RN9w6+7QoMeJVGyfmbcgs28Br8cvmnucEXnY0rYXWg0=
+github.com/Masterminds/semver/v3 v3.2.1/go.mod h1:qvl/7zhW3nngYb5+80sSMF+FG2BjYrf8m9wsX0PNOMQ=
+github.com/creack/pty v1.1.21 h1:1/QdRyBaHHJP61QkWMXlOIBfsgdDeeKfK8SYVUWJKf0=
+github.com/creack/pty v1.1.21/go.mod h1:MOBLtS5ELjhRRrroQr9kyvTxUAFNvYEK993ew/Vr4O4=
 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/fatih/color v1.13.0 h1:8LOYc1KYPPmyKMuN8QV2DNRWNbLo6LZ0iLs8+mlH53w=
-github.com/fatih/color v1.13.0/go.mod h1:kLAiJbzzSOZDVNGyDpeOxJ47H46qBXwg5ILebYFFOfk=
-github.com/frankban/quicktest v1.14.4 h1:g2rn0vABPOOXmZUj+vbmUp0lPoXEMuhTpIluN0XL9UY=
-github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0 h1:p104kn46Q8WdvHunIJ9dAyjPVtrBPhSr3KT2yUst43I=
-github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0/go.mod h1:fyg7847qk6SyHyPtNmDHnmrv/HOrqktSC+C9fM+CJOE=
-github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
-github.com/joho/godotenv v1.4.0 h1:3l4+N6zfMWnkbPEXKng2o2/MR5mSwTrBih4ZEkkz1lg=
-github.com/joho/godotenv v1.4.0/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
+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.16.0 h1:zmkK9Ngbjj+K0yRhTVONQh1p/HknKYSlNT+vZCzyokM=
+github.com/fatih/color v1.16.0/go.mod h1:fL2Sau1YI5c0pdGEVCbKQbLXB6edEj1ZgiY4NijnWvE=
+github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8=
+github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0=
+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.0.0-20240422130016-8f6b279b1e90 h1:JBbiZ2CXIZ9Upe3O2yI5+3ksWoa7hNVNi4BINs8TIrs=
+github.com/go-task/template v0.0.0-20240422130016-8f6b279b1e90/go.mod h1:RgwRaZK+kni/hJJ7/AaOE2lPQFPbAdji/DyhC6pxo4k=
+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/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/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
-github.com/mattn/go-colorable v0.1.9 h1:sqDoxXbdeALODt0DAeJCVp38ps9ZogZEAXjus69YV3U=
-github.com/mattn/go-colorable v0.1.9/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
-github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
-github.com/mattn/go-isatty v0.0.14 h1:yVuAays6BHfxijgZPzw+3Zlu5yQgKGP2/hcQbHb7S9Y=
-github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
+github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
+github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-zglob v0.0.4 h1:LQi2iOm0/fGgu80AioIJ/1j9w9Oh+9DZ39J4VAGzHQM=
 github.com/mattn/go-zglob v0.0.4/go.mod h1:MxxjyoXXnMxfIpxTK2GAkw1w8glPsQILx3N5wrKakiY=
 github.com/mitchellh/hashstructure/v2 v2.0.2 h1:vGKWl0YJqUNxE8d+h8f6NJLcCJrgbhC4NcD46KavDd4=
 github.com/mitchellh/hashstructure/v2 v2.0.2/go.mod h1:MG3aRVU/N29oo/V/IhBX8GR/zz4kQkprJgF2EVszyDE=
+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/mint v1.5.1 h1:XaPLeE+9vGbuyEHem1JNk3bYc7KKqyI/na0/mLd/Kks=
+github.com/otiai10/mint v1.5.1/go.mod h1:MJm72SBthJjz8qhefc4z1PYEieWmy8Bku7CjcAqyUSM=
 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.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8=
+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/sajari/fuzzy v1.0.0 h1:+FmwVvJErsd0d0hAPlj4CxqxUtQY/fOoY0DwX4ykpRY=
 github.com/sajari/fuzzy v1.0.0/go.mod h1:OjYR6KxoWOe9+dOlXeiCJd4dIbED4Oo8wpS89o0pwOo=
 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.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
-github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
-github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
-github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
-github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk=
-github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
-golang.org/x/exp v0.0.0-20220930202632-ec3f01382ef9 h1:RjggHMcaTVp0LOVZcW0bo8alwHrOaCrGUDgfWUHhnN4=
-golang.org/x/exp v0.0.0-20220930202632-ec3f01382ef9/go.mod h1:cyybsKvd6eL0RnXn6p/Grxp8F5bW7iYuBgsNCOHpMYE=
-golang.org/x/sync v0.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o=
-golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.3.0 h1:w8ZOecv6NaNa/zC8944JTU3vz4u6Lagfk4RPQxv92NQ=
-golang.org/x/sys v0.3.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/term v0.3.0 h1:qoo4akIqOcDME5bhc/NgxUdovd6BSS2uMsVjB56q1xI=
-golang.org/x/term v0.3.0/go.mod h1:q750SLmJuPmVoN1blW3UFBPREJfb1KmY3vwxfr+nFDA=
+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/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.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M=
+golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.19.0 h1:q5f1RH2jigJ1MoAWp2KTp3gm5zAGFUTarQZ5U386+4o=
+golang.org/x/sys v0.19.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/term v0.19.0 h1:+ThwsDv+tYfnJFhF4L8jITxu1tdTWRTZpdsWgEgjL6Q=
+golang.org/x/term v0.19.0/go.mod h1:2CuTdWZ7KHSQwUzKva0cbMg6q2DMI3Mmxp+gKJbskEk=
 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/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 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.6.0 h1:gtva4EXJ0dFNvl5bHjcUEvws+KRcDslT8VKheTYkbGU=
-mvdan.cc/sh/v3 v3.6.0/go.mod h1:U4mhtBLZ32iWhif5/lD+ygy1zrgaQhUu+XFy7C8+TTA=
+mvdan.cc/sh/v3 v3.8.0 h1:ZxuJipLZwr/HLbASonmXtcvvC9HXY9d2lXZHnKGjFc8=
+mvdan.cc/sh/v3 v3.8.0/go.mod h1:w04623xkgBVo7/IUK89E0g8hBykgEpN0vgOj3RJr6MY=

hash.go

@@ -4,10 +4,10 @@ import (
 	"fmt"
 
 	"github.com/go-task/task/v3/internal/hash"
-	"github.com/go-task/task/v3/taskfile"
+	"github.com/go-task/task/v3/taskfile/ast"
 )
 
-func (e *Executor) GetHash(t *taskfile.Task) (string, error) {
+func (e *Executor) GetHash(t *ast.Task) (string, error) {
 	r := t.Run
 	if r == "" {
 		r = e.Taskfile.Run

help.go

@@ -5,15 +5,17 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
-	"log"
 	"os"
-	"sort"
 	"strings"
 	"text/tabwriter"
 
+	"golang.org/x/sync/errgroup"
+
 	"github.com/go-task/task/v3/internal/editors"
+	"github.com/go-task/task/v3/internal/fingerprint"
 	"github.com/go-task/task/v3/internal/logger"
-	"github.com/go-task/task/v3/taskfile"
+	"github.com/go-task/task/v3/internal/sort"
+	"github.com/go-task/task/v3/taskfile/ast"
 )
 
 // ListOptions collects list-related options
@@ -21,14 +23,16 @@ type ListOptions struct {
 	ListOnlyTasksWithDescriptions bool
 	ListAllTasks                  bool
 	FormatTaskListAsJSON          bool
+	NoStatus                      bool
 }
 
 // NewListOptions creates a new ListOptions instance
-func NewListOptions(list, listAll, listAsJson bool) ListOptions {
+func NewListOptions(list, listAll, listAsJson, noStatus bool) ListOptions {
 	return ListOptions{
 		ListOnlyTasksWithDescriptions: list,
 		ListAllTasks:                  listAll,
 		FormatTaskListAsJSON:          listAsJson,
+		NoStatus:                      noStatus,
 	}
 }
 
@@ -45,11 +49,14 @@ func (o ListOptions) Validate() error {
 	if o.FormatTaskListAsJSON && !o.ShouldListTasks() {
 		return fmt.Errorf("task: --json only applies to --list or --list-all")
 	}
+	if o.NoStatus && !o.FormatTaskListAsJSON {
+		return fmt.Errorf("task: --no-status only applies to --json with --list or --list-all")
+	}
 	return nil
 }
 
 // Filters returns the slice of FilterFunc which filters a list
-// of taskfile.Task according to the given ListOptions
+// of ast.Task according to the given ListOptions
 func (o ListOptions) Filters() []FilterFunc {
 	filters := []FilterFunc{FilterOutInternal}
 
@@ -70,7 +77,7 @@ func (e *Executor) ListTasks(o ListOptions) (bool, error) {
 		return false, err
 	}
 	if o.FormatTaskListAsJSON {
-		output, err := e.ToEditorOutput(tasks)
+		output, err := e.ToEditorOutput(tasks, o.NoStatus)
 		if err != nil {
 			return false, err
 		}
@@ -85,13 +92,13 @@ func (e *Executor) ListTasks(o ListOptions) (bool, error) {
 	}
 	if len(tasks) == 0 {
 		if o.ListOnlyTasksWithDescriptions {
-			e.Logger.Outf(logger.Yellow, "task: No tasks with description available. Try --list-all to list all tasks")
+			e.Logger.Outf(logger.Yellow, "task: No tasks with description available. Try --list-all to list all tasks\n")
 		} else if o.ListAllTasks {
-			e.Logger.Outf(logger.Yellow, "task: No tasks available")
+			e.Logger.Outf(logger.Yellow, "task: No tasks available\n")
 		}
 		return false, nil
 	}
-	e.Logger.Outf(logger.Default, "task: Available tasks for this project:")
+	e.Logger.Outf(logger.Default, "task: Available tasks for this project:\n")
 
 	// Format in tab-separated columns with a tab stop of 8.
 	w := tabwriter.NewWriter(e.Stdout, 0, 8, 6, ' ', 0)
@@ -113,51 +120,88 @@ func (e *Executor) ListTasks(o ListOptions) (bool, error) {
 // ListTaskNames prints only the task names in a Taskfile.
 // Only tasks with a non-empty description are printed if allTasks is false.
 // Otherwise, all task names are printed.
-func (e *Executor) ListTaskNames(allTasks bool) {
-	// if called from cmd/task.go, e.Taskfile has not yet been parsed
-	if e.Taskfile == nil {
-		if err := e.readTaskfile(); err != nil {
-			log.Fatal(err)
-			return
-		}
-	}
+func (e *Executor) ListTaskNames(allTasks bool) error {
 	// use stdout if no output defined
 	var w io.Writer = os.Stdout
 	if e.Stdout != nil {
 		w = e.Stdout
 	}
-	// create a string slice from all map values (*taskfile.Task)
-	s := make([]string, 0, len(e.Taskfile.Tasks))
-	for _, t := range e.Taskfile.Tasks {
-		if (allTasks || t.Desc != "") && !t.Internal {
-			s = append(s, strings.TrimRight(t.Task, ":"))
-			for _, alias := range t.Aliases {
-				s = append(s, strings.TrimRight(alias, ":"))
+
+	// Get the list of tasks and sort them
+	tasks := e.Taskfile.Tasks.Values()
+
+	// Sort the tasks
+	if e.TaskSorter == nil {
+		e.TaskSorter = &sort.AlphaNumericWithRootTasksFirst{}
+	}
+	e.TaskSorter.Sort(tasks)
+
+	// Create a list of task names
+	taskNames := make([]string, 0, e.Taskfile.Tasks.Len())
+	for _, task := range tasks {
+		if (allTasks || task.Desc != "") && !task.Internal {
+			taskNames = append(taskNames, strings.TrimRight(task.Task, ":"))
+			for _, alias := range task.Aliases {
+				taskNames = append(taskNames, strings.TrimRight(alias, ":"))
 			}
 		}
 	}
-	// sort and print all task names
-	sort.Strings(s)
-	for _, t := range s {
+	for _, t := range taskNames {
 		fmt.Fprintln(w, t)
 	}
+	return nil
 }
 
-func (e *Executor) ToEditorOutput(tasks []*taskfile.Task) (*editors.Output, error) {
-	o := &editors.Output{
-		Tasks: make([]editors.Task, len(tasks)),
+func (e *Executor) ToEditorOutput(tasks []*ast.Task, noStatus bool) (*editors.Taskfile, error) {
+	o := &editors.Taskfile{
+		Tasks:    make([]editors.Task, len(tasks)),
+		Location: e.Taskfile.Location,
 	}
-	for i, t := range tasks {
-		upToDate, err := e.isTaskUpToDate(context.Background(), t)
-		if err != nil {
-			return nil, err
-		}
-		o.Tasks[i] = editors.Task{
-			Name:     t.Name(),
-			Desc:     t.Desc,
-			Summary:  t.Summary,
-			UpToDate: upToDate,
+	var g errgroup.Group
+	for i := range tasks {
+		task := tasks[i]
+		j := i
+		aliases := []string{}
+		if len(task.Aliases) > 0 {
+			aliases = task.Aliases
 		}
+		g.Go(func() error {
+			o.Tasks[j] = editors.Task{
+				Name:     task.Name(),
+				Desc:     task.Desc,
+				Summary:  task.Summary,
+				Aliases:  aliases,
+				UpToDate: false,
+				Location: &editors.Location{
+					Line:     task.Location.Line,
+					Column:   task.Location.Column,
+					Taskfile: task.Location.Taskfile,
+				},
+			}
+
+			if noStatus {
+				return nil
+			}
+
+			// Get the fingerprinting method to use
+			method := e.Taskfile.Method
+			if task.Method != "" {
+				method = task.Method
+			}
+			upToDate, err := fingerprint.IsTaskUpToDate(context.Background(), task,
+				fingerprint.WithMethod(method),
+				fingerprint.WithTempDir(e.TempDir),
+				fingerprint.WithDry(e.Dry),
+				fingerprint.WithLogger(e.Logger),
+			)
+			if err != nil {
+				return err
+			}
+
+			o.Tasks[j].UpToDate = upToDate
+
+			return nil
+		})
 	}
-	return o, nil
+	return o, g.Wait()
 }

init.go

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

internal/compiler/compiler.go

@@ -1,15 +1,206 @@
 package compiler
 
 import (
-	"github.com/go-task/task/v3/taskfile"
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"path/filepath"
+	"strings"
+	"sync"
+
+	"gopkg.in/yaml.v3"
+
+	"github.com/go-task/task/v3/internal/execext"
+	"github.com/go-task/task/v3/internal/filepathext"
+	"github.com/go-task/task/v3/internal/logger"
+	"github.com/go-task/task/v3/internal/templater"
+	"github.com/go-task/task/v3/internal/version"
+	"github.com/go-task/task/v3/taskfile/ast"
 )
 
-// Compiler handles compilation of a task before its execution.
-// E.g. variable merger, template processing, etc.
-type Compiler interface {
-	GetTaskfileVariables() (*taskfile.Vars, error)
-	GetVariables(t *taskfile.Task, call taskfile.Call) (*taskfile.Vars, error)
-	FastGetVariables(t *taskfile.Task, call taskfile.Call) (*taskfile.Vars, error)
-	HandleDynamicVar(v taskfile.Var, dir string) (string, error)
-	ResetCache()
+type Compiler struct {
+	Dir            string
+	Entrypoint     string
+	UserWorkingDir string
+
+	TaskfileEnv  *ast.Vars
+	TaskfileVars *ast.Vars
+
+	Logger *logger.Logger
+
+	dynamicCache   map[string]string
+	muDynamicCache sync.Mutex
+}
+
+func (c *Compiler) GetTaskfileVariables() (*ast.Vars, error) {
+	return c.getVariables(nil, nil, true)
+}
+
+func (c *Compiler) GetVariables(t *ast.Task, call *ast.Call) (*ast.Vars, error) {
+	return c.getVariables(t, call, true)
+}
+
+func (c *Compiler) FastGetVariables(t *ast.Task, call *ast.Call) (*ast.Vars, error) {
+	return c.getVariables(t, call, false)
+}
+
+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)
+		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 {
+		return func(k string, v ast.Var) error {
+			cache := &templater.Cache{Vars: result}
+			// Replace values
+			newVar := templater.ReplaceVar(v, cache)
+			// If the variable should not be evaluated, but is nil, set it to an empty string
+			// This stops empty interface errors when using the templater to replace values later
+			if !evaluateShVars && newVar.Value == nil {
+				result.Set(k, ast.Var{Value: ""})
+				return nil
+			}
+			// If the variable should not be evaluated and it is set, we can set it and return
+			if !evaluateShVars {
+				result.Set(k, ast.Var{Value: newVar.Value})
+				return nil
+			}
+			// Now we can check for errors since we've handled all the cases when we don't want to evaluate
+			if err := cache.Err(); err != nil {
+				return err
+			}
+			// Evaluate JSON
+			if newVar.Json != "" {
+				if err := json.Unmarshal([]byte(newVar.Json), &newVar.Value); err != nil {
+					return err
+				}
+			}
+			// Evaluate YAML
+			if newVar.Yaml != "" {
+				if err := yaml.Unmarshal([]byte(newVar.Yaml), &newVar.Value); err != nil {
+					return err
+				}
+			}
+			// If the variable is not dynamic, we can set it and return
+			if newVar.Value != nil || newVar.Sh == "" {
+				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)
+			if err != nil {
+				return err
+			}
+			result.Set(k, ast.Var{Value: static})
+			return nil
+		}
+	}
+	rangeFunc := getRangeFunc(c.Dir)
+
+	var taskRangeFunc func(k string, v ast.Var) error
+	if t != nil {
+		// NOTE(@andreynering): We're manually joining these paths here because
+		// this is the raw task, not the compiled one.
+		cache := &templater.Cache{Vars: result}
+		dir := templater.Replace(t.Dir, cache)
+		if err := cache.Err(); err != nil {
+			return nil, err
+		}
+		dir = filepathext.SmartJoin(c.Dir, dir)
+		taskRangeFunc = getRangeFunc(dir)
+	}
+
+	if err := c.TaskfileEnv.Range(rangeFunc); err != nil {
+		return nil, err
+	}
+	if err := c.TaskfileVars.Range(rangeFunc); err != nil {
+		return nil, err
+	}
+	if t != nil {
+		if err := t.IncludeVars.Range(rangeFunc); err != nil {
+			return nil, err
+		}
+		if err := t.IncludedTaskfileVars.Range(taskRangeFunc); err != nil {
+			return nil, err
+		}
+	}
+
+	if t == nil || call == nil {
+		return result, nil
+	}
+
+	if err := call.Vars.Range(rangeFunc); err != nil {
+		return nil, err
+	}
+	if err := t.Vars.Range(taskRangeFunc); err != nil {
+		return nil, err
+	}
+
+	return result, nil
+}
+
+func (c *Compiler) HandleDynamicVar(v ast.Var, dir string) (string, error) {
+	c.muDynamicCache.Lock()
+	defer c.muDynamicCache.Unlock()
+
+	if c.dynamicCache == nil {
+		c.dynamicCache = make(map[string]string, 30)
+	}
+	if result, ok := c.dynamicCache[v.Sh]; ok {
+		return result, nil
+	}
+
+	// NOTE(@andreynering): If a var have a specific dir, use this instead
+	if v.Dir != "" {
+		dir = v.Dir
+	}
+
+	var stdout bytes.Buffer
+	opts := &execext.RunCommandOptions{
+		Command: v.Sh,
+		Dir:     dir,
+		Stdout:  &stdout,
+		Stderr:  c.Logger.Stderr,
+	}
+	if err := execext.RunCommand(context.Background(), opts); err != nil {
+		return "", fmt.Errorf(`task: Command "%s" failed: %s`, opts.Command, err)
+	}
+
+	// Trim a single trailing newline from the result to make most command
+	// output easier to use in shell commands.
+	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)
+
+	return result, nil
+}
+
+// ResetCache clear the dymanic variables cache
+func (c *Compiler) ResetCache() {
+	c.muDynamicCache.Lock()
+	defer c.muDynamicCache.Unlock()
+
+	c.dynamicCache = nil
+}
+
+func (c *Compiler) getSpecialVars(t *ast.Task) (map[string]string, error) {
+	return map[string]string{
+		"TASK":             t.Task,
+		"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
 }

internal/compiler/env.go

@@ -4,17 +4,17 @@ import (
 	"os"
 	"strings"
 
-	"github.com/go-task/task/v3/taskfile"
+	"github.com/go-task/task/v3/taskfile/ast"
 )
 
 // GetEnviron the all return all environment variables encapsulated on a
-// taskfile.Vars
-func GetEnviron() *taskfile.Vars {
-	m := &taskfile.Vars{}
+// ast.Vars
+func GetEnviron() *ast.Vars {
+	m := &ast.Vars{}
 	for _, e := range os.Environ() {
 		keyVal := strings.SplitN(e, "=", 2)
 		key, val := keyVal[0], keyVal[1]
-		m.Set(key, taskfile.Var{Static: val})
+		m.Set(key, ast.Var{Value: val})
 	}
 	return m
 }

internal/compiler/v2/compiler_v2.go

@@ -1,131 +0,0 @@
-package v2
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-	"strings"
-	"sync"
-
-	"github.com/go-task/task/v3/internal/compiler"
-	"github.com/go-task/task/v3/internal/execext"
-	"github.com/go-task/task/v3/internal/logger"
-	"github.com/go-task/task/v3/internal/templater"
-	"github.com/go-task/task/v3/taskfile"
-)
-
-var _ compiler.Compiler = &CompilerV2{}
-
-type CompilerV2 struct {
-	Dir string
-
-	Taskvars     *taskfile.Vars
-	TaskfileVars *taskfile.Vars
-
-	Expansions int
-
-	Logger *logger.Logger
-
-	dynamicCache   map[string]string
-	muDynamicCache sync.Mutex
-}
-
-func (c *CompilerV2) GetTaskfileVariables() (*taskfile.Vars, error) {
-	return &taskfile.Vars{}, nil
-}
-
-// FastGetVariables is a no-op on v2
-func (c *CompilerV2) FastGetVariables(t *taskfile.Task, call taskfile.Call) (*taskfile.Vars, error) {
-	return c.GetVariables(t, call)
-}
-
-// GetVariables returns fully resolved variables following the priority order:
-// 1. Task variables
-// 2. Call variables
-// 3. Taskfile variables
-// 4. Taskvars file variables
-// 5. Environment variables
-func (c *CompilerV2) GetVariables(t *taskfile.Task, call taskfile.Call) (*taskfile.Vars, error) {
-	vr := varResolver{
-		c:    c,
-		vars: compiler.GetEnviron(),
-	}
-	vr.vars.Set("TASK", taskfile.Var{Static: t.Task})
-
-	for _, vars := range []*taskfile.Vars{c.Taskvars, c.TaskfileVars, call.Vars, t.Vars} {
-		for i := 0; i < c.Expansions; i++ {
-			vr.merge(vars)
-		}
-	}
-	return vr.vars, vr.err
-}
-
-type varResolver struct {
-	c    *CompilerV2
-	vars *taskfile.Vars
-	err  error
-}
-
-func (vr *varResolver) merge(vars *taskfile.Vars) {
-	if vr.err != nil {
-		return
-	}
-	tr := templater.Templater{Vars: vr.vars}
-	_ = vars.Range(func(k string, v taskfile.Var) error {
-		v = taskfile.Var{
-			Static: tr.Replace(v.Static),
-			Sh:     tr.Replace(v.Sh),
-		}
-		static, err := vr.c.HandleDynamicVar(v, "")
-		if err != nil {
-			vr.err = err
-			return err
-		}
-		vr.vars.Set(k, taskfile.Var{Static: static})
-		return nil
-	})
-	vr.err = tr.Err()
-}
-
-func (c *CompilerV2) HandleDynamicVar(v taskfile.Var, _ string) (string, error) {
-	if v.Static != "" || v.Sh == "" {
-		return v.Static, nil
-	}
-
-	c.muDynamicCache.Lock()
-	defer c.muDynamicCache.Unlock()
-
-	if c.dynamicCache == nil {
-		c.dynamicCache = make(map[string]string, 30)
-	}
-	if result, ok := c.dynamicCache[v.Sh]; ok {
-		return result, nil
-	}
-
-	var stdout bytes.Buffer
-	opts := &execext.RunCommandOptions{
-		Command: v.Sh,
-		Stdout:  &stdout,
-		Stderr:  c.Logger.Stderr,
-	}
-	if err := execext.RunCommand(context.Background(), opts); err != nil {
-		return "", fmt.Errorf(`task: Command "%s" failed: %s`, opts.Command, err)
-	}
-
-	// Trim a single trailing newline from the result to make most command
-	// output easier to use in shell commands.
-	result := strings.TrimSuffix(stdout.String(), "\n")
-
-	c.dynamicCache[v.Sh] = result
-	c.Logger.VerboseErrf(logger.Magenta, `task: dynamic variable: '%s' result: '%s'`, v.Sh, result)
-
-	return result, nil
-}
-
-// ResetCache clear the dymanic variables cache
-func (c *CompilerV2) ResetCache() {
-	c.muDynamicCache.Lock()
-	defer c.muDynamicCache.Unlock()
-
-	c.dynamicCache = nil
-}

internal/compiler/v3/compiler_v3.go

@@ -1,195 +0,0 @@
-package v3
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-	"strings"
-	"sync"
-
-	"github.com/go-task/task/v3/internal/compiler"
-	"github.com/go-task/task/v3/internal/execext"
-	"github.com/go-task/task/v3/internal/filepathext"
-	"github.com/go-task/task/v3/internal/logger"
-	"github.com/go-task/task/v3/internal/templater"
-	"github.com/go-task/task/v3/taskfile"
-)
-
-var _ compiler.Compiler = &CompilerV3{}
-
-type CompilerV3 struct {
-	Dir            string
-	UserWorkingDir string
-
-	TaskfileEnv  *taskfile.Vars
-	TaskfileVars *taskfile.Vars
-
-	Logger *logger.Logger
-
-	dynamicCache   map[string]string
-	muDynamicCache sync.Mutex
-}
-
-func (c *CompilerV3) GetTaskfileVariables() (*taskfile.Vars, error) {
-	return c.getVariables(nil, nil, true)
-}
-
-func (c *CompilerV3) GetVariables(t *taskfile.Task, call taskfile.Call) (*taskfile.Vars, error) {
-	return c.getVariables(t, &call, true)
-}
-
-func (c *CompilerV3) FastGetVariables(t *taskfile.Task, call taskfile.Call) (*taskfile.Vars, error) {
-	return c.getVariables(t, &call, false)
-}
-
-func (c *CompilerV3) getVariables(t *taskfile.Task, call *taskfile.Call, evaluateShVars bool) (*taskfile.Vars, error) {
-	result := compiler.GetEnviron()
-	if t != nil {
-		specialVars, err := c.getSpecialVars(t)
-		if err != nil {
-			return nil, err
-		}
-		for k, v := range specialVars {
-			result.Set(k, taskfile.Var{Static: v})
-		}
-	}
-
-	getRangeFunc := func(dir string) func(k string, v taskfile.Var) error {
-		return func(k string, v taskfile.Var) error {
-			tr := templater.Templater{Vars: result, RemoveNoValue: true}
-
-			if !evaluateShVars {
-				result.Set(k, taskfile.Var{Static: tr.Replace(v.Static)})
-				return nil
-			}
-
-			v = taskfile.Var{
-				Static: tr.Replace(v.Static),
-				Sh:     tr.Replace(v.Sh),
-				Dir:    v.Dir,
-			}
-			if err := tr.Err(); err != nil {
-				return err
-			}
-			static, err := c.HandleDynamicVar(v, dir)
-			if err != nil {
-				return err
-			}
-			result.Set(k, taskfile.Var{Static: static})
-			return nil
-		}
-	}
-	rangeFunc := getRangeFunc(c.Dir)
-
-	var taskRangeFunc func(k string, v taskfile.Var) error
-	if t != nil {
-		// NOTE(@andreynering): We're manually joining these paths here because
-		// this is the raw task, not the compiled one.
-		tr := templater.Templater{Vars: result, RemoveNoValue: true}
-		dir := tr.Replace(t.Dir)
-		if err := tr.Err(); err != nil {
-			return nil, err
-		}
-		dir = filepathext.SmartJoin(c.Dir, dir)
-		taskRangeFunc = getRangeFunc(dir)
-	}
-
-	if err := c.TaskfileEnv.Range(rangeFunc); err != nil {
-		return nil, err
-	}
-	if err := c.TaskfileVars.Range(rangeFunc); err != nil {
-		return nil, err
-	}
-	if t != nil {
-		if err := t.IncludedTaskfileVars.Range(taskRangeFunc); err != nil {
-			return nil, err
-		}
-		if err := t.IncludeVars.Range(rangeFunc); err != nil {
-			return nil, err
-		}
-	}
-
-	if t == nil || call == nil {
-		return result, nil
-	}
-
-	if err := call.Vars.Range(rangeFunc); err != nil {
-		return nil, err
-	}
-	if err := t.Vars.Range(taskRangeFunc); err != nil {
-		return nil, err
-	}
-
-	return result, nil
-}
-
-func (c *CompilerV3) HandleDynamicVar(v taskfile.Var, dir string) (string, error) {
-	if v.Static != "" || v.Sh == "" {
-		return v.Static, nil
-	}
-
-	c.muDynamicCache.Lock()
-	defer c.muDynamicCache.Unlock()
-
-	if c.dynamicCache == nil {
-		c.dynamicCache = make(map[string]string, 30)
-	}
-	if result, ok := c.dynamicCache[v.Sh]; ok {
-		return result, nil
-	}
-
-	// NOTE(@andreynering): If a var have a specific dir, use this instead
-	if v.Dir != "" {
-		dir = v.Dir
-	}
-
-	var stdout bytes.Buffer
-	opts := &execext.RunCommandOptions{
-		Command: v.Sh,
-		Dir:     dir,
-		Stdout:  &stdout,
-		Stderr:  c.Logger.Stderr,
-	}
-	if err := execext.RunCommand(context.Background(), opts); err != nil {
-		return "", fmt.Errorf(`task: Command "%s" failed: %s`, opts.Command, err)
-	}
-
-	// Trim a single trailing newline from the result to make most command
-	// output easier to use in shell commands.
-	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: '%s' result: '%s'`, v.Sh, result)
-
-	return result, nil
-}
-
-// ResetCache clear the dymanic variables cache
-func (c *CompilerV3) ResetCache() {
-	c.muDynamicCache.Lock()
-	defer c.muDynamicCache.Unlock()
-
-	c.dynamicCache = nil
-}
-
-func (c *CompilerV3) getSpecialVars(t *taskfile.Task) (map[string]string, error) {
-	taskfileDir, err := c.getTaskfileDir(t)
-	if err != nil {
-		return nil, err
-	}
-
-	return map[string]string{
-		"TASK":             t.Task,
-		"ROOT_DIR":         c.Dir,
-		"TASKFILE_DIR":     taskfileDir,
-		"USER_WORKING_DIR": c.UserWorkingDir,
-	}, nil
-}
-
-func (c *CompilerV3) getTaskfileDir(t *taskfile.Task) (string, error) {
-	if t.IncludedTaskfile != nil {
-		return t.IncludedTaskfile.FullDirPath()
-	}
-	return c.Dir, nil
-}

internal/deepcopy/deepcopy.go

@@ -0,0 +1,141 @@
+package deepcopy
+
+import (
+	"reflect"
+)
+
+type Copier[T any] interface {
+	DeepCopy() T
+}
+
+func Slice[T any](orig []T) []T {
+	if orig == nil {
+		return nil
+	}
+	c := make([]T, len(orig))
+	for i, v := range orig {
+		if copyable, ok := any(v).(Copier[T]); ok {
+			c[i] = copyable.DeepCopy()
+		} else {
+			c[i] = v
+		}
+	}
+	return c
+}
+
+func Map[K comparable, V any](orig map[K]V) map[K]V {
+	if orig == nil {
+		return nil
+	}
+	c := make(map[K]V, len(orig))
+	for k, v := range orig {
+		if copyable, ok := any(v).(Copier[V]); ok {
+			c[k] = copyable.DeepCopy()
+		} else {
+			c[k] = v
+		}
+	}
+	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
+// struct, map or a slice, the function will recursively call itself for each
+// field or element of the struct, map or slice until all strings inside the
+// struct or slice are replaced.
+func TraverseStringsFunc[T any](v T, fn func(v string) (string, error)) (T, error) {
+	original := reflect.ValueOf(v)
+	if original.Kind() == reflect.Invalid || !original.IsValid() {
+		return v, nil
+	}
+	copy := reflect.New(original.Type()).Elem()
+
+	var traverseFunc func(copy, v reflect.Value) error
+	traverseFunc = func(copy, v reflect.Value) error {
+		switch v.Kind() {
+
+		case reflect.Ptr:
+			// Unwrap the pointer
+			originalValue := v.Elem()
+			// If the pointer is nil, do nothing
+			if !originalValue.IsValid() {
+				return nil
+			}
+			// Create an empty copy from the original value's type
+			copy.Set(reflect.New(originalValue.Type()))
+			// Unwrap the newly created pointer and call traverseFunc recursively
+			if err := traverseFunc(copy.Elem(), originalValue); err != nil {
+				return err
+			}
+
+		case reflect.Interface:
+			// Unwrap the interface
+			originalValue := v.Elem()
+			if !originalValue.IsValid() {
+				return nil
+			}
+			// Create an empty copy from the original value's type
+			copyValue := reflect.New(originalValue.Type()).Elem()
+			// Unwrap the newly created pointer and call traverseFunc recursively
+			if err := traverseFunc(copyValue, originalValue); err != nil {
+				return err
+			}
+			copy.Set(copyValue)
+
+		case reflect.Struct:
+			// Loop over each field and call traverseFunc recursively
+			for i := 0; i < v.NumField(); i += 1 {
+				if err := traverseFunc(copy.Field(i), v.Field(i)); err != nil {
+					return err
+				}
+			}
+
+		case reflect.Slice:
+			// Create an empty copy from the original value's type
+			copy.Set(reflect.MakeSlice(v.Type(), v.Len(), v.Cap()))
+			// Loop over each element and call traverseFunc recursively
+			for i := 0; i < v.Len(); i += 1 {
+				if err := traverseFunc(copy.Index(i), v.Index(i)); err != nil {
+					return err
+				}
+			}
+
+		case reflect.Map:
+			// Create an empty copy from the original value's type
+			copy.Set(reflect.MakeMap(v.Type()))
+			// Loop over each key
+			for _, key := range v.MapKeys() {
+				// Create a copy of each map index
+				originalValue := v.MapIndex(key)
+				if originalValue.IsNil() {
+					continue
+				}
+				copyValue := reflect.New(originalValue.Type()).Elem()
+				// Call traverseFunc recursively
+				if err := traverseFunc(copyValue, originalValue); err != nil {
+					return err
+				}
+				copy.SetMapIndex(key, copyValue)
+			}
+
+		case reflect.String:
+			rv, err := fn(v.String())
+			if err != nil {
+				return err
+			}
+			copy.Set(reflect.ValueOf(rv))
+
+		default:
+			copy.Set(v)
+		}
+
+		return nil
+	}
+
+	if err := traverseFunc(copy, original); err != nil {
+		return v, err
+	}
+
+	return copy.Interface().(T), nil
+}

internal/editors/output.go

@@ -1,14 +1,24 @@
 package editors
 
-// Output wraps task list output for use in editor integrations (e.g. VSCode, etc)
-type Output struct {
-	Tasks []Task `json:"tasks"`
-}
-
-// Task describes a single task
-type Task struct {
-	Name     string `json:"name"`
-	Desc     string `json:"desc"`
-	Summary  string `json:"summary"`
-	UpToDate bool   `json:"up_to_date"`
-}
+type (
+	// Taskfile wraps task list output for use in editor integrations (e.g. VSCode, etc)
+	Taskfile struct {
+		Tasks    []Task `json:"tasks"`
+		Location string `json:"location"`
+	}
+	// Task describes a single task
+	Task struct {
+		Name     string    `json:"name"`
+		Desc     string    `json:"desc"`
+		Summary  string    `json:"summary"`
+		Aliases  []string  `json:"aliases"`
+		UpToDate bool      `json:"up_to_date"`
+		Location *Location `json:"location"`
+	}
+	// Location describes a task's location in a taskfile
+	Location struct {
+		Line     int    `json:"line"`
+		Column   int    `json:"column"`
+		Taskfile string `json:"taskfile"`
+	}
+)

internal/env/env.go

@@ -0,0 +1,37 @@
+package env
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/go-task/task/v3/taskfile/ast"
+)
+
+func Get(t *ast.Task) []string {
+	if t.Env == nil {
+		return nil
+	}
+
+	environ := os.Environ()
+	for k, v := range t.Env.ToCacheMap() {
+		if !isTypeAllowed(v) {
+			continue
+		}
+
+		if _, alreadySet := os.LookupEnv(k); alreadySet {
+			continue
+		}
+		environ = append(environ, fmt.Sprintf("%s=%v", k, v))
+	}
+
+	return environ
+}
+
+func isTypeAllowed(v any) bool {
+	switch v.(type) {
+	case string, bool, int, float32, float64:
+		return true
+	default:
+		return false
+	}
+}

internal/execext/exec.go

@@ -28,10 +28,8 @@ type RunCommandOptions struct {
 	Stderr    io.Writer
 }
 
-var (
-	// ErrNilOptions is returned when a nil options is given
-	ErrNilOptions = errors.New("execext: nil options given")
-)
+// ErrNilOptions is returned when a nil options is given
+var ErrNilOptions = errors.New("execext: nil options given")
 
 // RunCommand runs a shell command
 func RunCommand(ctx context.Context, opts *RunCommandOptions) error {
@@ -61,7 +59,7 @@ func RunCommand(ctx context.Context, opts *RunCommandOptions) error {
 	r, err := interp.New(
 		interp.Params(params...),
 		interp.Env(expand.ListEnviron(environ...)),
-		interp.ExecHandler(interp.DefaultExecHandler(15*time.Second)),
+		interp.ExecHandlers(execHandler),
 		interp.OpenHandler(openHandler),
 		interp.StdIO(opts.Stdin, opts.Stdout, opts.Stderr),
 		dirOption(opts.Dir),
@@ -105,6 +103,9 @@ func IsExitError(err error) bool {
 func Expand(s string) (string, error) {
 	s = filepath.ToSlash(s)
 	s = strings.ReplaceAll(s, " ", `\ `)
+	s = strings.ReplaceAll(s, "&", `\&`)
+	s = strings.ReplaceAll(s, "(", `\(`)
+	s = strings.ReplaceAll(s, ")", `\)`)
 	fields, err := shell.Fields(s, nil)
 	if err != nil {
 		return "", err
@@ -115,6 +116,10 @@ func Expand(s string) (string, error) {
 	return "", nil
 }
 
+func execHandler(next interp.ExecHandlerFunc) interp.ExecHandlerFunc {
+	return interp.DefaultExecHandler(15 * time.Second)
+}
+
 func openHandler(ctx context.Context, path string, flag int, perm os.FileMode) (io.ReadWriteCloser, error) {
 	if path == "/dev/null" {
 		return devNull{}, nil

internal/exp/maps.go

@@ -0,0 +1,26 @@
+// This package is intended as a place to copy functions from the
+// golang.org/x/exp package. Copying these functions allows us to rely on our
+// own code instead of an external package that may change unpredictably in the
+// future.
+//
+// It also prevents problems with transitive dependencies whereby a
+// package that imports Task (and therefore our version of golang.org/x/exp)
+// cannot import a different version of golang.org/x/exp.
+//
+// Finally, it serves as a place to track functions that may be able to be
+// removed in the future if they are added to the standard library. This is also
+// why this package is under the internal directory since these functions are
+// not intended to be used outside of Task.
+package exp
+
+import "cmp"
+
+// Keys is a copy of https://pkg.go.dev/golang.org/x/exp@v0.0.0-20240103183307-be819d1f06fc/maps#Keys.
+// This is not yet included in the standard library. See https://github.com/golang/go/issues/61538.
+func Keys[K cmp.Ordered, V any](m map[K]V) []K {
+	var keys []K
+	for key := range m {
+		keys = append(keys, key)
+	}
+	return keys
+}

internal/experiments/experiments.go

@@ -0,0 +1,108 @@
+package experiments
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"slices"
+	"strings"
+	"text/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.
+var (
+	GentleForce     Experiment
+	RemoteTaskfiles Experiment
+	AnyVariables    Experiment
+	MapVariables    Experiment
+)
+
+func init() {
+	readDotEnv()
+	GentleForce = New("GENTLE_FORCE")
+	RemoteTaskfiles = New("REMOTE_TASKFILES")
+	AnyVariables = New("ANY_VARIABLES", "1", "2")
+	MapVariables = New("MAP_VARIABLES", "1", "2")
+}
+
+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,
+	}
+}
+
+func (x Experiment) String() string {
+	if x.Enabled {
+		return fmt.Sprintf("on (%s)", x.Value)
+	}
+	return "off"
+}
+
+func getEnv(xName string) string {
+	envName := fmt.Sprintf("%s%s", envPrefix, xName)
+	return os.Getenv(envName)
+}
+
+func getEnvFilePath() string {
+	// Parse the CLI flags again to get the directory/taskfile being run
+	// We use a flagset here so that we can parse a subset of flags without exiting on error.
+	var dir, taskfile string
+	fs := pflag.NewFlagSet("experiments", pflag.ContinueOnError)
+	fs.StringVarP(&dir, "dir", "d", "", "Sets directory of execution.")
+	fs.StringVarP(&taskfile, "taskfile", "t", "", `Choose which Taskfile to run. Defaults to "Taskfile.yml".`)
+	_ = fs.Parse(os.Args[1:])
+	// If the directory is set, find a .env file in that directory.
+	if dir != "" {
+		return filepath.Join(dir, ".env")
+	}
+	// If the taskfile is set, find a .env file in the directory containing the Taskfile.
+	if taskfile != "" {
+		return filepath.Join(filepath.Dir(taskfile), ".env")
+	}
+	// Otherwise just use the current working directory.
+	return ".env"
+}
+
+func readDotEnv() {
+	env, _ := godotenv.Read(getEnvFilePath())
+	// If the env var is an experiment, set it.
+	for key, value := range env {
+		if strings.HasPrefix(key, envPrefix) {
+			os.Setenv(key, value)
+		}
+	}
+}
+
+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)
+	return w.Flush()
+}

internal/filepathext/filepathext.go

@@ -3,17 +3,43 @@ package filepathext
 import (
 	"os"
 	"path/filepath"
+	"strings"
 )
 
 // SmartJoin joins two paths, but only if the second is not already an
 // absolute path.
 func SmartJoin(a, b string) string {
-	if filepath.IsAbs(b) {
+	if IsAbs(b) {
 		return b
 	}
 	return filepath.Join(a, b)
 }
 
+func IsAbs(path string) bool {
+	// NOTE(@andreynering): If the path contains any if the special
+	// variables that we know are absolute, return true.
+	if isSpecialDir(path) {
+		return true
+	}
+
+	return filepath.IsAbs(path)
+}
+
+var knownAbsDirs = []string{
+	".ROOT_DIR",
+	".TASKFILE_DIR",
+	".USER_WORKING_DIR",
+}
+
+func isSpecialDir(dir string) bool {
+	for _, d := range knownAbsDirs {
+		if strings.Contains(dir, d) {
+			return true
+		}
+	}
+	return false
+}
+
 // TryAbsToRel tries to convert an absolute path to relative based on the
 // process working directory. If it can't, it returns the absolute path.
 func TryAbsToRel(abs string) string {

internal/fingerprint/checker.go

@@ -0,0 +1,20 @@
+package fingerprint
+
+import (
+	"context"
+
+	"github.com/go-task/task/v3/taskfile/ast"
+)
+
+// StatusCheckable defines any type that can check if the status of a task is up-to-date.
+type StatusCheckable interface {
+	IsUpToDate(ctx context.Context, t *ast.Task) (bool, error)
+}
+
+// SourcesCheckable defines any type that can check if the sources of a task are up-to-date.
+type SourcesCheckable interface {
+	IsUpToDate(t *ast.Task) (bool, error)
+	Value(t *ast.Task) (any, error)
+	OnError(t *ast.Task) error
+	Kind() string
+}

internal/fingerprint/glob.go

@@ -1,4 +1,4 @@
-package status
+package fingerprint
 
 import (
 	"os"
@@ -8,16 +8,25 @@ import (
 
 	"github.com/go-task/task/v3/internal/execext"
 	"github.com/go-task/task/v3/internal/filepathext"
+	"github.com/go-task/task/v3/taskfile/ast"
 )
 
-func globs(dir string, globs []string) ([]string, error) {
-	files := make([]string, 0)
+func Globs(dir string, globs []*ast.Glob) ([]string, error) {
+	fileMap := make(map[string]bool)
 	for _, g := range globs {
-		f, err := Glob(dir, g)
+		matches, err := Glob(dir, g.Glob)
 		if err != nil {
 			continue
 		}
-		files = append(files, f...)
+		for _, match := range matches {
+			fileMap[match] = !g.Negate
+		}
+	}
+	files := make([]string, 0)
+	for file, includePath := range fileMap {
+		if includePath {
+			files = append(files, file)
+		}
 	}
 	sort.Strings(files)
 	return files, nil

internal/fingerprint/sources.go

@@ -0,0 +1,16 @@
+package fingerprint
+
+import "fmt"
+
+func NewSourcesChecker(method, tempDir string, dry bool) (SourcesCheckable, error) {
+	switch method {
+	case "timestamp":
+		return NewTimestampChecker(tempDir, dry), nil
+	case "checksum":
+		return NewChecksumChecker(tempDir, dry), nil
+	case "none":
+		return NoneChecker{}, nil
+	default:
+		return nil, fmt.Errorf(`task: invalid method "%s"`, method)
+	}
+}

internal/fingerprint/sources_checksum.go

@@ -0,0 +1,126 @@
+package fingerprint
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+
+	"github.com/zeebo/xxh3"
+
+	"github.com/go-task/task/v3/internal/filepathext"
+	"github.com/go-task/task/v3/taskfile/ast"
+)
+
+// ChecksumChecker validates if a task is up to date by calculating its source
+// files checksum
+type ChecksumChecker struct {
+	tempDir string
+	dry     bool
+}
+
+func NewChecksumChecker(tempDir string, dry bool) *ChecksumChecker {
+	return &ChecksumChecker{
+		tempDir: tempDir,
+		dry:     dry,
+	}
+}
+
+func (checker *ChecksumChecker) IsUpToDate(t *ast.Task) (bool, error) {
+	if len(t.Sources) == 0 {
+		return false, nil
+	}
+
+	checksumFile := checker.checksumFilePath(t)
+
+	data, _ := os.ReadFile(checksumFile)
+	oldHash := strings.TrimSpace(string(data))
+
+	newHash, err := checker.checksum(t)
+	if err != nil {
+		return false, nil
+	}
+
+	if !checker.dry && oldHash != newHash {
+		_ = os.MkdirAll(filepathext.SmartJoin(checker.tempDir, "checksum"), 0o755)
+		if err = os.WriteFile(checksumFile, []byte(newHash+"\n"), 0o644); err != nil {
+			return false, err
+		}
+	}
+
+	if len(t.Generates) > 0 {
+		// For each specified 'generates' field, check whether the files actually exist
+		for _, g := range t.Generates {
+			if g.Negate {
+				continue
+			}
+			generates, err := Glob(t.Dir, g.Glob)
+			if os.IsNotExist(err) {
+				return false, nil
+			}
+			if err != nil {
+				return false, err
+			}
+			if len(generates) == 0 {
+				return false, nil
+			}
+		}
+	}
+
+	return oldHash == newHash, nil
+}
+
+func (checker *ChecksumChecker) Value(t *ast.Task) (any, error) {
+	return checker.checksum(t)
+}
+
+func (checker *ChecksumChecker) OnError(t *ast.Task) error {
+	if len(t.Sources) == 0 {
+		return nil
+	}
+	return os.Remove(checker.checksumFilePath(t))
+}
+
+func (*ChecksumChecker) Kind() string {
+	return "checksum"
+}
+
+func (c *ChecksumChecker) checksum(t *ast.Task) (string, error) {
+	sources, err := Globs(t.Dir, t.Sources)
+	if err != nil {
+		return "", err
+	}
+
+	h := xxh3.New()
+	buf := make([]byte, 128*1024)
+	for _, f := range sources {
+		// also sum the filename, so checksum changes for renaming a file
+		if _, err := io.CopyBuffer(h, strings.NewReader(filepath.Base(f)), buf); err != nil {
+			return "", err
+		}
+		f, err := os.Open(f)
+		if err != nil {
+			return "", err
+		}
+		if _, err = io.CopyBuffer(h, f, buf); err != nil {
+			return "", err
+		}
+		f.Close()
+	}
+
+	hash := h.Sum128()
+	return fmt.Sprintf("%x%x", hash.Hi, hash.Lo), nil
+}
+
+func (checker *ChecksumChecker) checksumFilePath(t *ast.Task) string {
+	return filepath.Join(checker.tempDir, "checksum", normalizeFilename(t.Name()))
+}
+
+var checksumFilenameRegexp = regexp.MustCompile("[^A-z0-9]")
+
+// replaces invalid characters on filenames with "-"
+func normalizeFilename(f string) string {
+	return checksumFilenameRegexp.ReplaceAllString(f, "-")
+}

internal/fingerprint/sources_checksum_test.go

@@ -1,4 +1,4 @@
-package status
+package fingerprint
 
 import (
 	"testing"

internal/fingerprint/sources_none.go

@@ -0,0 +1,23 @@
+package fingerprint
+
+import "github.com/go-task/task/v3/taskfile/ast"
+
+// NoneChecker is a no-op Checker.
+// It will always report that the task is not up-to-date.
+type NoneChecker struct{}
+
+func (NoneChecker) IsUpToDate(t *ast.Task) (bool, error) {
+	return false, nil
+}
+
+func (NoneChecker) Value(t *ast.Task) (any, error) {
+	return "", nil
+}
+
+func (NoneChecker) OnError(t *ast.Task) error {
+	return nil
+}
+
+func (NoneChecker) Kind() string {
+	return "none"
+}

internal/fingerprint/sources_timestamp.go

@@ -1,38 +1,43 @@
-package status
+package fingerprint
 
 import (
 	"os"
 	"path/filepath"
 	"time"
+
+	"github.com/go-task/task/v3/taskfile/ast"
 )
 
-// Timestamp checks if any source change compared with the generated files,
+// TimestampChecker checks if any source change compared with the generated files,
 // using file modifications timestamps.
-type Timestamp struct {
-	TempDir   string
-	Task      string
-	Dir       string
-	Sources   []string
-	Generates []string
-	Dry       bool
+type TimestampChecker struct {
+	tempDir string
+	dry     bool
+}
+
+func NewTimestampChecker(tempDir string, dry bool) *TimestampChecker {
+	return &TimestampChecker{
+		tempDir: tempDir,
+		dry:     dry,
+	}
 }
 
 // IsUpToDate implements the Checker interface
-func (t *Timestamp) IsUpToDate() (bool, error) {
+func (checker *TimestampChecker) IsUpToDate(t *ast.Task) (bool, error) {
 	if len(t.Sources) == 0 {
 		return false, nil
 	}
 
-	sources, err := globs(t.Dir, t.Sources)
+	sources, err := Globs(t.Dir, t.Sources)
 	if err != nil {
 		return false, nil
 	}
-	generates, err := globs(t.Dir, t.Generates)
+	generates, err := Globs(t.Dir, t.Generates)
 	if err != nil {
 		return false, nil
 	}
 
-	timestampFile := t.timestampFilePath()
+	timestampFile := checker.timestampFilePath(t)
 
 	// If the file exists, add the file path to the generates.
 	// If the generate file is old, the task will be executed.
@@ -41,7 +46,7 @@ func (t *Timestamp) IsUpToDate() (bool, error) {
 		generates = append(generates, timestampFile)
 	} else {
 		// Create the timestamp file for the next execution when the file does not exist.
-		if !t.Dry {
+		if !checker.dry {
 			if err := os.MkdirAll(filepath.Dir(timestampFile), 0o755); err != nil {
 				return false, err
 			}
@@ -70,7 +75,7 @@ func (t *Timestamp) IsUpToDate() (bool, error) {
 	}
 
 	// Modify the metadata of the file to the the current time.
-	if !t.Dry {
+	if !checker.dry {
 		if err := os.Chtimes(timestampFile, taskTime, taskTime); err != nil {
 			return false, err
 		}
@@ -79,13 +84,13 @@ func (t *Timestamp) IsUpToDate() (bool, error) {
 	return !shouldUpdate, nil
 }
 
-func (t *Timestamp) Kind() string {
+func (checker *TimestampChecker) Kind() string {
 	return "timestamp"
 }
 
 // Value implements the Checker Interface
-func (t *Timestamp) Value() (interface{}, error) {
-	sources, err := globs(t.Dir, t.Sources)
+func (checker *TimestampChecker) Value(t *ast.Task) (any, error) {
+	sources, err := Globs(t.Dir, t.Sources)
 	if err != nil {
 		return time.Now(), err
 	}
@@ -137,10 +142,10 @@ func anyFileNewerThan(files []string, givenTime time.Time) (bool, error) {
 }
 
 // OnError implements the Checker interface
-func (*Timestamp) OnError() error {
+func (*TimestampChecker) OnError(t *ast.Task) error {
 	return nil
 }
 
-func (t *Timestamp) timestampFilePath() string {
-	return filepath.Join(t.TempDir, "timestamp", normalizeFilename(t.Task))
+func (checker *TimestampChecker) timestampFilePath(t *ast.Task) string {
+	return filepath.Join(checker.tempDir, "timestamp", normalizeFilename(t.Task))
 }

internal/fingerprint/status.go

@@ -0,0 +1,36 @@
+package fingerprint
+
+import (
+	"context"
+
+	"github.com/go-task/task/v3/internal/env"
+	"github.com/go-task/task/v3/internal/execext"
+	"github.com/go-task/task/v3/internal/logger"
+	"github.com/go-task/task/v3/taskfile/ast"
+)
+
+type StatusChecker struct {
+	logger *logger.Logger
+}
+
+func NewStatusChecker(logger *logger.Logger) StatusCheckable {
+	return &StatusChecker{
+		logger: logger,
+	}
+}
+
+func (checker *StatusChecker) IsUpToDate(ctx context.Context, t *ast.Task) (bool, error) {
+	for _, s := range t.Status {
+		err := execext.RunCommand(ctx, &execext.RunCommandOptions{
+			Command: s,
+			Dir:     t.Dir,
+			Env:     env.Get(t),
+		})
+		if err != nil {
+			checker.logger.VerboseOutf(logger.Yellow, "task: status command %s exited non-zero: %s\n", s, err)
+			return false, nil
+		}
+		checker.logger.VerboseOutf(logger.Yellow, "task: status command %s exited zero\n", s)
+	}
+	return true, nil
+}

internal/fingerprint/task.go

@@ -0,0 +1,132 @@
+package fingerprint
+
+import (
+	"context"
+
+	"github.com/go-task/task/v3/internal/logger"
+	"github.com/go-task/task/v3/taskfile/ast"
+)
+
+type (
+	CheckerOption func(*CheckerConfig)
+	CheckerConfig struct {
+		method         string
+		dry            bool
+		tempDir        string
+		logger         *logger.Logger
+		statusChecker  StatusCheckable
+		sourcesChecker SourcesCheckable
+	}
+)
+
+func WithMethod(method string) CheckerOption {
+	return func(config *CheckerConfig) {
+		config.method = method
+	}
+}
+
+func WithDry(dry bool) CheckerOption {
+	return func(config *CheckerConfig) {
+		config.dry = dry
+	}
+}
+
+func WithTempDir(tempDir string) CheckerOption {
+	return func(config *CheckerConfig) {
+		config.tempDir = tempDir
+	}
+}
+
+func WithLogger(logger *logger.Logger) CheckerOption {
+	return func(config *CheckerConfig) {
+		config.logger = logger
+	}
+}
+
+func WithStatusChecker(checker StatusCheckable) CheckerOption {
+	return func(config *CheckerConfig) {
+		config.statusChecker = checker
+	}
+}
+
+func WithSourcesChecker(checker SourcesCheckable) CheckerOption {
+	return func(config *CheckerConfig) {
+		config.sourcesChecker = checker
+	}
+}
+
+func IsTaskUpToDate(
+	ctx context.Context,
+	t *ast.Task,
+	opts ...CheckerOption,
+) (bool, error) {
+	var statusUpToDate bool
+	var sourcesUpToDate bool
+	var err error
+
+	// Default config
+	config := &CheckerConfig{
+		method:         "none",
+		tempDir:        "",
+		dry:            false,
+		logger:         nil,
+		statusChecker:  nil,
+		sourcesChecker: nil,
+	}
+
+	// Apply functional options
+	for _, opt := range opts {
+		opt(config)
+	}
+
+	// If no status checker was given, set up the default one
+	if config.statusChecker == nil {
+		config.statusChecker = NewStatusChecker(config.logger)
+	}
+
+	// If no sources checker was given, set up the default one
+	if config.sourcesChecker == nil {
+		config.sourcesChecker, err = NewSourcesChecker(config.method, config.tempDir, config.dry)
+		if err != nil {
+			return false, err
+		}
+	}
+
+	statusIsSet := len(t.Status) != 0
+	sourcesIsSet := len(t.Sources) != 0
+
+	// If status is set, check if it is up-to-date
+	if statusIsSet {
+		statusUpToDate, err = config.statusChecker.IsUpToDate(ctx, t)
+		if err != nil {
+			return false, err
+		}
+	}
+
+	// If sources is set, check if they are up-to-date
+	if sourcesIsSet {
+		sourcesUpToDate, err = config.sourcesChecker.IsUpToDate(t)
+		if err != nil {
+			return false, err
+		}
+	}
+
+	// If both status and sources are set, the task is up-to-date if both are up-to-date
+	if statusIsSet && sourcesIsSet {
+		return statusUpToDate && sourcesUpToDate, nil
+	}
+
+	// If only status is set, the task is up-to-date if the status is up-to-date
+	if statusIsSet {
+		return statusUpToDate, nil
+	}
+
+	// If only sources is set, the task is up-to-date if the sources are up-to-date
+	if sourcesIsSet {
+		return sourcesUpToDate, nil
+	}
+
+	// If no status or sources are set, the task should always run
+	// i.e. it is never considered "up-to-date"
+	return false, nil
+}

internal/fingerprint/task_test.go

@@ -0,0 +1,173 @@
+package fingerprint
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
+
+	"github.com/go-task/task/v3/internal/mocks"
+	"github.com/go-task/task/v3/taskfile/ast"
+)
+
+// TruthTable
+//
+// | Status up-to-date | Sources up-to-date | Task is up-to-date |
+// | ----------------- | ------------------ | ------------------ |
+// | not set           | not set            | false              |
+// | not set           | true               | true               |
+// | not set           | false              | false              |
+// | true              | not set            | true               |
+// | true              | true               | true               |
+// | true              | false              | false              |
+// | false             | not set            | false              |
+// | false             | true               | false              |
+// | false             | false              | false              |
+func TestIsTaskUpToDate(t *testing.T) {
+	tests := []struct {
+		name                    string
+		task                    *ast.Task
+		setupMockStatusChecker  func(m *mocks.StatusCheckable)
+		setupMockSourcesChecker func(m *mocks.SourcesCheckable)
+		expected                bool
+	}{
+		{
+			name: "expect FALSE when no status or sources are defined",
+			task: &ast.Task{
+				Status:  nil,
+				Sources: nil,
+			},
+			setupMockStatusChecker:  nil,
+			setupMockSourcesChecker: nil,
+			expected:                false,
+		},
+		{
+			name: "expect TRUE when no status is defined and sources are up-to-date",
+			task: &ast.Task{
+				Status:  nil,
+				Sources: []*ast.Glob{{Glob: "sources"}},
+			},
+			setupMockStatusChecker: nil,
+			setupMockSourcesChecker: func(m *mocks.SourcesCheckable) {
+				m.EXPECT().IsUpToDate(mock.Anything).Return(true, nil)
+			},
+			expected: true,
+		},
+		{
+			name: "expect FALSE when no status is defined and sources are NOT up-to-date",
+			task: &ast.Task{
+				Status:  nil,
+				Sources: []*ast.Glob{{Glob: "sources"}},
+			},
+			setupMockStatusChecker: nil,
+			setupMockSourcesChecker: func(m *mocks.SourcesCheckable) {
+				m.EXPECT().IsUpToDate(mock.Anything).Return(false, nil)
+			},
+			expected: false,
+		},
+		{
+			name: "expect TRUE when status is up-to-date and sources are not defined",
+			task: &ast.Task{
+				Status:  []string{"status"},
+				Sources: nil,
+			},
+			setupMockStatusChecker: func(m *mocks.StatusCheckable) {
+				m.EXPECT().IsUpToDate(mock.Anything, mock.Anything).Return(true, nil)
+			},
+			setupMockSourcesChecker: nil,
+			expected:                true,
+		},
+		{
+			name: "expect TRUE when status and sources are up-to-date",
+			task: &ast.Task{
+				Status:  []string{"status"},
+				Sources: []*ast.Glob{{Glob: "sources"}},
+			},
+			setupMockStatusChecker: func(m *mocks.StatusCheckable) {
+				m.EXPECT().IsUpToDate(mock.Anything, mock.Anything).Return(true, nil)
+			},
+			setupMockSourcesChecker: func(m *mocks.SourcesCheckable) {
+				m.EXPECT().IsUpToDate(mock.Anything).Return(true, nil)
+			},
+			expected: true,
+		},
+		{
+			name: "expect FALSE when status is up-to-date, but sources are NOT up-to-date",
+			task: &ast.Task{
+				Status:  []string{"status"},
+				Sources: []*ast.Glob{{Glob: "sources"}},
+			},
+			setupMockStatusChecker: func(m *mocks.StatusCheckable) {
+				m.EXPECT().IsUpToDate(mock.Anything, mock.Anything).Return(true, nil)
+			},
+			setupMockSourcesChecker: func(m *mocks.SourcesCheckable) {
+				m.EXPECT().IsUpToDate(mock.Anything).Return(false, nil)
+			},
+			expected: false,
+		},
+		{
+			name: "expect FALSE when status is NOT up-to-date and sources are not defined",
+			task: &ast.Task{
+				Status:  []string{"status"},
+				Sources: nil,
+			},
+			setupMockStatusChecker: func(m *mocks.StatusCheckable) {
+				m.EXPECT().IsUpToDate(mock.Anything, mock.Anything).Return(false, nil)
+			},
+			setupMockSourcesChecker: nil,
+			expected:                false,
+		},
+		{
+			name: "expect FALSE when status is NOT up-to-date, but sources are up-to-date",
+			task: &ast.Task{
+				Status:  []string{"status"},
+				Sources: []*ast.Glob{{Glob: "sources"}},
+			},
+			setupMockStatusChecker: func(m *mocks.StatusCheckable) {
+				m.EXPECT().IsUpToDate(mock.Anything, mock.Anything).Return(false, nil)
+			},
+			setupMockSourcesChecker: func(m *mocks.SourcesCheckable) {
+				m.EXPECT().IsUpToDate(mock.Anything).Return(true, nil)
+			},
+			expected: false,
+		},
+		{
+			name: "expect FALSE when status and sources are NOT up-to-date",
+			task: &ast.Task{
+				Status:  []string{"status"},
+				Sources: []*ast.Glob{{Glob: "sources"}},
+			},
+			setupMockStatusChecker: func(m *mocks.StatusCheckable) {
+				m.EXPECT().IsUpToDate(mock.Anything, mock.Anything).Return(false, nil)
+			},
+			setupMockSourcesChecker: func(m *mocks.SourcesCheckable) {
+				m.EXPECT().IsUpToDate(mock.Anything).Return(false, nil)
+			},
+			expected: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			mockStatusChecker := mocks.NewStatusCheckable(t)
+			if tt.setupMockStatusChecker != nil {
+				tt.setupMockStatusChecker(mockStatusChecker)
+			}
+
+			mockSourcesChecker := mocks.NewSourcesCheckable(t)
+			if tt.setupMockSourcesChecker != nil {
+				tt.setupMockSourcesChecker(mockSourcesChecker)
+			}
+
+			result, err := IsTaskUpToDate(
+				context.Background(),
+				tt.task,
+				WithStatusChecker(mockStatusChecker),
+				WithSourcesChecker(mockSourcesChecker),
+			)
+			require.NoError(t, err)
+			assert.Equal(t, tt.expected, result)
+		})
+	}
+}

internal/flags/flags.go

@@ -0,0 +1,150 @@
+package flags
+
+import (
+	"errors"
+	"log"
+	"os"
+	"time"
+
+	"github.com/spf13/pflag"
+
+	"github.com/go-task/task/v3/internal/experiments"
+	"github.com/go-task/task/v3/taskfile/ast"
+)
+
+const usage = `Usage: task [flags...] [task...]
+
+Runs the specified task(s). Falls back to the "default" task if no task name
+was specified, or lists all tasks if an unknown task name was specified.
+
+Example: 'task hello' with the following 'Taskfile.yml' file will generate an
+'output.txt' file with the content "hello".
+
+'''
+version: '3'
+tasks:
+  hello:
+    cmds:
+      - echo "I am going to write a file named 'output.txt' now."
+      - echo "hello" > output.txt
+    generates:
+      - output.txt
+'''
+
+Options:
+`
+
+var (
+	Version     bool
+	Help        bool
+	Init        bool
+	List        bool
+	ListAll     bool
+	ListJson    bool
+	TaskSort    string
+	Status      bool
+	NoStatus    bool
+	Insecure    bool
+	Force       bool
+	ForceAll    bool
+	Watch       bool
+	Verbose     bool
+	Silent      bool
+	AssumeYes   bool
+	Dry         bool
+	Summary     bool
+	ExitCode    bool
+	Parallel    bool
+	Concurrency int
+	Dir         string
+	Entrypoint  string
+	Output      ast.Output
+	Color       bool
+	Interval    time.Duration
+	Global      bool
+	Experiments bool
+	Download    bool
+	Offline     bool
+	Timeout     time.Duration
+)
+
+func init() {
+	log.SetFlags(0)
+	log.SetOutput(os.Stderr)
+	pflag.Usage = func() {
+		log.Print(usage)
+		pflag.PrintDefaults()
+	}
+
+	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.")
+	pflag.BoolVarP(&List, "list", "l", false, "Lists tasks with description of current Taskfile.")
+	pflag.BoolVarP(&ListAll, "list-all", "a", false, "Lists tasks with or without a description.")
+	pflag.BoolVarP(&ListJson, "json", "j", false, "Formats task list as JSON.")
+	pflag.StringVar(&TaskSort, "sort", "", "Changes the order of the tasks when listed. [default|alphanumeric|none].")
+	pflag.BoolVar(&Status, "status", false, "Exits with non-zero exit code if any of the given tasks is not up-to-date.")
+	pflag.BoolVar(&NoStatus, "no-status", false, "Ignore status when listing tasks as JSON")
+	pflag.BoolVar(&Insecure, "insecure", false, "Forces Task to download Taskfiles over insecure connections.")
+	pflag.BoolVarP(&Watch, "watch", "w", false, "Enables watch of the given task.")
+	pflag.BoolVarP(&Verbose, "verbose", "v", false, "Enables verbose mode.")
+	pflag.BoolVarP(&Silent, "silent", "s", false, "Disables echoing.")
+	pflag.BoolVarP(&AssumeYes, "yes", "y", false, "Assume \"yes\" as answer to all prompts.")
+	pflag.BoolVarP(&Parallel, "parallel", "p", false, "Executes tasks provided on command line in parallel.")
+	pflag.BoolVarP(&Dry, "dry", "n", false, "Compiles and prints tasks in the order that they would be run, without executing them.")
+	pflag.BoolVar(&Summary, "summary", false, "Show summary about a task.")
+	pflag.BoolVarP(&ExitCode, "exit-code", "x", false, "Pass-through the exit code of the task command.")
+	pflag.StringVarP(&Dir, "dir", "d", "", "Sets directory of execution.")
+	pflag.StringVarP(&Entrypoint, "taskfile", "t", "", `Choose which Taskfile to run. Defaults to "Taskfile.yml".`)
+	pflag.StringVarP(&Output.Name, "output", "o", "", "Sets output style: [interleaved|group|prefixed].")
+	pflag.StringVar(&Output.Group.Begin, "output-group-begin", "", "Message template to print before a task's grouped output.")
+	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.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 {
+		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 {
+		pflag.BoolVarP(&ForceAll, "force", "f", false, "Forces execution even when the task is up-to-date.")
+	}
+
+	// Remote Taskfiles experiment will adds the "download" and "offline" flags
+	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.DurationVar(&Timeout, "timeout", time.Second*10, "Timeout for downloading remote Taskfiles.")
+	}
+
+	pflag.Parse()
+}
+
+func Validate() error {
+	if Download && Offline {
+		return errors.New("task: You can't set both --download and --offline flags")
+	}
+
+	if Global && Dir != "" {
+		log.Fatal("task: You can't set both --global and --dir")
+		return nil
+	}
+
+	if Output.Name != "group" {
+		if Output.Group.Begin != "" {
+			return errors.New("task: You can't set --output-group-begin without --output=group")
+		}
+		if Output.Group.End != "" {
+			return errors.New("task: You can't set --output-group-end without --output=group")
+		}
+		if Output.Group.ErrorOnly {
+			return errors.New("task: You can't set --output-group-error-only without --output=group")
+		}
+	}
+
+	return nil
+}

internal/goext/meta.go

@@ -32,6 +32,7 @@ var knownOS = map[string]struct{}{
 	"solaris":   {},
 	"windows":   {},
 	"zos":       {},
+	"__test__":  {},
 }
 
 var knownArch = map[string]struct{}{

internal/hash/hash.go

@@ -5,20 +5,20 @@ import (
 
 	"github.com/mitchellh/hashstructure/v2"
 
-	"github.com/go-task/task/v3/taskfile"
+	"github.com/go-task/task/v3/taskfile/ast"
 )
 
-type HashFunc func(*taskfile.Task) (string, error)
+type HashFunc func(*ast.Task) (string, error)
 
-func Empty(*taskfile.Task) (string, error) {
+func Empty(*ast.Task) (string, error) {
 	return "", nil
 }
 
-func Name(t *taskfile.Task) (string, error) {
+func Name(t *ast.Task) (string, error) {
 	return t.Task, nil
 }
 
-func Hash(t *taskfile.Task) (string, error) {
+func Hash(t *ast.Task) (string, error) {
 	h, err := hashstructure.Hash(t, hashstructure.FormatV2, nil)
 	return fmt.Sprintf("%s:%d", t.Task, h), err
 }

internal/logger/logger.go

@@ -1,65 +1,109 @@
 package logger
 
 import (
+	"bufio"
 	"io"
 	"os"
+	"slices"
 	"strconv"
+	"strings"
 
 	"github.com/fatih/color"
+
+	"github.com/go-task/task/v3/errors"
+	"github.com/go-task/task/v3/internal/term"
 )
 
-type Color func() PrintFunc
-type PrintFunc func(io.Writer, string, ...interface{})
+var (
+	ErrPromptCancelled = errors.New("prompt cancelled")
+	ErrNoTerminal      = errors.New("no terminal")
+)
+
+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(envColor("TASK_COLOR_RESET", color.Reset)...).FprintfFunc()
 }
+
 func Blue() PrintFunc {
-	return color.New(envColor("TASK_COLOR_BLUE", color.FgBlue)).FprintfFunc()
+	return color.New(envColor("TASK_COLOR_BLUE", color.FgBlue)...).FprintfFunc()
 }
+
 func Green() PrintFunc {
-	return color.New(envColor("TASK_COLOR_GREEN", color.FgGreen)).FprintfFunc()
+	return color.New(envColor("TASK_COLOR_GREEN", color.FgGreen)...).FprintfFunc()
 }
+
 func Cyan() PrintFunc {
-	return color.New(envColor("TASK_COLOR_CYAN", color.FgCyan)).FprintfFunc()
+	return color.New(envColor("TASK_COLOR_CYAN", color.FgCyan)...).FprintfFunc()
 }
+
 func Yellow() PrintFunc {
-	return color.New(envColor("TASK_COLOR_YELLOW", color.FgYellow)).FprintfFunc()
+	return color.New(envColor("TASK_COLOR_YELLOW", color.FgYellow)...).FprintfFunc()
 }
+
 func Magenta() PrintFunc {
-	return color.New(envColor("TASK_COLOR_MAGENTA", color.FgMagenta)).FprintfFunc()
+	return color.New(envColor("TASK_COLOR_MAGENTA", color.FgMagenta)...).FprintfFunc()
 }
+
 func Red() PrintFunc {
-	return color.New(envColor("TASK_COLOR_RED", color.FgRed)).FprintfFunc()
+	return color.New(envColor("TASK_COLOR_RED", color.FgRed)...).FprintfFunc()
 }
 
-func envColor(env string, defaultColor color.Attribute) color.Attribute {
-	override, err := strconv.Atoi(os.Getenv(env))
-	if err == nil {
-		return color.Attribute(override)
-
+func envColor(env string, defaultColor color.Attribute) []color.Attribute {
+	if os.Getenv("FORCE_COLOR") != "" {
+		color.NoColor = false
 	}
-	return defaultColor
+
+	// Fetch the environment variable
+	override := os.Getenv(env)
+
+	// First, try splitting the string by commas (RGB shortcut syntax) and if it
+	// matches, then prepend the 256-color foreground escape sequence.
+	// Otherwise, split by semicolons (ANSI color codes) and use them as is.
+	attributeStrs := strings.Split(override, ",")
+	if len(attributeStrs) == 3 {
+		attributeStrs = append([]string{"38", "2"}, attributeStrs...)
+	} else {
+		attributeStrs = strings.Split(override, ";")
+	}
+
+	// Loop over the attributes and convert them to integers
+	attributes := make([]color.Attribute, len(attributeStrs))
+	for i, attributeStr := range attributeStrs {
+		attribute, err := strconv.Atoi(attributeStr)
+		if err != nil {
+			return []color.Attribute{defaultColor}
+		}
+		attributes[i] = color.Attribute(attribute)
+	}
+
+	return attributes
 }
 
 // Logger is just a wrapper that prints stuff to STDOUT or STDERR,
 // with optional color.
 type Logger struct {
-	Stdout  io.Writer
-	Stderr  io.Writer
-	Verbose bool
-	Color   bool
+	Stdin      io.Reader
+	Stdout     io.Writer
+	Stderr     io.Writer
+	Verbose    bool
+	Color      bool
+	AssumeYes  bool
+	AssumeTerm bool // Used for testing
 }
 
 // Outf prints stuff to STDOUT.
-func (l *Logger) Outf(color Color, s string, args ...interface{}) {
-	l.FOutf(l.Stdout, color, s+"\n", args...)
+func (l *Logger) Outf(color Color, s string, args ...any) {
+	l.FOutf(l.Stdout, color, s, args...)
 }
 
 // FOutf prints stuff to the given writer.
-func (l *Logger) FOutf(w io.Writer, color Color, s string, args ...interface{}) {
+func (l *Logger) FOutf(w io.Writer, color Color, s string, args ...any) {
 	if len(args) == 0 {
-		s, args = "%s", []interface{}{s}
+		s, args = "%s", []any{s}
 	}
 	if !l.Color {
 		color = Default
@@ -69,27 +113,61 @@ func (l *Logger) FOutf(w io.Writer, color Color, s string, args ...interface{})
 }
 
 // VerboseOutf prints stuff to STDOUT if verbose mode is enabled.
-func (l *Logger) VerboseOutf(color Color, s string, args ...interface{}) {
+func (l *Logger) VerboseOutf(color Color, s string, args ...any) {
 	if l.Verbose {
 		l.Outf(color, s, args...)
 	}
 }
 
 // Errf prints stuff to STDERR.
-func (l *Logger) Errf(color Color, s string, args ...interface{}) {
+func (l *Logger) Errf(color Color, s string, args ...any) {
 	if len(args) == 0 {
-		s, args = "%s", []interface{}{s}
+		s, args = "%s", []any{s}
 	}
 	if !l.Color {
 		color = Default
 	}
 	print := color()
-	print(l.Stderr, s+"\n", args...)
+	print(l.Stderr, s, args...)
 }
 
 // VerboseErrf prints stuff to STDERR if verbose mode is enabled.
-func (l *Logger) VerboseErrf(color Color, s string, args ...interface{}) {
+func (l *Logger) VerboseErrf(color Color, s string, args ...any) {
 	if l.Verbose {
 		l.Errf(color, s, args...)
 	}
 }
+
+func (l *Logger) Warnf(message string, args ...any) {
+	l.Errf(Yellow, message, args...)
+}
+
+func (l *Logger) Prompt(color Color, prompt string, defaultValue string, continueValues ...string) error {
+	if l.AssumeYes {
+		l.Outf(color, "%s [assuming yes]\n", prompt)
+		return nil
+	}
+
+	if !l.AssumeTerm && !term.IsTerminal() {
+		return ErrNoTerminal
+	}
+
+	if len(continueValues) == 0 {
+		return errors.New("no continue values provided")
+	}
+
+	l.Outf(color, "%s [%s/%s]\n", prompt, strings.ToLower(continueValues[0]), strings.ToUpper(defaultValue))
+
+	reader := bufio.NewReader(l.Stdin)
+	input, err := reader.ReadString('\n')
+	if err != nil {
+		return err
+	}
+
+	input = strings.TrimSpace(strings.ToLower(input))
+	if !slices.Contains(continueValues, input) {
+		return ErrPromptCancelled
+	}
+
+	return nil
+}

internal/mocks/sources_checkable.go

@@ -0,0 +1,226 @@
+// Code generated by mockery v2.24.0. DO NOT EDIT.
+
+package mocks
+
+import (
+	ast "github.com/go-task/task/v3/taskfile/ast"
+
+	mock "github.com/stretchr/testify/mock"
+)
+
+// SourcesCheckable is an autogenerated mock type for the SourcesCheckable type
+type SourcesCheckable struct {
+	mock.Mock
+}
+
+type SourcesCheckable_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *SourcesCheckable) EXPECT() *SourcesCheckable_Expecter {
+	return &SourcesCheckable_Expecter{mock: &_m.Mock}
+}
+
+// IsUpToDate provides a mock function with given fields: t
+func (_m *SourcesCheckable) IsUpToDate(t *ast.Task) (bool, error) {
+	ret := _m.Called(t)
+
+	var r0 bool
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*ast.Task) (bool, error)); ok {
+		return rf(t)
+	}
+	if rf, ok := ret.Get(0).(func(*ast.Task) bool); ok {
+		r0 = rf(t)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+
+	if rf, ok := ret.Get(1).(func(*ast.Task) error); ok {
+		r1 = rf(t)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// SourcesCheckable_IsUpToDate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsUpToDate'
+type SourcesCheckable_IsUpToDate_Call struct {
+	*mock.Call
+}
+
+// IsUpToDate is a helper method to define mock.On call
+//   - t *ast.Task
+func (_e *SourcesCheckable_Expecter) IsUpToDate(t interface{}) *SourcesCheckable_IsUpToDate_Call {
+	return &SourcesCheckable_IsUpToDate_Call{Call: _e.mock.On("IsUpToDate", t)}
+}
+
+func (_c *SourcesCheckable_IsUpToDate_Call) Run(run func(t *ast.Task)) *SourcesCheckable_IsUpToDate_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(*ast.Task))
+	})
+	return _c
+}
+
+func (_c *SourcesCheckable_IsUpToDate_Call) Return(_a0 bool, _a1 error) *SourcesCheckable_IsUpToDate_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *SourcesCheckable_IsUpToDate_Call) RunAndReturn(run func(*ast.Task) (bool, error)) *SourcesCheckable_IsUpToDate_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Kind provides a mock function with given fields:
+func (_m *SourcesCheckable) Kind() string {
+	ret := _m.Called()
+
+	var r0 string
+	if rf, ok := ret.Get(0).(func() string); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	return r0
+}
+
+// SourcesCheckable_Kind_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Kind'
+type SourcesCheckable_Kind_Call struct {
+	*mock.Call
+}
+
+// Kind is a helper method to define mock.On call
+func (_e *SourcesCheckable_Expecter) Kind() *SourcesCheckable_Kind_Call {
+	return &SourcesCheckable_Kind_Call{Call: _e.mock.On("Kind")}
+}
+
+func (_c *SourcesCheckable_Kind_Call) Run(run func()) *SourcesCheckable_Kind_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *SourcesCheckable_Kind_Call) Return(_a0 string) *SourcesCheckable_Kind_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *SourcesCheckable_Kind_Call) RunAndReturn(run func() string) *SourcesCheckable_Kind_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// OnError provides a mock function with given fields: t
+func (_m *SourcesCheckable) OnError(t *ast.Task) error {
+	ret := _m.Called(t)
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*ast.Task) error); ok {
+		r0 = rf(t)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// SourcesCheckable_OnError_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OnError'
+type SourcesCheckable_OnError_Call struct {
+	*mock.Call
+}
+
+// OnError is a helper method to define mock.On call
+//   - t *ast.Task
+func (_e *SourcesCheckable_Expecter) OnError(t interface{}) *SourcesCheckable_OnError_Call {
+	return &SourcesCheckable_OnError_Call{Call: _e.mock.On("OnError", t)}
+}
+
+func (_c *SourcesCheckable_OnError_Call) Run(run func(t *ast.Task)) *SourcesCheckable_OnError_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(*ast.Task))
+	})
+	return _c
+}
+
+func (_c *SourcesCheckable_OnError_Call) Return(_a0 error) *SourcesCheckable_OnError_Call {
+	_c.Call.Return(_a0)
+	return _c
+}
+
+func (_c *SourcesCheckable_OnError_Call) RunAndReturn(run func(*ast.Task) error) *SourcesCheckable_OnError_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Value provides a mock function with given fields: t
+func (_m *SourcesCheckable) Value(t *ast.Task) (interface{}, error) {
+	ret := _m.Called(t)
+
+	var r0 interface{}
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*ast.Task) (interface{}, error)); ok {
+		return rf(t)
+	}
+	if rf, ok := ret.Get(0).(func(*ast.Task) interface{}); ok {
+		r0 = rf(t)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(interface{})
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*ast.Task) error); ok {
+		r1 = rf(t)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// SourcesCheckable_Value_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Value'
+type SourcesCheckable_Value_Call struct {
+	*mock.Call
+}
+
+// Value is a helper method to define mock.On call
+//   - t *ast.Task
+func (_e *SourcesCheckable_Expecter) Value(t interface{}) *SourcesCheckable_Value_Call {
+	return &SourcesCheckable_Value_Call{Call: _e.mock.On("Value", t)}
+}
+
+func (_c *SourcesCheckable_Value_Call) Run(run func(t *ast.Task)) *SourcesCheckable_Value_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(*ast.Task))
+	})
+	return _c
+}
+
+func (_c *SourcesCheckable_Value_Call) Return(_a0 interface{}, _a1 error) *SourcesCheckable_Value_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *SourcesCheckable_Value_Call) RunAndReturn(run func(*ast.Task) (interface{}, error)) *SourcesCheckable_Value_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+type mockConstructorTestingTNewSourcesCheckable interface {
+	mock.TestingT
+	Cleanup(func())
+}
+
+// NewSourcesCheckable creates a new instance of SourcesCheckable. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+func NewSourcesCheckable(t mockConstructorTestingTNewSourcesCheckable) *SourcesCheckable {
+	mock := &SourcesCheckable{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

internal/mocks/status_checkable.go

@@ -0,0 +1,92 @@
+// Code generated by mockery v2.24.0. DO NOT EDIT.
+
+package mocks
+
+import (
+	context "context"
+
+	ast "github.com/go-task/task/v3/taskfile/ast"
+
+	mock "github.com/stretchr/testify/mock"
+)
+
+// StatusCheckable is an autogenerated mock type for the StatusCheckable type
+type StatusCheckable struct {
+	mock.Mock
+}
+
+type StatusCheckable_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *StatusCheckable) EXPECT() *StatusCheckable_Expecter {
+	return &StatusCheckable_Expecter{mock: &_m.Mock}
+}
+
+// IsUpToDate provides a mock function with given fields: ctx, t
+func (_m *StatusCheckable) IsUpToDate(ctx context.Context, t *ast.Task) (bool, error) {
+	ret := _m.Called(ctx, t)
+
+	var r0 bool
+	var r1 error
+	if rf, ok := ret.Get(0).(func(context.Context, *ast.Task) (bool, error)); ok {
+		return rf(ctx, t)
+	}
+	if rf, ok := ret.Get(0).(func(context.Context, *ast.Task) bool); ok {
+		r0 = rf(ctx, t)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+
+	if rf, ok := ret.Get(1).(func(context.Context, *ast.Task) error); ok {
+		r1 = rf(ctx, t)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// StatusCheckable_IsUpToDate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsUpToDate'
+type StatusCheckable_IsUpToDate_Call struct {
+	*mock.Call
+}
+
+// IsUpToDate is a helper method to define mock.On call
+//   - ctx context.Context
+//   - t *ast.Task
+func (_e *StatusCheckable_Expecter) IsUpToDate(ctx interface{}, t interface{}) *StatusCheckable_IsUpToDate_Call {
+	return &StatusCheckable_IsUpToDate_Call{Call: _e.mock.On("IsUpToDate", ctx, t)}
+}
+
+func (_c *StatusCheckable_IsUpToDate_Call) Run(run func(ctx context.Context, t *ast.Task)) *StatusCheckable_IsUpToDate_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(*ast.Task))
+	})
+	return _c
+}
+
+func (_c *StatusCheckable_IsUpToDate_Call) Return(_a0 bool, _a1 error) *StatusCheckable_IsUpToDate_Call {
+	_c.Call.Return(_a0, _a1)
+	return _c
+}
+
+func (_c *StatusCheckable_IsUpToDate_Call) RunAndReturn(run func(context.Context, *ast.Task) (bool, error)) *StatusCheckable_IsUpToDate_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+type mockConstructorTestingTNewStatusCheckable interface {
+	mock.TestingT
+	Cleanup(func())
+}
+
+// NewStatusCheckable creates a new instance of StatusCheckable. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+func NewStatusCheckable(t mockConstructorTestingTNewStatusCheckable) *StatusCheckable {
+	mock := &StatusCheckable{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

internal/omap/orderedmap.go

@@ -0,0 +1,164 @@
+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

@@ -0,0 +1,121 @@
+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/group.go

@@ -3,21 +3,30 @@ package output
 import (
 	"bytes"
 	"io"
+
+	"github.com/go-task/task/v3/internal/templater"
 )
 
 type Group struct {
 	Begin, End string
+	ErrorOnly  bool
 }
 
-func (g Group) WrapWriter(stdOut, _ io.Writer, _ string, tmpl Templater) (io.Writer, io.Writer, CloseFunc) {
+func (g Group) WrapWriter(stdOut, _ io.Writer, _ string, cache *templater.Cache) (io.Writer, io.Writer, CloseFunc) {
 	gw := &groupWriter{writer: stdOut}
 	if g.Begin != "" {
-		gw.begin = tmpl.Replace(g.Begin) + "\n"
+		gw.begin = templater.Replace(g.Begin, cache) + "\n"
 	}
 	if g.End != "" {
-		gw.end = tmpl.Replace(g.End) + "\n"
+		gw.end = templater.Replace(g.End, cache) + "\n"
+	}
+	return gw, gw, func(err error) error {
+		if g.ErrorOnly && err == nil {
+			return nil
+		}
+
+		return gw.close()
 	}
-	return gw, gw, func() error { return gw.close() }
 }
 
 type groupWriter struct {

internal/output/interleaved.go

@@ -2,10 +2,12 @@ package output
 
 import (
 	"io"
+
+	"github.com/go-task/task/v3/internal/templater"
 )
 
 type Interleaved struct{}
 
-func (Interleaved) WrapWriter(stdOut, stdErr io.Writer, _ string, _ Templater) (io.Writer, io.Writer, CloseFunc) {
-	return stdOut, stdErr, func() error { return nil }
+func (Interleaved) WrapWriter(stdOut, stdErr io.Writer, _ string, _ *templater.Cache) (io.Writer, io.Writer, CloseFunc) {
+	return stdOut, stdErr, func(error) error { return nil }
 }

internal/output/output.go

@@ -4,24 +4,18 @@ import (
 	"fmt"
 	"io"
 
-	"github.com/go-task/task/v3/taskfile"
+	"github.com/go-task/task/v3/internal/templater"
+	"github.com/go-task/task/v3/taskfile/ast"
 )
 
-// Templater executes a template engine.
-// It is provided by the templater.Templater package.
-type Templater interface {
-	// Replace replaces the provided template string with a rendered string.
-	Replace(tmpl string) string
-}
-
 type Output interface {
-	WrapWriter(stdOut, stdErr io.Writer, prefix string, tmpl Templater) (io.Writer, io.Writer, CloseFunc)
+	WrapWriter(stdOut, stdErr io.Writer, prefix string, cache *templater.Cache) (io.Writer, io.Writer, CloseFunc)
 }
 
-type CloseFunc func() error
+type CloseFunc func(err error) error
 
-// Build the Output for the requested taskfile.Output.
-func BuildFor(o *taskfile.Output) (Output, error) {
+// Build the Output for the requested ast.Output.
+func BuildFor(o *ast.Output) (Output, error) {
 	switch o.Name {
 	case "interleaved", "":
 		if err := checkOutputGroupUnset(o); err != nil {
@@ -30,8 +24,9 @@ func BuildFor(o *taskfile.Output) (Output, error) {
 		return Interleaved{}, nil
 	case "group":
 		return Group{
-			Begin: o.Group.Begin,
-			End:   o.Group.End,
+			Begin:     o.Group.Begin,
+			End:       o.Group.End,
+			ErrorOnly: o.Group.ErrorOnly,
 		}, nil
 	case "prefixed":
 		if err := checkOutputGroupUnset(o); err != nil {
@@ -43,7 +38,7 @@ func BuildFor(o *taskfile.Output) (Output, error) {
 	}
 }
 
-func checkOutputGroupUnset(o *taskfile.Output) error {
+func checkOutputGroupUnset(o *ast.Output) error {
 	if o.Group.IsSet() {
 		return fmt.Errorf("task: output style %q does not support the group begin/end parameter", o.Name)
 	}

internal/output/output_test.go

@@ -2,21 +2,24 @@ package output_test
 
 import (
 	"bytes"
+	"errors"
 	"fmt"
 	"io"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
+	"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"
+	"github.com/go-task/task/v3/taskfile/ast"
 )
 
 func TestInterleaved(t *testing.T) {
 	var b bytes.Buffer
 	var o output.Output = output.Interleaved{}
-	var w, _, _ = o.WrapWriter(&b, io.Discard, "", nil)
+	w, _, _ := o.WrapWriter(&b, io.Discard, "", nil)
 
 	fmt.Fprintln(w, "foo\nbar")
 	assert.Equal(t, "foo\nbar\n", b.String())
@@ -27,7 +30,7 @@ func TestInterleaved(t *testing.T) {
 func TestGroup(t *testing.T) {
 	var b bytes.Buffer
 	var o output.Output = output.Group{}
-	var stdOut, stdErr, cleanup = o.WrapWriter(&b, io.Discard, "", nil)
+	stdOut, stdErr, cleanup := o.WrapWriter(&b, io.Discard, "", nil)
 
 	fmt.Fprintln(stdOut, "out\nout")
 	assert.Equal(t, "", b.String())
@@ -38,17 +41,16 @@ func TestGroup(t *testing.T) {
 	fmt.Fprintln(stdErr, "err")
 	assert.Equal(t, "", b.String())
 
-	assert.NoError(t, cleanup())
+	require.NoError(t, cleanup(nil))
 	assert.Equal(t, "out\nout\nerr\nerr\nout\nerr\n", b.String())
 }
 
 func TestGroupWithBeginEnd(t *testing.T) {
-	tmpl := templater.Templater{
-		Vars: &taskfile.Vars{
-			Keys: []string{"VAR1"},
-			Mapping: map[string]taskfile.Var{
-				"VAR1": {Static: "example-value"},
-			},
+	tmpl := templater.Cache{
+		Vars: &ast.Vars{
+			OrderedMap: omap.FromMap(map[string]ast.Var{
+				"VAR1": {Value: "example-value"},
+			}),
 		},
 	}
 
@@ -58,27 +60,55 @@ func TestGroupWithBeginEnd(t *testing.T) {
 	}
 	t.Run("simple", func(t *testing.T) {
 		var b bytes.Buffer
-		var w, _, cleanup = o.WrapWriter(&b, io.Discard, "", &tmpl)
+		w, _, cleanup := o.WrapWriter(&b, io.Discard, "", &tmpl)
 
 		fmt.Fprintln(w, "foo\nbar")
 		assert.Equal(t, "", b.String())
 		fmt.Fprintln(w, "baz")
 		assert.Equal(t, "", b.String())
-		assert.NoError(t, cleanup())
+		require.NoError(t, cleanup(nil))
 		assert.Equal(t, "::group::example-value\nfoo\nbar\nbaz\n::endgroup::\n", b.String())
 	})
 	t.Run("no output", func(t *testing.T) {
 		var b bytes.Buffer
-		var _, _, cleanup = o.WrapWriter(&b, io.Discard, "", &tmpl)
-		assert.NoError(t, cleanup())
+		_, _, cleanup := o.WrapWriter(&b, io.Discard, "", &tmpl)
+		require.NoError(t, cleanup(nil))
 		assert.Equal(t, "", b.String())
 	})
 }
 
+func TestGroupErrorOnlySwallowsOutputOnNoError(t *testing.T) {
+	var b bytes.Buffer
+	var o output.Output = output.Group{
+		ErrorOnly: true,
+	}
+	stdOut, stdErr, cleanup := o.WrapWriter(&b, io.Discard, "", nil)
+
+	_, _ = fmt.Fprintln(stdOut, "std-out")
+	_, _ = fmt.Fprintln(stdErr, "std-err")
+
+	require.NoError(t, cleanup(nil))
+	assert.Empty(t, b.String())
+}
+
+func TestGroupErrorOnlyShowsOutputOnError(t *testing.T) {
+	var b bytes.Buffer
+	var o output.Output = output.Group{
+		ErrorOnly: true,
+	}
+	stdOut, stdErr, cleanup := o.WrapWriter(&b, io.Discard, "", nil)
+
+	_, _ = fmt.Fprintln(stdOut, "std-out")
+	_, _ = fmt.Fprintln(stdErr, "std-err")
+
+	require.NoError(t, cleanup(errors.New("any-error")))
+	assert.Equal(t, "std-out\nstd-err\n", b.String())
+}
+
 func TestPrefixed(t *testing.T) {
 	var b bytes.Buffer
 	var o output.Output = output.Prefixed{}
-	var w, _, cleanup = o.WrapWriter(&b, io.Discard, "prefix", nil)
+	w, _, cleanup := o.WrapWriter(&b, io.Discard, "prefix", nil)
 
 	t.Run("simple use cases", func(t *testing.T) {
 		b.Reset()
@@ -87,7 +117,7 @@ func TestPrefixed(t *testing.T) {
 		assert.Equal(t, "[prefix] foo\n[prefix] bar\n", b.String())
 		fmt.Fprintln(w, "baz")
 		assert.Equal(t, "[prefix] foo\n[prefix] bar\n[prefix] baz\n", b.String())
-		assert.NoError(t, cleanup())
+		require.NoError(t, cleanup(nil))
 	})
 
 	t.Run("multiple writes for a single line", func(t *testing.T) {
@@ -98,7 +128,7 @@ func TestPrefixed(t *testing.T) {
 			assert.Equal(t, "", b.String())
 		}
 
-		assert.NoError(t, cleanup())
+		require.NoError(t, cleanup(nil))
 		assert.Equal(t, "[prefix] Test!\n", b.String())
 	})
 }

internal/output/prefixed.go

@@ -5,13 +5,15 @@ import (
 	"fmt"
 	"io"
 	"strings"
+
+	"github.com/go-task/task/v3/internal/templater"
 )
 
 type Prefixed struct{}
 
-func (Prefixed) WrapWriter(stdOut, _ io.Writer, prefix string, _ Templater) (io.Writer, io.Writer, CloseFunc) {
+func (Prefixed) WrapWriter(stdOut, _ io.Writer, prefix string, _ *templater.Cache) (io.Writer, io.Writer, CloseFunc) {
 	pw := &prefixWriter{writer: stdOut, prefix: prefix}
-	return pw, pw, func() error { return pw.close() }
+	return pw, pw, func(error) error { return pw.close() }
 }
 
 type prefixWriter struct {

internal/slicesext/slicesext.go

@@ -1,11 +1,11 @@
 package slicesext
 
 import (
-	"golang.org/x/exp/constraints"
-	"golang.org/x/exp/slices"
+	"cmp"
+	"slices"
 )
 
-func UniqueJoin[T constraints.Ordered](ss ...[]T) []T {
+func UniqueJoin[T cmp.Ordered](ss ...[]T) []T {
 	var length int
 	for _, s := range ss {
 		length += len(s)

internal/sort/sorter.go

@@ -0,0 +1,44 @@
+package sort
+
+import (
+	"sort"
+	"strings"
+
+	"github.com/go-task/task/v3/taskfile/ast"
+)
+
+type TaskSorter interface {
+	Sort([]*ast.Task)
+}
+
+type Noop struct{}
+
+func (s *Noop) Sort(tasks []*ast.Task) {}
+
+type AlphaNumeric struct{}
+
+// Tasks that are not namespaced should be listed before tasks that are.
+// We detect this by searching for a ':' in the task name.
+func (s *AlphaNumeric) Sort(tasks []*ast.Task) {
+	sort.Slice(tasks, func(i, j int) bool {
+		return tasks[i].Task < tasks[j].Task
+	})
+}
+
+type AlphaNumericWithRootTasksFirst struct{}
+
+// Tasks that are not namespaced should be listed before tasks that are.
+// We detect this by searching for a ':' in the task name.
+func (s *AlphaNumericWithRootTasksFirst) Sort(tasks []*ast.Task) {
+	sort.Slice(tasks, func(i, j int) bool {
+		iContainsColon := strings.Contains(tasks[i].Task, ":")
+		jContainsColon := strings.Contains(tasks[j].Task, ":")
+		if iContainsColon == jContainsColon {
+			return tasks[i].Task < tasks[j].Task
+		}
+		if !iContainsColon && jContainsColon {
+			return true
+		}
+		return false
+	})
+}

internal/sort/sorter_test.go

@@ -0,0 +1,77 @@
+package sort
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/go-task/task/v3/taskfile/ast"
+)
+
+func TestAlphaNumericWithRootTasksFirst_Sort(t *testing.T) {
+	task1 := &ast.Task{Task: "task1"}
+	task2 := &ast.Task{Task: "task2"}
+	task3 := &ast.Task{Task: "ns1:task3"}
+	task4 := &ast.Task{Task: "ns2:task4"}
+	task5 := &ast.Task{Task: "task5"}
+	task6 := &ast.Task{Task: "ns3:task6"}
+
+	tests := []struct {
+		name  string
+		tasks []*ast.Task
+		want  []*ast.Task
+	}{
+		{
+			name:  "no namespace tasks sorted alphabetically first",
+			tasks: []*ast.Task{task3, task2, task1},
+			want:  []*ast.Task{task1, task2, task3},
+		},
+		{
+			name:  "namespace tasks sorted alphabetically after non-namespaced tasks",
+			tasks: []*ast.Task{task3, task4, task5},
+			want:  []*ast.Task{task5, task3, task4},
+		},
+		{
+			name:  "all tasks sorted alphabetically with root tasks first",
+			tasks: []*ast.Task{task6, task5, task4, task3, task2, task1},
+			want:  []*ast.Task{task1, task2, task5, task3, task4, task6},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			s := &AlphaNumericWithRootTasksFirst{}
+			s.Sort(tt.tasks)
+			assert.Equal(t, tt.want, tt.tasks)
+		})
+	}
+}
+
+func TestAlphaNumeric_Sort(t *testing.T) {
+	task1 := &ast.Task{Task: "task1"}
+	task2 := &ast.Task{Task: "task2"}
+	task3 := &ast.Task{Task: "ns1:task3"}
+	task4 := &ast.Task{Task: "ns2:task4"}
+	task5 := &ast.Task{Task: "task5"}
+	task6 := &ast.Task{Task: "ns3:task6"}
+
+	tests := []struct {
+		name  string
+		tasks []*ast.Task
+		want  []*ast.Task
+	}{
+		{
+			name:  "all tasks sorted alphabetically",
+			tasks: []*ast.Task{task3, task2, task5, task1, task4, task6},
+			want:  []*ast.Task{task3, task4, task6, task1, task2, task5},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			s := &AlphaNumeric{}
+			s.Sort(tt.tasks)
+			assert.Equal(t, tt.tasks, tt.want)
+		})
+	}
+}

internal/status/checksum.go

@@ -1,121 +0,0 @@
-package status
-
-import (
-	"crypto/md5"
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-	"regexp"
-	"strings"
-
-	"github.com/go-task/task/v3/internal/filepathext"
-)
-
-// Checksum validades if a task is up to date by calculating its source
-// files checksum
-type Checksum struct {
-	TempDir   string
-	TaskDir   string
-	Task      string
-	Sources   []string
-	Generates []string
-	Dry       bool
-}
-
-// IsUpToDate implements the Checker interface
-func (c *Checksum) IsUpToDate() (bool, error) {
-	if len(c.Sources) == 0 {
-		return false, nil
-	}
-
-	checksumFile := c.checksumFilePath()
-
-	data, _ := os.ReadFile(checksumFile)
-	oldMd5 := strings.TrimSpace(string(data))
-
-	sources, err := globs(c.TaskDir, c.Sources)
-	if err != nil {
-		return false, err
-	}
-
-	newMd5, err := c.checksum(sources...)
-	if err != nil {
-		return false, nil
-	}
-
-	if !c.Dry {
-		_ = os.MkdirAll(filepathext.SmartJoin(c.TempDir, "checksum"), 0o755)
-		if err = os.WriteFile(checksumFile, []byte(newMd5+"\n"), 0o644); err != nil {
-			return false, err
-		}
-	}
-
-	if len(c.Generates) > 0 {
-		// For each specified 'generates' field, check whether the files actually exist
-		for _, g := range c.Generates {
-			generates, err := Glob(c.TaskDir, g)
-			if os.IsNotExist(err) {
-				return false, nil
-			}
-			if err != nil {
-				return false, err
-			}
-			if len(generates) == 0 {
-				return false, nil
-			}
-		}
-	}
-
-	return oldMd5 == newMd5, nil
-}
-
-func (c *Checksum) checksum(files ...string) (string, error) {
-	h := md5.New()
-
-	for _, f := range files {
-		// also sum the filename, so checksum changes for renaming a file
-		if _, err := io.Copy(h, strings.NewReader(filepath.Base(f))); err != nil {
-			return "", err
-		}
-		f, err := os.Open(f)
-		if err != nil {
-			return "", err
-		}
-		if _, err = io.Copy(h, f); err != nil {
-			return "", err
-		}
-		f.Close()
-	}
-
-	return fmt.Sprintf("%x", h.Sum(nil)), nil
-}
-
-// Value implements the Checker Interface
-func (c *Checksum) Value() (interface{}, error) {
-	return c.checksum()
-}
-
-// OnError implements the Checker interface
-func (c *Checksum) OnError() error {
-	if len(c.Sources) == 0 {
-		return nil
-	}
-	return os.Remove(c.checksumFilePath())
-}
-
-// Kind implements the Checker Interface
-func (*Checksum) Kind() string {
-	return "checksum"
-}
-
-func (c *Checksum) checksumFilePath() string {
-	return filepath.Join(c.TempDir, "checksum", normalizeFilename(c.Task))
-}
-
-var checksumFilenameRegexp = regexp.MustCompile("[^A-z0-9]")
-
-// replaces invalid caracters on filenames with "-"
-func normalizeFilename(f string) string {
-	return checksumFilenameRegexp.ReplaceAllString(f, "-")
-}

internal/status/none.go

@@ -1,23 +0,0 @@
-package status
-
-// None is a no-op Checker
-type None struct{}
-
-// IsUpToDate implements the Checker interface
-func (None) IsUpToDate() (bool, error) {
-	return false, nil
-}
-
-// Value implements the Checker interface
-func (None) Value() (interface{}, error) {
-	return "", nil
-}
-
-func (None) Kind() string {
-	return "none"
-}
-
-// OnError implements the Checker interface
-func (None) OnError() error {
-	return nil
-}

internal/status/status.go

@@ -1,15 +0,0 @@
-package status
-
-var (
-	_ Checker = &Timestamp{}
-	_ Checker = &Checksum{}
-	_ Checker = None{}
-)
-
-// Checker is an interface that checks if the status is up-to-date
-type Checker interface {
-	IsUpToDate() (bool, error)
-	Value() (interface{}, error)
-	OnError() error
-	Kind() string
-}

internal/summary/summary.go

@@ -4,13 +4,13 @@ import (
 	"strings"
 
 	"github.com/go-task/task/v3/internal/logger"
-	"github.com/go-task/task/v3/taskfile"
+	"github.com/go-task/task/v3/taskfile/ast"
 )
 
-func PrintTasks(l *logger.Logger, t *taskfile.Taskfile, c []taskfile.Call) {
+func PrintTasks(l *logger.Logger, t *ast.Taskfile, c []*ast.Call) {
 	for i, call := range c {
 		PrintSpaceBetweenSummaries(l, i)
-		PrintTask(l, t.Tasks[call.Task])
+		PrintTask(l, t.Tasks.Get(call.Task))
 	}
 }
 
@@ -20,11 +20,11 @@ func PrintSpaceBetweenSummaries(l *logger.Logger, i int) {
 		return
 	}
 
-	l.Outf(logger.Default, "")
-	l.Outf(logger.Default, "")
+	l.Outf(logger.Default, "\n")
+	l.Outf(logger.Default, "\n")
 }
 
-func PrintTask(l *logger.Logger, t *taskfile.Task) {
+func PrintTask(l *logger.Logger, t *ast.Task) {
 	printTaskName(l, t)
 	printTaskDescribingText(t, l)
 	printTaskDependencies(l, t)
@@ -32,7 +32,7 @@ func PrintTask(l *logger.Logger, t *taskfile.Task) {
 	printTaskCommands(l, t)
 }
 
-func printTaskDescribingText(t *taskfile.Task, l *logger.Logger) {
+func printTaskDescribingText(t *ast.Task, l *logger.Logger) {
 	if hasSummary(t) {
 		printTaskSummary(l, t)
 	} else if hasDescription(t) {
@@ -42,77 +42,77 @@ func printTaskDescribingText(t *taskfile.Task, l *logger.Logger) {
 	}
 }
 
-func hasSummary(t *taskfile.Task) bool {
+func hasSummary(t *ast.Task) bool {
 	return t.Summary != ""
 }
 
-func printTaskSummary(l *logger.Logger, t *taskfile.Task) {
+func printTaskSummary(l *logger.Logger, t *ast.Task) {
 	lines := strings.Split(t.Summary, "\n")
 	for i, line := range lines {
 		notLastLine := i+1 < len(lines)
 		if notLastLine || line != "" {
-			l.Outf(logger.Default, line)
+			l.Outf(logger.Default, "%s\n", line)
 		}
 	}
 }
 
-func printTaskName(l *logger.Logger, t *taskfile.Task) {
-	l.FOutf(l.Stdout, logger.Default, "task: ")
-	l.FOutf(l.Stdout, logger.Green, "%s\n", t.Name())
-	l.Outf(logger.Default, "")
+func printTaskName(l *logger.Logger, t *ast.Task) {
+	l.Outf(logger.Default, "task: ")
+	l.Outf(logger.Green, "%s\n", t.Name())
+	l.Outf(logger.Default, "\n")
 }
 
-func printTaskAliases(l *logger.Logger, t *taskfile.Task) {
+func printTaskAliases(l *logger.Logger, t *ast.Task) {
 	if len(t.Aliases) == 0 {
 		return
 	}
-	l.Outf(logger.Default, "")
-	l.Outf(logger.Default, "aliases:")
+	l.Outf(logger.Default, "\n")
+	l.Outf(logger.Default, "aliases:\n")
 	for _, alias := range t.Aliases {
-		l.FOutf(l.Stdout, logger.Default, " - ")
-		l.Outf(logger.Cyan, alias)
+		l.Outf(logger.Default, " - ")
+		l.Outf(logger.Cyan, "%s\n", alias)
 	}
 }
 
-func hasDescription(t *taskfile.Task) bool {
+func hasDescription(t *ast.Task) bool {
 	return t.Desc != ""
 }
 
-func printTaskDescription(l *logger.Logger, t *taskfile.Task) {
-	l.Outf(logger.Default, t.Desc)
+func printTaskDescription(l *logger.Logger, t *ast.Task) {
+	l.Outf(logger.Default, "%s\n", t.Desc)
 }
 
 func printNoDescriptionOrSummary(l *logger.Logger) {
-	l.Outf(logger.Default, "(task does not have description or summary)")
+	l.Outf(logger.Default, "(task does not have description or summary)\n")
 }
 
-func printTaskDependencies(l *logger.Logger, t *taskfile.Task) {
+func printTaskDependencies(l *logger.Logger, t *ast.Task) {
 	if len(t.Deps) == 0 {
 		return
 	}
 
-	l.Outf(logger.Default, "")
-	l.Outf(logger.Default, "dependencies:")
+	l.Outf(logger.Default, "\n")
+	l.Outf(logger.Default, "dependencies:\n")
 
 	for _, d := range t.Deps {
-		l.Outf(logger.Default, " - %s", d.Task)
+		l.Outf(logger.Default, " - %s\n", d.Task)
 	}
 }
 
-func printTaskCommands(l *logger.Logger, t *taskfile.Task) {
+func printTaskCommands(l *logger.Logger, t *ast.Task) {
 	if len(t.Cmds) == 0 {
 		return
 	}
 
-	l.Outf(logger.Default, "")
-	l.Outf(logger.Default, "commands:")
+	l.Outf(logger.Default, "\n")
+	l.Outf(logger.Default, "commands:\n")
 	for _, c := range t.Cmds {
 		isCommand := c.Cmd != ""
-		l.FOutf(l.Stdout, logger.Default, " - ")
+		l.Outf(logger.Default, " - ")
 		if isCommand {
-			l.FOutf(l.Stdout, logger.Yellow, "%s\n", c.Cmd)
+			l.Outf(logger.Yellow, "%s\n", c.Cmd)
 		} else {
-			l.FOutf(l.Stdout, logger.Green, "Task: %s\n", c.Task)
+			l.Outf(logger.Green, "Task: %s\n", c.Task)
 		}
 	}
 }

internal/summary/summary_test.go

@@ -9,13 +9,13 @@ import (
 
 	"github.com/go-task/task/v3/internal/logger"
 	"github.com/go-task/task/v3/internal/summary"
-	"github.com/go-task/task/v3/taskfile"
+	"github.com/go-task/task/v3/taskfile/ast"
 )
 
 func TestPrintsDependenciesIfPresent(t *testing.T) {
 	buffer, l := createDummyLogger()
-	task := &taskfile.Task{
-		Deps: []*taskfile.Dep{
+	task := &ast.Task{
+		Deps: []*ast.Dep{
 			{Task: "dep1"},
 			{Task: "dep2"},
 			{Task: "dep3"},
@@ -39,8 +39,8 @@ func createDummyLogger() (*bytes.Buffer, logger.Logger) {
 
 func TestDoesNotPrintDependenciesIfMissing(t *testing.T) {
 	buffer, l := createDummyLogger()
-	task := &taskfile.Task{
-		Deps: []*taskfile.Dep{},
+	task := &ast.Task{
+		Deps: []*ast.Dep{},
 	}
 
 	summary.PrintTask(&l, task)
@@ -50,7 +50,7 @@ func TestDoesNotPrintDependenciesIfMissing(t *testing.T) {
 
 func TestPrintTaskName(t *testing.T) {
 	buffer, l := createDummyLogger()
-	task := &taskfile.Task{
+	task := &ast.Task{
 		Task: "my-task-name",
 	}
 
@@ -61,8 +61,8 @@ func TestPrintTaskName(t *testing.T) {
 
 func TestPrintTaskCommandsIfPresent(t *testing.T) {
 	buffer, l := createDummyLogger()
-	task := &taskfile.Task{
-		Cmds: []*taskfile.Cmd{
+	task := &ast.Task{
+		Cmds: []*ast.Cmd{
 			{Cmd: "command-1"},
 			{Cmd: "command-2"},
 			{Task: "task-1"},
@@ -79,8 +79,8 @@ func TestPrintTaskCommandsIfPresent(t *testing.T) {
 
 func TestDoesNotPrintCommandIfMissing(t *testing.T) {
 	buffer, l := createDummyLogger()
-	task := &taskfile.Task{
-		Cmds: []*taskfile.Cmd{},
+	task := &ast.Task{
+		Cmds: []*ast.Cmd{},
 	}
 
 	summary.PrintTask(&l, task)
@@ -90,13 +90,13 @@ func TestDoesNotPrintCommandIfMissing(t *testing.T) {
 
 func TestLayout(t *testing.T) {
 	buffer, l := createDummyLogger()
-	task := &taskfile.Task{
+	task := &ast.Task{
 		Task:    "sample-task",
 		Summary: "line1\nline2\nline3\n",
-		Deps: []*taskfile.Dep{
+		Deps: []*ast.Dep{
 			{Task: "dependency"},
 		},
-		Cmds: []*taskfile.Cmd{
+		Cmds: []*ast.Cmd{
 			{Cmd: "command"},
 		},
 	}
@@ -124,15 +124,15 @@ commands:
 
 func TestPrintDescriptionAsFallback(t *testing.T) {
 	buffer, l := createDummyLogger()
-	taskWithoutSummary := &taskfile.Task{
+	taskWithoutSummary := &ast.Task{
 		Desc: "description",
 	}
 
-	taskWithSummary := &taskfile.Task{
+	taskWithSummary := &ast.Task{
 		Desc:    "description",
 		Summary: "summary",
 	}
-	taskWithoutSummaryOrDescription := &taskfile.Task{}
+	taskWithoutSummaryOrDescription := &ast.Task{}
 
 	summary.PrintTask(&l, taskWithoutSummary)
 
@@ -147,27 +147,25 @@ func TestPrintDescriptionAsFallback(t *testing.T) {
 	summary.PrintTask(&l, taskWithoutSummaryOrDescription)
 
 	assert.Contains(t, buffer.String(), "\n(task does not have description or summary)\n")
-
 }
 
 func TestPrintAllWithSpaces(t *testing.T) {
 	buffer, l := createDummyLogger()
 
-	t1 := &taskfile.Task{Task: "t1"}
-	t2 := &taskfile.Task{Task: "t2"}
-	t3 := &taskfile.Task{Task: "t3"}
+	t1 := &ast.Task{Task: "t1"}
+	t2 := &ast.Task{Task: "t2"}
+	t3 := &ast.Task{Task: "t3"}
 
-	tasks := make(taskfile.Tasks, 3)
-	tasks["t1"] = t1
-	tasks["t2"] = t2
-	tasks["t3"] = t3
+	tasks := ast.Tasks{}
+	tasks.Set("t1", t1)
+	tasks.Set("t2", t2)
+	tasks.Set("t3", t3)
 
 	summary.PrintTasks(&l,
-		&taskfile.Taskfile{Tasks: tasks},
-		[]taskfile.Call{{Task: "t1"}, {Task: "t2"}, {Task: "t3"}})
+		&ast.Taskfile{Tasks: tasks},
+		[]*ast.Call{{Task: "t1"}, {Task: "t2"}, {Task: "t3"}})
 
 	assert.True(t, strings.HasPrefix(buffer.String(), "task: t1"))
 	assert.Contains(t, buffer.String(), "\n(task does not have description or summary)\n\n\ntask: t2")
 	assert.Contains(t, buffer.String(), "\n(task does not have description or summary)\n\n\ntask: t3")
-
 }

internal/templater/funcs.go

@@ -4,15 +4,16 @@ import (
 	"path/filepath"
 	"runtime"
 	"strings"
-	"text/template"
 
-	sprig "github.com/go-task/slim-sprig"
+	"github.com/davecgh/go-spew/spew"
+	"mvdan.cc/sh/v3/shell"
 	"mvdan.cc/sh/v3/syntax"
+
+	sprig "github.com/go-task/slim-sprig/v3"
+	"github.com/go-task/template"
 )
 
-var (
-	templateFuncs template.FuncMap
-)
+var templateFuncs template.FuncMap
 
 func init() {
 	taskFuncs := template.FuncMap{
@@ -41,15 +42,47 @@ func init() {
 		"shellQuote": func(str string) (string, error) {
 			return syntax.Quote(str, syntax.LangBash)
 		},
+		"splitArgs": func(s string) ([]string, error) {
+			return shell.Fields(s, nil)
+		},
 		// IsSH is deprecated.
 		"IsSH": func() bool { return true },
+		"joinPath": func(elem ...string) string {
+			return filepath.Join(elem...)
+		},
+		"relPath": func(basePath, targetPath string) (string, error) {
+			return filepath.Rel(basePath, targetPath)
+		},
+		"merge": func(base map[string]any, v ...map[string]any) map[string]any {
+			cap := len(v)
+			for _, m := range v {
+				cap += len(m)
+			}
+			result := make(map[string]any, cap)
+			for k, v := range base {
+				result[k] = v
+			}
+			for _, m := range v {
+				for k, v := range m {
+					result[k] = v
+				}
+			}
+			return result
+		},
+		"spew": func(v any) string {
+			return spew.Sdump(v)
+		},
 	}
+
+	// aliases
+	taskFuncs["q"] = taskFuncs["shellQuote"]
+
 	// Deprecated aliases for renamed functions.
 	taskFuncs["FromSlash"] = taskFuncs["fromSlash"]
 	taskFuncs["ToSlash"] = taskFuncs["toSlash"]
 	taskFuncs["ExeExt"] = taskFuncs["exeExt"]
 
-	templateFuncs = sprig.TxtFuncMap()
+	templateFuncs = template.FuncMap(sprig.TxtFuncMap())
 	for k, v := range taskFuncs {
 		templateFuncs[k] = v
 	}