chore(deps): update all non-major dependencies (#2816)

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
Co-authored-by: Valentin Maerten <maerten.valentin@gmail.com>

.editorconfig

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

.gitattributes

@@ -1 +1,5 @@
 * text=auto
+*.mdx -linguist-detectable
+
+# Keep LF line endings in testdata for consistent checksums across platforms
+testdata/** text eol=lf

.github/CODE_OF_CONDUCT.md

@@ -1,46 +0,0 @@
-# Contributor Covenant Code of Conduct
-
-## Our Pledge
-
-In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.
-
-## Our Standards
-
-Examples of behavior that contributes to creating a positive environment include:
-
-* Using welcoming and inclusive language
-* Being respectful of differing viewpoints and experiences
-* Gracefully accepting constructive criticism
-* Focusing on what is best for the community
-* Showing empathy towards other community members
-
-Examples of unacceptable behavior by participants include:
-
-* The use of sexualized language or imagery and unwelcome sexual attention or advances
-* Trolling, insulting/derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information, such as a physical or electronic address, without explicit permission
-* Other conduct which could reasonably be considered inappropriate in a professional setting
-
-## Our Responsibilities
-
-Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
-
-Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
-
-## Scope
-
-This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.
-
-## 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.
-
-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.
-
-## Attribution
-
-This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [http://contributor-covenant.org/version/1/4][version]
-
-[homepage]: http://contributor-covenant.org
-[version]: http://contributor-covenant.org/version/1/4/

.github/CONTRIBUTING.md

@@ -1,6 +0,0 @@
-* 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
-
-[issues]: https://github.com/go-task/task/issues

.github/ISSUE_TEMPLATE.md

@@ -1,6 +0,0 @@
-<!--
-If relevant, include the following information:
-- Task version
-- OS
-- Example Taskfile showing the issue
--->

.github/ISSUE_TEMPLATE/bug_report.yml

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

.github/ISSUE_TEMPLATE/config.yml

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

.github/ISSUE_TEMPLATE/feature_request.yml

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

.github/pull_request_template.md

@@ -0,0 +1,11 @@
+<!--
+
+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/).
+
+-->
+
+- [ ] I have read and followed the [Contribution Guide](https://taskfile.dev/contributing/)

.github/renovate.json

@@ -0,0 +1,36 @@
+{
+  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+  "extends": [
+    "config:recommended",
+    "group:allNonMajor",
+    "schedule:weekly",
+    ":semanticCommitTypeAll(chore)"
+  ],
+  "mode": "full",
+  "addLabels":["area: dependencies"],
+  "customManagers": [
+    {
+      "customType": "regex",
+      "fileMatch": ["^\\.github/workflows/.*\\.ya?ml$"],
+      "matchStrings": [
+        "uses:\\s*golangci/golangci-lint-action@\\S+\\s+with:\\s+version:\\s*(?<currentValue>v[\\d.]+)"
+      ],
+      "datasourceTemplate": "github-releases",
+      "depNameTemplate": "golangci/golangci-lint"
+    }
+  ],
+  "packageRules": [
+    {
+      "matchManagers": ["github-actions"],
+      "addLabels": ["area: github actions"]
+    },
+    {
+      "matchCategories": ["js", "node"],
+      "addLabels": ["lang: javascript"]
+    },
+    {
+      "matchCategories": ["golang"],
+      "addLabels": ["lang: go"]
+    }
+  ]
+}

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

@@ -0,0 +1,46 @@
+name: issue awaiting response
+
+on:
+  issue_comment:
+    types: [created]
+
+permissions:
+  issues: write
+
+jobs:
+  issue-awaiting-response:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+        with:
+          github-token: ${{secrets.GITHUB_TOKEN}}
+          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,32 @@
+name: issue closed
+
+on:
+  issues:
+    types: [closed]
+
+permissions:
+  issues: write
+
+jobs:
+  issue-closed:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+        with:
+          github-token: ${{secrets.GITHUB_TOKEN}}
+          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,126 @@
+name: issue experiment
+
+on:
+  issues:
+    types: [field_added]
+
+permissions:
+  issues: write
+
+jobs:
+  issue-experiment-proposal:
+    if: github.event.issue_field.id == '6591' && github.event.issue_field_value.option.name == 'proposal'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+        with:
+          github-token: ${{secrets.GITHUB_TOKEN}}
+          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.issue_field.id == '6591' && github.event.issue_field_value.option.name == 'draft'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+        with:
+          github-token: ${{secrets.GITHUB_TOKEN}}
+          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.issue_field.id == '6591' && github.event.issue_field_value.option.name == 'candidate'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+        with:
+          github-token: ${{secrets.GITHUB_TOKEN}}
+          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.issue_field.id == '6591' && github.event.issue_field_value.option.name == 'stable'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+        with:
+          github-token: ${{secrets.GITHUB_TOKEN}}
+          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.issue_field.id == '6591' && github.event.issue_field_value.option.name == 'released'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+        with:
+          github-token: ${{secrets.GITHUB_TOKEN}}
+          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.issue_field.id == '6591' && github.event.issue_field_value.option.name == 'abandoned'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+        with:
+          github-token: ${{secrets.GITHUB_TOKEN}}
+          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.issue_field.id == '6591' && github.event.issue_field_value.option.name == 'superseded'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+        with:
+          github-token: ${{secrets.GITHUB_TOKEN}}
+          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,32 @@
+name: issue needs triage
+
+on:
+  issues:
+    types: [opened]
+
+permissions:
+  issues: write
+
+jobs:
+  issue-needs-triage:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+        with:
+          github-token: ${{secrets.GITHUB_TOKEN}}
+          script: |
+            const labels = await github.paginate(
+              github.rest.issues.listLabelsOnIssue, {
+                issue_number: context.issue.number,
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+              }
+            )
+            if (labels.length === 0) {
+              github.rest.issues.addLabels({
+                issue_number: context.issue.number,
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                labels: ['state: needs triage']
+              })
+            }

.github/workflows/lint.yml

@@ -0,0 +1,46 @@
+name: Lint
+
+on:
+  pull_request:
+  push:
+    tags:
+      - v*
+    branches:
+      - main
+
+permissions:
+  contents: read
+
+jobs:
+  lint:
+    name: Lint
+    strategy:
+      matrix:
+        go-version: [1.25.10, 1.26.x]
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
+        with:
+          go-version: ${{matrix.go-version}}
+
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+
+      - name: golangci-lint
+        uses: golangci/golangci-lint-action@1e7e51e771db61008b38414a730f564565cf7c20 # v9.2.0
+        with:
+          version: v2.12.2
+
+  lint-jsonschema:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+        with:
+          python-version: 3.14
+
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+
+      - name: install check-jsonschema
+        run: python -m pip install 'check-jsonschema==0.27.3'
+
+      - name: check-jsonschema (metaschema)
+        run: check-jsonschema --check-metaschema website/src/public/schema.json

.github/workflows/pr-build.yml

@@ -0,0 +1,69 @@
+name: PR Build
+
+on:
+  pull_request_target:
+    types: [labeled, synchronize]
+
+permissions:
+  contents: read
+  pull-requests: write
+
+jobs:
+  build:
+    if: contains(github.event.pull_request.labels.*.name, 'needs-build')
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          ref: ${{ github.event.pull_request.head.sha }}
+          fetch-depth: 0
+      - uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
+        with:
+          go-version: "1.26.x"
+          cache: true
+      - uses: goreleaser/goreleaser-action@1a80836c5c9d9e5755a25cb59ec6f45a3b5f41a8 # v7
+        with:
+          version: "~> v2"
+          args: release --snapshot --clean --config .goreleaser-pr.yml
+      - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: task_linux_amd64
+          path: dist/task_linux_amd64.tar.gz
+      - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: task_linux_arm64
+          path: dist/task_linux_arm64.tar.gz
+      - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: task_darwin_amd64
+          path: dist/task_darwin_amd64.tar.gz
+      - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: task_darwin_arm64
+          path: dist/task_darwin_arm64.tar.gz
+      - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: task_windows_amd64
+          path: dist/task_windows_amd64.zip
+      - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: checksums
+          path: dist/task_checksums.txt
+      - uses: peter-evans/find-comment@b30e6a3c0ed37e7c023ccd3f1db5c6c0b0c23aad # v4.0.0
+        id: find-comment
+        with:
+          token: ${{secrets.GITHUB_TOKEN}}
+          issue-number: ${{ github.event.pull_request.number }}
+          body-includes: "📦 Build artifacts ready!"
+      - uses: peter-evans/create-or-update-comment@e8674b075228eee787fea43ef493e45ece1004c9 # v5.0.0
+        with:
+          token: ${{secrets.GITHUB_TOKEN}}
+          comment-id: ${{ steps.find-comment.outputs.comment-id }}
+          issue-number: ${{ github.event.pull_request.number }}
+          body: |
+            ## 📦 Build artifacts ready!
+
+            Download binaries from [this workflow run](${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}).
+
+            Available platforms: Linux, macOS, Windows (amd64, arm64)
+          edit-mode: replace

.github/workflows/release-nightly.yml

@@ -0,0 +1,34 @@
+name: Release nightly
+
+on:
+  workflow_dispatch:
+  schedule:
+    - cron: 0 0 * * *
+
+permissions:
+  contents: write
+
+jobs:
+  goreleaser:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          fetch-depth: 0
+
+      - name: Set up Go
+        uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
+        with:
+          go-version: 1.26.x
+
+      - name: Run GoReleaser
+        uses: goreleaser/goreleaser-action@1a80836c5c9d9e5755a25cb59ec6f45a3b5f41a8 # v7
+        with:
+          distribution: goreleaser-pro
+          version: latest
+          args: release --clean --nightly -f .goreleaser-nightly.yml
+        env:
+          GITHUB_TOKEN: ${{secrets.GITHUB_TOKEN}}
+          GORELEASER_KEY: ${{secrets.GORELEASER_KEY}}
+          CLOUDSMITH_TOKEN: ${{secrets.CLOUDSMITH_TOKEN}}

.github/workflows/release.yml

@@ -0,0 +1,60 @@
+name: goreleaser
+
+on:
+  push:
+    tags:
+      - "v*"
+
+permissions:
+  id-token: write # Required for OIDC
+  contents: write
+
+jobs:
+  goreleaser:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          fetch-depth: 0
+
+      - name: Set up Go
+        uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
+        with:
+          go-version: 1.26.x
+
+      - uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6.4.0
+        with:
+          node-version: "24"
+          registry-url: "https://registry.npmjs.org"
+
+      - name: Update npm
+        run: npm install -g npm@latest
+
+      - name: Install Task
+        uses: go-task/setup-task@3be4020d41929789a01026e0e427a4321ce0ad44 # v2
+
+      - name: Install pnpm
+        uses: pnpm/action-setup@0e279bb959325dab635dd2c09392533439d90093 # v6
+        with:
+          package_json_file: "website/package.json"
+          run_install: "true"
+
+      - name: Run GoReleaser
+        uses: goreleaser/goreleaser-action@1a80836c5c9d9e5755a25cb59ec6f45a3b5f41a8 # v7
+        with:
+          distribution: goreleaser-pro
+          version: latest
+          args: release --clean --draft
+        env:
+          GITHUB_TOKEN: ${{secrets.GITHUB_TOKEN}}
+          GH_GORELEASER_TOKEN: ${{secrets.GH_GORELEASER_TOKEN}}
+          GORELEASER_KEY: ${{secrets.GORELEASER_KEY}}
+          CLOUDSMITH_TOKEN: ${{secrets.CLOUDSMITH_TOKEN}}
+
+      - name: Deploy Website
+        shell: bash
+        run: |
+          task website:deploy:prod
+        env:
+          NETLIFY_AUTH_TOKEN: ${{ secrets.NETLIFY_AUTH_TOKEN }}

.github/workflows/security.yml

@@ -0,0 +1,19 @@
+name: Security
+
+on:
+  pull_request:
+  push:
+    tags:
+      - v*
+    branches:
+      - main
+
+permissions:
+  contents: read
+
+jobs:
+  govulncheck:
+    name: govulncheck
+    runs-on: ubuntu-latest
+    steps:
+      - uses: golang/govulncheck-action@b625fbe08f3bccbe446d94fbf87fcc875a4f50ee # v1.0.4

.github/workflows/test.yml

@@ -0,0 +1,33 @@
+name: Test
+
+on:
+  pull_request:
+  push:
+    tags:
+      - v*
+    branches:
+      - main
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    name: Test
+    strategy:
+      fail-fast: false
+      matrix:
+        go-version: [1.25.10, 1.26.x]
+        platform: [ubuntu-latest, macos-latest, windows-latest]
+    runs-on: ${{matrix.platform}}
+    steps:
+      - name: Check out code
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+
+      - name: Set up Go ${{matrix.go-version}}
+        uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
+        with:
+          go-version: ${{matrix.go-version}}
+
+      - name: Test
+        run: go run ./cmd/task test

.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/
 
@@ -18,3 +21,18 @@
 dist/
 
 .DS_Store
+
+# editors
+.idea/
+.vscode/settings.json
+.fleet/
+
+# exuberant ctags
+tags
+
+/bin/*
+!/bin/.keep
+/testdata/vars/v1
+/tmp
+node_modules
+website/.netlify/

.golangci.yml

@@ -0,0 +1,47 @@
+version: "2"
+
+formatters:
+  enable:
+    - gofumpt
+    - goimports
+    - gci
+  settings:
+    gci:
+      sections:
+        - standard
+        - default
+        - prefix(github.com/go-task)
+        - localmodule
+
+linters:
+  enable:
+    - depguard
+    - gosec
+    - mirror
+    - misspell
+    - modernize
+    - noctx
+    - paralleltest
+    - thelper
+    - tparallel
+    - usetesting
+  settings:
+    gosec:
+      excludes:
+        - G306
+    depguard:
+      rules:
+        main:
+          files:
+            - $all
+            - '!$test'
+            - '!**/errors/*.go'
+          deny:
+            - pkg: errors
+              desc: Use github.com/go-task/task/v3/errors instead
+  exclusions:
+    presets:
+      - comments
+      - common-false-positives
+      - legacy
+      - std-error-handling

.goreleaser-nightly.yml

@@ -0,0 +1,15 @@
+# yaml-language-server: $schema=https://goreleaser.com/static/schema.json
+version: 2
+pro: true
+
+release:
+  name_template: 'v{{.Version}}'
+
+nightly:
+  publish_release: true
+  keep_single_release: true
+  version_template: "{{incminor .Version}}-nightly"
+
+includes:
+  - from_file:
+      path: ./.goreleaser.yml

.goreleaser-pr.yml

@@ -0,0 +1,31 @@
+# yaml-language-server: $schema=https://goreleaser.com/static/schema.json
+version: 2
+
+builds:
+  - binary: task
+    main: ./cmd/task
+    goos: [windows, darwin, linux]
+    goarch: [amd64, arm64]
+    env:
+      - CGO_ENABLED=0
+    mod_timestamp: '{{ .CommitTimestamp }}'
+    flags:
+      - -trimpath
+    ldflags:
+      - "-s -w"
+
+archives:
+  - name_template: '{{.Binary}}_{{.Os}}_{{.Arch}}'
+    files:
+      - README.md
+      - LICENSE
+      - completion/**/*
+    format_overrides:
+      - goos: windows
+        formats: [zip]
+
+snapshot:
+  version_template: 'pr-{{ .ShortCommit }}'
+
+checksum:
+  name_template: 'task_checksums.txt'

.goreleaser.yml

@@ -1,44 +1,176 @@
-build:
-  binary: task
-  main: cmd/task/task.go
-  goos:
-    - windows
-    - darwin
-    - linux
-  goarch:
-    - 386
-    - amd64
-  ignore:
-    - goos: darwin
-      goarch: 386
-  env:
-    - CGO_ENABLED=0
+# yaml-language-server: $schema=https://goreleaser.com/static/schema.json
+version: 2
 
-archive:
-  name_template: "{{.Binary}}_{{.Os}}_{{.Arch}}"
+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: arm
+      - goos: windows
+        goarch: riscv64
+    env:
+      - CGO_ENABLED=0
+    mod_timestamp: '{{ .CommitTimestamp }}'
+    flags:
+      - -trimpath
+    ldflags:
+      - "-s -w"
+      - "{{if .IsNightly}}-X github.com/go-task/task/v3/internal/version.version={{.Version}}{{end}}"
 
-  format_overrides:
-    - goos: windows
-      format: zip
+gomod:
+  proxy: true
 
-release:
-  draft: true
+archives:
+  - name_template: '{{.Binary}}_{{.Os}}_{{.Arch}}'
+    files:
+      - README.md
+      - LICENSE
+      - completion/**/*
+    format_overrides:
+      - goos: windows
+        formats: [zip]
+
+git:
+  ignore_tags:
+    - "{{if not .IsNightly}}nightly{{end}}"
 
 snapshot:
-  name_template: "{{.Tag}}"
+  version_template: '{{.Version}}'
 
 checksum:
-  name_template: "task_checksums.txt"
+  name_template: 'task_checksums.txt'
 
-nfpm:
-  vendor: Task
-  homepage: https://github.com/go-task/task
-  maintainer: Andrey Nering <andrey.nering@gmail.com>
-  description: Simple task runner written in Go
-  license: MIT
-  conflicts:
-    - taskwarrior
-  formats:
-    - deb
-    - rpm
-  name_template: "{{.ProjectName}}_{{.Os}}_{{.Arch}}"
+nfpms:
+  - vendor: Task
+    homepage: https://taskfile.dev
+    maintainer: The Task authors <task@taskfile.dev>
+    description: A fast, cross-platform build tool inspired by Make, designed for modern workflows.
+    section: golang
+    license: MIT
+    conflicts:
+      - taskwarrior
+    formats:
+      - deb
+      - rpm
+      - apk
+    file_name_template: '{{.ProjectName}}_{{.Version}}_{{.Os}}_{{.Arch}}'
+    contents:
+      - src: completion/bash/task.bash
+        dst: /etc/bash_completion.d/task
+      - src: completion/fish/task.fish
+        dst: /usr/share/fish/completions/task.fish
+      - src: completion/zsh/_task
+        dst: /usr/local/share/zsh/site-functions/_task
+
+brews:
+  - name: go-task
+    description: A fast, cross-platform build tool inspired by Make, designed for modern workflows.
+    license: MIT
+    homepage: https://taskfile.dev
+    directory: Formula
+    repository:
+      owner: go-task
+      name: homebrew-tap
+      token: "{{.Env.GH_GORELEASER_TOKEN}}" # So that it runs as the task-bot user
+    test: system "#{bin}/task", "--help"
+    install: |-
+      bin.install "task"
+      bash_completion.install "completion/bash/task.bash" => "task"
+      zsh_completion.install "completion/zsh/_task" => "_task"
+      fish_completion.install "completion/fish/task.fish"
+    commit_author:
+      name: task-bot
+      email: 106601941+task-bot@users.noreply.github.com
+
+winget:
+  - name: Task
+    publisher: Task
+    short_description: The modern task runner.
+    description: A fast, cross-platform build tool inspired by Make, designed for modern workflows.
+    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: release {{.PackageIdentifier}} {{.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
+    repository:
+      owner: go-task
+      name: winget-pkgs
+      branch: 'task-{{.Version}}'
+      token: "{{.Env.GH_GORELEASER_TOKEN}}" # So that it runs as the task-bot user
+      pull_request:
+        enabled: true
+        draft: false
+        check_boxes: true
+        base:
+          owner: microsoft
+          name: winget-pkgs
+          branch: master
+        body: |
+          /cc @andreynering @pd93 @vmaerten
+
+npms:
+  - name: "@go-task/cli"
+    repository: "git+https://github.com/go-task/task.git"
+    bugs: https://github.com/go-task/task/issues
+    description: A fast, cross-platform build tool inspired by Make, designed for modern workflows.
+    homepage: https://taskfile.dev
+    license: MIT
+    author: "The Task authors"
+    access: public
+    keywords:
+      - "task"
+      - "taskfile"
+      - "build-tool"
+      - "task-runner"
+
+cloudsmiths:
+  - organization: "task"
+    repository: "{{if not .IsNightly}}task{{end}}"
+    formats:
+      - deb
+      - rpm
+      - apk
+    distributions:
+      deb:
+        - "any-distro/any-version"
+      rpm:
+        - "any-distro/any-version"
+      alpine:
+        - "alpine/any-version"
+    component: main
+    republish: true

.mockery.yaml

@@ -0,0 +1,8 @@
+all: False
+template: testify
+filename: '{{base (trimSuffix ".go" .InterfaceFile)}}_mock.go'
+packages:
+  github.com/go-task/task/v3/internal/fingerprint:
+    interfaces:
+      SourcesCheckable:
+      StatusCheckable:

.prettierrc.yml

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

.taskrc.yml

@@ -0,0 +1,4 @@
+experiments:
+  GENTLE_FORCE: 0
+  REMOTE_TASKFILES: 0
+  ENV_PRECEDENCE: 0

.travis.yml

@@ -1,22 +0,0 @@
-language: go
-
-go:
-  - 1.10.x
-  - 1.11.x
-
-addons:
-  apt:
-    packages:
-      - rpm
-
-script:
-  - go install github.com/go-task/task/cmd/task
-  - task ci
-
-deploy:
-  - provider: script
-    skip_cleanup: true
-    script: curl -sL http://git.io/goreleaser | bash
-    on:
-      tags: true
-      condition: $TRAVIS_OS_NAME = linux

.vscode/extensions.json

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

.vscode/settings-sample.json

@@ -0,0 +1,14 @@
+{
+  "yaml.schemas": {
+    "./website/src/public/schema.json": [
+        "Taskfile.yml",
+        "Taskfile.yaml",
+        "taskfile.yml",
+        "taskfile.yaml"
+    ]
+  },
+  "gopls": {
+      "formatting.local": "github.com/go-task"
+  },
+  "go.formatTool": "gofumpt"
+}

README.md

@@ -1,22 +1,49 @@
-[![Build Status](https://travis-ci.org/go-task/task.svg?branch=master)](https://travis-ci.org/go-task/task)
+<div align="center">
+  <a href="https://taskfile.dev">
+    <img src="website/src/public/img/logo.svg" width="200px" height="200px" />
+  </a>
 
-# Task
+  <h1>Task: The Modern Task Runner</h1>
 
-Task is a task runner / build tool that aims to be simpler and easier to use
-than, for example, [GNU Make](https://www.gnu.org/software/make/).
+  <p>
+    A fast, cross-platform build tool inspired by Make, designed for modern workflows.
+  </p>
 
-See [taskfile.org](https://taskfile.org) for documentation.
+  <p>
+    <a href="https://taskfile.dev/docs/installation">Installation</a> &bullet; <a href="https://taskfile.dev/docs/getting-started">Getting Started</a> &bullet; <a href="https://taskfile.dev/docs/guide">Docs</a> &bullet; <a href="https://twitter.com/taskfiledev">Twitter</a> &bullet; <a href="https://bsky.app/profile/taskfile.dev">Bluesky</a> &bullet; <a href="https://fosstodon.org/@task">Mastodon</a> &bullet; <a href="https://discord.gg/6TY36E39UK">Discord</a>
+  </p>
 
----
+  <h1>Gold Sponsors</h1>
 
-## Sponsors
+  <table>
+    <tr>
+      <td align="center" valign="middle">
+        <a target="_blank" href="https://devowl.io">
+          <img src="website/src/public/img/devowl.io.svg" height="100px" width="200px" title="devowl.io" />
+        </a>
+      </td>
+      <td align="center" valign="middle">
+        <a target="_blank" href="https://goodx.international/">
+          <img src="website/src/public/img/goodx.svg" height="80px" width="200px" title="GoodX" />
+        </a>
+      </td>
+      <td align="center" valign="middle">
+        <a target="_blank" href="https://magic.dev/">
+          <img src="website/src/public/img/magic.png" height="100px" width="200px" title="Magic" />
+        </a>
+      </td>
+    </tr>
+  </table>
 
-[![Sponsors](https://opencollective.com/task/sponsors.svg?width=890)](https://opencollective.com/task)
+  <h2>Community Sponsors</h2>
 
-## Backers
-
-[![Backers](https://opencollective.com/task/backers.svg?width=890)](https://opencollective.com/task)
-
-## Contributors
-
-[![Contributors](https://opencollective.com/task/contributors.svg?width=890)](https://github.com/go-task/task/graphs/contributors)
+  <table>
+    <tr>
+      <td align="center" valign="middle">
+        <a target="_blank" href="https://cloudsmith.com/">
+          <img src="website/src/public/img/cloudsmith.svg" height="100px" width="200px" title="Cloudsmith" />
+        </a>
+      </td>
+    </tr>
+  </table>
+</div>

Taskfile.yml

@@ -1,88 +1,233 @@
-version: '2'
+version: '3'
 
 includes:
-  docs: ./docs
+  website:
+    aliases: [w, docs, d]
+    taskfile: ./website
+    dir: ./website
 
 vars:
-  GIT_COMMIT:
-    sh: git log -n 1 --format=%h
+  BIN: "{{.ROOT_DIR}}/bin"
+  GOTESTSUM_FORMAT: '{{if .CI}}github-actions{{else}}pkgname{{end}}'
 
-  GO_PACKAGES:
-    sh: go list ./...
+env:
+  CGO_ENABLED: '0'
 
 tasks:
   default:
     cmds:
+      - task: lint
       - task: test
 
+  run:
+    desc: Runs Task
+    cmds:
+      - go run ./cmd/task {{.CLI_ARGS}}
+
   install:
     desc: Installs Task
+    aliases: [i]
+    sources:
+      - './**/*.go'
+      - go.mod
     cmds:
-      - go install -v -ldflags="-w -s -X main.version={{.GIT_COMMIT}}" ./cmd/task
+      - go install -v ./cmd/task
+
+  generate:
+    aliases: [gen, g]
+    desc: Runs all generate tasks
+    cmds:
+      - task: generate:mocks
+      - task: generate:fixtures
+
+  generate:mocks:
+    desc: Runs Mockery to create mocks
+    aliases: [gen:mocks, g:mocks]
+    deps: [install:mockery]
+    sources:
+      - "internal/fingerprint/checker.go"
+    generates:
+      - "internal/mocks/*.go"
+    cmds:
+      - find . -type f -name *_mock.go -delete
+      - "{{.BIN}}/mockery"
+
+  generate:fixtures:
+    desc: Runs tests and generates golden fixture files
+    aliases: [gen:fixtures, g:fixtures]
     env:
-      CGO_ENABLED: '0'
-
-  dl-deps:
-    desc: Downloads cli dependencies
+      GOLDIE_UPDATE: 'true'
+      GOLDIE_TEMPLATE: 'true'
     cmds:
-      - task: go-get
-        vars: {REPO: golang.org/x/lint/golint}
-      - task: go-get
-        vars: {REPO: github.com/goreleaser/goreleaser}
-      - task: go-get
-        vars: {REPO: github.com/goreleaser/godownloader}
+      - find ./testdata -name '*.golden' -delete
+      - go test ./...
 
-  vendor:
-    desc: Sync vendor/ directory according to go.mod file
+  install:mockery:
+    desc: Installs mockgen; a tool to generate mock files
+    vars:
+      MOCKERY_VERSION: v3.2.2
+    env:
+      GOBIN: "{{.BIN}}"
+    status:
+      - go version -m {{.BIN}}/mockery | grep github.com/vektra/mockery | grep {{.MOCKERY_VERSION}}
     cmds:
-      - go mod vendor
+      - GOBIN="{{.BIN}}" go install github.com/vektra/mockery/v3@{{.MOCKERY_VERSION}}
 
-  update-deps:
-    desc: Updates dependencies
+  mod:
+    desc: Downloads and tidy Go modules
     cmds:
-      - dep ensure
-      - dep ensure -update
+      - go mod download
+      - go mod tidy
 
   clean:
     desc: Cleans temp files and folders
+    aliases: [clear]
     cmds:
       - rm -rf dist/
+      - rm -rf tmp/
 
   lint:
-    desc: Runs golint
+    desc: Runs golangci-lint
+    aliases: [l]
+    sources:
+      - './**/*.go'
+      - .golangci.yml
+      - go.mod
     cmds:
-      - golint {{catLines .GO_PACKAGES}}
+      - golangci-lint run
+
+  lint:fix:
+    desc: Runs golangci-lint and fixes any issues
+    sources:
+      - './**/*.go'
+      - .golangci.yml
+      - go.mod
+    cmds:
+      - golangci-lint run --fix
+
+  format:
+    desc: Runs golangci-lint and formats any Go files
+    aliases: [fmt, f]
+    sources:
+      - './**/*.go'
+      - .golangci.yml
+    cmds:
+      - golangci-lint fmt
+
+  sleepit:build:
+    desc: Builds the sleepit test helper
+    sources:
+      - ./cmd/sleepit/**/*.go
+    generates:
+      - "{{.BIN}}/sleepit"
+    cmds:
+      - go build -o {{.BIN}}/sleepit{{exeExt}} ./cmd/sleepit
+
+  sleepit:run:
+    desc: Builds the sleepit test helper
+    deps: [sleepit:build]
+    cmds:
+      - "{{.BIN}}/sleepit {{.CLI_ARGS}}"
     silent: true
 
   test:
     desc: Runs test suite
-    deps: [install]
+    aliases: [t]
+    deps: [gotestsum:install]
+    sources:
+      - "**/*.go"
+      - "testdata/**/*"
     cmds:
-      - go test {{catLines .GO_PACKAGES}}
+      - gotestsum -f '{{.GOTESTSUM_FORMAT}}' ./...
 
-  test-release:
+  test:watch:
+    desc: Runs test suite with watch tests included
+    deps: [sleepit:build, gotestsum:install]
+    cmds:
+      - gotestsum -f '{{.GOTESTSUM_FORMAT}}' ./... -tags 'watch'
+
+  test:all:
+    desc: Runs test suite with signals and watch tests included
+    deps: [sleepit:build, gotestsum:install]
+    cmds:
+      - gotestsum -f '{{.GOTESTSUM_FORMAT}}' -tags 'signals watch' ./...
+
+  goreleaser:test:
     desc: Tests release process without publishing
     cmds:
-      - goreleaser --snapshot --rm-dist
+      - goreleaser --snapshot --clean
 
-  generate-install-script:
-    desc: Generate install script using https://github.com/goreleaser/godownloader
+  gotestsum:install:
+    desc: Installs gotestsum
+    status:
+      - command -v gotestsum
     cmds:
-      - godownloader --repo go-task/task -o install-task.sh
-      - cp ./install-task.sh ./docs/install.sh
+      - go install gotest.tools/gotestsum@latest
 
-  ci:
+  goreleaser:install:
+    desc: Installs goreleaser
     cmds:
-      - task: go-get
-        vars: {REPO: golang.org/x/lint/golint}
-      - task: lint
-      - task: test
+      - go install github.com/goreleaser/goreleaser/v2@latest
 
-  go-get:
+  gorelease:install:
+    desc: "Installs gorelease: https://pkg.go.dev/golang.org/x/exp/cmd/gorelease"
+    status:
+      - command -v gorelease
     cmds:
-      - go get -u {{.REPO}}
+      - go install golang.org/x/exp/cmd/gorelease@latest
 
-  packages:
+  api:check:
+    desc: Checks what changes have been made to the public API
+    deps: [gorelease:install]
+    vars:
+      LATEST:
+        sh: git describe --tags --abbrev=0
     cmds:
-      - echo '{{.GO_PACKAGES}}'
-    silent: true
+      - gorelease -base={{.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, 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
+        - 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 -a v{{.VERSION}} -m v{{.VERSION}}"
+      - "git push origin tag v{{.VERSION}}"
+      - cmd: printf "%s" '{{.COMPLETE_MESSAGE}}'
+        silent: true

args/args.go

@@ -0,0 +1,59 @@
+package args
+
+import (
+	"strings"
+
+	"github.com/spf13/pflag"
+	"mvdan.cc/sh/v3/syntax"
+
+	"github.com/go-task/task/v3"
+	"github.com/go-task/task/v3/taskfile/ast"
+)
+
+// Get fetches the remaining arguments after CLI parsing and splits them into
+// two groups: the arguments before the double dash (--) and the arguments after
+// the double dash.
+func Get() ([]string, []string, error) {
+	args := pflag.Args()
+	doubleDashPos := pflag.CommandLine.ArgsLenAtDash()
+
+	if doubleDashPos == -1 {
+		return args, nil, nil
+	}
+	return args[:doubleDashPos], args[doubleDashPos:], nil
+}
+
+// Parse parses command line argument: tasks and global variables
+func Parse(args ...string) ([]*task.Call, *ast.Vars) {
+	calls := []*task.Call{}
+	globals := ast.NewVars()
+
+	for _, arg := range args {
+		if !strings.Contains(arg, "=") {
+			calls = append(calls, &task.Call{Task: arg})
+			continue
+		}
+
+		name, value := splitVar(arg)
+		globals.Set(name, ast.Var{Value: value})
+	}
+
+	return calls, globals
+}
+
+func ToQuotedString(args []string) (string, error) {
+	var quotedCliArgs []string
+	for _, arg := range args {
+		quotedCliArg, err := syntax.Quote(arg, syntax.LangBash)
+		if err != nil {
+			return "", err
+		}
+		quotedCliArgs = append(quotedCliArgs, quotedCliArg)
+	}
+	return strings.Join(quotedCliArgs, " "), nil
+}
+
+func splitVar(s string) (string, string) {
+	pair := strings.SplitN(s, "=", 2)
+	return pair[0], pair[1]
+}

args/args_test.go

@@ -0,0 +1,127 @@
+package args_test
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/go-task/task/v3"
+	"github.com/go-task/task/v3/args"
+	"github.com/go-task/task/v3/taskfile/ast"
+)
+
+func TestArgs(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		Args            []string
+		ExpectedCalls   []*task.Call
+		ExpectedGlobals *ast.Vars
+	}{
+		{
+			Args: []string{"task-a", "task-b", "task-c"},
+			ExpectedCalls: []*task.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: []*task.Call{
+				{Task: "task-a"},
+				{Task: "task-b"},
+				{Task: "task-c"},
+			},
+			ExpectedGlobals: ast.NewVars(
+				&ast.VarElement{
+					Key: "FOO",
+					Value: ast.Var{
+						Value: "bar",
+					},
+				},
+				&ast.VarElement{
+					Key: "BAR",
+					Value: ast.Var{
+						Value: "baz",
+					},
+				},
+				&ast.VarElement{
+					Key: "BAZ",
+					Value: ast.Var{
+						Value: "foo",
+					},
+				},
+			),
+		},
+		{
+			Args: []string{"task-a", "CONTENT=with some spaces"},
+			ExpectedCalls: []*task.Call{
+				{Task: "task-a"},
+			},
+			ExpectedGlobals: ast.NewVars(
+				&ast.VarElement{
+					Key: "CONTENT",
+					Value: ast.Var{
+						Value: "with some spaces",
+					},
+				},
+			),
+		},
+		{
+			Args: []string{"FOO=bar", "task-a", "task-b"},
+			ExpectedCalls: []*task.Call{
+				{Task: "task-a"},
+				{Task: "task-b"},
+			},
+			ExpectedGlobals: ast.NewVars(
+				&ast.VarElement{
+					Key: "FOO",
+					Value: ast.Var{
+						Value: "bar",
+					},
+				},
+			),
+		},
+		{
+			Args:          nil,
+			ExpectedCalls: []*task.Call{},
+		},
+		{
+			Args:          []string{},
+			ExpectedCalls: []*task.Call{},
+		},
+		{
+			Args:          []string{"FOO=bar", "BAR=baz"},
+			ExpectedCalls: []*task.Call{},
+			ExpectedGlobals: ast.NewVars(
+				&ast.VarElement{
+					Key: "FOO",
+					Value: ast.Var{
+						Value: "bar",
+					},
+				},
+				&ast.VarElement{
+					Key: "BAR",
+					Value: ast.Var{
+						Value: "baz",
+					},
+				},
+			),
+		},
+	}
+
+	for i, test := range tests {
+		t.Run(fmt.Sprintf("TestArgs%d", i+1), func(t *testing.T) {
+			t.Parallel()
+
+			calls, globals := args.Parse(test.Args...)
+			assert.Equal(t, test.ExpectedCalls, calls)
+			if test.ExpectedGlobals.Len() > 0 || globals.Len() > 0 {
+				assert.Equal(t, test.ExpectedGlobals, globals)
+				assert.Equal(t, test.ExpectedGlobals, globals)
+			}
+		})
+	}
+}

call.go

@@ -0,0 +1,11 @@
+package task
+
+import "github.com/go-task/task/v3/taskfile/ast"
+
+// Call is the parameters to a task call
+type Call struct {
+	Task     string
+	Vars     *ast.Vars
+	Silent   bool
+	Indirect bool // True if the task was called by another task
+}

cmd/release/main.go

@@ -0,0 +1,137 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"regexp"
+	"strings"
+	"time"
+
+	"github.com/Masterminds/semver/v3"
+	"github.com/spf13/pflag"
+
+	"github.com/go-task/task/v3/errors"
+)
+
+const (
+	changelogSource = "CHANGELOG.md"
+	changelogTarget = "website/src/docs/changelog.md"
+	versionFile     = "internal/version/version.txt"
+)
+
+var changelogReleaseRegex = regexp.MustCompile(`## Unreleased`)
+
+// 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(versionFile)
+	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 := setVersionFile(versionFile, version); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func getVersion(filename string) (*semver.Version, error) {
+	b, err := os.ReadFile(filename)
+	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 { //nolint:gosec
+		return err
+	}
+
+	// Wrap the changelog content with v-pre directive for VitePress to prevent
+	// Vue from interpreting template syntax like {{.TASK_VERSION}}
+	changelogWithVPre := strings.Replace(changelog, "# Changelog\n\n", "# Changelog\n\n::: v-pre\n\n", 1) + "\n:::"
+
+	// Add the frontmatter to the changelog
+	changelogWithFrontmatter := fmt.Sprintf("---\n%s\n---\n\n%s", frontmatter, changelogWithVPre)
+
+	// Write the changelog to the target file
+	return os.WriteFile(changelogTarget, []byte(changelogWithFrontmatter), 0o644) //nolint:gosec
+}
+
+func setVersionFile(fileName string, version *semver.Version) error {
+	return os.WriteFile(fileName, []byte(version.String()+"\n"), 0o644)
+}

cmd/sleepit/sleepit.go

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

cmd/task/task.go

@@ -2,150 +2,202 @@ package main
 
 import (
 	"context"
-	"log"
+	"fmt"
 	"os"
-	"os/signal"
-	"syscall"
-
-	"github.com/go-task/task/v2"
-	"github.com/go-task/task/v2/internal/args"
+	"path/filepath"
+	"strconv"
 
 	"github.com/spf13/pflag"
+
+	"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/experiments"
+	"github.com/go-task/task/v3/internal/filepathext"
+	"github.com/go-task/task/v3/internal/flags"
+	"github.com/go-task/task/v3/internal/logger"
+	"github.com/go-task/task/v3/internal/version"
+	"github.com/go-task/task/v3/taskfile/ast"
 )
 
-var (
-	version = "master"
-)
-
-const usage = `Usage: task [-ilfwvsd] [--init] [--list] [--force] [--watch] [--verbose] [--silent] [--dir] [--dry] [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".
-
-'''
-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)
-
-	pflag.Usage = func() {
-		log.Print(usage)
-		pflag.PrintDefaults()
+	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 {
+			emitCIErrorAnnotation(err)
+			l.Errf(logger.Red, "%v\n", err)
+			os.Exit(err.TaskExitCode())
+		}
+		if err, ok := err.(errors.TaskError); ok {
+			emitCIErrorAnnotation(err)
+			l.Errf(logger.Red, "%v\n", err)
+			os.Exit(err.Code())
+		}
+		emitCIErrorAnnotation(err)
+		l.Errf(logger.Red, "%v\n", err)
+		os.Exit(errors.CodeUnknown)
 	}
+	os.Exit(errors.CodeOk)
+}
 
-	var (
-		versionFlag bool
-		init        bool
-		list        bool
-		status      bool
-		force       bool
-		watch       bool
-		verbose     bool
-		silent      bool
-		dry         bool
-		dir         string
-	)
-
-	pflag.BoolVar(&versionFlag, "version", false, "show Task version")
-	pflag.BoolVarP(&init, "init", "i", false, "creates a new Taskfile.yml in the current folder")
-	pflag.BoolVarP(&list, "list", "l", false, "lists tasks with description of current Taskfile")
-	pflag.BoolVar(&status, "status", false, "exits with non-zero exit code if any of the given tasks is not up-to-date")
-	pflag.BoolVarP(&force, "force", "f", false, "forces execution even when the task is up-to-date")
-	pflag.BoolVarP(&watch, "watch", "w", false, "enables watch of the given task")
-	pflag.BoolVarP(&verbose, "verbose", "v", false, "enables verbose mode")
-	pflag.BoolVarP(&silent, "silent", "s", false, "disables echoing")
-	pflag.BoolVar(&dry, "dry", false, "compiles and prints tasks in the order that they would be run, without executing them")
-	pflag.StringVarP(&dir, "dir", "d", "", "sets directory of execution")
-	pflag.Parse()
-
-	if versionFlag {
-		log.Printf("Task version: %s\n", version)
+// emitCIErrorAnnotation emits an error annotation for supported CI providers.
+func emitCIErrorAnnotation(err error) {
+	if isGA, _ := strconv.ParseBool(os.Getenv("GITHUB_ACTIONS")); !isGA {
 		return
 	}
+	if e, ok := err.(*errors.TaskRunError); ok {
+		fmt.Fprintf(os.Stdout, "::error title=Task '%s' failed::%v\n", e.TaskName, e.Err)
+		return
+	}
+	fmt.Fprintf(os.Stdout, "::error title=Task failed::%v\n", err)
+}
 
-	if init {
+func run() error {
+	log := &logger.Logger{
+		Stdout:  os.Stdout,
+		Stderr:  os.Stderr,
+		Verbose: flags.Verbose,
+		Color:   flags.Color,
+	}
+
+	if err := flags.Validate(); err != nil {
+		return err
+	}
+
+	if err := experiments.Validate(); err != nil {
+		log.Warnf("%s\n", err.Error())
+	}
+
+	if flags.Version {
+		fmt.Println(version.GetVersionWithBuildInfo())
+		return nil
+	}
+
+	if flags.Help {
+		pflag.Usage()
+		return nil
+	}
+
+	if flags.Experiments {
+		return log.PrintExperiments()
+	}
+
+	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)
+		args, _, err := args.Get()
+		if err != nil {
+			return err
 		}
-		return
+		path := wd
+		if len(args) > 0 {
+			name := args[0]
+			if filepathext.IsExtOnly(name) {
+				name = filepathext.SmartJoin(filepath.Dir(name), "Taskfile"+filepath.Ext(name))
+			}
+			path = filepathext.SmartJoin(wd, name)
+		}
+		finalPath, err := task.InitTaskfile(path)
+		if err != nil {
+			return err
+		}
+		if !flags.Silent {
+			if flags.Verbose {
+				log.Outf(logger.Default, "%s\n", task.DefaultTaskfile)
+			}
+			log.Outf(logger.Green, "Taskfile created: %s\n", filepathext.TryAbsToRel(finalPath))
+		}
+		return nil
+	}
+
+	if flags.Completion != "" {
+		script, err := task.Completion(flags.Completion)
+		if err != nil {
+			return err
+		}
+		fmt.Println(script)
+		return nil
+	}
+
+	e := task.NewExecutor(
+		flags.WithFlags(),
+		task.WithVersionCheck(true),
+	)
+	if err := e.Setup(); err != nil {
+		return err
+	}
+
+	if flags.ClearCache {
+		cachePath := filepath.Join(e.TempDir.Remote, "remote")
+		return os.RemoveAll(cachePath)
+	}
+
+	listOptions := task.NewListOptions(
+		flags.List,
+		flags.ListAll,
+		flags.ListJson,
+		flags.NoStatus,
+		flags.Nested,
+	)
+	if listOptions.ShouldListTasks() {
+		if flags.Silent {
+			return e.ListTaskNames(flags.ListAll)
+		}
+		foundTasks, err := e.ListTasks(listOptions)
+		if err != nil {
+			return err
+		}
+		if !foundTasks {
+			os.Exit(errors.CodeUnknown)
+		}
+		return nil
+	}
+
+	// Parse the remaining arguments
+	cliArgsPreDash, cliArgsPostDash, err := args.Get()
+	if err != nil {
+		return err
+	}
+	calls, globals := args.Parse(cliArgsPreDash...)
+
+	// If there are no calls, run the default task instead
+	if len(calls) == 0 {
+		calls = append(calls, &task.Call{Task: "default"})
+	}
+
+	// Merge CLI variables first (e.g. FOO=bar) so they take priority over Taskfile defaults
+	e.Taskfile.Vars.Merge(globals, nil)
+
+	// Then ReverseMerge special variables so they're available for templating
+	cliArgsPostDashQuoted, err := args.ToQuotedString(cliArgsPostDash)
+	if err != nil {
+		return err
+	}
+	specialVars := ast.NewVars()
+	specialVars.Set("CLI_ARGS", ast.Var{Value: cliArgsPostDashQuoted})
+	specialVars.Set("CLI_ARGS_LIST", ast.Var{Value: cliArgsPostDash})
+	specialVars.Set("CLI_FORCE", ast.Var{Value: flags.Force || flags.ForceAll})
+	specialVars.Set("CLI_SILENT", ast.Var{Value: flags.Silent})
+	specialVars.Set("CLI_VERBOSE", ast.Var{Value: flags.Verbose})
+	specialVars.Set("CLI_OFFLINE", ast.Var{Value: flags.Offline})
+	specialVars.Set("CLI_ASSUME_YES", ast.Var{Value: flags.AssumeYes})
+	e.Taskfile.Vars.ReverseMerge(specialVars, nil)
+	if !flags.Watch {
+		e.InterceptInterruptSignals()
 	}
 
 	ctx := context.Background()
-	if !watch {
-		ctx = getSignalContext()
+
+	if flags.Status {
+		return e.Status(ctx, calls...)
 	}
 
-	e := task.Executor{
-		Force:   force,
-		Watch:   watch,
-		Verbose: verbose,
-		Silent:  silent,
-		Dir:     dir,
-		Dry:     dry,
-
-		Context: ctx,
-
-		Stdin:  os.Stdin,
-		Stdout: os.Stdout,
-		Stderr: os.Stderr,
-	}
-	if err := e.Setup(); err != nil {
-		log.Fatal(err)
-	}
-
-	if list {
-		e.PrintTasksHelp()
-		return
-	}
-
-	arguments := pflag.Args()
-	if len(arguments) == 0 {
-		log.Println("task: No argument given, trying default task")
-		arguments = []string{"default"}
-	}
-
-	calls, err := args.Parse(arguments...)
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	if status {
-		if err = e.Status(calls...); err != nil {
-			log.Fatal(err)
-		}
-		return
-	}
-
-	if err := e.Run(calls...); err != nil {
-		log.Fatal(err)
-	}
-}
-
-func getSignalContext() context.Context {
-	ch := make(chan os.Signal, 1)
-	signal.Notify(ch, os.Interrupt, os.Kill, syscall.SIGTERM)
-	ctx, cancel := context.WithCancel(context.Background())
-	go func() {
-		sig := <-ch
-		log.Printf("task: signal received: %s", sig)
-		cancel()
-	}()
-	return ctx
+	return e.Run(ctx, calls...)
 }

compiler.go

@@ -0,0 +1,231 @@
+package task
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+
+	"github.com/go-task/task/v3/internal/env"
+	"github.com/go-task/task/v3/internal/execext"
+	"github.com/go-task/task/v3/internal/filepathext"
+	"github.com/go-task/task/v3/internal/logger"
+	"github.com/go-task/task/v3/internal/templater"
+	"github.com/go-task/task/v3/internal/version"
+	"github.com/go-task/task/v3/taskfile/ast"
+)
+
+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 *Call) (*ast.Vars, error) {
+	return c.getVariables(t, call, true)
+}
+
+func (c *Compiler) FastGetVariables(t *ast.Task, call *Call) (*ast.Vars, error) {
+	return c.getVariables(t, call, false)
+}
+
+func (c *Compiler) getVariables(t *ast.Task, call *Call, evaluateShVars bool) (*ast.Vars, error) {
+	result := env.GetEnviron()
+	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
+			// Preserve the Sh field so it can be displayed in summary
+			if !evaluateShVars && newVar.Value == nil {
+				result.Set(k, ast.Var{Value: "", Sh: newVar.Sh})
+				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, Sh: newVar.Sh})
+				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 already set, we can set it and return
+			if newVar.Value != nil || newVar.Sh == nil {
+				result.Set(k, ast.Var{Value: newVar.Value})
+				return nil
+			}
+			// If the variable is dynamic, we need to resolve it first
+			static, err := c.HandleDynamicVar(newVar, dir, env.GetFromVars(result))
+			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)
+	}
+
+	for k, v := range c.TaskfileEnv.All() {
+		if err := rangeFunc(k, v); err != nil {
+			return nil, err
+		}
+	}
+	for k, v := range c.TaskfileVars.All() {
+		if err := rangeFunc(k, v); err != nil {
+			return nil, err
+		}
+	}
+	if t != nil {
+		for k, v := range t.IncludeVars.All() {
+			if err := rangeFunc(k, v); err != nil {
+				return nil, err
+			}
+		}
+		for k, v := range t.IncludedTaskfileVars.All() {
+			if err := taskRangeFunc(k, v); err != nil {
+				return nil, err
+			}
+		}
+	}
+
+	if t == nil || call == nil {
+		return result, nil
+	}
+
+	for k, v := range call.Vars.All() {
+		if err := rangeFunc(k, v); err != nil {
+			return nil, err
+		}
+	}
+	for k, v := range t.Vars.All() {
+		if err := taskRangeFunc(k, v); err != nil {
+			return nil, err
+		}
+	}
+
+	return result, nil
+}
+
+func (c *Compiler) HandleDynamicVar(v ast.Var, dir string, e []string) (string, error) {
+	c.muDynamicCache.Lock()
+	defer c.muDynamicCache.Unlock()
+
+	// If the variable is not dynamic or it is empty, return an empty string
+	if v.Sh == nil || *v.Sh == "" {
+		return "", nil
+	}
+
+	if c.dynamicCache == nil {
+		c.dynamicCache = make(map[string]string, 30)
+	}
+	if result, ok := c.dynamicCache[*v.Sh]; ok {
+		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,
+		Env:     e,
+	}
+	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 dynamic variables cache
+func (c *Compiler) ResetCache() {
+	c.muDynamicCache.Lock()
+	defer c.muDynamicCache.Unlock()
+
+	c.dynamicCache = nil
+}
+
+func (c *Compiler) getSpecialVars(t *ast.Task, call *Call) (map[string]string, error) {
+	// Use filepath.ToSlash for all paths to ensure consistent forward slashes
+	// across platforms. This prevents issues with backslashes being interpreted
+	// as escape sequences when paths are used in shell commands on Windows.
+	allVars := map[string]string{
+		"TASK_EXE":            filepath.ToSlash(os.Args[0]),
+		"ROOT_TASKFILE":       filepath.ToSlash(filepathext.SmartJoin(c.Dir, c.Entrypoint)),
+		"ROOT_DIR":            filepath.ToSlash(c.Dir),
+		"USER_WORKING_DIR":    filepath.ToSlash(c.UserWorkingDir),
+		"TASK_VERSION":        version.GetVersion(),
+		"PATH_LIST_SEPARATOR": string(os.PathListSeparator),
+		"FILE_PATH_SEPARATOR": string(os.PathSeparator),
+	}
+	if t != nil {
+		allVars["TASK"] = t.Task
+		allVars["TASK_DIR"] = filepath.ToSlash(filepathext.SmartJoin(c.Dir, t.Dir))
+		allVars["TASKFILE"] = filepath.ToSlash(t.Location.Taskfile)
+		allVars["TASKFILE_DIR"] = filepath.ToSlash(filepath.Dir(t.Location.Taskfile))
+	} else {
+		allVars["TASK"] = ""
+		allVars["TASK_DIR"] = ""
+		allVars["TASKFILE"] = ""
+		allVars["TASKFILE_DIR"] = ""
+	}
+	if call != nil {
+		allVars["ALIAS"] = call.Task
+	} else {
+		allVars["ALIAS"] = ""
+	}
+
+	return allVars, nil
+}

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

@@ -0,0 +1,60 @@
+# vim: set tabstop=2 shiftwidth=2 expandtab:
+
+_GO_TASK_COMPLETION_LIST_OPTION='--list-all'
+TASK_CMD="${TASK_EXE:-task}"
+
+function _task()
+{
+  local cur prev words cword
+  _init_completion -n : || return
+
+  # 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|--remote-cache-dir)
+      _filedir -d
+      return $?
+    ;;
+    --cacert|--cert|--cert-key)
+      _filedir
+      return $?
+    ;;
+    -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 _task "$TASK_CMD"

completion/fish/task.fish

@@ -0,0 +1,120 @@
+set -l GO_TASK_PROGNAME (if set -q GO_TASK_PROGNAME; echo $GO_TASK_PROGNAME; else if set -q TASK_EXE; echo $TASK_EXE; else; echo task; end)
+
+# Cache variables for experiments (global)
+set -g __task_experiments_cache ""
+set -g __task_experiments_cache_time 0
+
+# Helper function to get experiments with 1-second cache
+function __task_get_experiments --inherit-variable GO_TASK_PROGNAME
+    set -l now (date +%s)
+    set -l ttl 1  # Cache for 1 second only
+
+    # Return cached value if still valid
+    if test (math "$now - $__task_experiments_cache_time") -lt $ttl
+        printf '%s\n' $__task_experiments_cache
+        return
+    end
+
+    # Refresh cache
+    set -g __task_experiments_cache ($GO_TASK_PROGNAME --experiments 2>/dev/null)
+    set -g __task_experiments_cache_time $now
+    printf '%s\n' $__task_experiments_cache
+end
+
+# Helper function to check if an experiment is enabled
+function __task_is_experiment_enabled
+    set -l experiment $argv[1]
+    __task_get_experiments | string match -qr "^\* $experiment:.*on"
+end
+
+function __task_get_tasks --description "Prints all available tasks with their description" --inherit-variable GO_TASK_PROGNAME
+  # Check if the global task is requested
+  set -l global_task false
+  commandline --current-process | read --tokenize --list --local cmd_args
+  for arg in $cmd_args
+    if test "_$arg" = "_--"
+      break # ignore arguments to be passed to the task
+    end
+    if test "_$arg" = "_--global" -o "_$arg" = "_-g"
+      set global_task true
+      break
+    end
+  end
+
+  # Read the list of tasks (and potential errors)
+  if $global_task
+    $GO_TASK_PROGNAME --global --list-all
+  else
+    $GO_TASK_PROGNAME --list-all
+  end 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/\* \(.*\):[[:space:]]\{2,\}\(.*\)[[:space:]]\{2,\}(\(aliases.*\))/\1\t\2\t\3/' -e 's/\* \(.*\):[[:space:]]\{2,\}\(.*\)/\1\t\2/'| string split0)
+  if test $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)" \
+  -n "not __fish_seen_subcommand_from --"
+
+# Standard flags
+complete -c $GO_TASK_PROGNAME -s a -l list-all                  -d 'list all tasks'
+complete -c $GO_TASK_PROGNAME -s c -l color                     -d 'colored output (default true)'
+complete -c $GO_TASK_PROGNAME -s C -l concurrency               -d 'limit number of concurrent tasks'
+complete -c $GO_TASK_PROGNAME      -l completion                -d 'generate shell completion script' -xa "bash zsh fish powershell"
+complete -c $GO_TASK_PROGNAME -s d -l dir                       -d 'set directory of execution'
+complete -c $GO_TASK_PROGNAME      -l disable-fuzzy             -d 'disable fuzzy matching for task names'
+complete -c $GO_TASK_PROGNAME -s n -l dry                       -d 'compile and print tasks without executing'
+complete -c $GO_TASK_PROGNAME -s x -l exit-code                 -d 'pass-through exit code of task command'
+complete -c $GO_TASK_PROGNAME      -l experiments               -d 'list available experiments'
+complete -c $GO_TASK_PROGNAME -s F -l failfast                  -d 'when running tasks in parallel, stop all tasks if one fails'
+complete -c $GO_TASK_PROGNAME -s f -l force                     -d 'force execution even when up-to-date'
+complete -c $GO_TASK_PROGNAME -s g -l global                    -d 'run global Taskfile from home directory'
+complete -c $GO_TASK_PROGNAME -s h -l help                      -d 'show help'
+complete -c $GO_TASK_PROGNAME -s i -l init                      -d 'create new Taskfile'
+complete -c $GO_TASK_PROGNAME      -l insecure                  -d 'allow insecure Taskfile downloads'
+complete -c $GO_TASK_PROGNAME -s I -l interval                  -d 'interval to watch for changes'
+complete -c $GO_TASK_PROGNAME -s j -l json                      -d 'format task list as JSON'
+complete -c $GO_TASK_PROGNAME -s l -l list                      -d 'list tasks with descriptions'
+complete -c $GO_TASK_PROGNAME      -l nested                    -d 'nest namespaces when listing as JSON'
+complete -c $GO_TASK_PROGNAME      -l no-status                 -d 'ignore status when listing as JSON'
+complete -c $GO_TASK_PROGNAME      -l interactive               -d 'prompt for missing required variables'
+complete -c $GO_TASK_PROGNAME -s o -l output                    -d 'set output style' -xa "interleaved group prefixed"
+complete -c $GO_TASK_PROGNAME      -l output-group-begin        -d 'message template before grouped output'
+complete -c $GO_TASK_PROGNAME      -l output-group-end          -d 'message template after grouped output'
+complete -c $GO_TASK_PROGNAME      -l output-group-error-only   -d 'hide output from successful tasks'
+complete -c $GO_TASK_PROGNAME -s p -l parallel                  -d 'execute tasks in parallel'
+complete -c $GO_TASK_PROGNAME -s s -l silent                    -d 'disable echoing'
+complete -c $GO_TASK_PROGNAME      -l sort                      -d 'set task sorting order' -xa "default alphanumeric none"
+complete -c $GO_TASK_PROGNAME      -l status                    -d 'exit non-zero if tasks not up-to-date'
+complete -c $GO_TASK_PROGNAME      -l summary                   -d 'show task summary'
+complete -c $GO_TASK_PROGNAME -s t -l taskfile                  -d 'choose Taskfile to run'
+complete -c $GO_TASK_PROGNAME -s v -l verbose                   -d 'verbose output'
+complete -c $GO_TASK_PROGNAME      -l version                   -d 'show version'
+complete -c $GO_TASK_PROGNAME -s w -l watch                     -d 'watch mode, re-run on changes'
+complete -c $GO_TASK_PROGNAME -s y -l yes                       -d 'assume yes to all prompts'
+
+# Experimental flags (dynamically checked at completion time via -n condition)
+# GentleForce experiment
+complete -c $GO_TASK_PROGNAME -n "__task_is_experiment_enabled GENTLE_FORCE" -l force-all -d 'force execution of task and all dependencies'
+
+# RemoteTaskfiles experiment - Options
+complete -c $GO_TASK_PROGNAME -n "__task_is_experiment_enabled REMOTE_TASKFILES" -l offline          -d 'use only local or cached Taskfiles'
+complete -c $GO_TASK_PROGNAME -n "__task_is_experiment_enabled REMOTE_TASKFILES" -l timeout          -d 'timeout for remote Taskfile downloads'
+complete -c $GO_TASK_PROGNAME -n "__task_is_experiment_enabled REMOTE_TASKFILES" -l expiry           -d 'cache expiry duration'
+complete -c $GO_TASK_PROGNAME -n "__task_is_experiment_enabled REMOTE_TASKFILES" -l remote-cache-dir -d 'directory to cache remote Taskfiles' -xa "(__fish_complete_directories)"
+complete -c $GO_TASK_PROGNAME -n "__task_is_experiment_enabled REMOTE_TASKFILES" -l cacert           -d 'custom CA certificate for TLS' -r
+complete -c $GO_TASK_PROGNAME -n "__task_is_experiment_enabled REMOTE_TASKFILES" -l cert             -d 'client certificate for mTLS' -r
+complete -c $GO_TASK_PROGNAME -n "__task_is_experiment_enabled REMOTE_TASKFILES" -l cert-key         -d 'client certificate private key' -r
+
+# RemoteTaskfiles experiment - Operations
+complete -c $GO_TASK_PROGNAME -n "__task_is_experiment_enabled REMOTE_TASKFILES" -l download    -d 'download remote Taskfile'
+complete -c $GO_TASK_PROGNAME -n "__task_is_experiment_enabled REMOTE_TASKFILES" -l clear-cache -d 'clear remote Taskfile cache'

completion/ps/task.ps1

@@ -0,0 +1,92 @@
+using namespace System.Management.Automation
+
+Register-ArgumentCompleter -CommandName task -ScriptBlock {
+	param($commandName, $parameterName, $wordToComplete, $commandAst, $fakeBoundParameters)
+
+	if ($commandName.StartsWith('-')) {
+		$completions = @(
+			# Standard flags (alphabetical order)
+			[CompletionResult]::new('-a', '-a', [CompletionResultType]::ParameterName, 'list all tasks'),
+			[CompletionResult]::new('--list-all', '--list-all', [CompletionResultType]::ParameterName, 'list all tasks'),
+			[CompletionResult]::new('-c', '-c', [CompletionResultType]::ParameterName, 'colored output'),
+			[CompletionResult]::new('--color', '--color', [CompletionResultType]::ParameterName, 'colored output'),
+			[CompletionResult]::new('-C', '-C', [CompletionResultType]::ParameterName, 'limit concurrent tasks'),
+			[CompletionResult]::new('--concurrency', '--concurrency', [CompletionResultType]::ParameterName, 'limit concurrent tasks'),
+			[CompletionResult]::new('--completion', '--completion', [CompletionResultType]::ParameterName, 'generate shell completion'),
+			[CompletionResult]::new('-d', '-d', [CompletionResultType]::ParameterName, 'set directory'),
+			[CompletionResult]::new('--dir', '--dir', [CompletionResultType]::ParameterName, 'set directory'),
+			[CompletionResult]::new('--disable-fuzzy', '--disable-fuzzy', [CompletionResultType]::ParameterName, 'disable fuzzy matching'),
+			[CompletionResult]::new('-n', '-n', [CompletionResultType]::ParameterName, 'dry run'),
+			[CompletionResult]::new('--dry', '--dry', [CompletionResultType]::ParameterName, 'dry run'),
+			[CompletionResult]::new('-x', '-x', [CompletionResultType]::ParameterName, 'pass-through exit code'),
+			[CompletionResult]::new('--exit-code', '--exit-code', [CompletionResultType]::ParameterName, 'pass-through exit code'),
+			[CompletionResult]::new('--experiments', '--experiments', [CompletionResultType]::ParameterName, 'list experiments'),
+			[CompletionResult]::new('-F', '-F', [CompletionResultType]::ParameterName, 'fail fast on pallalel tasks'),
+			[CompletionResult]::new('--failfast', '--failfast', [CompletionResultType]::ParameterName, 'force execution'),
+			[CompletionResult]::new('-f', '-f', [CompletionResultType]::ParameterName, 'force execution'),
+			[CompletionResult]::new('--force', '--force', [CompletionResultType]::ParameterName, 'force execution'),
+			[CompletionResult]::new('-g', '-g', [CompletionResultType]::ParameterName, 'run global Taskfile'),
+			[CompletionResult]::new('--global', '--global', [CompletionResultType]::ParameterName, 'run global Taskfile'),
+			[CompletionResult]::new('-h', '-h', [CompletionResultType]::ParameterName, 'show help'),
+			[CompletionResult]::new('--help', '--help', [CompletionResultType]::ParameterName, 'show help'),
+			[CompletionResult]::new('-i', '-i', [CompletionResultType]::ParameterName, 'create new Taskfile'),
+			[CompletionResult]::new('--init', '--init', [CompletionResultType]::ParameterName, 'create new Taskfile'),
+			[CompletionResult]::new('--insecure', '--insecure', [CompletionResultType]::ParameterName, 'allow insecure downloads'),
+			[CompletionResult]::new('-I', '-I', [CompletionResultType]::ParameterName, 'watch interval'),
+			[CompletionResult]::new('--interval', '--interval', [CompletionResultType]::ParameterName, 'watch interval'),
+			[CompletionResult]::new('-j', '-j', [CompletionResultType]::ParameterName, 'format as JSON'),
+			[CompletionResult]::new('--json', '--json', [CompletionResultType]::ParameterName, 'format as JSON'),
+			[CompletionResult]::new('-l', '-l', [CompletionResultType]::ParameterName, 'list tasks'),
+			[CompletionResult]::new('--list', '--list', [CompletionResultType]::ParameterName, 'list tasks'),
+			[CompletionResult]::new('--nested', '--nested', [CompletionResultType]::ParameterName, 'nest namespaces in JSON'),
+			[CompletionResult]::new('--no-status', '--no-status', [CompletionResultType]::ParameterName, 'ignore status in JSON'),
+			[CompletionResult]::new('--interactive', '--interactive', [CompletionResultType]::ParameterName, 'prompt for missing required variables'),
+			[CompletionResult]::new('-o', '-o', [CompletionResultType]::ParameterName, 'set output style'),
+			[CompletionResult]::new('--output', '--output', [CompletionResultType]::ParameterName, 'set output style'),
+			[CompletionResult]::new('--output-group-begin', '--output-group-begin', [CompletionResultType]::ParameterName, 'template before group'),
+			[CompletionResult]::new('--output-group-end', '--output-group-end', [CompletionResultType]::ParameterName, 'template after group'),
+			[CompletionResult]::new('--output-group-error-only', '--output-group-error-only', [CompletionResultType]::ParameterName, 'hide successful output'),
+			[CompletionResult]::new('-p', '-p', [CompletionResultType]::ParameterName, 'execute in parallel'),
+			[CompletionResult]::new('--parallel', '--parallel', [CompletionResultType]::ParameterName, 'execute in parallel'),
+			[CompletionResult]::new('-s', '-s', [CompletionResultType]::ParameterName, 'silent mode'),
+			[CompletionResult]::new('--silent', '--silent', [CompletionResultType]::ParameterName, 'silent mode'),
+			[CompletionResult]::new('--sort', '--sort', [CompletionResultType]::ParameterName, 'task sorting order'),
+			[CompletionResult]::new('--status', '--status', [CompletionResultType]::ParameterName, 'check task status'),
+			[CompletionResult]::new('--summary', '--summary', [CompletionResultType]::ParameterName, 'show task summary'),
+			[CompletionResult]::new('-t', '-t', [CompletionResultType]::ParameterName, 'choose Taskfile'),
+			[CompletionResult]::new('--taskfile', '--taskfile', [CompletionResultType]::ParameterName, 'choose Taskfile'),
+			[CompletionResult]::new('-v', '-v', [CompletionResultType]::ParameterName, 'verbose output'),
+			[CompletionResult]::new('--verbose', '--verbose', [CompletionResultType]::ParameterName, 'verbose output'),
+			[CompletionResult]::new('--version', '--version', [CompletionResultType]::ParameterName, 'show version'),
+			[CompletionResult]::new('-w', '-w', [CompletionResultType]::ParameterName, 'watch mode'),
+			[CompletionResult]::new('--watch', '--watch', [CompletionResultType]::ParameterName, 'watch mode'),
+			[CompletionResult]::new('-y', '-y', [CompletionResultType]::ParameterName, 'assume yes'),
+			[CompletionResult]::new('--yes', '--yes', [CompletionResultType]::ParameterName, 'assume yes')
+		)
+
+		# Experimental flags (dynamically added based on enabled experiments)
+		$experiments = & task --experiments 2>$null | Out-String
+
+		if ($experiments -match '\* GENTLE_FORCE:.*on') {
+			$completions += [CompletionResult]::new('--force-all', '--force-all', [CompletionResultType]::ParameterName, 'force all dependencies')
+		}
+
+		if ($experiments -match '\* REMOTE_TASKFILES:.*on') {
+			# Options
+			$completions += [CompletionResult]::new('--offline', '--offline', [CompletionResultType]::ParameterName, 'use cached Taskfiles')
+			$completions += [CompletionResult]::new('--timeout', '--timeout', [CompletionResultType]::ParameterName, 'download timeout')
+			$completions += [CompletionResult]::new('--expiry', '--expiry', [CompletionResultType]::ParameterName, 'cache expiry')
+			$completions += [CompletionResult]::new('--remote-cache-dir', '--remote-cache-dir', [CompletionResultType]::ParameterName, 'cache directory')
+			$completions += [CompletionResult]::new('--cacert', '--cacert', [CompletionResultType]::ParameterName, 'custom CA certificate')
+			$completions += [CompletionResult]::new('--cert', '--cert', [CompletionResultType]::ParameterName, 'client certificate')
+			$completions += [CompletionResult]::new('--cert-key', '--cert-key', [CompletionResultType]::ParameterName, 'client private key')
+			# Operations
+			$completions += [CompletionResult]::new('--download', '--download', [CompletionResultType]::ParameterName, 'download remote Taskfile')
+			$completions += [CompletionResult]::new('--clear-cache', '--clear-cache', [CompletionResultType]::ParameterName, 'clear cache')
+		}
+
+		return $completions.Where{ $_.CompletionText.StartsWith($commandName) }
+	}
+
+	return 	$(task --list-all --silent) | Where-Object { $_.StartsWith($commandName) } | ForEach-Object { return $_ + " " }
+}

completion/zsh/_task

@@ -1,25 +1,154 @@
 #compdef task
+typeset -A opt_args
+TASK_CMD="${TASK_EXE:-task}"
+compdef _task "$TASK_CMD"
+
+_GO_TASK_COMPLETION_LIST_OPTION="${GO_TASK_COMPLETION_LIST_OPTION:---list-all}"
+
+# Check if an experiment is enabled
+function __task_is_experiment_enabled() {
+    local experiment=$1
+    task --experiments 2>/dev/null | grep -q "^\* ${experiment}:.*on"
+}
 
 # Listing commands from Taskfile.yml
-function __list() {
-    local -a scripts
+function __task_list() {
+    local -a scripts cmd
+    local -i enabled=0
+    local taskfile item task desc
 
-    if [ -f Taskfile.yml ]; then
-        scripts=($(task -l | sed '1d' | sed 's/://' | awk '{ print $2 }'))
-        _describe 'script' scripts
+    cmd=($TASK_CMD)
+    taskfile=${(Qv)opt_args[(i)-t|--taskfile]}
+    taskfile=${taskfile//\~/$HOME}
+
+    for arg in "${words[@]:0:$CURRENT}"; do
+        if [[ "$arg" = "--" ]]; then
+            # Use default completion for words after `--` as they are CLI_ARGS.
+            _default
+            return 0
+        fi
+    done
+
+    if [[ -n "$taskfile" && -f "$taskfile" ]]; then
+        cmd+=(--taskfile "$taskfile")
+    fi
+
+    # Check if global flag is set
+    if (( ${+opt_args[-g]} || ${+opt_args[--global]} )); then
+        cmd+=(--global)
+    fi
+
+    if output=$("${cmd[@]}" $_GO_TASK_COMPLETION_LIST_OPTION 2>/dev/null); then
+        enabled=1
+    fi
+
+    (( enabled )) || return 0
+
+    scripts=()
+
+    # Read zstyle verbose option (default = true via -T)
+    local show_desc
+    zstyle -T ":completion:${curcontext}:" verbose && show_desc=true || show_desc=false
+
+    for item in "${(@)${(f)output}[2,-1]#\* }"; do
+        task="${item%%:[[:space:]]*}"
+
+        if [[ "$show_desc" == "true" ]]; then
+            local desc="${item##[^[:space:]]##[[:space:]]##}"
+            scripts+=( "${task//:/\\:}:$desc" )
+        else
+            scripts+=( "$task" )
+        fi
+    done
+
+    if [[ "$show_desc" == "true" ]]; then
+        _describe 'Task to run' scripts
+    else
+        compadd -Q -a scripts
     fi
 }
 
-_arguments \
-    '(-d --dir)'{-d,--dir}': :_files' \
-    '(--dry)'--dry \
-    '(-f --force)'{-f,--force} \
-    '(-i --init)'{-i,--init} \
-    '(-l --list)'{-l,--list} \
-    '(-s --silent)'{-s,--silent} \
-    '(--status)'--status \
-    '(-v --verbose)'{-v,--verbose} \
-    '(--version)'--version \
-    '(-w --watch)'{-w,--watch} \
-    '(- *)'{-h,--help} \
-    '*: :__list' \
+_task() {
+    local -a standard_args operation_args
+
+    standard_args=(
+        '(-C --concurrency)'{-C,--concurrency}'[limit number of concurrent tasks]: '
+        '(-p --parallel)'{-p,--parallel}'[run command-line tasks in parallel]'
+        '(-F --failfast)'{-F,--failfast}'[when running tasks in parallel, stop all tasks if one fails]'
+        '(-f --force)'{-f,--force}'[run even if task is up-to-date]'
+        '(-c --color)'{-c,--color}'[colored output]'
+        '(--completion)--completion[generate shell completion script]:shell:(bash zsh fish powershell)'
+        '(-d --dir)'{-d,--dir}'[dir to run in]:execution dir:_dirs'
+        '(--disable-fuzzy)--disable-fuzzy[disable fuzzy matching for task names]'
+        '(-n --dry)'{-n,--dry}'[compiles and prints tasks without executing]'
+        '(--dry)--dry[dry-run mode, compile and print tasks only]'
+        '(-x --exit-code)'{-x,--exit-code}'[pass-through exit code of task command]'
+        '(--experiments)--experiments[list available experiments]'
+        '(-g --global)'{-g,--global}'[run global Taskfile from home directory]'
+        '(--insecure)--insecure[allow insecure Taskfile downloads]'
+        '(-I --interval)'{-I,--interval}'[interval to watch for changes]:duration: '
+        '(-j --json)'{-j,--json}'[format task list as JSON]'
+        '(--nested)--nested[nest namespaces when listing as JSON]'
+        '(--no-status)--no-status[ignore status when listing as JSON]'
+        '(--interactive)--interactive[prompt for missing required variables]'
+        '(-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: '
+        '(--output-group-error-only)--output-group-error-only[hide output from successful tasks]'
+        '(-s --silent)'{-s,--silent}'[disable echoing]'
+        '(--sort)--sort[set task sorting order]:order:(default alphanumeric none)'
+        '(--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]'
+        '(-y --yes)'{-y,--yes}'[assume yes to all prompts]'
+    )
+
+    # Experimental flags (dynamically added based on enabled experiments)
+    # Options (modify behavior)
+    if __task_is_experiment_enabled "GENTLE_FORCE"; then
+        standard_args+=('(--force-all)--force-all[force execution of task and all dependencies]')
+    fi
+
+    if __task_is_experiment_enabled "REMOTE_TASKFILES"; then
+        standard_args+=(
+            '(--offline --download)--offline[use only local or cached Taskfiles]'
+            '(--timeout)--timeout[timeout for remote Taskfile downloads]:duration: '
+            '(--expiry)--expiry[cache expiry duration]:duration: '
+            '(--remote-cache-dir)--remote-cache-dir[directory to cache remote Taskfiles]:cache dir:_dirs'
+            '(--cacert)--cacert[custom CA certificate for TLS]:file:_files'
+            '(--cert)--cert[client certificate for mTLS]:file:_files'
+            '(--cert-key)--cert-key[client certificate private key]:file:_files'
+        )
+    fi
+
+    operation_args=(
+        # Task names completion (can be specified multiple times)
+        '(operation)*: :__task_list'
+        # Operational args completion (mutually exclusive)
+        + '(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]'
+    )
+
+    # Experimental operations (dynamically added based on enabled experiments)
+    if __task_is_experiment_enabled "REMOTE_TASKFILES"; then
+        standard_args+=(
+            '(--offline --clear-cache)--download[download remote Taskfile]'
+        )
+        operation_args+=(
+            '(* --download)--clear-cache[clear remote Taskfile cache]'
+        )
+    fi
+
+    _arguments -S $standard_args $operation_args
+}
+
+# don't run the completion function when being source-ed or eval-ed
+if [ "$funcstack[1]" = "_task" ]; then
+    _task "$@"
+fi

concurrency.go

@@ -0,0 +1,25 @@
+package task
+
+func (e *Executor) acquireConcurrencyLimit() func() {
+	if e.concurrencySemaphore == nil {
+		return emptyFunc
+	}
+
+	e.concurrencySemaphore <- struct{}{}
+	return func() {
+		<-e.concurrencySemaphore
+	}
+}
+
+func (e *Executor) releaseConcurrencyLimit() func() {
+	if e.concurrencySemaphore == nil {
+		return emptyFunc
+	}
+
+	<-e.concurrencySemaphore
+	return func() {
+		e.concurrencySemaphore <- struct{}{}
+	}
+}
+
+func emptyFunc() {}

docs/CNAME

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

docs/README.md

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

docs/Taskfile.yml

@@ -1,12 +0,0 @@
-version: '2'
-
-tasks:
-  install:
-    desc: Installs docsify to work the on the documentation site
-    cmds:
-      - npm install docsify-cli -g
-
-  serve:
-    desc: Serves the documentation site locally
-    cmds:
-      - docsify serve docs

docs/_sidebar.md

@@ -1,7 +0,0 @@
-- [Installation](installation.md)
-- [Usage](usage.md)
-- [Taskfile Versions](taskfile_versions.md)
-- [Examples](examples.md)
-- [Releasing Task](releasing_task.md)
-- [Alternative Task Runners](alternative_task_runners.md)
-- [![Github](https://icongram.jgog.in/simple/github.svg?color=808080&size=16)Github](https://github.com/go-task/task)

docs/alternative_task_runners.md

@@ -1,17 +0,0 @@
-# Alternative task runners
-
-## YAML based
-
-- [rliebz/tusk][tusk]
-
-## Go based
-
-- [magefile/mage][mage]
-
-## Make similar
-
-- [casey/just][just]
-
-[tusk]: https://github.com/rliebz/tusk
-[mage]: https://github.com/magefile/mage
-[just]: https://github.com/casey/just

docs/examples.md

@@ -1,7 +0,0 @@
-# Examples
-
-The [go-task/examples][examples] intends to be a collection of Taskfiles for
-various use cases.
-(It still lacks many examples, though. Contributions are welcome).
-
-[examples]: https://github.com/go-task/examples

docs/index.html

@@ -1,49 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8">
-    <title>Task</title>
-    <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1" />
-    <meta name="description" content="A task runner / simpler Make alternative written in Go">
-    <meta name="viewport" content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
-    <link rel="stylesheet" href="//unpkg.com/docsify-themeable/dist/css/theme-simple.css">
-    <meta name="google-site-verification" content="VGAYkbdmuaciIDGkBe-eAg9yfZg0C6ostgonbGxxOa0" />
-    <script>
-      var SeedAndDewConfig = {};
-      (function() {
-        SeedAndDewConfig['adClass'] = "snd-ad";
-        /* * * DON'T EDIT BELOW THIS LINE * * */
-        SeedAndDewConfig['projectId'] = '16e0aed0-b265-48c9-9eae-0aad56147553';
-        SeedAndDewConfig['loadStartTime'] = performance.now();
-        SeedAndDewConfig['apiVersion'] = '2018-05-28'
-        SeedAndDewConfig['sessionId'] = Math.random().toString(36).substring(2, 15);
-        var snd = document.createElement('script');
-        snd.type = 'text/javascript';
-        snd.async = true;
-        snd.src = 'https://www.seedanddew.com/static/embed.min.js';
-        (document.getElementsByTagName('head')[0] ||
-        document.getElementsByTagName('body')[0]).appendChild(snd);
-      })();
-    </script>
-  </head>
-  <body>
-    <div id="app"></div>
-    <script>
-      window.$docsify = {
-        name: 'Task',
-        repo: 'go-task/task',
-        ga: 'UA-126286662-1',
-        themeColor: '#83d0f2',
-        loadSidebar: true,
-        auto2top: true,
-        maxLevel: 3,
-        subMaxLevel: 3
-      }
-    </script>
-    <script src="//unpkg.com/docsify/lib/docsify.min.js"></script>
-    <script src="//unpkg.com/docsify/lib/plugins/ga.min.js"></script>
-    <script src="//unpkg.com/docsify-themeable"></script>
-    <script src="//unpkg.com/prismjs/components/prism-bash.min.js"></script>
-    <script src="//unpkg.com/prismjs/components/prism-yaml.min.js"></script>
-  </body>
-</html>

docs/installation.md

@@ -1,90 +0,0 @@
-# Installation
-
-## Binary
-
-Or you can download the binary from the [releases][releases] page and add to
-your $PATH. DEB and RPM packages are also available.
-The `task_checksums.txt` file contains the sha256 checksum for each file.
-
-## Homebrew
-
-If you're on macOS and have [Homebrew][homebrew] installed, getting Task is
-as simple as running:
-
-```bash
-brew install go-task/tap/go-task
-```
-
-## Snap
-
-Task is available for [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
-```
-
-## Scoop
-
-If you're on Windows and have [Scoop][scoop] installed, use `extras` bucket
-to install Task like:
-
-```cmd
-scoop bucket add extras
-scoop install task
-```
-
-This installation method is community owned. After a new release of Task, it
-may take some time until it's available on Scoop.
-
-## Go
-
-Task now uses [Go Modules](https://github.com/golang/go/wiki/Modules), which
-means you may have trouble compiling it on older Go versions.
-
-For CI environments we recommend using the [Install Script](#install-script)
-instead, which is faster and more stable, since it'll just download the latest
-released binary, instead of compiling the edge (master branch) version.
-
-Installing in your `$GOPATH`:
-
-```bash
-go get -u -v github.com/go-task/task/cmd/task
-```
-
-Installing in another directory:
-
-```bash
-git clone https://github.com/go-task/task
-cd task
-
-# compiling binary to $GOPATH/bin
-go install -v
-
-# compiling it to another location
-# use -o ./task.exe on Windows
-go build -v -o ./task ./cmd/task
-```
-
-Both methods requires having the [Go][go] environment properly setup locally.
-
-## Install script
-
-We also have a [install script][installscript], which is very useful on
-scenarios like CIs. Many thanks to [godownloader][godownloader] for allowing
-easily generating this script.
-
-```bash
-curl -s https://taskfile.org/install.sh | sh
-```
-
-> This method will download the binary on the local `./bin` directory by default.
-
-[go]: https://golang.org/
-[snapcraft]: https://snapcraft.io/
-[homebrew]: https://brew.sh/
-[installscript]: https://github.com/go-task/task/blob/master/install-task.sh
-[releases]: https://github.com/go-task/task/releases
-[godownloader]: https://github.com/goreleaser/godownloader
-[scoop]: https://scoop.sh/

docs/releasing_task.md

@@ -1,39 +0,0 @@
-# Releasing Task
-
-The release process of Task is done with the help of
-[GoReleaser][goreleaser]. You can test the release process locally by calling
-the `test-release` task of the Taskfile.
-
-The Travis CI should release automatically when a new
-Git tag is pushed to master, either for the artifact uploading (raw executables
-and DEB and RPM packages)
-
-# Homebrew
-
-To release a new version on the [Homebrew tap][homebrewtap] edit the
-[Formula/go-task.rb][gotaskrb] file, updating with the new version, download
-URL and sha256.
-
-# Snapcraft
-
-The exception is the publishing of a new version of the
-[snap package][snappackage]. This current require two steps after publishing
-the binaries:
-
-* Updating the current version on [snapcraft.yaml][snapcraftyaml];
-* Moving both `i386` and `amd64` new artifacts to the stable channel on
-the [Snapscraft 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/task.json).
-If you think its Task version is outdated, open an issue to let us know.
-
-[goreleaser]: https://goreleaser.com/#continuous_integration
-[homebrewtap]: https://github.com/go-task/homebrew-tap
-[gotaskrb]: https://github.com/go-task/homebrew-tap/blob/master/Formula/go-task.rb
-[snappackage]: https://github.com/go-task/snap
-[snapcraftyaml]: https://github.com/go-task/snap/blob/master/snap/snapcraft.yaml#L2
-[snapcraftdashboard]: https://dashboard.snapcraft.io/

docs/taskfile_versions.md

@@ -1,148 +0,0 @@
-# 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. You you choose to use `2.0` Task will not enable future
-`2.1` features, but if you choose to use `2`, than any `2.x.x` features will be
-available, but not `3.0.0+`.
-
-## Version 1
-
-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 envolve 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 not 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
-```
-
-Please check the [documentation][includes]
-
-[output]: usage.md#output-syntax
-[ignore_errors]: usage.md#ignore-errors
-[includes]: usage.md#including-other-taskfiles

docs/usage.md

@@ -1,714 +0,0 @@
-# Usage
-
-## Getting started
-
-Create a file called `Taskfile.yml` in the root of your project.
-The `cmds` attribute should contain the commands of a task.
-The example below allows compiling a Go app and uses [Minify][minify] to concat
-and minify multiple CSS files into a single one.
-
-```yaml
-version: '2'
-
-tasks:
-  build:
-    cmds:
-      - go build -v -i main.go
-
-  assets:
-    cmds:
-      - minify -o public/style.css src/css
-```
-
-Running the tasks is as simple as running:
-
-```bash
-task assets build
-```
-
-Task uses [github.com/mvdan/sh](https://github.com/mvdan/sh), a native Go sh
-interpreter. So you can write sh/bash commands and it will work even on
-Windows, where `sh` or `bash` are usually not available. Just remember any
-executable called must be available by the OS or in PATH.
-
-If you omit a task name, "default" will be assumed.
-
-## Environment
-
-You can use `env` to set custom environment variables for a specific task:
-
-```yaml
-version: '2'
-
-tasks:
-  greet:
-    cmds:
-      - echo $GREETING
-    env:
-      GREETING: Hey, there!
-```
-
-Additionally, you can set globally environment variables, that'll be available
-to all tasks:
-
-```yaml
-version: '2'
-
-env:
-  GREETING: Hey, there!
-
-tasks:
-  greet:
-    cmds:
-      - echo $GREETING
-```
-
-> NOTE: `env` supports expansion and and retrieving output from a shell command
-> just like variables, as you can see on the [Variables](#variables) section.
-
-## Operating System specific tasks
-
-If you add a `Taskfile_{{GOOS}}.yml` you can override or amend your Taskfile
-based on the operating system.
-
-Example:
-
-Taskfile.yml:
-
-```yaml
-version: '2'
-
-tasks:
-  build:
-    cmds:
-      - echo "default"
-```
-
-Taskfile_linux.yml:
-
-```yaml
-version: '2'
-
-tasks:
-  build:
-    cmds:
-      - echo "linux"
-```
-
-Will print out `linux` and not `default`.
-
-Keep in mind that the version of the files should match. Also, when redefining
-a task the whole task is replaced, properties of the task are not merged.
-
-It's also possible to have an OS specific `Taskvars.yml` file, like
-`Taskvars_windows.yml`, `Taskvars_linux.yml`, or `Taskvars_darwin.yml`. See the
-[variables section](#variables) below.
-
-## Including other Taskfiles
-
-> This feature is still experimental and may have bugs.
-
-If you want to share tasks between different projects (Taskfiles), you can use
-the importing mechanism to include other Taskfiles using the `includes` keyword:
-
-```yaml
-version: '2'
-
-includes:
-  docs: ./documentation # will look for ./documentation/Taskfile.yml
-  docker: ./DockerTasks.yml
-```
-
-The tasks described in the given Taskfiles will be available with the informed
-namespace. So, you'd call `task docs:serve` to run the `serve` task from
-`documentation/Taskfile.yml` or `task docker:build` to run the `build` task
-from the `DockerTasks.yml` file.
-
-> The included Taskfiles must be using the same schema version the main
-> Taskfile uses.
-
-> Also, for now included Taskfiles can't include other Taskfiles.
-> This was a deliberate decision to keep use and implementation simple.
-> If you disagree, open an GitHub issue and explain your use case. =)
-
-## Task directory
-
-By default, tasks will be executed in the directory where the Taskfile is
-located. But you can easily make the task run in another folder informing
-`dir`:
-
-```yaml
-version: '2'
-
-tasks:
-  serve:
-    dir: public/www
-    cmds:
-      # run http server
-      - caddy
-```
-
-## Task dependencies
-
-You may have tasks that depend on others. Just pointing them on `deps` will
-make them run automatically before running the parent task:
-
-```yaml
-version: '2'
-
-tasks:
-  build:
-    deps: [assets]
-    cmds:
-      - go build -v -i main.go
-
-  assets:
-    cmds:
-      - minify -o public/style.css src/css
-```
-
-In the above example, `assets` will always run right before `build` if you run
-`task build`.
-
-A task can have only dependencies and no commands to group tasks together:
-
-```yaml
-version: '2'
-
-tasks:
-  assets:
-    deps: [js, css]
-
-  js:
-    cmds:
-      - minify -o public/script.js src/js
-
-  css:
-    cmds:
-      - minify -o public/style.css src/css
-```
-
-If there is more than one dependency, they always run in parallel for better
-performance.
-
-If you want to pass information to dependencies, you can do that the same
-manner as you would to [call another task](#calling-another-task):
-
-```yaml
-version: '2'
-
-tasks:
-  default:
-    deps:
-      - task: echo_sth
-        vars: {TEXT: "before 1"}
-      - task: echo_sth
-        vars: {TEXT: "before 2"}
-    cmds:
-      - echo "after"
-
-  echo_sth:
-    cmds:
-      - echo {{.TEXT}}
-```
-
-## Calling another task
-
-When a task has many dependencies, they are executed concurrently. This will
-often result in a faster build pipeline. But in some situations you may need
-to call other tasks serially. In this case, just use the following syntax:
-
-```yaml
-version: '2'
-
-tasks:
-  main-task:
-    cmds:
-      - task: task-to-be-called
-      - task: another-task
-      - echo "Both done"
-
-  task-to-be-called:
-    cmds:
-      - echo "Task to be called"
-
-  another-task:
-    cmds:
-      - echo "Another task"
-```
-
-Overriding variables in the called task is as simple as informing `vars`
-attribute:
-
-```yaml
-version: '2'
-
-tasks:
-  main-task:
-    cmds:
-      - task: write-file
-        vars: {FILE: "hello.txt", CONTENT: "Hello!"}
-      - task: write-file
-        vars: {FILE: "world.txt", CONTENT: "World!"}
-
-  write-file:
-    cmds:
-      - echo "{{.CONTENT}}" > {{.FILE}}
-```
-
-The above syntax is also supported in `deps`.
-
-## Prevent unnecessary work
-
-If a task generates something, you can inform Task the source and generated
-files, so Task will prevent to run them if not necessary.
-
-```yaml
-version: '2'
-
-tasks:
-  build:
-    deps: [js, css]
-    cmds:
-      - go build -v -i main.go
-
-  js:
-    cmds:
-      - minify -o public/script.js src/js
-    sources:
-      - src/js/**/*.js
-    generates:
-      - public/script.js
-
-  css:
-    cmds:
-      - minify -o public/style.css src/css
-    sources:
-      - src/css/**/*.css
-    generates:
-      - public/style.css
-```
-
-`sources` and `generates` can be files or file patterns. When both are given,
-Task will compare the modification date/time of the files to determine if it's
-necessary to run the task. If not, it will just print a message like
-`Task "js" is up to date`.
-
-If you prefer this check to be made by the content of the files, instead of
-its timestamp, just set the `method` property to `checksum`.
-You will probably want to ignore the `.task` folder in your `.gitignore` file
-(It's there that Task stores the last checksum).
-
-```yaml
-version: '2'
-
-tasks:
-  build:
-    cmds:
-      - go build .
-    sources:
-      - ./*.go
-    generates:
-      - app{{exeExt}}
-    method: checksum
-```
-
-> TIP: method `none` skips any validation and always run the task.
-
-Alternatively, you can inform a sequence of tests as `status`. If no error
-is returned (exit status 0), the task is considered up-to-date:
-
-```yaml
-version: '2'
-
-tasks:
-  generate-files:
-    cmds:
-      - mkdir directory
-      - touch directory/file1.txt
-      - touch directory/file2.txt
-    # test existence of files
-    status:
-      - test -d directory
-      - test -f directory/file1.txt
-      - test -f directory/file2.txt
-```
-
-You can use `--force` or `-f` if you want to force a task to run even when
-up-to-date.
-
-Also, `task --status [tasks]...` will exit with a non-zero exit code if any of
-the tasks are not up-to-date.
-
-## Variables
-
-When doing interpolation of variables, Task will look for the below.
-They are listed below in order of importance (e.g. most important first):
-
-- Variables declared locally in the task
-- Variables given while calling a task from another.
-  (See [Calling another task](#calling-another-task) above)
-- Variables declared in the `vars:` option in the `Taskfile`
-- Variables available in the `Taskvars.yml` file
-- Environment variables
-
-Example of sending parameters with environment variables:
-
-```bash
-$ TASK_VARIABLE=a-value task do-something
-```
-
-Since some shells don't support above syntax to set environment variables
-(Windows) tasks also accepts a similar style when not in the beginning of
-the command. Variables given in this form are only visible to the task called
-right before.
-
-```bash
-$ task write-file FILE=file.txt "CONTENT=Hello, World!" print "MESSAGE=All done!"
-```
-
-Example of locally declared vars:
-
-```yaml
-version: '2'
-
-tasks:
-  print-var:
-    cmds:
-      echo "{{.VAR}}"
-    vars:
-      VAR: Hello!
-```
-
-Example of global vars in a `Taskfile.yml`:
-
-```yaml
-version: '2'
-
-vars:
-  GREETING: Hello from Taskfile!
-
-tasks:
-  greet:
-    cmds:
-      - echo "{{.GREETING}}"
-```
-
-Example of `Taskvars.yml` file:
-
-```yaml
-PROJECT_NAME: My Project
-DEV_MODE: production
-GIT_COMMIT: {sh: git log -n 1 --format=%h}
-```
-
-### Variables expansion
-
-Variables are expanded 2 times by default. You can change that by setting the
-`expansions:` option. Change that will be necessary if you compose many
-variables together:
-
-```yaml
-version: '2'
-
-expansions: 3
-
-vars:
-  FOO: foo
-  BAR: bar
-  BAZ: baz
-  FOOBAR: "{{.FOO}}{{.BAR}}"
-  FOOBARBAZ: "{{.FOOBAR}}{{.BAZ}}"
-
-tasks:
-  default:
-    cmds:
-      - echo "{{.FOOBARBAZ}}"
-```
-
-### Dynamic variables
-
-The below syntax (`sh:` prop in a variable) is considered a dynamic variable.
-The value will be treated as a command and the output assigned. If there is one
-or more trailing newlines, the last newline will be trimmed.
-
-```yaml
-version: '2'
-
-tasks:
-  build:
-    cmds:
-      - go build -ldflags="-X main.Version={{.GIT_COMMIT}}" main.go
-    vars:
-      GIT_COMMIT:
-        sh: git log -n 1 --format=%h
-```
-
-This works for all types of variables.
-
-## Go's template engine
-
-Task parse commands as [Go's template engine][gotemplate] before executing
-them. Variables are accessible through dot syntax (`.VARNAME`).
-
-All functions by the Go's [sprig lib](http://masterminds.github.io/sprig/)
-are available. The following example gets the current date in a given format:
-
-```yaml
-version: '2'
-
-tasks:
-  print-date:
-    cmds:
-      - echo {{now | date "2006-01-02"}}
-```
-
-Task also adds the following functions:
-
-- `OS`: Returns operating system. Possible values are "windows", "linux",
-  "darwin" (macOS) and "freebsd".
-- `ARCH`: return the architecture Task was compiled to: "386", "amd64", "arm"
-  or "s390x".
-- `splitLines`: Splits Unix (\n) and Windows (\r\n) styled newlines.
-- `catLines`: Replaces Unix (\n) and Windows (\r\n) styled newlines with a space.
-- `toSlash`: Does nothing on Unix, but on Windows converts a string from `\`
-  path format to `/`.
-- `fromSlash`: Opposite of `toSlash`. Does nothing on Unix, but on Windows
-  converts a string from `\` path format to `/`.
-- `exeExt`: Returns the right executable extension for the current OS
-  (`".exe"` for Windows, `""` for others).
-
-Example:
-
-```yaml
-version: '2'
-
-tasks:
-  print-os:
-    cmds:
-      - echo '{{OS}} {{ARCH}}'
-      - echo '{{if eq OS "windows"}}windows-command{{else}}unix-command{{end}}'
-      # This will be path/to/file on Unix but path\to\file on Windows
-      - echo '{{fromSlash "path/to/file"}}'
-  enumerated-file:
-    vars:
-      CONTENT: |
-        foo
-        bar
-    cmds:
-      - |
-        cat << EOF > output.txt
-        {{range $i, $line := .CONTENT | splitLines -}}
-        {{printf "%3d" $i}}: {{$line}}
-        {{end}}EOF
-```
-
-## Help
-
-Running `task --list` (or `task -l`) lists all tasks with a description.
-The following Taskfile:
-
-```yaml
-version: '2'
-
-tasks:
-  build:
-    desc: Build the go binary.
-    cmds:
-      - go build -v -i main.go
-
-  test:
-    desc: Run all the go tests.
-    cmds:
-      - go test -race ./...
-
-  js:
-    cmds:
-      - minify -o public/script.js src/js
-
-  css:
-    cmds:
-      - minify -o public/style.css src/css
-```
-
-would print the following output:
-
-```bash
-* build:   Build the go binary.
-* test:    Run all the go tests.
-```
-
-## Silent mode
-
-Silent mode disables echoing of commands before Task runs it.
-For the following Taskfile:
-
-```yaml
-version: '2'
-
-tasks:
-  echo:
-    cmds:
-      - echo "Print something"
-```
-
-Normally this will be print:
-
-```sh
-echo "Print something"
-Print something
-```
-
-With silent mode on, the below will be print instead:
-
-```sh
-Print something
-```
-
-There's three ways to enable silent mode:
-
-* At command level:
-
-```yaml
-version: '2'
-
-tasks:
-  echo:
-    cmds:
-      - cmd: echo "Print something"
-        silent: true
-```
-
-* At task level:
-
-```yaml
-version: '2'
-
-tasks:
-  echo:
-    cmds:
-      - echo "Print something"
-    silent: true
-```
-
-* Or globally with `--silent` or `-s` flag
-
-If you want to suppress STDOUT instead, just redirect a command to `/dev/null`:
-
-```yaml
-version: '2'
-
-tasks:
-  echo:
-    cmds:
-      - echo "This will print nothing" > /dev/null
-```
-
-## Dry run mode
-
-Dry run mode (`--dry`) compiles and steps through each task, printing the commands
-that would be run without executing them. This is useful for debugging your Taskfiles.
-
-## Ignore errors
-
-You have the option to ignore errors during command execution.
-Given the following Taskfile:
-
-```yaml
-version: '2'
-
-tasks:
-  echo:
-    cmds:
-      - exit 1
-      - echo "Hello World"
-```
-
-Task will abort the execution after running `exit 1` because the status code `1` stands for `EXIT_FAILURE`.
-However it is possible to continue with execution using `ignore_error`:
-
-```yaml
-version: '2'
-
-tasks:
-  echo:
-    cmds:
-      - cmd: exit 1
-        ignore_error: true
-      - echo "Hello World"
-```
-
-`ignore_error` can also be set for a task, which mean errors will be supressed
-for all commands. But keep in mind this option won't propagate to other tasks
-called either by `deps` or `cmds`!
-
-## Output syntax
-
-By default, Task just redirect the STDOUT and STDERR of the running commands
-to the shell in real time. This is good for having live feedback for log
-printed by commands, but the output can become messy if you have multiple
-commands running at the same time and printing lots of stuff.
-
-To make this more customizable, there are currently three different output
-options you can choose:
-
-- `interleaved` (default)
-- `group`
-- `prefixed`
-
-To choose another one, just set it to root in the Taskfile:
-
-```yaml
-version: '2'
-
-output: 'group'
-
-tasks:
-  # ...
-```
-
- The `group` output will print the entire output of a command once, after it
- finishes, so you won't have live feedback for commands that take a long time
- to run.
-
- The `prefix` output will prefix every line printed by a command with
- `[task-name] ` as the prefix, but you can customize the prefix for a command
- with the `prefix:` attribute:
-
- ```yaml
-version: '2'
-
-output: prefixed
-
-tasks:
-  default:
-    deps:
-      - task: print
-        vars: {TEXT: foo}
-      - task: print
-        vars: {TEXT: bar}
-      - task: print
-        vars: {TEXT: baz}
-
-  print:
-    cmds:
-      - echo "{{.TEXT}}"
-    prefix: "print-{{.TEXT}}"
-    silent: true
-```
-
-```bash
-$ task default
-[print-foo] foo
-[print-bar] bar
-[print-baz] baz
-```
-
-## Watch tasks
-
-If you give a `--watch` or `-w` argument, task will watch for file changes
-and run the task again. This requires the `sources` attribute to be given,
-so task know which files to watch.
-
-[gotemplate]: https://golang.org/pkg/text/template/
-[minify]: https://github.com/tdewolff/minify/tree/master/cmd/minify

errors.go

@@ -1,43 +0,0 @@
-package task
-
-import (
-	"errors"
-	"fmt"
-)
-
-var (
-	// ErrTaskfileAlreadyExists is returned on creating a Taskfile if one already exists
-	ErrTaskfileAlreadyExists = errors.New("task: A Taskfile already exists")
-)
-
-type taskNotFoundError struct {
-	taskName string
-}
-
-func (err *taskNotFoundError) Error() string {
-	return fmt.Sprintf(`task: Task "%s" not found`, err.taskName)
-}
-
-type taskRunError struct {
-	taskName string
-	err      error
-}
-
-func (err *taskRunError) Error() string {
-	return fmt.Sprintf(`task: Failed to run task "%s": %v`, err.taskName, err.err)
-}
-
-// MaximumTaskCallExceededError is returned when a task is called too
-// many times. In this case you probably have a cyclic dependendy or
-// infinite loop
-type MaximumTaskCallExceededError struct {
-	task string
-}
-
-func (e *MaximumTaskCallExceededError) Error() string {
-	return fmt.Sprintf(
-		`task: maximum task call exceeded (%d) for task "%s": probably an cyclic dep or infinite loop`,
-		MaximumTaskCall,
-		e.task,
-	)
-}

errors/error_taskfile_decode.go

@@ -0,0 +1,127 @@
+package errors
+
+import (
+	"bytes"
+	"cmp"
+	"errors"
+	"fmt"
+	"strings"
+
+	"github.com/fatih/color"
+	"go.yaml.in/yaml/v3"
+)
+
+type (
+	TaskfileDecodeError struct {
+		Message  string
+		Location string
+		Line     int
+		Column   int
+		Tag      string
+		Snippet  string
+		Err      error
+	}
+)
+
+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", message))
+				}
+			} else {
+				fmt.Fprintln(buf, color.RedString("err:  %s", 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))
+	fmt.Fprint(buf, err.Snippet)
+	return buf.String()
+}
+
+func (err *TaskfileDecodeError) Debug() string {
+	const indentWidth = 2
+	buf := &bytes.Buffer{}
+	fmt.Fprintln(buf, "TaskfileDecodeError:")
+
+	// Recursively loop through the error chain and print any details
+	var debug func(error, int)
+	debug = func(err error, indent int) {
+		indentStr := strings.Repeat(" ", indent*indentWidth)
+
+		// Nothing left to unwrap
+		if err == nil {
+			fmt.Fprintf(buf, "%sEnd of chain\n", indentStr)
+			return
+		}
+
+		// Taskfile decode error
+		decodeErr := &TaskfileDecodeError{}
+		if errors.As(err, &decodeErr) {
+			fmt.Fprintf(buf, "%s%s (%s:%d:%d)\n",
+				indentStr,
+				cmp.Or(decodeErr.Message, "<no_message>"),
+				decodeErr.Location,
+				decodeErr.Line,
+				decodeErr.Column,
+			)
+			debug(errors.Unwrap(err), indent+1)
+			return
+		}
+
+		fmt.Fprintf(buf, "%s%s\n", indentStr, err)
+		debug(errors.Unwrap(err), indent+1)
+	}
+	debug(err, 0)
+	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, snippet string) *TaskfileDecodeError {
+	err.Location = location
+	err.Snippet = snippet
+	return err
+}

errors/errors.go

@@ -0,0 +1,72 @@
+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
+)
+
+// TaskRC related exit codes
+const (
+	CodeTaskRCNotFoundError int = iota + 50
+)
+
+// Taskfile related exit codes
+const (
+	CodeTaskfileNotFound int = iota + 100
+	CodeTaskfileAlreadyExists
+	CodeTaskfileDecode
+	CodeTaskfileFetchFailed
+	CodeTaskfileNotTrusted
+	CodeTaskfileNotSecure
+	CodeTaskfileCacheNotFound
+	CodeTaskfileVersionCheckError
+	CodeTaskfileNetworkTimeout
+	CodeTaskfileInvalid
+	CodeTaskfileCycle
+	CodeTaskfileDoesNotMatchChecksum
+)
+
+// Task related exit codes
+const (
+	CodeTaskNotFound int = iota + 200
+	CodeTaskRunError
+	CodeTaskInternal
+	CodeTaskNameConflict
+	CodeTaskCalledTooManyTimes
+	CodeTaskCancelled
+	CodeTaskMissingRequiredVars
+	CodeTaskNotAllowedVars
+)
+
+// 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,208 @@
+package errors
+
+import (
+	"errors"
+	"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 {
+	var exit interp.ExitStatus
+	if errors.As(err.Err, &exit) {
+		return int(exit)
+	}
+	return err.Code()
+}
+
+func (err *TaskRunError) Unwrap() error {
+	return err.Err
+}
+
+// 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
+}
+
+// TaskMissingRequiredVarsError is returned when a task is missing required variables.
+
+type MissingVar struct {
+	Name          string
+	AllowedValues []string
+}
+type TaskMissingRequiredVarsError struct {
+	TaskName    string
+	MissingVars []MissingVar
+}
+
+func (v MissingVar) String() string {
+	if len(v.AllowedValues) == 0 {
+		return v.Name
+	}
+	return fmt.Sprintf("%s (allowed values: %v)", v.Name, v.AllowedValues)
+}
+
+func (err *TaskMissingRequiredVarsError) Error() string {
+	vars := make([]string, 0, len(err.MissingVars))
+	for _, v := range err.MissingVars {
+		vars = append(vars, v.String())
+	}
+
+	return fmt.Sprintf(
+		`task: Task %q cancelled because it is missing required variables: %s`,
+		err.TaskName,
+		strings.Join(vars, ", "))
+}
+
+func (err *TaskMissingRequiredVarsError) Code() int {
+	return CodeTaskMissingRequiredVars
+}
+
+type NotAllowedVar struct {
+	Value string
+	Enum  []string
+	Name  string
+}
+
+type TaskNotAllowedVarsError struct {
+	TaskName       string
+	NotAllowedVars []NotAllowedVar
+}
+
+func (err *TaskNotAllowedVarsError) Error() string {
+	var builder strings.Builder
+
+	builder.WriteString(fmt.Sprintf("task: Task %q cancelled because it is missing required variables:\n", err.TaskName)) //nolint:staticcheck
+	for _, s := range err.NotAllowedVars {
+		builder.WriteString(fmt.Sprintf("  - %s has an invalid value : '%s' (allowed values : %v)\n", s.Name, s.Value, s.Enum)) //nolint:staticcheck
+	}
+
+	return builder.String()
+}
+
+func (err *TaskNotAllowedVarsError) Code() int {
+	return CodeTaskNotAllowedVars
+}

errors/errors_taskfile.go

@@ -0,0 +1,218 @@
+package errors
+
+import (
+	"fmt"
+	"net/http"
+	"path/filepath"
+	"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
+	AskInit     bool
+	OwnerChange bool
+}
+
+func (err TaskfileNotFoundError) Error() string {
+	var walkText string
+	if err.OwnerChange {
+		walkText = " (or any of the parent directories until ownership changed)."
+	} else if err.Walk {
+		walkText = " (or any of the parent directories)."
+	}
+	if err.AskInit {
+		walkText += " Run `task --init` to create a new Taskfile."
+	}
+	return fmt.Sprintf(`task: No Taskfile found at %q%s`, filepath.ToSlash(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", filepath.ToSlash(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`, filepath.ToSlash(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`,
+		filepath.ToSlash(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`,
+		filepath.ToSlash(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`,
+		filepath.ToSlash(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`,
+			filepath.ToSlash(err.URI),
+		)
+	}
+	return fmt.Sprintf(
+		"task: Invalid schema version in Taskfile %q:\nSchema version (%s) %s",
+		filepath.ToSlash(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
+}
+
+func (err *TaskfileNetworkTimeoutError) Error() string {
+	return fmt.Sprintf(
+		`task: Network connection timed out after %s while attempting to download Taskfile %q`,
+		err.Timeout, filepath.ToSlash(err.URI),
+	)
+}
+
+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",
+		filepath.ToSlash(err.Source),
+		filepath.ToSlash(err.Destination),
+	)
+}
+
+func (err TaskfileCycleError) Code() int {
+	return CodeTaskfileCycle
+}
+
+// TaskfileDoesNotMatchChecksum is returned when a Taskfile's checksum does not
+// match the one pinned in the parent Taskfile.
+type TaskfileDoesNotMatchChecksum struct {
+	URI              string
+	ExpectedChecksum string
+	ActualChecksum   string
+}
+
+func (err *TaskfileDoesNotMatchChecksum) Error() string {
+	return fmt.Sprintf(
+		"task: The checksum of the Taskfile at %q does not match!\ngot: %q\nwant: %q",
+		filepath.ToSlash(err.URI),
+		err.ActualChecksum,
+		err.ExpectedChecksum,
+	)
+}
+
+func (err *TaskfileDoesNotMatchChecksum) Code() int {
+	return CodeTaskfileDoesNotMatchChecksum
+}

errors/errors_taskrc.go

@@ -0,0 +1,20 @@
+package errors
+
+import "fmt"
+
+type TaskRCNotFoundError struct {
+	URI  string
+	Walk bool
+}
+
+func (err TaskRCNotFoundError) Error() string {
+	var walkText string
+	if err.Walk {
+		walkText = " (or any of the parent directories)"
+	}
+	return fmt.Sprintf(`task: No Task config file found at %q%s`, err.URI, walkText)
+}
+
+func (err TaskRCNotFoundError) Code() int {
+	return CodeTaskRCNotFoundError
+}

executor.go

@@ -0,0 +1,619 @@
+package task
+
+import (
+	"context"
+	"io"
+	"os"
+	"sync"
+	"time"
+
+	"github.com/puzpuzpuz/xsync/v4"
+	"github.com/sajari/fuzzy"
+
+	"github.com/go-task/task/v3/internal/logger"
+	"github.com/go-task/task/v3/internal/output"
+	"github.com/go-task/task/v3/internal/sort"
+	"github.com/go-task/task/v3/taskfile/ast"
+)
+
+type (
+	// An ExecutorOption is any type that can apply a configuration to an
+	// [Executor].
+	ExecutorOption interface {
+		ApplyToExecutor(*Executor)
+	}
+	// An Executor is used for processing Taskfile(s) and executing the task(s)
+	// within them.
+	Executor struct {
+		// Flags
+		Dir                 string
+		Entrypoint          string
+		TempDir             TempDir
+		Force               bool
+		ForceAll            bool
+		Insecure            bool
+		Download            bool
+		Offline             bool
+		TrustedHosts        []string
+		Timeout             time.Duration
+		CacheExpiryDuration time.Duration
+		RemoteCacheDir      string
+		CACert              string
+		Cert                string
+		CertKey             string
+		Watch               bool
+		Verbose             bool
+		Silent              bool
+		DisableFuzzy        bool
+		AssumeYes           bool
+		AssumeTerm          bool // Used for testing
+		Interactive         bool
+		Dry                 bool
+		Summary             bool
+		Parallel            bool
+		Color               bool
+		Concurrency         int
+		Interval            time.Duration
+		Failfast            bool
+
+		// I/O
+		Stdin  io.Reader
+		Stdout io.Writer
+		Stderr io.Writer
+
+		// Internal
+		Taskfile           *ast.Taskfile
+		Logger             *logger.Logger
+		Compiler           *Compiler
+		Output             output.Output
+		OutputStyle        ast.Output
+		TaskSorter         sort.Sorter
+		UserWorkingDir     string
+		EnableVersionCheck bool
+
+		fuzzyModel     *fuzzy.Model
+		fuzzyModelOnce sync.Once
+
+		promptedVars         *ast.Vars // vars collected via interactive prompts
+		concurrencySemaphore chan struct{}
+		taskCallCount        map[string]*int32
+		mkdirMutexMap        map[string]*sync.Mutex
+		executionHashes      map[string]context.Context
+		executionHashesMutex sync.Mutex
+		watchedDirs          *xsync.Map[string, bool]
+	}
+	TempDir struct {
+		Remote      string
+		Fingerprint string
+	}
+)
+
+// NewExecutor creates a new [Executor] and applies the given functional options
+// to it.
+func NewExecutor(opts ...ExecutorOption) *Executor {
+	e := &Executor{
+		Timeout:              time.Second * 10,
+		Stdin:                os.Stdin,
+		Stdout:               os.Stdout,
+		Stderr:               os.Stderr,
+		Logger:               nil,
+		Compiler:             nil,
+		Output:               nil,
+		OutputStyle:          ast.Output{},
+		TaskSorter:           sort.AlphaNumericWithRootTasksFirst,
+		UserWorkingDir:       "",
+		fuzzyModel:           nil,
+		concurrencySemaphore: nil,
+		taskCallCount:        map[string]*int32{},
+		mkdirMutexMap:        map[string]*sync.Mutex{},
+		executionHashes:      map[string]context.Context{},
+		executionHashesMutex: sync.Mutex{},
+	}
+	e.Options(opts...)
+	return e
+}
+
+// Options loops through the given [ExecutorOption] functions and applies them
+// to the [Executor].
+func (e *Executor) Options(opts ...ExecutorOption) {
+	for _, opt := range opts {
+		opt.ApplyToExecutor(e)
+	}
+}
+
+// WithDir sets the working directory of the [Executor]. By default, the
+// directory is set to the user's current working directory.
+func WithDir(dir string) ExecutorOption {
+	return &dirOption{dir}
+}
+
+type dirOption struct {
+	dir string
+}
+
+func (o *dirOption) ApplyToExecutor(e *Executor) {
+	e.Dir = o.dir
+}
+
+// WithEntrypoint sets the entrypoint (main Taskfile) of the [Executor]. By
+// default, Task will search for one of the default Taskfiles in the given
+// directory.
+func WithEntrypoint(entrypoint string) ExecutorOption {
+	return &entrypointOption{entrypoint}
+}
+
+type entrypointOption struct {
+	entrypoint string
+}
+
+func (o *entrypointOption) ApplyToExecutor(e *Executor) {
+	e.Entrypoint = o.entrypoint
+}
+
+// WithTempDir sets the temporary directory that will be used by [Executor] for
+// storing temporary files like checksums and cached remote files. By default,
+// the temporary directory is set to the user's temporary directory.
+func WithTempDir(tempDir TempDir) ExecutorOption {
+	return &tempDirOption{tempDir}
+}
+
+type tempDirOption struct {
+	tempDir TempDir
+}
+
+func (o *tempDirOption) ApplyToExecutor(e *Executor) {
+	e.TempDir = o.tempDir
+}
+
+// WithForce ensures that the [Executor] always runs a task, even when
+// fingerprinting or prompts would normally stop it.
+func WithForce(force bool) ExecutorOption {
+	return &forceOption{force}
+}
+
+type forceOption struct {
+	force bool
+}
+
+func (o *forceOption) ApplyToExecutor(e *Executor) {
+	e.Force = o.force
+}
+
+// WithForceAll ensures that the [Executor] always runs all tasks (including
+// subtasks), even when fingerprinting or prompts would normally stop them.
+func WithForceAll(forceAll bool) ExecutorOption {
+	return &forceAllOption{forceAll}
+}
+
+type forceAllOption struct {
+	forceAll bool
+}
+
+func (o *forceAllOption) ApplyToExecutor(e *Executor) {
+	e.ForceAll = o.forceAll
+}
+
+// WithInsecure allows the [Executor] to make insecure connections when reading
+// remote taskfiles. By default, insecure connections are rejected.
+func WithInsecure(insecure bool) ExecutorOption {
+	return &insecureOption{insecure}
+}
+
+type insecureOption struct {
+	insecure bool
+}
+
+func (o *insecureOption) ApplyToExecutor(e *Executor) {
+	e.Insecure = o.insecure
+}
+
+// WithDownload forces the [Executor] to download a fresh copy of the taskfile
+// from the remote source.
+func WithDownload(download bool) ExecutorOption {
+	return &downloadOption{download}
+}
+
+type downloadOption struct {
+	download bool
+}
+
+func (o *downloadOption) ApplyToExecutor(e *Executor) {
+	e.Download = o.download
+}
+
+// WithOffline stops the [Executor] from being able to make network connections.
+// It will still be able to read local files and cached copies of remote files.
+func WithOffline(offline bool) ExecutorOption {
+	return &offlineOption{offline}
+}
+
+type offlineOption struct {
+	offline bool
+}
+
+func (o *offlineOption) ApplyToExecutor(e *Executor) {
+	e.Offline = o.offline
+}
+
+// WithTrustedHosts configures the [Executor] with a list of trusted hosts for remote
+// Taskfiles. Hosts in this list will not prompt for user confirmation.
+func WithTrustedHosts(trustedHosts []string) ExecutorOption {
+	return &trustedHostsOption{trustedHosts}
+}
+
+type trustedHostsOption struct {
+	trustedHosts []string
+}
+
+func (o *trustedHostsOption) ApplyToExecutor(e *Executor) {
+	e.TrustedHosts = o.trustedHosts
+}
+
+// WithTimeout sets the [Executor]'s timeout for fetching remote taskfiles. By
+// default, the timeout is set to 10 seconds.
+func WithTimeout(timeout time.Duration) ExecutorOption {
+	return &timeoutOption{timeout}
+}
+
+type timeoutOption struct {
+	timeout time.Duration
+}
+
+func (o *timeoutOption) ApplyToExecutor(e *Executor) {
+	e.Timeout = o.timeout
+}
+
+// WithCacheExpiryDuration sets the duration after which the cache is considered
+// expired. By default, the cache is 0 (disabled).
+func WithCacheExpiryDuration(duration time.Duration) ExecutorOption {
+	return &cacheExpiryDurationOption{duration: duration}
+}
+
+type cacheExpiryDurationOption struct {
+	duration time.Duration
+}
+
+func (o *cacheExpiryDurationOption) ApplyToExecutor(r *Executor) {
+	r.CacheExpiryDuration = o.duration
+}
+
+// WithRemoteCacheDir sets the directory where remote taskfiles are cached.
+func WithRemoteCacheDir(dir string) ExecutorOption {
+	return &remoteCacheDirOption{dir: dir}
+}
+
+type remoteCacheDirOption struct {
+	dir string
+}
+
+func (o *remoteCacheDirOption) ApplyToExecutor(e *Executor) {
+	e.RemoteCacheDir = o.dir
+}
+
+// WithCACert sets the path to a custom CA certificate for TLS connections.
+func WithCACert(caCert string) ExecutorOption {
+	return &caCertOption{caCert: caCert}
+}
+
+type caCertOption struct {
+	caCert string
+}
+
+func (o *caCertOption) ApplyToExecutor(e *Executor) {
+	e.CACert = o.caCert
+}
+
+// WithCert sets the path to a client certificate for TLS connections.
+func WithCert(cert string) ExecutorOption {
+	return &certOption{cert: cert}
+}
+
+type certOption struct {
+	cert string
+}
+
+func (o *certOption) ApplyToExecutor(e *Executor) {
+	e.Cert = o.cert
+}
+
+// WithCertKey sets the path to a client certificate key for TLS connections.
+func WithCertKey(certKey string) ExecutorOption {
+	return &certKeyOption{certKey: certKey}
+}
+
+type certKeyOption struct {
+	certKey string
+}
+
+func (o *certKeyOption) ApplyToExecutor(e *Executor) {
+	e.CertKey = o.certKey
+}
+
+// WithWatch tells the [Executor] to keep running in the background and watch
+// for changes to the fingerprint of the tasks that are run. When changes are
+// detected, a new task run is triggered.
+func WithWatch(watch bool) ExecutorOption {
+	return &watchOption{watch}
+}
+
+type watchOption struct {
+	watch bool
+}
+
+func (o *watchOption) ApplyToExecutor(e *Executor) {
+	e.Watch = o.watch
+}
+
+// WithVerbose tells the [Executor] to output more information about the tasks
+// that are run.
+func WithVerbose(verbose bool) ExecutorOption {
+	return &verboseOption{verbose}
+}
+
+type verboseOption struct {
+	verbose bool
+}
+
+func (o *verboseOption) ApplyToExecutor(e *Executor) {
+	e.Verbose = o.verbose
+}
+
+// WithSilent tells the [Executor] to suppress all output except for the output
+// of the tasks that are run.
+func WithSilent(silent bool) ExecutorOption {
+	return &silentOption{silent}
+}
+
+type silentOption struct {
+	silent bool
+}
+
+func (o *silentOption) ApplyToExecutor(e *Executor) {
+	e.Silent = o.silent
+}
+
+// WithDisableFuzzy tells the [Executor] to disable fuzzy matching for task names.
+func WithDisableFuzzy(disableFuzzy bool) ExecutorOption {
+	return &disableFuzzyOption{disableFuzzy}
+}
+
+type disableFuzzyOption struct {
+	disableFuzzy bool
+}
+
+func (o *disableFuzzyOption) ApplyToExecutor(e *Executor) {
+	e.DisableFuzzy = o.disableFuzzy
+}
+
+// WithAssumeYes tells the [Executor] to assume "yes" for all prompts.
+func WithAssumeYes(assumeYes bool) ExecutorOption {
+	return &assumeYesOption{assumeYes}
+}
+
+type assumeYesOption struct {
+	assumeYes bool
+}
+
+func (o *assumeYesOption) ApplyToExecutor(e *Executor) {
+	e.AssumeYes = o.assumeYes
+}
+
+// WithAssumeTerm is used for testing purposes to simulate a terminal.
+func WithAssumeTerm(assumeTerm bool) ExecutorOption {
+	return &assumeTermOption{assumeTerm}
+}
+
+type assumeTermOption struct {
+	assumeTerm bool
+}
+
+func (o *assumeTermOption) ApplyToExecutor(e *Executor) {
+	e.AssumeTerm = o.assumeTerm
+}
+
+// WithInteractive tells the [Executor] to prompt for missing required variables.
+func WithInteractive(interactive bool) ExecutorOption {
+	return &interactiveOption{interactive}
+}
+
+type interactiveOption struct {
+	interactive bool
+}
+
+func (o *interactiveOption) ApplyToExecutor(e *Executor) {
+	e.Interactive = o.interactive
+}
+
+// WithDry tells the [Executor] to output the commands that would be run without
+// actually running them.
+func WithDry(dry bool) ExecutorOption {
+	return &dryOption{dry}
+}
+
+type dryOption struct {
+	dry bool
+}
+
+func (o *dryOption) ApplyToExecutor(e *Executor) {
+	e.Dry = o.dry
+}
+
+// WithSummary tells the [Executor] to output a summary of the given tasks
+// instead of running them.
+func WithSummary(summary bool) ExecutorOption {
+	return &summaryOption{summary}
+}
+
+type summaryOption struct {
+	summary bool
+}
+
+func (o *summaryOption) ApplyToExecutor(e *Executor) {
+	e.Summary = o.summary
+}
+
+// WithParallel tells the [Executor] to run tasks given in the same call in
+// parallel.
+func WithParallel(parallel bool) ExecutorOption {
+	return &parallelOption{parallel}
+}
+
+type parallelOption struct {
+	parallel bool
+}
+
+func (o *parallelOption) ApplyToExecutor(e *Executor) {
+	e.Parallel = o.parallel
+}
+
+// WithColor tells the [Executor] whether or not to output using colorized
+// strings.
+func WithColor(color bool) ExecutorOption {
+	return &colorOption{color}
+}
+
+type colorOption struct {
+	color bool
+}
+
+func (o *colorOption) ApplyToExecutor(e *Executor) {
+	e.Color = o.color
+}
+
+// WithConcurrency sets the maximum number of tasks that the [Executor] can run
+// in parallel.
+func WithConcurrency(concurrency int) ExecutorOption {
+	return &concurrencyOption{concurrency}
+}
+
+type concurrencyOption struct {
+	concurrency int
+}
+
+func (o *concurrencyOption) ApplyToExecutor(e *Executor) {
+	e.Concurrency = o.concurrency
+}
+
+// WithInterval sets the interval at which the [Executor] will wait for
+// duplicated events before running a task.
+func WithInterval(interval time.Duration) ExecutorOption {
+	return &intervalOption{interval}
+}
+
+type intervalOption struct {
+	interval time.Duration
+}
+
+func (o *intervalOption) ApplyToExecutor(e *Executor) {
+	e.Interval = o.interval
+}
+
+// WithOutputStyle sets the output style of the [Executor]. By default, the
+// output style is set to the style defined in the Taskfile.
+func WithOutputStyle(outputStyle ast.Output) ExecutorOption {
+	return &outputStyleOption{outputStyle}
+}
+
+type outputStyleOption struct {
+	outputStyle ast.Output
+}
+
+func (o *outputStyleOption) ApplyToExecutor(e *Executor) {
+	e.OutputStyle = o.outputStyle
+}
+
+// WithTaskSorter sets the sorter that the [Executor] will use to sort tasks. By
+// default, the sorter is set to sort tasks alphabetically, but with tasks with
+// no namespace (in the root Taskfile) first.
+func WithTaskSorter(sorter sort.Sorter) ExecutorOption {
+	return &taskSorterOption{sorter}
+}
+
+type taskSorterOption struct {
+	sorter sort.Sorter
+}
+
+func (o *taskSorterOption) ApplyToExecutor(e *Executor) {
+	e.TaskSorter = o.sorter
+}
+
+// WithStdin sets the [Executor]'s standard input [io.Reader].
+func WithStdin(stdin io.Reader) ExecutorOption {
+	return &stdinOption{stdin}
+}
+
+type stdinOption struct {
+	stdin io.Reader
+}
+
+func (o *stdinOption) ApplyToExecutor(e *Executor) {
+	e.Stdin = o.stdin
+}
+
+// WithStdout sets the [Executor]'s standard output [io.Writer].
+func WithStdout(stdout io.Writer) ExecutorOption {
+	return &stdoutOption{stdout}
+}
+
+type stdoutOption struct {
+	stdout io.Writer
+}
+
+func (o *stdoutOption) ApplyToExecutor(e *Executor) {
+	e.Stdout = o.stdout
+}
+
+// WithStderr sets the [Executor]'s standard error [io.Writer].
+func WithStderr(stderr io.Writer) ExecutorOption {
+	return &stderrOption{stderr}
+}
+
+type stderrOption struct {
+	stderr io.Writer
+}
+
+func (o *stderrOption) ApplyToExecutor(e *Executor) {
+	e.Stderr = o.stderr
+}
+
+// WithIO sets the [Executor]'s standard input, output, and error to the same
+// [io.ReadWriter].
+func WithIO(rw io.ReadWriter) ExecutorOption {
+	return &ioOption{rw}
+}
+
+type ioOption struct {
+	rw io.ReadWriter
+}
+
+func (o *ioOption) ApplyToExecutor(e *Executor) {
+	e.Stdin = o.rw
+	e.Stdout = o.rw
+	e.Stderr = o.rw
+}
+
+// WithVersionCheck tells the [Executor] whether or not to check the version of
+func WithVersionCheck(enableVersionCheck bool) ExecutorOption {
+	return &versionCheckOption{enableVersionCheck}
+}
+
+type versionCheckOption struct {
+	enableVersionCheck bool
+}
+
+func (o *versionCheckOption) ApplyToExecutor(e *Executor) {
+	e.EnableVersionCheck = o.enableVersionCheck
+}
+
+// WithFailfast tells the [Executor] whether or not to check the version of
+func WithFailfast(failfast bool) ExecutorOption {
+	return &failfastOption{failfast}
+}
+
+type failfastOption struct {
+	failfast bool
+}
+
+func (o *failfastOption) ApplyToExecutor(e *Executor) {
+	e.Failfast = o.failfast
+}

experiments/errors.go

@@ -0,0 +1,35 @@
+package experiments
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+
+	"github.com/go-task/task/v3/internal/slicesext"
+)
+
+type InvalidValueError struct {
+	Name          string
+	AllowedValues []int
+	Value         int
+}
+
+func (err InvalidValueError) Error() string {
+	return fmt.Sprintf(
+		"task: Experiment %q has an invalid value %q (allowed values: %s)",
+		err.Name,
+		err.Value,
+		strings.Join(slicesext.Convert(err.AllowedValues, strconv.Itoa), ", "),
+	)
+}
+
+type InactiveError struct {
+	Name string
+}
+
+func (err InactiveError) Error() string {
+	return fmt.Sprintf(
+		"task: Experiment %q is inactive and cannot be enabled",
+		err.Name,
+	)
+}

experiments/experiment.go

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

experiments/experiment_test.go

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

experiments/experiments.go

@@ -0,0 +1,89 @@
+package experiments
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/joho/godotenv"
+
+	"github.com/go-task/task/v3/taskrc"
+	"github.com/go-task/task/v3/taskrc/ast"
+)
+
+const envPrefix = "TASK_X_"
+
+// Active experiments.
+var (
+	GentleForce     Experiment
+	RemoteTaskfiles Experiment
+	EnvPrecedence   Experiment
+)
+
+// Inactive experiments. These are experiments that cannot be enabled, but are
+// preserved for error handling.
+var (
+	AnyVariables Experiment
+	MapVariables Experiment
+)
+
+// An internal list of all the initialized experiments used for iterating.
+var xList []Experiment
+
+func Parse(dir string) {
+	config, _ := taskrc.GetConfig(dir)
+	ParseWithConfig(dir, config)
+}
+
+func ParseWithConfig(dir string, config *ast.TaskRC) {
+	// Read any .env files
+	readDotEnv(dir)
+	// Initialize the experiments
+	GentleForce = New("GENTLE_FORCE", config, 1)
+	RemoteTaskfiles = New("REMOTE_TASKFILES", config, 1)
+	EnvPrecedence = New("ENV_PRECEDENCE", config, 1)
+	AnyVariables = New("ANY_VARIABLES", config)
+	MapVariables = New("MAP_VARIABLES", config)
+}
+
+// Validate checks if any experiments have been enabled while being inactive.
+// If one is found, the function returns an error.
+func Validate() error {
+	for _, x := range List() {
+		if err := x.Valid(); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func List() []Experiment {
+	return xList
+}
+
+func getEnv(xName string) string {
+	envName := fmt.Sprintf("%s%s", envPrefix, xName)
+	return os.Getenv(envName)
+}
+
+func getFilePath(filename, dir string) string {
+	if dir != "" {
+		return filepath.Join(dir, filename)
+	}
+	return filename
+}
+
+func readDotEnv(dir string) {
+	env, err := godotenv.Read(getFilePath(".env", dir))
+	if err != nil {
+		return
+	}
+
+	// If the env var is an experiment, set it.
+	for key, value := range env {
+		if strings.HasPrefix(key, envPrefix) {
+			os.Setenv(key, value)
+		}
+	}
+}

formatter_test.go

@@ -0,0 +1,236 @@
+package task_test
+
+import (
+	"bytes"
+	"path/filepath"
+	"testing"
+
+	"github.com/sebdah/goldie/v2"
+	"github.com/stretchr/testify/require"
+
+	"github.com/go-task/task/v3"
+	"github.com/go-task/task/v3/experiments"
+	"github.com/go-task/task/v3/taskfile/ast"
+)
+
+type (
+	// A FormatterTestOption is a function that configures an [FormatterTest].
+	FormatterTestOption interface {
+		applyToFormatterTest(*FormatterTest)
+	}
+	// A FormatterTest is a test wrapper around a [task.Executor] to make it
+	// easy to write tests for the task formatter. See [NewFormatterTest] for
+	// information on creating and running FormatterTests. These tests use
+	// fixture files to assert whether the result of the output is correct. If
+	// Task's behavior has been changed, the fixture files can be updated by
+	// running `task gen:fixtures`.
+	FormatterTest struct {
+		TaskTest
+		task           string
+		vars           map[string]any
+		executorOpts   []task.ExecutorOption
+		listOptions    task.ListOptions
+		wantSetupError bool
+		wantListError  bool
+	}
+)
+
+// NewFormatterTest sets up a new [task.Executor] with the given options and
+// runs a task with the given [FormatterTestOption]s. The output of the task is
+// written to a set of fixture files depending on the configuration of the test.
+func NewFormatterTest(t *testing.T, opts ...FormatterTestOption) {
+	t.Helper()
+	tt := &FormatterTest{
+		task: "default",
+		vars: map[string]any{},
+		TaskTest: TaskTest{
+			experiments:         map[*experiments.Experiment]int{},
+			fixtureTemplateData: map[string]any{},
+		},
+	}
+	// Apply the functional options
+	for _, opt := range opts {
+		opt.applyToFormatterTest(tt)
+	}
+	// Enable any experiments that have been set
+	for x, v := range tt.experiments {
+		prev := *x
+		*x = experiments.Experiment{
+			Name:          prev.Name,
+			AllowedValues: []int{v},
+			Value:         v,
+		}
+		t.Cleanup(func() {
+			*x = prev
+		})
+	}
+	tt.run(t)
+}
+
+// Functional options
+
+// WithListOptions sets the list options for the formatter.
+func WithListOptions(opts task.ListOptions) FormatterTestOption {
+	return &listOptionsTestOption{opts}
+}
+
+type listOptionsTestOption struct {
+	listOptions task.ListOptions
+}
+
+func (opt *listOptionsTestOption) applyToFormatterTest(t *FormatterTest) {
+	t.listOptions = opt.listOptions
+}
+
+// WithListError tells the test to expect an error when running the formatter.
+// A fixture will be created with the output of any errors.
+func WithListError() FormatterTestOption {
+	return &listErrorTestOption{}
+}
+
+type listErrorTestOption struct{}
+
+func (opt *listErrorTestOption) applyToFormatterTest(t *FormatterTest) {
+	t.wantListError = true
+}
+
+// Helpers
+
+// writeFixtureErrList is a wrapper for writing the output of an error when
+// running the formatter to a fixture file.
+func (tt *FormatterTest) writeFixtureErrList(
+	t *testing.T,
+	g *goldie.Goldie,
+	err error,
+) {
+	t.Helper()
+	tt.writeFixture(t, g, "err-list", []byte(err.Error()))
+}
+
+// run is the main function for running the test. It sets up the task executor,
+// runs the task, and writes the output to a fixture file.
+func (tt *FormatterTest) run(t *testing.T) {
+	t.Helper()
+	f := func(t *testing.T) {
+		t.Helper()
+		var buf bytes.Buffer
+
+		opts := append(
+			tt.executorOpts,
+			task.WithStdout(&buf),
+			task.WithStderr(&buf),
+		)
+
+		// Set up the task executor
+		e := task.NewExecutor(opts...)
+
+		// Create a golden fixture file for the output
+		g := goldie.New(t,
+			goldie.WithFixtureDir(filepath.Join(e.Dir, "testdata")),
+			goldie.WithEqualFn(NormalizedEqual),
+		)
+
+		// Call setup and check for errors
+		if err := e.Setup(); tt.wantSetupError {
+			require.Error(t, err)
+			tt.writeFixtureErrSetup(t, g, err)
+			tt.writeFixtureBuffer(t, g, buf)
+			return
+		} else {
+			require.NoError(t, err)
+		}
+
+		// Create the task call
+		vars := ast.NewVars()
+		for key, value := range tt.vars {
+			vars.Set(key, ast.Var{Value: value})
+		}
+
+		// Run the formatter and check for errors
+		if _, err := e.ListTasks(tt.listOptions); tt.wantListError {
+			require.Error(t, err)
+			tt.writeFixtureErrList(t, g, err)
+			tt.writeFixtureBuffer(t, g, buf)
+			return
+		} else {
+			require.NoError(t, err)
+		}
+
+		tt.writeFixtureBuffer(t, g, buf)
+	}
+
+	// Run the test (with a name if it has one)
+	if tt.name != "" {
+		t.Run(tt.name, f)
+	} else {
+		f(t)
+	}
+}
+
+func TestNoLabelInList(t *testing.T) {
+	t.Parallel()
+
+	NewFormatterTest(t,
+		WithExecutorOptions(
+			task.WithDir("testdata/label_list"),
+		),
+		WithListOptions(task.ListOptions{
+			ListOnlyTasksWithDescriptions: true,
+		}),
+	)
+}
+
+// task -al case 1: listAll list all tasks
+func TestListAllShowsNoDesc(t *testing.T) {
+	t.Parallel()
+
+	NewFormatterTest(t,
+		WithExecutorOptions(
+			task.WithDir("testdata/list_mixed_desc"),
+		),
+		WithListOptions(task.ListOptions{
+			ListAllTasks: true,
+		}),
+	)
+}
+
+// task -al case 2: !listAll list some tasks (only those with desc)
+func TestListCanListDescOnly(t *testing.T) {
+	t.Parallel()
+
+	NewFormatterTest(t,
+		WithExecutorOptions(
+			task.WithDir("testdata/list_mixed_desc"),
+		),
+		WithListOptions(task.ListOptions{
+			ListOnlyTasksWithDescriptions: true,
+		}),
+	)
+}
+
+func TestListDescInterpolation(t *testing.T) {
+	t.Parallel()
+
+	NewFormatterTest(t,
+		WithExecutorOptions(
+			task.WithDir("testdata/list_desc_interpolation"),
+		),
+		WithListOptions(task.ListOptions{
+			ListOnlyTasksWithDescriptions: true,
+		}),
+	)
+}
+
+func TestJsonListFormat(t *testing.T) {
+	t.Parallel()
+
+	NewFormatterTest(t,
+		WithExecutorOptions(
+			task.WithDir("testdata/json_list_format"),
+		),
+		WithListOptions(task.ListOptions{
+			FormatTaskListAsJSON: true,
+		}),
+		WithFixtureTemplating(),
+	)
+}

go.mod

@@ -1,24 +1,136 @@
-module github.com/go-task/task/v2
+module github.com/go-task/task/v3
+
+go 1.25.10
 
 require (
-	github.com/Masterminds/semver v1.4.2
-	github.com/Masterminds/sprig v2.16.0+incompatible
-	github.com/aokoli/goutils v1.0.1 // indirect
-	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/google/uuid v1.0.0 // indirect
-	github.com/huandu/xstrings v1.1.0 // indirect
-	github.com/imdario/mergo v0.3.6 // indirect
-	github.com/kr/pretty v0.1.0 // indirect
-	github.com/mattn/go-zglob v0.0.0-20180803001819-2ea3427bfa53
-	github.com/mitchellh/go-homedir v1.0.0
-	github.com/pmezard/go-difflib v1.0.0 // indirect
-	github.com/radovskyb/watcher v1.0.2
-	github.com/spf13/pflag v1.0.3
-	github.com/stretchr/testify v1.2.2
-	golang.org/x/crypto v0.0.0-20180830192347-182538f80094 // indirect
-	golang.org/x/net v0.0.0-20180826012351-8a410e7b638d // indirect
-	golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f
-	golang.org/x/sys v0.0.0-20180831094639-fa5fdf94c789 // indirect
-	gopkg.in/yaml.v2 v2.2.1
-	mvdan.cc/sh v2.6.3-0.20181216173157-8aeb0734cd0f+incompatible
+	charm.land/bubbles/v2 v2.1.0
+	charm.land/bubbletea/v2 v2.0.6
+	charm.land/lipgloss/v2 v2.0.3
+	github.com/Ladicle/tabwriter v1.0.0
+	github.com/Masterminds/semver/v3 v3.5.0
+	github.com/alecthomas/chroma/v2 v2.24.1
+	github.com/chainguard-dev/git-urls v1.0.2
+	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc
+	github.com/dominikbraun/graph v0.23.0
+	github.com/elliotchance/orderedmap/v3 v3.1.0
+	github.com/fatih/color v1.19.0
+	github.com/fsnotify/fsnotify v1.10.1
+	github.com/go-task/slim-sprig/v3 v3.0.0
+	github.com/go-task/template v0.2.0
+	github.com/google/uuid v1.6.0
+	github.com/hashicorp/go-getter v1.8.6
+	github.com/joho/godotenv v1.5.1
+	github.com/mitchellh/hashstructure/v2 v2.0.2
+	github.com/puzpuzpuz/xsync/v4 v4.5.0
+	github.com/sajari/fuzzy v1.0.0
+	github.com/sebdah/goldie/v2 v2.8.0
+	github.com/spf13/pflag v1.0.10
+	github.com/stretchr/testify v1.11.1
+	github.com/zeebo/xxh3 v1.1.0
+	go.yaml.in/yaml/v3 v3.0.4
+	golang.org/x/sync v0.20.0
+	golang.org/x/term v0.43.0
+	mvdan.cc/sh/moreinterp v0.0.0-20260120230322-19def062a997
+	mvdan.cc/sh/v3 v3.13.2-0.20260510185049-f5c6e2779117
+)
+
+require (
+	cel.dev/expr v0.25.1 // indirect
+	cloud.google.com/go v0.123.0 // indirect
+	cloud.google.com/go/auth v0.18.2 // indirect
+	cloud.google.com/go/auth/oauth2adapt v0.2.8 // indirect
+	cloud.google.com/go/compute/metadata v0.9.0 // indirect
+	cloud.google.com/go/iam v1.5.3 // indirect
+	cloud.google.com/go/monitoring v1.24.3 // indirect
+	cloud.google.com/go/storage v1.61.3 // indirect
+	github.com/GoogleCloudPlatform/opentelemetry-operations-go/detectors/gcp v1.30.0 // indirect
+	github.com/GoogleCloudPlatform/opentelemetry-operations-go/exporter/metric v0.55.0 // indirect
+	github.com/GoogleCloudPlatform/opentelemetry-operations-go/internal/resourcemapping v0.55.0 // indirect
+	github.com/atotto/clipboard v0.1.4 // indirect
+	github.com/aws/aws-sdk-go-v2 v1.41.5 // indirect
+	github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.8 // indirect
+	github.com/aws/aws-sdk-go-v2/config v1.32.12 // indirect
+	github.com/aws/aws-sdk-go-v2/credentials v1.19.12 // indirect
+	github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.20 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.21 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.21 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/ini v1.8.6 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.22 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.7 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.9.13 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.21 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.19.21 // indirect
+	github.com/aws/aws-sdk-go-v2/service/s3 v1.97.3 // indirect
+	github.com/aws/aws-sdk-go-v2/service/signin v1.0.8 // indirect
+	github.com/aws/aws-sdk-go-v2/service/sso v1.30.13 // indirect
+	github.com/aws/aws-sdk-go-v2/service/ssooidc v1.35.17 // indirect
+	github.com/aws/aws-sdk-go-v2/service/sts v1.41.9 // indirect
+	github.com/aws/smithy-go v1.24.2 // indirect
+	github.com/bgentry/go-netrc v0.0.0-20140422174119-9fd32a8b3d3d // indirect
+	github.com/cespare/xxhash/v2 v2.3.0 // indirect
+	github.com/charmbracelet/colorprofile v0.4.3 // indirect
+	github.com/charmbracelet/ultraviolet v0.0.0-20260416155717-489999b90468 // indirect
+	github.com/charmbracelet/x/ansi v0.11.7 // indirect
+	github.com/charmbracelet/x/term v0.2.2 // indirect
+	github.com/charmbracelet/x/termios v0.1.1 // indirect
+	github.com/charmbracelet/x/windows v0.2.2 // indirect
+	github.com/clipperhouse/displaywidth v0.11.0 // indirect
+	github.com/clipperhouse/uax29/v2 v2.7.0 // indirect
+	github.com/cncf/xds/go v0.0.0-20251210132809-ee656c7534f5 // indirect
+	github.com/dlclark/regexp2 v1.12.0 // indirect
+	github.com/dustin/go-humanize v1.0.1 // indirect
+	github.com/envoyproxy/go-control-plane/envoy v1.36.0 // indirect
+	github.com/envoyproxy/protoc-gen-validate v1.3.0 // indirect
+	github.com/felixge/httpsnoop v1.0.4 // indirect
+	github.com/go-jose/go-jose/v4 v4.1.4 // indirect
+	github.com/go-logr/logr v1.4.3 // indirect
+	github.com/go-logr/stdr v1.2.2 // indirect
+	github.com/google/s2a-go v0.1.9 // indirect
+	github.com/googleapis/enterprise-certificate-proxy v0.3.14 // indirect
+	github.com/googleapis/gax-go/v2 v2.17.0 // indirect
+	github.com/hashicorp/aws-sdk-go-base/v2 v2.0.0-beta.72 // indirect
+	github.com/hashicorp/go-cleanhttp v0.5.2 // indirect
+	github.com/hashicorp/go-version v1.8.0 // indirect
+	github.com/klauspost/compress v1.18.5 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.10 // indirect
+	github.com/klauspost/pgzip v1.2.6 // indirect
+	github.com/lucasb-eyer/go-colorful v1.4.0 // indirect
+	github.com/mattn/go-colorable v0.1.14 // indirect
+	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/mattn/go-runewidth v0.0.23 // indirect
+	github.com/mitchellh/go-homedir v1.1.0 // indirect
+	github.com/muesli/cancelreader v0.2.2 // indirect
+	github.com/pierrec/lz4/v4 v4.1.22 // indirect
+	github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10 // indirect
+	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
+	github.com/rivo/uniseg v0.4.7 // indirect
+	github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3 // indirect
+	github.com/spiffe/go-spiffe/v2 v2.6.0 // indirect
+	github.com/stretchr/objx v0.5.2 // indirect
+	github.com/u-root/u-root v0.15.1-0.20251208185023-2f8c7e763cf8 // indirect
+	github.com/u-root/uio v0.0.0-20240224005618-d2acac8f3701 // indirect
+	github.com/ulikunitz/xz v0.5.15 // indirect
+	github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
+	go.opentelemetry.io/auto/sdk v1.2.1 // indirect
+	go.opentelemetry.io/contrib/detectors/gcp v1.39.0 // indirect
+	go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.63.0 // indirect
+	go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.61.0 // indirect
+	go.opentelemetry.io/otel v1.43.0 // indirect
+	go.opentelemetry.io/otel/metric v1.43.0 // indirect
+	go.opentelemetry.io/otel/sdk v1.43.0 // indirect
+	go.opentelemetry.io/otel/sdk/metric v1.43.0 // indirect
+	go.opentelemetry.io/otel/trace v1.43.0 // indirect
+	golang.org/x/crypto v0.51.0 // indirect
+	golang.org/x/net v0.54.0 // indirect
+	golang.org/x/oauth2 v0.36.0 // indirect
+	golang.org/x/sys v0.44.0 // indirect
+	golang.org/x/text v0.37.0 // indirect
+	golang.org/x/time v0.15.0 // indirect
+	google.golang.org/api v0.271.0 // indirect
+	google.golang.org/genproto v0.0.0-20260128011058-8636f8732409 // indirect
+	google.golang.org/genproto/googleapis/api v0.0.0-20260203192932-546029d2fa20 // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20260226221140-a57be14db171 // indirect
+	google.golang.org/grpc v1.79.3 // indirect
+	google.golang.org/protobuf v1.36.11 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum

@@ -1,45 +1,329 @@
-github.com/Masterminds/semver v1.4.2 h1:WBLTQ37jOCzSLtXNdoo8bNM8876KhNqOKvrlGITgsTc=
-github.com/Masterminds/semver v1.4.2/go.mod h1:MB6lktGJrhw8PrUyiEoblNEGEQ+RzHPF078ddwwvV3Y=
-github.com/Masterminds/sprig v2.16.0+incompatible h1:QZbMUPxRQ50EKAq3LFMnxddMu88/EUUG3qmxwtDmPsY=
-github.com/Masterminds/sprig v2.16.0+incompatible/go.mod h1:y6hNFY5UBTIWBxnzTeuNhlNS5hqE0NB0E6fgfo2Br3o=
-github.com/aokoli/goutils v1.0.1 h1:7fpzNGoJ3VA8qcrm++XEE1QUe0mIwNeLa02Nwq7RDkg=
-github.com/aokoli/goutils v1.0.1/go.mod h1:SijmP0QR8LtwsmDs8Yii5Z/S4trXFGFC2oO5g9DP+DQ=
-github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+cel.dev/expr v0.25.1 h1:1KrZg61W6TWSxuNZ37Xy49ps13NUovb66QLprthtwi4=
+cel.dev/expr v0.25.1/go.mod h1:hrXvqGP6G6gyx8UAHSHJ5RGk//1Oj5nXQ2NI02Nrsg4=
+charm.land/bubbles/v2 v2.1.0 h1:YSnNh5cPYlYjPxRrzs5VEn3vwhtEn3jVGRBT3M7/I0g=
+charm.land/bubbles/v2 v2.1.0/go.mod h1:l97h4hym2hvWBVfmJDtrEHHCtkIKeTEb3TTJ4ZOB3wY=
+charm.land/bubbletea/v2 v2.0.6 h1:UHN/91OyuhaOFGSrBXQ/hMZD8IO1Uc4BvHlgHXL2WJo=
+charm.land/bubbletea/v2 v2.0.6/go.mod h1:MH/D8ZLlN3op37vQvijKuU29g3rqTp+aQapURFonF9g=
+charm.land/lipgloss/v2 v2.0.3 h1:yM2zJ4Cf5Y51b7RHIwioil4ApI/aypFXXVHSwlM6RzU=
+charm.land/lipgloss/v2 v2.0.3/go.mod h1:7myLU9iG/3xluAWzpY/fSxYYHCgoKTie7laxk6ATwXA=
+cloud.google.com/go v0.123.0 h1:2NAUJwPR47q+E35uaJeYoNhuNEM9kM8SjgRgdeOJUSE=
+cloud.google.com/go v0.123.0/go.mod h1:xBoMV08QcqUGuPW65Qfm1o9Y4zKZBpGS+7bImXLTAZU=
+cloud.google.com/go/auth v0.18.2 h1:+Nbt5Ev0xEqxlNjd6c+yYUeosQ5TtEUaNcN/3FozlaM=
+cloud.google.com/go/auth v0.18.2/go.mod h1:xD+oY7gcahcu7G2SG2DsBerfFxgPAJz17zz2joOFF3M=
+cloud.google.com/go/auth/oauth2adapt v0.2.8 h1:keo8NaayQZ6wimpNSmW5OPc283g65QNIiLpZnkHRbnc=
+cloud.google.com/go/auth/oauth2adapt v0.2.8/go.mod h1:XQ9y31RkqZCcwJWNSx2Xvric3RrU88hAYYbjDWYDL+c=
+cloud.google.com/go/compute/metadata v0.9.0 h1:pDUj4QMoPejqq20dK0Pg2N4yG9zIkYGdBtwLoEkH9Zs=
+cloud.google.com/go/compute/metadata v0.9.0/go.mod h1:E0bWwX5wTnLPedCKqk3pJmVgCBSM6qQI1yTBdEb3C10=
+cloud.google.com/go/iam v1.5.3 h1:+vMINPiDF2ognBJ97ABAYYwRgsaqxPbQDlMnbHMjolc=
+cloud.google.com/go/iam v1.5.3/go.mod h1:MR3v9oLkZCTlaqljW6Eb2d3HGDGK5/bDv93jhfISFvU=
+cloud.google.com/go/logging v1.13.1 h1:O7LvmO0kGLaHY/gq8cV7T0dyp6zJhYAOtZPX4TF3QtY=
+cloud.google.com/go/logging v1.13.1/go.mod h1:XAQkfkMBxQRjQek96WLPNze7vsOmay9H5PqfsNYDqvw=
+cloud.google.com/go/longrunning v0.8.0 h1:LiKK77J3bx5gDLi4SMViHixjD2ohlkwBi+mKA7EhfW8=
+cloud.google.com/go/longrunning v0.8.0/go.mod h1:UmErU2Onzi+fKDg2gR7dusz11Pe26aknR4kHmJJqIfk=
+cloud.google.com/go/monitoring v1.24.3 h1:dde+gMNc0UhPZD1Azu6at2e79bfdztVDS5lvhOdsgaE=
+cloud.google.com/go/monitoring v1.24.3/go.mod h1:nYP6W0tm3N9H/bOw8am7t62YTzZY+zUeQ+Bi6+2eonI=
+cloud.google.com/go/storage v1.61.3 h1:VS//ZfBuPGDvakfD9xyPW1RGF1Vy3BWUoVZXgW1KMOg=
+cloud.google.com/go/storage v1.61.3/go.mod h1:JtqK8BBB7TWv0HVGHubtUdzYYrakOQIsMLffZ2Z/HWk=
+cloud.google.com/go/trace v1.11.7 h1:kDNDX8JkaAG3R2nq1lIdkb7FCSi1rCmsEtKVsty7p+U=
+cloud.google.com/go/trace v1.11.7/go.mod h1:TNn9d5V3fQVf6s4SCveVMIBS2LJUqo73GACmq/Tky0s=
+github.com/GoogleCloudPlatform/opentelemetry-operations-go/detectors/gcp v1.30.0 h1:sBEjpZlNHzK1voKq9695PJSX2o5NEXl7/OL3coiIY0c=
+github.com/GoogleCloudPlatform/opentelemetry-operations-go/detectors/gcp v1.30.0/go.mod h1:P4WPRUkOhJC13W//jWpyfJNDAIpvRbAUIYLX/4jtlE0=
+github.com/GoogleCloudPlatform/opentelemetry-operations-go/exporter/metric v0.55.0 h1:UnDZ/zFfG1JhH/DqxIZYU/1CUAlTUScoXD/LcM2Ykk8=
+github.com/GoogleCloudPlatform/opentelemetry-operations-go/exporter/metric v0.55.0/go.mod h1:IA1C1U7jO/ENqm/vhi7V9YYpBsp+IMyqNrEN94N7tVc=
+github.com/GoogleCloudPlatform/opentelemetry-operations-go/internal/cloudmock v0.55.0 h1:7t/qx5Ost0s0wbA/VDrByOooURhp+ikYwv20i9Y07TQ=
+github.com/GoogleCloudPlatform/opentelemetry-operations-go/internal/cloudmock v0.55.0/go.mod h1:vB2GH9GAYYJTO3mEn8oYwzEdhlayZIdQz6zdzgUIRvA=
+github.com/GoogleCloudPlatform/opentelemetry-operations-go/internal/resourcemapping v0.55.0 h1:0s6TxfCu2KHkkZPnBfsQ2y5qia0jl3MMrmBhu3nCOYk=
+github.com/GoogleCloudPlatform/opentelemetry-operations-go/internal/resourcemapping v0.55.0/go.mod h1:Mf6O40IAyB9zR/1J8nGDDPirZQQPbYJni8Yisy7NTMc=
+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.4.0 h1:Zog+i5UMtVoCU8oKka5P7i9q9HgrJeGzI9SA1Xbatp0=
+github.com/Masterminds/semver/v3 v3.4.0/go.mod h1:4V+yj/TJE1HU9XfppCwVMZq3I84lprf4nC11bSS5beM=
+github.com/Masterminds/semver/v3 v3.5.0 h1:kQceYJfbupGfZOKZQg0kou0DgAKhzDg2NZPAwZ/2OOE=
+github.com/Masterminds/semver/v3 v3.5.0/go.mod h1:4V+yj/TJE1HU9XfppCwVMZq3I84lprf4nC11bSS5beM=
+github.com/alecthomas/assert/v2 v2.11.0 h1:2Q9r3ki8+JYXvGsDyBXwH3LcJ+WK5D0gc5E8vS6K3D0=
+github.com/alecthomas/assert/v2 v2.11.0/go.mod h1:Bze95FyfUr7x34QZrjL+XP+0qgp/zg8yS+TtBj1WA3k=
+github.com/alecthomas/chroma/v2 v2.23.1 h1:nv2AVZdTyClGbVQkIzlDm/rnhk1E9bU9nXwmZ/Vk/iY=
+github.com/alecthomas/chroma/v2 v2.23.1/go.mod h1:NqVhfBR0lte5Ouh3DcthuUCTUpDC9cxBOfyMbMQPs3o=
+github.com/alecthomas/chroma/v2 v2.24.1 h1:m5ffpfZbIb++k8AqFEKy9uVgY12xIQtBsQlc6DfZJQM=
+github.com/alecthomas/chroma/v2 v2.24.1/go.mod h1:l+ohZ9xRXIbGe7cIW+YZgOGbvuVLjMps/FYN/CwuabI=
+github.com/alecthomas/repr v0.5.2 h1:SU73FTI9D1P5UNtvseffFSGmdNci/O6RsqzeXJtP0Qs=
+github.com/alecthomas/repr v0.5.2/go.mod h1:Fr0507jx4eOXV7AlPV6AVZLYrLIuIeSOWtW57eE/O/4=
+github.com/atotto/clipboard v0.1.4 h1:EH0zSVneZPSuFR11BlR9YppQTVDbh5+16AmcJi4g1z4=
+github.com/atotto/clipboard v0.1.4/go.mod h1:ZY9tmq7sm5xIbd9bOK4onWV4S6X0u6GY7Vn0Yu86PYI=
+github.com/aws/aws-sdk-go-v2 v1.41.5 h1:dj5kopbwUsVUVFgO4Fi5BIT3t4WyqIDjGKCangnV/yY=
+github.com/aws/aws-sdk-go-v2 v1.41.5/go.mod h1:mwsPRE8ceUUpiTgF7QmQIJ7lgsKUPQOUl3o72QBrE1o=
+github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.8 h1:eBMB84YGghSocM7PsjmmPffTa+1FBUeNvGvFou6V/4o=
+github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.8/go.mod h1:lyw7GFp3qENLh7kwzf7iMzAxDn+NzjXEAGjKS2UOKqI=
+github.com/aws/aws-sdk-go-v2/config v1.32.12 h1:O3csC7HUGn2895eNrLytOJQdoL2xyJy0iYXhoZ1OmP0=
+github.com/aws/aws-sdk-go-v2/config v1.32.12/go.mod h1:96zTvoOFR4FURjI+/5wY1vc1ABceROO4lWgWJuxgy0g=
+github.com/aws/aws-sdk-go-v2/credentials v1.19.12 h1:oqtA6v+y5fZg//tcTWahyN9PEn5eDU/Wpvc2+kJ4aY8=
+github.com/aws/aws-sdk-go-v2/credentials v1.19.12/go.mod h1:U3R1RtSHx6NB0DvEQFGyf/0sbrpJrluENHdPy1j/3TE=
+github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.20 h1:zOgq3uezl5nznfoK3ODuqbhVg1JzAGDUhXOsU0IDCAo=
+github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.20/go.mod h1:z/MVwUARehy6GAg/yQ1GO2IMl0k++cu1ohP9zo887wE=
+github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.21 h1:Rgg6wvjjtX8bNHcvi9OnXWwcE0a2vGpbwmtICOsvcf4=
+github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.21/go.mod h1:A/kJFst/nm//cyqonihbdpQZwiUhhzpqTsdbhDdRF9c=
+github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.21 h1:PEgGVtPoB6NTpPrBgqSE5hE/o47Ij9qk/SEZFbUOe9A=
+github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.21/go.mod h1:p+hz+PRAYlY3zcpJhPwXlLC4C+kqn70WIHwnzAfs6ps=
+github.com/aws/aws-sdk-go-v2/internal/ini v1.8.6 h1:qYQ4pzQ2Oz6WpQ8T3HvGHnZydA72MnLuFK9tJwmrbHw=
+github.com/aws/aws-sdk-go-v2/internal/ini v1.8.6/go.mod h1:O3h0IK87yXci+kg6flUKzJnWeziQUKciKrLjcatSNcY=
+github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.22 h1:rWyie/PxDRIdhNf4DzRk0lvjVOqFJuNnO8WwaIRVxzQ=
+github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.22/go.mod h1:zd/JsJ4P7oGfUhXn1VyLqaRZwPmZwg44Jf2dS84Dm3Y=
+github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.7 h1:5EniKhLZe4xzL7a+fU3C2tfUN4nWIqlLesfrjkuPFTY=
+github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.7/go.mod h1:x0nZssQ3qZSnIcePWLvcoFisRXJzcTVvYpAAdYX8+GI=
+github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.9.13 h1:JRaIgADQS/U6uXDqlPiefP32yXTda7Kqfx+LgspooZM=
+github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.9.13/go.mod h1:CEuVn5WqOMilYl+tbccq8+N2ieCy0gVn3OtRb0vBNNM=
+github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.21 h1:c31//R3xgIJMSC8S6hEVq+38DcvUlgFY0FM6mSI5oto=
+github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.21/go.mod h1:r6+pf23ouCB718FUxaqzZdbpYFyDtehyZcmP5KL9FkA=
+github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.19.21 h1:ZlvrNcHSFFWURB8avufQq9gFsheUgjVD9536obIknfM=
+github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.19.21/go.mod h1:cv3TNhVrssKR0O/xxLJVRfd2oazSnZnkUeTf6ctUwfQ=
+github.com/aws/aws-sdk-go-v2/service/s3 v1.97.3 h1:HwxWTbTrIHm5qY+CAEur0s/figc3qwvLWsNkF4RPToo=
+github.com/aws/aws-sdk-go-v2/service/s3 v1.97.3/go.mod h1:uoA43SdFwacedBfSgfFSjjCvYe8aYBS7EnU5GZ/YKMM=
+github.com/aws/aws-sdk-go-v2/service/signin v1.0.8 h1:0GFOLzEbOyZABS3PhYfBIx2rNBACYcKty+XGkTgw1ow=
+github.com/aws/aws-sdk-go-v2/service/signin v1.0.8/go.mod h1:LXypKvk85AROkKhOG6/YEcHFPoX+prKTowKnVdcaIxE=
+github.com/aws/aws-sdk-go-v2/service/sso v1.30.13 h1:kiIDLZ005EcKomYYITtfsjn7dtOwHDOFy7IbPXKek2o=
+github.com/aws/aws-sdk-go-v2/service/sso v1.30.13/go.mod h1:2h/xGEowcW/g38g06g3KpRWDlT+OTfxxI0o1KqayAB8=
+github.com/aws/aws-sdk-go-v2/service/ssooidc v1.35.17 h1:jzKAXIlhZhJbnYwHbvUQZEB8KfgAEuG0dc08Bkda7NU=
+github.com/aws/aws-sdk-go-v2/service/ssooidc v1.35.17/go.mod h1:Al9fFsXjv4KfbzQHGe6V4NZSZQXecFcvaIF4e70FoRA=
+github.com/aws/aws-sdk-go-v2/service/sts v1.41.9 h1:Cng+OOwCHmFljXIxpEVXAGMnBia8MSU6Ch5i9PgBkcU=
+github.com/aws/aws-sdk-go-v2/service/sts v1.41.9/go.mod h1:LrlIndBDdjA/EeXeyNBle+gyCwTlizzW5ycgWnvIxkk=
+github.com/aws/smithy-go v1.24.2 h1:FzA3bu/nt/vDvmnkg+R8Xl46gmzEDam6mZ1hzmwXFng=
+github.com/aws/smithy-go v1.24.2/go.mod h1:YE2RhdIuDbA5E5bTdciG9KrW3+TiEONeUWCqxX9i1Fc=
+github.com/aymanbagabas/go-udiff v0.4.1 h1:OEIrQ8maEeDBXQDoGCbbTTXYJMYRCRO1fnodZ12Gv5o=
+github.com/aymanbagabas/go-udiff v0.4.1/go.mod h1:0L9PGwj20lrtmEMeyw4WKJ/TMyDtvAoK9bf2u/mNo3w=
+github.com/bgentry/go-netrc v0.0.0-20140422174119-9fd32a8b3d3d h1:xDfNPAt8lFiC1UJrqV3uuy861HCTo708pDMbjHHdCas=
+github.com/bgentry/go-netrc v0.0.0-20140422174119-9fd32a8b3d3d/go.mod h1:6QX/PXZ00z/TKoufEY6K/a0k6AhaJrQKdFe6OfVXsa4=
+github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
+github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/chainguard-dev/git-urls v1.0.2 h1:pSpT7ifrpc5X55n4aTTm7FFUE+ZQHKiqpiwNkJrVcKQ=
+github.com/chainguard-dev/git-urls v1.0.2/go.mod h1:rbGgj10OS7UgZlbzdUQIQpT0k/D4+An04HJY7Ol+Y/o=
+github.com/charmbracelet/colorprofile v0.4.3 h1:QPa1IWkYI+AOB+fE+mg/5/4HRMZcaXex9t5KX76i20Q=
+github.com/charmbracelet/colorprofile v0.4.3/go.mod h1:/zT4BhpD5aGFpqQQqw7a+VtHCzu+zrQtt1zhMt9mR4Q=
+github.com/charmbracelet/ultraviolet v0.0.0-20260416155717-489999b90468 h1:Q9fO0y1Zo5KB/5Vu8JZoLGm1N3RzF9bNj3Ao3xoR+Ac=
+github.com/charmbracelet/ultraviolet v0.0.0-20260416155717-489999b90468/go.mod h1:bAAz7dh/FTYfC+oiHavL4mX1tOIBZ0ZwYjSi3qE6ivM=
+github.com/charmbracelet/x/ansi v0.11.7 h1:kzv1kJvjg2S3r9KHo8hDdHFQLEqn4RBCb39dAYC84jI=
+github.com/charmbracelet/x/ansi v0.11.7/go.mod h1:9qGpnAVYz+8ACONkZBUWPtL7lulP9No6p1epAihUZwQ=
+github.com/charmbracelet/x/exp/golden v0.0.0-20250806222409-83e3a29d542f h1:pk6gmGpCE7F3FcjaOEKYriCvpmIN4+6OS/RD0vm4uIA=
+github.com/charmbracelet/x/exp/golden v0.0.0-20250806222409-83e3a29d542f/go.mod h1:IfZAMTHB6XkZSeXUqriemErjAWCCzT0LwjKFYCZyw0I=
+github.com/charmbracelet/x/term v0.2.2 h1:xVRT/S2ZcKdhhOuSP4t5cLi5o+JxklsoEObBSgfgZRk=
+github.com/charmbracelet/x/term v0.2.2/go.mod h1:kF8CY5RddLWrsgVwpw4kAa6TESp6EB5y3uxGLeCqzAI=
+github.com/charmbracelet/x/termios v0.1.1 h1:o3Q2bT8eqzGnGPOYheoYS8eEleT5ZVNYNy8JawjaNZY=
+github.com/charmbracelet/x/termios v0.1.1/go.mod h1:rB7fnv1TgOPOyyKRJ9o+AsTU/vK5WHJ2ivHeut/Pcwo=
+github.com/charmbracelet/x/windows v0.2.2 h1:IofanmuvaxnKHuV04sC0eBy/smG6kIKrWG2/jYn2GuM=
+github.com/charmbracelet/x/windows v0.2.2/go.mod h1:/8XtdKZzedat74NQFn0NGlGL4soHB0YQZrETF96h75k=
+github.com/clipperhouse/displaywidth v0.11.0 h1:lBc6kY44VFw+TDx4I8opi/EtL9m20WSEFgwIwO+UVM8=
+github.com/clipperhouse/displaywidth v0.11.0/go.mod h1:bkrFNkf81G8HyVqmKGxsPufD3JhNl3dSqnGhOoSD/o0=
+github.com/clipperhouse/uax29/v2 v2.7.0 h1:+gs4oBZ2gPfVrKPthwbMzWZDaAFPGYK72F0NJv2v7Vk=
+github.com/clipperhouse/uax29/v2 v2.7.0/go.mod h1:EFJ2TJMRUaplDxHKj1qAEhCtQPW2tJSwu5BF98AuoVM=
+github.com/cncf/xds/go v0.0.0-20251210132809-ee656c7534f5 h1:6xNmx7iTtyBRev0+D/Tv1FZd4SCg8axKApyNyRsAt/w=
+github.com/cncf/xds/go v0.0.0-20251210132809-ee656c7534f5/go.mod h1:KdCmV+x/BuvyMxRnYBlmVaq4OLiKW6iRQfvC62cvdkI=
+github.com/creack/pty v1.1.24 h1:bJrF4RRfyJnbTJqzRLHzcGaZK1NeM5kTC9jGgovnR1s=
+github.com/creack/pty v1.1.24/go.mod h1:08sCNb52WyoAwi2QDyzUCTgcvVFhUzewun7wtTfvcwE=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/google/uuid v1.0.0 h1:b4Gk+7WdP/d3HZH8EJsZpvV7EtDOgaZLtnaNGIu1adA=
-github.com/google/uuid v1.0.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/huandu/xstrings v1.1.0 h1:9oZY6Z/H3A1gytJxzuicbmV5QoR8M1TAPcn9WTg7vqg=
-github.com/huandu/xstrings v1.1.0/go.mod h1:DvyZB1rfVYsBIigL8HwpZgxHwXozlTgGqn63UyNX5k4=
-github.com/imdario/mergo v0.3.6 h1:xTNEAn+kxVO7dTZGu0CegyqKZmoWFI0rF8UxjlB2d28=
-github.com/imdario/mergo v0.3.6/go.mod h1:2EnlNZ0deacrJVfApfmtdGgDfMuh/nq6Ok1EcJh5FfA=
-github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
+github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM=
+github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/dlclark/regexp2 v1.11.5 h1:Q/sSnsKerHeCkc/jSTNq1oCm7KiVgUMZRDUoRu0JQZQ=
+github.com/dlclark/regexp2 v1.11.5/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
+github.com/dlclark/regexp2 v1.12.0 h1:0j4c5qQmnC6XOWNjP3PIXURXN2gWx76rd3KvgdPkCz8=
+github.com/dlclark/regexp2 v1.12.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/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
+github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
+github.com/elliotchance/orderedmap/v3 v3.1.0 h1:j4DJ5ObEmMBt/lcwIecKcoRxIQUEnw0L804lXYDt/pg=
+github.com/elliotchance/orderedmap/v3 v3.1.0/go.mod h1:G+Hc2RwaZvJMcS4JpGCOyViCnGeKf0bTYCGTO4uhjSo=
+github.com/envoyproxy/go-control-plane v0.14.0 h1:hbG2kr4RuFj222B6+7T83thSPqLjwBIfQawTkC++2HA=
+github.com/envoyproxy/go-control-plane v0.14.0/go.mod h1:NcS5X47pLl/hfqxU70yPwL9ZMkUlwlKxtAohpi2wBEU=
+github.com/envoyproxy/go-control-plane/envoy v1.36.0 h1:yg/JjO5E7ubRyKX3m07GF3reDNEnfOboJ0QySbH736g=
+github.com/envoyproxy/go-control-plane/envoy v1.36.0/go.mod h1:ty89S1YCCVruQAm9OtKeEkQLTb+Lkz0k8v9W0Oxsv98=
+github.com/envoyproxy/go-control-plane/ratelimit v0.1.0 h1:/G9QYbddjL25KvtKTv3an9lx6VBE2cnb8wp1vEGNYGI=
+github.com/envoyproxy/go-control-plane/ratelimit v0.1.0/go.mod h1:Wk+tMFAFbCXaJPzVVHnPgRKdUdwW/KdbRt94AzgRee4=
+github.com/envoyproxy/protoc-gen-validate v1.3.0 h1:TvGH1wof4H33rezVKWSpqKz5NXWg5VPuZ0uONDT6eb4=
+github.com/envoyproxy/protoc-gen-validate v1.3.0/go.mod h1:HvYl7zwPa5mffgyeTUHA9zHIH36nmrm7oCbo4YKoSWA=
+github.com/fatih/color v1.19.0 h1:Zp3PiM21/9Ld6FzSKyL5c/BULoe/ONr9KlbYVOfG8+w=
+github.com/fatih/color v1.19.0/go.mod h1:zNk67I0ZUT1bEGsSGyCZYZNrHuTkJJB+r6Q9VuMi0LE=
+github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg=
+github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U=
+github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=
+github.com/fsnotify/fsnotify v1.9.0/go.mod h1:8jBTzvmWwFyi3Pb8djgCCO5IBqzKJ/Jwo8TRcHyHii0=
+github.com/fsnotify/fsnotify v1.10.1 h1:b0/UzAf9yR5rhf3RPm9gf3ehBPpf0oZKIjtpKrx59Ho=
+github.com/fsnotify/fsnotify v1.10.1/go.mod h1:TLheqan6HD6GBK6PrDWyDPBaEV8LspOxvPSjC+bVfgo=
+github.com/go-jose/go-jose/v4 v4.1.4 h1:moDMcTHmvE6Groj34emNPLs/qtYXRVcd6S7NHbHz3kA=
+github.com/go-jose/go-jose/v4 v4.1.4/go.mod h1:x4oUasVrzR7071A4TnHLGSPpNOm2a21K9Kf04k1rs08=
+github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
+github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI=
+github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
+github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
+github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
+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.2.0 h1:xW7ek0o65FUSTbKcSNeg2Vyf/I7wYXFgLUznptvviBE=
+github.com/go-task/template v0.2.0/go.mod h1:dbdoUb6qKnHQi1y6o+IdIrs0J4o/SEhSTA6bbzZmdtc=
+github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=
+github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps=
+github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
+github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
+github.com/google/martian/v3 v3.3.3 h1:DIhPTQrbPkgs2yJYdXU/eNACCG5DVQjySNRNlflZ9Fc=
+github.com/google/martian/v3 v3.3.3/go.mod h1:iEPrYcgCF7jA9OtScMFQyAlZZ4YXTKEtJ1E6RWzmBA0=
+github.com/google/s2a-go v0.1.9 h1:LGD7gtMgezd8a/Xak7mEWL0PjoTQFvpRudN895yqKW0=
+github.com/google/s2a-go v0.1.9/go.mod h1:YA0Ei2ZQL3acow2O62kdp9UlnvMmU7kA6Eutn0dXayM=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/googleapis/enterprise-certificate-proxy v0.3.14 h1:yh8ncqsbUY4shRD5dA6RlzjJaT4hi3kII+zYw8wmLb8=
+github.com/googleapis/enterprise-certificate-proxy v0.3.14/go.mod h1:vqVt9yG9480NtzREnTlmGSBmFrA+bzb0yl0TxoBQXOg=
+github.com/googleapis/gax-go/v2 v2.17.0 h1:RksgfBpxqff0EZkDWYuz9q/uWsTVz+kf43LsZ1J6SMc=
+github.com/googleapis/gax-go/v2 v2.17.0/go.mod h1:mzaqghpQp4JDh3HvADwrat+6M3MOIDp5YKHhb9PAgDY=
+github.com/hashicorp/aws-sdk-go-base/v2 v2.0.0-beta.72 h1:vTCWu1wbdYo7PEZFem/rlr01+Un+wwVmI7wiegFdRLk=
+github.com/hashicorp/aws-sdk-go-base/v2 v2.0.0-beta.72/go.mod h1:Vn+BBgKQHVQYdVQ4NZDICE1Brb+JfaONyDHr3q07oQc=
+github.com/hashicorp/go-cleanhttp v0.5.2 h1:035FKYIWjmULyFRBKPs8TBQoi0x6d9G4xc9neXJWAZQ=
+github.com/hashicorp/go-cleanhttp v0.5.2/go.mod h1:kO/YDlP8L1346E6Sodw+PrpBSV4/SoxCXGY6BqNFT48=
+github.com/hashicorp/go-getter v1.8.6 h1:9sQboWULaydVphxc4S64oAI4YqpuCk7nPmvbk131ebY=
+github.com/hashicorp/go-getter v1.8.6/go.mod h1:nVH12eOV2P58dIiL3rsU6Fh3wLeJEKBOJzhMmzlSWoo=
+github.com/hashicorp/go-version v1.8.0 h1:KAkNb1HAiZd1ukkxDFGmokVZe1Xy9HG6NUp+bPle2i4=
+github.com/hashicorp/go-version v1.8.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA=
+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/compress v1.18.5 h1:/h1gH5Ce+VWNLSWqPzOVn6XBO+vJbCNGvjoaGBFW2IE=
+github.com/klauspost/compress v1.18.5/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ=
+github.com/klauspost/cpuid/v2 v2.2.10 h1:tBs3QSyvjDyFTq3uoc/9xFpCuOsJQFNPiAhYdw2skhE=
+github.com/klauspost/cpuid/v2 v2.2.10/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0=
+github.com/klauspost/pgzip v1.2.6 h1:8RXeL5crjEUFnR2/Sn6GJNWtSQ3Dk8pq4CL3jvdDyjU=
+github.com/klauspost/pgzip v1.2.6/go.mod h1:Ch1tH69qFZu15pkjo5kYi6mth2Zzwzt50oCQKQE9RUs=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
-github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
-github.com/mattn/go-zglob v0.0.0-20180803001819-2ea3427bfa53 h1:tGfIHhDghvEnneeRhODvGYOt305TPwingKt6p90F4MU=
-github.com/mattn/go-zglob v0.0.0-20180803001819-2ea3427bfa53/go.mod h1:9fxibJccNxU2cnpIKLRRFA7zX7qhkJIQWBb449FYHOo=
-github.com/mitchellh/go-homedir v1.0.0 h1:vKb8ShqSby24Yrqr/yDYkuFz8d0WUjys40rvnGC8aR0=
-github.com/mitchellh/go-homedir v1.0.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/lucasb-eyer/go-colorful v1.4.0 h1:UtrWVfLdarDgc44HcS7pYloGHJUjHV/4FwW4TvVgFr4=
+github.com/lucasb-eyer/go-colorful v1.4.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
+github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
+github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
+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-runewidth v0.0.23 h1:7ykA0T0jkPpzSvMS5i9uoNn2Xy3R383f9HDx3RybWcw=
+github.com/mattn/go-runewidth v0.0.23/go.mod h1:XBkDxAl56ILZc9knddidhrOlY5R/pDhgLpndooCuJAs=
+github.com/mitchellh/go-homedir v1.1.0 h1:lukF9ziXFxDFPkA1vsr5zpc1XuPDn/wFntq5mG+4E0Y=
+github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
+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/muesli/cancelreader v0.2.2 h1:3I4Kt4BQjOR54NavqnDogx/MIoWBFa0StPA8ELUXHmA=
+github.com/muesli/cancelreader v0.2.2/go.mod h1:3XuTXfFS2VjM+HTLZY9Ak0l6eUKfijIfMUZ4EgX0QYo=
+github.com/pierrec/lz4/v4 v4.1.22 h1:cKFw6uJDK+/gfw5BcDL0JL5aBsAFdsIT18eRtLj7VIU=
+github.com/pierrec/lz4/v4 v4.1.22/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4=
+github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10 h1:GFCKgmp0tecUJ0sJuv4pzYCqS9+RGSn52M3FUwPs+uo=
+github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10/go.mod h1:t/avpk3KcrXxUnYOhZhMXJlSEyie6gQbtLq5NM3loB8=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/radovskyb/watcher v1.0.2 h1:9L5TsZUbo1nKhQEQPtICVc+x9UZQ6VPdBepLHyGw/bQ=
-github.com/radovskyb/watcher v1.0.2/go.mod h1:78okwvY5wPdzcb1UYnip1pvrZNIVEIh/Cm+ZuvsUYIg=
-github.com/spf13/pflag v1.0.3 h1:zPAT6CGy6wXeQ7NtTnaTerfKOsV6V6F8agHXFiazDkg=
-github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
-github.com/stretchr/testify v1.2.2 h1:bSDNvY7ZPG5RlJ8otE/7V6gMiyenm9RtJ7IUVIAoJ1w=
-github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
-golang.org/x/crypto v0.0.0-20180830192347-182538f80094 h1:rVTAlhYa4+lCfNxmAIEOGQRoD23UqP72M3+rSWVGDTg=
-golang.org/x/crypto v0.0.0-20180830192347-182538f80094/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
-golang.org/x/net v0.0.0-20180826012351-8a410e7b638d h1:g9qWBGx4puODJTMVyoPrpoxPFgVGd+z1DZwjfRu4d0I=
-golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f h1:wMNYb4v58l5UBM7MYRLPG6ZhfOqbKu7X5eyFl8ZhKvA=
-golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sys v0.0.0-20180831094639-fa5fdf94c789 h1:T8D7l6WB3tLu+VpKvw06ieD/OhBi1XpJmG1U/FtttZg=
-golang.org/x/sys v0.0.0-20180831094639-fa5fdf94c789/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U=
+github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/puzpuzpuz/xsync/v4 v4.5.0 h1:vOSWu6b57/emh+L/Cw0BeQfvxa/cogFywXHeGUxQxAg=
+github.com/puzpuzpuz/xsync/v4 v4.5.0/go.mod h1:VJDmTCJMBt8igNxnkQd86r+8KUeN1quSfNKu5bLYFQo=
+github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
+github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
+github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
+github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
+github.com/sajari/fuzzy v1.0.0 h1:+FmwVvJErsd0d0hAPlj4CxqxUtQY/fOoY0DwX4ykpRY=
+github.com/sajari/fuzzy v1.0.0/go.mod h1:OjYR6KxoWOe9+dOlXeiCJd4dIbED4Oo8wpS89o0pwOo=
+github.com/sebdah/goldie/v2 v2.8.0 h1:dZb9wR8q5++oplmEiJT+U/5KyotVD+HNGCAc5gNr8rc=
+github.com/sebdah/goldie/v2 v2.8.0/go.mod h1:oZ9fp0+se1eapSRjfYbsV/0Hqhbuu3bJVvKI/NNtssI=
+github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo=
+github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3 h1:n661drycOFuPLCN3Uc8sB6B/s6Z4t2xvBgU1htSHuq8=
+github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3/go.mod h1:A0bzQcvG0E7Rwjx0REVgAGH58e96+X0MeOfepqsbeW4=
+github.com/spf13/pflag v1.0.10 h1:4EBh2KAYBwaONj6b2Ye1GiHfwjqyROoF4RwYO+vPwFk=
+github.com/spf13/pflag v1.0.10/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/spiffe/go-spiffe/v2 v2.6.0 h1:l+DolpxNWYgruGQVV0xsfeya3CsC7m8iBzDnMpsbLuo=
+github.com/spiffe/go-spiffe/v2 v2.6.0/go.mod h1:gm2SeUoMZEtpnzPNs2Csc0D/gX33k1xIx7lEzqblHEs=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY=
+github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
+github.com/u-root/u-root v0.15.1-0.20251208185023-2f8c7e763cf8 h1:cq+DjLAjz3ZPwh0+G571O/jMH0c0DzReDPLjQGL2/BA=
+github.com/u-root/u-root v0.15.1-0.20251208185023-2f8c7e763cf8/go.mod h1:JNauIV2zopCBv/6o+umxcT3bKe8YUqYJaTZQYSYpKss=
+github.com/u-root/uio v0.0.0-20240224005618-d2acac8f3701 h1:pyC9PaHYZFgEKFdlp3G8RaCKgVpHZnecvArXvPXcFkM=
+github.com/u-root/uio v0.0.0-20240224005618-d2acac8f3701/go.mod h1:P3a5rG4X7tI17Nn3aOIAYr5HbIMukwXG0urG0WuL8OA=
+github.com/ulikunitz/xz v0.5.15 h1:9DNdB5s+SgV3bQ2ApL10xRc35ck0DuIX/isZvIk+ubY=
+github.com/ulikunitz/xz v0.5.15/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14=
+github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e h1:JVG44RsyaB9T2KIHavMF/ppJZNG9ZpyihvCd0w101no=
+github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e/go.mod h1:RbqR21r5mrJuqunuUZ/Dhy/avygyECGrLceyNeo4LiM=
+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.1.0 h1:s7DLGDK45Dyfg7++yxI0khrfwq9661w9EN78eP/UZVs=
+github.com/zeebo/xxh3 v1.1.0/go.mod h1:IisAie1LELR4xhVinxWS5+zf1lA4p0MW4T+w+W07F5s=
+go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64=
+go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y=
+go.opentelemetry.io/contrib/detectors/gcp v1.39.0 h1:kWRNZMsfBHZ+uHjiH4y7Etn2FK26LAGkNFw7RHv1DhE=
+go.opentelemetry.io/contrib/detectors/gcp v1.39.0/go.mod h1:t/OGqzHBa5v6RHZwrDBJ2OirWc+4q/w2fTbLZwAKjTk=
+go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.63.0 h1:YH4g8lQroajqUwWbq/tr2QX1JFmEXaDLgG+ew9bLMWo=
+go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.63.0/go.mod h1:fvPi2qXDqFs8M4B4fmJhE92TyQs9Ydjlg3RvfUp+NbQ=
+go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.61.0 h1:F7Jx+6hwnZ41NSFTO5q4LYDtJRXBf2PD0rNBkeB/lus=
+go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.61.0/go.mod h1:UHB22Z8QsdRDrnAtX4PntOl36ajSxcdUMt1sF7Y6E7Q=
+go.opentelemetry.io/otel v1.43.0 h1:mYIM03dnh5zfN7HautFE4ieIig9amkNANT+xcVxAj9I=
+go.opentelemetry.io/otel v1.43.0/go.mod h1:JuG+u74mvjvcm8vj8pI5XiHy1zDeoCS2LB1spIq7Ay0=
+go.opentelemetry.io/otel/exporters/stdout/stdoutmetric v1.40.0 h1:ZrPRak/kS4xI3AVXy8F7pipuDXmDsrO8Lg+yQjBLjw0=
+go.opentelemetry.io/otel/exporters/stdout/stdoutmetric v1.40.0/go.mod h1:3y6kQCWztq6hyW8Z9YxQDDm0Je9AJoFar2G0yDcmhRk=
+go.opentelemetry.io/otel/metric v1.43.0 h1:d7638QeInOnuwOONPp4JAOGfbCEpYb+K6DVWvdxGzgM=
+go.opentelemetry.io/otel/metric v1.43.0/go.mod h1:RDnPtIxvqlgO8GRW18W6Z/4P462ldprJtfxHxyKd2PY=
+go.opentelemetry.io/otel/sdk v1.43.0 h1:pi5mE86i5rTeLXqoF/hhiBtUNcrAGHLKQdhg4h4V9Dg=
+go.opentelemetry.io/otel/sdk v1.43.0/go.mod h1:P+IkVU3iWukmiit/Yf9AWvpyRDlUeBaRg6Y+C58QHzg=
+go.opentelemetry.io/otel/sdk/metric v1.43.0 h1:S88dyqXjJkuBNLeMcVPRFXpRw2fuwdvfCGLEo89fDkw=
+go.opentelemetry.io/otel/sdk/metric v1.43.0/go.mod h1:C/RJtwSEJ5hzTiUz5pXF1kILHStzb9zFlIEe85bhj6A=
+go.opentelemetry.io/otel/trace v1.43.0 h1:BkNrHpup+4k4w+ZZ86CZoHHEkohws8AY+WTX09nk+3A=
+go.opentelemetry.io/otel/trace v1.43.0/go.mod h1:/QJhyVBUUswCphDVxq+8mld+AvhXZLhe+8WVFxiFff0=
+go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc=
+go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
+golang.org/x/crypto v0.51.0 h1:IBPXwPfKxY7cWQZ38ZCIRPI50YLeevDLlLnyC5wRGTI=
+golang.org/x/crypto v0.51.0/go.mod h1:8AdwkbraGNABw2kOX6YFPs3WM22XqI4EXEd8g+x7Oc8=
+golang.org/x/exp v0.0.0-20250305212735-054e65f0b394 h1:nDVHiLt8aIbd/VzvPWN6kSOPE7+F/fNFDSXLVYkE/Iw=
+golang.org/x/exp v0.0.0-20250305212735-054e65f0b394/go.mod h1:sIifuuw/Yco/y6yb6+bDNfyeQ/MdPUy/hKEMYQV17cM=
+golang.org/x/net v0.54.0 h1:2zJIZAxAHV/OHCDTCOHAYehQzLfSXuf/5SoL/Dv6w/w=
+golang.org/x/net v0.54.0/go.mod h1:Sj4oj8jK6XmHpBZU/zWHw3BV3abl4Kvi+Ut7cQcY+cQ=
+golang.org/x/oauth2 v0.36.0 h1:peZ/1z27fi9hUOFCAZaHyrpWG5lwe0RJEEEeH0ThlIs=
+golang.org/x/oauth2 v0.36.0/go.mod h1:YDBUJMTkDnJS+A4BP4eZBjCqtokkg1hODuPjwiGPO7Q=
+golang.org/x/sync v0.20.0 h1:e0PTpb7pjO8GAtTs2dQ6jYa5BWYlMuX047Dco/pItO4=
+golang.org/x/sync v0.20.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.44.0 h1:ildZl3J4uzeKP07r2F++Op7E9B29JRUy+a27EibtBTQ=
+golang.org/x/sys v0.44.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
+golang.org/x/term v0.43.0 h1:S4RLU2sB31O/NCl+zFN9Aru9A/Cq2aqKpTZJ6B+DwT4=
+golang.org/x/term v0.43.0/go.mod h1:lrhlHNdQJHO+1qVYiHfFKVuVioJIheAc3fBSMFYEIsk=
+golang.org/x/text v0.37.0 h1:Cqjiwd9eSg8e0QAkyCaQTNHFIIzWtidPahFWR83rTrc=
+golang.org/x/text v0.37.0/go.mod h1:a5sjxXGs9hsn/AJVwuElvCAo9v8QYLzvavO5z2PiM38=
+golang.org/x/time v0.15.0 h1:bbrp8t3bGUeFOx08pvsMYRTCVSMk89u4tKbNOZbp88U=
+golang.org/x/time v0.15.0/go.mod h1:Y4YMaQmXwGQZoFaVFk4YpCt4FLQMYKZe9oeV/f4MSno=
+gonum.org/v1/gonum v0.16.0 h1:5+ul4Swaf3ESvrOnidPp4GZbzf0mxVQpDCYUQE7OJfk=
+gonum.org/v1/gonum v0.16.0/go.mod h1:fef3am4MQ93R2HHpKnLk4/Tbh/s0+wqD5nfa6Pnwy4E=
+google.golang.org/api v0.271.0 h1:cIPN4qcUc61jlh7oXu6pwOQqbJW2GqYh5PS6rB2C/JY=
+google.golang.org/api v0.271.0/go.mod h1:CGT29bhwkbF+i11qkRUJb2KMKqcJ1hdFceEIRd9u64Q=
+google.golang.org/genproto v0.0.0-20260128011058-8636f8732409 h1:VQZ/yAbAtjkHgH80teYd2em3xtIkkHd7ZhqfH2N9CsM=
+google.golang.org/genproto v0.0.0-20260128011058-8636f8732409/go.mod h1:rxKD3IEILWEu3P44seeNOAwZN4SaoKaQ/2eTg4mM6EM=
+google.golang.org/genproto/googleapis/api v0.0.0-20260203192932-546029d2fa20 h1:7ei4lp52gK1uSejlA8AZl5AJjeLUOHBQscRQZUgAcu0=
+google.golang.org/genproto/googleapis/api v0.0.0-20260203192932-546029d2fa20/go.mod h1:ZdbssH/1SOVnjnDlXzxDHK2MCidiqXtbYccJNzNYPEE=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20260226221140-a57be14db171 h1:ggcbiqK8WWh6l1dnltU4BgWGIGo+EVYxCaAPih/zQXQ=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20260226221140-a57be14db171/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8=
+google.golang.org/grpc v1.79.3 h1:sybAEdRIEtvcD68Gx7dmnwjZKlyfuc61Dyo9pGXXkKE=
+google.golang.org/grpc v1.79.3/go.mod h1:KmT0Kjez+0dde/v2j9vzwoAScgEPx/Bw1CYChhHLrHQ=
+google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE=
+google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/yaml.v2 v2.2.1 h1:mUhvW9EsL+naU5Q3cakzfE91YhliOondGd6ZrsDBHQE=
-gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-mvdan.cc/sh v2.6.3-0.20181216173157-8aeb0734cd0f+incompatible h1:jf0jjqiqwKXdH3JBKY+K3tFXGtUQZr/pFIO+cn0tQCc=
-mvdan.cc/sh v2.6.3-0.20181216173157-8aeb0734cd0f+incompatible/go.mod h1:IeeQbZq+x2SUGBensq/jge5lLQbS3XT2ktyp3wrt4x8=
+gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
+gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+mvdan.cc/sh/moreinterp v0.0.0-20260120230322-19def062a997 h1:3bbJwtPFh98dJ6lxRdR3eLHTH1CmR3BcU6TriIMiXjE=
+mvdan.cc/sh/moreinterp v0.0.0-20260120230322-19def062a997/go.mod h1:Qy/zdaMDxq9sT72Gi43K3gsV+TtTohyDO3f1cyBVwuo=
+mvdan.cc/sh/v3 v3.13.2-0.20260503214111-9e7dd28c81cf h1:3mGRe/xSr7fd9m+c5FSab/CSCtADsbdMcyhYGdVR6DY=
+mvdan.cc/sh/v3 v3.13.2-0.20260503214111-9e7dd28c81cf/go.mod h1:lXJ8SexMvEVcHCoDvAGLZgFJ9Wsm2sulmoNEXGhYZD0=
+mvdan.cc/sh/v3 v3.13.2-0.20260510185049-f5c6e2779117 h1:BfzdGSjcnJBb8sPNLudpzTml8zFUxS1N0N/v9IIS6tQ=
+mvdan.cc/sh/v3 v3.13.2-0.20260510185049-f5c6e2779117/go.mod h1:lXJ8SexMvEVcHCoDvAGLZgFJ9Wsm2sulmoNEXGhYZD0=

hash.go

@@ -0,0 +1,25 @@
+package task
+
+import (
+	"cmp"
+	"fmt"
+
+	"github.com/go-task/task/v3/internal/hash"
+	"github.com/go-task/task/v3/taskfile/ast"
+)
+
+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":
+		h = hash.Empty
+	case "once":
+		h = hash.Name
+	case "when_changed":
+		h = hash.Hash
+	default:
+		return "", fmt.Errorf(`task: invalid run "%s"`, r)
+	}
+	return h(t)
+}

help.go

@@ -1,37 +1,200 @@
 package task
 
 import (
+	"context"
+	"encoding/json"
 	"fmt"
-	"sort"
-	"text/tabwriter"
+	"io"
+	"os"
+	"strings"
 
-	"github.com/go-task/task/v2/internal/taskfile"
+	"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/internal/sort"
+	"github.com/go-task/task/v3/taskfile/ast"
 )
 
-// PrintTasksHelp prints help os tasks that have a description
-func (e *Executor) PrintTasksHelp() {
-	tasks := e.tasksWithDesc()
-	if len(tasks) == 0 {
-		e.Logger.Outf("task: No tasks with description available")
-		return
+// ListOptions collects list-related options
+type ListOptions struct {
+	ListOnlyTasksWithDescriptions bool
+	ListAllTasks                  bool
+	FormatTaskListAsJSON          bool
+	NoStatus                      bool
+	Nested                        bool
+}
+
+// NewListOptions creates a new ListOptions instance
+func NewListOptions(list, listAll, listAsJson, noStatus, nested bool) ListOptions {
+	return ListOptions{
+		ListOnlyTasksWithDescriptions: list,
+		ListAllTasks:                  listAll,
+		FormatTaskListAsJSON:          listAsJson,
+		NoStatus:                      noStatus,
+		Nested:                        nested,
 	}
-	e.Logger.Outf("task: Available tasks for this project:")
+}
+
+// ShouldListTasks returns true if one of the options to list tasks has been set to true
+func (o ListOptions) ShouldListTasks() bool {
+	return o.ListOnlyTasksWithDescriptions || o.ListAllTasks
+}
+
+// Filters returns the slice of FilterFunc which filters a list
+// of ast.Task according to the given ListOptions
+func (o ListOptions) Filters() []FilterFunc {
+	filters := []FilterFunc{FilterOutInternal}
+
+	if o.ListOnlyTasksWithDescriptions {
+		filters = append(filters, FilterOutNoDesc)
+	}
+
+	return filters
+}
+
+// ListTasks prints a list of tasks.
+// Tasks that match the given filters will be excluded from the list.
+// The function returns a boolean indicating whether tasks were found
+// and an error if one was encountered while preparing the output.
+func (e *Executor) ListTasks(o ListOptions) (bool, error) {
+	tasks, err := e.GetTaskList(o.Filters()...)
+	if err != nil {
+		return false, err
+	}
+	if o.FormatTaskListAsJSON {
+		output, err := e.ToEditorOutput(tasks, o.NoStatus, o.Nested)
+		if err != nil {
+			return false, err
+		}
+
+		encoder := json.NewEncoder(e.Stdout)
+		encoder.SetIndent("", "  ")
+		if err := encoder.Encode(output); err != nil {
+			return false, err
+		}
+
+		return len(tasks) > 0, nil
+	}
+	if len(tasks) == 0 {
+		if o.ListOnlyTasksWithDescriptions {
+			e.Logger.Outf(logger.Yellow, "task: No tasks with description available. Try --list-all to list all tasks\n")
+		} else if o.ListAllTasks {
+			e.Logger.Outf(logger.Yellow, "task: No tasks available\n")
+		}
+		return false, nil
+	}
+	e.Logger.Outf(logger.Default, "task: Available tasks for this project:\n")
 
 	// Format in tab-separated columns with a tab stop of 8.
-	w := tabwriter.NewWriter(e.Stdout, 0, 8, 0, '\t', 0)
+	w := tabwriter.NewWriter(e.Stdout, 0, 8, 6, ' ', 0)
 	for _, task := range tasks {
-		fmt.Fprintf(w, "* %s: \t%s\n", task.Task, task.Desc)
+		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")
 	}
-	w.Flush()
+	if err := w.Flush(); err != nil {
+		return false, err
+	}
+	return true, nil
 }
 
-func (e *Executor) tasksWithDesc() (tasks []*taskfile.Task) {
-	tasks = make([]*taskfile.Task, 0, len(e.Taskfile.Tasks))
-	for _, task := range e.Taskfile.Tasks {
-		if task.Desc != "" {
-			tasks = append(tasks, task)
+// ListTaskNames prints only the task names in a Taskfile.
+// Only tasks with a non-empty description are printed if allTasks is false.
+// Otherwise, all task names are printed.
+func (e *Executor) ListTaskNames(allTasks bool) error {
+	// use stdout if no output defined
+	var w io.Writer = os.Stdout
+	if e.Stdout != nil {
+		w = e.Stdout
+	}
+
+	// Sort the tasks
+	if e.TaskSorter == nil {
+		e.TaskSorter = sort.AlphaNumericWithRootTasksFirst
+	}
+
+	// Create a list of task names
+	taskNames := make([]string, 0, e.Taskfile.Tasks.Len())
+	for task := range e.Taskfile.Tasks.Values(e.TaskSorter) {
+		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.Slice(tasks, func(i, j int) bool { return tasks[i].Task < tasks[j].Task })
-	return
+	for _, t := range taskNames {
+		fmt.Fprintln(w, t)
+	}
+	return nil
+}
+
+func (e *Executor) ToEditorOutput(tasks []*ast.Task, noStatus bool, nested bool) (*editors.Namespace, error) {
+	var g errgroup.Group
+	editorTasks := make([]editors.Task, len(tasks))
+
+	// Look over each task in parallel and turn it into an editor task
+	for i := range tasks {
+		g.Go(func() error {
+			editorTask := editors.NewTask(tasks[i])
+
+			if noStatus {
+				editorTasks[i] = editorTask
+				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
+			}
+
+			editorTask.UpToDate = &upToDate
+			editorTasks[i] = editorTask
+			return nil
+		})
+	}
+	if err := g.Wait(); err != nil {
+		return nil, err
+	}
+
+	// Create the root namespace
+	var tasksLen int
+	if !nested {
+		tasksLen = len(editorTasks)
+	}
+	rootNamespace := &editors.Namespace{
+		Tasks:    make([]editors.Task, tasksLen),
+		Location: e.Taskfile.Location,
+	}
+
+	// Recursively add namespaces to the root namespace or if nesting is
+	// disabled add them all to the root namespace
+	for i, task := range editorTasks {
+		taskNamespacePath := strings.Split(task.Task, ast.NamespaceSeparator)
+		if nested {
+			rootNamespace.AddNamespace(taskNamespacePath, task)
+		} else {
+			rootNamespace.Tasks[i] = task
+		}
+	}
+
+	return rootNamespace, g.Wait()
 }

init.go

@@ -1,38 +1,50 @@
 package task
 
 import (
-	"fmt"
-	"io"
-	"io/ioutil"
+	_ "embed"
 	"os"
-	"path/filepath"
+
+	"github.com/go-task/task/v3/errors"
+	"github.com/go-task/task/v3/internal/filepathext"
+	"github.com/go-task/task/v3/taskfile"
 )
 
-const defaultTaskfile = `# https://taskfile.org
+const defaultFilename = "Taskfile.yml"
 
-version: '2'
+//go:embed taskfile/templates/default.yml
+var DefaultTaskfile string
 
-vars:
-  GREETING: Hello, World!
-
-tasks:
-  default:
-    cmds:
-      - echo "{{.GREETING}}"
-    silent: true
-`
-
-// InitTaskfile Taskfile creates a new Taskfile
-func InitTaskfile(w io.Writer, dir string) error {
-	f := filepath.Join(dir, "Taskfile.yml")
-
-	if _, err := os.Stat(f); err == nil {
-		return ErrTaskfileAlreadyExists
+// InitTaskfile creates a new Taskfile at path.
+//
+// path can be either a file path or a directory path.
+// If path is a directory, path/Taskfile.yml will be created.
+//
+// The final file path is always returned and may be different from the input path.
+func InitTaskfile(path string) (string, error) {
+	info, err := os.Stat(path)
+	if err == nil && !info.IsDir() {
+		return path, errors.TaskfileAlreadyExistsError{}
 	}
 
-	if err := ioutil.WriteFile(f, []byte(defaultTaskfile), 0644); err != nil {
-		return err
+	if info != nil && info.IsDir() {
+		// path was a directory, check if there is a Taskfile already
+		if hasDefaultTaskfile(path) {
+			return path, errors.TaskfileAlreadyExistsError{}
+		}
+		path = filepathext.SmartJoin(path, defaultFilename)
 	}
-	fmt.Fprintf(w, "Taskfile.yml created in the current directory\n")
-	return nil
+
+	if err := os.WriteFile(path, []byte(DefaultTaskfile), 0o644); err != nil {
+		return path, err
+	}
+	return path, nil
+}
+
+func hasDefaultTaskfile(dir string) bool {
+	for _, name := range taskfile.DefaultTaskfiles {
+		if _, err := os.Stat(filepathext.SmartJoin(dir, name)); err == nil {
+			return true
+		}
+	}
+	return false
 }

init_test.go

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

install-task.sh

@@ -1,6 +1,6 @@
 #!/bin/sh
 set -e
-# Code generated by godownloader on 2018-04-07T17:47:38Z. DO NOT EDIT.
+# Code generated by godownloader on 2021-01-12T13:40:40Z. DO NOT EDIT.
 #
 
 usage() {
@@ -27,11 +27,12 @@ parse_args() {
   # over-ridden by flag below
 
   BINDIR=${BINDIR:-./bin}
-  while getopts "b:dh?" arg; do
+  while getopts "b:dh?x" arg; do
     case "$arg" in
       b) BINDIR="$OPTARG" ;;
       d) log_set_priority 10 ;;
       h | \?) usage "$0" ;;
+      x) set -x ;;
     esac
   done
   shift $((OPTIND - 1))
@@ -42,46 +43,41 @@ parse_args() {
 # network, either nothing will happen or will syntax error
 # out preventing half-done work
 execute() {
-  tmpdir=$(mktmpdir)
+  tmpdir=$(mktemp -d)
   log_debug "downloading files into ${tmpdir}"
   http_download "${tmpdir}/${TARBALL}" "${TARBALL_URL}"
   http_download "${tmpdir}/${CHECKSUM}" "${CHECKSUM_URL}"
   hash_sha256_verify "${tmpdir}/${TARBALL}" "${tmpdir}/${CHECKSUM}"
   srcdir="${tmpdir}"
   (cd "${tmpdir}" && untar "${TARBALL}")
-  install -d "${BINDIR}"
-  for binexe in "task" ; do
+  test ! -d "${BINDIR}" && install -d "${BINDIR}"
+  for binexe in $BINARIES; do
     if [ "$OS" = "windows" ]; then
       binexe="${binexe}.exe"
     fi
     install "${srcdir}/${binexe}" "${BINDIR}/"
     log_info "installed ${BINDIR}/${binexe}"
   done
+  rm -rf "${tmpdir}"
 }
-is_supported_platform() {
-  platform=$1
-  found=1
-  case "$platform" in
-    windows/386) found=0 ;;
-    windows/amd64) found=0 ;;
-    darwin/386) found=0 ;;
-    darwin/amd64) found=0 ;;
-    linux/386) found=0 ;;
-    linux/amd64) found=0 ;;
+get_binaries() {
+  case "$PLATFORM" in
+    darwin/amd64) BINARIES="task" ;;
+    darwin/arm64) BINARIES="task" ;;
+    darwin/arm) BINARIES="task" ;;
+    linux/386) BINARIES="task" ;;
+    linux/amd64) BINARIES="task" ;;
+    linux/arm64) BINARIES="task" ;;
+    linux/arm) BINARIES="task" ;;
+    windows/386) BINARIES="task" ;;
+    windows/amd64) BINARIES="task" ;;
+    windows/arm64) BINARIES="task" ;;
+    windows/arm) 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
+      ;;
   esac
-  case "$platform" in
-    darwin/386) found=1 ;;
-  esac
-  return $found
-}
-check_platform() {
-  if is_supported_platform "$PLATFORM"; then
-    # optional logging goes here
-    true
-  else
-    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
-  fi
 }
 tag_to_version() {
   if [ -z "${TAG}" ]; then
@@ -99,8 +95,8 @@ tag_to_version() {
   VERSION=${TAG#v}
 }
 adjust_format() {
-  # change format (tar.gz or zip) based on ARCH
-  case ${ARCH} in
+  # change format (tar.gz or zip) based on OS
+  case ${OS} in
     windows) FORMAT=zip ;;
   esac
   true
@@ -174,7 +170,9 @@ log_crit() {
 uname_os() {
   os=$(uname -s | tr '[:upper:]' '[:lower:]')
   case "$os" in
-    msys_nt) os="windows" ;;
+    cygwin_nt*) os="windows" ;;
+    mingw*) os="windows" ;;
+    msys_nt*) os="windows" ;;
   esac
   echo "$os"
 }
@@ -186,9 +184,9 @@ uname_arch() {
     i686) arch="386" ;;
     i386) arch="386" ;;
     aarch64) arch="arm64" ;;
-    armv5*) arch="arm5" ;;
-    armv6*) arch="arm6" ;;
-    armv7*) arch="arm7" ;;
+    armv5*) arch="arm" ;;
+    armv6*) arch="arm" ;;
+    armv7*) arch="arm" ;;
   esac
   echo ${arch}
 }
@@ -216,9 +214,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 ;;
@@ -234,8 +230,8 @@ uname_arch_check() {
 untar() {
   tarball=$1
   case "${tarball}" in
-    *.tar.gz | *.tgz) tar -xzf "${tarball}" ;;
-    *.tar) tar -xf "${tarball}" ;;
+    *.tar.gz | *.tgz) tar --no-same-owner -xzf "${tarball}" ;;
+    *.tar) tar --no-same-owner -xf "${tarball}" ;;
     *.zip) unzip "${tarball}" ;;
     *)
       log_err "untar unknown archive format for ${tarball}"
@@ -243,11 +239,6 @@ untar() {
       ;;
   esac
 }
-mktmpdir() {
-  test -z "$TMPDIR" && TMPDIR="$(mktemp -d)"
-  mkdir -p "${TMPDIR}"
-  echo "${TMPDIR}"
-}
 http_download_curl() {
   local_file=$1
   source_url=$2
@@ -368,7 +359,7 @@ uname_arch_check "$ARCH"
 
 parse_args "$@"
 
-check_platform
+get_binaries
 
 tag_to_version
 

internal/args/args.go

@@ -1,36 +0,0 @@
-package args
-
-import (
-	"errors"
-	"strings"
-
-	"github.com/go-task/task/v2/internal/taskfile"
-)
-
-var (
-	// ErrVariableWithoutTask is returned when variables are given before any task
-	ErrVariableWithoutTask = errors.New("task: variable given before any task")
-)
-
-// Parse parses command line argument: tasks and vars of each task
-func Parse(args ...string) ([]taskfile.Call, error) {
-	var calls []taskfile.Call
-
-	for _, arg := range args {
-		if !strings.Contains(arg, "=") {
-			calls = append(calls, taskfile.Call{Task: arg})
-			continue
-		}
-		if len(calls) < 1 {
-			return nil, ErrVariableWithoutTask
-		}
-
-		if calls[len(calls)-1].Vars == nil {
-			calls[len(calls)-1].Vars = make(taskfile.Vars)
-		}
-
-		pair := strings.SplitN(arg, "=", 2)
-		calls[len(calls)-1].Vars[pair[0]] = taskfile.Var{Static: pair[1]}
-	}
-	return calls, nil
-}

internal/args/args_test.go

@@ -1,70 +0,0 @@
-package args_test
-
-import (
-	"fmt"
-	"testing"
-
-	"github.com/go-task/task/v2/internal/args"
-	"github.com/go-task/task/v2/internal/taskfile"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestArgs(t *testing.T) {
-	tests := []struct {
-		Args     []string
-		Expected []taskfile.Call
-		Err      error
-	}{
-		{
-			Args: []string{"task-a", "task-b", "task-c"},
-			Expected: []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"},
-			Expected: []taskfile.Call{
-				{
-					Task: "task-a",
-					Vars: taskfile.Vars{
-						"FOO": taskfile.Var{Static: "bar"},
-					},
-				},
-				{Task: "task-b"},
-				{
-					Task: "task-c",
-					Vars: taskfile.Vars{
-						"BAR": taskfile.Var{Static: "baz"},
-						"BAZ": taskfile.Var{Static: "foo"},
-					},
-				},
-			},
-		},
-		{
-			Args: []string{"task-a", "CONTENT=with some spaces"},
-			Expected: []taskfile.Call{
-				{
-					Task: "task-a",
-					Vars: taskfile.Vars{
-						"CONTENT": taskfile.Var{Static: "with some spaces"},
-					},
-				},
-			},
-		},
-		{
-			Args: []string{"FOO=bar", "task-a"},
-			Err:  args.ErrVariableWithoutTask,
-		},
-	}
-
-	for i, test := range tests {
-		t.Run(fmt.Sprintf("TestArgs%d", i+1), func(t *testing.T) {
-			calls, err := args.Parse(test.Args...)
-			assert.Equal(t, test.Err, err)
-			assert.Equal(t, test.Expected, calls)
-		})
-	}
-}

internal/compiler/compiler.go

@@ -1,12 +0,0 @@
-package compiler
-
-import (
-	"github.com/go-task/task/v2/internal/taskfile"
-)
-
-// Compiler handles compilation of a task before its execution.
-// E.g. variable merger, template processing, etc.
-type Compiler interface {
-	GetVariables(t *taskfile.Task, call taskfile.Call) (taskfile.Vars, error)
-	HandleDynamicVar(v taskfile.Var) (string, error)
-}

internal/compiler/env.go

@@ -1,24 +0,0 @@
-package compiler
-
-import (
-	"os"
-	"strings"
-
-	"github.com/go-task/task/v2/internal/taskfile"
-)
-
-// GetEnviron the all return all environment variables encapsulated on a
-// taskfile.Vars
-func GetEnviron() taskfile.Vars {
-	var (
-		env = os.Environ()
-		m   = make(taskfile.Vars, len(env))
-	)
-
-	for _, e := range env {
-		keyVal := strings.SplitN(e, "=", 2)
-		key, val := keyVal[0], keyVal[1]
-		m[key] = taskfile.Var{Static: val}
-	}
-	return m
-}

internal/compiler/v1/compiler_v1.go

@@ -1,137 +0,0 @@
-package v1
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-	"strings"
-	"sync"
-
-	"github.com/go-task/task/v2/internal/compiler"
-	"github.com/go-task/task/v2/internal/execext"
-	"github.com/go-task/task/v2/internal/logger"
-	"github.com/go-task/task/v2/internal/taskfile"
-	"github.com/go-task/task/v2/internal/templater"
-)
-
-var _ compiler.Compiler = &CompilerV1{}
-
-type CompilerV1 struct {
-	Dir  string
-	Vars taskfile.Vars
-
-	Logger *logger.Logger
-
-	dynamicCache   map[string]string
-	muDynamicCache sync.Mutex
-}
-
-// GetVariables returns fully resolved variables following the priority order:
-// 1. Call variables (should already have been resolved)
-// 2. Environment (should not need to be resolved)
-// 3. Task variables, resolved with access to:
-//    - call, taskvars and environment variables
-// 4. Taskvars variables, resolved with access to:
-//    - environment variables
-func (c *CompilerV1) GetVariables(t *taskfile.Task, call taskfile.Call) (taskfile.Vars, error) {
-	merge := func(dest taskfile.Vars, srcs ...taskfile.Vars) {
-		for _, src := range srcs {
-			for k, v := range src {
-				dest[k] = v
-			}
-		}
-	}
-	varsKeys := func(srcs ...taskfile.Vars) []string {
-		m := make(map[string]struct{})
-		for _, src := range srcs {
-			for k := range src {
-				m[k] = struct{}{}
-			}
-		}
-		lst := make([]string, 0, len(m))
-		for k := range m {
-			lst = append(lst, k)
-		}
-		return lst
-	}
-	replaceVars := func(dest taskfile.Vars, keys []string) error {
-		r := templater.Templater{Vars: dest}
-		for _, k := range keys {
-			v := dest[k]
-			dest[k] = taskfile.Var{
-				Static: r.Replace(v.Static),
-				Sh:     r.Replace(v.Sh),
-			}
-		}
-		return r.Err()
-	}
-	resolveShell := func(dest taskfile.Vars, keys []string) error {
-		for _, k := range keys {
-			v := dest[k]
-			static, err := c.HandleDynamicVar(v)
-			if err != nil {
-				return err
-			}
-			dest[k] = taskfile.Var{Static: static}
-		}
-		return nil
-	}
-	update := func(dest taskfile.Vars, srcs ...taskfile.Vars) error {
-		merge(dest, srcs...)
-		// updatedKeys ensures template evaluation is run only once.
-		updatedKeys := varsKeys(srcs...)
-		if err := replaceVars(dest, updatedKeys); err != nil {
-			return err
-		}
-		return resolveShell(dest, updatedKeys)
-	}
-
-	// Resolve taskvars variables to "result" with environment override variables.
-	override := compiler.GetEnviron()
-	result := make(taskfile.Vars, len(c.Vars)+len(t.Vars)+len(override))
-	if err := update(result, c.Vars, override); err != nil {
-		return nil, err
-	}
-	// Resolve task variables to "result" with environment and call override variables.
-	merge(override, call.Vars)
-	if err := update(result, t.Vars, override); err != nil {
-		return nil, err
-	}
-	return result, nil
-}
-
-func (c *CompilerV1) HandleDynamicVar(v taskfile.Var) (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,
-		Dir:     c.Dir,
-		Stdout:  &stdout,
-		Stderr:  c.Logger.Stderr,
-	}
-	if err := execext.RunCommand(context.Background(), opts); err != nil {
-		return "", fmt.Errorf(`task: Command "%s" in taskvars file 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(`task: dynamic variable: '%s' result: '%s'`, v.Sh, result)
-
-	return result, nil
-}

internal/compiler/v2/compiler_v2.go

@@ -1,109 +0,0 @@
-package v2
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-	"strings"
-	"sync"
-
-	"github.com/go-task/task/v2/internal/compiler"
-	"github.com/go-task/task/v2/internal/execext"
-	"github.com/go-task/task/v2/internal/logger"
-	"github.com/go-task/task/v2/internal/taskfile"
-	"github.com/go-task/task/v2/internal/templater"
-)
-
-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
-}
-
-// 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()}
-	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}
-	for k, v := range vars {
-		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
-		}
-		vr.vars[k] = taskfile.Var{Static: static}
-	}
-	vr.err = tr.Err()
-}
-
-func (c *CompilerV2) HandleDynamicVar(v taskfile.Var) (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,
-		Dir:     c.Dir,
-		Stdout:  &stdout,
-		Stderr:  c.Logger.Stderr,
-	}
-	if err := execext.RunCommand(context.Background(), opts); err != nil {
-		return "", fmt.Errorf(`task: Command "%s" in taskvars file 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(`task: dynamic variable: '%s' result: '%s'`, v.Sh, result)
-
-	return result, nil
-}

internal/deepcopy/deepcopy.go

@@ -0,0 +1,167 @@
+package deepcopy
+
+import (
+	"reflect"
+
+	"github.com/elliotchance/orderedmap/v3"
+)
+
+type Copier[T any] interface {
+	DeepCopy() T
+}
+
+func Scalar[T any](orig *T) *T {
+	if orig == nil {
+		return nil
+	} else {
+		v := *orig
+		return &v
+	}
+}
+
+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
+}
+
+func OrderedMap[K comparable, V any](orig *orderedmap.OrderedMap[K, V]) *orderedmap.OrderedMap[K, V] {
+	if orig.Len() == 0 {
+		return orderedmap.NewOrderedMap[K, V]()
+	}
+	c := orderedmap.NewOrderedMap[K, V]()
+	for pair := orig.Front(); pair != nil; pair = pair.Next() {
+		if copyable, ok := any(pair.Value).(Copier[V]); ok {
+			c.Set(pair.Key, copyable.DeepCopy())
+		} else {
+			c.Set(pair.Key, pair.Value)
+		}
+	}
+	return c
+}
+
+// TraverseStringsFunc runs the given function on every string in the given
+// value by traversing it recursively. If the given value is a string, the
+// function will run on a copy of the string and return it. If the value is a
+// 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.Pointer:
+			// 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,86 @@
+package editors
+
+import (
+	"github.com/go-task/task/v3/taskfile/ast"
+)
+
+type (
+	// Namespace wraps task list output for use in editor integrations (e.g. VSCode, etc)
+	Namespace struct {
+		Tasks      []Task                `json:"tasks"`
+		Namespaces map[string]*Namespace `json:"namespaces,omitempty"`
+		Location   string                `json:"location,omitempty"`
+	}
+	// Task describes a single task
+	Task struct {
+		Name     string    `json:"name"`
+		Task     string    `json:"task"`
+		Desc     string    `json:"desc"`
+		Summary  string    `json:"summary"`
+		Aliases  []string  `json:"aliases"`
+		UpToDate *bool     `json:"up_to_date,omitempty"`
+		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"`
+	}
+)
+
+func NewTask(task *ast.Task) Task {
+	aliases := []string{}
+	if len(task.Aliases) > 0 {
+		aliases = task.Aliases
+	}
+	return Task{
+		Name:    task.Name(),
+		Task:    task.Task,
+		Desc:    task.Desc,
+		Summary: task.Summary,
+		Aliases: aliases,
+		Location: &Location{
+			Line:     task.Location.Line,
+			Column:   task.Location.Column,
+			Taskfile: task.Location.Taskfile,
+		},
+	}
+}
+
+func (parent *Namespace) AddNamespace(namespacePath []string, task Task) {
+	if len(namespacePath) == 0 {
+		return
+	}
+
+	// If there are no child namespaces, then we have found a task and we can
+	// simply add it to the current namespace
+	if len(namespacePath) == 1 {
+		parent.Tasks = append(parent.Tasks, task)
+		return
+	}
+
+	// Get the key of the current namespace in the path
+	namespaceKey := namespacePath[0]
+
+	// Add the namespace to the parent namespaces map using the namespace key
+	if parent.Namespaces == nil {
+		parent.Namespaces = make(map[string]*Namespace, 0)
+	}
+
+	// Search for the current namespace in the parent namespaces map
+	// If it doesn't exist, create it
+	namespace, ok := parent.Namespaces[namespaceKey]
+	if !ok {
+		namespace = &Namespace{}
+		parent.Namespaces[namespaceKey] = namespace
+	}
+
+	// Remove the current namespace key from the namespace path.
+	childNamespacePath := namespacePath[1:]
+
+	// If there are no child namespaces in the task name, then we have found the
+	// namespace of the task and we can add it to the current namespace.
+	// Otherwise, we need to go deeper
+	namespace.AddNamespace(childNamespacePath, task)
+}

internal/env/env.go

@@ -0,0 +1,125 @@
+package env
+
+import (
+	"fmt"
+	"os"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/go-task/task/v3/experiments"
+	"github.com/go-task/task/v3/taskfile/ast"
+)
+
+const taskVarPrefix = "TASK_"
+
+// GetEnviron the all return all environment variables encapsulated on a
+// ast.Vars
+func GetEnviron() *ast.Vars {
+	m := ast.NewVars()
+	for _, e := range os.Environ() {
+		keyVal := strings.SplitN(e, "=", 2)
+		key, val := keyVal[0], keyVal[1]
+		m.Set(key, ast.Var{Value: val})
+	}
+	return m
+}
+
+func Get(t *ast.Task) []string {
+	if t.Env == nil {
+		return nil
+	}
+
+	return GetFromVars(t.Env)
+}
+
+func GetFromVars(env *ast.Vars) []string {
+	environ := os.Environ()
+
+	for k, v := range 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
+	}
+}
+
+func GetTaskEnv(key string) string {
+	return os.Getenv(taskVarPrefix + key)
+}
+
+// GetTaskEnvBool returns the boolean value of a TASK_ prefixed env var.
+// Returns the value and true if set and valid, or false and false if not set or invalid.
+func GetTaskEnvBool(key string) (bool, bool) {
+	v := GetTaskEnv(key)
+	if v == "" {
+		return false, false
+	}
+	b, err := strconv.ParseBool(v)
+	return b, err == nil
+}
+
+// GetTaskEnvInt returns the integer value of a TASK_ prefixed env var.
+// Returns the value and true if set and valid, or 0 and false if not set or invalid.
+func GetTaskEnvInt(key string) (int, bool) {
+	v := GetTaskEnv(key)
+	if v == "" {
+		return 0, false
+	}
+	i, err := strconv.Atoi(v)
+	return i, err == nil
+}
+
+// GetTaskEnvDuration returns the duration value of a TASK_ prefixed env var.
+// Returns the value and true if set and valid, or 0 and false if not set or invalid.
+func GetTaskEnvDuration(key string) (time.Duration, bool) {
+	v := GetTaskEnv(key)
+	if v == "" {
+		return 0, false
+	}
+	d, err := time.ParseDuration(v)
+	return d, err == nil
+}
+
+// GetTaskEnvString returns the string value of a TASK_ prefixed env var.
+// Returns the value and true if set (non-empty), or empty string and false if not set.
+func GetTaskEnvString(key string) (string, bool) {
+	v := GetTaskEnv(key)
+	return v, v != ""
+}
+
+// GetTaskEnvStringSlice returns a comma-separated list from a TASK_ prefixed env var.
+// Returns the slice and true if set (non-empty), or nil and false if not set.
+func GetTaskEnvStringSlice(key string) ([]string, bool) {
+	v := GetTaskEnv(key)
+	if v == "" {
+		return nil, false
+	}
+	parts := strings.Split(v, ",")
+	result := make([]string, 0, len(parts))
+	for _, p := range parts {
+		if trimmed := strings.TrimSpace(p); trimmed != "" {
+			result = append(result, trimmed)
+		}
+	}
+	if len(result) == 0 {
+		return nil, false
+	}
+	return result, true
+}

internal/execext/coreutils.go

@@ -0,0 +1,20 @@
+package execext
+
+import (
+	"runtime"
+	"strconv"
+
+	"github.com/go-task/task/v3/internal/env"
+)
+
+var useGoCoreUtils bool
+
+func init() {
+	// If TASK_CORE_UTILS is set to either true or false, respect that.
+	// By default, enable on Windows only.
+	if v, err := strconv.ParseBool(env.GetTaskEnv("CORE_UTILS")); err == nil {
+		useGoCoreUtils = v
+	} else {
+		useGoCoreUtils = runtime.GOOS == "windows"
+	}
+}

internal/execext/devnull.go

@@ -0,0 +1,13 @@
+package execext
+
+import (
+	"io"
+)
+
+var _ io.ReadWriteCloser = devNull{}
+
+type devNull struct{}
+
+func (devNull) Read(p []byte) (int, error)  { return 0, io.EOF }
+func (devNull) Write(p []byte) (int, error) { return len(p), nil }
+func (devNull) Close() error                { return nil }

internal/execext/exec.go

@@ -2,41 +2,53 @@ package execext
 
 import (
 	"context"
-	"errors"
+	"fmt"
 	"io"
 	"os"
+	"path/filepath"
 	"strings"
 
-	"mvdan.cc/sh/expand"
-	"mvdan.cc/sh/interp"
-	"mvdan.cc/sh/shell"
-	"mvdan.cc/sh/syntax"
+	"mvdan.cc/sh/moreinterp/coreutils"
+	"mvdan.cc/sh/v3/expand"
+	"mvdan.cc/sh/v3/interp"
+	"mvdan.cc/sh/v3/syntax"
+
+	"github.com/go-task/task/v3/errors"
 )
 
-// RunCommandOptions is the options for the RunCommand func
+// ErrNilOptions is returned when a nil options is given
+var ErrNilOptions = errors.New("execext: nil options given")
+
+// 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")
-)
-
 // RunCommand runs a shell command
 func RunCommand(ctx context.Context, opts *RunCommandOptions) error {
 	if opts == nil {
 		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
@@ -45,39 +57,122 @@ func RunCommand(ctx context.Context, opts *RunCommandOptions) error {
 	}
 
 	r, err := interp.New(
-		interp.Dir(opts.Dir),
+		interp.Params(params...),
 		interp.Env(expand.ListEnviron(environ...)),
-
-		interp.Module(interp.DefaultExec),
-		interp.Module(interp.OpenDevImpls(interp.DefaultOpen)),
-
+		interp.ExecHandlers(execHandlers()...),
+		interp.OpenHandler(openHandler),
 		interp.StdIO(opts.Stdin, opts.Stdout, opts.Stderr),
+		dirOption(opts.Dir),
 	)
 	if err != nil {
 		return err
 	}
+
+	parser := syntax.NewParser()
+
+	// Run any shopt commands
+	if len(opts.BashOpts) > 0 {
+		shoptCmdStr := fmt.Sprintf("shopt -s %s", strings.Join(opts.BashOpts, " "))
+		shoptCmd, err := parser.Parse(strings.NewReader(shoptCmdStr), "")
+		if err != nil {
+			return err
+		}
+		if err := r.Run(ctx, shoptCmd); err != nil {
+			return err
+		}
+	}
+
+	// Run the user-defined command
+	p, err := parser.Parse(strings.NewReader(opts.Command), "")
+	if err != nil {
+		return err
+	}
 	return r.Run(ctx, p)
 }
 
-// IsExitError returns true the given error is an exis status error
-func IsExitError(err error) bool {
-	switch err.(type) {
-	case interp.ExitStatus, interp.ShellExitStatus:
-		return true
-	default:
-		return false
-	}
+func escape(s string) string {
+	s = filepath.ToSlash(s)
+	s = strings.ReplaceAll(s, " ", `\ `)
+	s = strings.ReplaceAll(s, "&", `\&`)
+	s = strings.ReplaceAll(s, "(", `\(`)
+	s = strings.ReplaceAll(s, ")", `\)`)
+	return s
 }
 
-// Expand is a helper to mvdan.cc/shell.Fields that returns the first field
-// if available.
-func Expand(s string) (string, error) {
-	fields, err := shell.Fields(s, nil)
+// ExpandLiteral is a wrapper around [expand.Literal]. It will escape the input
+// string, expand any shell symbols (such as '~') and resolve any environment
+// variables.
+func ExpandLiteral(s string) (string, error) {
+	if s == "" {
+		return "", nil
+	}
+	p := syntax.NewParser()
+	word, err := p.Document(strings.NewReader(s))
 	if err != nil {
 		return "", err
 	}
-	if len(fields) > 0 {
-		return fields[0], nil
+	cfg := &expand.Config{
+		Env:      expand.FuncEnviron(os.Getenv),
+		ReadDir2: os.ReadDir,
+		GlobStar: true,
+	}
+	return expand.Literal(cfg, word)
+}
+
+// ExpandFields is a wrapper around [expand.Fields]. It will escape the input
+// string, expand any shell symbols (such as '~') and resolve any environment
+// variables. It also expands brace expressions ({a.b}) and globs (*/**) and
+// returns the results as a list of strings.
+func ExpandFields(s string) ([]string, error) {
+	s = escape(s)
+	p := syntax.NewParser()
+	var words []*syntax.Word
+	for w, err := range p.WordsSeq(strings.NewReader(s)) {
+		if err != nil {
+			return nil, err
+		}
+		words = append(words, w)
+	}
+	cfg := &expand.Config{
+		Env:      expand.FuncEnviron(os.Getenv),
+		ReadDir2: os.ReadDir,
+		GlobStar: true,
+		NullGlob: true,
+	}
+	return expand.Fields(cfg, words...)
+}
+
+func execHandlers() (handlers []func(next interp.ExecHandlerFunc) interp.ExecHandlerFunc) {
+	if useGoCoreUtils {
+		handlers = append(handlers, coreutils.ExecHandler)
+	}
+	return handlers
+}
+
+func openHandler(ctx context.Context, path string, flag int, perm os.FileMode) (io.ReadWriteCloser, error) {
+	if path == "/dev/null" {
+		return devNull{}, nil
+	}
+	return interp.DefaultOpenHandler()(ctx, path, flag, perm)
+}
+
+func dirOption(path string) interp.RunnerOption {
+	return func(r *interp.Runner) error {
+		err := interp.Dir(path)(r)
+		if err == nil {
+			return nil
+		}
+
+		// If the specified directory doesn't exist, it will be created later.
+		// Therefore, even if `interp.Dir` method returns an error, the
+		// directory path should be set only when the directory cannot be found.
+		if absPath, _ := filepath.Abs(path); absPath != "" {
+			if _, err := os.Stat(absPath); os.IsNotExist(err) {
+				r.Dir = absPath
+				return nil
+			}
+		}
+
+		return err
 	}
-	return "", nil
 }

internal/filepathext/filepathext.go

@@ -0,0 +1,63 @@
+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
+}
+
+// IsExtOnly checks whether path points to a file with no name but with
+// an extension, i.e. ".yaml"
+func IsExtOnly(path string) bool {
+	return filepath.Base(path) == filepath.Ext(path)
+}

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/checker_mock.go

@@ -0,0 +1,320 @@
+// Code generated by mockery; DO NOT EDIT.
+// github.com/vektra/mockery
+// template: testify
+
+package fingerprint
+
+import (
+	"context"
+
+	"github.com/go-task/task/v3/taskfile/ast"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// NewMockStatusCheckable creates a new instance of MockStatusCheckable. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewMockStatusCheckable(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockStatusCheckable {
+	mock := &MockStatusCheckable{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// MockStatusCheckable is an autogenerated mock type for the StatusCheckable type
+type MockStatusCheckable struct {
+	mock.Mock
+}
+
+type MockStatusCheckable_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MockStatusCheckable) EXPECT() *MockStatusCheckable_Expecter {
+	return &MockStatusCheckable_Expecter{mock: &_m.Mock}
+}
+
+// IsUpToDate provides a mock function for the type MockStatusCheckable
+func (_mock *MockStatusCheckable) IsUpToDate(ctx context.Context, t *ast.Task) (bool, error) {
+	ret := _mock.Called(ctx, t)
+
+	if len(ret) == 0 {
+		panic("no return value specified for IsUpToDate")
+	}
+
+	var r0 bool
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *ast.Task) (bool, error)); ok {
+		return returnFunc(ctx, t)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *ast.Task) bool); ok {
+		r0 = returnFunc(ctx, t)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, *ast.Task) error); ok {
+		r1 = returnFunc(ctx, t)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MockStatusCheckable_IsUpToDate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsUpToDate'
+type MockStatusCheckable_IsUpToDate_Call struct {
+	*mock.Call
+}
+
+// IsUpToDate is a helper method to define mock.On call
+//   - ctx
+//   - t
+func (_e *MockStatusCheckable_Expecter) IsUpToDate(ctx interface{}, t interface{}) *MockStatusCheckable_IsUpToDate_Call {
+	return &MockStatusCheckable_IsUpToDate_Call{Call: _e.mock.On("IsUpToDate", ctx, t)}
+}
+
+func (_c *MockStatusCheckable_IsUpToDate_Call) Run(run func(ctx context.Context, t *ast.Task)) *MockStatusCheckable_IsUpToDate_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(context.Context), args[1].(*ast.Task))
+	})
+	return _c
+}
+
+func (_c *MockStatusCheckable_IsUpToDate_Call) Return(b bool, err error) *MockStatusCheckable_IsUpToDate_Call {
+	_c.Call.Return(b, err)
+	return _c
+}
+
+func (_c *MockStatusCheckable_IsUpToDate_Call) RunAndReturn(run func(ctx context.Context, t *ast.Task) (bool, error)) *MockStatusCheckable_IsUpToDate_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// NewMockSourcesCheckable creates a new instance of MockSourcesCheckable. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewMockSourcesCheckable(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *MockSourcesCheckable {
+	mock := &MockSourcesCheckable{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
+
+// MockSourcesCheckable is an autogenerated mock type for the SourcesCheckable type
+type MockSourcesCheckable struct {
+	mock.Mock
+}
+
+type MockSourcesCheckable_Expecter struct {
+	mock *mock.Mock
+}
+
+func (_m *MockSourcesCheckable) EXPECT() *MockSourcesCheckable_Expecter {
+	return &MockSourcesCheckable_Expecter{mock: &_m.Mock}
+}
+
+// IsUpToDate provides a mock function for the type MockSourcesCheckable
+func (_mock *MockSourcesCheckable) IsUpToDate(t *ast.Task) (bool, error) {
+	ret := _mock.Called(t)
+
+	if len(ret) == 0 {
+		panic("no return value specified for IsUpToDate")
+	}
+
+	var r0 bool
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(*ast.Task) (bool, error)); ok {
+		return returnFunc(t)
+	}
+	if returnFunc, ok := ret.Get(0).(func(*ast.Task) bool); ok {
+		r0 = returnFunc(t)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+	if returnFunc, ok := ret.Get(1).(func(*ast.Task) error); ok {
+		r1 = returnFunc(t)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MockSourcesCheckable_IsUpToDate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsUpToDate'
+type MockSourcesCheckable_IsUpToDate_Call struct {
+	*mock.Call
+}
+
+// IsUpToDate is a helper method to define mock.On call
+//   - t
+func (_e *MockSourcesCheckable_Expecter) IsUpToDate(t interface{}) *MockSourcesCheckable_IsUpToDate_Call {
+	return &MockSourcesCheckable_IsUpToDate_Call{Call: _e.mock.On("IsUpToDate", t)}
+}
+
+func (_c *MockSourcesCheckable_IsUpToDate_Call) Run(run func(t *ast.Task)) *MockSourcesCheckable_IsUpToDate_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(*ast.Task))
+	})
+	return _c
+}
+
+func (_c *MockSourcesCheckable_IsUpToDate_Call) Return(b bool, err error) *MockSourcesCheckable_IsUpToDate_Call {
+	_c.Call.Return(b, err)
+	return _c
+}
+
+func (_c *MockSourcesCheckable_IsUpToDate_Call) RunAndReturn(run func(t *ast.Task) (bool, error)) *MockSourcesCheckable_IsUpToDate_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Kind provides a mock function for the type MockSourcesCheckable
+func (_mock *MockSourcesCheckable) Kind() string {
+	ret := _mock.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Kind")
+	}
+
+	var r0 string
+	if returnFunc, ok := ret.Get(0).(func() string); ok {
+		r0 = returnFunc()
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+	return r0
+}
+
+// MockSourcesCheckable_Kind_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Kind'
+type MockSourcesCheckable_Kind_Call struct {
+	*mock.Call
+}
+
+// Kind is a helper method to define mock.On call
+func (_e *MockSourcesCheckable_Expecter) Kind() *MockSourcesCheckable_Kind_Call {
+	return &MockSourcesCheckable_Kind_Call{Call: _e.mock.On("Kind")}
+}
+
+func (_c *MockSourcesCheckable_Kind_Call) Run(run func()) *MockSourcesCheckable_Kind_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run()
+	})
+	return _c
+}
+
+func (_c *MockSourcesCheckable_Kind_Call) Return(s string) *MockSourcesCheckable_Kind_Call {
+	_c.Call.Return(s)
+	return _c
+}
+
+func (_c *MockSourcesCheckable_Kind_Call) RunAndReturn(run func() string) *MockSourcesCheckable_Kind_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// OnError provides a mock function for the type MockSourcesCheckable
+func (_mock *MockSourcesCheckable) OnError(t *ast.Task) error {
+	ret := _mock.Called(t)
+
+	if len(ret) == 0 {
+		panic("no return value specified for OnError")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(*ast.Task) error); ok {
+		r0 = returnFunc(t)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// MockSourcesCheckable_OnError_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OnError'
+type MockSourcesCheckable_OnError_Call struct {
+	*mock.Call
+}
+
+// OnError is a helper method to define mock.On call
+//   - t
+func (_e *MockSourcesCheckable_Expecter) OnError(t interface{}) *MockSourcesCheckable_OnError_Call {
+	return &MockSourcesCheckable_OnError_Call{Call: _e.mock.On("OnError", t)}
+}
+
+func (_c *MockSourcesCheckable_OnError_Call) Run(run func(t *ast.Task)) *MockSourcesCheckable_OnError_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(*ast.Task))
+	})
+	return _c
+}
+
+func (_c *MockSourcesCheckable_OnError_Call) Return(err error) *MockSourcesCheckable_OnError_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *MockSourcesCheckable_OnError_Call) RunAndReturn(run func(t *ast.Task) error) *MockSourcesCheckable_OnError_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// Value provides a mock function for the type MockSourcesCheckable
+func (_mock *MockSourcesCheckable) Value(t *ast.Task) (any, error) {
+	ret := _mock.Called(t)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Value")
+	}
+
+	var r0 any
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(*ast.Task) (any, error)); ok {
+		return returnFunc(t)
+	}
+	if returnFunc, ok := ret.Get(0).(func(*ast.Task) any); ok {
+		r0 = returnFunc(t)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(any)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(*ast.Task) error); ok {
+		r1 = returnFunc(t)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// MockSourcesCheckable_Value_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Value'
+type MockSourcesCheckable_Value_Call struct {
+	*mock.Call
+}
+
+// Value is a helper method to define mock.On call
+//   - t
+func (_e *MockSourcesCheckable_Expecter) Value(t interface{}) *MockSourcesCheckable_Value_Call {
+	return &MockSourcesCheckable_Value_Call{Call: _e.mock.On("Value", t)}
+}
+
+func (_c *MockSourcesCheckable_Value_Call) Run(run func(t *ast.Task)) *MockSourcesCheckable_Value_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		run(args[0].(*ast.Task))
+	})
+	return _c
+}
+
+func (_c *MockSourcesCheckable_Value_Call) Return(v any, err error) *MockSourcesCheckable_Value_Call {
+	_c.Call.Return(v, err)
+	return _c
+}
+
+func (_c *MockSourcesCheckable_Value_Call) RunAndReturn(run func(t *ast.Task) (any, error)) *MockSourcesCheckable_Value_Call {
+	_c.Call.Return(run)
+	return _c
+}

