v3.39.2

Co-authored-by: Andrey Nering <andreynering@users.noreply.github.com>

.editorconfig

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

.gitattributes

@@ -1 +1,2 @@
 * text=auto
+*.mdx -linguist-detectable

.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,3 +1,3 @@
-github: andreynering
+github: [andreynering, pd93, vmaerten]
 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,9 @@
+<!--
+
+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/renovate.json

@@ -0,0 +1,48 @@
+{
+  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+  "extends": [
+    "config:recommended",
+    "group:allNonMajor",
+    "schedule:monthly"
+  ],
+  "mode": "full",
+  "reviewers": ["team:developer"],
+  "packageRules": [
+    {
+      "matchManagers": ["github-actions"],
+      "groupName": "Github Action",
+      "labels": ["area: github actions", "area: dependencies"],
+      "matchPackageNames": [
+        "*"
+      ],
+      "matchUpdateTypes": [
+        "minor",
+        "patch"
+      ]
+    },
+    {
+      "matchManagers": ["npm", "nvm"],
+      "groupName": "Website",
+      "labels": ["lang: javascript", "area: dependencies"],
+      "matchPackageNames": [
+        "*"
+      ],
+      "matchUpdateTypes": [
+        "minor",
+        "patch"
+      ]
+    },
+    {
+      "matchManagers": ["gomod"],
+      "groupName": "golang",
+      "labels": ["lang: go", "area: dependencies"],
+      "matchPackageNames": [
+        "*"
+      ],
+      "matchUpdateTypes": [
+        "minor",
+        "patch"
+      ]
+    }
+  ]
+}

.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

@@ -6,19 +6,53 @@ on:
     tags:
       - v*
     branches:
-      - master
+      - main
 
 jobs:
   lint:
+    name: Lint
+    strategy:
+      matrix:
+        go-version: [1.22.x, 1.23.x]
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/setup-go@v3
+      - uses: actions/setup-go@v5
         with:
-          go-version: 1.18
+          go-version: ${{matrix.go-version}}
 
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
 
       - name: golangci-lint
-        uses: golangci/golangci-lint-action@v3
+        uses: golangci/golangci-lint-action@v6
         with:
-          version: v1.46.1
+          version: v1.60.1
+
+  lint-jsonschema:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/setup-python@v5
+        with:
+          python-version: 3.12
+
+      - uses: actions/checkout@v4
+
+      - 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
+  check_doc:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Get changed files in the docs folder
+        id: changed-files-specific
+        uses: tj-actions/changed-files@v44
+        with:
+          files: website/versioned_docs/**
+
+      - uses: actions/github-script@v7
+        if: steps.changed-files-specific.outputs.any_changed == 'true'
+        with:
+          script: |
+            core.setFailed('website/versioned_docs has changed. Instead you need to update the docs in the website/docs folder.')

.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@v3
+        uses: actions/checkout@v4
 
       - name: Set up Go
-        uses: actions/setup-go@v3
+        uses: actions/setup-go@v5
         with:
-          go-version: 1.18.x
+          go-version: 1.22.x
 
       - name: Run GoReleaser
         uses: goreleaser/goreleaser-action@v2
         with:
           version: latest
-          args: release --rm-dist
+          args: release --clean
         env:
           GITHUB_TOKEN: ${{secrets.GH_PAT}}

.github/workflows/test.yml

@@ -6,25 +6,25 @@ on:
     tags:
       - v*
     branches:
-      - master
+      - main
 
 jobs:
   test:
     name: Test
     strategy:
       matrix:
-        go-version: [1.17.x, 1.18.x]
+        go-version: [1.22.x, 1.23.x]
         platform: [ubuntu-latest, macos-latest, windows-latest]
     runs-on: ${{matrix.platform}}
     steps:
       - name: Set up Go ${{matrix.go-version}}
-        uses: actions/setup-go@v3
+        uses: actions/setup-go@v5
         with:
           go-version: ${{matrix.go-version}}
         id: go
 
       - name: Check out code into the Go module directory
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
 
       - name: Download Go modules
         run: go mod download

.github/workflows/website-deploy.yml

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

.github/workflows/website-test.yml

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

.gitignore

@@ -10,6 +10,9 @@
 # Output of the go coverage tool, specifically when used with LiteIDE
 *.out
 
+# Graphvis files
+*.gv
+
 # Project-local glide cache, RE: https://github.com/Masterminds/glide/issues/736
 .glide/
 
@@ -21,7 +24,8 @@ dist/
 
 # editors
 .idea/
-.vscode/
+.vscode/settings.json
+.fleet/
 
 # exuberant ctags
 tags
@@ -30,3 +34,4 @@ tags
 !/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,36 @@
-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.
+# yaml-language-server: $schema=https://goreleaser.com/static/schema.json
+version: 2
+
+builds:
+  - binary: task
+    main: ./cmd/task
+    goos:
+      - windows
+      - darwin
+      - linux
+      - freebsd
+    goarch:
+      - '386'
+      - amd64
+      - arm
+      - arm64
+      - riscv64
+    goarm:
+      - '6'
+    ignore:
+      - goos: darwin
+        goarch: '386'
+      - goos: darwin
+        goarch: riscv64
+      - goos: windows
+        goarch: riscv64
+    env:
+      - CGO_ENABLED=0
+    mod_timestamp: '{{ .CommitTimestamp }}'
+    flags:
+      - -trimpath
+    ldflags:
+      - -s -w # Don't set main.version.
 
 gomod:
   proxy: true
@@ -37,7 +49,7 @@ release:
   draft: true
 
 snapshot:
-  name_template: "{{.Tag}}"
+  version_template: "{{.Tag}}"
 
 checksum:
   name_template: "task_checksums.txt"
@@ -67,8 +79,8 @@ brews:
     description: Task runner / simpler Make alternative written in Go
     license: MIT
     homepage: https://taskfile.dev
-    folder: Formula
-    tap:
+    directory: Formula
+    repository:
       owner: go-task
       name: homebrew-tap
     test:
@@ -81,3 +93,41 @@ brews:
     commit_author:
       name: task-bot
       email: 106601941+task-bot@users.noreply.github.com
+
+winget:
+  - name: Task
+    publisher: Task
+    short_description: A task runner / simpler Make alternative written in Go
+    description: Task is a task runner / build tool that aims to be simpler and easier to use than, for example, GNU Make.
+    license: MIT
+    homepage: https://taskfile.dev/
+    publisher_url: https://taskfile.dev/
+    publisher_support_url: https://github.com/go-task/task/issues
+    package_identifier: Task.Task
+    commit_author:
+      name: task-bot
+      email: 106601941+task-bot@users.noreply.github.com
+    commit_msg_template: "chore: bump {{.PackageIdentifier}} to {{.Tag}}"
+    release_notes_url: https://github.com/go-task/task/releases/tag/{{.Tag}}
+    tags:
+      - build
+      - build-tool
+      - devops
+      - go
+      - make
+      - makefile
+      - runner
+      - task
+      - task-runner
+      - taskfile
+      - tool
+    skip_upload: true
+    repository:
+      owner: microsoft
+      name: winget-pkgs
+      pull_request:
+        enabled: true
+        base:
+          owner: go-task
+          name: winget-pkgs
+          branch: "bump-task-to-{{.Tag}}"

.mockery.yaml

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

.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/extensions.json

@@ -0,0 +1,7 @@
+{
+  "recommendations": [
+    "editorconfig.editorconfig",
+    "golang.go",
+    "task.vscode-task"
+  ]
+}

.vscode/settings-sample.json

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

README.md

@@ -1,6 +1,6 @@
 <div align="center">
   <a href="https://taskfile.dev">
-    <img src="docs/static/img/logo.svg" width="200px" height="200px" />
+    <img src="website/static/img/logo.svg" width="200px" height="200px" />
   </a>
 
   <h1>Task</h1>
@@ -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'
@@ -23,10 +20,34 @@ tasks:
 
   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 Mockery 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
@@ -36,51 +57,130 @@ tasks:
 
   clean:
     desc: Cleans temp files and folders
+    aliases: [clear]
     cmds:
       - rm -rf dist/
       - rm -rf tmp/
 
   lint:
     desc: Runs golangci-lint
+    aliases: [l]
     sources:
       - './**/*.go'
+      - .golangci.yml
     cmds:
       - golangci-lint run
 
+  lint:fix:
+    desc: Runs golangci-lint and fixes any issues
+    sources:
+      - './**/*.go'
+      - .golangci.yml
+    cmds:
+      - golangci-lint run --fix
+
   sleepit:build:
     desc: Builds the sleepit test helper
     sources:
       - ./cmd/sleepit/**/*.go
     generates:
-      - ./bin/sleepit
+      - "{{.BIN}}/sleepit"
     cmds:
-      - go build -o ./bin/sleepit{{exeExt}} ./cmd/sleepit
+      - go build -o {{.BIN}}/sleepit{{exeExt}} ./cmd/sleepit
 
   sleepit:run:
     desc: Builds the sleepit test helper
     deps: [sleepit:build]
     cmds:
-      - ./bin/sleepit {{.CLI_ARGS}}
+      - "{{.BIN}}/sleepit {{.CLI_ARGS}}"
     silent: true
 
   test:
     desc: Runs test suite
+    aliases: [t]
     deps: [install]
     cmds:
       - go test {{catLines .GO_PACKAGES}}
+    vars:
+      GO_PACKAGES:
+        sh: go list ./...
 
-  test:signals:
-    desc: Runs test suite with signals tests included
+  test:all:
+    desc: Runs test suite with signals and watch tests included
     deps: [install, sleepit:build]
     cmds:
-      - go test {{catLines .GO_PACKAGES}} -tags signals
+      - go test {{catLines .GO_PACKAGES}} -tags 'signals watch'
+    vars:
+      GO_PACKAGES:
+        sh: go list ./...
 
-  test-release:
+  goreleaser:test:
     desc: Tests release process without publishing
     cmds:
