v3.37.0

* feat(remote): replace env variable in include remote URL

* use templating system instead of os.ExpandEnv

* lint

.editorconfig

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

.github/CODE_OF_CONDUCT.md

@@ -34,7 +34,7 @@ This Code of Conduct applies both within project spaces and in public spaces whe
 
 ## Enforcement
 
-Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at andrey.nering@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/FUNDING.yml

@@ -1,2 +1,3 @@
+github: [andreynering, pd93]
 open_collective: task
-custom: 'https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=GSVDU63RKG45A&currency_code=USD&source=url'
+custom: https://taskfile.dev/donate/

.github/ISSUE_TEMPLATE/bug_report.md

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

.github/ISSUE_TEMPLATE/config.yml

@@ -1,5 +1,11 @@
 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.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
-    about: Ask questions and discuss general ideas with the community
+    about: Ask questions and discuss general ideas with the community.

.github/ISSUE_TEMPLATE/feature_request.md

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

.github/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/pull_request_template.md

@@ -0,0 +1,5 @@
+> Thanks for your pull request, we really appreciate contributions!
+>
+> Please understand that it may take some time to be reviewed.
+>
+> Also, make sure to follow the [Contribution Guide](https://taskfile.dev/contributing/).

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

@@ -0,0 +1,43 @@
+name: issue awaiting response
+
+on:
+  issue_comment:
+    types: [created]
+
+jobs:
+  issue-awaiting-response:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/github-script@v6
+        with:
+          github-token: ${{secrets.GH_PAT}}
+          script: |
+            const issue = await github.rest.issues.get({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              issue_number: context.issue.number,
+            })
+            const comments = await github.paginate(
+              github.rest.issues.listComments, {
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: context.issue.number,
+              }
+            )
+            const labels = await github.paginate(
+              github.rest.issues.listLabelsOnIssue, {
+                issue_number: context.issue.number,
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+              }
+            )
+            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: 'state: awaiting response'
+                })
+              }
+            }

.github/workflows/issue-closed.yml

@@ -0,0 +1,29 @@
+name: issue closed
+
+on:
+  issues:
+    types: [closed]
+
+jobs:
+  issue-closed:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/github-script@v6
+        with:
+          github-token: ${{secrets.GH_PAT}}
+          script: |
+            const labels = await github.paginate(
+              github.rest.issues.listLabelsOnIssue, {
+                issue_number: context.issue.number,
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+              }
+            )
+            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: '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

@@ -0,0 +1,29 @@
+name: issue needs triage
+
+on:
+  issues:
+    types: [opened]
+
+jobs:
+  issue-needs-triage:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/github-script@v6
+        with:
+          github-token: ${{secrets.GH_PAT}}
+          script: |
+            const labels = await github.paginate(
+              github.rest.issues.listLabelsOnIssue, {
+                issue_number: context.issue.number,
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+              }
+            )
+            if (labels.length === 0) {
+              github.rest.issues.addLabels({
+                issue_number: context.issue.number,
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                labels: ['state: needs triage']
+              })
+            }

.github/workflows/lint.yml

@@ -0,0 +1,43 @@
+name: Lint
+
+on:
+  pull_request:
+  push:
+    tags:
+      - v*
+    branches:
+      - 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: ${{matrix.go-version}}
+
+      - uses: actions/checkout@v3
+
+      - name: golangci-lint
+        uses: golangci/golangci-lint-action@v3
+        with:
+          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,24 +3,24 @@ name: goreleaser
 on:
   push:
     tags:
-      - '*'
+      - 'v*'
 
 jobs:
   goreleaser:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v1
+        uses: actions/checkout@v3
 
       - name: Set up Go
-        uses: actions/setup-go@v1
+        uses: actions/setup-go@v3
         with:
-          go-version: 1.17.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

@@ -1,22 +1,30 @@
 name: Test
-on: [push, pull_request]
+
+on:
+  pull_request:
+  push:
+    tags:
+      - v*
+    branches:
+      - main
+
 jobs:
   test:
     name: Test
     strategy:
       matrix:
-        go-version: [1.16.x, 1.17.x]
+        go-version: [1.21.x, 1.22.x]
         platform: [ubuntu-latest, macos-latest, windows-latest]
     runs-on: ${{matrix.platform}}
     steps:
       - name: Set up Go ${{matrix.go-version}}
-        uses: actions/setup-go@v1
+        uses: actions/setup-go@v3
         with:
           go-version: ${{matrix.go-version}}
         id: go
 
       - name: Check out code into the Go module directory
-        uses: actions/checkout@v1
+        uses: actions/checkout@v3
 
       - name: Download Go modules
         run: go mod download
@@ -27,4 +35,4 @@ jobs:
         run: go build -o ./bin/task -v ./cmd/task
 
       - name: Test
-        run: ./bin/task test
+        run: ./bin/task test --output=group --output-group-begin='::group::{{.TASK}}' --output-group-end='::endgroup::'

.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

.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,11 +24,15 @@ dist/
 
 # editors
 .idea/
-.vscode/
+.vscode/*
+!.vscode/*-sample.json
+.fleet/
 
 # exuberant ctags
 tags
 
-/bin
+/bin/*
+!/bin/.keep
 /testdata/vars/v1
 /tmp
+node_modules

.golangci.yml

@@ -0,0 +1,18 @@
+# NOTE(@andreynering): The linters listed here are additions on top of
+# those enabled by default:
+#
+# https://golangci-lint.run/usage/linters/#enabled-by-default
+
+linters:
+  enable:
+    - goimports
+    - gofmt
+    - gofumpt
+
+linters-settings:
+  goimports:
+    local-prefixes: github.com/go-task
+  gofmt:
+    rewrite-rules:
+      - pattern: 'interface{}'
+        replacement: 'any'

.goreleaser.yml

@@ -1,24 +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
-  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
@@ -44,8 +48,8 @@ checksum:
 
 nfpms:
   - vendor: Task
-    homepage: https://github.com/go-task/task
-    maintainer: Andrey Nering <andrey.nering@gmail.com>
+    homepage: https://taskfile.dev
+    maintainer: Andrey Nering <andrey@nering.com.br>
     description: Simple task runner written in Go
     license: MIT
     conflicts:
@@ -54,6 +58,13 @@ nfpms:
       - deb
       - rpm
     file_name_template: "{{.ProjectName}}_{{.Os}}_{{.Arch}}"
+    contents:
+      - src: completion/bash/task.bash
+        dst: /etc/bash_completion.d/task
+      - src: completion/fish/task.fish
+        dst: /usr/share/fish/completions/task.fish
+      - src: completion/zsh/_task
+        dst: /usr/local/share/zsh/site-functions/_task
 
 brews:
   - name: go-task
@@ -61,7 +72,7 @@ brews:
     license: MIT
     homepage: https://taskfile.dev
     folder: Formula
-    tap:
+    repository:
       owner: go-task
       name: homebrew-tap
     test:
@@ -71,3 +82,44 @@ brews:
       bash_completion.install "completion/bash/task.bash" => "task"
       zsh_completion.install "completion/zsh/_task" => "_task"
       fish_completion.install "completion/fish/task.fish"
+    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

.nvmrc

@@ -0,0 +1 @@
+18.12.1

.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/Logo.png" width="200px" height="200px" />
+    <img src="website/static/img/logo.svg" width="200px" height="200px" />
   </a>
 
   <h1>Task</h1>
@@ -10,6 +10,6 @@
   </p>
 
   <p>
-    See <a href="https://taskfile.dev">taskfile.dev</a> for the documentation.
+    <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>

Taskfile.yml

@@ -1,16 +1,13 @@
 version: '3'
 
 includes:
-  docs:
-    taskfile: ./docs
-    dir: ./docs
+  website:
+    aliases: [w, docs, d]
+    taskfile: ./website
+    dir: ./website
 
 vars:
-  GIT_COMMIT:
-    sh: git log -n 1 --format=%h
-
-  GO_PACKAGES:
-    sh: go list ./...
+  BIN: "{{.ROOT_DIR}}/bin"
 
 env:
   CGO_ENABLED: '0'
@@ -18,12 +15,39 @@ env:
 tasks:
   default:
     cmds:
+      - task: lint
       - task: test
 
   install:
     desc: Installs Task
+    aliases: [i]
+    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:
+      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
@@ -31,53 +55,88 @@ tasks:
       - go mod download
       - go mod tidy
 
-  cli-deps:
-    desc: Downloads CLI dependencies
-    cmds:
-      - task: go-get
-        vars: {REPO: golang.org/x/lint/golint}
-      - task: go-get
-        vars: {REPO: github.com/goreleaser/goreleaser}
-      - task: go-get
-        vars: {REPO: github.com/goreleaser/godownloader}
-
   clean:
     desc: Cleans temp files and folders
     cmds:
       - rm -rf dist/
+      - rm -rf tmp/
 
   lint:
-    desc: Runs golint
+    desc: Runs golangci-lint
+    aliases: [l]
+    sources:
+      - './**/*.go'
+      - .golangci.yml
     cmds:
-      - golint {{catLines .GO_PACKAGES}}
+      - 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"
+    cmds:
+      - go build -o {{.BIN}}/sleepit{{exeExt}} ./cmd/sleepit
+
+  sleepit:run:
+    desc: Builds the sleepit test helper
+    deps: [sleepit:build]
+    cmds:
+      - "{{.BIN}}/sleepit {{.CLI_ARGS}}"
     silent: true
 
   test:
     desc: Runs test suite
+    aliases: [t]
     deps: [install]
     cmds:
       - go test {{catLines .GO_PACKAGES}}
+    vars:
+      GO_PACKAGES:
+        sh: go list ./...
 
-  test-release:
+  test:all:
+    desc: Runs test suite with signals and watch tests included
+    deps: [install, sleepit:build]
+    cmds:
+      - go test {{catLines .GO_PACKAGES}} -tags 'signals watch'
+    vars:
+      GO_PACKAGES:
+        sh: go list ./...
+
+  goreleaser:test:
     desc: Tests release process without publishing
     cmds:
-      - goreleaser --snapshot --rm-dist
+      - goreleaser --snapshot --clean
 
-  gen-install-script:
-    desc: Generate install script using https://github.com/goreleaser/godownloader
+  goreleaser:install:
+    desc: Installs goreleaser
     cmds:
-      - godownloader --repo go-task/task -o install-task.sh
-      - cp ./install-task.sh ./docs/install.sh
+      - go install github.com/goreleaser/goreleaser@latest
 
-  ci:
-    - task: go-get
-      vars: {REPO: golang.org/x/lint/golint}
-    - task: lint
-    - task: test
+  release:
+    desc: Prepare the project for a new release
+    cmds:
+      - go run ./cmd/release {{.CLI_ARGS}}
 
-  go-get: go get -u {{.REPO}}
+  npm:publish:
+    desc: Publish release to npm
+    cmds:
+      - npm publish --access=public
 
   packages:
     cmds:
       - echo '{{.GO_PACKAGES}}'
+    vars:
+      GO_PACKAGES:
+        sh: go list ./...
     silent: true

args/args.go

@@ -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

@@ -0,0 +1,171 @@
+// This code is released under the MIT License
+// Copyright (c) 2020 Marco Molteni and the timeit contributors.
+
+package main
+
+import (
+	"flag"
+	"fmt"
+	"os"
+	"os/signal"
+	"time"
+)
+
+const usage = `sleepit: sleep for the specified duration, optionally handling signals
+When the line "sleepit: ready" is printed, it means that it is safe to send signals to it
+Usage: sleepit <command> [<args>]
+Commands
+  default     Use default action: on reception of SIGINT terminate abruptly
+  handle      Handle signals: on reception of SIGINT perform cleanup before exiting
+  version     Show the sleepit version`
+
+// Filled by the linker.
+var fullVersion = "unknown" // example: v0.0.9-8-g941583d027-dirty
+
+func main() {
+	os.Exit(run(os.Args[1:]))
+}
+
+func run(args []string) int {
+	if len(args) < 1 {
+		fmt.Fprintln(os.Stderr, usage)
+		return 2
+	}
+
+	defaultCmd := flag.NewFlagSet("default", flag.ExitOnError)
+	defaultSleep := defaultCmd.Duration("sleep", 5*time.Second, "Sleep duration")
+
+	handleCmd := flag.NewFlagSet("handle", flag.ExitOnError)
+	handleSleep := handleCmd.Duration("sleep", 5*time.Second, "Sleep duration")
+	handleCleanup := handleCmd.Duration("cleanup", 5*time.Second, "Cleanup duration")
+	handleTermAfter := handleCmd.Int("term-after", 0,
+		"Terminate immediately after `N` signals.\n"+
+			"Default is to terminate only when the cleanup phase has completed.")
+
+	versionCmd := flag.NewFlagSet("version", flag.ExitOnError)
+
+	switch args[0] {
+
+	case "default":
+		_ = defaultCmd.Parse(args[1:])
+		if len(defaultCmd.Args()) > 0 {
+			fmt.Fprintf(os.Stderr, "default: unexpected arguments: %v\n", defaultCmd.Args())
+			return 2
+		}
+		return supervisor(*defaultSleep, 0, 0, nil)
+
+	case "handle":
+		_ = handleCmd.Parse(args[1:])
+		if *handleTermAfter == 1 {
+			fmt.Fprintf(os.Stderr, "handle: term-after cannot be 1\n")
+			return 2
+		}
+		if len(handleCmd.Args()) > 0 {
+			fmt.Fprintf(os.Stderr, "handle: unexpected arguments: %v\n", handleCmd.Args())
+			return 2
+		}
+		sigCh := make(chan os.Signal, 1)
+		signal.Notify(sigCh, os.Interrupt) // Ctrl-C -> SIGINT
+		return supervisor(*handleSleep, *handleCleanup, *handleTermAfter, sigCh)
+
+	case "version":
+		_ = versionCmd.Parse(args[1:])
+		if len(versionCmd.Args()) > 0 {
+			fmt.Fprintf(os.Stderr, "version: unexpected arguments: %v\n", versionCmd.Args())
+			return 2
+		}
+		fmt.Printf("sleepit version %s\n", fullVersion)
+		return 0
+
+	default:
+		fmt.Fprintln(os.Stderr, usage)
+		return 2
+	}
+}
+
+func supervisor(
+	sleep time.Duration,
+	cleanup time.Duration,
+	termAfter int,
+	sigCh <-chan os.Signal,
+) int {
+	fmt.Printf("sleepit: ready\n")
+	fmt.Printf("sleepit: PID=%d sleep=%v cleanup=%v\n",
+		os.Getpid(), sleep, cleanup)
+
+	cancelWork := make(chan struct{})
+	workerDone := worker(cancelWork, sleep, "work")
+
+	cancelCleaner := make(chan struct{})
+	var cleanerDone <-chan struct{}
+
+	sigCount := 0
+	for {
+		select {
+		case sig := <-sigCh:
+			sigCount++
+			fmt.Printf("sleepit: got signal=%s count=%d\n", sig, sigCount)
+			if sigCount == 1 {
+				// since `cancelWork` is unbuffered, sending will be synchronous:
+				// we are ensured that the worker has terminated before starting cleanup.
+				// This is important in some real-life situations.
+				cancelWork <- struct{}{}
+				cleanerDone = worker(cancelCleaner, cleanup, "cleanup")
+			}
+			if sigCount == termAfter {
+				cancelCleaner <- struct{}{}
+				return 4
+			}
+		case <-workerDone:
+			return 0
+		case <-cleanerDone:
+			return 3
+		}
+	}
+}
+
+// Start a worker goroutine and return immediately a `workerDone` channel.
+// The goroutine will prepend its prints with the prefix `name`.
+// The goroutine will simulate some work and will terminate when one of the following
+// conditions happens:
+//  1. When `howlong` is elapsed. This case will be signaled on the `workerDone` channel.
+//  2. When something happens on channel `canceled`. Note that this simulates real-life,
+//     so cancellation is not instantaneous: if the caller wants a synchronous cancel,
+//     it should send a message; if instead it wants an asynchronous cancel, it should
+//     close the channel.
+func worker(
+	canceled <-chan struct{},
+	howlong time.Duration,
+	name string,
+) <-chan struct{} {
+	workerDone := make(chan struct{})
+	deadline := time.Now().Add(howlong)
+	go func() {
+		fmt.Printf("sleepit: %s started\n", name)
+		for {
+			select {
+			case <-canceled:
+				fmt.Printf("sleepit: %s canceled\n", name)
+				return
+			default:
+				if doSomeWork(deadline) {
+					fmt.Printf("sleepit: %s done\n", name) // <== NOTE THIS LINE
+					workerDone <- struct{}{}
+					return
+				}
+			}
+		}
+	}()
+	return workerDone
+}
+
+// Do some work and then return, so that the caller can decide wether to continue or not.
+// Return true when all work is done.
+func doSomeWork(deadline time.Time) bool {
+	if time.Now().After(deadline) {
+		return true
+	}
+	timeout := 100 * time.Millisecond
+	time.Sleep(timeout)
+	return false
+}

cmd/task/task.go

@@ -3,197 +3,195 @@ package main
 import (
 	"context"
 	"fmt"
-	"log"
 	"os"
-	"os/signal"
-	"path/filepath"
-	"runtime/debug"
 	"strings"
-	"syscall"
 
 	"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
-		status      bool
-		force       bool
-		watch       bool
-		verbose     bool
-		silent      bool
-		dry         bool
-		summary     bool
-		parallel    bool
-		concurrency int
-		dir         string
-		entrypoint  string
-		output      string
-		color       bool
-	)
-
-	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.yml in the current folder")
-	pflag.BoolVarP(&list, "list", "l", false, "lists tasks with description of current Taskfile")
-	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.BoolVar(&dry, "dry", 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.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, "output", "o", "", "sets output style: [interleaved|group|prefixed]")
-	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.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 flags.Global {
+		home, err := os.UserHomeDir()
+		if err != nil {
+			return fmt.Errorf("task: Failed to get user home directory: %w", err)
+		}
+		dir = home
 	}
-	if entrypoint != "" {
-		dir = filepath.Dir(entrypoint)
-		entrypoint = filepath.Base(entrypoint)
-	} else {
-		entrypoint = "Taskfile.yml"
+
+	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,
+		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,
-	}
-	if err := e.Setup(); err != nil {
-		log.Fatal(err)
-	}
-	v, err := e.Taskfile.ParsedVersion()
-	if err != nil {
-		log.Fatal(err)
-		return
+		OutputStyle: flags.Output,
+		TaskSorter:  taskSorter,
 	}
 