internal/fingerprint/glob.go

@@ -0,0 +1,60 @@
+package fingerprint
+
+import (
+	"os"
+	"path/filepath"
+	"sort"
+
+	"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 []*ast.Glob) ([]string, error) {
+	resultMap := make(map[string]bool)
+	for _, g := range globs {
+		matches, err := glob(dir, g.Glob)
+		if err != nil {
+			continue
+		}
+		for _, match := range matches {
+			resultMap[match] = !g.Negate
+		}
+	}
+	return collectKeys(resultMap), nil
+}
+
+func glob(dir string, g string) ([]string, error) {
+	g = filepathext.SmartJoin(dir, g)
+
+	fs, err := execext.ExpandFields(g)
+	if err != nil {
+		return nil, err
+	}
+
+	results := make(map[string]bool, len(fs))
+
+	for _, f := range fs {
+		info, err := os.Stat(f)
+		if err != nil {
+			return nil, err
+		}
+		if info.IsDir() {
+			continue
+		}
+		results[f] = true
+	}
+	return collectKeys(results), nil
+}
+
+func collectKeys(m map[string]bool) []string {
+	keys := make([]string, 0, len(m))
+	for k, v := range m {
+		if v {
+			// Normalize path separators for consistent sorting across platforms
+			keys = append(keys, filepath.ToSlash(k))
+		}
+	}
+	sort.Strings(keys)
+	return keys
+}

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,127 @@
+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 {
+			// Exclusion patterns don't represent output files; skip them.
+			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"
@@ -7,6 +7,8 @@ import (
 )
 
 func TestNormalizeFilename(t *testing.T) {
+	t.Parallel()
+
 	tests := []struct {
 		In, Out string
 	}{
@@ -16,6 +18,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"
+}