-      - goreleaser --snapshot --rm-dist
+      - goreleaser --snapshot --clean
+
+  goreleaser:install:
+    desc: Installs goreleaser
+    cmds:
+      - go install github.com/goreleaser/goreleaser@latest
+
+  release:*:
+    desc: Prepare the project for a new release
+    summary: |
+      This task will do the following:
+
+      - Update the version and date in the CHANGELOG.md file
+      - Update the version in the package.json and package-lock.json files
+      - Copy the latest docs to the "current" version on the website
+      - Commit the changes
+      - Create a new tag
+      - Push the commit/tag to the repository
+      - Create a GitHub release
+
+      To use the task, simply run "task release:<version>" where "<version>" is is one of:
+
+      - "major" - Bumps the major number
+      - "minor" - Bumps the minor number
+      - "patch" - Bumps the patch number
+      - A semver compatible version number (e.g. "1.2.3")
+    vars:
+      VERSION:
+        sh: "go run ./cmd/release --version {{index .MATCH 0}}"
+      COMPLETE_MESSAGE: |
+        Creating release with GoReleaser: https://github.com/go-task/task/actions/workflows/release.yml
+
+        Please wait for the CI to finish and then do the following:
+
+        - Copy the changelog for v{{.VERSION}} to the GitHub release
+        - Publish the package to NPM with `task npm:publish`
+        - Update and push the snapcraft manifest in https://github.com/go-task/snap/blob/main/snap/snapcraft.yaml
+    preconditions:
+      - sh: test $(git rev-parse --abbrev-ref HEAD) = "main"
+        msg: "You must be on the main branch to release"
+      - sh: "[[ -z $(git diff --shortstat main) ]]"
+        msg: "You must have a clean working tree to release"
+    prompt: "Are you sure you want to release version {{.VERSION}}?"
+    cmds:
+      - cmd: echo "Releasing v{{.VERSION}}"
+        silent: true
+      - "go run ./cmd/release {{.VERSION}}"
+      - "git add --all"
+      - "git commit -m v{{.VERSION}}"
+      - "git push"
+      - "git tag v{{.VERSION}}"
+      - "git push origin tag v{{.VERSION}}"
+      - cmd: printf "%s" '{{.COMPLETE_MESSAGE}}'
+        silent: true
+
+  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,168 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"regexp"
+	"strings"
+	"time"
+
+	"github.com/Masterminds/semver/v3"
+	"github.com/otiai10/copy"
+	"github.com/spf13/pflag"
+)
+
+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+",$`)
+)
+
+// Flags
+var (
+	versionFlag bool
+)
+
+func init() {
+	pflag.BoolVarP(&versionFlag, "version", "v", false, "resolved version number")
+	pflag.Parse()
+}
+
+func main() {
+	if err := release(); err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+}
+
+func release() error {
+	if len(pflag.Args()) != 1 {
+		return errors.New("error: expected version number")
+	}
+
+	version, err := getVersion()
+	if err != nil {
+		return err
+	}
+
+	if err := bumpVersion(version, pflag.Arg(0)); err != nil {
+		return err
+	}
+
+	if versionFlag {
+		fmt.Println(version)
+		return nil
+	}
+
+	if err := changelog(version); err != nil {
+		return err
+	}
+
+	if err := setJSONVersion("package.json", version); err != nil {
+		return err
+	}
+
+	if err := setJSONVersion("package-lock.json", version); err != nil {
+		return err
+	}
+
+	if err := docs(); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func getVersion() (*semver.Version, error) {
+	cmd := exec.Command("git", "describe", "--tags", "--abbrev=0")
+	b, err := cmd.Output()
+	if err != nil {
+		return nil, err
+	}
+
+	return semver.NewVersion(strings.TrimSpace(string(b)))
+}
+
+func bumpVersion(version *semver.Version, verb string) error {
+	switch verb {
+	case "major":
+		*version = version.IncMajor()
+	case "minor":
+		*version = version.IncMinor()
+	case "patch":
+		*version = version.IncPatch()
+	default:
+		*version = *semver.MustParse(verb)
+	}
+	return nil
+}
+
+func changelog(version *semver.Version) error {
+	// Open changelog target file
+	b, err := os.ReadFile(changelogTarget)
+	if err != nil {
+		return err
+	}
+
+	// Get the current frontmatter
+	currentChangelog := string(b)
+	sections := strings.SplitN(currentChangelog, "---", 3)
+	if len(sections) != 3 {
+		return errors.New("error: invalid frontmatter")
+	}
+	frontmatter := strings.TrimSpace(sections[1])
+
+	// Open changelog source file
+	b, err = os.ReadFile(changelogSource)
+	if err != nil {
+		return err
+	}
+	changelog := string(b)
+	date := time.Now().Format("2006-01-02")
+
+	// Replace "Unreleased" with the new version and date
+	changelog = changelogReleaseRegex.ReplaceAllString(changelog, fmt.Sprintf("## v%s - %s", version, date))
+
+	// Write the changelog to the source file
+	if err := os.WriteFile(changelogSource, []byte(changelog), 0o644); err != nil {
+		return err
+	}
+
+	// Add the frontmatter to the changelog
+	changelog = fmt.Sprintf("---\n%s\n---\n\n%s", frontmatter, changelog)
+
+	// Write the changelog to the target file
+	return os.WriteFile(changelogTarget, []byte(changelog), 0o644)
+}
+
+func setJSONVersion(fileName string, version *semver.Version) error {
+	// Read the JSON file
+	b, err := os.ReadFile(fileName)
+	if err != nil {
+		return err
+	}
+
+	// Replace the version
+	new := versionRegex.ReplaceAllString(string(b), fmt.Sprintf(`  "version": "%s",`, version.String()))
+
+	// Write the JSON file
+	return os.WriteFile(fileName, []byte(new), 0o644)
+}
+
+func docs() error {
+	if err := os.RemoveAll(docsTarget); err != nil {
+		return err
+	}
+	if err := copy.Copy(docsSource, docsTarget); err != nil {
+		return err
+	}
+	return nil
+}

cmd/sleepit/sleepit.go

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

cmd/task/task.go

@@ -3,10 +3,7 @@ package main
 import (
 	"context"
 	"fmt"
-	"log"
 	"os"
-	"path/filepath"
-	"runtime/debug"
 	"strings"
 
 	"github.com/spf13/pflag"
@@ -14,217 +11,206 @@ import (
 
 	"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/internal/sort"
+	ver "github.com/go-task/task/v3/internal/version"
 	"github.com/go-task/task/v3/taskfile"
+	"github.com/go-task/task/v3/taskfile/ast"
 )
 
-var (
-	version = ""
-)
-
-const usage = `Usage: task [-ilfwvsd] [--init] [--list] [--force] [--watch] [--verbose] [--silent] [--dir] [--taskfile] [--dry] [--summary] [task...]
-
-Runs the specified task(s). Falls back to the "default" task if no task name
-was specified, or lists all tasks if an unknown task name was specified.
-
-Example: 'task hello' with the following 'Taskfile.yml' file will generate an
-'output.txt' file with the content "hello".
-
-'''
-version: '3'
-tasks:
-  hello:
-    cmds:
-      - echo "I am going to write a file named 'output.txt' now."
-      - echo "hello" > output.txt
-    generates:
-      - output.txt
-'''
-
-Options:
-`
-
 func main() {
-	log.SetFlags(0)
-	log.SetOutput(os.Stderr)
+	if err := run(); err != nil {
+		l := &logger.Logger{
+			Stdout:  os.Stdout,
+			Stderr:  os.Stderr,
+			Verbose: flags.Verbose,
+			Color:   flags.Color,
+		}
+		if err, ok := err.(*errors.TaskRunError); ok && flags.ExitCode {
+			l.Errf(logger.Red, "%v\n", err)
+			os.Exit(err.TaskExitCode())
+		}
+		if err, ok := err.(errors.TaskError); ok {
+			l.Errf(logger.Red, "%v\n", err)
+			os.Exit(err.Code())
+		}
+		l.Errf(logger.Red, "%v\n", err)
+		os.Exit(errors.CodeUnknown)
+	}
+	os.Exit(errors.CodeOk)
+}
 
-	pflag.Usage = func() {
-		log.Print(usage)
-		pflag.PrintDefaults()
+func run() error {
+	logger := &logger.Logger{
+		Stdout:  os.Stdout,
+		Stderr:  os.Stderr,
+		Verbose: flags.Verbose,
+		Color:   flags.Color,
 	}
 
-	var (
-		versionFlag bool
-		helpFlag    bool
-		init        bool
-		list        bool
-		listAll     bool
-		status      bool
-		force       bool
-		watch       bool
-		verbose     bool
-		silent      bool
-		dry         bool
-		summary     bool
-		exitCode    bool
-		parallel    bool
-		concurrency int
-		dir         string
-		entrypoint  string
-		output      taskfile.Output
-		color       bool
-	)
-
-	pflag.BoolVar(&versionFlag, "version", false, "show Task version")
-	pflag.BoolVarP(&helpFlag, "help", "h", false, "shows Task usage")
-	pflag.BoolVarP(&init, "init", "i", false, "creates a new Taskfile.yaml in the current folder")
-	pflag.BoolVarP(&list, "list", "l", false, "lists tasks with description of current Taskfile")
-	pflag.BoolVarP(&listAll, "list-all", "a", false, "lists tasks with or without a description")
-	pflag.BoolVar(&status, "status", false, "exits with non-zero exit code if any of the given tasks is not up-to-date")
-	pflag.BoolVarP(&force, "force", "f", false, "forces execution even when the task is up-to-date")
-	pflag.BoolVarP(&watch, "watch", "w", false, "enables watch of the given task")
-	pflag.BoolVarP(&verbose, "verbose", "v", false, "enables verbose mode")
-	pflag.BoolVarP(&silent, "silent", "s", false, "disables echoing")
-	pflag.BoolVarP(&parallel, "parallel", "p", false, "executes tasks provided on command line in parallel")
-	pflag.BoolVarP(&dry, "dry", "n", false, "compiles and prints tasks in the order that they would be run, without executing them")
-	pflag.BoolVar(&summary, "summary", false, "show summary about a task")
-	pflag.BoolVarP(&exitCode, "exit-code", "x", false, "pass-through the exit code of the task command")
-	pflag.StringVarP(&dir, "dir", "d", "", "sets directory of execution")
-	pflag.StringVarP(&entrypoint, "taskfile", "t", "", `choose which Taskfile to run. Defaults to "Taskfile.yml"`)
-	pflag.StringVarP(&output.Name, "output", "o", "", "sets output style: [interleaved|group|prefixed]")
-	pflag.StringVar(&output.Group.Begin, "output-group-begin", "", "message template to print before a task's grouped output")
-	pflag.StringVar(&output.Group.End, "output-group-end", "", "message template to print after a task's grouped output")
-	pflag.BoolVarP(&color, "color", "c", true, "colored output. Enabled by default. Set flag to false or use NO_COLOR=1 to disable")
-	pflag.IntVarP(&concurrency, "concurrency", "C", 0, "limit number tasks to run concurrently")
-	pflag.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.GetVersionWithSum())
+		return nil
+	}
+
+	if flags.Help {
 		pflag.Usage()
-		return
+		return nil
 	}
 
-	if init {
+	if flags.Experiments {
+		return experiments.List(logger)
+	}
+
+	if flags.Init {
 		wd, err := os.Getwd()
 		if err != nil {
-			log.Fatal(err)
+			return err
 		}
 		if err := task.InitTaskfile(os.Stdout, wd); err != nil {
-			log.Fatal(err)
+			return err
 		}
-		return
+		return nil
 	}
 
-	if dir != "" && entrypoint != "" {
-		log.Fatal("task: You can't set both --dir and --taskfile")
-		return
-	}
-	if entrypoint != "" {
-		dir = filepath.Dir(entrypoint)
-		entrypoint = filepath.Base(entrypoint)
+	if flags.Completion != "" {
+		script, err := task.Completion(flags.Completion)
+		if err != nil {
+			return err
+		}
+		fmt.Println(script)
+		return nil
 	}
 
-	if output.Name != "group" {
-		if output.Group.Begin != "" {
-			log.Fatal("task: You can't set --output-group-begin without --output=group")
-			return
-		}
-		if output.Group.End != "" {
-			log.Fatal("task: You can't set --output-group-end without --output=group")
-			return
+	if flags.Global {
+		home, err := os.UserHomeDir()
+		if err != nil {
+			return fmt.Errorf("task: Failed to get user home directory: %w", err)
 		}
+		dir = home
+	}
+
+	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,
+		OutputStyle: flags.Output,
+		TaskSorter:  taskSorter,
+	}
+	listOptions := task.NewListOptions(flags.List, flags.ListAll, flags.ListJson, flags.NoStatus)
+	if err := listOptions.Validate(); err != nil {
+		return err
 	}
 
-	if (list || listAll) && silent {
-		e.ListTaskNames(listAll)
-		return
-	}
-
-	if err := e.Setup(); err != nil {
-		log.Fatal(err)
-	}
-	v, err := e.Taskfile.ParsedVersion()
+	err := e.Setup()
 	if err != nil {
-		log.Fatal(err)
-		return
+		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 list {
-		e.ListTasksWithDesc()
-		return
+	// If the download flag is specified, we should stop execution as soon as
+	// taskfile is downloaded
+	if flags.Download {
+		return nil
 	}
 
-	if listAll {
-		e.ListAllTasks()
-		return
+	if flags.ClearCache {
+		cache, err := taskfile.NewCache(e.TempDir.Remote)
+		if err != nil {
+			return err
+		}
+		return cache.Clear()
+	}
+
+	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})
+	globals.Set("CLI_SILENT", ast.Var{Value: flags.Silent})
+	globals.Set("CLI_VERBOSE", ast.Var{Value: flags.Verbose})
+	e.Taskfile.Vars.Merge(globals, nil)
 
-	if !watch {
+	if !flags.Watch {
 		e.InterceptInterruptSignals()
 	}
 
 	ctx := context.Background()
 
-	if status {
-		if err := e.Status(ctx, calls...); err != nil {
-			log.Fatal(err)
-		}
-		return
+	if flags.Status {
+		return e.Status(ctx, calls...)
 	}
 
-	if err := e.Run(ctx, calls...); err != nil {
-		e.Logger.Errf(logger.Red, "%v", err)
-
-		if exitCode {
-			if err, ok := err.(*task.TaskRunError); ok {
-				os.Exit(err.ExitCode())
-			}
-		}
-		os.Exit(1)
-	}
+	return e.Run(ctx, calls...)
 }
 
 func getArgs() ([]string, string, error) {
@@ -247,21 +233,3 @@ func getArgs() ([]string, string, error) {
 	}
 	return args[:doubleDashPos], strings.Join(quotedCliArgs, " "), nil
 }
-
-func getVersion() string {
-	if version != "" {
-		return version
-	}
-
-	info, ok := debug.ReadBuildInfo()
-	if !ok || info.Main.Version == "" {
-		return "unknown"
-	}
-
-	version = info.Main.Version
-	if info.Main.Sum != "" {
-		version += fmt.Sprintf(" (%s)", info.Main.Sum)
-	}
-
-	return version
-}

completion.go

@@ -0,0 +1,34 @@
+package task
+
+import (
+	_ "embed"
+	"fmt"
+)
+
+//go:embed completion/bash/task.bash
+var completionBash string
+
+//go:embed completion/fish/task.fish
+var completionFish string
+
+//go:embed completion/ps/task.ps1
+var completionPowershell string
+
+//go:embed completion/zsh/_task
+var completionZsh string
+
+func Completion(completion string) (string, error) {
+	// Get the file extension for the selected shell
+	switch completion {
+	case "bash":
+		return completionBash, nil
+	case "fish":
+		return completionFish, nil
+	case "powershell":
+		return completionPowershell, nil
+	case "zsh":
+		return completionZsh, nil
+	default:
+		return "", fmt.Errorf("unknown shell: %s", completion)
+	}
+}

completion/bash/task.bash

@@ -1,26 +1,55 @@
-#!/bin/bash
+# vim: set tabstop=2 shiftwidth=2 expandtab:
 
-GO_TASK_PROGNAME=task
+_GO_TASK_COMPLETION_LIST_OPTION='--list-all'
 
-_go_task_completion()
+function _task()
 {
-  local cur
-  _get_comp_words_by_ref -n : cur
+  local cur prev words cword
+  _init_completion -n : || return
 
-  case "$cur" in
-  --*)
-    local options
-    options="$(_parse_help task)"
-    mapfile -t COMPREPLY < <(compgen -W "$options" -- "$cur")
+  # 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
+
+  # Handle special arguments of options.
+  case "$prev" in
+    -d|--dir)
+      _filedir -d
+      return $?
     ;;
-  *)
-    local tasks
-    tasks="$($GO_TASK_PROGNAME --list-all 2> /dev/null | awk 'NR>1 { sub(/:$/,"",$2); print $2 }')"
-    mapfile -t COMPREPLY < <(compgen -W "$tasks" -- "$cur")
+    -t|--taskfile)
+      _filedir yaml || return $?
+      _filedir yml
+      return $?
+    ;;
+    -o|--output)
+      COMPREPLY=( $( compgen -W "interleaved group prefixed" -- $cur ) )
+      return 0
     ;;
   esac
 
+  # Handle normal options.
+  case "$cur" in
+    -*)
+      COMPREPLY=( $( compgen -W "$(_parse_help $1)" -- $cur ) )
+      return 0
+    ;;
+  esac
+
+  # Prepare task name completions.
+  local tasks=( $( "${words[@]}" --silent $_GO_TASK_COMPLETION_LIST_OPTION 2> /dev/null ) )
+  COMPREPLY=( $( compgen -W "${tasks[*]}" -- "$cur" ) )
+
+  # Post-process because task names might contain colons.
   __ltrim_colon_completions "$cur"
 }
 
-complete -F _go_task_completion $GO_TASK_PROGNAME
+complete -F _task task

completion/fish/task.fish

@@ -1,16 +1,24 @@
 set GO_TASK_PROGNAME task
 
 function __task_get_tasks --description "Prints all available tasks with their description"
-	set -l output ($GO_TASK_PROGNAME --list-all | sed '1d; s/\* \(.*\):\s*\(.*\)/\1\t\2/' | string split0)
+  # 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\t\3/' -e 's/\* \(.*\):\s*\(.*\)/\1\t\2/'| string split0)
   if test $output
-      echo $output
+    echo $output
   end
 end
 
 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 $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'

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,8 +1,9 @@
 #compdef task
-
-local context state state_descr line
+compdef _task task
 typeset -A opt_args
 
+_GO_TASK_COMPLETION_LIST_OPTION="${GO_TASK_COMPLETION_LIST_OPTION:---list-all}"
+
 # Listing commands from Taskfile.yml
 function __task_list() {
     local -a scripts cmd
@@ -10,13 +11,15 @@ function __task_list() {
     local taskfile item task desc
 
     cmd=(task)
-    taskfile="${(v)opt_args[(i)-t|--taskfile]}"
+    taskfile=${(Qv)opt_args[(i)-t|--taskfile]}
+    taskfile=${taskfile//\~/$HOME}
+
 
     if [[ -n "$taskfile" && -f "$taskfile" ]]; then
         enabled=1
         cmd+=(--taskfile "$taskfile")
     else
-        for taskfile in Taskfile{,.dist}.{yaml,yml}; do
+        for taskfile in {T,t}askfile{,.dist}.{yaml,yml}; do
             if [[ -f "$taskfile" ]]; then
                 enabled=1
                 break
@@ -27,7 +30,7 @@ function __task_list() {
     (( enabled )) || return 0
 
     scripts=()
-    for item in "${(@)${(f)$("${cmd[@]}" --list)}[2,-1]#\* }"; do
+    for item in "${(@)${(f)$("${cmd[@]}" $_GO_TASK_COMPLETION_LIST_OPTION)}[2,-1]#\* }"; do
         task="${item%%:[[:space:]]*}"
         desc="${item##[^[:space:]]##[[:space:]]##}"
         scripts+=( "${task//:/\\:}:$desc" )
@@ -35,26 +38,33 @@ function __task_list() {
     _describe 'Task to run' scripts
 }
 
-_arguments \
-    '(-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.yaml]' \
-        '(-*)'{-h,--help}'[show help]' \
-        '(-*)--version[show version and exit]' \
-        '*: :__task_list'
+_task() {
+    _arguments \
+        '(-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'
+}
+
+# don't run the completion function when being source-ed or eval-ed
+if [ "$funcstack[1]" = "_task" ]; then
+    _task "$@"
+fi

docs/Taskfile.yml

@@ -1,29 +0,0 @@
-version: '3'
-
-tasks:
-  setup:
-    desc: Setup Docusaurus locally
-    cmds:
-      - yarn install
-
-  start:
-    desc: Start website
-    vars:
-      PORT: '{{default "3001" .PORT}}'
-    cmds:
-      - npx docusaurus start --no-open --port={{.PORT}}
-
-  build:
-    desc: Build website
-    cmds:
-      - npx docusaurus build
-
-  clean:
-    desc: Clean temp directories
-    cmds:
-      - rm -rf ./build
-
-  deploy:
-    desc: Build and deploy Docusaurus. Requires GIT_USER and GIT_PASS envs to be previous set
-    cmds:
-      - npx docusaurus deploy

docs/babel.config.js

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

docs/docs/api_reference.md

@@ -1,219 +0,0 @@
----
-slug: /api/
-sidebar_position: 4
----
-
-# API Reference
-
-## CLI
-
-Task command line tool has the following syntax:
-
-```bash
-task [--flags] [tasks...] [-- CLI_ARGS...]
-```
-
-:::tip
-
-If `--` is given, all remaning arguments will be assigned to a special `CLI_ARGS`
-variable
-
-:::
-
-| Short | Flag | Type | Default | Description |
-| - | - | - | - | - |
-| `-c` | `--color` | `bool` | `true` | Colored output. Enabled by default. Set flag to `false` or use `NO_COLOR=1` to disable. |
-| `-C` | `--concurrency` | `int` | `0` | Limit number tasks to run concurrently. Zero means unlimited. |
-| `-d` | `--dir` | `string` | Working directory | Sets directory of execution. |
-| `-n` | `--dry` | `bool` | `false` | Compiles and prints tasks in the order that they would be run, without executing them. |
-| `-x` | `--exit-code` | `bool` | `false` | Pass-through the exit code of the task command. |
-| `-f` | `--force` | `bool` | `false` | Forces execution even when the task is up-to-date. |
-| `-h` | `--help` | `bool` | `false` | Shows Task usage. |
-| `-i` | `--init` | `bool` | `false` | Creates a new Taskfile.yaml in the current folder. |
-| `-l` | `--list` | `bool` | `false` | Lists tasks with description of current Taskfile. |
-| `-a` | `--list-all` | `bool` | `false` | Lists tasks with or without a description. |
-| `-o` | `--output` | `string` | Default set in the Taskfile or `intervealed` | Sets output style: [`interleaved`/`group`/`prefixed`]. |
-|      | `--output-group-begin` | `string` | | Message template to print before a task's grouped output. |
-|      | `--output-group-end `  | `string` | | Message template to print after a task's grouped output. |
-| `-p` | `--parallel` | `bool` | `false` | Executes tasks provided on command line in parallel. |
-| `-s` | `--silent` | `bool` | `false` | Disables echoing. |
-|      | `--status` | `bool` | `false` | Exits with non-zero exit code if any of the given tasks is not up-to-date. |
-|      | `--summary` | `bool` | `false` | Show summary about a task. |
-| `-t` | `--taskfile` | `string` | `Taskfile.yml` or `Taskfile.yaml` | |
-| `-v` | `--verbose` | `bool` | `false` | Enables verbose mode. |
-|      | `--version` | `bool` | `false` | Show Task version. |
-| `-w` | `--watch` | `bool` | `false` | Enables watch of the given task. |
-
-## ENV
-
-Some environment variables can be overriden to adjust Task behavior.
-
-| ENV | Default | Description |
-| - | - | - |
-| `TASK_TEMP_DIR` | `.task` | Location of the temp dir. Can relative to the project like `tmp/task` or absolute like `/tmp/.task` or `~/.task`. |
-| `TASK_COLOR_RESET` | `0` | Color used for white. |
-| `TASK_COLOR_BLUE` | `34` | Color used for blue. |
-| `TASK_COLOR_GREEN` | `32` | Color used for green. |
-| `TASK_COLOR_CYAN` | `36` | Color used for cyan. |
-| `TASK_COLOR_YELLOW` | `33` | Color used for yellow. |
-| `TASK_COLOR_MAGENTA` | `35` | Color used for magenta. |
-| `TASK_COLOR_RED` | `31` | Color used for red. |
-
-## Schema
-
-### Taskfile
-
-| Attribute | Type | Default | Description |
-| - | - | - | - |
-| `version` | `string` | | Version of the Taskfile. The current version is `3`. |
-| `includes` | [`map[string]Include`](#include) | | Additional Taskfiles to be included. |
-| `output` | `string` | `interleaved` | Output mode. Available options: `interleaved`, `group` and `prefixed`. |
-| `method` | `string` | `checksum` | Default method in this Taskfile. Can be overriden in a task by task basis. Available options: `checksum`, `timestamp` and `none`. |
-| `silent` | `bool` | `false` | Default "silent" options for this Taskfile. If `false`, can be overidden with `true` in a task by task basis. |
-| `run` | `string` | `always` | Default "run" option for this Taskfile. Available options: `always`, `once` and `when_changed`. |
-| `vars` | [`map[string]Variable`](#variable) | | Global variables. |
-| `env` | [`map[string]Variable`](#variable) | | Global environment. |
-| `dotenv` | `[]string` | | A list of `.env` file paths to be parsed. |
-| `tasks` | [`map[string]Task`](#task) | | The task definitions. |
-
-
-### Include
-
-| Attribute | Type | Default | Description |
-| - | - | - | - |
-| `taskfile` | `string` | | The path for the Taskfile or directory to be included. If a directory, Task will look for files named `Taskfile.yml` or `Taskfile.yaml` inside that directory. |
-| `dir` | `string` | The parent Taskfile directory | The working directory of the included tasks when run. |
-| `optional` | `bool` | `false` | If `true`, no errors will be thrown if the specified file does not exist. |
-
-:::info
-
-Informing only a string like below is equivalent to setting that value to the `taskfile` attribute.
-
-```yaml
-includes:
-  foo: ./path
-```
-
-:::
-
-### Task
-
-| Attribute | Type | Default | Description |
-| - | - | - | - |
-| `desc` | `string` | | A short description of the task. This is listed when calling `task --list`. |
-| `summary` | `string` | | A longer description of the task. This is listed when calling `task --summary [task]`. |
-| `sources` | `[]string` | | List of sources to check before running this task. Relevant for `checksum` and `timestamp` methods. Can be file paths or star globs. |
-| `dir` | `string` | | The current directory which this task should run. |
-| `method` | `string` | `checksum` | Method used by this task. Default to the one declared globally or `checksum`. Available options: `checksum`, `timestamp` and `none` |
-| `silent` | `bool` | `false` | Skips some output for this task. Note that STDOUT and STDERR of the commands will still be redirected. |
-| `run` | `string` | The one declared globally in the Taskfile or `always` | Specifies whether the task should run again or not if called more than once. Available options: `always`, `once` and `when_changed`. |
-| `prefix` | `string` | | Allows to override the prefix print before the STDOUT. Only relevant when using the `prefixed` output mode. |
-| `ignore_error` | `bool` | `false` | Continue execution if errors happen while executing the commands. |
-| `generates` | `[]string` | | List of files meant to be generated by this task. Relevant for `timestamp` method. Can be file paths or star globs. |
-| `status` | `[]string` | | List of commands to check if this task should run. The task is skipped otherwise. This overrides `method`, `sources` and `generates`. |
-| `preconditions` | [`[]Precondition`](#precondition) | | List of commands to check if this task should run. The task errors otherwise. |
-| `vars` | [`map[string]Variable`](#variable) | | Task variables. |
-| `env` | [`map[string]Variable`](#variable) | | Task environment. |
-| `deps` | [`[]Dependency`](#dependency) | | List of dependencies of this task. |
-| `cmds` | [`[]Command`](#command) | | List of commands to be executed. |
-
-:::info
-
-These alternative syntaxes are available. They will set the given values to
-`cmds` and everything else will be set to their default values:
-
-```yaml
-tasks:
-  foo: echo "foo"
-
-  foobar:
-    - echo "foo"
-    - echo "bar"
-```
-
-:::
-
-### Dependency
-
-| Attribute | Type | Default | Description |
-| - | - | - | - |
-| `task` | `string` | | The task to be execute as a dependency. |
-| `vars` | [`map[string]Variable`](#variable) | | Optional additional variables to be passed to this task. |
-
-:::tip
-
-If you don't want to set additional variables, it's enough to declare the
-dependency as a list of strings (they will be assigned to `task`):
-
-```yaml
-tasks:
-  foo:
-    deps: [foo, bar]
-```
-
-:::
-
-### Command
-
-| Attribute | Type | Default | Description |
-| - | - | - | - |
-| `cmd` | `string` | | The shell command to be executed. |
-| `defer` | `string` | | Alternative to `cmd`, but schedules the command to be executed at the end of this task instead of immediately. This cannot be used together with `cmd`. |
-| `silent` | `bool` | `false` | Skips some output for this command. Note that STDOUT and STDERR of the commands will still be redirected. |
-| `ignore_error` | `bool` | `false` | Continue execution if errors happen while executing the command. |
-| `task` | `string` | | Set this to trigger execution of another task instead of running a command. This cannot be set together with `cmd`. |
-| `vars` | [`map[string]Variable`](#variable) | | Optional additional variables to be passed to the referenced task. Only relevant when setting `task` instead of `cmd`. |
-
-:::info
-
-If given as a a string, the value will be assigned to `cmd`:
-
-```yaml
-tasks:
-  foo:
-    cmds:
-      - echo "foo"
-      - echo "bar"
-```
-
-:::
-
-### Variable
-
-| Attribute | Type | Default | Description |
-| - | - | - | - |
-| *itself* | `string` | | A static value that will be set to the variable. |
-| `sh` | `string` | | A shell command. The output (`STDOUT`) will be assigned to the variable. |
-
-:::info
-
-Static and dynamic variables have different syntaxes, like below:
-
-```yaml
-vars:
-  STATIC: static
-  DYNAMIC:
-    sh: echo "dynamic"
-```
-
-:::
-
-### Precondition
-
-| Attribute | Type | Default | Description |
-| - | - | - | - |
-| `sh` | `string` | | Command to be executed. If a non-zero exit code is returned, the task errors without executing its commands. |
-| `msg` | `string` | | Optional message to print if the precondition isn't met. |
-
-:::tip
-
-If you don't want to set a different message, you can declare a precondition
-like this and the value will be assigned to `sh`:
-
-```yaml
-tasks:
-  foo:
-    precondition: test -f Taskfile.yml
-```
-
-:::

docs/docs/changelog.md

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

docs/docs/community.md

@@ -1,63 +0,0 @@
----
-slug: /community/
-sidebar_position: 6
----
-
-# 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).
-
-### IntelliJ plugin
-
-There's a JetBrains IntelliJ plugin done by
-[@lechuckroh](https://github.com/lechuckroh), which has its code [here](https://github.com/lechuckroh/task-intellij-plugin)
-and is published [here](https://plugins.jetbrains.com/plugin/17058-taskfile).
-
-## Installation methods
-
-Some installation methods are maintained by third party:
-
-- [GitHub Actions](https://github.com/arduino/setup-task)
-  by [@arduino](https://github.com/arduino)
-- [AUR](https://aur.archlinux.org/packages/taskfile-git)
-  by [@kovetskiy](https://github.com/kovetskiy)
-- [Scoop](https://github.com/lukesampson/scoop-extras/blob/master/bucket/task.json)
-- [Fedora](https://packages.fedoraproject.org/pkgs/golang-github-task/go-task/)
-- [NixOS](https://github.com/NixOS/nixpkgs/blob/master/pkgs/development/tools/go-task/default.nix)
-
-## More
-
-Also, thanks for all the [code contributors](https://github.com/go-task/task/graphs/contributors),
-[financial contributors](https://opencollective.com/task), all those who
-[reported bugs](https://github.com/go-task/task/issues?q=is%3Aissue) and
-[answered questions](https://github.com/go-task/task/discussions).
-
-If you know something that is missing in this document, please submit a
-pull request.

docs/docs/installation.md

@@ -1,177 +0,0 @@
----
-slug: /installation/
-sidebar_position: 2
----
-
-# Installation
-
-Task offers many installation methods. Check out the available methods below.
-
-## Package Managers
-
-### 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
-```
-
-### Chocolatey
-
-If you're on Windows and have [Chocolatey][choco] installed, getting
-Task is as simple as running:
-
-```bash
-choco install go-task
-```
-
-This installation method is community owned.
-
-
-### Scoop
-
-If you're on Windows and have [Scoop][scoop] installed, getting
-Task is as simple as running:
-
-```cmd
-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.
-
-### Fedora
-
-If you're on Fedora Linux you can install Task from the official
-[Fedora](https://packages.fedoraproject.org/pkgs/golang-github-task/go-task/) repository using `dnf`:
-
-```cmd
-sudo dnf install go-task
-```
-
-This installation method is community owned. After a new release of Task, it
-may take some time until it's available in [Fedora](https://packages.fedoraproject.org/pkgs/golang-github-task/go-task/).
-
-### Nix
-
-If you're on NixOS or have Nix installed
-you can install Task from [nixpkgs](https://github.com/NixOS/nixpkgs):
-
-```cmd
-nix-env -iA nixpkgs.go-task
-```
-
-This installation method is community owned. After a new release of Task, it
-may take some time until it's available in [nixpkgs](https://github.com/NixOS/nixpkgs).
-
-## Get The Binary
-
-### 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
-
-```
-
-:::info
-
-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.
-
-## Build From Source
-
-### 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
-```
-
-:::tip
-
-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.
-
-:::
-
-[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
-[choco]: https://chocolatey.org/
-[scoop]: https://scoop.sh/

docs/docs/releasing.md

@@ -1,51 +0,0 @@
----
-slug: /releasing/
-sidebar_position: 7
----
-
-# Releasing
-
-The release process of Task is done with the help of
-[GoReleaser][goreleaser]. You can test the release process locally by calling
-the `test-release` task of the Taskfile.
-
-[GitHub Actions](https://github.com/go-task/task/actions) should release
-artifacts automatically when a new Git tag is pushed to master
-(raw executables and DEB and RPM packages).
-
-# 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 `amd64`, `armhf` and `arm64` 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.
-
-# Nix
-
-Nix is a community owned installation method. Nix package maintainers usually take care
-of updating versions there by editing
-[this file](https://github.com/NixOS/nixpkgs/blob/nixos-unstable/pkgs/development/tools/go-task/default.nix).
-If you think its Task version is outdated, open an issue to let us know.
-
-[goreleaser]: https://goreleaser.com/
-[homebrewtap]: https://github.com/go-task/homebrew-tap
-[gotaskrb]: https://github.com/go-task/homebrew-tap/blob/master/Formula/go-task.rb
-[snappackage]: https://github.com/go-task/snap
-[snapcraftyaml]: https://github.com/go-task/snap/blob/master/snap/snapcraft.yaml#L2
-[snapcraftdashboard]: https://snapcraft.io/task/releases

docs/docs/taskfile_versions.md

@@ -1,230 +0,0 @@
----
-slug: /taskfile-versions/
-sidebar_position: 8
----
-
-# Taskfile Versions
-
-The Taskfile syntax and features changed with time. This document explains what
-changed on each version and how to upgrade your Taskfile.
-
-## What the Taskfile version mean
-
-The Taskfile version follows the Task version. E.g. the change to Taskfile
-version `2` means that Task `v2.0.0` should be release to support it.
-
-The `version:` key on Taskfile accepts a semver string, so either `2`, `2.0` or
-`2.0.0` is accepted. If you choose to use `2.0` Task will not enable future
-`2.1` features, but if you choose to use `2`, then any `2.x.x` features will be
-available, but not `3.0.0+`.
-
-## Version 1
-
-> NOTE: Taskfiles in version 1 are not supported on Task >= v3.0.0 anymore.
-
-In the first version of the `Taskfile`, the `version:` key was not available,
-because the tasks was in the root of the YAML document. Like this:
-
-```yaml
-echo:
-  cmds:
-    - echo "Hello, World!"
-```
-
-The variable priority order was also different:
-
-1. Call variables
-2. Environment
-3. Task variables
-4. `Taskvars.yml` variables
-
-## Version 2.0
-
-At version 2, we introduced the `version:` key, to allow us to evolve Task
-with new features without breaking existing Taskfiles. The new syntax is as
-follows:
-
-```yaml
-version: '2'
-
-tasks:
-  echo:
-    cmds:
-      - echo "Hello, World!"
-```
-
-Version 2 allows you to write global variables directly in the Taskfile,
-if you don't want to create a `Taskvars.yml`:
-
-```yaml
-version: '2'
-
-vars:
-  GREETING: Hello, World!
-
-tasks:
-  greet:
-    cmds:
-      - echo "{{.GREETING}}"
-```
-
-The variable priority order changed to the following:
-
-1. Task variables
-2. Call variables
-3. Taskfile variables
-4. Taskvars file variables
-5. Environment variables
-
-A new global option was added to configure the number of variables expansions
-(which default to 2):
-
-```yaml
-version: '2'
-
-expansions: 3
-
-vars:
-  FOO: foo
-  BAR: bar
-  BAZ: baz
-  FOOBAR: "{{.FOO}}{{.BAR}}"
-  FOOBARBAZ: "{{.FOOBAR}}{{.BAZ}}"
-
-tasks:
-  default:
-    cmds:
-      - echo "{{.FOOBARBAZ}}"
-```
-
-## Version 2.1
-
-Version 2.1 includes a global `output` option, to allow having more control
-over how commands output are printed to the console
-(see [documentation][output] for more info):
-
-```yaml
-version: '2'
-
-output: prefixed
-
-tasks:
-  server:
-    cmds:
-      - go run main.go
-  prefix: server
-```
-
-From this version it's also possible to ignore errors of a command or task
-(check documentation [here][ignore_errors]):
-
-```yaml
-version: '2'
-
-tasks:
-  example-1:
-    cmds:
-      - cmd: exit 1
-        ignore_error: true
-      - echo "This will be print"
-
-  example-2:
-    cmds:
-      - exit 1
-      - echo "This will be print"
-    ignore_error: true
-```
-
-## Version 2.2
-
-Version 2.2 comes with a global `includes` options to include other
-Taskfiles:
-
-```yaml
-version: '2'
-
-includes:
-  docs: ./documentation # will look for ./documentation/Taskfile.yml
-  docker: ./DockerTasks.yml
-```
-
-## Version 2.6
-
-Version 2.6 comes with `preconditions` stanza in tasks.
-
-```yaml
-version: '2'
-
-tasks:
-  upload_environment:
-    preconditions:
-      - test -f .env
-    cmds:
-      - aws s3 cp .env s3://myenvironment
-```
-
-Please check the [documentation][includes]
-
-[output]: usage.md#output-syntax
-[ignore_errors]: usage.md#ignore-errors
-[includes]: usage.md#including-other-taskfiles
-
-## Version 3
-
-These are some major changes done on `v3`:
-
-- Task's output will now be colored
-- Added support for `.env` like files
-- Added `label:` setting to task so one can override how the task name
-  appear in the logs
-- A global `method:` was added to allow setting the default method,
-  and Task's default changed to `checksum`
-- Two magic variables were added when using `status:`: `CHECKSUM` and
-  `TIMESTAMP` which contains, respectively, the md5 checksum and greatest
-  modification timestamp of the files listed on `sources:`
-- Also, the `TASK` variable is always available with the current task name
-- CLI variables are always treated as global variables
-- Added `dir:` option to `includes` to allow choosing on which directory an
-  included Taskfile will run:
-
-```yaml
-includes:
-  docs:
-    taskfile: ./docs
-    dir: ./docs
-```
-
-- Implemented short task syntax. All below syntaxes are equivalent:
-
-```yaml
-version: '3'
-
-tasks:
-  print:
-    cmds:
-      - echo "Hello, World!"
-```
-
-```yaml
-version: '3'
-
-tasks:
-  print:
-    - echo "Hello, World!"
-```
-
-```yaml
-version: '3'
-
-tasks:
-  print: echo "Hello, World!"
-```
-
-- There was a major refactor on how variables are handled. They're now easier
-  to understand. The `expansions:` setting was removed as it became unncessary.
-  This is the order in which Task will process variables, each level can see
-  the variables set by the previous one and override those.
-  - Environment variables
-  - Global + CLI variables
-  - Call variables
-  - Task variables

docs/docusaurus.config.js

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

docs/prettier.config.js

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

docs/sidebars.js

@@ -1,14 +0,0 @@
-// @ts-check
-
-/** @type {import('@docusaurus/plugin-content-docs').SidebarsConfig} */
-const sidebars = {
-  tutorialSidebar: [
-    { type: 'autogenerated', dirName: '.' },
-    {
-      type: 'html',
-      value: '<div id="sidebar-ads"></div>'
-    }
-  ]
-};
-
-module.exports = sidebars;

docs/src/css/custom.css

@@ -1,31 +0,0 @@
-:root {
-  --ifm-color-primary: #43ABA2 ;
-  --ifm-color-primary-dark: #3AB2A6;
-  --ifm-color-primary-darker: #32B8AB;
-  --ifm-color-primary-darkest: #29BEB0;
-  --ifm-color-primary-light: #4CA59D;
-  --ifm-color-primary-lighter: #559F98;
-  --ifm-color-primary-lightest: #5D9993;
-  --ifm-code-font-size: 95%;
-  --docusaurus-highlighted-code-line-bg: rgba(0, 0, 0, 0.1);
-}
-
-[data-theme='dark'] {
-  --ifm-color-primary: #43ABA2 ;
-  --ifm-color-primary-dark: #3AB2A6;
-  --ifm-color-primary-darker: #32B8AB;
-  --ifm-color-primary-darkest: #29BEB0;
-  --ifm-color-primary-light: #4CA59D;
-  --ifm-color-primary-lighter: #559F98;
-  --ifm-color-primary-lightest: #5D9993;
-  --docusaurus-highlighted-code-line-bg: rgba(0, 0, 0, 0.3);
-}
-
-.code-block--max-width {
-  width: 100%;
-}
-
-#carbonads {
-  margin-top: 30px;
-  margin-right: 10px;
-}

docs/static/img/logo.svg

@@ -1,5 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 375 375" width="500" height="500">
-  <path fill="#29beb0" d="M 187.570312 190.933594 L 187.570312 375 L 30.070312 279.535156 L 30.070312 95.464844 Z"/>
-  <path fill="#69d2c8" d="M 187.570312 190.933594 L 187.570312 375 L 345.070312 279.535156 L 345.070312 95.464844 Z"/>
-  <path fill="#94dfd8" d="M 187.570312 190.933594 L 30.070312 95.464844 L 187.570312 0 L 345.070312 95.464844 Z"/>
-</svg>

docs/static/img/logo_mono.svg

@@ -1,3 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 375 375" width="500" height="500">
-  <path d="M 29.021972 281.445466 L 183.370289 375 L 183.370289 194.622441 L 29.021972 101.064089 Z M 345.978037 281.445466 L 345.978037 101.064079 L 191.629731 194.622431 L 191.629731 375 Z M 342.140723 93.731759 L 187.5 0 L 32.859297 93.731759 L 187.5 187.467349 Z"/>
-</svg>

docs/static/js/carbon.js

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

errors.go

@@ -1,53 +0,0 @@
-package task
-
-import (
-	"errors"
-	"fmt"
-
-	"mvdan.cc/sh/v3/interp"
-)
-
-var (
-	// ErrTaskfileAlreadyExists is returned on creating a Taskfile if one already exists
-	ErrTaskfileAlreadyExists = errors.New("task: A Taskfile already exists")
-)
-
-type taskNotFoundError struct {
-	taskName string
-}
-
-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)
-}
-
-func (err *TaskRunError) ExitCode() int {
-	if c, ok := interp.IsExitStatus(err.err); ok {
-		return int(c)
-	}
-
-	return 1
-}
-
-// MaximumTaskCallExceededError is returned when a task is called too
-// many times. In this case you probably have a cyclic dependendy or
-// infinite loop
-type MaximumTaskCallExceededError struct {
-	task string
-}
-
-func (e *MaximumTaskCallExceededError) Error() string {
-	return fmt.Sprintf(
-		`task: maximum task call exceeded (%d) for task "%s": probably an cyclic dep or infinite loop`,
-		MaximumTaskCall,
-		e.task,
-	)
-}

errors/error_taskfile_decode.go

@@ -0,0 +1,179 @@
+package errors
+
+import (
+	"bytes"
+	"embed"
+	"errors"
+	"fmt"
+	"regexp"
+	"strings"
+
+	"github.com/alecthomas/chroma/v2"
+	"github.com/alecthomas/chroma/v2/quick"
+	"github.com/alecthomas/chroma/v2/styles"
+	"github.com/fatih/color"
+	"gopkg.in/yaml.v3"
+)
+
+//go:embed themes/*.xml
+var embedded embed.FS
+
+var typeErrorRegex = regexp.MustCompile(`line \d+: (.*)`)
+
+func init() {
+	r, err := embedded.Open("themes/task.xml")
+	if err != nil {
+		panic(err)
+	}
+	style, err := chroma.NewXMLStyle(r)
+	if err != nil {
+		panic(err)
+	}
+	styles.Register(style)
+}
+
+type (
+	TaskfileDecodeError struct {
+		Message  string
+		Location string
+		Line     int
+		Column   int
+		Tag      string
+		Snippet  TaskfileSnippet
+		Err      error
+	}
+	TaskfileSnippet struct {
+		Lines     []string
+		StartLine int
+		EndLine   int
+		Padding   int
+	}
+)
+
+func NewTaskfileDecodeError(err error, node *yaml.Node) *TaskfileDecodeError {
+	// If the error is already a DecodeError, return it
+	taskfileInvalidErr := &TaskfileDecodeError{}
+	if errors.As(err, &taskfileInvalidErr) {
+		return taskfileInvalidErr
+	}
+	return &TaskfileDecodeError{
+		Line:   node.Line,
+		Column: node.Column,
+		Tag:    node.ShortTag(),
+		Err:    err,
+	}
+}
+
+func (err *TaskfileDecodeError) Error() string {
+	buf := &bytes.Buffer{}
+
+	// Print the error message
+	if err.Message != "" {
+		fmt.Fprintln(buf, color.RedString("err:  %s", err.Message))
+	} else {
+		// Extract the errors from the TypeError
+		te := &yaml.TypeError{}
+		if errors.As(err.Err, &te) {
+			if len(te.Errors) > 1 {
+				fmt.Fprintln(buf, color.RedString("errs:"))
+				for _, message := range te.Errors {
+					fmt.Fprintln(buf, color.RedString("- %s", extractTypeErrorMessage(message)))
+				}
+			} else {
+				fmt.Fprintln(buf, color.RedString("err:  %s", extractTypeErrorMessage(te.Errors[0])))
+			}
+		} else {
+			// Otherwise print the error message normally
+			fmt.Fprintln(buf, color.RedString("err:  %s", err.Err))
+		}
+	}
+	fmt.Fprintln(buf, color.RedString("file: %s:%d:%d", err.Location, err.Line, err.Column))
+
+	// Print the snippet
+	maxLineNumberDigits := digits(err.Snippet.EndLine)
+	lineNumberSpacer := strings.Repeat(" ", maxLineNumberDigits)
+	columnSpacer := strings.Repeat(" ", err.Column-1)
+	for i, line := range err.Snippet.Lines {
+		currentLine := err.Snippet.StartLine + i + 1
+
+		lineIndicator := " "
+		if currentLine == err.Line {
+			lineIndicator = ">"
+		}
+		columnIndicator := "^"
+
+		// Print each line
+		lineIndicator = color.RedString(lineIndicator)
+		columnIndicator = color.RedString(columnIndicator)
+		lineNumberFormat := fmt.Sprintf("%%%dd", maxLineNumberDigits)
+		lineNumber := fmt.Sprintf(lineNumberFormat, currentLine)
+		fmt.Fprintf(buf, "%s %s | %s", lineIndicator, lineNumber, line)
+
+		// Print the column indicator
+		if currentLine == err.Line {
+			fmt.Fprintf(buf, "\n  %s | %s%s", lineNumberSpacer, columnSpacer, columnIndicator)
+		}
+
+		// If there are more lines to print, add a newline
+		if i < len(err.Snippet.Lines)-1 {
+			fmt.Fprintln(buf)
+		}
+	}
+
+	return buf.String()
+}
+
+func (err *TaskfileDecodeError) Unwrap() error {
+	return err.Err
+}
+
+func (err *TaskfileDecodeError) Code() int {
+	return CodeTaskfileDecode
+}
+
+func (err *TaskfileDecodeError) WithMessage(format string, a ...any) *TaskfileDecodeError {
+	err.Message = fmt.Sprintf(format, a...)
+	return err
+}
+
+func (err *TaskfileDecodeError) WithTypeMessage(t string) *TaskfileDecodeError {
+	err.Message = fmt.Sprintf("cannot unmarshal %s into %s", err.Tag, t)
+	return err
+}
+
+func (err *TaskfileDecodeError) WithFileInfo(location string, b []byte, padding int) *TaskfileDecodeError {
+	buf := &bytes.Buffer{}
+	if err := quick.Highlight(buf, string(b), "yaml", "terminal", "task"); err != nil {
+		buf.WriteString(string(b))
+	}
+	lines := strings.Split(buf.String(), "\n")
+	start := max(err.Line-1-padding, 0)
+	end := min(err.Line+padding, len(lines)-1)
+
+	err.Location = location
+	err.Snippet = TaskfileSnippet{
+		Lines:     lines[start:end],
+		StartLine: start,
+		EndLine:   end,
+		Padding:   padding,
+	}
+
+	return err
+}
+
+func extractTypeErrorMessage(message string) string {
+	matches := typeErrorRegex.FindStringSubmatch(message)
+	if len(matches) == 2 {
+		return matches[1]
+	}
+	return message
+}
+
+func digits(number int) int {
+	count := 0
+	for number != 0 {
+		number /= 10
+		count += 1
+	}
+	return count
+}

errors/errors.go

@@ -0,0 +1,65 @@
+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
+	CodeTaskfileDecode
+	CodeTaskfileFetchFailed
+	CodeTaskfileNotTrusted
+	CodeTaskfileNotSecure
+	CodeTaskfileCacheNotFound
+	CodeTaskfileVersionCheckError
+	CodeTaskfileNetworkTimeout
+	CodeTaskfileInvalid
+	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)
+}
+
+// Unwrap wraps the standard errors.Unwrap function so that we don't need to alias that package.
+func Unwrap(err error) error {
+	return errors.Unwrap(err)
+}

errors/errors_task.go

@@ -0,0 +1,160 @@
+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
+}
+
+type TaskNameFlattenConflictError struct {
+	TaskName string
+	Include  string
+}
+
+func (err *TaskNameFlattenConflictError) Error() string {
+	return fmt.Sprintf(`task: Found multiple tasks (%s) included by "%s""`, err.TaskName, err.Include)
+}
+
+func (err *TaskNameFlattenConflictError) 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
+}

errors/themes/task.xml

@@ -0,0 +1,17 @@
+<style name="task">
+  <entry type="Background" style="bg:#eee8d5"/>
+  <entry type="Keyword" style="#859900"/>
+  <entry type="KeywordConstant" style=""/>
+  <entry type="KeywordNamespace" style="#dc322f"/>
+  <entry type="KeywordType" style=""/>
+  <entry type="Name" style="#268bd2"/>
+  <entry type="NameBuiltin" style="#cb4b16"/>
+  <entry type="NameClass" style="#cb4b16"/>
+  <entry type="NameTag" style=""/>
+  <entry type="Literal" style="#2aa198"/>
+  <entry type="LiteralNumber" style=""/>
+  <entry type="OperatorWord" style="#859900"/>
+  <entry type="Comment" style="italic #93a1a1"/>
+  <entry type="Generic" style="#d33682"/>
+  <entry type="Text" style="#586e75"/>
+</style>

go.mod

@@ -1,27 +1,39 @@
 module github.com/go-task/task/v3
 
+go 1.22.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/Ladicle/tabwriter v1.0.0
+	github.com/Masterminds/semver/v3 v3.3.0
+	github.com/alecthomas/chroma/v2 v2.14.0
+	github.com/davecgh/go-spew v1.1.1
+	github.com/dominikbraun/graph v0.23.0
+	github.com/fatih/color v1.17.0
+	github.com/go-task/slim-sprig/v3 v3.0.0
+	github.com/go-task/template v0.1.0
+	github.com/joho/godotenv v1.5.1
+	github.com/mattn/go-zglob v0.0.6
 	github.com/mitchellh/hashstructure/v2 v2.0.2
+	github.com/otiai10/copy v1.14.0
 	github.com/radovskyb/watcher v1.0.7
+	github.com/sajari/fuzzy v1.0.0
 	github.com/spf13/pflag v1.0.5
-	github.com/stretchr/testify v1.8.0
-	golang.org/x/sync v0.0.0-20210220032951-036812b2e83c
+	github.com/stretchr/testify v1.9.0
+	github.com/zeebo/xxh3 v1.0.2
+	golang.org/x/sync v0.8.0
+	golang.org/x/term v0.24.0
 	gopkg.in/yaml.v3 v3.0.1
-	mvdan.cc/sh/v3 v3.6.0-0.dev.0.20220704111049-a6e3029cd899
+	mvdan.cc/sh/v3 v3.9.0
 )
 
 require (
-	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/mattn/go-colorable v0.1.9 // indirect
-	github.com/mattn/go-isatty v0.0.14 // indirect
+	github.com/dlclark/regexp2 v1.11.0 // indirect
+	github.com/klauspost/cpuid/v2 v2.0.9 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
+	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/muesli/cancelreader v0.2.2 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
-	golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e // indirect
-	golang.org/x/term v0.0.0-20210927222741-03fcf44c2211 // indirect
+	github.com/stretchr/objx v0.5.2 // indirect
+	golang.org/x/sys v0.25.0 // indirect
 	gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 // indirect
 )
-
-go 1.17

go.sum

@@ -1,76 +1,86 @@
-github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
-github.com/creack/pty v1.1.17 h1:QeVUsEDNrLBW4tMgZHvxy18sKtr6VI492kBhUfhDJNI=
-github.com/creack/pty v1.1.17/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/Ladicle/tabwriter v1.0.0 h1:DZQqPvMumBDwVNElso13afjYLNp0Z7pHqHnu0r4t9Dg=
+github.com/Ladicle/tabwriter v1.0.0/go.mod h1:c4MdCjxQyTbGuQO/gvqJ+IA/89UEwrsD6hUCW98dyp4=
+github.com/Masterminds/semver/v3 v3.3.0 h1:B8LGeaivUe71a5qox1ICM/JLl0NqZSW5CHyL+hmvYS0=
+github.com/Masterminds/semver/v3 v3.3.0/go.mod h1:4V+yj/TJE1HU9XfppCwVMZq3I84lprf4nC11bSS5beM=
+github.com/alecthomas/assert/v2 v2.7.0 h1:QtqSACNS3tF7oasA8CU6A6sXZSBDqnm7RfpLl9bZqbE=
+github.com/alecthomas/assert/v2 v2.7.0/go.mod h1:Bze95FyfUr7x34QZrjL+XP+0qgp/zg8yS+TtBj1WA3k=
+github.com/alecthomas/chroma/v2 v2.14.0 h1:R3+wzpnUArGcQz7fCETQBzO5n9IMNi13iIs46aU4V9E=
+github.com/alecthomas/chroma/v2 v2.14.0/go.mod h1:QolEbTfmUHIMVpBqxeDnNBj2uoeI4EbYP4i6n68SG4I=
+github.com/alecthomas/repr v0.4.0 h1:GhI2A8MACjfegCPVq9f1FLvIBS+DrQ2KQBFZP1iFzXc=
+github.com/alecthomas/repr v0.4.0/go.mod h1:Fr0507jx4eOXV7AlPV6AVZLYrLIuIeSOWtW57eE/O/4=
+github.com/creack/pty v1.1.21 h1:1/QdRyBaHHJP61QkWMXlOIBfsgdDeeKfK8SYVUWJKf0=
+github.com/creack/pty v1.1.21/go.mod h1:MOBLtS5ELjhRRrroQr9kyvTxUAFNvYEK993ew/Vr4O4=
 github.com/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.14.0 h1:+cqqvzZV87b4adx/5ayVOaYZ2CrvM4ejQvUdBzPPUss=
-github.com/frankban/quicktest v1.14.0/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/dlclark/regexp2 v1.11.0 h1:G/nrcoOa7ZXlpoa/91N3X7mM3r8eIlMBBJZvsz/mxKI=
+github.com/dlclark/regexp2 v1.11.0/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
+github.com/dominikbraun/graph v0.23.0 h1:TdZB4pPqCLFxYhdyMFb1TBdFxp8XLcJfTTBQucVPgCo=
+github.com/dominikbraun/graph v0.23.0/go.mod h1:yOjYyogZLY1LSG9E33JWZJiq5k83Qy2C6POAuiViluc=
+github.com/fatih/color v1.17.0 h1:GlRw1BRJxkpqUCBKzKOw098ed57fEsKeNjpTe3cSjK4=
+github.com/fatih/color v1.17.0/go.mod h1:YZ7TlrGPkiz6ku9fK3TLD/pl3CpsiFyu8N92HLgmosI=
+github.com/go-quicktest/qt v1.101.0 h1:O1K29Txy5P2OK0dGo59b7b0LR6wKfIhttaAhHUyn7eI=
+github.com/go-quicktest/qt v1.101.0/go.mod h1:14Bz/f7NwaXPtdYEgzsx46kqSxVwTbzVZsDC26tQJow=
+github.com/go-task/slim-sprig/v3 v3.0.0 h1:sUs3vkvUymDpBKi3qH1YSqBQk9+9D/8M2mN1vB6EwHI=
+github.com/go-task/slim-sprig/v3 v3.0.0/go.mod h1:W848ghGpv3Qj3dhTPRyJypKRiqCdHZiAzKg9hl15HA8=
+github.com/go-task/template v0.1.0 h1:ym/r2G937RZA1bsgiWedNnY9e5kxDT+3YcoAnuIetTE=
+github.com/go-task/template v0.1.0/go.mod h1:RgwRaZK+kni/hJJ7/AaOE2lPQFPbAdji/DyhC6pxo4k=
+github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
+github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/hexops/gotextdiff v1.0.3 h1:gitA9+qJrrTCsiCl7+kh75nPqQt1cx4ZkudSTLoUqJM=
+github.com/hexops/gotextdiff v1.0.3/go.mod h1:pSWU5MAI3yDq+fZBTazCSJysOMbxWL1BSow5/V2vxeg=
+github.com/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.6 h1:mP8RnmCgho4oaUYDIDn6GNxYk+qJGUs8fJLn+twYj2A=
+github.com/mattn/go-zglob v0.0.6/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/muesli/cancelreader v0.2.2 h1:3I4Kt4BQjOR54NavqnDogx/MIoWBFa0StPA8ELUXHmA=
+github.com/muesli/cancelreader v0.2.2/go.mod h1:3XuTXfFS2VjM+HTLZY9Ak0l6eUKfijIfMUZ4EgX0QYo=
+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 h1:geMPLpDpQOgVyCg5z5GoRwLHepNdb71NXb67XFkP+Eg=
-github.com/rogpeppe/go-internal v1.8.1/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/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
-github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
-github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PKk=
-github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
-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-20211216021012-1d35b9e2eb4e h1:fLOSk5Q00efkSvAm+4xcoXD+RRmLmmulPn5I3Y9F2EM=
-golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/term v0.0.0-20210927222741-03fcf44c2211 h1:JGgROgKl9N8DuW20oFS5gxc+lE67/N3FcwmBPMe7ArY=
-golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
-golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
-golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/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.8.0 h1:3NFvSEYkUoMifnESzZl15y791HH1qU2xm6eCJU5ZPXQ=
+golang.org/x/sync v0.8.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.25.0 h1:r+8e+loiHxRqhXVl6ML1nO3l1+oFoWbnlu2Ehimmi34=
+golang.org/x/sys v0.25.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/term v0.24.0 h1:Mh5cbb+Zk2hqqXNO7S1iTjEphVL+jb8ZWaqh/g+JWkM=
+golang.org/x/term v0.24.0/go.mod h1:lOBK/LVxemqiMij05LGJ0tzNr8xlmwBRJ81PX6wVLH8=
 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/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-mvdan.cc/editorconfig v0.2.0/go.mod h1:lvnnD3BNdBYkhq+B4uBuFFKatfp02eB6HixDvEz91C0=
-mvdan.cc/sh/v3 v3.6.0-0.dev.0.20220704111049-a6e3029cd899 h1:nwm4t5PtLlFd/H342GP50CtYf7vyMCOZkPx3g9shO0c=
-mvdan.cc/sh/v3 v3.6.0-0.dev.0.20220704111049-a6e3029cd899/go.mod h1:1JcoyAKm1lZw/2bZje/iYKWicU/KMd0rsyJeKHnsK4E=
+mvdan.cc/sh/v3 v3.9.0 h1:it14fyjCdQUk4jf/aYxLO3FG8jFarR9GzMCtnlvvD7c=
+mvdan.cc/sh/v3 v3.9.0/go.mod h1:cdBk8bgoiBI7lSZqK5JhUuq7OB64VQ7fgm85xelw3Nk=

hash.go

@@ -1,18 +1,15 @@
 package task
 
 import (
+	"cmp"
 	"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) {
-	r := t.Run
-	if r == "" {
-		r = e.Taskfile.Run
-	}
-
+func (e *Executor) GetHash(t *ast.Task) (string, error) {
+	r := cmp.Or(t.Run, e.Taskfile.Run)
 	var h hash.HashFunc
 	switch r {
 	case "always":

help.go

@@ -1,104 +1,206 @@
 package task
 
 import (
+	"context"
+	"encoding/json"
 	"fmt"
 	"io"
-	"log"
 	"os"
-	"sort"
 	"strings"
-	"text/tabwriter"
 
+	"github.com/Ladicle/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"
 )
 
-// ListTasksWithDesc reports tasks that have a description spec.
-func (e *Executor) ListTasksWithDesc() {
-	e.printTasks(false)
+// ListOptions collects list-related options
+type ListOptions struct {
+	ListOnlyTasksWithDescriptions bool
+	ListAllTasks                  bool
+	FormatTaskListAsJSON          bool
+	NoStatus                      bool
 }
 
-// ListAllTasks reports all tasks, with or without a description spec.
-func (e *Executor) ListAllTasks() {
-	e.printTasks(true)
+// NewListOptions creates a new ListOptions instance
+func NewListOptions(list, listAll, listAsJson, noStatus bool) ListOptions {
+	return ListOptions{
+		ListOnlyTasksWithDescriptions: list,
+		ListAllTasks:                  listAll,
+		FormatTaskListAsJSON:          listAsJson,
+		NoStatus:                      noStatus,
+	}
 }
 
-func (e *Executor) printTasks(listAll bool) {
-	var tasks []*taskfile.Task
-	if listAll {
-		tasks = e.allTaskNames()
-	} else {
-		tasks = e.tasksWithDesc()
+// 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)
 	}
 
-	if len(tasks) == 0 {
-		if listAll {
-			e.Logger.Outf(logger.Yellow, "task: No tasks available")
-		} else {
-			e.Logger.Outf(logger.Yellow, "task: No tasks with description available. Try --list-all to list all tasks")
+	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
 		}
-		return
+
+		encoder := json.NewEncoder(e.Stdout)
+		encoder.SetIndent("", "  ")
+		if err := encoder.Encode(output); err != nil {
+			return false, err
+		}
+
+		return len(tasks) > 0, nil
 	}
-	e.Logger.Outf(logger.Default, "task: Available tasks for this project:")
+	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)
-	}
-	w.Flush()
-}
-
-func (e *Executor) allTaskNames() (tasks []*taskfile.Task) {
-	tasks = make([]*taskfile.Task, 0, len(e.Taskfile.Tasks))
-	for _, task := range e.Taskfile.Tasks {
-		tasks = append(tasks, task)
-	}
-	sort.Slice(tasks, func(i, j int) bool { return tasks[i].Task < tasks[j].Task })
-	return
-}
-
-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
-			}
-			tasks = append(tasks, task)
+		e.Logger.FOutf(w, logger.Yellow, "* ")
+		e.Logger.FOutf(w, logger.Green, task.Task)
+		desc := strings.ReplaceAll(task.Desc, "\n", " ")
+		e.Logger.FOutf(w, logger.Default, ": \t%s", desc)
+		if len(task.Aliases) > 0 {
+			e.Logger.FOutf(w, logger.Cyan, "\t(aliases: %s)", strings.Join(task.Aliases, ", "))
 		}
+		_, _ = fmt.Fprint(w, "\n")
 	}
-	sort.Slice(tasks, func(i, j int) bool { return tasks[i].Task < tasks[j].Task })
-	return
+	if err := w.Flush(); err != nil {
+		return false, err
+	}
+	return true, nil
 }
 
-// PrintTaskNames prints only the task names in a Taskfile.
+// ListTaskNames prints only the task names in a Taskfile.
 // Only tasks with a non-empty description are printed if allTasks is false.
 // Otherwise, all task names are printed.
-func (e *Executor) ListTaskNames(allTasks bool) {
-	// if called from cmd/task.go, e.Taskfile has not yet been parsed
-	if e.Taskfile == nil {
-		if err := e.readTaskfile(); err != nil {
-			log.Fatal(err)
-			return
-		}
-	}
+func (e *Executor) ListTaskNames(allTasks bool) error {
 	// use stdout if no output defined
 	var w io.Writer = os.Stdout
 	if e.Stdout != nil {
 		w = e.Stdout
 	}
-	// create a string slice from all map values (*taskfile.Task)
-	s := make([]string, 0, len(e.Taskfile.Tasks))
-	for _, t := range e.Taskfile.Tasks {
-		if allTasks || t.Desc != "" {
-			s = append(s, strings.TrimRight(t.Task, ":"))
+
+	// Get the list of tasks and sort them
+	tasks := e.Taskfile.Tasks.Values()
+
+	// Sort the tasks
+	if e.TaskSorter == nil {
+		e.TaskSorter = &sort.AlphaNumericWithRootTasksFirst{}
+	}
+	e.TaskSorter.Sort(tasks)
+
+	// Create a list of task names
+	taskNames := make([]string, 0, e.Taskfile.Tasks.Len())
+	for _, task := range tasks {
+		if (allTasks || task.Desc != "") && !task.Internal {
+			taskNames = append(taskNames, strings.TrimRight(task.Task, ":"))
+			for _, alias := range task.Aliases {
+				taskNames = append(taskNames, strings.TrimRight(alias, ":"))
+			}
 		}
 	}
-	// sort and print all task names
-	sort.Strings(s)
-	for _, t := range s {
+	for _, t := range taskNames {
 		fmt.Fprintln(w, t)
 	}
+	return nil
+}
+
+func (e *Executor) ToEditorOutput(tasks []*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 {
+		aliases := []string{}
+		if len(tasks[i].Aliases) > 0 {
+			aliases = tasks[i].Aliases
+		}
+		g.Go(func() error {
+			o.Tasks[i] = editors.Task{
+				Name:     tasks[i].Name(),
+				Desc:     tasks[i].Desc,
+				Summary:  tasks[i].Summary,
+				Aliases:  aliases,
+				UpToDate: false,
+				Location: &editors.Location{
+					Line:     tasks[i].Location.Line,
+					Column:   tasks[i].Location.Column,
+					Taskfile: tasks[i].Location.Taskfile,
+				},
+			}
+
+			if noStatus {
+				return nil
+			}
+
+			// Get the fingerprinting method to use
+			method := e.Taskfile.Method
+			if tasks[i].Method != "" {
+				method = tasks[i].Method
+			}
+			upToDate, err := fingerprint.IsTaskUpToDate(context.Background(), tasks[i],
+				fingerprint.WithMethod(method),
+				fingerprint.WithTempDir(e.TempDir.Fingerprint),
+				fingerprint.WithDry(e.Dry),
+				fingerprint.WithLogger(e.Logger),
+			)
+			if err != nil {
+				return err
+			}
+
+			o.Tasks[i].UpToDate = upToDate
+
+			return nil
+		})
+	}
+	return o, g.Wait()
 }

init.go

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

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,194 @@
 package compiler
 
 import (
-	"github.com/go-task/task/v3/taskfile"
+	"bytes"
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+
+	"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, call)
+		if err != nil {
+			return nil, err
+		}
+		for k, v := range specialVars {
+			result.Set(k, ast.Var{Value: v})
+		}
+	}
+
+	getRangeFunc := func(dir string) func(k string, v ast.Var) error {
+		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
+			}
+			// 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, call *ast.Call) (map[string]string, error) {
+	return map[string]string{
+		"TASK":             t.Task,
+		"ALIAS":            call.Task,
+		"TASK_EXE":         filepath.ToSlash(os.Args[0]),
+		"ROOT_TASKFILE":    filepathext.SmartJoin(c.Dir, c.Entrypoint),
+		"ROOT_DIR":         c.Dir,
+		"TASKFILE":         t.Location.Taskfile,
+		"TASKFILE_DIR":     filepath.Dir(t.Location.Taskfile),
+		"USER_WORKING_DIR": c.UserWorkingDir,
+		"TASK_VERSION":     version.GetVersion(),
+	}, nil
 }

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,169 +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)
-
-	var taskRangeFunc func(k string, v taskfile.Var) error
-	if t != nil {
-		// NOTE(@andreynering): We're manually joining these paths here because
-		// this is the raw task, not the compiled one.
-		tr := templater.Templater{Vars: result, RemoveNoValue: true}
-		dir := tr.Replace(t.Dir)
-		if err := tr.Err(); err != nil {
-			return nil, err
-		}
-		if !filepath.IsAbs(dir) {
-			dir = filepath.Join(c.Dir, dir)
-		}
-		taskRangeFunc = getRangeFunc(dir)
-	}
-
-	if err := c.TaskfileEnv.Range(rangeFunc); err != nil {
-		return nil, err
-	}
-	if err := c.TaskfileVars.Range(rangeFunc); err != nil {
-		return nil, err
-	}
-	if t != nil {
-		if err := t.IncludedTaskfileVars.Range(taskRangeFunc); err != nil {
-			return nil, err
-		}
-		if err := t.IncludeVars.Range(rangeFunc); err != nil {
-			return nil, err
-		}
-	}
-
-	if t == nil || call == nil {
-		return result, nil
-	}
-
-	if err := call.Vars.Range(rangeFunc); err != nil {
-		return nil, err
-	}
-	if err := t.Vars.Range(taskRangeFunc); err != nil {
-		return nil, err
-	}
-
-	return result, nil
-}
-
-func (c *CompilerV3) HandleDynamicVar(v taskfile.Var, dir string) (string, error) {
-	if v.Static != "" || v.Sh == "" {
-		return v.Static, nil
-	}
-
-	c.muDynamicCache.Lock()
-	defer c.muDynamicCache.Unlock()
-
-	if c.dynamicCache == nil {
-		c.dynamicCache = make(map[string]string, 30)
-	}
-	if result, ok := c.dynamicCache[v.Sh]; ok {
-		return result, nil
-	}
-
-	// NOTE(@andreynering): If a var have a specific dir, use this instead
-	if v.Dir != "" {
-		dir = v.Dir
-	}
-
-	var stdout bytes.Buffer
-	opts := &execext.RunCommandOptions{
-		Command: v.Sh,
-		Dir:     dir,
-		Stdout:  &stdout,
-		Stderr:  c.Logger.Stderr,
-	}
-	if err := execext.RunCommand(context.Background(), opts); err != nil {
-		return "", fmt.Errorf(`task: Command "%s" failed: %s`, opts.Command, err)
-	}
-
-	// Trim a single trailing newline from the result to make most command
-	// output easier to use in shell commands.
-	result := strings.TrimSuffix(stdout.String(), "\r\n")
-	result = strings.TrimSuffix(result, "\n")
-
-	c.dynamicCache[v.Sh] = result
-	c.Logger.VerboseErrf(logger.Magenta, `task: dynamic variable: '%s' result: '%s'`, v.Sh, result)
-
-	return result, nil
-}
-
-// ResetCache clear the dymanic variables cache
-func (c *CompilerV3) ResetCache() {
-	c.muDynamicCache.Lock()
-	defer c.muDynamicCache.Unlock()
-
-	c.dynamicCache = nil
-}

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 := range v.NumField() {
+				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 := range v.Len() {
+				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,38 @@
+package env
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/go-task/task/v3/internal/experiments"
+	"github.com/go-task/task/v3/taskfile/ast"
+)
+
+func Get(t *ast.Task) []string {
+	if t.Env == nil {
+		return nil
+	}
+	environ := os.Environ()
+	for k, v := range t.Env.ToCacheMap() {
+		if !isTypeAllowed(v) {
+			continue
+		}
+		if !experiments.EnvPrecedence.Enabled {
+			if _, alreadySet := os.LookupEnv(k); alreadySet {
+				continue
+			}
+		}
+		environ = append(environ, fmt.Sprintf("%s=%v", k, v))
+	}
+
+	return environ
+}
+
+func isTypeAllowed(v any) bool {
+	switch v.(type) {
+	case string, bool, int, float32, float64:
+		return true
+	default:
+		return false
+	}
+}

internal/execext/exec.go

@@ -3,6 +3,7 @@ package execext
 import (
 	"context"
 	"errors"
+	"fmt"
 	"io"
 	"os"
 	"path/filepath"
@@ -17,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 {
@@ -36,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
@@ -47,9 +57,9 @@ func RunCommand(ctx context.Context, opts *RunCommandOptions) error {
 	}
 
 	r, err := interp.New(
-		interp.Params("-e"),
+		interp.Params(params...),
 		interp.Env(expand.ListEnviron(environ...)),
-		interp.ExecHandler(interp.DefaultExecHandler(15*time.Second)),
+		interp.ExecHandlers(execHandler),
 		interp.OpenHandler(openHandler),
 		interp.StdIO(opts.Stdin, opts.Stdout, opts.Stderr),
 		dirOption(opts.Dir),
@@ -58,22 +68,36 @@ func RunCommand(ctx context.Context, opts *RunCommandOptions) error {
 		return err
 	}
 
-	return r.Run(ctx, p)
-}
+	parser := syntax.NewParser()
 
-// IsExitError returns true the given error is an exis status error
-func IsExitError(err error) bool {
-	if _, ok := interp.IsExitStatus(err); ok {
-		return true
+	// 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
+		}
 	}
-	return false
+
+	// Run the user-defined command
+	p, err := parser.Parse(strings.NewReader(opts.Command), "")
+	if err != nil {
+		return err
+	}
+	return r.Run(ctx, p)
 }
 
 // Expand is a helper to mvdan.cc/shell.Fields that returns the first field
 // 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
@@ -84,6 +108,10 @@ func Expand(s string) (string, error) {
 	return "", nil
 }
 
+func execHandler(next interp.ExecHandlerFunc) interp.ExecHandlerFunc {
+	return interp.DefaultExecHandler(15 * time.Second)
+}
+
 func openHandler(ctx context.Context, path string, flag int, perm os.FileMode) (io.ReadWriteCloser, error) {
 	if path == "/dev/null" {
 		return devNull{}, nil

internal/exp/maps.go

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

internal/experiments/experiments.go

@@ -0,0 +1,112 @@
+package experiments
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"slices"
+	"strings"
+
+	"github.com/Ladicle/tabwriter"
+	"github.com/joho/godotenv"
+	"github.com/spf13/pflag"
+
+	"github.com/go-task/task/v3/internal/logger"
+)
+
+const envPrefix = "TASK_X_"
+
+type Experiment struct {
+	Name    string
+	Enabled bool
+	Value   string
+}
+
+// A list of experiments.
+var (
+	GentleForce     Experiment
+	RemoteTaskfiles Experiment
+	AnyVariables    Experiment
+	MapVariables    Experiment
+	EnvPrecedence   Experiment
+)
+
+func init() {
+	readDotEnv()
+	GentleForce = New("GENTLE_FORCE")
+	RemoteTaskfiles = New("REMOTE_TASKFILES")
+	AnyVariables = New("ANY_VARIABLES", "1", "2")
+	MapVariables = New("MAP_VARIABLES", "1", "2")
+	EnvPrecedence = New("ENV_PRECEDENCE")
+}
+
+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.Usage = func() {}
+	_ = 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)
+	printExperiment(w, l, EnvPrecedence)
+	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,158 @@
+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
+	Completion  string
+	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
+	ClearCache  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.StringVar(&Completion, "completion", "", "Generates shell completion script.")
+	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.BoolVar(&ClearCache, "clear-cache", false, "Clear the remote cache.")
+	}
+
+	pflag.Parse()
+}
+
+func Validate() error {
+	if Download && Offline {
+		return errors.New("task: You can't set both --download and --offline flags")
+	}
+
+	if Download && ClearCache {
+		return errors.New("task: You can't set both --download and --clear-cache 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) {
-	return t.Task, nil
+func Name(t *ast.Task) (string, error) {
+	return fmt.Sprintf("%s:%s", t.Location.Taskfile, t.LocalName()), 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,90 +1,197 @@
 package logger
 
 import (
+	"bufio"
 	"io"
 	"os"
+	"slices"
 	"strconv"
+	"strings"
 
 	"github.com/fatih/color"
+
+	"github.com/go-task/task/v3/errors"
+	"github.com/go-task/task/v3/internal/term"
 )
 
-type Color func() PrintFunc
-type PrintFunc func(io.Writer, string, ...interface{})
+var (
+	ErrPromptCancelled = errors.New("prompt cancelled")
+	ErrNoTerminal      = errors.New("no terminal")
+)
+
+type (
+	Color     func() PrintFunc
+	PrintFunc func(io.Writer, string, ...any)
+)
 
 func Default() PrintFunc {
-	return color.New(envColor("TASK_COLOR_RESET", color.Reset)).FprintfFunc()
+	return color.New(envColor("TASK_COLOR_RESET", color.Reset)...).FprintfFunc()
 }
+
 func Blue() PrintFunc {
-	return color.New(envColor("TASK_COLOR_BLUE", color.FgBlue)).FprintfFunc()
+	return color.New(envColor("TASK_COLOR_BLUE", color.FgBlue)...).FprintfFunc()
 }
+
 func Green() PrintFunc {
-	return color.New(envColor("TASK_COLOR_GREEN", color.FgGreen)).FprintfFunc()
+	return color.New(envColor("TASK_COLOR_GREEN", color.FgGreen)...).FprintfFunc()
 }
+
 func Cyan() PrintFunc {
-	return color.New(envColor("TASK_COLOR_CYAN", color.FgCyan)).FprintfFunc()
+	return color.New(envColor("TASK_COLOR_CYAN", color.FgCyan)...).FprintfFunc()
 }
+
 func Yellow() PrintFunc {
-	return color.New(envColor("TASK_COLOR_YELLOW", color.FgYellow)).FprintfFunc()
+	return color.New(envColor("TASK_COLOR_YELLOW", color.FgYellow)...).FprintfFunc()
 }
+
 func Magenta() PrintFunc {
-	return color.New(envColor("TASK_COLOR_MAGENTA", color.FgMagenta)).FprintfFunc()
+	return color.New(envColor("TASK_COLOR_MAGENTA", color.FgMagenta)...).FprintfFunc()
 }
+
 func Red() PrintFunc {
-	return color.New(envColor("TASK_COLOR_RED", color.FgRed)).FprintfFunc()
+	return color.New(envColor("TASK_COLOR_RED", color.FgRed)...).FprintfFunc()
 }
 
-func envColor(env string, defaultColor color.Attribute) color.Attribute {
-	override, err := strconv.Atoi(os.Getenv(env))
-	if err == nil {
-		return color.Attribute(override)
+func BrightBlue() PrintFunc {
+	return color.New(envColor("TASK_COLOR_BRIGHT_BLUE", color.FgHiBlue)...).FprintfFunc()
+}
 
+func BrightGreen() PrintFunc {
+	return color.New(envColor("TASK_COLOR_BRIGHT_GREEN", color.FgHiGreen)...).FprintfFunc()
+}
+
+func BrightCyan() PrintFunc {
+	return color.New(envColor("TASK_COLOR_BRIGHT_CYAN", color.FgHiCyan)...).FprintfFunc()
+}
+
+func BrightYellow() PrintFunc {
+	return color.New(envColor("TASK_COLOR_BRIGHT_YELLOW", color.FgHiYellow)...).FprintfFunc()
+}
+
+func BrightMagenta() PrintFunc {
+	return color.New(envColor("TASK_COLOR_BRIGHT_MAGENTA", color.FgHiMagenta)...).FprintfFunc()
+}
+
+func BrightRed() PrintFunc {
+	return color.New(envColor("TASK_COLOR_BRIGHT_RED", color.FgHiRed)...).FprintfFunc()
+}
+
+func envColor(env string, defaultColor color.Attribute) []color.Attribute {
+	if os.Getenv("FORCE_COLOR") != "" {
+		color.NoColor = false
 	}
-	return defaultColor
+
+	// Fetch the environment variable
+	override := os.Getenv(env)
+
+	// First, try splitting the string by commas (RGB shortcut syntax) and if it
+	// matches, then prepend the 256-color foreground escape sequence.
+	// Otherwise, split by semicolons (ANSI color codes) and use them as is.
+	attributeStrs := strings.Split(override, ",")
+	if len(attributeStrs) == 3 {
+		attributeStrs = slices.Concat([]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]: ", 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
+}