-	if list {
-		e.PrintTasksHelp()
-		return
+	listOptions := task.NewListOptions(flags.List, flags.ListAll, flags.ListJson, flags.NoStatus)
+	if err := listOptions.Validate(); err != nil {
+		return err
+	}
+
+	if err := e.Setup(); err != nil {
+		return err
+	}
+
+	if experiments.AnyVariables.Enabled {
+		logger.Warnf("The 'Any Variables' experiment flag is no longer required to use non-map variable types. If you wish to use map variables, please use 'TASK_X_MAP_VARIABLES' instead. See https://github.com/go-task/task/issues/1585\n")
+	}
+
+	// If the download flag is specified, we should stop execution as soon as
+	// taskfile is downloaded
+	if flags.Download {
+		return nil
+	}
+
+	if (listOptions.ShouldListTasks()) && flags.Silent {
+		return e.ListTaskNames(flags.ListAll)
+	}
+
+	if listOptions.ShouldListTasks() {
+		foundTasks, err := e.ListTasks(listOptions)
+		if err != nil {
+			return err
+		}
+		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 !flags.Watch {
+		e.InterceptInterruptSignals()
+	}
 
 	ctx := context.Background()
-	if !watch {
-		ctx = getSignalContext()
+
+	if flags.Status {
+		return e.Status(ctx, calls...)
 	}
 
-	if status {
-		if err := e.Status(ctx, calls...); err != nil {
-			log.Fatal(err)
-		}
-		return
-	}
-
-	if err := e.Run(ctx, calls...); err != nil {
-		e.Logger.Errf(logger.Red, "%v", err)
-		os.Exit(1)
-	}
+	return e.Run(ctx, calls...)
 }
 
 func getArgs() ([]string, string, error) {
@@ -216,33 +214,3 @@ func getArgs() ([]string, string, error) {
 	}
 	return args[:doubleDashPos], strings.Join(quotedCliArgs, " "), nil
 }
-
-func getSignalContext() context.Context {
-	ch := make(chan os.Signal, 1)
-	signal.Notify(ch, os.Interrupt, syscall.SIGTERM)
-	ctx, cancel := context.WithCancel(context.Background())
-	go func() {
-		sig := <-ch
-		log.Printf("task: signal received: %s", sig)
-		cancel()
-	}()
-	return ctx
-}
-
-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/bash/task.bash

@@ -1,21 +1,55 @@
-_task_completion()
+# vim: set tabstop=2 shiftwidth=2 expandtab:
+
+_GO_TASK_COMPLETION_LIST_OPTION='--list-all'
+
+function _task()
 {
-  local scripts;
-  local curr_arg;
+  local cur prev words cword
+  _init_completion -n : || return
 
-  # Remove colon from word breaks
-  COMP_WORDBREAKS=${COMP_WORDBREAKS//:}
+  # Check for `--` within command-line and quit or strip suffix.
+  local i
+  for i in "${!words[@]}"; do
+    if [ "${words[$i]}" == "--" ]; then
+      # Do not complete words following `--` passed to CLI_ARGS.
+      [ $cword -gt $i ] && return
+      # Remove the words following `--` to not put --list in CLI_ARGS.
+      words=( "${words[@]:0:$i}" )
+      break
+    fi
+  done
 
-  scripts=$(task -l | sed '1d' | awk '{ print $2 }' | sed 's/:$//');
+  # Handle special arguments of options.
+  case "$prev" in
+    -d|--dir)
+      _filedir -d
+      return $?
+    ;;
+    -t|--taskfile)
+      _filedir yaml || return $?
+      _filedir yml
+      return $?
+    ;;
+    -o|--output)
+      COMPREPLY=( $( compgen -W "interleaved group prefixed" -- $cur ) )
+      return 0
+    ;;
+  esac
 
-  curr_arg="${COMP_WORDS[COMP_CWORD]:-"."}"
+  # Handle normal options.
+  case "$cur" in
+    -*)
+      COMPREPLY=( $( compgen -W "$(_parse_help $1)" -- $cur ) )
+      return 0
+    ;;
+  esac
 
-  # Do not accept more than 1 argument
-  if [ "${#COMP_WORDS[@]}" != "2" ]; then
-    return
-  fi
+  # Prepare task name completions.
+  local tasks=( $( "${words[@]}" --silent $_GO_TASK_COMPLETION_LIST_OPTION 2> /dev/null ) )
+  COMPREPLY=( $( compgen -W "${tasks[*]}" -- "$cur" ) )
 
-  COMPREPLY=($(compgen -c | echo "$scripts" | grep -- $curr_arg));
+  # Post-process because task names might contain colons.
+  __ltrim_colon_completions "$cur"
 }
 
-complete -F _task_completion task
+complete -F _task task

completion/fish/task.fish

@@ -1,24 +1,37 @@
+set GO_TASK_PROGNAME task
+
 function __task_get_tasks --description "Prints all available tasks with their description"
-	task -l | sed '1d' | awk '{ $1=""; print $0 }' | sed 's/:\ /\t/g' | string trim
+  # Read the list of tasks (and potential errors)
+  $GO_TASK_PROGNAME --list-all 2>&1 | read -lz rawOutput
+
+  # Return on non-zero exit code (for cases when there is no Taskfile found or etc.)
+  if test $status -ne 0
+    return
+  end
+
+  # Grab names and descriptions (if any) of the tasks
+  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
 end
 
-complete -c task -d '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 
+complete -c $GO_TASK_PROGNAME -d '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.' -xa "(__task_get_tasks)"
 
-
-complete -c task -s c -l color     -d 'colored output (default true)'
-complete -c task -s d -l dir       -d 'sets directory of execution'
-complete -c task      -l dry       -d 'compiles and prints tasks in the order that they would be run, without executing them'
-complete -c task -s f -l force     -d 'forces execution even when the task is up-to-date'
-complete -c task -s h -l help      -d 'shows Task usage'
-complete -c task -s i -l init      -d 'creates a new Taskfile.yml in the current folder'
-complete -c task -s l -l list      -d 'lists tasks with description of current Taskfile'
-complete -c task -s o -l output    -d 'sets output style: [interleaved|group|prefixed]' -xa "interleaved group prefixed"
-complete -c task -s p -l parallel  -d 'executes tasks provided on command line in parallel'
-complete -c task -s s -l silent    -d 'disables echoing'
-complete -c task      -l status    -d 'exits with non-zero exit code if any of the given tasks is not up-to-date'
-complete -c task      -l summary   -d 'show summary about a task'
-complete -c task -s t -l taskfile  -d 'choose which Taskfile to run. Defaults to "Taskfile.yml"'
-complete -c task -s v -l verbose   -d 'enables verbose mode'
-complete -c task      -l version   -d 'show Task version'
-complete -c task -s w -l watch     -d 'enables watch of the given task'
+complete -c $GO_TASK_PROGNAME -s c -l color     -d 'colored output (default true)'
+complete -c $GO_TASK_PROGNAME -s d -l dir       -d 'sets directory of execution'
+complete -c $GO_TASK_PROGNAME      -l dry       -d 'compiles and prints tasks in the order that they would be run, without executing them'
+complete -c $GO_TASK_PROGNAME -s f -l force     -d 'forces execution even when the task is up-to-date'
+complete -c $GO_TASK_PROGNAME -s h -l help      -d 'shows Task usage'
+complete -c $GO_TASK_PROGNAME -s i -l init      -d 'creates a new Taskfile.yml in the current folder'
+complete -c $GO_TASK_PROGNAME -s l -l list      -d 'lists tasks with description of current Taskfile'
+complete -c $GO_TASK_PROGNAME -s o -l output    -d 'sets output style: [interleaved|group|prefixed]' -xa "interleaved group prefixed"
+complete -c $GO_TASK_PROGNAME -s p -l parallel  -d 'executes tasks provided on command line in parallel'
+complete -c $GO_TASK_PROGNAME -s s -l silent    -d 'disables echoing'
+complete -c $GO_TASK_PROGNAME      -l status    -d 'exits with non-zero exit code if any of the given tasks is not up-to-date'
+complete -c $GO_TASK_PROGNAME      -l summary   -d 'show summary about a task'
+complete -c $GO_TASK_PROGNAME -s t -l taskfile  -d 'choose which Taskfile to run. Defaults to "Taskfile.yml"'
+complete -c $GO_TASK_PROGNAME -s v -l verbose   -d 'enables verbose mode'
+complete -c $GO_TASK_PROGNAME      -l version   -d 'show Task version'
+complete -c $GO_TASK_PROGNAME -s w -l watch     -d 'enables watch of the given task'

completion/ps/task.ps1

@@ -1,10 +1,28 @@
-$scriptBlock = {
-	param($commandName, $wordToComplete, $cursorPosition)
-	$curReg = "task{.exe}? (.*?)$"
-	$startsWith = $wordToComplete | Select-String $curReg -AllMatches | ForEach-Object { $_.Matches.Groups[1].Value }
-	$reg = "\* ($startsWith.+?):"
-	$listOutput = $(task -l)
-	$listOutput | Select-String $reg -AllMatches | ForEach-Object { $_.Matches.Groups[1].Value + " " }
-}
+using namespace System.Management.Automation
 
-Register-ArgumentCompleter -Native -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

@@ -1,25 +1,64 @@
 #compdef task
 
