v3.19.1

Co-authored-by: Andrey Nering <andrey@nering.com.br>

.github/FUNDING.yml

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

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

@@ -10,6 +10,7 @@ jobs:
     steps:
       - uses: actions/github-script@v6
         with:
+          github-token: ${{secrets.GH_PAT}}
           script: |
             const issue = await github.rest.issues.get({
               owner: context.repo.owner,

.github/workflows/issue-closed.yml

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

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

@@ -5,11 +5,12 @@ on:
     types: [opened]
 
 jobs:
-  needs-triage:
+  issue-needs-triage:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/github-script@v6
         with:
+          github-token: ${{secrets.GH_PAT}}
           script: |
             const labels = await github.paginate(
               github.rest.issues.listLabelsOnIssue, {

.golangci.yml

@@ -0,0 +1,12 @@
+# NOTE(@andreynering): The linters listed here are additions on top of
+# those enabled by default:
+#
+# https://golangci-lint.run/usage/linters/#enabled-by-default
+
+linters:
+  enable:
+    - goimports
+
+linters-settings:
+  goimports:
+    local-prefixes: github.com/go-task/task

.nvmrc

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

CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## v3.19.1 - 2022-12-31
+
+- Small bug fix: closing `Taskfile.yml` once we're done reading it
+  ([#963](https://github.com/go-task/task/issues/963), [#964](https://github.com/go-task/task/pull/964) by @HeCorr).
+- Fixes a bug in v2 that caused a panic when using a `Taskfile_{{OS}}.yml` file
+  ([#961](https://github.com/go-task/task/issues/961), [#971](https://github.com/go-task/task/pull/971) by @pd93).
+- Fixed a bug where watch intervals set in the Taskfile were not being respected ([#969](https://github.com/go-task/task/pull/969), [#970](https://github.com/go-task/task/pull/970) by @pd93)
+- Add `--json` flag (alias `-j`) with the intent to improve support for code
+  editors and add room to other possible integrations. This is basic for now,
+  but we plan to add more info in the near future
+  ([#936](https://github.com/go-task/task/pull/936) by @davidalpert, [#764](https://github.com/go-task/task/issues/764)).
+
 ## v3.19.0 - 2022-12-05
 
 - Installation via npm now supports [pnpm](https://pnpm.io/) as well

Taskfile.yml

@@ -47,6 +47,7 @@ tasks:
     aliases: [l]
     sources:
       - './**/*.go'
+      - .golangci.yml
     cmds:
       - golangci-lint run
 
@@ -73,11 +74,11 @@ tasks:
     cmds:
       - go test {{catLines .GO_PACKAGES}}
 
-  test:signals:
-    desc: Runs test suite with signals tests included
+  test:all:
+    desc: Runs test suite with signals and watch tests included
     deps: [install, sleepit:build]
     cmds:
-      - go test {{catLines .GO_PACKAGES}} -tags signals
+      - go test {{catLines .GO_PACKAGES}} -tags 'signals watch'
 
   test-release:
     desc: Tests release process without publishing
@@ -92,7 +93,7 @@ tasks:
       - rm {{.FILE}}
       - 'echo "---" >> {{.FILE}}'
       - 'echo "slug: /changelog/" >> {{.FILE}}'
-      - 'echo "sidebar_position: 6" >> {{.FILE}}'
+      - 'echo "sidebar_position: 7" >> {{.FILE}}'
       - 'echo "---" >> {{.FILE}}'
       - 'echo "" >> {{.FILE}}'
       - 'cat CHANGELOG.md >> {{.FILE}}'

cmd/sleepit/sleepit.go

@@ -130,11 +130,11 @@ func supervisor(
 // The goroutine will prepend its prints with the prefix `name`.
 // The goroutine will simulate some work and will terminate when one of the following
 // conditions happens:
-// 1. When `howlong` is elapsed. This case will be signaled on the `workerDone` channel.
-// 2. When something happens on channel `canceled`. Note that this simulates real-life,
-//    so cancellation is not instantaneous: if the caller wants a synchronous cancel,
-//    it should send a message; if instead it wants an asynchronous cancel, it should
-//    close the channel.
+//  1. When `howlong` is elapsed. This case will be signaled on the `workerDone` channel.
+//  2. When something happens on channel `canceled`. Note that this simulates real-life,
+//     so cancellation is not instantaneous: if the caller wants a synchronous cancel,
+//     it should send a message; if instead it wants an asynchronous cancel, it should
+//     close the channel.
 func worker(
 	canceled <-chan struct{},
 	howlong time.Duration,

cmd/task/task.go

@@ -8,6 +8,7 @@ import (
 	"path/filepath"
 	"runtime/debug"
 	"strings"
+	"time"
 
 	"github.com/spf13/pflag"
 	"mvdan.cc/sh/v3/syntax"
@@ -59,6 +60,7 @@ func main() {
 		init        bool
 		list        bool
 		listAll     bool
+		listJson    bool
 		status      bool
 		force       bool
 		watch       bool
@@ -73,7 +75,7 @@ func main() {
 		entrypoint  string
 		output      taskfile.Output
 		color       bool
-		interval    string
+		interval    time.Duration
 	)
 
 	pflag.BoolVar(&versionFlag, "version", false, "show Task version")
@@ -81,6 +83,7 @@ func main() {
 	pflag.BoolVarP(&init, "init", "i", false, "creates a new Taskfile.yaml in the current folder")
 	pflag.BoolVarP(&list, "list", "l", false, "lists tasks with description of current Taskfile")
 	pflag.BoolVarP(&listAll, "list-all", "a", false, "lists tasks with or without a description")
+	pflag.BoolVarP(&listJson, "json", "j", false, "formats task list as json")
 	pflag.BoolVar(&status, "status", false, "exits with non-zero exit code if any of the given tasks is not up-to-date")
 	pflag.BoolVarP(&force, "force", "f", false, "forces execution even when the task is up-to-date")
 	pflag.BoolVarP(&watch, "watch", "w", false, "enables watch of the given task")
@@ -97,7 +100,7 @@ func main() {
 	pflag.StringVar(&output.Group.End, "output-group-end", "", "message template to print after a task's grouped output")
 	pflag.BoolVarP(&color, "color", "c", true, "colored output. Enabled by default. Set flag to false or use NO_COLOR=1 to disable")
 	pflag.IntVarP(&concurrency, "concurrency", "C", 0, "limit number tasks to run concurrently")
-	pflag.StringVarP(&interval, "interval", "I", "5s", "interval to watch for changes")
+	pflag.DurationVarP(&interval, "interval", "I", 0, "interval to watch for changes")
 	pflag.Parse()
 
 	if versionFlag {
@@ -162,7 +165,12 @@ func main() {
 		OutputStyle: output,
 	}
 
-	if (list || listAll) && silent {
+	var listOptions = task.NewListOptions(list, listAll, listJson)
+	if err := listOptions.Validate(); err != nil {
+		log.Fatal(err)
+	}
+
+	if (listOptions.ShouldListTasks()) && silent {
 		e.ListTaskNames(listAll)
 		return
 	}
@@ -176,16 +184,9 @@ func main() {
 		return
 	}
 
-	if list {
-		if ok := e.ListTasks(task.FilterOutInternal(), task.FilterOutNoDesc()); !ok {
-			e.Logger.Outf(logger.Yellow, "task: No tasks with description available. Try --list-all to list all tasks")
-		}
-		return
-	}
-
-	if listAll {
-		if ok := e.ListTasks(task.FilterOutInternal()); !ok {
-			e.Logger.Outf(logger.Yellow, "task: No tasks available")
+	if listOptions.ShouldListTasks() {
+		if foundTasks, err := e.ListTasks(listOptions); !foundTasks || err != nil {
+			os.Exit(1)
 		}
 		return
 	}

docs/Taskfile.yml

@@ -35,3 +35,8 @@ tasks:
     summary: Requires GIT_USER and GIT_PASS envs to be previous set
     cmds:
       - npx docusaurus deploy
+
+  upgrade:
+    desc: Upgrade Docusaurus
+    cmds:
+      - yarn upgrade @docusaurus/core@latest @docusaurus/preset-classic@latest

docs/docs/changelog.md

@@ -1,10 +1,22 @@
 ---
 slug: /changelog/
-sidebar_position: 6
+sidebar_position: 7
 ---
 
 # Changelog
 
+## v3.19.1 - 2022-12-31
+
+- Small bug fix: closing `Taskfile.yml` once we're done reading it
+  ([#963](https://github.com/go-task/task/issues/963), [#964](https://github.com/go-task/task/pull/964) by @HeCorr).
+- Fixes a bug in v2 that caused a panic when using a `Taskfile_{{OS}}.yml` file
+  ([#961](https://github.com/go-task/task/issues/961), [#971](https://github.com/go-task/task/pull/971) by @pd93).
+- Fixed a bug where watch intervals set in the Taskfile were not being respected ([#969](https://github.com/go-task/task/pull/969), [#970](https://github.com/go-task/task/pull/970) by @pd93)
+- Add `--json` flag (alias `-j`) with the intent to improve support for code
+  editors and add room to other possible integrations. This is basic for now,
+  but we plan to add more info in the near future
+  ([#936](https://github.com/go-task/task/pull/936) by @davidalpert, [#764](https://github.com/go-task/task/issues/764)).
+
 ## v3.19.0 - 2022-12-05
 
 - Installation via npm now supports [pnpm](https://pnpm.io/) as well

docs/docs/community.md

@@ -1,6 +1,6 @@
 ---
 slug: /community/
-sidebar_position: 6
+sidebar_position: 8
 ---
 
 # Community

docs/docs/contributing.md

@@ -1,6 +1,6 @@
 ---
 slug: /contributing/
-sidebar_position: 7
+sidebar_position: 9
 ---
 
 # Contributing

docs/docs/donate.md

@@ -1,6 +1,6 @@
 ---
 slug: /donate/
-sidebar_position: 10
+sidebar_position: 12
 ---
 
 # Donate
@@ -11,10 +11,23 @@ channels listed below.
 This is just a way of saying "thank you", it won't give you any benefits like
 higher priority on issues or something similar.
 
+Companies who donate at least $100/month will be featured as a "Gold Sponsor"
+in the website homepage and on the GitHub repository README. Make contact with
+[@andreynering] with the logo you want to be shown.
+Suspect businesses (gambling, casinos, etc) won't be allowed, though.
+
+## GitHub Sponsors
+
+The preferred way to donate to the maintainers is via GitHub Sponsors.
+Just use the following links to do your donation:
+
+- [@andreynering](https://github.com/sponsors/andreynering)
+- [@pd93](https://github.com/sponsors/pd93)
+
 ## Open Collective
 
-Task is on [Open Collective](https://opencollective.com/task) and you have
-these options to donate:
+If you prefer [Open Collective](https://opencollective.com/task) you can donate
+by using these links:
 
 - [$2 per month](https://opencollective.com/task/contribute/backer-4034/checkout)
 - [$5 per month](https://opencollective.com/task/contribute/supporter-8404/checkout)
@@ -22,15 +35,15 @@ these options to donate:
 - [$50 per month](https://opencollective.com/task/contribute/sponsor-28775/checkout)
 - [Custom value - One-time donation option supported](https://opencollective.com/task/donate)
 
-## GitHub Sponsors
-
-- [@andreynering](https://github.com/sponsors/andreynering)
-
 ## PayPal
 
+You can donate to [@andreynering] via PayPal as well:
+
 - [Any value - One-time donation](https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=GSVDU63RKG45A&currency_code=USD&source=url)
 
 ## PIX (Brazil only)
 
-If you're Brazilian, you can donate any value by
+And if you're Brazilian, you can also donate to [@andreynering] via PIX by
 [using this QR Code](/img/pix.png).
+
+[@andreynering]: https://github.com/andreynering

docs/docs/faq.md

@@ -0,0 +1,54 @@
+---
+slug: /faq/
+sidebar_position: 5
+---
+
+# FAQ
+
+This page contains a list of frequently asked questions about Task.
+
+- [Why won't my task update my shell environment?](#why-wont-my-task-update-my-shell-environment)
+- ['x' builtin command doesn't work on Windows](#x-builtin-command-doesnt-work-on-windows)
+
+## Why won't my task update my shell environment?
+
+This is a limitation of how shells work. Task runs as a subprocess of your
+current shell, so it can't change the environment of the shell that started it.
+This limitation is shared by other task runners and build tools too.
+
+A common way to work around this is to create a task that will generate output
+that can be parsed by your shell. For example, to set an environment variable on
+your shell you can write a task like this:
+
+```yaml
+my-shell-env:
+  cmds:
+    - echo "export FOO=foo"
+    - echo "export BAR=bar"
+```
+
+Now run `eval $(task my-shell-env)` and the variables `$FOO` and `$BAR` will be
+available in your shell.
+
+## 'x' builtin command doesn't work on Windows
+
+The default shell on Windows (`cmd` and `powershell`) do not have commands like
+`rm` and `cp` available as builtins. This means that these commands won't work.
+If you want to make your Taskfile fully cross-platform, you'll need to work
+around this limitation using one of the following methods:
+
+- Use the `{{OS}}` function to run an OS-specific script.
+- Use something like `{{if eq OS "windows"}}powershell {{end}}<my_cmd>` to
+  detect windows and run the command in Powershell directly.
+- Use a shell on Windows that supports these commands as builtins, such as [Git
+  Bash] or [WSL].
+
+We want to make improvements to this part of Task and the issues below track
+this work. Constructive comments and contributions are very welcome!
+
+- [#197](https://github.com/go-task/task/issues/197)
+- [mvdan/sh#93](https://github.com/mvdan/sh/issues/93)
+- [mvdan/sh#97](https://github.com/mvdan/sh/issues/97)
+
+[Git Bash]: https://gitforwindows.org/
+[WSL]: https://learn.microsoft.com/en-us/windows/wsl/install

docs/docs/installation.md

@@ -18,6 +18,15 @@ Task is as simple as running:
 brew install go-task/tap/go-task
 ```
 
+The above Formula is [maintained by ourselves](https://github.com/go-task/homebrew-tap/blob/master/Formula/go-task.rb).
+
+Recently, Task was also made available [on the official Homebrew repository](https://formulae.brew.sh/formula/go-task),
+so you also have that option if you prefer:
+
+```bash
+brew install go-task
+```
+
 ### Snap
 
 Task is available in [Snapcraft][snapcraft], but keep in mind that your

docs/docs/releasing.md

@@ -1,6 +1,6 @@
 ---
 slug: /releasing/
-sidebar_position: 8
+sidebar_position: 10
 ---
 
 # Releasing

docs/docs/styleguide.md

@@ -1,6 +1,6 @@
 ---
 slug: /styleguide/
-sidebar_position: 5
+sidebar_position: 6
 ---
 
 # Styleguide

docs/docs/taskfile_versions.md

@@ -1,6 +1,6 @@
 ---
 slug: /taskfile-versions/
-sidebar_position: 9
+sidebar_position: 11
 ---
 
 # Taskfile Versions

docs/package.json

@@ -14,8 +14,8 @@
     "write-heading-ids": "docusaurus write-heading-ids"
   },
   "dependencies": {
-    "@docusaurus/core": "2.0.0-beta.20",
-    "@docusaurus/preset-classic": "2.0.0-beta.20",
+    "@docusaurus/core": "^2.2.0",
+    "@docusaurus/preset-classic": "^2.2.0",
     "@mdx-js/react": "^1.6.22",
     "clsx": "^1.1.1",
     "prism-react-renderer": "^1.3.1",

docs/static/schema.json

@@ -370,7 +370,8 @@
         },
         "interval": {
           "description": "Sets a different watch interval when using `--watch`, the default being 5 seconds. This string should be a valid Go duration: https://pkg.go.dev/time#ParseDuration.",
-          "$ref": "#/definitions/3/run"
+          "type": "string",
+          "pattern": "^[0-9]+(?:m|s|ms)$"
         }
       },
       "additionalProperties": false,

go.mod

@@ -11,9 +11,9 @@ require (
 	github.com/spf13/pflag v1.0.5
 	github.com/stretchr/testify v1.8.1
 	golang.org/x/exp v0.0.0-20220930202632-ec3f01382ef9
-	golang.org/x/sync v0.0.0-20210220032951-036812b2e83c
+	golang.org/x/sync v0.1.0
 	gopkg.in/yaml.v3 v3.0.1
-	mvdan.cc/sh/v3 v3.6.0-0.dev.0.20220704111049-a6e3029cd899
+	mvdan.cc/sh/v3 v3.6.0
 )
 
 require (
@@ -21,8 +21,8 @@ require (
 	github.com/mattn/go-colorable v0.1.9 // indirect
 	github.com/mattn/go-isatty v0.0.14 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
-	golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f // indirect
-	golang.org/x/term v0.0.0-20210927222741-03fcf44c2211 // indirect
+	golang.org/x/sys v0.3.0 // indirect
+	golang.org/x/term v0.3.0 // indirect
 	gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 // indirect
 )
 

go.sum

@@ -1,16 +1,16 @@
-github.com/creack/pty v1.1.17 h1:QeVUsEDNrLBW4tMgZHvxy18sKtr6VI492kBhUfhDJNI=
+github.com/creack/pty v1.1.18 h1:n56/Zwd5o6whRC5PMGretI4IdRLlmBXYNjScPaBgsbY=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/fatih/color v1.13.0 h1:8LOYc1KYPPmyKMuN8QV2DNRWNbLo6LZ0iLs8+mlH53w=
 github.com/fatih/color v1.13.0/go.mod h1:kLAiJbzzSOZDVNGyDpeOxJ47H46qBXwg5ILebYFFOfk=
-github.com/frankban/quicktest v1.14.0 h1:+cqqvzZV87b4adx/5ayVOaYZ2CrvM4ejQvUdBzPPUss=
+github.com/frankban/quicktest v1.14.4 h1:g2rn0vABPOOXmZUj+vbmUp0lPoXEMuhTpIluN0XL9UY=
 github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0 h1:p104kn46Q8WdvHunIJ9dAyjPVtrBPhSr3KT2yUst43I=
 github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0/go.mod h1:fyg7847qk6SyHyPtNmDHnmrv/HOrqktSC+C9fM+CJOE=
-github.com/google/go-cmp v0.5.8 h1:e6P7q2lk1O+qJJb4BtCQXlK8vWEO8V1ZeuEdJNOqZyg=
+github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
 github.com/joho/godotenv v1.4.0 h1:3l4+N6zfMWnkbPEXKng2o2/MR5mSwTrBih4ZEkkz1lg=
 github.com/joho/godotenv v1.4.0/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
-github.com/kr/pretty v0.3.0 h1:WgNl7dwNpEZ6jJ9k1snq4pZsg7DOEN8hP9Xw0Tsjwk0=
+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/mattn/go-colorable v0.1.9 h1:sqDoxXbdeALODt0DAeJCVp38ps9ZogZEAXjus69YV3U=
 github.com/mattn/go-colorable v0.1.9/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
@@ -25,7 +25,7 @@ github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZb
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/radovskyb/watcher v1.0.7 h1:AYePLih6dpmS32vlHfhCeli8127LzkIgwJGcwwe8tUE=
 github.com/radovskyb/watcher v1.0.7/go.mod h1:78okwvY5wPdzcb1UYnip1pvrZNIVEIh/Cm+ZuvsUYIg=
-github.com/rogpeppe/go-internal v1.8.1 h1:geMPLpDpQOgVyCg5z5GoRwLHepNdb71NXb67XFkP+Eg=
+github.com/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8=
 github.com/sajari/fuzzy v1.0.0 h1:+FmwVvJErsd0d0hAPlj4CxqxUtQY/fOoY0DwX4ykpRY=
 github.com/sajari/fuzzy v1.0.0/go.mod h1:OjYR6KxoWOe9+dOlXeiCJd4dIbED4Oo8wpS89o0pwOo=
 github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
@@ -40,15 +40,15 @@ github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKs
 github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
 golang.org/x/exp v0.0.0-20220930202632-ec3f01382ef9 h1:RjggHMcaTVp0LOVZcW0bo8alwHrOaCrGUDgfWUHhnN4=
 golang.org/x/exp v0.0.0-20220930202632-ec3f01382ef9/go.mod h1:cyybsKvd6eL0RnXn6p/Grxp8F5bW7iYuBgsNCOHpMYE=
-golang.org/x/sync v0.0.0-20210220032951-036812b2e83c h1:5KslGYwFpkhGh+Q16bwMP3cOontH8FOep7tGV86Y7SQ=
-golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o=
+golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f h1:v4INt8xihDGvnrfjMDVXGxw9wrfxYyCjk0KbXjhR55s=
-golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/term v0.0.0-20210927222741-03fcf44c2211 h1:JGgROgKl9N8DuW20oFS5gxc+lE67/N3FcwmBPMe7ArY=
-golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
+golang.org/x/sys v0.3.0 h1:w8ZOecv6NaNa/zC8944JTU3vz4u6Lagfk4RPQxv92NQ=
+golang.org/x/sys v0.3.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/term v0.3.0 h1:qoo4akIqOcDME5bhc/NgxUdovd6BSS2uMsVjB56q1xI=
+golang.org/x/term v0.3.0/go.mod h1:q750SLmJuPmVoN1blW3UFBPREJfb1KmY3vwxfr+nFDA=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
@@ -56,5 +56,5 @@ gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-mvdan.cc/sh/v3 v3.6.0-0.dev.0.20220704111049-a6e3029cd899 h1:nwm4t5PtLlFd/H342GP50CtYf7vyMCOZkPx3g9shO0c=
-mvdan.cc/sh/v3 v3.6.0-0.dev.0.20220704111049-a6e3029cd899/go.mod h1:1JcoyAKm1lZw/2bZje/iYKWicU/KMd0rsyJeKHnsK4E=
+mvdan.cc/sh/v3 v3.6.0 h1:gtva4EXJ0dFNvl5bHjcUEvws+KRcDslT8VKheTYkbGU=
+mvdan.cc/sh/v3 v3.6.0/go.mod h1:U4mhtBLZ32iWhif5/lD+ygy1zrgaQhUu+XFy7C8+TTA=

help.go

@@ -1,6 +1,8 @@
 package task
 
 import (
+	"context"
+	"encoding/json"
 	"fmt"
 	"io"
 	"log"
@@ -9,16 +11,82 @@ import (
 	"strings"
 	"text/tabwriter"
 
+	"github.com/go-task/task/v3/internal/editors"
 	"github.com/go-task/task/v3/internal/logger"
+	"github.com/go-task/task/v3/taskfile"
 )
 
+// ListOptions collects list-related options
+type ListOptions struct {
+	ListOnlyTasksWithDescriptions bool
+	ListAllTasks                  bool
+	FormatTaskListAsJSON          bool
+}
+
+// NewListOptions creates a new ListOptions instance
+func NewListOptions(list, listAll, listAsJson bool) ListOptions {
+	return ListOptions{
+		ListOnlyTasksWithDescriptions: list,
+		ListAllTasks:                  listAll,
+		FormatTaskListAsJSON:          listAsJson,
+	}
+}
+
+// ShouldListTasks returns true if one of the options to list tasks has been set to true
+func (o ListOptions) ShouldListTasks() bool {
+	return o.ListOnlyTasksWithDescriptions || o.ListAllTasks
+}
+
+// Validate validates that the collection of list-related options are in a valid configuration
+func (o ListOptions) Validate() error {
+	if o.ListOnlyTasksWithDescriptions && o.ListAllTasks {
+		return fmt.Errorf("task: cannot use --list and --list-all at the same time")
+	}
+	if o.FormatTaskListAsJSON && !o.ShouldListTasks() {
+		return fmt.Errorf("task: --json only applies to --list or --list-all")
+	}
+	return nil
+}
+
+// Filters returns the slice of FilterFunc which filters a list
+// of taskfile.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 or not tasks were found.
-func (e *Executor) ListTasks(filters ...FilterFunc) bool {
-	tasks := e.GetTaskList(filters...)
+// 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 := e.GetTaskList(o.Filters()...)
+	if o.FormatTaskListAsJSON {
+		output, err := e.ToEditorOutput(tasks)
+		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 {
-		return false
+		if o.ListOnlyTasksWithDescriptions {
+			e.Logger.Outf(logger.Yellow, "task: No tasks with description available. Try --list-all to list all tasks")
+		} else if o.ListAllTasks {
+			e.Logger.Outf(logger.Yellow, "task: No tasks available")
+		}
+		return false, nil
 	}
 	e.Logger.Outf(logger.Default, "task: Available tasks for this project:")
 
@@ -31,10 +99,12 @@ func (e *Executor) ListTasks(filters ...FilterFunc) bool {
 		if len(task.Aliases) > 0 {
 			e.Logger.FOutf(w, logger.Cyan, "\t(aliases: %s)", strings.Join(task.Aliases, ", "))
 		}
-		fmt.Fprint(w, "\n")
+		_, _ = fmt.Fprint(w, "\n")
 	}
-	w.Flush()
-	return true
+	if err := w.Flush(); err != nil {
+		return false, err
+	}
+	return true, nil
 }
 
 // ListTaskNames prints only the task names in a Taskfile.
@@ -69,3 +139,22 @@ func (e *Executor) ListTaskNames(allTasks bool) {
 		fmt.Fprintln(w, t)
 	}
 }
+
+func (e *Executor) ToEditorOutput(tasks []*taskfile.Task) (*editors.Output, error) {
+	o := &editors.Output{
+		Tasks: make([]editors.Task, len(tasks)),
+	}
+	for i, t := range tasks {
+		upToDate, err := e.isTaskUpToDate(context.Background(), t)
+		if err != nil {
+			return nil, err
+		}
+		o.Tasks[i] = editors.Task{
+			Name:     t.Name(),
+			Desc:     t.Desc,
+			Summary:  t.Summary,
+			UpToDate: upToDate,
+		}
+	}
+	return o, nil
+}

internal/editors/output.go

@@ -0,0 +1,14 @@
+package editors
+
+// Output wraps task list output for use in editor integrations (e.g. VSCode, etc)
+type Output struct {
+	Tasks []Task `json:"tasks"`
+}
+
+// Task describes a single task
+type Task struct {
+	Name     string `json:"name"`
+	Desc     string `json:"desc"`
+	Summary  string `json:"summary"`
+	UpToDate bool   `json:"up_to_date"`
+}

internal/output/output_test.go

@@ -6,11 +6,11 @@ import (
 	"io"
 	"testing"
 
-	"github.com/go-task/task/v3/internal/templater"
-	"github.com/go-task/task/v3/taskfile"
 	"github.com/stretchr/testify/assert"
 
 	"github.com/go-task/task/v3/internal/output"
+	"github.com/go-task/task/v3/internal/templater"
+	"github.com/go-task/task/v3/taskfile"
 )
 
 func TestInterleaved(t *testing.T) {

internal/sleepit/main.go

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

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@go-task/cli",
-  "version": "3.19.0",
+  "version": "3.19.1",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@go-task/cli",
-      "version": "3.19.0",
+      "version": "3.19.1",
       "hasInstallScript": true,
       "license": "MIT",
       "dependencies": {

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@go-task/cli",
-  "version": "3.19.0",
+  "version": "3.19.1",
   "description": "A task runner / simpler Make alternative written in Go",
   "scripts": {
     "postinstall": "go-npm install",

task.go

@@ -9,6 +9,7 @@ import (
 	"strings"
 	"sync"
 	"sync/atomic"
+	"time"
 
 	"github.com/go-task/task/v3/internal/compiler"
 	"github.com/go-task/task/v3/internal/execext"
@@ -45,7 +46,7 @@ type Executor struct {
 	Parallel    bool
 	Color       bool
 	Concurrency int
-	Interval    string
+	Interval    time.Duration
 
 	Stdin  io.Reader
 	Stdout io.Writer
@@ -72,12 +73,20 @@ func (e *Executor) Run(ctx context.Context, calls ...taskfile.Call) error {
 	for _, call := range calls {
 		task, err := e.GetTask(call)
 		if err != nil {
-			e.ListTasks(FilterOutInternal(), FilterOutNoDesc())
+			if _, ok := err.(*taskNotFoundError); ok {
+				if _, err := e.ListTasks(ListOptions{ListOnlyTasksWithDescriptions: true}); err != nil {
+					return err
+				}
+			}
 			return err
 		}
 
 		if task.Internal {
-			e.ListTasks(FilterOutInternal(), FilterOutNoDesc())
+			if _, ok := err.(*taskNotFoundError); ok {
+				if _, err := e.ListTasks(ListOptions{ListOnlyTasksWithDescriptions: true}); err != nil {
+					return err
+				}
+			}
 			return &taskInternalError{taskName: call.Task}
 		}
 	}
@@ -396,7 +405,7 @@ func (e *Executor) GetTaskList(filters ...FilterFunc) []*taskfile.Task {
 		tasks = filter(tasks)
 	}
 
-	// Sort the tasks
+	// Sort the tasks.
 	// Tasks that are not namespaced should be listed before tasks that are.
 	// We detect this by searching for a ':' in the task name.
 	sort.Slice(tasks, func(i, j int) bool {

task_test.go

@@ -10,7 +10,6 @@ import (
 	"runtime"
 	"strings"
 	"testing"
-	"time"
 
 	"github.com/stretchr/testify/assert"
 
@@ -606,7 +605,9 @@ func TestNoLabelInList(t *testing.T) {
 		Stderr: &buff,
 	}
 	assert.NoError(t, e.Setup())
-	e.ListTasks(task.FilterOutInternal(), task.FilterOutNoDesc())
+	if _, err := e.ListTasks(task.ListOptions{ListOnlyTasksWithDescriptions: true}); err != nil {
+		t.Error(err)
+	}
 	assert.Contains(t, buff.String(), "foo")
 }
 
@@ -624,7 +625,9 @@ func TestListAllShowsNoDesc(t *testing.T) {
 	assert.NoError(t, e.Setup())
 
 	var title string
-	e.ListTasks(task.FilterOutInternal())
+	if _, err := e.ListTasks(task.ListOptions{ListAllTasks: true}); err != nil {
+		t.Error(err)
+	}
 	for _, title = range []string{
 		"foo",
 		"voo",
@@ -646,7 +649,9 @@ func TestListCanListDescOnly(t *testing.T) {
 	}
 
 	assert.NoError(t, e.Setup())
-	e.ListTasks(task.FilterOutInternal(), task.FilterOutNoDesc())
+	if _, err := e.ListTasks(task.ListOptions{ListOnlyTasksWithDescriptions: true}); err != nil {
+		t.Error(err)
+	}
 
 	var title string
 	assert.Contains(t, buff.String(), "foo")
@@ -1034,7 +1039,7 @@ func TestIncludesInternal(t *testing.T) {
 	}{
 		{"included internal task via task", "task-1", false, "Hello, World!\n"},
 		{"included internal task via dep", "task-2", false, "Hello, World!\n"},
-		{"included internal direct", "included:task-3", true, ""},
+		{"included internal direct", "included:task-3", true, "task: No tasks with description available. Try --list-all to list all tasks\n"},
 	}
 
 	for _, test := range tests {
@@ -1643,67 +1648,6 @@ func TestEvaluateSymlinksInPaths(t *testing.T) {
 	assert.NoError(t, err)
 }
 
-func TestFileWatcherInterval(t *testing.T) {
-	const dir = "testdata/watcher_interval"
-	expectedOutput := strings.TrimSpace(`
-task: Started watching for tasks: default
-task: [default] echo "Hello, World!"
-Hello, World!
-task: [default] echo "Hello, World!"
-Hello, World!
-	`)
-
-	var buff bytes.Buffer
-	e := &task.Executor{
-		Dir:    dir,
-		Stdout: &buff,
-		Stderr: &buff,
-		Watch:  true,
-	}
-
-	assert.NoError(t, e.Setup())
-	buff.Reset()
-
-	err := os.MkdirAll(filepathext.SmartJoin(dir, "src"), 0755)
-	assert.NoError(t, err)
-
-	err = os.WriteFile(filepathext.SmartJoin(dir, "src/a"), []byte("test"), 0644)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	ctx := context.Background()
-	ctx, cancel := context.WithCancel(ctx)
-
-	go func(ctx context.Context) {
-		for {
-			select {
-			case <-ctx.Done():
-				return
-			default:
-				err := e.Run(ctx, taskfile.Call{Task: "default"})
-				if err != nil {
-					return
-				}
-			}
-		}
-	}(ctx)
-
-	time.Sleep(10 * time.Millisecond)
-	err = os.WriteFile(filepathext.SmartJoin(dir, "src/a"), []byte("test updated"), 0644)
-	if err != nil {
-		t.Fatal(err)
-	}
-	time.Sleep(700 * time.Millisecond)
-	cancel()
-	assert.Equal(t, expectedOutput, strings.TrimSpace(buff.String()))
-	buff.Reset()
-	err = os.RemoveAll(filepathext.SmartJoin(dir, ".task"))
-	assert.NoError(t, err)
-	err = os.RemoveAll(filepathext.SmartJoin(dir, "src"))
-	assert.NoError(t, err)
-}
-
 func TestTaskfileWalk(t *testing.T) {
 	tests := []struct {
 		name     string

taskfile/cmd.go

@@ -1,5 +1,11 @@
 package taskfile
 
+import (
+	"fmt"
+
+	"gopkg.in/yaml.v3"
+)
+
 // Cmd is a task command
 type Cmd struct {
 	Cmd         string
@@ -16,68 +22,93 @@ type Dep struct {
 	Vars *Vars
 }
 
-// UnmarshalYAML implements yaml.Unmarshaler interface
-func (c *Cmd) UnmarshalYAML(unmarshal func(interface{}) error) error {
-	var cmd string
-	if err := unmarshal(&cmd); err == nil {
+func (c *Cmd) UnmarshalYAML(node *yaml.Node) error {
+	switch node.Kind {
+
+	case yaml.ScalarNode:
+		var cmd string
+		if err := node.Decode(&cmd); err != nil {
+			return err
+		}
 		c.Cmd = cmd
 		return nil
+
+	case yaml.MappingNode:
+
+		// A command with additional options
+		var cmdStruct struct {
+			Cmd         string
+			Silent      bool
+			IgnoreError bool `yaml:"ignore_error"`
+		}
+		if err := node.Decode(&cmdStruct); err == nil && cmdStruct.Cmd != "" {
+			c.Cmd = cmdStruct.Cmd
+			c.Silent = cmdStruct.Silent
+			c.IgnoreError = cmdStruct.IgnoreError
+			return nil
+		}
+
+		// A deferred command
+		var deferredCmd struct {
+			Defer string
+		}
+		if err := node.Decode(&deferredCmd); err == nil && deferredCmd.Defer != "" {
+			c.Defer = true
+			c.Cmd = deferredCmd.Defer
+			return nil
+		}
+
+		// A deferred task call
+		var deferredCall struct {
+			Defer Call
+		}
+		if err := node.Decode(&deferredCall); err == nil && deferredCall.Defer.Task != "" {
+			c.Defer = true
+			c.Task = deferredCall.Defer.Task
+			c.Vars = deferredCall.Defer.Vars
+			return nil
+		}
+
+		// A task call
+		var taskCall struct {
+			Task string
+			Vars *Vars
+		}
+		if err := node.Decode(&taskCall); err == nil && taskCall.Task != "" {
+			c.Task = taskCall.Task
+			c.Vars = taskCall.Vars
+			return nil
+		}
+
+		return fmt.Errorf("yaml: line %d: invalid keys in command", node.Line)
 	}
-	var cmdStruct struct {
-		Cmd         string
-		Silent      bool
-		IgnoreError bool `yaml:"ignore_error"`
-	}
-	if err := unmarshal(&cmdStruct); err == nil && cmdStruct.Cmd != "" {
-		c.Cmd = cmdStruct.Cmd
-		c.Silent = cmdStruct.Silent
-		c.IgnoreError = cmdStruct.IgnoreError
-		return nil
-	}
-	var deferredCmd struct {
-		Defer string
-	}
-	if err := unmarshal(&deferredCmd); err == nil && deferredCmd.Defer != "" {
-		c.Defer = true
-		c.Cmd = deferredCmd.Defer
-		return nil
-	}
-	var deferredCall struct {
-		Defer Call
-	}
-	if err := unmarshal(&deferredCall); err == nil && deferredCall.Defer.Task != "" {
-		c.Defer = true
-		c.Task = deferredCall.Defer.Task
-		c.Vars = deferredCall.Defer.Vars
-		return nil
-	}
-	var taskCall struct {
-		Task string
-		Vars *Vars
-	}
-	if err := unmarshal(&taskCall); err != nil {
-		return err
-	}
-	c.Task = taskCall.Task
-	c.Vars = taskCall.Vars
-	return nil
+
+	return fmt.Errorf("yaml: line %d: cannot unmarshal %s into command", node.Line, node.ShortTag())
 }
 
-// UnmarshalYAML implements yaml.Unmarshaler interface
-func (d *Dep) UnmarshalYAML(unmarshal func(interface{}) error) error {
-	var task string
-	if err := unmarshal(&task); err == nil {
+func (d *Dep) UnmarshalYAML(node *yaml.Node) error {
+	switch node.Kind {
+
+	case yaml.ScalarNode:
+		var task string
+		if err := node.Decode(&task); err != nil {
+			return err
+		}
 		d.Task = task
 		return nil
+
+	case yaml.MappingNode:
+		var taskCall struct {
+			Task string
+			Vars *Vars
+		}
+		if err := node.Decode(&taskCall); err != nil {
+			return err
+		}
+		d.Task = taskCall.Task
+		d.Vars = taskCall.Vars
+		return nil
 	}
-	var taskCall struct {
-		Task string
-		Vars *Vars
-	}
-	if err := unmarshal(&taskCall); err != nil {
-		return err
-	}
-	d.Task = taskCall.Task
-	d.Vars = taskCall.Vars
-	return nil
+
+	return fmt.Errorf("cannot unmarshal %s into dependency", node.ShortTag())
 }

taskfile/included_taskfile.go

@@ -1,7 +1,6 @@
 package taskfile
 
 import (
-	"errors"
 	"fmt"
 	"path/filepath"
 
@@ -32,24 +31,26 @@ type IncludedTaskfiles struct {
 
 // UnmarshalYAML implements the yaml.Unmarshaler interface.
 func (tfs *IncludedTaskfiles) UnmarshalYAML(node *yaml.Node) error {
-	if node.Kind != yaml.MappingNode {
-		return errors.New("task: includes is not a map")
-	}
+	switch node.Kind {
 
-	// NOTE(@andreynering): on this style of custom unmarsheling,
-	// even number contains the keys, while odd numbers contains
-	// the values.
-	for i := 0; i < len(node.Content); i += 2 {
-		keyNode := node.Content[i]
-		valueNode := node.Content[i+1]
+	case yaml.MappingNode:
+		// NOTE(@andreynering): on this style of custom unmarshalling,
+		// even number contains the keys, while odd numbers contains
+		// the values.
+		for i := 0; i < len(node.Content); i += 2 {
+			keyNode := node.Content[i]
+			valueNode := node.Content[i+1]
 
-		var v IncludedTaskfile
-		if err := valueNode.Decode(&v); err != nil {
-			return err
+			var v IncludedTaskfile
+			if err := valueNode.Decode(&v); err != nil {
+				return err
+			}
+			tfs.Set(keyNode.Value, v)
 		}
-		tfs.Set(keyNode.Value, v)
+		return nil
 	}
-	return nil
+
+	return fmt.Errorf("yaml: line %d: cannot unmarshal %s into included taskfiles", node.Line, node.ShortTag())
 }
 
 // Len returns the length of the map
@@ -92,33 +93,40 @@ func (tfs *IncludedTaskfiles) Range(yield func(key string, includedTaskfile Incl
 	return nil
 }
 
-// UnmarshalYAML implements yaml.Unmarshaler interface
-func (it *IncludedTaskfile) UnmarshalYAML(unmarshal func(interface{}) error) error {
-	var str string
-	if err := unmarshal(&str); err == nil {
+func (it *IncludedTaskfile) UnmarshalYAML(node *yaml.Node) error {
+	switch node.Kind {
+
+	case yaml.ScalarNode:
+		var str string
+		if err := node.Decode(&str); err != nil {
+			return err
+		}
 		it.Taskfile = str
 		return nil
+
+	case yaml.MappingNode:
+		var includedTaskfile struct {
+			Taskfile string
+			Dir      string
+			Optional bool
+			Internal bool
+			Aliases  []string
+			Vars     *Vars
+		}
+		if err := node.Decode(&includedTaskfile); err != nil {
+			return err
+		}
+		it.Taskfile = includedTaskfile.Taskfile
+		it.Dir = includedTaskfile.Dir
+		it.Optional = includedTaskfile.Optional
+		it.Internal = includedTaskfile.Internal
+		it.Aliases = includedTaskfile.Aliases
+		it.AdvancedImport = true
+		it.Vars = includedTaskfile.Vars
+		return nil
 	}
 
-	var includedTaskfile struct {
-		Taskfile string
-		Dir      string
-		Optional bool
-		Internal bool
-		Aliases  []string
-		Vars     *Vars
-	}
-	if err := unmarshal(&includedTaskfile); err != nil {
-		return err
-	}
-	it.Taskfile = includedTaskfile.Taskfile
-	it.Dir = includedTaskfile.Dir
-	it.Optional = includedTaskfile.Optional
-	it.Internal = includedTaskfile.Internal
-	it.Aliases = includedTaskfile.Aliases
-	it.AdvancedImport = true
-	it.Vars = includedTaskfile.Vars
-	return nil
+	return fmt.Errorf("yaml: line %d: cannot unmarshal %s into included taskfile", node.Line, node.ShortTag())
 }
 
 // DeepCopy creates a new instance of IncludedTaskfile and copies

taskfile/merge.go

@@ -45,7 +45,7 @@ func Merge(t1, t2 *Taskfile, includedTaskfile *IncludedTaskfile, namespaces ...s
 
 		// Set the task to internal if EITHER the included task or the included
 		// taskfile are marked as internal
-		task.Internal = task.Internal || includedTaskfile.Internal
+		task.Internal = task.Internal || (includedTaskfile != nil && includedTaskfile.Internal)
 
 		// Add namespaces to dependencies, commands and aliases
 		for _, dep := range task.Deps {

taskfile/output.go

@@ -2,6 +2,8 @@ package taskfile
 
 import (
 	"fmt"
+
+	"gopkg.in/yaml.v3"
 )
 
 // Output of the Task output
@@ -17,28 +19,35 @@ func (s *Output) IsSet() bool {
 	return s.Name != ""
 }
 
-// UnmarshalYAML implements yaml.Unmarshaler
-// It accepts a scalar node representing the Output.Name or a mapping node representing the OutputGroup.
-func (s *Output) UnmarshalYAML(unmarshal func(interface{}) error) error {
-	var name string
-	if err := unmarshal(&name); err == nil {
+func (s *Output) UnmarshalYAML(node *yaml.Node) error {
+	switch node.Kind {
+
+	case yaml.ScalarNode:
+		var name string
+		if err := node.Decode(&name); err != nil {
+			return err
+		}
 		s.Name = name
 		return nil
+
+	case yaml.MappingNode:
+		var tmp struct {
+			Group *OutputGroup
+		}
+		if err := node.Decode(&tmp); err != nil {
+			return fmt.Errorf("task: output style must be a string or mapping with a \"group\" key: %w", err)
+		}
+		if tmp.Group == nil {
+			return fmt.Errorf("task: output style must have the \"group\" key when in mapping form")
+		}
+		*s = Output{
+			Name:  "group",
+			Group: *tmp.Group,
+		}
+		return nil
 	}
-	var tmp struct {
-		Group *OutputGroup
-	}
-	if err := unmarshal(&tmp); err != nil {
-		return fmt.Errorf("task: output style must be a string or mapping with a \"group\" key: %w", err)
-	}
-	if tmp.Group == nil {
-		return fmt.Errorf("task: output style must have the \"group\" key when in mapping form")
-	}
-	*s = Output{
-		Name:  "group",
-		Group: *tmp.Group,
-	}
-	return nil
+
+	return fmt.Errorf("yaml: line %d: cannot unmarshal %s into output", node.Line, node.ShortTag())
 }
 
 // OutputGroup is the style options specific to the Group style.

taskfile/precondition.go

@@ -3,6 +3,8 @@ package taskfile
 import (
 	"errors"
 	"fmt"
+
+	"gopkg.in/yaml.v3"
 )
 
 var (
@@ -17,29 +19,33 @@ type Precondition struct {
 }
 
 // UnmarshalYAML implements yaml.Unmarshaler interface.
-func (p *Precondition) UnmarshalYAML(unmarshal func(interface{}) error) error {
-	var cmd string
+func (p *Precondition) UnmarshalYAML(node *yaml.Node) error {
+	switch node.Kind {
 
-	if err := unmarshal(&cmd); err == nil {
+	case yaml.ScalarNode:
+		var cmd string
+		if err := node.Decode(&cmd); err != nil {
+			return err
+		}
 		p.Sh = cmd
 		p.Msg = fmt.Sprintf("`%s` failed", cmd)
 		return nil
+
+	case yaml.MappingNode:
+		var sh struct {
+			Sh  string
+			Msg string
+		}
+		if err := node.Decode(&sh); err != nil {
+			return err
+		}
+		p.Sh = sh.Sh
+		p.Msg = sh.Msg
+		if p.Msg == "" {
+			p.Msg = fmt.Sprintf("%s failed", sh.Sh)
+		}
+		return nil
 	}
 
-	var sh struct {
-		Sh  string
-		Msg string
-	}
-
-	if err := unmarshal(&sh); err != nil {
-		return err
-	}
-
-	p.Sh = sh.Sh
-	p.Msg = sh.Msg
-	if p.Msg == "" {
-		p.Msg = fmt.Sprintf("%s failed", sh.Sh)
-	}
-
-	return nil
+	return fmt.Errorf("yaml: line %d: cannot unmarshal %s into precondition", node.Line, node.ShortTag())
 }

taskfile/read/taskfile.go

@@ -197,6 +197,8 @@ func readTaskfile(file string) (*taskfile.Taskfile, error) {
 	if err != nil {
 		return nil, err
 	}
+	defer f.Close()
+
 	var t taskfile.Taskfile
 	if err := yaml.NewDecoder(f).Decode(&t); err != nil {
 		return nil, fmt.Errorf("task: Failed to parse %s:\n%w", filepathext.TryAbsToRel(file), err)

taskfile/task.go

@@ -1,5 +1,11 @@
 package taskfile
 
+import (
+	"fmt"
+
+	"gopkg.in/yaml.v3"
+)
+
 // Tasks represents a group of tasks
 type Tasks map[string]*Task
 
@@ -39,67 +45,80 @@ func (t *Task) Name() string {
 	return t.Task
 }
 
-func (t *Task) UnmarshalYAML(unmarshal func(interface{}) error) error {
-	var cmd Cmd
-	if err := unmarshal(&cmd); err == nil && cmd.Cmd != "" {
+func (t *Task) UnmarshalYAML(node *yaml.Node) error {
+	switch node.Kind {
+
+	// Shortcut syntax for a task with a single command
+	case yaml.ScalarNode:
+		var cmd Cmd
+		if err := node.Decode(&cmd); err != nil {
+			return err
+		}
 		t.Cmds = append(t.Cmds, &cmd)
 		return nil
-	}
 
-	var cmds []*Cmd
-	if err := unmarshal(&cmds); err == nil && len(cmds) > 0 {
+	// Shortcut syntax for a simple task with a list of commands
+	case yaml.SequenceNode:
+		var cmds []*Cmd
+		if err := node.Decode(&cmds); err != nil {
+			return err
+		}
 		t.Cmds = cmds
 		return nil
+
+	// Full task object
+	case yaml.MappingNode:
+		var task struct {
+			Cmds          []*Cmd
+			Deps          []*Dep
+			Label         string
+			Desc          string
+			Summary       string
+			Aliases       []string
+			Sources       []string
+			Generates     []string
+			Status        []string
+			Preconditions []*Precondition
+			Dir           string
+			Vars          *Vars
+			Env           *Vars
+			Dotenv        []string
+			Silent        bool
+			Interactive   bool
+			Internal      bool
+			Method        string
+			Prefix        string
+			IgnoreError   bool `yaml:"ignore_error"`
+			Run           string
+		}
+		if err := node.Decode(&task); err != nil {
+			return err
+		}
+		t.Cmds = task.Cmds
+		t.Deps = task.Deps
+		t.Label = task.Label
+		t.Desc = task.Desc
+		t.Summary = task.Summary
+		t.Aliases = task.Aliases
+		t.Sources = task.Sources
+		t.Generates = task.Generates
+		t.Status = task.Status
+		t.Preconditions = task.Preconditions
+		t.Dir = task.Dir
+		t.Vars = task.Vars
+		t.Env = task.Env
+		t.Dotenv = task.Dotenv
+		t.Silent = task.Silent
+		t.Interactive = task.Interactive
+		t.Internal = task.Internal
+		t.Method = task.Method
+		t.Prefix = task.Prefix
+		t.IgnoreError = task.IgnoreError
+		t.Run = task.Run
+		return nil
 	}
 
-	var task struct {
-		Cmds          []*Cmd
-		Deps          []*Dep
-		Label         string
-		Desc          string
-		Summary       string
-		Aliases       []string
-		Sources       []string
-		Generates     []string
-		Status        []string
-		Preconditions []*Precondition
-		Dir           string
-		Vars          *Vars
-		Env           *Vars
-		Dotenv        []string
-		Silent        bool
-		Interactive   bool
-		Internal      bool
-		Method        string
-		Prefix        string
-		IgnoreError   bool `yaml:"ignore_error"`
-		Run           string
-	}
-	if err := unmarshal(&task); err != nil {
-		return err
-	}
-	t.Cmds = task.Cmds
-	t.Deps = task.Deps
-	t.Label = task.Label
-	t.Desc = task.Desc
-	t.Aliases = task.Aliases
-	t.Summary = task.Summary
-	t.Sources = task.Sources
-	t.Generates = task.Generates
-	t.Status = task.Status
-	t.Preconditions = task.Preconditions
-	t.Dir = task.Dir
-	t.Vars = task.Vars
-	t.Env = task.Env
-	t.Dotenv = task.Dotenv
-	t.Silent = task.Silent
-	t.Interactive = task.Interactive
-	t.Internal = task.Internal
-	t.Method = task.Method
-	t.Prefix = task.Prefix
-	t.IgnoreError = task.IgnoreError
-	t.Run = task.Run
-	return nil
+	return fmt.Errorf("yaml: line %d: cannot unmarshal %s into task", node.Line, node.ShortTag())
 }
 
 // DeepCopy creates a new instance of Task and copies

taskfile/taskfile.go

@@ -3,6 +3,9 @@ package taskfile
 import (
 	"fmt"
 	"strconv"
+	"time"
+
+	"gopkg.in/yaml.v3"
 )
 
 // Taskfile represents a Taskfile.yml
@@ -18,53 +21,55 @@ type Taskfile struct {
 	Silent     bool
 	Dotenv     []string
 	Run        string
-	Interval   string
+	Interval   time.Duration
 }
 
-// UnmarshalYAML implements yaml.Unmarshaler interface
-func (tf *Taskfile) UnmarshalYAML(unmarshal func(interface{}) error) error {
-	var taskfile struct {
-		Version    string
-		Expansions int
-		Output     Output
-		Method     string
-		Includes   *IncludedTaskfiles
-		Vars       *Vars
-		Env        *Vars
-		Tasks      Tasks
-		Silent     bool
-		Dotenv     []string
-		Run        string
-		Interval   string
+func (tf *Taskfile) UnmarshalYAML(node *yaml.Node) error {
+	switch node.Kind {
+
+	case yaml.MappingNode:
+		var taskfile struct {
+			Version    string
+			Expansions int
+			Output     Output
+			Method     string
+			Includes   *IncludedTaskfiles
+			Vars       *Vars
+			Env        *Vars
+			Tasks      Tasks
+			Silent     bool
+			Dotenv     []string
+			Run        string
+			Interval   time.Duration
+		}
+		if err := node.Decode(&taskfile); err != nil {
+			return err
+		}
+		tf.Version = taskfile.Version
+		tf.Expansions = taskfile.Expansions
+		tf.Output = taskfile.Output
+		tf.Method = taskfile.Method
+		tf.Includes = taskfile.Includes
+		tf.Vars = taskfile.Vars
+		tf.Env = taskfile.Env
+		tf.Tasks = taskfile.Tasks
+		tf.Silent = taskfile.Silent
+		tf.Dotenv = taskfile.Dotenv
+		tf.Run = taskfile.Run
+		tf.Interval = taskfile.Interval
+		if tf.Expansions <= 0 {
+			tf.Expansions = 2
+		}
+		if tf.Vars == nil {
+			tf.Vars = &Vars{}
+		}
+		if tf.Env == nil {
+			tf.Env = &Vars{}
+		}
+		return nil
 	}
 
-	if err := unmarshal(&taskfile); err != nil {
-		return err
-	}
-
-	tf.Version = taskfile.Version
-	tf.Expansions = taskfile.Expansions
-	tf.Output = taskfile.Output
-	tf.Method = taskfile.Method
-	tf.Includes = taskfile.Includes
-	tf.Vars = taskfile.Vars
-	tf.Env = taskfile.Env
-	tf.Tasks = taskfile.Tasks
-	tf.Silent = taskfile.Silent
-	tf.Dotenv = taskfile.Dotenv
-	tf.Run = taskfile.Run
-	tf.Interval = taskfile.Interval
-
-	if tf.Expansions <= 0 {
-		tf.Expansions = 2
-	}
-	if tf.Vars == nil {
-		tf.Vars = &Vars{}
-	}
-	if tf.Env == nil {
-		tf.Env = &Vars{}
-	}
-	return nil
+	return fmt.Errorf("yaml: line %d: cannot unmarshal %s into taskfile", node.Line, node.ShortTag())
 }
 
 // ParsedVersion returns the version as a float64

taskfile/var.go

@@ -1,7 +1,7 @@
 package taskfile
 
 import (
-	"errors"
+	"fmt"
 
 	"golang.org/x/exp/slices"
 	"gopkg.in/yaml.v3"
@@ -13,26 +13,27 @@ type Vars struct {
 	Mapping map[string]Var
 }
 
-// UnmarshalYAML implements the yaml.Unmarshaler interface.
 func (vs *Vars) UnmarshalYAML(node *yaml.Node) error {
-	if node.Kind != yaml.MappingNode {
-		return errors.New("task: vars is not a map")
-	}
+	switch node.Kind {
 
-	// NOTE(@andreynering): on this style of custom unmarsheling,
-	// even number contains the keys, while odd numbers contains
-	// the values.
-	for i := 0; i < len(node.Content); i += 2 {
-		keyNode := node.Content[i]
-		valueNode := node.Content[i+1]
+	case yaml.MappingNode:
+		// NOTE(@andreynering): on this style of custom unmarshalling,
+		// even number contains the keys, while odd numbers contains
+		// the values.
+		for i := 0; i < len(node.Content); i += 2 {
+			keyNode := node.Content[i]
+			valueNode := node.Content[i+1]
 
-		var v Var
-		if err := valueNode.Decode(&v); err != nil {
-			return err
+			var v Var
+			if err := valueNode.Decode(&v); err != nil {
+				return err
+			}
+			vs.Set(keyNode.Value, v)
 		}
-		vs.Set(keyNode.Value, v)
+		return nil
 	}
-	return nil
+
+	return fmt.Errorf("yaml: line %d: cannot unmarshal %s into variables", node.Line, node.ShortTag())
 }
 
 // DeepCopy creates a new instance of Vars and copies
@@ -116,20 +117,27 @@ type Var struct {
 	Dir    string
 }
 
-// UnmarshalYAML implements yaml.Unmarshaler interface.
-func (v *Var) UnmarshalYAML(unmarshal func(interface{}) error) error {
-	var str string
-	if err := unmarshal(&str); err == nil {
+func (v *Var) UnmarshalYAML(node *yaml.Node) error {
+	switch node.Kind {
+
+	case yaml.ScalarNode:
+		var str string
+		if err := node.Decode(&str); err != nil {
+			return err
+		}
 		v.Static = str
 		return nil
+
+	case yaml.MappingNode:
+		var sh struct {
+			Sh string
+		}
+		if err := node.Decode(&sh); err != nil {
+			return err
+		}
+		v.Sh = sh.Sh
+		return nil
 	}
 
-	var sh struct {
-		Sh string
-	}
-	if err := unmarshal(&sh); err != nil {
-		return err
-	}
-	v.Sh = sh.Sh
-	return nil
+	return fmt.Errorf("yaml: line %d: cannot unmarshal %s into variable", node.Line, node.ShortTag())
 }

watch.go

@@ -10,10 +10,11 @@ import (
 	"syscall"
 	"time"
 
+	"github.com/radovskyb/watcher"
+
 	"github.com/go-task/task/v3/internal/logger"
 	"github.com/go-task/task/v3/internal/status"
 	"github.com/go-task/task/v3/taskfile"
-	"github.com/radovskyb/watcher"
 )
 
 const defaultWatchInterval = 5 * time.Second
@@ -37,23 +38,14 @@ func (e *Executor) watchTasks(calls ...taskfile.Call) error {
 		}()
 	}
 
-	var watchIntervalString string
-
-	if e.Interval != "" {
-		watchIntervalString = e.Interval
-	} else if e.Taskfile.Interval != "" {
-		watchIntervalString = e.Taskfile.Interval
-	}
-
-	watchInterval := defaultWatchInterval
-
-	if watchIntervalString != "" {
-		var err error
-		watchInterval, err = parseWatchInterval(watchIntervalString)
-		if err != nil {
-			cancel()
-			return err
-		}
+	var watchInterval time.Duration
+	switch {
+	case e.Interval != 0:
+		watchInterval = e.Interval
+	case e.Taskfile.Interval != 0:
+		watchInterval = e.Taskfile.Interval
+	default:
+		watchInterval = defaultWatchInterval
 	}
 
 	e.Logger.VerboseOutf(logger.Green, "task: Watching for changes every %v", watchInterval)
@@ -185,11 +177,3 @@ func (e *Executor) registerWatchedFiles(w *watcher.Watcher, calls ...taskfile.Ca
 func shouldIgnoreFile(path string) bool {
 	return strings.Contains(path, "/.git") || strings.Contains(path, "/.task") || strings.Contains(path, "/node_modules")
 }
-
-func parseWatchInterval(watchInterval string) (time.Duration, error) {
-	v, err := time.ParseDuration(watchInterval)
-	if err != nil {
-		return 0, fmt.Errorf(`task: Could not parse watch interval "%s": %v`, watchInterval, err)
-	}
-	return v, nil
-}

watch_test.go

@@ -0,0 +1,80 @@
+//go:build watch
+// +build watch
+
+package task_test
+
+import (
+	"bytes"
+	"context"
+	"os"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/go-task/task/v3"
+	"github.com/go-task/task/v3/internal/filepathext"
+	"github.com/go-task/task/v3/taskfile"
+)
+
+func TestFileWatcherInterval(t *testing.T) {
+	const dir = "testdata/watcher_interval"
+	expectedOutput := strings.TrimSpace(`
+task: Started watching for tasks: default
+task: [default] echo "Hello, World!"
+Hello, World!
+task: [default] echo "Hello, World!"
+Hello, World!
+	`)
+
+	var buff bytes.Buffer
+	e := &task.Executor{
+		Dir:    dir,
+		Stdout: &buff,
+		Stderr: &buff,
+		Watch:  true,
+	}
+
+	assert.NoError(t, e.Setup())
+	buff.Reset()
+
+	err := os.MkdirAll(filepathext.SmartJoin(dir, "src"), 0755)
+	assert.NoError(t, err)
+
+	err = os.WriteFile(filepathext.SmartJoin(dir, "src/a"), []byte("test"), 0644)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	ctx := context.Background()
+	ctx, cancel := context.WithCancel(ctx)
+
+	go func(ctx context.Context) {
+		for {
+			select {
+			case <-ctx.Done():
+				return
+			default:
+				err := e.Run(ctx, taskfile.Call{Task: "default"})
+				if err != nil {
+					return
+				}
+			}
+		}
+	}(ctx)
+
+	time.Sleep(10 * time.Millisecond)
+	err = os.WriteFile(filepathext.SmartJoin(dir, "src/a"), []byte("test updated"), 0644)
+	if err != nil {
+		t.Fatal(err)
+	}
+	time.Sleep(700 * time.Millisecond)
+	cancel()
+	assert.Equal(t, expectedOutput, strings.TrimSpace(buff.String()))
+	buff.Reset()
+	err = os.RemoveAll(filepathext.SmartJoin(dir, ".task"))
+	assert.NoError(t, err)
+	err = os.RemoveAll(filepathext.SmartJoin(dir, "src"))
+	assert.NoError(t, err)
+}