-# Listing commands from Taskfile.yml
-function __list() {
-    local -a scripts
+local context state state_descr line
+typeset -A opt_args
 
-    if [ -f Taskfile.yml ]; then
-        scripts=($(task -l | sed '1d' | sed 's/^\* //' | awk '{ print $1 }' | sed 's/:$//' | sed 's/:/\\:/g'))
-        _describe 'script' scripts
+_GO_TASK_COMPLETION_LIST_OPTION="${GO_TASK_COMPLETION_LIST_OPTION:---list-all}"
+
+# Listing commands from Taskfile.yml
+function __task_list() {
+    local -a scripts cmd
+    local -i enabled=0
+    local taskfile item task desc
+
+    cmd=(task)
+    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 {T,t}askfile{,.dist}.{yaml,yml}; do
+            if [[ -f "$taskfile" ]]; then
+                enabled=1
+                break
+            fi
+        done
     fi
+
+    (( enabled )) || return 0
+
+    scripts=()
+    for item in "${(@)${(f)$("${cmd[@]}" $_GO_TASK_COMPLETION_LIST_OPTION)}[2,-1]#\* }"; do
+        task="${item%%:[[:space:]]*}"
+        desc="${item##[^[:space:]]##[[:space:]]##}"
+        scripts+=( "${task//:/\\:}:$desc" )
+    done
+    _describe 'Task to run' scripts
 }
 
 _arguments \
-    '(-d --dir)'{-d,--dir}': :_files' \
-    '(--dry)'--dry \
-    '(-f --force)'{-f,--force} \
-    '(-i --init)'{-i,--init} \
-    '(-l --list)'{-l,--list} \
-    '(-s --silent)'{-s,--silent} \
-    '(--status)'--status \
-    '(-v --verbose)'{-v,--verbose} \
-    '(--version)'--version \
-    '(-w --watch)'{-w,--watch} \
-    '(- *)'{-h,--help} \
-    '*: :__list' \
+    '(-C --concurrency)'{-C,--concurrency}'[limit number of concurrent tasks]: ' \
+    '(-p --parallel)'{-p,--parallel}'[run command-line tasks in parallel]' \
+    '(-f --force)'{-f,--force}'[run even if task is up-to-date]' \
+    '(-c --color)'{-c,--color}'[colored output]' \
+    '(-d --dir)'{-d,--dir}'[dir to run in]:execution dir:_dirs' \
+    '(--dry)--dry[dry-run mode, compile and print tasks only]' \
+    '(-o --output)'{-o,--output}'[set output style]:style:(interleaved group prefixed)' \
+    '(--output-group-begin)--output-group-begin[message template before grouped output]:template text: ' \
+    '(--output-group-end)--output-group-end[message template after grouped output]:template text: ' \
+    '(-s --silent)'{-s,--silent}'[disable echoing]' \
+    '(--status)--status[exit non-zero if supplied tasks not up-to-date]' \
+    '(--summary)--summary[show summary\: field from tasks instead of running them]' \
+    '(-t --taskfile)'{-t,--taskfile}'[specify a different taskfile]:taskfile:_files' \
+    '(-v --verbose)'{-v,--verbose}'[verbose mode]' \
+    '(-w --watch)'{-w,--watch}'[watch-mode for given tasks, re-run when inputs change]' \
+    + '(operation)' \
+        {-l,--list}'[list describable tasks]' \
+        {-a,--list-all}'[list all tasks]' \
+        {-i,--init}'[create new Taskfile.yml]' \
+        '(-*)'{-h,--help}'[show help]' \
+        '(-*)--version[show version and exit]' \
+        '*: :__task_list'

docs/CNAME

@@ -1 +0,0 @@
-taskfile.dev

docs/README.md

@@ -1,51 +0,0 @@
-# Task
-
-<div align="center">
-  <img id="logo" src="/Logo.png" height="250px" width="250px" />
-</div>
-
-Task is a task runner / build tool that aims to be simpler and easier to use
-than, for example, [GNU Make][make].
-
-Since it's written in [Go][go], Task is just a single binary and has no other
-dependencies, which means you don't need to mess with any complicated install
-setups just to use a build tool.
-
-Once [installed](installation.md), you just need to describe your build tasks
-using a simple [YAML][yaml] schema in a file called `Taskfile.yml`:
-
-```yaml
-version: '3'
-
-tasks:
-  hello:
-    cmds:
-      - echo 'Hello World from Task!'
-    silent: true
-```
-
-And call it by running `task hello` from you terminal.
-
-The above example is just the start, you can take a look at the [usage](usage.md)
-guide to check the full schema documentation and Task features.
-
-## Features
-
-- [Easy installation](installation.md): just download a single binary, add to
-  $PATH and you're done! Or you can also install using [Homebrew][homebrew],
-  [Snapcraft][snapcraft], or [Scoop][scoop] if you want;
-- Available on CIs: by adding [this simple command](installation.md#install-script)
-  to install on your CI script and you're done to use Task as part of your CI pipeline;
-- Truly cross-platform: while most build tools only work well on Linux or macOS,
-  Task also supports Windows thanks to [this awesome shell interpreter for Go][sh];
-- Great for code generation: you can easily [prevent a task from running](usage.md#prevent-unnecessary-work)
-  if a given set of files haven't changed since last run (based either on its
-  timestamp or content).
-
-[make]: https://www.gnu.org/software/make/
-[go]: https://golang.org/
-[yaml]: http://yaml.org/
-[homebrew]: https://brew.sh/
-[snapcraft]: https://snapcraft.io/
-[scoop]: https://scoop.sh/
-[sh]: https://mvdan.cc/sh

docs/Taskfile.yml

@@ -1,17 +0,0 @@
-version: '3'
-
-tasks:
-  install:
-    desc: Installs docsify to work the on the documentation site
-    cmds:
-      - npm install docsify-cli -g
-
-  serve:
-    desc: Serves the documentation site locally
-    cmds:
-      - docsify serve .
-
-  ico:
-    desc: Generate favicon.ico from Logo.png
-    cmds:
-      - convert -background transparent "Logo.png" -define icon:auto-resize=16,24,32,48,64,72,96,128,256 "favicon.ico"

docs/_sidebar.md

@@ -1,8 +0,0 @@
-- [Installation](installation.md)
-- [Usage](usage.md)
-- [Styleguide](styleguide.md)
-- [Taskfile Versions](taskfile_versions.md)
-- [Community](community.md)
-- [Releasing Task](releasing_task.md)
-- [Donate](donate.md)
-- [GitHub](https://github.com/go-task/task)

docs/community.md

@@ -1,50 +0,0 @@
-# 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.
-
-## Editor Integrations
-
-### JSON Schema
-
-[@KROSF](https://github.com/KROSF) worked on a JSON Schema [into this Gist](https://gist.github.com/KROSF/c5435acf590acd632f71bb720f685895),
-which later was made officially available by [@Crandel](https://github.com/Crandel)
-at [https://json.schemastore.org/taskfile.json](https://json.schemastore.org/taskfile.json).
-Further improvements are possible by opening pull requests changing
-[this file](https://github.com/SchemaStore/schemastore/blob/master/src/schemas/json/taskfile.json).
-Some code editors, like Visual Studio Code, make use of Schema Store
-automatically.
-
-### 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).
-
-## 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/taskfile-git)
-  by [@kovetskiy](https://github.com/kovetskiy)
-- [Scoop](https://github.com/lukesampson/scoop-extras/blob/master/bucket/task.json)
-
-## 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/donate.md

@@ -1,27 +0,0 @@
-# Donate
-
-If you find this project useful, you can consider donating by using one of the
-channels listed below.
-
-This is just a way of saying "thank you", it won't give you any benefits like
-higher priority on issues or something similar.
-
-## Open Collective
-
-Task is on [Open Collective](https://opencollective.com/task) and you have
-these options to donate:
-
-- [$2 per month](https://opencollective.com/task/contribute/backer-4034/checkout)
-- [$5 per month](https://opencollective.com/task/contribute/supporter-8404/checkout)
-- [$20 per month](https://opencollective.com/task/contribute/sponsor-4035/checkout)
-- [$50 per month](https://opencollective.com/task/contribute/sponsor-28775/checkout)
-- [Custom value - One-time donation option supported](https://opencollective.com/task/donate)
-
-## PayPal
-
-- [Any value - One-time donation](https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=GSVDU63RKG45A&currency_code=USD&source=url)
-
-## PIX (Brazil only)
-
-If you're Brazilian, you can donate any value by
-<a href="/pix.png" target="_blank">using this QR Code</a>.

docs/index.html

@@ -1,50 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8">
-    <title>Task</title>
-    <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1" />
-    <meta name="description" content="A task runner / simpler Make alternative written in Go">
-    <meta name="viewport" content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
-    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/docsify-themeable@0/dist/css/theme-simple.css">
-    <meta name="google-site-verification" content="VGAYkbdmuaciIDGkBe-eAg9yfZg0C6ostgonbGxxOa0" />
-    <style>
-      #logo {
-        transition: all 0.7s ease;
-      }
-      #logo:hover {
-        -webkit-transform: rotateZ(360deg);
-        -ms-transform: rotateZ(360deg);
-        transform: rotateZ(360deg);
-      }
-      .app-name-link img {
-        width: 125px;
-      }
-      :root {
-        --base-font-size: 14px;
-        --theme-color: #29beb0;
-      }
-    </style>
-  </head>
-  <body>
-    <div id="app"></div>
-    <script>
-      window.$docsify = {
-        name: 'Task',
-        repo: 'go-task/task',
-        logo: 'Logo.png',
-        themeColor: '#29beb0',
-        loadSidebar: true,
-        auto2top: true,
-        maxLevel: 3,
-        subMaxLevel: 3
-      }
-    </script>
-    <script src="//cdn.jsdelivr.net/npm/docsify/lib/docsify.min.js"></script>
-    <script src="//cdn.jsdelivr.net/npm/docsify-themeable/dist/js/docsify-themeable.min.js"></script>
-    <script src="//cdn.jsdelivr.net/npm/docsify-tabs"></script>
-    <script src="//cdn.jsdelivr.net/npm/docsify/lib/plugins/search.min.js"></script>
-    <script src="//cdn.jsdelivr.net/npm/prismjs/components/prism-bash.min.js"></script>
-    <script src="//cdn.jsdelivr.net/npm/prismjs/components/prism-yaml.min.js"></script>
-  </body>
-</html>

docs/installation.md

@@ -1,140 +0,0 @@
-# Installation
-
-Task offers many installation methods. Check out the available methods below.
-
-## Package Managers
-
-<!-- tabs:start -->
-
-#### **Homebrew**
-
-If you're on macOS or Linux and have [Homebrew][homebrew] installed, getting
-Task is as simple as running:
-
-```bash
-brew install go-task/tap/go-task
-```
-
-#### **Snap**
-
-Task is available in [Snapcraft][snapcraft], but keep in mind that your
-Linux distribution should allow classic confinement for Snaps to Task work
-right:
-
-```bash
-sudo snap install task --classic
-```
-
-#### **Scoop**
-
-If you're on Windows and have [Scoop][scoop] installed, use `extras` bucket
-to install Task like:
-
-```cmd
-scoop bucket add extras
-scoop install task
-```
-
-This installation method is community owned. After a new release of Task, it
-may take some time until it's available on Scoop.
-
-#### **AUR**
-
-If you're on Arch Linux you can install Task from
-[AUR](https://aur.archlinux.org/packages/taskfile-git) using your favorite
-package manager such as `yay`, `pacaur` or `yaourt`:
-
-```cmd
-yay -S taskfile-git
-```
-
-This installation method is community owned, but since it's `-git` version of
-the package, it's always latest available version based on the Git repository.
-
-<!-- tabs:end -->
-
-## Get The Binary
-
-<!-- tabs:start -->
-
-#### **Binary**
-
-You can download the binary from the [releases page on GitHub][releases] and
-add to your `$PATH`.
-
-DEB and RPM packages are also available.
-
-The `task_checksums.txt` file contains the SHA-256 checksum for each file.
-
-#### **Install Script**
-
-We also have an [install script][installscript] which is very useful in
-scenarios like CI. Many thanks to [GoDownloader][godownloader] for enabling the
-easy generation of this script.
-
-```bash
-# For Default Installation to ./bin with debug logging
-sh -c "$(curl --location https://taskfile.dev/install.sh)" -- -d
-
-# For Installation To /usr/local/bin for userwide access with debug logging
-# May require sudo sh
-sh -c "$(curl --location https://taskfile.dev/install.sh)" -- -d -b /usr/local/bin
-
-```
-
-> This method will download the binary on the local `./bin` directory by default.
-
-#### **GitHub Actions**
-
-If you want to install Task in GitHub Actions you can try using
-[this action](https://github.com/arduino/setup-task)
-by the Arduino team:
-
-```yaml
-- name: Install Task
-  uses: arduino/setup-task@v1
-```
-
-This installation method is community owned.
-
-<!-- tabs:end -->
-
-## Build From Source
-
-<!-- tabs:start -->
-
-#### **Go Modules**
-
-First, make sure you have [Go][go] properly installed and setup.
-
-You can easily install the latest release globally by running:
-
-```bash
-go install github.com/go-task/task/v3/cmd/task@latest
-```
-
-Or you can install into another directory:
-
-```bash
-env GOBIN=/bin go install github.com/go-task/task/v3/cmd/task@latest
-```
-
-If using Go 1.15 or earlier, instead use:
-
-```bash
-env GO111MODULE=on go get -u github.com/go-task/task/v3/cmd/task@latest
-```
-
-> For CI environments we recommend using the [Install Script](#get-the-binary)
-> instead, which is faster and more stable, since it'll just download the latest
-> released binary.
-
-<!-- tabs:end -->
-
-[go]: https://golang.org/
-[snapcraft]: https://snapcraft.io/task
-[homebrew]: https://brew.sh/
-[installscript]: https://github.com/go-task/task/blob/master/install-task.sh
-[releases]: https://github.com/go-task/task/releases
-[godownloader]: https://github.com/goreleaser/godownloader
-[scoop]: https://scoop.sh/

docs/releasing_task.md

@@ -1,39 +0,0 @@
-# Releasing Task
-
-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).
-
-# Homebrew
-
-To release a new version on the [Homebrew tap][homebrewtap] edit the
-[Formula/go-task.rb][gotaskrb] file, updating with the new version, download
-URL and sha256.
-
-# Snapcraft
-
-The exception is the publishing of a new version of the
-[snap package][snappackage]. This current require two steps after publishing
-the binaries:
-
-* Updating the current version on [snapcraft.yaml][snapcraftyaml];
-* Moving both `i386` and `amd64` new artifacts to the stable channel on
-the [Snapcraft dashboard][snapcraftdashboard]
-
-# Scoop
-
-Scoop is a community owned installation method. Scoop owners usually take care
-of updating versions there by editing
-[this file](https://github.com/lukesampson/scoop-extras/blob/master/bucket/task.json).
-If you think its Task version is outdated, open an issue to let us know.
-
-[goreleaser]: https://goreleaser.com/#continuous_integration
-[homebrewtap]: https://github.com/go-task/homebrew-tap
-[gotaskrb]: https://github.com/go-task/homebrew-tap/blob/master/Formula/go-task.rb
-[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

errors.go

@@ -1,43 +0,0 @@
-package task
-
-import (
-	"errors"
-	"fmt"
-)
-
-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
-}
-
-func (err *taskNotFoundError) Error() string {
-	return fmt.Sprintf(`task: Task "%s" not found`, err.taskName)
-}
-
-type taskRunError struct {
-	taskName string
-	err      error
-}
-
-func (err *taskRunError) Error() string {
-	return fmt.Sprintf(`task: Failed to run task "%s": %v`, err.taskName, err.err)
-}
-
-// 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 "%s": 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,17 +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/mattn/go-zglob v0.0.3
+	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.7.0
-	golang.org/x/sync v0.0.0-20210220032951-036812b2e83c
-	gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c
-	mvdan.cc/sh/v3 v3.4.2-0.20211202103622-5ae9d64e1402
+	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.8.0
 )
 
-go 1.16
+require (
+	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
+	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.sum

@@ -1,72 +1,72 @@
-github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
-github.com/creack/pty v1.1.15 h1:cKRCLMj3Ddm54bKSpemfQ8AtYFBhAI2MPmdys22fBdc=
-github.com/creack/pty v1.1.15/go.mod h1:MOBLtS5ELjhRRrroQr9kyvTxUAFNvYEK993ew/Vr4O4=
-github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/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/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.13.1 h1:xVm/f9seEhZFL9+n5kv5XLrGwy6elc4V9v/XFY2vmd8=
-github.com/frankban/quicktest v1.13.1/go.mod h1:NeW+ay9A/U67EYXNFA1nPE8e/tnQv/09mUdL/ijj8og=
-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.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ=
-github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/renameio v1.0.1/go.mod h1:t/HQoYBZSsWSNK35C6CO/TpPLDVWvxOHboWUAweKUpk=
-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/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
-github.com/kr/pretty v0.3.0 h1:WgNl7dwNpEZ6jJ9k1snq4pZsg7DOEN8hP9Xw0Tsjwk0=
-github.com/kr/pretty v0.3.0/go.mod h1:640gp4NfQd8pI5XOwp5fnNeVWj67G7CFk/SaSQn7NBk=
-github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
-github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/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/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
-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/mattn/go-zglob v0.0.3 h1:6Ry4EYsScDyt5di4OI6xw1bYhOqfE5S33Z1OPy+d+To=
-github.com/mattn/go-zglob v0.0.3/go.mod h1:9fxibJccNxU2cnpIKLRRFA7zX7qhkJIQWBb449FYHOo=
+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/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
+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.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
-github.com/rogpeppe/go-internal v1.8.1-0.20210923151022-86f73c517451 h1:d1PiN4RxzIFXCJTvRkvSkKqwtRAl5ZV4lATKtQI0B7I=
-github.com/rogpeppe/go-internal v1.8.1-0.20210923151022-86f73c517451/go.mod h1:JeRgkft04UBgHMgCIwADu4Pn6Mtm5d4nPKWu0nJ5d+o=
+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/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
-github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
-github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-golang.org/x/sync v0.0.0-20210220032951-036812b2e83c h1:5KslGYwFpkhGh+Q16bwMP3cOontH8FOep7tGV86Y7SQ=
-golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/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-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20210925032602-92d5a993a665 h1:QOQNt6vCjMpXE7JSK5VvAzJC1byuN3FgTNSBwf+CJgI=
-golang.org/x/sys v0.0.0-20210925032602-92d5a993a665/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/term v0.0.0-20210916214954-140adaaadfaf h1:Ihq/mm/suC88gF8WFcVwk+OV6Tq+wyA1O0E5UEvDglI=
-golang.org/x/term v0.0.0-20210916214954-140adaaadfaf/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
-golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
-golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+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/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
-gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-mvdan.cc/editorconfig v0.2.0/go.mod h1:lvnnD3BNdBYkhq+B4uBuFFKatfp02eB6HixDvEz91C0=
-mvdan.cc/sh/v3 v3.4.2-0.20211202103622-5ae9d64e1402 h1:IhYcaLRZjSJqGoLrn+sXXFq3Xhd40I0wBkoIyg6cSZs=
-mvdan.cc/sh/v3 v3.4.2-0.20211202103622-5ae9d64e1402/go.mod h1:p/tqPPI4Epfk2rICAe2RoaNd8HBSJ8t9Y2DA9yQlbzY=
+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.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

@@ -1,42 +1,207 @@
 package task
 
 import (
+	"context"
+	"encoding/json"
 	"fmt"
-	"sort"
+	"io"
+	"os"
+	"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"
 )
 
-// PrintTasksHelp prints help os tasks that have a description
-func (e *Executor) PrintTasksHelp() {
-	tasks := e.tasksWithDesc()
-	if len(tasks) == 0 {
-		e.Logger.Outf(logger.Yellow, "task: No tasks with description available")
-		return
+// ListOptions collects list-related options
+type ListOptions struct {
+	ListOnlyTasksWithDescriptions bool
+	ListAllTasks                  bool
+	FormatTaskListAsJSON          bool
+	NoStatus                      bool
+}
+
+// NewListOptions creates a new ListOptions instance
+func NewListOptions(list, listAll, listAsJson, noStatus bool) ListOptions {
+	return ListOptions{
+		ListOnlyTasksWithDescriptions: list,
+		ListAllTasks:                  listAll,
+		FormatTaskListAsJSON:          listAsJson,
+		NoStatus:                      noStatus,
 	}
-	e.Logger.Outf(logger.Default, "task: Available tasks for this project:")
+}
+
+// ShouldListTasks returns true if one of the options to list tasks has been set to true
+func (o ListOptions) ShouldListTasks() bool {
+	return o.ListOnlyTasksWithDescriptions || o.ListAllTasks
+}
+
+// Validate validates that the collection of list-related options are in a valid configuration
+func (o ListOptions) Validate() error {
+	if o.ListOnlyTasksWithDescriptions && o.ListAllTasks {
+		return fmt.Errorf("task: cannot use --list and --list-all at the same time")
+	}
+	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 ast.Task according to the given ListOptions
+func (o ListOptions) Filters() []FilterFunc {
+	filters := []FilterFunc{FilterOutInternal}
+
+	if o.ListOnlyTasksWithDescriptions {
+		filters = append(filters, FilterOutNoDesc)
+	}
+
+	return filters
+}
+
+// ListTasks prints a list of tasks.
+// Tasks that match the given filters will be excluded from the list.
+// The function returns a boolean indicating whether tasks were found
+// and an error if one was encountered while preparing the output.
+func (e *Executor) ListTasks(o ListOptions) (bool, error) {
+	tasks, err := e.GetTaskList(o.Filters()...)
+	if err != nil {
+		return false, err
+	}
+	if o.FormatTaskListAsJSON {
+		output, err := e.ToEditorOutput(tasks, o.NoStatus)
+		if err != nil {
+			return false, err
+		}
+
+		encoder := json.NewEncoder(e.Stdout)
+		encoder.SetIndent("", "  ")
+		if err := encoder.Encode(output); err != nil {
+			return false, err
+		}
+
+		return len(tasks) > 0, nil
+	}
+	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\n")
+		} else if o.ListAllTasks {
+			e.Logger.Outf(logger.Yellow, "task: No tasks available\n")
+		}
+		return false, nil
+	}
+	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, 0, '\t', 0)
+	w := tabwriter.NewWriter(e.Stdout, 0, 8, 6, ' ', 0)
 	for _, task := range tasks {
-		fmt.Fprintf(w, "* %s: \t%s\n", task.Name(), task.Desc)
+		e.Logger.FOutf(w, logger.Yellow, "* ")
+		e.Logger.FOutf(w, logger.Green, task.Task)
+		e.Logger.FOutf(w, logger.Default, ": \t%s", task.Desc)
+		if len(task.Aliases) > 0 {
+			e.Logger.FOutf(w, logger.Cyan, "\t(aliases: %s)", strings.Join(task.Aliases, ", "))
+		}
+		_, _ = fmt.Fprint(w, "\n")
 	}
-	w.Flush()
+	if err := w.Flush(); err != nil {
+		return false, err
+	}
+	return true, nil
 }
 
-func (e *Executor) tasksWithDesc() (tasks []*taskfile.Task) {
-	tasks = make([]*taskfile.Task, 0, len(e.Taskfile.Tasks))
-	for _, task := range e.Taskfile.Tasks {
-		if task.Desc != "" {
-			compiledTask, err := e.FastCompiledTask(taskfile.Call{Task: task.Task})
-			if err == nil {
-				task = compiledTask
+// 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) error {
+	// use stdout if no output defined
+	var w io.Writer = os.Stdout
+	if e.Stdout != nil {
+		w = e.Stdout
+	}
+
+	// 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, ":"))
 			}
-			tasks = append(tasks, task)
 		}
 	}
-	sort.Slice(tasks, func(i, j int) bool { return tasks[i].Task < tasks[j].Task })
-	return
+	for _, t := range taskNames {
+		fmt.Fprintln(w, t)
+	}
+	return nil
+}
+
+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,
+	}
+	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, g.Wait()
 }

init.go

@@ -3,9 +3,10 @@ package task
 import (
 	"fmt"
 	"io"
-	"io/ioutil"
 	"os"
-	"path/filepath"
+
+	"github.com/go-task/task/v3/errors"
+	"github.com/go-task/task/v3/internal/filepathext"
 )
 
 const defaultTaskfile = `# https://taskfile.dev
@@ -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 := filepath.Join(dir, "Taskfile.yml")
+	f := filepathext.SmartJoin(dir, defaultTaskfileName)
 
 	if _, err := os.Stat(f); err == nil {
-		return ErrTaskfileAlreadyExists
+		return errors.TaskfileAlreadyExistsError{}
 	}
 
-	if err := ioutil.WriteFile(f, []byte(defaultTaskfile), 0644); err != nil {
+	if err := os.WriteFile(f, []byte(defaultTaskfile), 0o644); err != nil {
 		return err
 	}
-	fmt.Fprintf(w, "Taskfile.yml created in the current directory\n")
+	fmt.Fprintf(w, "%s created in the current directory\n", defaultTaskfile)
 	return nil
 }

install-task.sh

@@ -64,15 +64,21 @@ get_binaries() {
   case "$PLATFORM" in
     darwin/amd64) BINARIES="task" ;;
     darwin/arm64) BINARIES="task" ;;
+    darwin/armv5) BINARIES="task" ;;
     darwin/armv6) BINARIES="task" ;;
+    darwin/armv7) BINARIES="task" ;;
     linux/386) BINARIES="task" ;;
     linux/amd64) BINARIES="task" ;;
     linux/arm64) BINARIES="task" ;;
+    linux/armv5) BINARIES="task" ;;
     linux/armv6) BINARIES="task" ;;
+    linux/armv7) BINARIES="task" ;;
     windows/386) BINARIES="task" ;;
     windows/amd64) BINARIES="task" ;;
     windows/arm64) BINARIES="task" ;;
+    windows/armv5) BINARIES="task" ;;
     windows/armv6) BINARIES="task" ;;
+    windows/armv7) BINARIES="task" ;;
     *)
       log_crit "platform $PLATFORM is not supported.  Make sure this script is up-to-date and file request at https://github.com/${PREFIX}/issues/new"
       exit 1
@@ -184,9 +190,9 @@ uname_arch() {
     i686) arch="386" ;;
     i386) arch="386" ;;
     aarch64) arch="arm64" ;;
-    armv5*) arch="armv5" ;;
-    armv6*) arch="armv6" ;;
-    armv7*) arch="armv7" ;;
+    armv5*) arch="arm" ;;
+    armv6*) arch="arm" ;;
+    armv7*) arch="arm" ;;
   esac
   echo ${arch}
 }
@@ -214,9 +220,7 @@ uname_arch_check() {
     386) return 0 ;;
     amd64) return 0 ;;
     arm64) return 0 ;;
-    armv5) return 0 ;;
-    armv6) return 0 ;;
-    armv7) return 0 ;;
+    arm) return 0 ;;
     ppc64) return 0 ;;
     ppc64le) return 0 ;;
     mips) return 0 ;;

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,158 +0,0 @@
-package v3
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-	"path/filepath"
-	"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 = &CompilerV3{}
-
-type CompilerV3 struct {
-	Dir 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 {
-		result.Set("TASK", taskfile.Var{Static: t.Task})
-	}
-
-	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)
-
-	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 || call == nil {
-		return result, nil
-	}
-
-	if err := call.Vars.Range(rangeFunc); err != nil {
-		return nil, err
-	}
-
-	// 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
-	}
-	if !filepath.IsAbs(dir) {
-		dir = filepath.Join(c.Dir, dir)
-	}
-	taskRangeFunc := getRangeFunc(dir)
-
-	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(), "\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
-}

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

@@ -0,0 +1,24 @@
+package editors
+
+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,31 @@
+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() {
+		str, isString := v.(string)
+		if !isString {
+			continue
+		}
+
+		if _, alreadySet := os.LookupEnv(k); alreadySet {
+			continue
+		}
+
+		environ = append(environ, fmt.Sprintf("%s=%s", k, str))
+	}
+
+	return environ
+}

internal/execext/exec.go

@@ -3,10 +3,12 @@ package execext
 import (
 	"context"
 	"errors"
+	"fmt"
 	"io"
 	"os"
 	"path/filepath"
 	"strings"
+	"time"
 
 	"mvdan.cc/sh/v3/expand"
 	"mvdan.cc/sh/v3/interp"
@@ -16,18 +18,18 @@ import (
 
 // RunCommandOptions is the options for the RunCommand func
 type RunCommandOptions struct {
-	Command string
-	Dir     string
-	Env     []string
-	Stdin   io.Reader
-	Stdout  io.Writer
-	Stderr  io.Writer
+	Command   string
+	Dir       string
+	Env       []string
+	PosixOpts []string
+	BashOpts  []string
+	Stdin     io.Reader
+	Stdout    io.Writer
+	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 {
@@ -35,9 +37,18 @@ func RunCommand(ctx context.Context, opts *RunCommandOptions) error {
 		return ErrNilOptions
 	}
 
-	p, err := syntax.NewParser().Parse(strings.NewReader(opts.Command), "")
-	if err != nil {
-		return err
+	// Set "-e" or "errexit" by default
+	opts.PosixOpts = append(opts.PosixOpts, "e")
+
+	// Format POSIX options into a slice that mvdan/sh understands
+	var params []string
+	for _, opt := range opts.PosixOpts {
+		if len(opt) == 1 {
+			params = append(params, fmt.Sprintf("-%s", opt))
+		} else {
+			params = append(params, "-o")
+			params = append(params, opt)
+		}
 	}
 
 	environ := opts.Env
@@ -46,15 +57,36 @@ func RunCommand(ctx context.Context, opts *RunCommandOptions) error {
 	}
 
 	r, err := interp.New(
-		interp.Params("-e"),
-		interp.Dir(opts.Dir),
+		interp.Params(params...),
 		interp.Env(expand.ListEnviron(environ...)),
+		interp.ExecHandlers(execHandler),
 		interp.OpenHandler(openHandler),
 		interp.StdIO(opts.Stdin, opts.Stdout, opts.Stderr),
+		dirOption(opts.Dir),
 	)
 	if err != nil {
 		return err
 	}
+
+	parser := syntax.NewParser()
+
+	// Run any shopt commands
+	if len(opts.BashOpts) > 0 {
+		shoptCmdStr := fmt.Sprintf("shopt -s %s", strings.Join(opts.BashOpts, " "))
+		shoptCmd, err := parser.Parse(strings.NewReader(shoptCmdStr), "")
+		if err != nil {
+			return err
+		}
+		if err := r.Run(ctx, shoptCmd); err != nil {
+			return err
+		}
+	}
+
+	// Run the user-defined command
+	p, err := parser.Parse(strings.NewReader(opts.Command), "")
+	if err != nil {
+		return err
+	}
 	return r.Run(ctx, p)
 }
 
@@ -70,7 +102,10 @@ func IsExitError(err error) bool {
 // if available.
 func Expand(s string) (string, error) {
 	s = filepath.ToSlash(s)
-	s = strings.Replace(s, " ", `\ `, -1)
+	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
@@ -81,9 +116,34 @@ 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
 	}
 	return interp.DefaultOpenHandler()(ctx, path, flag, perm)
 }
+
+func dirOption(path string) interp.RunnerOption {
+	return func(r *interp.Runner) error {
+		err := interp.Dir(path)(r)
+		if err == nil {
+			return nil
+		}
+
+		// If the specified directory doesn't exist, it will be created later.
+		// Therefore, even if `interp.Dir` method returns an error, the
+		// directory path should be set only when the directory cannot be found.
+		if absPath, _ := filepath.Abs(path); absPath != "" {
+			if _, err := os.Stat(absPath); os.IsNotExist(err) {
+				r.Dir = absPath
+				return nil
+			}
+		}
+
+		return err
+	}
+}

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

@@ -0,0 +1,57 @@
+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 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 {
+	wd, err := os.Getwd()
+	if err != nil {
+		return abs
+	}
+
+	rel, err := filepath.Rel(wd, abs)
+	if err != nil {
+		return abs
+	}
+
+	return rel
+}

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,23 +1,32 @@
-package status
+package fingerprint
 
 import (
 	"os"
-	"path/filepath"
 	"sort"
 
 	"github.com/mattn/go-zglob"
 
 	"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
@@ -25,17 +34,18 @@ func globs(dir string, globs []string) ([]string, error) {
 
 func Glob(dir string, g string) ([]string, error) {
 	files := make([]string, 0)
-	if !filepath.IsAbs(g) {
-		g = filepath.Join(dir, g)
-	}
+	g = filepathext.SmartJoin(dir, g)
+
 	g, err := execext.Expand(g)
 	if err != nil {
 		return nil, err
 	}
-	fs, err := zglob.Glob(g)
+
+	fs, err := zglob.GlobFollowSymlinks(g)
 	if err != nil {
 		return nil, err
 	}
+
 	for _, f := range fs {
 		info, err := os.Stat(f)
 		if err != 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"
@@ -16,6 +16,6 @@ func TestNormalizeFilename(t *testing.T) {
 		{"foo1bar2baz3", "foo1bar2baz3"},
 	}
 	for _, test := range tests {
-		assert.Equal(t, test.Out, (&Checksum{}).normalizeFilename(test.In))
+		assert.Equal(t, test.Out, normalizeFilename(test.In))
 	}
 }

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

@@ -0,0 +1,151 @@
+package fingerprint
+
+import (
+	"os"
+	"path/filepath"
+	"time"
+
+	"github.com/go-task/task/v3/taskfile/ast"
+)
+
+// TimestampChecker checks if any source change compared with the generated files,
+// using file modifications timestamps.
+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 (checker *TimestampChecker) IsUpToDate(t *ast.Task) (bool, error) {
+	if len(t.Sources) == 0 {
+		return false, nil
+	}
+
+	sources, err := Globs(t.Dir, t.Sources)
+	if err != nil {
+		return false, nil
+	}
+	generates, err := Globs(t.Dir, t.Generates)
+	if err != nil {
+		return false, nil
+	}
+
+	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.
+	_, err = os.Stat(timestampFile)
+	if err == nil {
+		generates = append(generates, timestampFile)
+	} else {
+		// Create the timestamp file for the next execution when the file does not exist.
+		if !checker.dry {
+			if err := os.MkdirAll(filepath.Dir(timestampFile), 0o755); err != nil {
+				return false, err
+			}
+			f, err := os.Create(timestampFile)
+			if err != nil {
+				return false, err
+			}
+			f.Close()
+		}
+	}
+
+	taskTime := time.Now()
+
+	// Compare the time of the generates and sources. If the generates are old, the task will be executed.
+
+	// Get the max time of the generates.
+	generateMaxTime, err := getMaxTime(generates...)
+	if err != nil || generateMaxTime.IsZero() {
+		return false, nil
+	}
+
+	// Check if any of the source files is newer than the max time of the generates.
+	shouldUpdate, err := anyFileNewerThan(sources, generateMaxTime)
+	if err != nil {
+		return false, nil
+	}
+
+	// Modify the metadata of the file to the the current time.
+	if !checker.dry {
+		if err := os.Chtimes(timestampFile, taskTime, taskTime); err != nil {
+			return false, err
+		}
+	}
+
+	return !shouldUpdate, nil
+}
+
+func (checker *TimestampChecker) Kind() string {
+	return "timestamp"
+}
+
+// Value implements the Checker Interface
+func (checker *TimestampChecker) Value(t *ast.Task) (any, error) {
+	sources, err := Globs(t.Dir, t.Sources)
+	if err != nil {
+		return time.Now(), err
+	}
+
+	sourcesMaxTime, err := getMaxTime(sources...)
+	if err != nil {
+		return time.Now(), err
+	}
+
+	if sourcesMaxTime.IsZero() {
+		return time.Unix(0, 0), nil
+	}
+
+	return sourcesMaxTime, nil
+}
+
+func getMaxTime(files ...string) (time.Time, error) {
+	var t time.Time
+	for _, f := range files {
+		info, err := os.Stat(f)
+		if err != nil {
+			return time.Time{}, err
+		}
+		t = maxTime(t, info.ModTime())
+	}
+	return t, nil
+}
+
+func maxTime(a, b time.Time) time.Time {
+	if a.After(b) {
+		return a
+	}
+	return b
+}
+
+// If the modification time of any of the files is newer than the the given time, returns true.
+// This function is lazy, as it stops when it finds a file newer than the given time.
+func anyFileNewerThan(files []string, givenTime time.Time) (bool, error) {
+	for _, f := range files {
+		info, err := os.Stat(f)
+		if err != nil {
+			return false, err
+		}
+		if info.ModTime().After(givenTime) {
+			return true, nil
+		}
+	}
+	return false, nil
+}
+
+// OnError implements the Checker interface
+func (*TimestampChecker) OnError(t *ast.Task) error {
+	return nil
+}
+
+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

@@ -0,0 +1,63 @@
+package goext
+
+// NOTE(@andreynering): The lists in this file were copied from:
+//
+// https://github.com/golang/go/blob/master/src/go/build/syslist.go
+
+func IsKnownOS(str string) bool {
+	_, known := knownOS[str]
+	return known
+}
+
+func IsKnownArch(str string) bool {
+	_, known := knownArch[str]
+	return known
+}
+
+var knownOS = map[string]struct{}{
+	"aix":       {},
+	"android":   {},
+	"darwin":    {},
+	"dragonfly": {},
+	"freebsd":   {},
+	"hurd":      {},
+	"illumos":   {},
+	"ios":       {},
+	"js":        {},
+	"linux":     {},
+	"nacl":      {},
+	"netbsd":    {},
+	"openbsd":   {},
+	"plan9":     {},
+	"solaris":   {},
+	"windows":   {},
+	"zos":       {},
+	"__test__":  {},
+}
+
+var knownArch = map[string]struct{}{
+	"386":         {},
+	"amd64":       {},
+	"amd64p32":    {},
+	"arm":         {},
+	"armbe":       {},
+	"arm64":       {},
+	"arm64be":     {},
+	"loong64":     {},
+	"mips":        {},
+	"mipsle":      {},
+	"mips64":      {},
+	"mips64le":    {},
+	"mips64p32":   {},
+	"mips64p32le": {},
+	"ppc":         {},
+	"ppc64":       {},
+	"ppc64le":     {},
+	"riscv":       {},
+	"riscv64":     {},
+	"s390":        {},
+	"s390x":       {},
+	"sparc":       {},
+	"sparc64":     {},
+	"wasm":        {},
+}

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,173 @@
 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")
+)
 
-func Default() PrintFunc { return color.New(color.Reset).FprintfFunc() }
-func Blue() PrintFunc    { return color.New(color.FgBlue).FprintfFunc() }
-func Green() PrintFunc   { return color.New(color.FgGreen).FprintfFunc() }
-func Cyan() PrintFunc    { return color.New(color.FgCyan).FprintfFunc() }
-func Yellow() PrintFunc  { return color.New(color.FgYellow).FprintfFunc() }
-func Magenta() PrintFunc { return color.New(color.FgMagenta).FprintfFunc() }
-func Red() PrintFunc     { return color.New(color.FgRed).FprintfFunc() }
+type (
+	Color     func() PrintFunc
+	PrintFunc func(io.Writer, string, ...any)
+)
+
+func Default() PrintFunc {
+	return color.New(envColor("TASK_COLOR_RESET", color.Reset)...).FprintfFunc()
+}
+
+func Blue() PrintFunc {
+	return color.New(envColor("TASK_COLOR_BLUE", color.FgBlue)...).FprintfFunc()
+}
+
+func Green() PrintFunc {
+	return color.New(envColor("TASK_COLOR_GREEN", color.FgGreen)...).FprintfFunc()
+}
+
+func Cyan() PrintFunc {
+	return color.New(envColor("TASK_COLOR_CYAN", color.FgCyan)...).FprintfFunc()
+}
+
+func Yellow() PrintFunc {
+	return color.New(envColor("TASK_COLOR_YELLOW", color.FgYellow)...).FprintfFunc()
+}
+
+func Magenta() PrintFunc {
+	return color.New(envColor("TASK_COLOR_MAGENTA", color.FgMagenta)...).FprintfFunc()
+}
+
+func Red() PrintFunc {
+	return color.New(envColor("TASK_COLOR_RED", color.FgRed)...).FprintfFunc()
+}
+
+func envColor(env string, defaultColor color.Attribute) []color.Attribute {
+	if os.Getenv("FORCE_COLOR") != "" {
+		color.NoColor = false
+	}
+
+	// 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{}) {
+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 ...any) {
 	if len(args) == 0 {
-		s, args = "%s", []interface{}{s}
+		s, args = "%s", []any{s}
 	}
 	if !l.Color {
 		color = Default
 	}
 	print := color()
-	print(l.Stdout, s+"\n", args...)
+	print(w, s, args...)
 }
 
 // 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,24 +3,51 @@ package output
 import (
 	"bytes"
 	"io"
+
+	"github.com/go-task/task/v3/internal/templater"
 )
 
-type Group struct{}
+type Group struct {
+	Begin, End string
+	ErrorOnly  bool
+}
 
-func (Group) WrapWriter(w io.Writer, _ string) io.Writer {
-	return &groupWriter{writer: w}
+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 = templater.Replace(g.Begin, cache) + "\n"
+	}
+	if g.End != "" {
+		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()
+	}
 }
 
 type groupWriter struct {
-	writer io.Writer
-	buff   bytes.Buffer
+	writer     io.Writer
+	buff       bytes.Buffer
+	begin, end string
 }
 
 func (gw *groupWriter) Write(p []byte) (int, error) {
 	return gw.buff.Write(p)
 }
 
-func (gw *groupWriter) Close() error {
+func (gw *groupWriter) close() error {
+	if gw.buff.Len() == 0 {
+		// don't print begin/end messages if there's no buffered entries
+		return nil
+	}
+	if _, err := io.WriteString(gw.writer, gw.begin); err != nil {
+		return err
+	}
+	gw.buff.WriteString(gw.end)
 	_, err := io.Copy(gw.writer, &gw.buff)
 	return err
 }

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(w io.Writer, _ string) io.Writer {
-	return w
+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

@@ -1,9 +1,46 @@
 package output
 
 import (
+	"fmt"
 	"io"
+
+	"github.com/go-task/task/v3/internal/templater"
+	"github.com/go-task/task/v3/taskfile/ast"
 )
 
 type Output interface {
-	WrapWriter(w io.Writer, prefix string) io.Writer
+	WrapWriter(stdOut, stdErr io.Writer, prefix string, cache *templater.Cache) (io.Writer, io.Writer, CloseFunc)
+}
+
+type CloseFunc func(err error) 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 {
+			return nil, err
+		}
+		return Interleaved{}, nil
+	case "group":
+		return Group{
+			Begin:     o.Group.Begin,
+			End:       o.Group.End,
+			ErrorOnly: o.Group.ErrorOnly,
+		}, nil
+	case "prefixed":
+		if err := checkOutputGroupUnset(o); err != nil {
+			return nil, err
+		}
+		return Prefixed{}, nil
+	default:
+		return nil, fmt.Errorf(`task: output style %q not recognized`, o.Name)
+	}
+}
+
+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)
+	}
+	return nil
 }

internal/output/output_test.go

@@ -2,19 +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/ast"
 )
 
 func TestInterleaved(t *testing.T) {
 	var b bytes.Buffer
 	var o output.Output = output.Interleaved{}
-	var w = o.WrapWriter(&b, "")
+	w, _, _ := o.WrapWriter(&b, io.Discard, "", nil)
 
 	fmt.Fprintln(w, "foo\nbar")
 	assert.Equal(t, "foo\nbar\n", b.String())
@@ -25,20 +30,85 @@ func TestInterleaved(t *testing.T) {
 func TestGroup(t *testing.T) {
 	var b bytes.Buffer
 	var o output.Output = output.Group{}
-	var w = o.WrapWriter(&b, "").(io.WriteCloser)
+	stdOut, stdErr, cleanup := o.WrapWriter(&b, io.Discard, "", nil)
 
-	fmt.Fprintln(w, "foo\nbar")
+	fmt.Fprintln(stdOut, "out\nout")
 	assert.Equal(t, "", b.String())
-	fmt.Fprintln(w, "baz")
+	fmt.Fprintln(stdErr, "err\nerr")
 	assert.Equal(t, "", b.String())
-	assert.NoError(t, w.Close())
-	assert.Equal(t, "foo\nbar\nbaz\n", b.String())
+	fmt.Fprintln(stdOut, "out")
+	assert.Equal(t, "", b.String())
+	fmt.Fprintln(stdErr, "err")
+	assert.Equal(t, "", b.String())
+
+	require.NoError(t, cleanup(nil))
+	assert.Equal(t, "out\nout\nerr\nerr\nout\nerr\n", b.String())
+}
+
+func TestGroupWithBeginEnd(t *testing.T) {
+	tmpl := templater.Cache{
+		Vars: &ast.Vars{
+			OrderedMap: omap.FromMap(map[string]ast.Var{
+				"VAR1": {Value: "example-value"},
+			}),
+		},
+	}
+
+	var o output.Output = output.Group{
+		Begin: "::group::{{ .VAR1 }}",
+		End:   "::endgroup::",
+	}
+	t.Run("simple", func(t *testing.T) {
+		var b bytes.Buffer
+		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())
+		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
+		_, _, 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 = o.WrapWriter(&b, "prefix").(io.WriteCloser)
+	w, _, cleanup := o.WrapWriter(&b, io.Discard, "prefix", nil)
 
 	t.Run("simple use cases", func(t *testing.T) {
 		b.Reset()
@@ -47,6 +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())
+		require.NoError(t, cleanup(nil))
 	})
 
 	t.Run("multiple writes for a single line", func(t *testing.T) {
@@ -57,7 +128,7 @@ func TestPrefixed(t *testing.T) {
 			assert.Equal(t, "", b.String())
 		}
 
-		assert.NoError(t, w.Close())
+		require.NoError(t, cleanup(nil))
 		assert.Equal(t, "[prefix] Test!\n", b.String())
 	})
 }

internal/output/prefixed.go

@@ -5,12 +5,15 @@ import (
 	"fmt"
 	"io"
 	"strings"
+
+	"github.com/go-task/task/v3/internal/templater"
 )
 
 type Prefixed struct{}
 
-func (Prefixed) WrapWriter(w io.Writer, prefix string) io.Writer {
-	return &prefixWriter{writer: w, prefix: prefix}
+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) error { return pw.close() }
 }
 
 type prefixWriter struct {
@@ -28,7 +31,7 @@ func (pw *prefixWriter) Write(p []byte) (int, error) {
 	return n, pw.writeOutputLines(false)
 }
 
-func (pw *prefixWriter) Close() error {
+func (pw *prefixWriter) close() error {
 	return pw.writeOutputLines(true)
 }
 

internal/slicesext/slicesext.go

@@ -0,0 +1,20 @@
+package slicesext
+
+import (
+	"cmp"
+	"slices"
+)
+
+func UniqueJoin[T cmp.Ordered](ss ...[]T) []T {
+	var length int
+	for _, s := range ss {
+		length += len(s)
+	}
+	r := make([]T, length)
+	var i int
+	for _, s := range ss {
+		i += copy(r[i:], s)
+	}
+	slices.Sort(r)
+	return slices.Compact(r)
+}

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,119 +0,0 @@
-package status
-
-import (
-	"crypto/md5"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"regexp"
-	"strings"
-)
-
-// Checksum validades if a task is up to date by calculating its source
-// files checksum
-type Checksum struct {
-	BaseDir   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, _ := ioutil.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(filepath.Join(c.BaseDir, ".task", "checksum"), 0755)
-		if err = ioutil.WriteFile(checksumFile, []byte(newMd5+"\n"), 0644); 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
-		}
-	}
-
-	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.BaseDir, ".task", "checksum", c.normalizeFilename(c.Task))
-}
-
-var checksumFilenameRegexp = regexp.MustCompile("[^A-z0-9]")
-
-// replaces invalid caracters on filenames with "-"
-func (*Checksum) 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/status/timestamp.go

@@ -1,108 +0,0 @@
-package status
-
-import (
-	"os"
-	"time"
-)
-
-// Timestamp checks if any source change compared with the generated files,
-// using file modifications timestamps.
-type Timestamp struct {
-	Dir       string
-	Sources   []string
-	Generates []string
-}
-
-// IsUpToDate implements the Checker interface
-func (t *Timestamp) IsUpToDate() (bool, error) {
-	if len(t.Sources) == 0 || len(t.Generates) == 0 {
-		return false, nil
-	}
-
-	sources, err := globs(t.Dir, t.Sources)
-	if err != nil {
-		return false, nil
-	}
-	generates, err := globs(t.Dir, t.Generates)
-	if err != nil {
-		return false, nil
-	}
-
-	sourcesMaxTime, err := getMaxTime(sources...)
-	if err != nil || sourcesMaxTime.IsZero() {
-		return false, nil
-	}
-
-	generatesMinTime, err := getMinTime(generates...)
-	if err != nil || generatesMinTime.IsZero() {
-		return false, nil
-	}
-
-	return !generatesMinTime.Before(sourcesMaxTime), nil
-}
-
-func (t *Timestamp) Kind() string {
-	return "timestamp"
-}
-
-// Value implements the Checker Interface
-func (t *Timestamp) Value() (interface{}, error) {
-	sources, err := globs(t.Dir, t.Sources)
-	if err != nil {
-		return time.Now(), err
-	}
-
-	sourcesMaxTime, err := getMaxTime(sources...)
-	if err != nil {
-		return time.Now(), err
-	}
-
-	if sourcesMaxTime.IsZero() {
-		return time.Unix(0, 0), nil
-	}
-
-	return sourcesMaxTime, nil
-}
-
-func getMinTime(files ...string) (time.Time, error) {
-	var t time.Time
-	for _, f := range files {
-		info, err := os.Stat(f)
-		if err != nil {
-			return time.Time{}, err
-		}
-		t = minTime(t, info.ModTime())
-	}
-	return t, nil
-}
-
-func getMaxTime(files ...string) (time.Time, error) {
-	var t time.Time
-	for _, f := range files {
-		info, err := os.Stat(f)
-		if err != nil {
-			return time.Time{}, err
-		}
-		t = maxTime(t, info.ModTime())
-	}
-	return t, nil
-}
-
-func minTime(a, b time.Time) time.Time {
-	if !a.IsZero() && a.Before(b) {
-		return a
-	}
-	return b
-}
-
-func maxTime(a, b time.Time) time.Time {
-	if a.After(b) {
-		return a
-	}
-	return b
-}
-
-// OnError implements the Checker interface
-func (*Timestamp) OnError() error {
-	return nil
-}