v3.14.0

Closes #568
Closes #792

.editorconfig

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

.github/FUNDING.yml

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

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,7 +1,6 @@
 ---
 name: Bug Report
 about: Use the template to report bugs and issues
-labels: bug
 ---
 
 - Task version:

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,7 +1,6 @@
 ---
 name: Feature Request
 about: Use the template to make feature requests
-labels: feature
 ---
 
 Describe in detail what feature do you want to see in Task.

.github/workflows/lint.yml

@@ -0,0 +1,24 @@
+name: Lint
+
+on:
+  pull_request:
+  push:
+    tags:
+      - v*
+    branches:
+      - master
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/setup-go@v3
+        with:
+          go-version: 1.18
+
+      - uses: actions/checkout@v3
+
+      - name: golangci-lint
+        uses: golangci/golangci-lint-action@v3
+        with:
+          version: v1.46.1

.github/workflows/release.yml

@@ -10,12 +10,12 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v1
+        uses: actions/checkout@v3
 
       - name: Set up Go
-        uses: actions/setup-go@v1
+        uses: actions/setup-go@v3
         with:
-          go-version: 1.17.x
+          go-version: 1.18.x
 
       - name: Run GoReleaser
         uses: goreleaser/goreleaser-action@v2
@@ -23,4 +23,4 @@ jobs:
           version: latest
           args: release --rm-dist
         env:
-          GITHUB_TOKEN: ${{secrets.GITHUB_TOKEN}}
+          GITHUB_TOKEN: ${{secrets.GH_PAT}}

.github/workflows/test.yml

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

.github/workflows/website-deploy.yml

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

.github/workflows/website-test.yml

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

.gitignore

@@ -26,6 +26,7 @@ dist/
 # exuberant ctags
 tags
 
-/bin
+/bin/*
+!/bin/.keep
 /testdata/vars/v1
 /tmp

.goreleaser.yml

@@ -25,6 +25,10 @@ gomod:
 
 archives:
   - name_template: "{{.Binary}}_{{.Os}}_{{.Arch}}"
+    files:
+      - README.md
+      - LICENSE
+      - completion/**/*
     format_overrides:
       - goos: windows
         format: zip
@@ -40,8 +44,8 @@ checksum:
 
 nfpms:
   - vendor: Task
-    homepage: https://github.com/go-task/task
-    maintainer: Andrey Nering <andrey.nering@gmail.com>
+    homepage: https://taskfile.dev
+    maintainer: Andrey Nering <andrey@nering.com.br>
     description: Simple task runner written in Go
     license: MIT
     conflicts:
@@ -50,6 +54,13 @@ nfpms:
       - deb
       - rpm
     file_name_template: "{{.ProjectName}}_{{.Os}}_{{.Arch}}"
+    contents:
+      - src: completion/bash/task.bash
+        dst: /etc/bash_completion.d/task
+      - src: completion/fish/task.fish
+        dst: /usr/share/fish/completions/task.fish
+      - src: completion/zsh/_task
+        dst: /usr/local/share/zsh/site-functions/_task
 
 brews:
   - name: go-task
@@ -62,5 +73,11 @@ brews:
       name: homebrew-tap
     test:
       system "#{bin}/task", "--help"
-    url_template: https://github.com/go-task/task/releases/download/{{.Tag}}/{{.ArtifactName}}
-    skip_upload: true
+    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

CHANGELOG.md

@@ -1,5 +1,125 @@
 # Changelog
 
+## v3.14.0 - 2022-07-08
+
+- Add ability to override the `.task` directory location with the
+  `TASK_TEMP_DIR` environment variable.
+- Allow to override Task colors using environment variables:
+  `TASK_COLOR_RESET`, `TASK_COLOR_BLUE`, `TASK_COLOR_GREEN`,
+  `TASK_COLOR_CYAN`, `TASK_COLOR_YELLOW`, `TASK_COLOR_MAGENTA`
+  and `TASK_COLOR_RED`
+  ([#568](https://github.com/go-task/task/pull/568), [#792](https://github.com/go-task/task/pull/792)).
+- Fixed bug when using the `output: group` mode where STDOUT and STDERR were
+  being print in separated blocks instead of in the right order
+  ([#779](https://github.com/go-task/task/issues/779)).
+- Starting on this release, ARM architecture binaries are been released to Snap
+  as well
+  ([#795](https://github.com/go-task/task/issues/795)).
+- i386 binaries won't be available anymore on Snap because Ubuntu removed the support
+  for this architecture.
+- Upgrade mvdan.cc/sh, which fixes a bug with associative arrays
+  ([#785](https://github.com/go-task/task/issues/785), [mvdan/sh#884](https://github.com/mvdan/sh/issues/884), [mvdan/sh#893](https://github.com/mvdan/sh/pull/893)).
+
+## v3.13.0 - 2022-06-13
+
+- Added `-n` as an alias to `--dry`
+  ([#776](https://github.com/go-task/task/issues/776), [#777](https://github.com/go-task/task/pull/777)).
+- Fix behavior of interrupt (SIGINT, SIGTERM) signals. Task will now give time
+  for the processes running to do cleanup work
+  ([#458](https://github.com/go-task/task/issues/458), [#479](https://github.com/go-task/task/pull/479), [#728](https://github.com/go-task/task/issues/728), [#769](https://github.com/go-task/task/pull/769)).
+- Add new `--exit-code` (`-x`) flag that will pass-through the exit form the
+  command being ran
+  ([#755](https://github.com/go-task/task/pull/755)).
+
+## v3.12.1 - 2022-05-10
+
+- Fixed bug where, on Windows, variables were ending with `\r` because we were
+  only removing the final `\n` but not `\r\n`
+  ([#717](https://github.com/go-task/task/issues/717)).
+
+## v3.12.0 - 2022-03-31
+
+- The `--list` and `--list-all` flags can now be combined with the `--silent`
+  flag to print the task names only, without their description
+  ([#691](https://github.com/go-task/task/pull/691)).
+- Added support for multi-level inclusion of Taskfiles. This means that
+  included Taskfiles can also include other Taskfiles. Before this was limited
+  to one level
+  ([#390](https://github.com/go-task/task/issues/390), [#623](https://github.com/go-task/task/discussions/623), [#656](https://github.com/go-task/task/pull/656)).
+- Add ability to specify vars when including a Taskfile.
+  [Check out the documentation](https://taskfile.dev/#/usage?id=vars-of-included-taskfiles)
+  for more information.
+  ([#677](https://github.com/go-task/task/pull/677)).
+
+## v3.11.0 - 2022-02-19
+
+- Task now supports printing begin and end messages when using the `group`
+  output mode, useful for grouping tasks in CI systems.
+  [Check out the documentation](http://taskfile.dev/#/usage?id=output-syntax) for more information
+  ([#647](https://github.com/go-task/task/issues/647), [#651](https://github.com/go-task/task/pull/651)).
+- Add `Taskfile.dist.yml` and `Taskfile.dist.yaml` to the supported file
+  name list. [Check out the documentation](https://taskfile.dev/#/usage?id=supported-file-names) for more information
+  ([#498](https://github.com/go-task/task/issues/498), [#666](https://github.com/go-task/task/pull/666)).
+
+## v3.10.0 - 2022-01-04
+
+- A new `--list-all` (alias `-a`) flag is now available. It's similar to the
+  exiting `--list` (`-l`) but prints all tasks, even those without a
+  description
+  ([#383](https://github.com/go-task/task/issues/383), [#401](https://github.com/go-task/task/pull/401)).
+- It's now possible to schedule cleanup commands to run once a task finishes
+  with the `defer:` keyword
+  ([Documentation](https://taskfile.dev/#/usage?id=doing-task-cleanup-with-defer), [#475](https://github.com/go-task/task/issues/475), [#626](https://github.com/go-task/task/pull/626)).
+- Remove long deprecated and undocumented `$` variable prefix and `^` command
+  prefix
+  ([#642](https://github.com/go-task/task/issues/642), [#644](https://github.com/go-task/task/issues/644), [#645](https://github.com/go-task/task/pull/645)).
+- Add support for `.yaml` extension (as an alternative to `.yml`).
+  This was requested multiple times throughout the years. Enjoy!
+  ([#183](https://github.com/go-task/task/issues/183), [#184](https://github.com/go-task/task/pull/184), [#369](https://github.com/go-task/task/issues/369), [#584](https://github.com/go-task/task/issues/584), [#621](https://github.com/go-task/task/pull/621)).
+- Fixed error when computing a variable when the task directory do not exist
+  yet
+  ([#481](https://github.com/go-task/task/issues/481), [#579](https://github.com/go-task/task/pull/579)).
+
+## v3.9.2 - 2021-12-02
+
+- Upgrade [mvdan/sh](https://github.com/mvdan/sh) which contains a fix a for
+  a important regression on Windows
+  ([#619](https://github.com/go-task/task/issues/619), [mvdan/sh#768](https://github.com/mvdan/sh/issues/768), [mvdan/sh#769](https://github.com/mvdan/sh/pull/769)).
+
+## v3.9.1 - 2021-11-28
+
+- Add logging in verbose mode for when a task starts and finishes
+  ([#533](https://github.com/go-task/task/issues/533), [#588](https://github.com/go-task/task/pull/588)).
+- Fix an issue with preconditions and context errors
+  ([#597](https://github.com/go-task/task/issues/597), [#598](https://github.com/go-task/task/pull/598)).
+- Quote each `{{.CLI_ARGS}}` argument to prevent one with spaces to become many
+  ([#613](https://github.com/go-task/task/pull/613)).
+- Fix  nil pointer when `cmd:` was left empty
+  ([#612](https://github.com/go-task/task/issues/612), [#614](https://github.com/go-task/task/pull/614)).
+- Upgrade [mvdan/sh](https://github.com/mvdan/sh) which contains two
+  relevant fixes:
+  - Fix quote of empty strings in `shellQuote`
+    ([#609](https://github.com/go-task/task/issues/609), [mvdan/sh#763](https://github.com/mvdan/sh/issues/763)).
+  - Fix issue of wrong environment variable being picked when there's another
+    very similar one
+    ([#586](https://github.com/go-task/task/issues/586), [mvdan/sh#745](https://github.com/mvdan/sh/pull/745)).
+- Install shell completions automatically when installing via Homebrew
+  ([#264](https://github.com/go-task/task/issues/264), [#592](https://github.com/go-task/task/pull/592), [go-task/homebrew-tap#2](https://github.com/go-task/homebrew-tap/pull/2)).
+
+## v3.9.0 - 2021-10-02
+
+- A new `shellQuote` function was added to the template system
+  (`{{shellQuote "a string"}}`) to ensure a string is safe for use in shell
+  ([mvdan/sh#727](https://github.com/mvdan/sh/pull/727), [mvdan/sh#737](https://github.com/mvdan/sh/pull/737), [Documentation](https://pkg.go.dev/mvdan.cc/sh/v3@v3.4.0/syntax#Quote))
+- In this version [mvdan.cc/sh](https://github.com/mvdan/sh) was upgraded
+  with some small fixes and features
+  - The `read -p` flag is now supported
+    ([#314](https://github.com/go-task/task/issues/314), [mvdan/sh#551](https://github.com/mvdan/sh/issues/551), [mvdan/sh#772](https://github.com/mvdan/sh/pull/722))
+  - The `pwd -P` and `pwd -L` flags are now supported
+    ([#553](https://github.com/go-task/task/issues/553), [mvdan/sh#724](https://github.com/mvdan/sh/issues/724), [mvdan/sh#728](https://github.com/mvdan/sh/pull/728))
+  - The `$GID` environment variable is now correctly being set
+    ([#561](https://github.com/go-task/task/issues/561), [mvdan/sh#723](https://github.com/mvdan/sh/pull/723))
+
 ## v3.8.0 - 2021-09-26
 
 - Add `interactive: true` setting to improve support for interactive CLI apps

README.md

@@ -1,6 +1,6 @@
 <div align="center">
   <a href="https://taskfile.dev">
-    <img src="docs/Logo.png" width="200px" height="200px" />
+    <img src="docs/static/img/logo.svg" width="200px" height="200px" />
   </a>
 
   <h1>Task</h1>

Taskfile.yml

@@ -18,10 +18,13 @@ env:
 tasks:
   default:
     cmds:
+      - task: lint
       - task: test
 
   install:
     desc: Installs Task
+    sources:
+      - './**/*.go'
     cmds:
       - go install -v -ldflags="-w -s -X main.version={{.GIT_COMMIT}}" ./cmd/task
 
@@ -31,25 +34,33 @@ tasks:
       - go mod download
       - go mod tidy
 
-  cli-deps:
-    desc: Downloads CLI dependencies
-    cmds:
-      - task: go-get
-        vars: {REPO: golang.org/x/lint/golint}
-      - task: go-get
-        vars: {REPO: github.com/goreleaser/goreleaser}
-      - task: go-get
-        vars: {REPO: github.com/goreleaser/godownloader}
-
   clean:
     desc: Cleans temp files and folders
     cmds:
       - rm -rf dist/
+      - rm -rf tmp/
 
   lint:
-    desc: Runs golint
+    desc: Runs golangci-lint
+    sources:
+      - './**/*.go'
     cmds:
-      - golint {{catLines .GO_PACKAGES}}
+      - golangci-lint run
+
+  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:
@@ -58,25 +69,17 @@ tasks:
     cmds:
       - go test {{catLines .GO_PACKAGES}}
 
+  test:signals:
+    desc: Runs test suite with signals tests included
+    deps: [install, sleepit:build]
+    cmds:
+      - go test {{catLines .GO_PACKAGES}} -tags signals
+
   test-release:
     desc: Tests release process without publishing
     cmds:
       - goreleaser --snapshot --rm-dist
 
-  gen-install-script:
-    desc: Generate install script using https://github.com/goreleaser/godownloader
-    cmds:
-      - godownloader --repo go-task/task -o install-task.sh
-      - cp ./install-task.sh ./docs/install.sh
-
-  ci:
-    - task: go-get
-      vars: {REPO: golang.org/x/lint/golint}
-    - task: lint
-    - task: test
-
-  go-get: go get -u {{.REPO}}
-
   packages:
     cmds:
       - echo '{{.GO_PACKAGES}}'

cmd/sleepit/sleepit.go

@@ -0,0 +1,173 @@
+// 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
+}

cmd/task/task.go

@@ -5,13 +5,12 @@ import (
 	"fmt"
 	"log"
 	"os"
-	"os/signal"
 	"path/filepath"
 	"runtime/debug"
 	"strings"
-	"syscall"
 
 	"github.com/spf13/pflag"
+	"mvdan.cc/sh/v3/syntax"
 
 	"github.com/go-task/task/v3"
 	"github.com/go-task/task/v3/args"
@@ -59,6 +58,7 @@ func main() {
 		helpFlag    bool
 		init        bool
 		list        bool
+		listAll     bool
 		status      bool
 		force       bool
 		watch       bool
@@ -66,29 +66,34 @@ func main() {
 		silent      bool
 		dry         bool
 		summary     bool
+		exitCode    bool
 		parallel    bool
 		concurrency int
 		dir         string
 		entrypoint  string
-		output      string
+		output      taskfile.Output
 		color       bool
 	)
 
 	pflag.BoolVar(&versionFlag, "version", false, "show Task version")
 	pflag.BoolVarP(&helpFlag, "help", "h", false, "shows Task usage")
-	pflag.BoolVarP(&init, "init", "i", false, "creates a new Taskfile.yml in the current folder")
+	pflag.BoolVarP(&init, "init", "i", false, "creates a new Taskfile.yaml in the current folder")
 	pflag.BoolVarP(&list, "list", "l", false, "lists tasks with description of current Taskfile")
+	pflag.BoolVarP(&listAll, "list-all", "a", false, "lists tasks with or without a description")
 	pflag.BoolVar(&status, "status", false, "exits with non-zero exit code if any of the given tasks is not up-to-date")
 	pflag.BoolVarP(&force, "force", "f", false, "forces execution even when the task is up-to-date")
 	pflag.BoolVarP(&watch, "watch", "w", false, "enables watch of the given task")
 	pflag.BoolVarP(&verbose, "verbose", "v", false, "enables verbose mode")
 	pflag.BoolVarP(&silent, "silent", "s", false, "disables echoing")
 	pflag.BoolVarP(&parallel, "parallel", "p", false, "executes tasks provided on command line in parallel")
-	pflag.BoolVar(&dry, "dry", false, "compiles and prints tasks in the order that they would be run, without executing them")
+	pflag.BoolVarP(&dry, "dry", "n", false, "compiles and prints tasks in the order that they would be run, without executing them")
 	pflag.BoolVar(&summary, "summary", false, "show summary about a task")
+	pflag.BoolVarP(&exitCode, "exit-code", "x", false, "pass-through the exit code of the task command")
 	pflag.StringVarP(&dir, "dir", "d", "", "sets directory of execution")
 	pflag.StringVarP(&entrypoint, "taskfile", "t", "", `choose which Taskfile to run. Defaults to "Taskfile.yml"`)
-	pflag.StringVarP(&output, "output", "o", "", "sets output style: [interleaved|group|prefixed]")
+	pflag.StringVarP(&output.Name, "output", "o", "", "sets output style: [interleaved|group|prefixed]")
+	pflag.StringVar(&output.Group.Begin, "output-group-begin", "", "message template to print before a task's grouped output")
+	pflag.StringVar(&output.Group.End, "output-group-end", "", "message template to print after a task's grouped output")
 	pflag.BoolVarP(&color, "color", "c", true, "colored output. Enabled by default. Set flag to false or use NO_COLOR=1 to disable")
 	pflag.IntVarP(&concurrency, "concurrency", "C", 0, "limit number tasks to run concurrently")
 	pflag.Parse()
@@ -121,8 +126,17 @@ func main() {
 	if entrypoint != "" {
 		dir = filepath.Dir(entrypoint)
 		entrypoint = filepath.Base(entrypoint)
-	} else {
-		entrypoint = "Taskfile.yml"
+	}
+
+	if output.Name != "group" {
+		if output.Group.Begin != "" {
+			log.Fatal("task: You can't set --output-group-begin without --output=group")
+			return
+		}
+		if output.Group.End != "" {
+			log.Fatal("task: You can't set --output-group-end without --output=group")
+			return
+		}
 	}
 
 	e := task.Executor{
@@ -144,6 +158,12 @@ func main() {
 
 		OutputStyle: output,
 	}
+
+	if (list || listAll) && silent {
+		e.ListTaskNames(listAll)
+		return
+	}
+
 	if err := e.Setup(); err != nil {
 		log.Fatal(err)
 	}
@@ -154,30 +174,40 @@ func main() {
 	}
 
 	if list {
-		e.PrintTasksHelp()
+		e.ListTasksWithDesc()
+		return
+	}
+
+	if listAll {
+		e.ListAllTasks()
 		return
 	}
 
 	var (
-		calls                 []taskfile.Call
-		globals               *taskfile.Vars
-		tasksAndVars, cliArgs = getArgs()
+		calls   []taskfile.Call
+		globals *taskfile.Vars
 	)
 
+	tasksAndVars, cliArgs, err := getArgs()
+	if err != nil {
+		log.Fatal(err)
+	}
+
 	if v >= 3.0 {
 		calls, globals = args.ParseV3(tasksAndVars...)
 	} else {
 		calls, globals = args.ParseV2(tasksAndVars...)
 	}
 
-	globals.Set("CLI_ARGS", taskfile.Var{Static: strings.Join(cliArgs, " ")})
+	globals.Set("CLI_ARGS", taskfile.Var{Static: cliArgs})
 	e.Taskfile.Vars.Merge(globals)
 
-	ctx := context.Background()
 	if !watch {
-		ctx = getSignalContext()
+		e.InterceptInterruptSignals()
 	}
 
+	ctx := context.Background()
+
 	if status {
 		if err := e.Status(ctx, calls...); err != nil {
 			log.Fatal(err)
@@ -187,36 +217,35 @@ func main() {
 
 	if err := e.Run(ctx, calls...); err != nil {
 		e.Logger.Errf(logger.Red, "%v", err)
+
+		if exitCode {
+			if err, ok := err.(*task.TaskRunError); ok {
+				os.Exit(err.ExitCode())
+			}
+		}
 		os.Exit(1)
 	}
 }
 
-func getArgs() (tasksAndVars, cliArgs []string) {
+func getArgs() ([]string, string, error) {
 	var (
 		args          = pflag.Args()
 		doubleDashPos = pflag.CommandLine.ArgsLenAtDash()
 	)
 
-	if doubleDashPos != -1 {
-		tasksAndVars = args[:doubleDashPos]
-		cliArgs = args[doubleDashPos:]
-	} else {
-		tasksAndVars = args
+	if doubleDashPos == -1 {
+		return args, "", nil
 	}
 
-	return
-}
-
-func getSignalContext() context.Context {
-	ch := make(chan os.Signal, 1)
-	signal.Notify(ch, os.Interrupt, syscall.SIGTERM)
-	ctx, cancel := context.WithCancel(context.Background())
-	go func() {
-		sig := <-ch
-		log.Printf("task: signal received: %s", sig)
-		cancel()
-	}()
-	return ctx
+	var quotedCliArgs []string
+	for _, arg := range args[doubleDashPos:] {
+		quotedCliArg, err := syntax.Quote(arg, syntax.LangBash)
+		if err != nil {
+			return nil, "", err
+		}
+		quotedCliArgs = append(quotedCliArgs, quotedCliArg)
+	}
+	return args[:doubleDashPos], strings.Join(quotedCliArgs, " "), nil
 }
 
 func getVersion() string {

completion/bash/task.bash

@@ -1,21 +1,26 @@
-_task_completion()
+#!/bin/bash
+
+GO_TASK_PROGNAME=task
+
+_go_task_completion()
 {
-  local scripts;
-  local curr_arg;
+  local cur
+  _get_comp_words_by_ref -n : cur
 
-  # Remove colon from word breaks
-  COMP_WORDBREAKS=${COMP_WORDBREAKS//:}
+  case "$cur" in
+  --*)
+    local options
+    options="$(_parse_help task)"
+    mapfile -t COMPREPLY < <(compgen -W "$options" -- "$cur")
+    ;;
+  *)
+    local tasks
+    tasks="$($GO_TASK_PROGNAME --list-all 2> /dev/null | awk 'NR>1 { sub(/:$/,"",$2); print $2 }')"
+    mapfile -t COMPREPLY < <(compgen -W "$tasks" -- "$cur")
+    ;;
+  esac
 
-  scripts=$(task -l | sed '1d' | awk '{ print $2 }' | sed 's/:$//');
-
-  curr_arg="${COMP_WORDS[COMP_CWORD]:-"."}"
-
-  # Do not accept more than 1 argument
-  if [ "${#COMP_WORDS[@]}" != "2" ]; then
-    return
-  fi
-
-  COMPREPLY=($(compgen -c | echo "$scripts" | grep -- $curr_arg));
+  __ltrim_colon_completions "$cur"
 }
 
-complete -F _task_completion task
+complete -F _go_task_completion $GO_TASK_PROGNAME

completion/fish/task.fish

@@ -1,24 +1,29 @@
+set GO_TASK_PROGNAME task
+
 function __task_get_tasks --description "Prints all available tasks with their description"
-	task -l | sed '1d' | awk '{ $1=""; print $0 }' | sed 's/:\ /\t/g' | string trim
+	set -l output ($GO_TASK_PROGNAME --list-all | sed '1d; s/\* \(.*\):\s*\(.*\)/\1\t\2/' | string split0)
+  if test $output
+      echo $output
+  end
 end
 
-complete -c task -d 'Runs the specified task(s). Falls back to the "default" task if no task name was specified, or lists all tasks if an unknown task name was 
+complete -c $GO_TASK_PROGNAME -d 'Runs the specified task(s). Falls back to the "default" task if no task name was specified, or lists all tasks if an unknown task name was
 specified.' -xa "(__task_get_tasks)"
 
 
-complete -c task -s c -l color     -d 'colored output (default true)'
-complete -c task -s d -l dir       -d 'sets directory of execution'
-complete -c task      -l dry       -d 'compiles and prints tasks in the order that they would be run, without executing them'
-complete -c task -s f -l force     -d 'forces execution even when the task is up-to-date'
-complete -c task -s h -l help      -d 'shows Task usage'
-complete -c task -s i -l init      -d 'creates a new Taskfile.yml in the current folder'
-complete -c task -s l -l list      -d 'lists tasks with description of current Taskfile'
-complete -c task -s o -l output    -d 'sets output style: [interleaved|group|prefixed]' -xa "interleaved group prefixed"
-complete -c task -s p -l parallel  -d 'executes tasks provided on command line in parallel'
-complete -c task -s s -l silent    -d 'disables echoing'
-complete -c task      -l status    -d 'exits with non-zero exit code if any of the given tasks is not up-to-date'
-complete -c task      -l summary   -d 'show summary about a task'
-complete -c task -s t -l taskfile  -d 'choose which Taskfile to run. Defaults to "Taskfile.yml"'
-complete -c task -s v -l verbose   -d 'enables verbose mode'
-complete -c task      -l version   -d 'show Task version'
-complete -c task -s w -l watch     -d 'enables watch of the given task'
+complete -c $GO_TASK_PROGNAME -s c -l color     -d 'colored output (default true)'
+complete -c $GO_TASK_PROGNAME -s d -l dir       -d 'sets directory of execution'
+complete -c $GO_TASK_PROGNAME      -l dry       -d 'compiles and prints tasks in the order that they would be run, without executing them'
+complete -c $GO_TASK_PROGNAME -s f -l force     -d 'forces execution even when the task is up-to-date'
+complete -c $GO_TASK_PROGNAME -s h -l help      -d 'shows Task usage'
+complete -c $GO_TASK_PROGNAME -s i -l init      -d 'creates a new Taskfile.yml in the current folder'
+complete -c $GO_TASK_PROGNAME -s l -l list      -d 'lists tasks with description of current Taskfile'
+complete -c $GO_TASK_PROGNAME -s o -l output    -d 'sets output style: [interleaved|group|prefixed]' -xa "interleaved group prefixed"
+complete -c $GO_TASK_PROGNAME -s p -l parallel  -d 'executes tasks provided on command line in parallel'
+complete -c $GO_TASK_PROGNAME -s s -l silent    -d 'disables echoing'
+complete -c $GO_TASK_PROGNAME      -l status    -d 'exits with non-zero exit code if any of the given tasks is not up-to-date'
+complete -c $GO_TASK_PROGNAME      -l summary   -d 'show summary about a task'
+complete -c $GO_TASK_PROGNAME -s t -l taskfile  -d 'choose which Taskfile to run. Defaults to "Taskfile.yml"'
+complete -c $GO_TASK_PROGNAME -s v -l verbose   -d 'enables verbose mode'
+complete -c $GO_TASK_PROGNAME      -l version   -d 'show Task version'
+complete -c $GO_TASK_PROGNAME -s w -l watch     -d 'enables watch of the given task'

completion/zsh/_task

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

docs/.gitignore

@@ -0,0 +1,20 @@
+# Dependencies
+/node_modules
+
+# Production
+/build
+
+# Generated files
+.docusaurus
+.cache-loader
+
+# Misc
+.DS_Store
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*

docs/CNAME

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

docs/Taskfile.yml

@@ -1,17 +1,29 @@
 version: '3'
 
 tasks:
-  install:
-    desc: Installs docsify to work the on the documentation site
+  setup:
+    desc: Setup Docusaurus locally
     cmds:
-      - npm install docsify-cli -g
+      - yarn install
 
-  serve:
-    desc: Serves the documentation site locally
+  start:
+    desc: Start website
+    vars:
+      PORT: '{{default "3001" .PORT}}'
     cmds:
-      - docsify serve .
+      - npx docusaurus start --no-open --port={{.PORT}}
 
-  ico:
-    desc: Generate favicon.ico from Logo.png
+  build:
+    desc: Build website
     cmds:
-      - convert -background transparent "Logo.png" -define icon:auto-resize=16,24,32,48,64,72,96,128,256 "favicon.ico"
+      - npx docusaurus build
+
+  clean:
+    desc: Clean temp directories
+    cmds:
+      - rm -rf ./build
+
+  deploy:
+    desc: Build and deploy Docusaurus. Requires GIT_USER and GIT_PASS envs to be previous set
+    cmds:
+      - npx docusaurus deploy

docs/_sidebar.md

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

docs/babel.config.js

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

docs/blog/authors.yml

@@ -0,0 +1,5 @@
+andreynering:
+  name: Andrey Nering
+  title: Maintainer of Task
+  url: https://github.com/andreynering
+  image_url: https://github.com/andreynering.png

docs/docs/api_reference.md

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

docs/docs/changelog.md

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

docs/docs/community.md

@@ -1,3 +1,8 @@
+---
+slug: /community/
+sidebar_position: 6
+---
+
 # Community
 
 Some of the work to improve the Task ecosystem is done by the community, be
@@ -25,10 +30,16 @@ and is published [here](https://marketplace.visualstudio.com/items?itemName=paul
 
 ### Sublime Text 4 package
 
-There is a convenience wrapper for initializing and running tasks from Sublime Text's command palette. The package is 
+There is a convenience wrapper for initializing and running tasks from Sublime Text's command palette. The package is
 developed by [@biozz](https://github.com/biozz), the source code is available [here](https://github.com/biozz/sublime-taskfile)
 and it is published on Package Control [here](https://packagecontrol.io/packages/Taskfile).
 
+### IntelliJ plugin
+
+There's a JetBrains IntelliJ plugin done by
+[@lechuckroh](https://github.com/lechuckroh), which has its code [here](https://github.com/lechuckroh/task-intellij-plugin)
+and is published [here](https://plugins.jetbrains.com/plugin/17058-taskfile).
+
 ## Installation methods
 
 Some installation methods are maintained by third party:
@@ -38,6 +49,8 @@ Some installation methods are maintained by third party:
 - [AUR](https://aur.archlinux.org/packages/taskfile-git)
   by [@kovetskiy](https://github.com/kovetskiy)
 - [Scoop](https://github.com/lukesampson/scoop-extras/blob/master/bucket/task.json)
+- [Fedora](https://packages.fedoraproject.org/pkgs/golang-github-task/go-task/)
+- [NixOS](https://github.com/NixOS/nixpkgs/blob/master/pkgs/development/tools/go-task/default.nix)
 
 ## More
 

docs/docs/donate.md

@@ -1,3 +1,8 @@
+---
+slug: /donate/
+sidebar_position: 9
+---
+
 # Donate
 
 If you find this project useful, you can consider donating by using one of the
@@ -17,6 +22,10 @@ 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
 
 - [Any value - One-time donation](https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=GSVDU63RKG45A&currency_code=USD&source=url)
@@ -24,4 +33,4 @@ these options to donate:
 ## PIX (Brazil only)
 
 If you're Brazilian, you can donate any value by
-<a href="/pix.png" target="_blank">using this QR Code</a>.
+[using this QR Code](/img/pix.png).

docs/docs/installation.md

@@ -1,12 +1,15 @@
+---
+slug: /installation/
+sidebar_position: 2
+---
+
 # Installation
 
 Task offers many installation methods. Check out the available methods below.
 
 ## Package Managers
 
-<!-- tabs:start -->
-
-#### **Homebrew**
+### Homebrew
 
 If you're on macOS or Linux and have [Homebrew][homebrew] installed, getting
 Task is as simple as running:
@@ -15,7 +18,7 @@ Task is as simple as running:
 brew install go-task/tap/go-task
 ```
 
-#### **Snap**
+### Snap
 
 Task is available in [Snapcraft][snapcraft], but keep in mind that your
 Linux distribution should allow classic confinement for Snaps to Task work
@@ -25,20 +28,31 @@ right:
 sudo snap install task --classic
 ```
 
-#### **Scoop**
+### Chocolatey
 
-If you're on Windows and have [Scoop][scoop] installed, use `extras` bucket
-to install Task like:
+If you're on Windows and have [Chocolatey][choco] installed, getting
+Task is as simple as running:
+
+```bash
+choco install go-task
+```
+
+This installation method is community owned.
+
+
+### Scoop
+
+If you're on Windows and have [Scoop][scoop] installed, getting
+Task is as simple as running:
 
 ```cmd
-scoop bucket add extras
 scoop install task
 ```
 
 This installation method is community owned. After a new release of Task, it
 may take some time until it's available on Scoop.
 
-#### **AUR**
+### AUR
 
 If you're on Arch Linux you can install Task from
 [AUR](https://aur.archlinux.org/packages/taskfile-git) using your favorite
@@ -51,13 +65,33 @@ yay -S taskfile-git
 This installation method is community owned, but since it's `-git` version of
 the package, it's always latest available version based on the Git repository.
 
-<!-- tabs:end -->
+### Fedora
+
+If you're on Fedora Linux you can install Task from the official
+[Fedora](https://packages.fedoraproject.org/pkgs/golang-github-task/go-task/) repository using `dnf`:
+
+```cmd
+sudo dnf install go-task
+```
+
+This installation method is community owned. After a new release of Task, it
+may take some time until it's available in [Fedora](https://packages.fedoraproject.org/pkgs/golang-github-task/go-task/).
+
+### Nix
+
+If you're on NixOS or have Nix installed
+you can install Task from [nixpkgs](https://github.com/NixOS/nixpkgs):
+
+```cmd
+nix-env -iA nixpkgs.go-task
+```
+
+This installation method is community owned. After a new release of Task, it
+may take some time until it's available in [nixpkgs](https://github.com/NixOS/nixpkgs).
 
 ## Get The Binary
 
-<!-- tabs:start -->
-
-#### **Binary**
+### Binary
 
 You can download the binary from the [releases page on GitHub][releases] and
 add to your `$PATH`.
@@ -66,7 +100,7 @@ DEB and RPM packages are also available.
 
 The `task_checksums.txt` file contains the SHA-256 checksum for each file.
 
-#### **Install Script**
+### Install Script
 
 We also have an [install script][installscript] which is very useful in
 scenarios like CI. Many thanks to [GoDownloader][godownloader] for enabling the
@@ -82,9 +116,13 @@ sh -c "$(curl --location https://taskfile.dev/install.sh)" -- -d -b /usr/local/b
 
 ```
 
-> This method will download the binary on the local `./bin` directory by default.
+:::info
 
-#### **GitHub Actions**
+This method will download the binary on the local `./bin` directory by default.
+
+:::
+
+### GitHub Actions
 
 If you want to install Task in GitHub Actions you can try using
 [this action](https://github.com/arduino/setup-task)
@@ -97,13 +135,9 @@ by the Arduino team:
 
 This installation method is community owned.
 
-<!-- tabs:end -->
-
 ## Build From Source
 
-<!-- tabs:start -->
-
-#### **Go Modules**
+### Go Modules
 
 First, make sure you have [Go][go] properly installed and setup.
 
@@ -125,11 +159,13 @@ If using Go 1.15 or earlier, instead use:
 env GO111MODULE=on go get -u github.com/go-task/task/v3/cmd/task@latest
 ```
 
-> For CI environments we recommend using the [Install Script](#get-the-binary)
-> instead, which is faster and more stable, since it'll just download the latest
-> released binary.
+:::tip
 
-<!-- tabs:end -->
+For CI environments we recommend using the [install script](#get-the-binary)
+instead, which is faster and more stable, since it'll just download the latest
+released binary.
+
+:::
 
 [go]: https://golang.org/
 [snapcraft]: https://snapcraft.io/task
@@ -137,4 +173,5 @@ env GO111MODULE=on go get -u github.com/go-task/task/v3/cmd/task@latest
 [installscript]: https://github.com/go-task/task/blob/master/install-task.sh
 [releases]: https://github.com/go-task/task/releases
 [godownloader]: https://github.com/goreleaser/godownloader
+[choco]: https://chocolatey.org/
 [scoop]: https://scoop.sh/

docs/docs/intro.md

@@ -1,7 +1,13 @@
+---
+slug: /
+sidebar_position: 1
+title: Home
+---
+
 # Task
 
 <div align="center">
-  <img id="logo" src="/Logo.png" height="250px" width="250px" />
+  <img id="logo" src="img/logo.svg" height="250px" width="250px" />
 </div>
 
 Task is a task runner / build tool that aims to be simpler and easier to use
@@ -14,7 +20,7 @@ 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
+```yaml title="Taskfile.yml"
 version: '3'
 
 tasks:
@@ -24,28 +30,28 @@ tasks:
     silent: true
 ```
 
-And call it by running `task hello` from you terminal.
+And call it by running `task hello` from your terminal.
 
-The above example is just the start, you can take a look at the [usage](usage.md)
+The above example is just the start, you can take a look at the [usage](/usage)
 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;
+  `$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)
+  Task also supports Windows thanks to [this shell interpreter for Go][sh].
+- Great for code generation: you can easily [prevent a task from running](/usage#prevent-unnecessary-work)
   if a given set of files haven't changed since last run (based either on its
   timestamp or content).
 
 [make]: https://www.gnu.org/software/make/
-[go]: https://golang.org/
+[go]: https://go.dev/
 [yaml]: http://yaml.org/
 [homebrew]: https://brew.sh/
 [snapcraft]: https://snapcraft.io/
 [scoop]: https://scoop.sh/
-[sh]: https://mvdan.cc/sh
+[sh]: https://github.com/mvdan/sh

docs/docs/releasing.md

@@ -1,4 +1,9 @@
-# Releasing Task
+---
+slug: /releasing/
+sidebar_position: 7
+---
+
+# Releasing
 
 The release process of Task is done with the help of
 [GoReleaser][goreleaser]. You can test the release process locally by calling
@@ -20,9 +25,9 @@ The exception is the publishing of a new version of the
 [snap package][snappackage]. This current require two steps after publishing
 the binaries:
 
-* Updating the current version on [snapcraft.yaml][snapcraftyaml];
-* Moving both `i386` and `amd64` new artifacts to the stable channel on
-the [Snapcraft dashboard][snapcraftdashboard]
+* Updating the current version on [snapcraft.yaml][snapcraftyaml].
+* Moving both `amd64`, `armhf` and `arm64` new artifacts to the stable channel on
+the [Snapcraft dashboard][snapcraftdashboard].
 
 # Scoop
 
@@ -31,7 +36,14 @@ of updating versions there by editing
 [this file](https://github.com/lukesampson/scoop-extras/blob/master/bucket/task.json).
 If you think its Task version is outdated, open an issue to let us know.
 
-[goreleaser]: https://goreleaser.com/#continuous_integration
+# Nix
+
+Nix is a community owned installation method. Nix package maintainers usually take care
+of updating versions there by editing
+[this file](https://github.com/NixOS/nixpkgs/blob/nixos-unstable/pkgs/development/tools/go-task/default.nix).
+If you think its Task version is outdated, open an issue to let us know.
+
+[goreleaser]: https://goreleaser.com/
 [homebrewtap]: https://github.com/go-task/homebrew-tap
 [gotaskrb]: https://github.com/go-task/homebrew-tap/blob/master/Formula/go-task.rb
 [snappackage]: https://github.com/go-task/snap

docs/docs/styleguide.md

@@ -1,11 +1,16 @@
+---
+slug: /styleguide/
+sidebar_position: 5
+---
+
 # Styleguide
 
 This is the official Task styleguide for `Taskfile.yml` files. This guide
 contains some basic instructions to keep your Taskfile clean and familiar to
 other users.
 
-This contains general guidelines, but don't necessarely need to be strictly
-followed. Feel free to disagree and proceed differently in some point if you
+This contains general guidelines, but they don't necessarily need to be strictly
+followed. Feel free to disagree and proceed differently at some point if you
 need or want to. Also, feel free to open issues or pull requests with
 improvements to this guide.
 
@@ -28,9 +33,9 @@ officially supported. On Linux, only `Taskfile.yml` will work, though.
 
 - `version:`
 - `includes:`
-- Configuration ones, like `output:` or `silent:`
+- Configuration ones, like `output:`, `silent:`, `method:` and `run:`
 - `vars:`
-- `env:`
+- `env:`, `dotenv:`
 - `tasks:`
 
 ## Use 2 spaces for indentation

docs/docs/taskfile_versions.md

@@ -1,3 +1,8 @@
+---
+slug: /taskfile-versions/
+sidebar_position: 8
+---
+
 # Taskfile Versions
 
 The Taskfile syntax and features changed with time. This document explains what

docs/docs/usage.md

@@ -1,3 +1,8 @@
+---
+slug: /usage/
+sidebar_position: 3
+---
+
 # Usage
 
 ## Getting started
@@ -26,13 +31,27 @@ Running the tasks is as simple as running:
 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
+Task uses [mvdan.cc/sh](https://mvdan.cc/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.
 
+## Supported file names
+
+Task will look for the following file names, in order of priority:
+
+- Taskfile.yml
+- Taskfile.yaml
+- Taskfile.dist.yml
+- Taskfile.dist.yaml
+
+The intention of having the `.dist` variants is to allow projects to have one
+committed version (`.dist`) while still allowing individual users to override
+the Taskfile by adding an additional `Taskfile.yml` (which would be on
+`.gitignore`).
+
 ## Environment variables
 
 ### Task
@@ -50,7 +69,7 @@ tasks:
       GREETING: Hey, there!
 ```
 
-Additionally, you can set globally environment variables, that'll be available
+Additionally, you can set global environment variables that will be available
 to all tasks:
 
 ```yaml
@@ -65,27 +84,27 @@ tasks:
       - echo $GREETING
 ```
 
-> NOTE: `env` supports expansion and retrieving output from a shell command
-> just like variables, as you can see on the [Variables](#variables) section.
+:::info
+
+`env` supports expansion and retrieving output from a shell command
+just like variables, as you can see in the [Variables](#variables) section.
+
+:::
 
 ### .env files
 
 You can also ask Task to include `.env` like files by using the `dotenv:`
 setting:
 
-```
-# .env
+```bash title=".env"
 KEYNAME=VALUE
 ```
 
-```
-# testing/.env
+```bash title="testing/.env"
 ENDPOINT=testing.com
 ```
 
-```yaml
-# Taskfile.yml
-
+```yaml title="Taskfile.yml"
 version: '3'
 
 env:
@@ -134,7 +153,7 @@ includes:
 
 ### Directory of included Taskfile
 
-By default, included Taskfile's tasks are ran in the current directory, even
+By default, included Taskfile's tasks are run in the current directory, even
 if the Taskfile is in another directory, but you can force its tasks to run
 in another directory by using this alternative syntax:
 
@@ -147,12 +166,12 @@ includes:
     dir: ./docs
 ```
 
-> The included Taskfiles must be using the same schema version the main
-> Taskfile uses.
+:::info
 
-> 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. =)
+The included Taskfiles must be using the same schema version as the main
+Taskfile uses.
+
+:::
 
 ### Optional includes
 
@@ -173,10 +192,39 @@ tasks:
       - echo "This command can still be successfully executed if ./tests/Taskfile.yml does not exist"
 ```
 
+### Vars of included Taskfiles
+
+You can also specify variables when including a Taskfile. This may be useful
+for having reusable Taskfile that can be tweaked or even included more than once:
+
+```yaml
+version: '3'
+
+includes:
+  backend:
+    taskfile: ./taskfiles/Docker.yml
+    vars:
+      DOCKER_IMAGE: backend_image
+
+  frontend:
+    taskfile: ./taskfiles/Docker.yml
+    vars:
+      DOCKER_IMAGE: frontend_image
+```
+
+:::info
+
+Vars declared in the included Taskfile have preference over the
+included ones! If you want a variable in an included Taskfile to be overridable,
+use the [default function](https://go-task.github.io/slim-sprig/defaults.html):
+`MY_VAR: '{{.MY_VAR | default "my-default-value"}}'`.
+
+:::
+
 ## 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
+located. But you can easily make the task run in another folder, informing
 `dir`:
 
 ```yaml
@@ -190,12 +238,12 @@ tasks:
       - caddy
 ```
 
-If the directory doesn't exist, `task` creates it.
+If the directory does not exist, `task` creates it.
 
 ## Task dependencies
 
-> Dependencies run in parallel, so dependencies of a task shouldn't depend one
-> another. If you want to force tasks to run serially take a look at the
+> Dependencies run in parallel, so dependencies of a task should not depend one
+> another. If you want to force tasks to run serially, take a look at the
 > [Calling Another Task](#calling-another-task) section below.
 
 You may have tasks that depend on others. Just pointing them on `deps` will
@@ -239,8 +287,12 @@ tasks:
 If there is more than one dependency, they always run in parallel for better
 performance.
 
-> You can also make the tasks given by the command line run in parallel by
-> using the `--parallel` flag (alias `-p`). Example: `task --parallel js css`.
+:::tip
+
+You can also make the tasks given by the command line run in parallel by
+using the `--parallel` flag (alias `-p`). Example: `task --parallel js css`.
+
+:::
 
 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):
@@ -266,8 +318,8 @@ tasks:
 ## 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:
+often result in a faster build pipeline. However, in some situations, you may need
+to call other tasks serially. In this case, use the following syntax:
 
 ```yaml
 version: '3'
@@ -309,16 +361,20 @@ tasks:
 
 The above syntax is also supported in `deps`.
 
-> NOTE: If you want to call a task declared in the root Taskfile from within an
-> [included Taskfile](#including-other-taskfiles), add a leading `:` like this:
-> `task: :task-name`.
+:::tip
+
+NOTE: If you want to call a task declared in the root Taskfile from within an
+[included Taskfile](#including-other-taskfiles), add a leading `:` like this:
+`task: :task-name`.
+
+:::
 
 ## Prevent unnecessary work
 
 ### By fingerprinting locally generated files and their sources
 
 If a task generates something, you can inform Task the source and generated
-files, so Task will prevent to run them if not necessary.
+files, so Task will prevent running them if not necessary.
 
 ```yaml
 version: '3'
@@ -350,8 +406,6 @@ tasks:
 Task will compare the checksum of the source 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`.
-You will probably want to ignore the `.task` folder in your `.gitignore` file
-(It's there that Task stores the last checksum).
 
 If you prefer this check to be made by the modification timestamp of the files,
 instead of its checksum (content), just set the `method` property to `timestamp`.
@@ -367,14 +421,56 @@ tasks:
       - ./*.go
     generates:
       - app{{exeExt}}
-    method: checksum
+    method: timestamp
 ```
 
-> TIP: method `none` skips any validation and always run the task.
+:::info
 
-> NOTE: for the `checksum` (default) method to work, it's only necessary to
-> inform the source files, but if you want to use the `timestamp` method, you
-> also need to inform the generated files with `generates`.
+By default, task stores checksums on a local `.task` directory in the project's
+directory. Most of the time, you'll want to have this directory on `.gitignore`
+(or equivalent) so it isn't committed. (If you have a task for code generation
+that is committed it may make sense to commit the checksum of that task as
+well, though).
+
+If you want these files to be stored in another directory, you can set a
+`TASK_TEMP_DIR` environment variable in your machine. It can contain a relative
+path like `tmp/task` that will be interpreted as relative to the project
+directory, or an absolute or home path like `/tmp/.task` or `~/.task`
+(subdirectories will be created for each project).
+
+```bash
+export TASK_TEMP_DIR='~/.task'
+```
+
+:::
+
+:::info
+
+Each task has only one checksum stored for its `sources`. If you want
+to distinguish a task by any of its input variables, you can add those
+variables as part of the task's label, and it will be considered a different
+task.
+
+This is useful if you want to run a task once for each distinct set of
+inputs until the sources actually change. For example, if the sources depend
+on the value of a variable, or you if you want the task to rerun if some arguments
+change even if the source has not.
+
+:::
+
+:::tip
+
+The method `none` skips any validation and always run the task.
+
+:::
+
+:::info
+
+For the `checksum` (default) method to work, it is only necessary to
+inform the source files, but if you want to use the `timestamp` method, you
+also need to inform the generated files with `generates`.
+
+:::
 
 ### Using programmatic checks to indicate a task is up to date.
 
@@ -418,13 +514,13 @@ 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.
 
-### Using programmatic checks to cancel execution of an task and it's dependencies
+### Using programmatic checks to cancel the execution of a task and its dependencies
 
-In addition to `status` checks, there are also `preconditions` checks, which are
+In addition to `status` checks, `preconditions` checks are
 the logical inverse of `status` checks.  That is, if you need a certain set of
 conditions to be _true_ you can use the `preconditions` stanza.
-`preconditions` are similar to `status` lines except they support `sh`
-expansion and they SHOULD all return 0.
+`preconditions` are similar to `status` lines, except they support `sh`
+expansion, and they SHOULD all return 0.
 
 ```yaml
 version: '3'
@@ -450,7 +546,7 @@ precondition is not met - the calling task will fail.  Note that a task
 executed with a failing precondition will not run unless `--force` is
 given.
 
-Unlike `status` which will skip a task if it is up to date, and continue
+Unlike `status`, which will skip a task if it is up to date and continue
 executing tasks that depend on it, a `precondition` will fail a task, along
 with any other tasks that depend on it.
 
@@ -516,11 +612,13 @@ tasks:
 ## 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):
+They are listed below in order of importance (i.e. most important first):
 
 - Variables declared in the task definition
 - Variables given while calling a task from another
   (See [Calling another task](#calling-another-task) above)
+- Variables of the [included Taskfile](#including-other-taskfiles) (when the task is included)
+- Variables of the [inclusion of the Taskfile](#vars-of-included-taskfiles) (when the task is included)
 - Global variables (those declared in the `vars:` option in the Taskfile)
 - Environment variables
 
@@ -530,10 +628,14 @@ Example of sending parameters with environment variables:
 $ TASK_VARIABLE=a-value task do-something
 ```
 
-> TIP: A special variable `.TASK` is always available containing the task name.
+:::tip
 
-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
+A special variable `.TASK` is always available containing the task name.
+
+:::
+
+Since some shells do not support the above syntax to set environment variables
+(Windows) tasks also accept a similar style when not at the beginning of
 the command.
 
 ```bash
@@ -570,7 +672,7 @@ tasks:
 ### 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
+The value will be treated as a command and the output assigned. If there are one
 or more trailing newlines, the last newline will be trimmed.
 
 ```yaml
@@ -589,7 +691,7 @@ This works for all types of variables.
 
 ## Forwarding CLI arguments to commands
 
-If `--` is given in the CLI, all following paramaters are added to a
+If `--` is given in the CLI, all following parameters are added to a
 special `.CLI_ARGS` variable. This is useful to forward arguments to another
 command.
 
@@ -608,6 +710,49 @@ tasks:
       - yarn {{.CLI_ARGS}}
 ```
 
+## Doing task cleanup with `defer`
+
+With the `defer` keyword, it's possible to schedule cleanup to be run once
+the task finishes. The difference with just putting it as the last command is
+that this command will run even when the task fails.
+
+In the example below, `rm -rf tmpdir/` will run even if the third command fails:
+
+```yaml
+version: '3'
+
+tasks:
+  default:
+    cmds:
+      - mkdir -p tmpdir/
+      - defer: rm -rf tmpdir/
+      - echo 'Do work on tmpdir/'
+```
+
+If you want to move the cleanup command into another task, that is possible as
+well:
+
+```yaml
+version: '3'
+
+tasks:
+  default:
+    cmds:
+      - mkdir -p tmpdir/
+      - defer: { task: cleanup }
+      - echo 'Do work on tmpdir/'
+
+  cleanup: rm -rf tmpdir/
+```
+
+:::info
+
+Due to the nature of how the
+[Go's own `defer` work](https://go.dev/tour/flowcontrol/13), the deferred
+commands are executed in the reverse order if you schedule multiple of them.
+
+:::
+
 ## Go's template engine
 
 Task parse commands as [Go's template engine][gotemplate] before executing
@@ -627,7 +772,7 @@ tasks:
 
 Task also adds the following functions:
 
-- `OS`: Returns operating system. Possible values are "windows", "linux",
+- `OS`: Returns the operating system. Possible values are "windows", "linux",
   "darwin" (macOS) and "freebsd".
 - `ARCH`: return the architecture Task was compiled to: "386", "amd64", "arm"
   or "s390x".
@@ -639,6 +784,9 @@ Task also adds the following functions:
   converts a string from `/` path format to `\`.
 - `exeExt`: Returns the right executable extension for the current OS
   (`".exe"` for Windows, `""` for others).
+- `shellQuote`: Quotes a string to make it safe for use in shell scripts.
+  Task uses [this Go function](https://pkg.go.dev/mvdan.cc/sh/v3@v3.4.0/syntax#Quote)
+  for this. The Bash dialect is assumed.
 
 Example:
 
@@ -700,6 +848,8 @@ would print the following output:
 * test:    Run all the go tests.
 ```
 
+If you want to see all tasks, there's a `--list-all` (alias `-a`) flag as well.
+
 ## Display summary of task
 
 Running `task --summary task-name` will show a summary of a task.
@@ -747,8 +897,8 @@ Please note: *showing the summary will not execute the command*.
 
 ## Overriding task name
 
-Sometimes you may want to override the task name print on summary, up-to-date
-messages to STDOUT, etc. In this case you can just set `label:`, which can also
+Sometimes you may want to override the task name printed on the summary, up-to-date
+messages to STDOUT, etc. In this case, you can just set `label:`, which can also
 be interpolated with variables:
 
 ```yaml
@@ -771,7 +921,7 @@ tasks:
 
 ## Silent mode
 
-Silent mode disables echoing of commands before Task runs it.
+Silent mode disables the echoing of commands before Task runs it.
 For the following Taskfile:
 
 ```yaml
@@ -783,14 +933,14 @@ tasks:
       - echo "Print something"
 ```
 
-Normally this will be print:
+Normally this will be printed:
 
 ```sh
 echo "Print something"
 Print something
 ```
 
-With silent mode on, the below will be print instead:
+With silent mode on, the below will be printed instead:
 
 ```sh
 Print something
@@ -869,7 +1019,7 @@ tasks:
 ```
 
 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`:
+However, it is possible to continue with execution using `ignore_error`:
 
 ```yaml
 version: '3'
@@ -882,16 +1032,16 @@ tasks:
       - echo "Hello World"
 ```
 
-`ignore_error` can also be set for a task, which mean errors will be suppressed
-for all commands. But keep in mind this option won't propagate to other tasks
+`ignore_error` can also be set for a task, which means errors will be suppressed
+for all commands. Nevertheless, keep in mind that this option will not 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
+By default, Task just redirects the STDOUT and STDERR of the running commands
+to the shell in real-time. This is good for having live feedback for logging
 printed by commands, but the output can become messy if you have multiple
-commands running at the same time and printing lots of stuff.
+commands running simultaneously and printing lots of stuff.
 
 To make this more customizable, there are currently three different output
 options you can choose:
@@ -911,13 +1061,41 @@ 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 `group` output will print the entire output of a command once after it
+finishes, so you will not 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:
+When using the `group` output, you can optionally provide a templated message
+to print at the start and end of the group. This can be useful for instructing
+CI systems to group all of the output for a given task, such as with
+[GitHub Actions' `::group::` command](https://docs.github.com/en/actions/learn-github-actions/workflow-commands-for-github-actions#grouping-log-lines)
+or [Azure Pipelines](https://docs.microsoft.com/en-us/azure/devops/pipelines/scripts/logging-commands?expand=1&view=azure-devops&tabs=bash#formatting-commands).
+
+```yaml
+version: '3'
+
+output:
+  group:
+    begin: '::group::{{.TASK}}'
+    end: '::endgroup::'
+
+tasks:
+  default:
+    cmds:
+      - echo 'Hello, World!'
+    silent: true
+```
+
+```bash
+$ task default
+::group::default
+Hello, World!
+::endgroup::
+```
+
+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: '3'
@@ -948,28 +1126,33 @@ $ task default
 [print-baz] baz
 ```
 
-> The `output` option can also be specified by the `--output` or `-o` flags.
+:::tip
+
+The `output` option can also be specified by the `--output` or `-o` flags.
+
+:::
 
 ## Interactive CLI application
 
 When running interactive CLI applications inside Task they can sometimes behave
-weirdly, specially when the [output mode](#output-syntax) is set to something
-other than `interleaved` (the default), or when interactive apps are ran in
+weirdly, especially when the [output mode](#output-syntax) is set to something
+other than `interleaved` (the default), or when interactive apps are run in
 parallel with other tasks.
 
-The `interactive: true` tells Task this is an interactive application, and Task
+The `interactive: true` tells Task this is an interactive application and Task
 will try to optimize for it:
 
 ```yaml
 version: '3'
 
 tasks:
-  cmds:
-    - vim my-file.txt
-  interactive: true
+  default:
+    cmds:
+      - vim my-file.txt
+    interactive: true
 ```
 
-If you still have problem running an interactive app through Task, please open
+If you still have problems running an interactive app through Task, please open
 an issue about it.
 
 ## Short task syntax

docs/docusaurus.config.js

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

docs/index.html

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

docs/package.json

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

docs/prettier.config.js

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

docs/sidebars.js

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

docs/src/css/carbon.css

@@ -0,0 +1,65 @@
+#carbonads * {
+  margin: initial;
+  padding: initial;
+}
+#carbonads {
+  display: flex;
+  max-width: 330px;
+  background-color: hsl(0, 0%, 98%);
+  box-shadow: 0 1px 4px 1px hsla(0, 0%, 0%, 0.1);
+  z-index: 100;
+}
+#carbonads a {
+  color: inherit;
+  text-decoration: none;
+}
+#carbonads a:hover {
+  color: inherit;
+}
+#carbonads span {
+  position: relative;
+  display: block;
+  overflow: hidden;
+}
+#carbonads .carbon-wrap {
+  display: flex;
+}
+#carbonads .carbon-img {
+  display: block;
+  margin: 0;
+  line-height: 1;
+}
+#carbonads .carbon-img img {
+  display: block;
+}
+#carbonads .carbon-text {
+  font-size: 13px;
+  padding: 10px;
+  margin-bottom: 16px;
+  line-height: 1.5;
+  text-align: left;
+}
+#carbonads .carbon-poweredby {
+  display: block;
+  padding: 6px 8px;
+  background: #f1f1f2;
+  text-align: center;
+  text-transform: uppercase;
+  letter-spacing: 0.5px;
+  font-weight: 600;
+  font-size: 8px;
+  line-height: 1;
+  border-top-left-radius: 3px;
+  position: absolute;
+  bottom: 0;
+  right: 0;
+}
+
+[data-theme='dark'] #carbonads {
+  background-color: hsl(0, 0%, 35%);
+  box-shadow: 0 1px 4px 1px hsl(0, 0%, 55%);
+}
+
+[data-theme='dark'] #carbonads .carbon-poweredby {
+  background-color: hsl(0, 0%, 55%);
+}

docs/src/css/custom.css

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

docs/static/CNAME

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

docs/static/img/logo.svg

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

docs/static/img/logo_mono.svg

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

docs/static/js/carbon.js

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

errors.go

@@ -3,6 +3,8 @@ package task
 import (
 	"errors"
 	"fmt"
+
+	"mvdan.cc/sh/v3/interp"
 )
 
 var (
@@ -18,15 +20,23 @@ func (err *taskNotFoundError) Error() string {
 	return fmt.Sprintf(`task: Task "%s" not found`, err.taskName)
 }
 
-type taskRunError struct {
+type TaskRunError struct {
 	taskName string
 	err      error
 }
 
-func (err *taskRunError) Error() string {
+func (err *TaskRunError) Error() string {
 	return fmt.Sprintf(`task: Failed to run task "%s": %v`, err.taskName, err.err)
 }
 
+func (err *TaskRunError) ExitCode() int {
+	if c, ok := interp.IsExitStatus(err.err); ok {
+		return int(c)
+	}
+
+	return 1
+}
+
 // MaximumTaskCallExceededError is returned when a task is called too
 // many times. In this case you probably have a cyclic dependendy or
 // infinite loop

go.mod

@@ -8,10 +8,20 @@ require (
 	github.com/mitchellh/hashstructure/v2 v2.0.2
 	github.com/radovskyb/watcher v1.0.7
 	github.com/spf13/pflag v1.0.5
-	github.com/stretchr/testify v1.7.0
+	github.com/stretchr/testify v1.8.0
 	golang.org/x/sync v0.0.0-20210220032951-036812b2e83c
-	gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c
-	mvdan.cc/sh/v3 v3.3.1
+	gopkg.in/yaml.v3 v3.0.1
+	mvdan.cc/sh/v3 v3.6.0-0.dev.0.20220704111049-a6e3029cd899
 )
 
-go 1.16
+require (
+	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/mattn/go-colorable v0.1.9 // indirect
+	github.com/mattn/go-isatty v0.0.14 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
+	golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e // indirect
+	golang.org/x/term v0.0.0-20210927222741-03fcf44c2211 // indirect
+	gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 // indirect
+)
+
+go 1.17

go.sum

@@ -1,6 +1,6 @@
 github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
-github.com/creack/pty v1.1.13 h1:rTPnd/xocYRjutMfqide2zle1u96upp1gm6eUHKi7us=
-github.com/creack/pty v1.1.13/go.mod h1:MOBLtS5ELjhRRrroQr9kyvTxUAFNvYEK993ew/Vr4O4=
+github.com/creack/pty v1.1.17 h1:QeVUsEDNrLBW4tMgZHvxy18sKtr6VI492kBhUfhDJNI=
+github.com/creack/pty v1.1.17/go.mod h1:MOBLtS5ELjhRRrroQr9kyvTxUAFNvYEK993ew/Vr4O4=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
@@ -9,14 +9,18 @@ github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSs
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/fatih/color v1.13.0 h1:8LOYc1KYPPmyKMuN8QV2DNRWNbLo6LZ0iLs8+mlH53w=
 github.com/fatih/color v1.13.0/go.mod h1:kLAiJbzzSOZDVNGyDpeOxJ47H46qBXwg5ILebYFFOfk=
+github.com/frankban/quicktest v1.14.0 h1:+cqqvzZV87b4adx/5ayVOaYZ2CrvM4ejQvUdBzPPUss=
+github.com/frankban/quicktest v1.14.0/go.mod h1:NeW+ay9A/U67EYXNFA1nPE8e/tnQv/09mUdL/ijj8og=
 github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0 h1:p104kn46Q8WdvHunIJ9dAyjPVtrBPhSr3KT2yUst43I=
 github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0/go.mod h1:fyg7847qk6SyHyPtNmDHnmrv/HOrqktSC+C9fM+CJOE=
+github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ=
+github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/renameio v1.0.1/go.mod h1:t/HQoYBZSsWSNK35C6CO/TpPLDVWvxOHboWUAweKUpk=
 github.com/joho/godotenv v1.4.0 h1:3l4+N6zfMWnkbPEXKng2o2/MR5mSwTrBih4ZEkkz1lg=
 github.com/joho/godotenv v1.4.0/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
-github.com/kr/pretty v0.2.1 h1:Fmg33tUaq4/8ym9TJN1x7sLJnHVwhP33CNkpYV/7rwI=
-github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
+github.com/kr/pretty v0.3.0 h1:WgNl7dwNpEZ6jJ9k1snq4pZsg7DOEN8hP9Xw0Tsjwk0=
+github.com/kr/pretty v0.3.0/go.mod h1:640gp4NfQd8pI5XOwp5fnNeVWj67G7CFk/SaSQn7NBk=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
@@ -35,29 +39,38 @@ 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.0/go.mod h1:WmiCO8CzOY8rg0OYDC4/i/2WRWAB6poM+XZ2dLUbcbE=
+github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
+github.com/rogpeppe/go-internal v1.8.1 h1:geMPLpDpQOgVyCg5z5GoRwLHepNdb71NXb67XFkP+Eg=
+github.com/rogpeppe/go-internal v1.8.1/go.mod h1:JeRgkft04UBgHMgCIwADu4Pn6Mtm5d4nPKWu0nJ5d+o=
 github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
 github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
-github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
-github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PKk=
+github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
 golang.org/x/sync v0.0.0-20210220032951-036812b2e83c h1:5KslGYwFpkhGh+Q16bwMP3cOontH8FOep7tGV86Y7SQ=
 golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c h1:F1jZWGFhYfh0Ci55sIpILtKKK8p3i2/krTr0H1rg74I=
 golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/term v0.0.0-20210615171337-6886f2dfbf5b h1:9zKuko04nR4gjZ4+DNjHqRlAJqbJETHwiNKDqTfOjfE=
-golang.org/x/term v0.0.0-20210615171337-6886f2dfbf5b/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
+golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e h1:fLOSk5Q00efkSvAm+4xcoXD+RRmLmmulPn5I3Y9F2EM=
+golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/term v0.0.0-20210927222741-03fcf44c2211 h1:JGgROgKl9N8DuW20oFS5gxc+lE67/N3FcwmBPMe7ArY=
+golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 mvdan.cc/editorconfig v0.2.0/go.mod h1:lvnnD3BNdBYkhq+B4uBuFFKatfp02eB6HixDvEz91C0=
-mvdan.cc/sh/v3 v3.3.1 h1:aA0i7NZOc1oV5jfAH20FCz+QsmI/TX7FiAquC5Rdo5o=
-mvdan.cc/sh/v3 v3.3.1/go.mod h1:DpbFT2B4fXpKiq69fEoMe+71JrmUn5aUekYy9fNKnQw=
+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=

help.go

@@ -2,18 +2,41 @@ package task
 
 import (
 	"fmt"
+	"io"
+	"log"
+	"os"
 	"sort"
+	"strings"
 	"text/tabwriter"
 
 	"github.com/go-task/task/v3/internal/logger"
 	"github.com/go-task/task/v3/taskfile"
 )
 
-// PrintTasksHelp prints help os tasks that have a description
-func (e *Executor) PrintTasksHelp() {
-	tasks := e.tasksWithDesc()
+// ListTasksWithDesc reports tasks that have a description spec.
+func (e *Executor) ListTasksWithDesc() {
+	e.printTasks(false)
+}
+
+// ListAllTasks reports all tasks, with or without a description spec.
+func (e *Executor) ListAllTasks() {
+	e.printTasks(true)
+}
+
+func (e *Executor) printTasks(listAll bool) {
+	var tasks []*taskfile.Task
+	if listAll {
+		tasks = e.allTaskNames()
+	} else {
+		tasks = e.tasksWithDesc()
+	}
+
 	if len(tasks) == 0 {
-		e.Logger.Outf(logger.Yellow, "task: No tasks with description available")
+		if listAll {
+			e.Logger.Outf(logger.Yellow, "task: No tasks available")
+		} else {
+			e.Logger.Outf(logger.Yellow, "task: No tasks with description available. Try --list-all to list all tasks")
+		}
 		return
 	}
 	e.Logger.Outf(logger.Default, "task: Available tasks for this project:")
@@ -26,6 +49,15 @@ func (e *Executor) PrintTasksHelp() {
 	w.Flush()
 }
 
+func (e *Executor) allTaskNames() (tasks []*taskfile.Task) {
+	tasks = make([]*taskfile.Task, 0, len(e.Taskfile.Tasks))
+	for _, task := range e.Taskfile.Tasks {
+		tasks = append(tasks, task)
+	}
+	sort.Slice(tasks, func(i, j int) bool { return tasks[i].Task < tasks[j].Task })
+	return
+}
+
 func (e *Executor) tasksWithDesc() (tasks []*taskfile.Task) {
 	tasks = make([]*taskfile.Task, 0, len(e.Taskfile.Tasks))
 	for _, task := range e.Taskfile.Tasks {
@@ -40,3 +72,33 @@ func (e *Executor) tasksWithDesc() (tasks []*taskfile.Task) {
 	sort.Slice(tasks, func(i, j int) bool { return tasks[i].Task < tasks[j].Task })
 	return
 }
+
+// PrintTaskNames prints only the task names in a Taskfile.
+// Only tasks with a non-empty description are printed if allTasks is false.
+// Otherwise, all task names are printed.
+func (e *Executor) ListTaskNames(allTasks bool) {
+	// if called from cmd/task.go, e.Taskfile has not yet been parsed
+	if e.Taskfile == nil {
+		if err := e.readTaskfile(); err != nil {
+			log.Fatal(err)
+			return
+		}
+	}
+	// use stdout if no output defined
+	var w io.Writer = os.Stdout
+	if e.Stdout != nil {
+		w = e.Stdout
+	}
+	// create a string slice from all map values (*taskfile.Task)
+	s := make([]string, 0, len(e.Taskfile.Tasks))
+	for _, t := range e.Taskfile.Tasks {
+		if allTasks || t.Desc != "" {
+			s = append(s, strings.TrimRight(t.Task, ":"))
+		}
+	}
+	// sort and print all task names
+	sort.Strings(s)
+	for _, t := range s {
+		fmt.Fprintln(w, t)
+	}
+}

init.go

@@ -3,7 +3,6 @@ package task
 import (
 	"fmt"
 	"io"
-	"io/ioutil"
 	"os"
 	"path/filepath"
 )
@@ -24,15 +23,15 @@ tasks:
 
 // InitTaskfile Taskfile creates a new Taskfile
 func InitTaskfile(w io.Writer, dir string) error {
-	f := filepath.Join(dir, "Taskfile.yml")
+	f := filepath.Join(dir, "Taskfile.yaml")
 
 	if _, err := os.Stat(f); err == nil {
 		return ErrTaskfileAlreadyExists
 	}
 
-	if err := ioutil.WriteFile(f, []byte(defaultTaskfile), 0644); err != nil {
+	if err := os.WriteFile(f, []byte(defaultTaskfile), 0644); err != nil {
 		return err
 	}
-	fmt.Fprintf(w, "Taskfile.yml created in the current directory\n")
+	fmt.Fprintf(w, "Taskfile.yaml created in the current directory\n")
 	return nil
 }

internal/compiler/v2/compiler_v2.go

@@ -71,7 +71,7 @@ func (vr *varResolver) merge(vars *taskfile.Vars) {
 		return
 	}
 	tr := templater.Templater{Vars: vr.vars}
-	vars.Range(func(k string, v taskfile.Var) error {
+	_ = vars.Range(func(k string, v taskfile.Var) error {
 		v = taskfile.Var{
 			Static: tr.Replace(v.Static),
 			Sh:     tr.Replace(v.Sh),

internal/compiler/v3/compiler_v3.go

@@ -74,12 +74,35 @@ func (c *CompilerV3) getVariables(t *taskfile.Task, call *taskfile.Call, evaluat
 	}
 	rangeFunc := getRangeFunc(c.Dir)
 
+	var taskRangeFunc func(k string, v taskfile.Var) error
+	if t != nil {
+		// NOTE(@andreynering): We're manually joining these paths here because
+		// this is the raw task, not the compiled one.
+		tr := templater.Templater{Vars: result, RemoveNoValue: true}
+		dir := tr.Replace(t.Dir)
+		if err := tr.Err(); err != nil {
+			return nil, err
+		}
+		if !filepath.IsAbs(dir) {
+			dir = filepath.Join(c.Dir, dir)
+		}
+		taskRangeFunc = getRangeFunc(dir)
+	}
+
 	if err := c.TaskfileEnv.Range(rangeFunc); err != nil {
 		return nil, err
 	}
 	if err := c.TaskfileVars.Range(rangeFunc); err != nil {
 		return nil, err
 	}
+	if t != nil {
+		if err := t.IncludedTaskfileVars.Range(taskRangeFunc); err != nil {
+			return nil, err
+		}
+		if err := t.IncludeVars.Range(rangeFunc); err != nil {
+			return nil, err
+		}
+	}
 
 	if t == nil || call == nil {
 		return result, nil
@@ -88,19 +111,6 @@ func (c *CompilerV3) getVariables(t *taskfile.Task, call *taskfile.Call, evaluat
 	if err := call.Vars.Range(rangeFunc); err != nil {
 		return nil, err
 	}
-
-	// NOTE(@andreynering): We're manually joining these paths here because
-	// this is the raw task, not the compiled one.
-	tr := templater.Templater{Vars: result, RemoveNoValue: true}
-	dir := tr.Replace(t.Dir)
-	if err := tr.Err(); err != nil {
-		return nil, err
-	}
-	if !filepath.IsAbs(dir) {
-		dir = filepath.Join(c.Dir, dir)
-	}
-	taskRangeFunc := getRangeFunc(dir)
-
 	if err := t.Vars.Range(taskRangeFunc); err != nil {
 		return nil, err
 	}
@@ -141,7 +151,8 @@ func (c *CompilerV3) HandleDynamicVar(v taskfile.Var, dir string) (string, error
 
 	// 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")
+	result := strings.TrimSuffix(stdout.String(), "\r\n")
+	result = strings.TrimSuffix(result, "\n")
 
 	c.dynamicCache[v.Sh] = result
 	c.Logger.VerboseErrf(logger.Magenta, `task: dynamic variable: '%s' result: '%s'`, v.Sh, result)

internal/execext/exec.go

@@ -7,6 +7,7 @@ import (
 	"os"
 	"path/filepath"
 	"strings"
+	"time"
 
 	"mvdan.cc/sh/v3/expand"
 	"mvdan.cc/sh/v3/interp"
@@ -47,14 +48,16 @@ func RunCommand(ctx context.Context, opts *RunCommandOptions) error {
 
 	r, err := interp.New(
 		interp.Params("-e"),
-		interp.Dir(opts.Dir),
 		interp.Env(expand.ListEnviron(environ...)),
+		interp.ExecHandler(interp.DefaultExecHandler(15*time.Second)),
 		interp.OpenHandler(openHandler),
 		interp.StdIO(opts.Stdin, opts.Stdout, opts.Stderr),
+		dirOption(opts.Dir),
 	)
 	if err != nil {
 		return err
 	}
+
 	return r.Run(ctx, p)
 }
 
@@ -87,3 +90,24 @@ func openHandler(ctx context.Context, path string, flag int, perm os.FileMode) (
 	}
 	return interp.DefaultOpenHandler()(ctx, path, flag, perm)
 }
+
+func dirOption(path string) interp.RunnerOption {
+	return func(r *interp.Runner) error {
+		err := interp.Dir(path)(r)
+		if err == nil {
+			return nil
+		}
+
+		// If the specified directory doesn't exist, it will be created later.
+		// Therefore, even if `interp.Dir` method returns an error, the
+		// directory path should be set only when the directory cannot be found.
+		if absPath, _ := filepath.Abs(path); absPath != "" {
+			if _, err := os.Stat(absPath); os.IsNotExist(err) {
+				r.Dir = absPath
+				return nil
+			}
+		}
+
+		return err
+	}
+}

internal/logger/logger.go

@@ -2,6 +2,8 @@ package logger
 
 import (
 	"io"
+	"os"
+	"strconv"
 
 	"github.com/fatih/color"
 )
@@ -9,13 +11,36 @@ import (
 type Color func() PrintFunc
 type PrintFunc func(io.Writer, string, ...interface{})
 
-func Default() PrintFunc { return color.New(color.Reset).FprintfFunc() }
-func Blue() PrintFunc    { return color.New(color.FgBlue).FprintfFunc() }
-func Green() PrintFunc   { return color.New(color.FgGreen).FprintfFunc() }
-func Cyan() PrintFunc    { return color.New(color.FgCyan).FprintfFunc() }
-func Yellow() PrintFunc  { return color.New(color.FgYellow).FprintfFunc() }
-func Magenta() PrintFunc { return color.New(color.FgMagenta).FprintfFunc() }
-func Red() PrintFunc     { return color.New(color.FgRed).FprintfFunc() }
+func Default() PrintFunc {
+	return color.New(envColor("TASK_COLOR_RESET", color.Reset)).FprintfFunc()
+}
+func Blue() PrintFunc {
+	return color.New(envColor("TASK_COLOR_BLUE", color.FgBlue)).FprintfFunc()
+}
+func Green() PrintFunc {
+	return color.New(envColor("TASK_COLOR_GREEN", color.FgGreen)).FprintfFunc()
+}
+func Cyan() PrintFunc {
+	return color.New(envColor("TASK_COLOR_CYAN", color.FgCyan)).FprintfFunc()
+}
+func Yellow() PrintFunc {
+	return color.New(envColor("TASK_COLOR_YELLOW", color.FgYellow)).FprintfFunc()
+}
+func Magenta() PrintFunc {
+	return color.New(envColor("TASK_COLOR_MAGENTA", color.FgMagenta)).FprintfFunc()
+}
+func Red() PrintFunc {
+	return color.New(envColor("TASK_COLOR_RED", color.FgRed)).FprintfFunc()
+}
+
+func envColor(env string, defaultColor color.Attribute) color.Attribute {
+	override, err := strconv.Atoi(os.Getenv(env))
+	if err == nil {
+		return color.Attribute(override)
+
+	}
+	return defaultColor
+}
 
 // Logger is just a wrapper that prints stuff to STDOUT or STDERR,
 // with optional color.

internal/output/group.go

@@ -5,22 +5,40 @@ import (
 	"io"
 )
 
-type Group struct{}
+type Group struct {
+	Begin, End string
+}
 
-func (Group) WrapWriter(w io.Writer, _ string) io.Writer {
-	return &groupWriter{writer: w}
+func (g Group) WrapWriter(stdOut, _ io.Writer, _ string, tmpl Templater) (io.Writer, io.Writer, CloseFunc) {
+	gw := &groupWriter{writer: stdOut}
+	if g.Begin != "" {
+		gw.begin = tmpl.Replace(g.Begin) + "\n"
+	}
+	if g.End != "" {
+		gw.end = tmpl.Replace(g.End) + "\n"
+	}
+	return gw, gw, func() error { return gw.close() }
 }
 
 type groupWriter struct {
-	writer io.Writer
-	buff   bytes.Buffer
+	writer     io.Writer
+	buff       bytes.Buffer
+	begin, end string
 }
 
 func (gw *groupWriter) Write(p []byte) (int, error) {
 	return gw.buff.Write(p)
 }
 
-func (gw *groupWriter) Close() error {
+func (gw *groupWriter) close() error {
+	if gw.buff.Len() == 0 {
+		// don't print begin/end messages if there's no buffered entries
+		return nil
+	}
+	if _, err := io.WriteString(gw.writer, gw.begin); err != nil {
+		return err
+	}
+	gw.buff.WriteString(gw.end)
 	_, err := io.Copy(gw.writer, &gw.buff)
 	return err
 }

internal/output/interleaved.go

@@ -6,6 +6,6 @@ import (
 
 type Interleaved struct{}
 
-func (Interleaved) WrapWriter(w io.Writer, _ string) io.Writer {
-	return w
+func (Interleaved) WrapWriter(stdOut, stdErr io.Writer, _ string, _ Templater) (io.Writer, io.Writer, CloseFunc) {
+	return stdOut, stdErr, func() error { return nil }
 }

internal/output/output.go

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

internal/output/output_test.go

@@ -6,6 +6,8 @@ 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"
@@ -14,7 +16,7 @@ import (
 func TestInterleaved(t *testing.T) {
 	var b bytes.Buffer
 	var o output.Output = output.Interleaved{}
-	var w = o.WrapWriter(&b, "")
+	var w, _, _ = o.WrapWriter(&b, io.Discard, "", nil)
 
 	fmt.Fprintln(w, "foo\nbar")
 	assert.Equal(t, "foo\nbar\n", b.String())
@@ -25,20 +27,58 @@ func TestInterleaved(t *testing.T) {
 func TestGroup(t *testing.T) {
 	var b bytes.Buffer
 	var o output.Output = output.Group{}
-	var w = o.WrapWriter(&b, "").(io.WriteCloser)
+	var stdOut, stdErr, cleanup = o.WrapWriter(&b, io.Discard, "", nil)
 
-	fmt.Fprintln(w, "foo\nbar")
+	fmt.Fprintln(stdOut, "out\nout")
 	assert.Equal(t, "", b.String())
-	fmt.Fprintln(w, "baz")
+	fmt.Fprintln(stdErr, "err\nerr")
 	assert.Equal(t, "", b.String())
-	assert.NoError(t, w.Close())
-	assert.Equal(t, "foo\nbar\nbaz\n", b.String())
+	fmt.Fprintln(stdOut, "out")
+	assert.Equal(t, "", b.String())
+	fmt.Fprintln(stdErr, "err")
+	assert.Equal(t, "", b.String())
+
+	assert.NoError(t, cleanup())
+	assert.Equal(t, "out\nout\nerr\nerr\nout\nerr\n", b.String())
+}
+
+func TestGroupWithBeginEnd(t *testing.T) {
+	tmpl := templater.Templater{
+		Vars: &taskfile.Vars{
+			Keys: []string{"VAR1"},
+			Mapping: map[string]taskfile.Var{
+				"VAR1": {Static: "example-value"},
+			},
+		},
+	}
+
+	var o output.Output = output.Group{
+		Begin: "::group::{{ .VAR1 }}",
+		End:   "::endgroup::",
+	}
+	t.Run("simple", func(t *testing.T) {
+		var b bytes.Buffer
+		var w, _, cleanup = o.WrapWriter(&b, io.Discard, "", &tmpl)
+
+		fmt.Fprintln(w, "foo\nbar")
+		assert.Equal(t, "", b.String())
+		fmt.Fprintln(w, "baz")
+		assert.Equal(t, "", b.String())
+		assert.NoError(t, cleanup())
+		assert.Equal(t, "::group::example-value\nfoo\nbar\nbaz\n::endgroup::\n", b.String())
+	})
+	t.Run("no output", func(t *testing.T) {
+		var b bytes.Buffer
+		var _, _, cleanup = o.WrapWriter(&b, io.Discard, "", &tmpl)
+		assert.NoError(t, cleanup())
+		assert.Equal(t, "", b.String())
+	})
 }
 
 func TestPrefixed(t *testing.T) {
 	var b bytes.Buffer
 	var o output.Output = output.Prefixed{}
-	var w = o.WrapWriter(&b, "prefix").(io.WriteCloser)
+	var w, _, cleanup = o.WrapWriter(&b, io.Discard, "prefix", nil)
 
 	t.Run("simple use cases", func(t *testing.T) {
 		b.Reset()
@@ -47,6 +87,7 @@ func TestPrefixed(t *testing.T) {
 		assert.Equal(t, "[prefix] foo\n[prefix] bar\n", b.String())
 		fmt.Fprintln(w, "baz")
 		assert.Equal(t, "[prefix] foo\n[prefix] bar\n[prefix] baz\n", b.String())
+		assert.NoError(t, cleanup())
 	})
 
 	t.Run("multiple writes for a single line", func(t *testing.T) {
@@ -57,7 +98,7 @@ func TestPrefixed(t *testing.T) {
 			assert.Equal(t, "", b.String())
 		}
 
-		assert.NoError(t, w.Close())
+		assert.NoError(t, cleanup())
 		assert.Equal(t, "[prefix] Test!\n", b.String())
 	})
 }

internal/output/prefixed.go

@@ -9,8 +9,9 @@ import (
 
 type Prefixed struct{}
 
-func (Prefixed) WrapWriter(w io.Writer, prefix string) io.Writer {
-	return &prefixWriter{writer: w, prefix: prefix}
+func (Prefixed) WrapWriter(stdOut, _ io.Writer, prefix string, _ Templater) (io.Writer, io.Writer, CloseFunc) {
+	pw := &prefixWriter{writer: stdOut, prefix: prefix}
+	return pw, pw, func() error { return pw.close() }
 }
 
 type prefixWriter struct {
@@ -28,7 +29,7 @@ func (pw *prefixWriter) Write(p []byte) (int, error) {
 	return n, pw.writeOutputLines(false)
 }
 
-func (pw *prefixWriter) Close() error {
+func (pw *prefixWriter) close() error {
 	return pw.writeOutputLines(true)
 }
 

internal/sleepit/main.go

@@ -0,0 +1,176 @@
+// 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
+}

internal/status/checksum.go

@@ -4,7 +4,6 @@ import (
 	"crypto/md5"
 	"fmt"
 	"io"
-	"io/ioutil"
 	"os"
 	"path/filepath"
 	"regexp"
@@ -14,7 +13,7 @@ import (
 // Checksum validades if a task is up to date by calculating its source
 // files checksum
 type Checksum struct {
-	BaseDir   string
+	TempDir   string
 	TaskDir   string
 	Task      string
 	Sources   []string
@@ -30,7 +29,7 @@ func (c *Checksum) IsUpToDate() (bool, error) {
 
 	checksumFile := c.checksumFilePath()
 
-	data, _ := ioutil.ReadFile(checksumFile)
+	data, _ := os.ReadFile(checksumFile)
 	oldMd5 := strings.TrimSpace(string(data))
 
 	sources, err := globs(c.TaskDir, c.Sources)
@@ -44,8 +43,8 @@ func (c *Checksum) IsUpToDate() (bool, error) {
 	}
 
 	if !c.Dry {
-		_ = os.MkdirAll(filepath.Join(c.BaseDir, ".task", "checksum"), 0755)
-		if err = ioutil.WriteFile(checksumFile, []byte(newMd5+"\n"), 0644); err != nil {
+		_ = os.MkdirAll(filepath.Join(c.TempDir, "checksum"), 0755)
+		if err = os.WriteFile(checksumFile, []byte(newMd5+"\n"), 0644); err != nil {
 			return false, err
 		}
 	}
@@ -108,7 +107,7 @@ func (*Checksum) Kind() string {
 }
 
 func (c *Checksum) checksumFilePath() string {
-	return filepath.Join(c.BaseDir, ".task", "checksum", c.normalizeFilename(c.Task))
+	return filepath.Join(c.TempDir, "checksum", c.normalizeFilename(c.Task))
 }
 
 var checksumFilenameRegexp = regexp.MustCompile("[^A-z0-9]")

internal/templater/funcs.go

@@ -6,7 +6,8 @@ import (
 	"strings"
 	"text/template"
 
-	"github.com/go-task/slim-sprig"
+	sprig "github.com/go-task/slim-sprig"
+	"mvdan.cc/sh/v3/syntax"
 )
 
 var (
@@ -37,6 +38,9 @@ func init() {
 			}
 			return ""
 		},
+		"shellQuote": func(str string) (string, error) {
+			return syntax.Quote(str, syntax.LangBash)
+		},
 		// IsSH is deprecated.
 		"IsSH": func() bool { return true },
 	}

internal/templater/templater.go

@@ -68,7 +68,7 @@ func (r *Templater) ReplaceVars(vars *taskfile.Vars) *taskfile.Vars {
 	}
 
 	var new taskfile.Vars
-	vars.Range(func(k string, v taskfile.Var) error {
+	_ = vars.Range(func(k string, v taskfile.Var) error {
 		new.Set(k, taskfile.Var{
 			Static: r.Replace(v.Static),
 			Live:   v.Live,

setup.go

@@ -0,0 +1,277 @@
+package task
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+
+	compilerv2 "github.com/go-task/task/v3/internal/compiler/v2"
+	compilerv3 "github.com/go-task/task/v3/internal/compiler/v3"
+	"github.com/go-task/task/v3/internal/execext"
+	"github.com/go-task/task/v3/internal/logger"
+	"github.com/go-task/task/v3/internal/output"
+	"github.com/go-task/task/v3/taskfile"
+	"github.com/go-task/task/v3/taskfile/read"
+)
+
+func (e *Executor) Setup() error {
+	if err := e.readTaskfile(); err != nil {
+		return err
+	}
+
+	v, err := e.Taskfile.ParsedVersion()
+	if err != nil {
+		return err
+	}
+
+	if err := e.setupTempDir(); err != nil {
+		return err
+	}
+	e.setupStdFiles()
+	e.setupLogger()
+	if err := e.setupOutput(); err != nil {
+		return err
+	}
+	if err := e.setupCompiler(v); err != nil {
+		return err
+	}
+	if err := e.readDotEnvFiles(v); err != nil {
+		return err
+	}
+
+	if err := e.doVersionChecks(v); err != nil {
+		return err
+	}
+	e.setupDefaults(v)
+	e.setupConcurrencyState()
+
+	return nil
+}
+
+func (e *Executor) readTaskfile() error {
+	var err error
+	e.Taskfile, err = read.Taskfile(&read.ReaderNode{
+		Dir:        e.Dir,
+		Entrypoint: e.Entrypoint,
+		Parent:     nil,
+		Optional:   false,
+	})
+	return err
+}
+
+func (e *Executor) setupTempDir() error {
+	if e.TempDir != "" {
+		return nil
+	}
+
+	if os.Getenv("TASK_TEMP_DIR") == "" {
+		e.TempDir = filepath.Join(e.Dir, ".task")
+	} else if filepath.IsAbs(os.Getenv("TASK_TEMP_DIR")) || strings.HasPrefix(os.Getenv("TASK_TEMP_DIR"), "~") {
+		tempDir, err := execext.Expand(os.Getenv("TASK_TEMP_DIR"))
+		if err != nil {
+			return err
+		}
+		projectDir, _ := filepath.Abs(e.Dir)
+		projectName := filepath.Base(projectDir)
+		e.TempDir = filepath.Join(tempDir, projectName)
+	} else {
+		e.TempDir = filepath.Join(e.Dir, os.Getenv("TASK_TEMP_DIR"))
+	}
+
+	return nil
+}
+
+func (e *Executor) setupStdFiles() {
+	if e.Stdin == nil {
+		e.Stdin = os.Stdin
+	}
+	if e.Stdout == nil {
+		e.Stdout = os.Stdout
+	}
+	if e.Stderr == nil {
+		e.Stderr = os.Stderr
+	}
+}
+
+func (e *Executor) setupLogger() {
+	e.Logger = &logger.Logger{
+		Stdout:  e.Stdout,
+		Stderr:  e.Stderr,
+		Verbose: e.Verbose,
+		Color:   e.Color,
+	}
+}
+
+func (e *Executor) setupOutput() error {
+	if !e.OutputStyle.IsSet() {
+		e.OutputStyle = e.Taskfile.Output
+	}
+
+	var err error
+	e.Output, err = output.BuildFor(&e.OutputStyle)
+	return err
+}
+
+func (e *Executor) setupCompiler(v float64) error {
+	if v < 3 {
+		var err error
+		e.taskvars, err = read.Taskvars(e.Dir)
+		if err != nil {
+			return err
+		}
+
+		e.Compiler = &compilerv2.CompilerV2{
+			Dir:          e.Dir,
+			Taskvars:     e.taskvars,
+			TaskfileVars: e.Taskfile.Vars,
+			Expansions:   e.Taskfile.Expansions,
+			Logger:       e.Logger,
+		}
+	} else {
+		e.Compiler = &compilerv3.CompilerV3{
+			Dir:          e.Dir,
+			TaskfileEnv:  e.Taskfile.Env,
+			TaskfileVars: e.Taskfile.Vars,
+			Logger:       e.Logger,
+		}
+	}
+
+	return nil
+}
+
+func (e *Executor) readDotEnvFiles(v float64) error {
+	if v < 3.0 {
+		return nil
+	}
+
+	env, err := read.Dotenv(e.Compiler, e.Taskfile, e.Dir)
+	if err != nil {
+		return err
+	}
+
+	err = env.Range(func(key string, value taskfile.Var) error {
+		if _, ok := e.Taskfile.Env.Mapping[key]; !ok {
+			e.Taskfile.Env.Set(key, value)
+		}
+		return nil
+	})
+	return err
+}
+
+func (e *Executor) setupDefaults(v float64) {
+	// Color available only on v3
+	if v < 3 {
+		e.Logger.Color = false
+	}
+
+	if e.Taskfile.Method == "" {
+		if v >= 3 {
+			e.Taskfile.Method = "checksum"
+		} else {
+			e.Taskfile.Method = "timestamp"
+		}
+	}
+
+	if e.Taskfile.Run == "" {
+		e.Taskfile.Run = "always"
+	}
+}
+
+func (e *Executor) setupConcurrencyState() {
+	e.executionHashes = make(map[string]context.Context)
+
+	e.taskCallCount = make(map[string]*int32, len(e.Taskfile.Tasks))
+	e.mkdirMutexMap = make(map[string]*sync.Mutex, len(e.Taskfile.Tasks))
+	for k := range e.Taskfile.Tasks {
+		e.taskCallCount[k] = new(int32)
+		e.mkdirMutexMap[k] = &sync.Mutex{}
+	}
+
+	if e.Concurrency > 0 {
+		e.concurrencySemaphore = make(chan struct{}, e.Concurrency)
+	}
+}
+
+func (e *Executor) doVersionChecks(v float64) error {
+	if v < 2 {
+		return fmt.Errorf(`task: Taskfile versions prior to v2 are not supported anymore`)
+	}
+
+	// consider as equal to the greater version if round
+	if v == 2.0 {
+		v = 2.6
+	}
+	if v == 3.0 {
+		v = 3.8
+	}
+
+	if v > 3.8 {
+		return fmt.Errorf(`task: Taskfile versions greater than v3.8 not implemented in the version of Task`)
+	}
+
+	if v < 2.1 && !e.Taskfile.Output.IsSet() {
+		return fmt.Errorf(`task: Taskfile option "output" is only available starting on Taskfile version v2.1`)
+	}
+	if v < 2.2 && e.Taskfile.Includes.Len() > 0 {
+		return fmt.Errorf(`task: Including Taskfiles is only available starting on Taskfile version v2.2`)
+	}
+	if v >= 3.0 && e.Taskfile.Expansions > 2 {
+		return fmt.Errorf(`task: The "expansions" setting is not available anymore on v3.0`)
+	}
+	if v < 3.8 && e.Taskfile.Output.Group.IsSet() {
+		return fmt.Errorf(`task: Taskfile option "output.group" is only available starting on Taskfile version v3.8`)
+	}
+
+	if v <= 2.1 {
+		err := errors.New(`task: Taskfile option "ignore_error" is only available starting on Taskfile version v2.1`)
+
+		for _, task := range e.Taskfile.Tasks {
+			if task.IgnoreError {
+				return err
+			}
+			for _, cmd := range task.Cmds {
+				if cmd.IgnoreError {
+					return err
+				}
+			}
+		}
+	}
+
+	if v < 2.6 {
+		for _, task := range e.Taskfile.Tasks {
+			if len(task.Preconditions) > 0 {
+				return errors.New(`task: Task option "preconditions" is only available starting on Taskfile version v2.6`)
+			}
+		}
+	}
+
+	if v < 3 {
+		err := e.Taskfile.Includes.Range(func(_ string, taskfile taskfile.IncludedTaskfile) error {
+			if taskfile.AdvancedImport {
+				return errors.New(`task: Import with additional parameters is only available starting on Taskfile version v3`)
+			}
+			return nil
+		})
+		if err != nil {
+			return err
+		}
+	}
+
+	if v < 3.7 {
+		if e.Taskfile.Run != "" {
+			return errors.New(`task: Setting the "run" type is only available starting on Taskfile version v3.7`)
+		}
+
+		for _, task := range e.Taskfile.Tasks {
+			if task.Run != "" {
+				return errors.New(`task: Setting the "run" type is only available starting on Taskfile version v3.7`)
+			}
+		}
+	}
+
+	return nil
+}

signals.go

@@ -0,0 +1,31 @@
+package task
+
+import (
+	"os"
+	"os/signal"
+	"syscall"
+
+	"github.com/go-task/task/v3/internal/logger"
+)
+
+// NOTE(@andreynering): This function intercepts SIGINT and SIGTERM signals
+// so the Task process is not killed immediatelly and processes running have
+// time to do cleanup work.
+func (e *Executor) InterceptInterruptSignals() {
+	ch := make(chan os.Signal, 3)
+	signal.Notify(ch, os.Interrupt, syscall.SIGTERM)
+
+	go func() {
+		for i := 1; i <= 3; i++ {
+			sig := <-ch
+
+			if i < 3 {
+				e.Logger.Outf(logger.Yellow, `task: Signal received: "%s"`, sig)
+				continue
+			}
+
+			e.Logger.Errf(logger.Red, `task: Signal received for the third time: "%s". Forcing shutdown`, sig)
+			os.Exit(1)
+		}
+	}()
+}

signals_test.go

@@ -0,0 +1,245 @@
+//go:build signals
+// +build signals
+
+// This file contains tests for signal handling on Unix.
+// Based on code from https://github.com/marco-m/timeit
+// Due to how signals work, for robustness we always spawn a separate process;
+// we never send signals to the test process.
+
+package task_test
+
+import (
+	"bytes"
+	"errors"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"syscall"
+	"testing"
+	"time"
+)
+
+var (
+	SLEEPIT, _ = filepath.Abs("./bin/sleepit")
+)
+
+func TestSignalSentToProcessGroup(t *testing.T) {
+	task, err := getTaskPath()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	testCases := map[string]struct {
+		args     []string
+		sendSigs int
+		want     []string
+		notWant  []string
+	}{
+		// regression:
+		// - child is terminated, immediately, by "context canceled" (another bug???)
+		"child does not handle sigint: receives sigint and terminates immediately": {
+			args:     []string{task, "--", SLEEPIT, "default", "-sleep=10s"},
+			sendSigs: 1,
+			want: []string{
+				"sleepit: ready\n",
+				"sleepit: work started\n",
+				"task: Signal received: \"interrupt\"\n",
+				// 130 = 128 + SIGINT
+				"task: Failed to run task \"default\": exit status 130\n",
+			},
+			notWant: []string{
+				"task: Failed to run task \"default\": context canceled\n",
+			},
+		},
+		// 2 regressions:
+		// - child receives 2 signals instead of 1
+		// - child is terminated, immediately, by "context canceled" (another bug???)
+		// TODO we need -cleanup=2s only to show reliably the bug; once the fix is committed,
+		// we can use -cleanup=50ms to speed the test up
+		"child intercepts sigint: receives sigint and does cleanup": {
+			args:     []string{task, "--", SLEEPIT, "handle", "-sleep=10s", "-cleanup=2s"},
+			sendSigs: 1,
+			want: []string{
+				"sleepit: ready\n",
+				"sleepit: work started\n",
+				"task: Signal received: \"interrupt\"\n",
+				"sleepit: got signal=interrupt count=1\n",
+				"sleepit: work canceled\n",
+				"sleepit: cleanup started\n",
+				"sleepit: cleanup done\n",
+				"task: Failed to run task \"default\": exit status 3\n",
+			},
+			notWant: []string{
+				"sleepit: got signal=interrupt count=2\n",
+				"task: Failed to run task \"default\": context canceled\n",
+			},
+		},
+		// regression: child receives 2 signal instead of 1 and thus terminates abruptly
+		"child simulates terraform: receives 1 sigint and does cleanup": {
+			args:     []string{task, "--", SLEEPIT, "handle", "-term-after=2", "-sleep=10s", "-cleanup=50ms"},
+			sendSigs: 1,
+			want: []string{
+				"sleepit: ready\n",
+				"sleepit: work started\n",
+				"task: Signal received: \"interrupt\"\n",
+				"sleepit: got signal=interrupt count=1\n",
+				"sleepit: work canceled\n",
+				"sleepit: cleanup started\n",
+				"sleepit: cleanup done\n",
+				"task: Failed to run task \"default\": exit status 3\n",
+			},
+			notWant: []string{
+				"sleepit: got signal=interrupt count=2\n",
+				"sleepit: cleanup canceled\n",
+				"task: Failed to run task \"default\": exit status 4\n",
+			},
+		},
+	}
+
+	for name, tc := range testCases {
+		t.Run(name, func(t *testing.T) {
+			var out bytes.Buffer
+			sut := exec.Command(tc.args[0], tc.args[1:]...)
+			sut.Stdout = &out
+			sut.Stderr = &out
+			sut.Dir = "testdata/ignore_signals"
+			// Create a new process group by setting the process group ID of the child
+			// to the child PID.
+			// By default, the child would inherit the process group of the parent, but
+			// we want to avoid this, to protect the parent (the test process) from the
+			// signal that this test will send. More info in the comments below for
+			// syscall.Kill().
+			sut.SysProcAttr = &syscall.SysProcAttr{Setpgid: true, Pgid: 0}
+
+			if err := sut.Start(); err != nil {
+				t.Fatalf("starting the SUT process: %v", err)
+			}
+
+			// After the child is started, we want to avoid a race condition where we send
+			// it a signal before it had time to setup its own signal handlers. Sleeping
+			// is way too flaky, instead we parse the child output until we get a line
+			// that we know is printed after the signal handlers are installed...
+			ready := false
+			timeout := time.Duration(time.Second)
+			start := time.Now()
+			for time.Since(start) < timeout {
+				if strings.Contains(out.String(), "sleepit: ready\n") {
+					ready = true
+					break
+				}
+				time.Sleep(10 * time.Millisecond)
+			}
+			if !ready {
+				t.Fatalf("sleepit not ready after %v\n"+
+					"additional information:\n"+
+					"  output:\n%s",
+					timeout, out.String())
+			}
+
+			// When we have a running program in a shell and type CTRL-C, the tty driver
+			// will send a SIGINT signal to all the processes in the foreground process
+			// group (see https://en.wikipedia.org/wiki/Process_group).
+			//
+			// Here we want to emulate this behavior: send SIGINT to the process group of
+			// the test executable. Although Go for some reasons doesn't wrap the
+			// killpg(2) system call, what works is using syscall.Kill(-PID, SIGINT),
+			// where the negative PID means the corresponding process group. Note that
+			// this negative PID works only as long as the caller of the kill(2) system
+			// call has a different PID, which is the case for this test.
+			for i := 1; i <= tc.sendSigs; i++ {
+				if err := syscall.Kill(-sut.Process.Pid, syscall.SIGINT); err != nil {
+					t.Fatalf("sending INT signal to the process group: %v", err)
+				}
+				time.Sleep(1 * time.Millisecond)
+			}
+
+			err := sut.Wait()
+
+			// In case of a subprocess failing, Task always returns exit code 1, not the
+			// exit code returned by the subprocess. This is understandable, since Task
+			// supports parallel execution: if two parallel subprocess fail, each with a
+			// different exit code, which one should Task report? This would be a race.
+			var wantErr *exec.ExitError
+			const wantExitStatus = 1 // Task always returns exit code 1 in case of error
+			if errors.As(err, &wantErr) {
+				if wantErr.ExitCode() != wantExitStatus {
+					t.Errorf(
+						"waiting for child process: got exit status %v; want %d\n"+
+							"additional information:\n"+
+							"  process state: %q",
+						wantErr.ExitCode(), wantExitStatus, wantErr.String())
+				}
+			} else {
+				t.Errorf("waiting for child process: got unexpected error type %v (%T); want (%T)",
+					err, err, wantErr)
+			}
+
+			gotLines := strings.SplitAfter(out.String(), "\n")
+			notFound := listDifference(tc.want, gotLines)
+			if len(notFound) > 0 {
+				t.Errorf("\nwanted but not found:\n%v", notFound)
+			}
+
+			found := listIntersection(tc.notWant, gotLines)
+			if len(found) > 0 {
+				t.Errorf("\nunwanted but found:\n%v", found)
+			}
+
+			if len(notFound) > 0 || len(found) > 0 {
+				t.Errorf("\noutput:\n%v", gotLines)
+			}
+		})
+	}
+}
+
+func getTaskPath() (string, error) {
+	if info, err := os.Stat("./bin/task"); err == nil {
+		return info.Name(), nil
+	}
+
+	if path, err := exec.LookPath("task"); err == nil {
+		return path, nil
+	}
+
+	return "", errors.New("task: \"task\" binary was not found!")
+}
+
+// Return the difference of the two lists: the elements that are present in the first
+// list, but not in the second one. The notion of presence is not with `=` but with
+// string.Contains(l2, l1).
+// FIXME this does not enforce ordering. We might want to support both.
+func listDifference(lines1, lines2 []string) []string {
+	difference := []string{}
+	for _, l1 := range lines1 {
+		found := false
+		for _, l2 := range lines2 {
+			if strings.Contains(l2, l1) {
+				found = true
+				break
+			}
+		}
+		if !found {
+			difference = append(difference, l1)
+		}
+	}
+
+	return difference
+}
+
+// Return the intersection of the two lists: the elements that are present in both lists.
+// The notion of presence is not with '=' but with string.Contains(l2, l1)
+// FIXME this does not enforce ordering. We might want to support both.
+func listIntersection(lines1, lines2 []string) []string {
+	intersection := []string{}
+	for _, l1 := range lines1 {
+		for _, l2 := range lines2 {
+			if strings.Contains(l2, l1) {
+				intersection = append(intersection, l1)
+				break
+			}
+		}
+	}
+
+	return intersection
+}

status.go

@@ -95,7 +95,7 @@ func (e *Executor) timestampChecker(t *taskfile.Task) status.Checker {
 
 func (e *Executor) checksumChecker(t *taskfile.Task) status.Checker {
 	return &status.Checksum{
-		BaseDir:   e.Dir,
+		TempDir:   e.TempDir,
 		TaskDir:   t.Dir,
 		Task:      t.Name(),
 		Sources:   t.Sources,

task.go

@@ -2,7 +2,6 @@ package task
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"io"
 	"os"
@@ -10,14 +9,12 @@ import (
 	"sync/atomic"
 
 	"github.com/go-task/task/v3/internal/compiler"
-	compilerv2 "github.com/go-task/task/v3/internal/compiler/v2"
-	compilerv3 "github.com/go-task/task/v3/internal/compiler/v3"
 	"github.com/go-task/task/v3/internal/execext"
 	"github.com/go-task/task/v3/internal/logger"
 	"github.com/go-task/task/v3/internal/output"
 	"github.com/go-task/task/v3/internal/summary"
+	"github.com/go-task/task/v3/internal/templater"
 	"github.com/go-task/task/v3/taskfile"
-	"github.com/go-task/task/v3/taskfile/read"
 
 	"golang.org/x/sync/errgroup"
 )
@@ -33,6 +30,7 @@ type Executor struct {
 	Taskfile *taskfile.Taskfile
 
 	Dir         string
+	TempDir     string
 	Entrypoint  string
 	Force       bool
 	Watch       bool
@@ -51,7 +49,7 @@ type Executor struct {
 	Logger      *logger.Logger
 	Compiler    compiler.Compiler
 	Output      output.Output
-	OutputStyle string
+	OutputStyle taskfile.Output
 
 	taskvars *taskfile.Vars
 
@@ -68,7 +66,7 @@ func (e *Executor) Run(ctx context.Context, calls ...taskfile.Call) error {
 	for _, c := range calls {
 		if _, ok := e.Taskfile.Tasks[c.Task]; !ok {
 			// FIXME: move to the main package
-			e.PrintTasksHelp()
+			e.ListTasksWithDesc()
 			return &taskNotFoundError{taskName: c.Task}
 		}
 	}
@@ -103,199 +101,6 @@ func (e *Executor) Run(ctx context.Context, calls ...taskfile.Call) error {
 	return g.Wait()
 }
 
-// Setup setups Executor's internal state
-func (e *Executor) Setup() error {
-	if e.Entrypoint == "" {
-		e.Entrypoint = "Taskfile.yml"
-	}
-
-	var err error
-	e.Taskfile, err = read.Taskfile(e.Dir, e.Entrypoint)
-	if err != nil {
-		return err
-	}
-
-	v, err := e.Taskfile.ParsedVersion()
-	if err != nil {
-		return err
-	}
-
-	if v < 3.0 {
-		e.taskvars, err = read.Taskvars(e.Dir)
-		if err != nil {
-			return err
-		}
-	}
-
-	if e.Stdin == nil {
-		e.Stdin = os.Stdin
-	}
-	if e.Stdout == nil {
-		e.Stdout = os.Stdout
-	}
-	if e.Stderr == nil {
-		e.Stderr = os.Stderr
-	}
-	e.Logger = &logger.Logger{
-		Stdout:  e.Stdout,
-		Stderr:  e.Stderr,
-		Verbose: e.Verbose,
-		Color:   e.Color,
-	}
-
-	if v < 2 {
-		return fmt.Errorf(`task: Taskfile versions prior to v2 are not supported anymore`)
-	}
-
-	// consider as equal to the greater version if round
-	if v == 2.0 {
-		v = 2.6
-	}
-	if v == 3.0 {
-		v = 3.7
-	}
-
-	if v > 3.7 {
-		return fmt.Errorf(`task: Taskfile versions greater than v3.7 not implemented in the version of Task`)
-	}
-
-	// Color available only on v3
-	if v < 3 {
-		e.Logger.Color = false
-	}
-
-	if v < 3 {
-		e.Compiler = &compilerv2.CompilerV2{
-			Dir:          e.Dir,
-			Taskvars:     e.taskvars,
-			TaskfileVars: e.Taskfile.Vars,
-			Expansions:   e.Taskfile.Expansions,
-			Logger:       e.Logger,
-		}
-	} else {
-		e.Compiler = &compilerv3.CompilerV3{
-			Dir:          e.Dir,
-			TaskfileEnv:  e.Taskfile.Env,
-			TaskfileVars: e.Taskfile.Vars,
-			Logger:       e.Logger,
-		}
-	}
-
-	if v >= 3.0 {
-		env, err := read.Dotenv(e.Compiler, e.Taskfile, e.Dir)
-		if err != nil {
-			return err
-		}
-
-		err = env.Range(func(key string, value taskfile.Var) error {
-			if _, ok := e.Taskfile.Env.Mapping[key]; !ok {
-				e.Taskfile.Env.Set(key, value)
-			}
-			return nil
-		})
-		if err != nil {
-			return err
-		}
-	}
-
-	if v < 2.1 && e.Taskfile.Output != "" {
-		return fmt.Errorf(`task: Taskfile option "output" is only available starting on Taskfile version v2.1`)
-	}
-	if v < 2.2 && e.Taskfile.Includes.Len() > 0 {
-		return fmt.Errorf(`task: Including Taskfiles is only available starting on Taskfile version v2.2`)
-	}
-	if v >= 3.0 && e.Taskfile.Expansions > 2 {
-		return fmt.Errorf(`task: The "expansions" setting is not available anymore on v3.0`)
-	}
-
-	if e.OutputStyle != "" {
-		e.Taskfile.Output = e.OutputStyle
-	}
-	switch e.Taskfile.Output {
-	case "", "interleaved":
-		e.Output = output.Interleaved{}
-	case "group":
-		e.Output = output.Group{}
-	case "prefixed":
-		e.Output = output.Prefixed{}
-	default:
-		return fmt.Errorf(`task: output option "%s" not recognized`, e.Taskfile.Output)
-	}
-
-	if e.Taskfile.Method == "" {
-		if v >= 3 {
-			e.Taskfile.Method = "checksum"
-		} else {
-			e.Taskfile.Method = "timestamp"
-		}
-	}
-
-	if v <= 2.1 {
-		err := errors.New(`task: Taskfile option "ignore_error" is only available starting on Taskfile version v2.1`)
-
-		for _, task := range e.Taskfile.Tasks {
-			if task.IgnoreError {
-				return err
-			}
-			for _, cmd := range task.Cmds {
-				if cmd.IgnoreError {
-					return err
-				}
-			}
-		}
-	}
-
-	if v < 2.6 {
-		for _, task := range e.Taskfile.Tasks {
-			if len(task.Preconditions) > 0 {
-				return errors.New(`task: Task option "preconditions" is only available starting on Taskfile version v2.6`)
-			}
-		}
-	}
-
-	if v < 3 {
-		err := e.Taskfile.Includes.Range(func(_ string, taskfile taskfile.IncludedTaskfile) error {
-			if taskfile.AdvancedImport {
-				return errors.New(`task: Import with additional parameters is only available starting on Taskfile version v3`)
-			}
-			return nil
-		})
-		if err != nil {
-			return err
-		}
-	}
-
-	if v < 3.7 {
-		if e.Taskfile.Run != "" {
-			return errors.New(`task: Setting the "run" type is only available starting on Taskfile version v3.7`)
-		}
-
-		for _, task := range e.Taskfile.Tasks {
-			if task.Run != "" {
-				return errors.New(`task: Setting the "run" type is only available starting on Taskfile version v3.7`)
-			}
-		}
-	}
-
-	if e.Taskfile.Run == "" {
-		e.Taskfile.Run = "always"
-	}
-
-	e.executionHashes = make(map[string]context.Context)
-
-	e.taskCallCount = make(map[string]*int32, len(e.Taskfile.Tasks))
-	e.mkdirMutexMap = make(map[string]*sync.Mutex, len(e.Taskfile.Tasks))
-	for k := range e.Taskfile.Tasks {
-		e.taskCallCount[k] = new(int32)
-		e.mkdirMutexMap[k] = &sync.Mutex{}
-	}
-
-	if e.Concurrency > 0 {
-		e.concurrencySemaphore = make(chan struct{}, e.Concurrency)
-	}
-	return nil
-}
-
 // RunTask runs a task by its name
 func (e *Executor) RunTask(ctx context.Context, call taskfile.Call) error {
 	t, err := e.CompiledTask(call)
@@ -310,11 +115,16 @@ func (e *Executor) RunTask(ctx context.Context, call taskfile.Call) error {
 	defer release()
 
 	return e.startExecution(ctx, t, func(ctx context.Context) error {
+		e.Logger.VerboseErrf(logger.Magenta, `task: "%s" started`, call.Task)
 		if err := e.runDeps(ctx, t); err != nil {
 			return err
 		}
 
 		if !e.Force {
+			if err := ctx.Err(); err != nil {
+				return err
+			}
+
 			preCondMet, err := e.areTaskPreconditionsMet(ctx, t)
 			if err != nil {
 				return err
@@ -338,6 +148,11 @@ func (e *Executor) RunTask(ctx context.Context, call taskfile.Call) error {
 		}
 
 		for i := range t.Cmds {
+			if t.Cmds[i].Defer {
+				defer e.runDeferred(t, call, i)
+				continue
+			}
+
 			if err := e.runCommand(ctx, t, call, i); err != nil {
 				if err2 := e.statusOnError(t); err2 != nil {
 					e.Logger.VerboseErrf(logger.Yellow, "task: error cleaning status on error: %v", err2)
@@ -348,9 +163,10 @@ func (e *Executor) RunTask(ctx context.Context, call taskfile.Call) error {
 					continue
 				}
 
-				return &taskRunError{t.Task, err}
+				return &TaskRunError{t.Task, err}
 			}
 		}
+		e.Logger.VerboseErrf(logger.Magenta, `task: "%s" finished`, call.Task)
 		return nil
 	})
 }
@@ -393,6 +209,15 @@ func (e *Executor) runDeps(ctx context.Context, t *taskfile.Task) error {
 	return g.Wait()
 }
 
+func (e *Executor) runDeferred(t *taskfile.Task, call taskfile.Call, i int) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	if err := e.runCommand(ctx, t, call, i); err != nil {
+		e.Logger.VerboseErrf(logger.Yellow, `task: ignored error in deferred cmd: %s`, err.Error())
+	}
+}
+
 func (e *Executor) runCommand(ctx context.Context, t *taskfile.Task, call taskfile.Call, i int) error {
 	cmd := t.Cmds[i]
 
@@ -419,23 +244,19 @@ func (e *Executor) runCommand(ctx context.Context, t *taskfile.Task, call taskfi
 		if t.Interactive {
 			outputWrapper = output.Interleaved{}
 		}
-		stdOut := outputWrapper.WrapWriter(e.Stdout, t.Prefix)
-		stdErr := outputWrapper.WrapWriter(e.Stderr, t.Prefix)
-
+		vars, err := e.Compiler.FastGetVariables(t, call)
+		outputTemplater := &templater.Templater{Vars: vars, RemoveNoValue: true}
+		if err != nil {
+			return fmt.Errorf("task: failed to get variables: %w", err)
+		}
+		stdOut, stdErr, close := outputWrapper.WrapWriter(e.Stdout, e.Stderr, t.Prefix, outputTemplater)
 		defer func() {
-			if _, ok := stdOut.(*os.File); !ok {
-				if closer, ok := stdOut.(io.Closer); ok {
-					closer.Close()
-				}
-			}
-			if _, ok := stdErr.(*os.File); !ok {
-				if closer, ok := stdErr.(io.Closer); ok {
-					closer.Close()
-				}
+			if err := close(); err != nil {
+				e.Logger.Errf(logger.Red, "task: unable to close writter: %v", err)
 			}
 		}()
 
-		err := execext.RunCommand(ctx, &execext.RunCommandOptions{
+		err = execext.RunCommand(ctx, &execext.RunCommandOptions{
 			Command: cmd.Cmd,
 			Dir:     t.Dir,
 			Env:     getEnviron(t),

task_test.go

@@ -4,7 +4,7 @@ import (
 	"bytes"
 	"context"
 	"fmt"
-	"io/ioutil"
+	"io"
 	"os"
 	"path/filepath"
 	"runtime"
@@ -24,10 +24,11 @@ func init() {
 // fileContentTest provides a basic reusable test-case for running a Taskfile
 // and inspect generated files.
 type fileContentTest struct {
-	Dir       string
-	Target    string
-	TrimSpace bool
-	Files     map[string]string
+	Dir        string
+	Entrypoint string
+	Target     string
+	TrimSpace  bool
+	Files      map[string]string
 }
 
 func (fct fileContentTest) name(file string) string {
@@ -40,16 +41,18 @@ func (fct fileContentTest) Run(t *testing.T) {
 	}
 
 	e := &task.Executor{
-		Dir:    fct.Dir,
-		Stdout: ioutil.Discard,
-		Stderr: ioutil.Discard,
+		Dir:        fct.Dir,
+		TempDir:    filepath.Join(fct.Dir, ".task"),
+		Entrypoint: fct.Entrypoint,
+		Stdout:     io.Discard,
+		Stderr:     io.Discard,
 	}
 	assert.NoError(t, e.Setup(), "e.Setup()")
 	assert.NoError(t, e.Run(context.Background(), taskfile.Call{Task: fct.Target}), "e.Run(target)")
 
 	for name, expectContent := range fct.Files {
 		t.Run(fct.name(name), func(t *testing.T) {
-			b, err := ioutil.ReadFile(filepath.Join(fct.Dir, name))
+			b, err := os.ReadFile(filepath.Join(fct.Dir, name))
 			assert.NoError(t, err, "Error reading file")
 			s := string(b)
 			if fct.TrimSpace {
@@ -63,8 +66,8 @@ func (fct fileContentTest) Run(t *testing.T) {
 func TestEmptyTask(t *testing.T) {
 	e := &task.Executor{
 		Dir:    "testdata/empty_task",
-		Stdout: ioutil.Discard,
-		Stderr: ioutil.Discard,
+		Stdout: io.Discard,
+		Stderr: io.Discard,
 	}
 	assert.NoError(t, e.Setup(), "e.Setup()")
 	assert.NoError(t, e.Run(context.Background(), taskfile.Call{Task: "default"}))
@@ -168,8 +171,8 @@ func TestVarsInvalidTmpl(t *testing.T) {
 
 	e := &task.Executor{
 		Dir:    dir,
-		Stdout: ioutil.Discard,
-		Stderr: ioutil.Discard,
+		Stdout: io.Discard,
+		Stderr: io.Discard,
 	}
 	assert.NoError(t, e.Setup(), "e.Setup()")
 	assert.EqualError(t, e.Run(context.Background(), taskfile.Call{Task: target}), expectError, "e.Run(target)")
@@ -183,8 +186,8 @@ func TestConcurrency(t *testing.T) {
 
 	e := &task.Executor{
 		Dir:         dir,
-		Stdout:      ioutil.Discard,
-		Stderr:      ioutil.Discard,
+		Stdout:      io.Discard,
+		Stderr:      io.Discard,
 		Concurrency: 1,
 	}
 	assert.NoError(t, e.Setup(), "e.Setup()")
@@ -236,8 +239,8 @@ func TestDeps(t *testing.T) {
 
 	e := &task.Executor{
 		Dir:    dir,
-		Stdout: ioutil.Discard,
-		Stderr: ioutil.Discard,
+		Stdout: io.Discard,
+		Stderr: io.Discard,
 	}
 	assert.NoError(t, e.Setup())
 	assert.NoError(t, e.Run(context.Background(), taskfile.Call{Task: "default"}))
@@ -268,10 +271,11 @@ func TestStatus(t *testing.T) {
 
 	var buff bytes.Buffer
 	e := &task.Executor{
-		Dir:    dir,
-		Stdout: &buff,
-		Stderr: &buff,
-		Silent: true,
+		Dir:     dir,
+		TempDir: filepath.Join(dir, ".task"),
+		Stdout:  &buff,
+		Stderr:  &buff,
+		Silent:  true,
 	}
 	assert.NoError(t, e.Setup())
 	assert.NoError(t, e.Run(context.Background(), taskfile.Call{Task: "gen-foo"}))
@@ -419,9 +423,10 @@ func TestStatusChecksum(t *testing.T) {
 
 	var buff bytes.Buffer
 	e := task.Executor{
-		Dir:    dir,
-		Stdout: &buff,
-		Stderr: &buff,
+		Dir:     dir,
+		TempDir: filepath.Join(dir, ".task"),
+		Stdout:  &buff,
+		Stderr:  &buff,
 	}
 	assert.NoError(t, e.Setup())
 
@@ -516,10 +521,58 @@ func TestLabelInList(t *testing.T) {
 		Stderr: &buff,
 	}
 	assert.NoError(t, e.Setup())
-	e.PrintTasksHelp()
+	e.ListTasksWithDesc()
 	assert.Contains(t, buff.String(), "foobar")
 }
 
+// task -al case 1: listAll list all tasks
+func TestListAllShowsNoDesc(t *testing.T) {
+	const dir = "testdata/list_mixed_desc"
+
+	var buff bytes.Buffer
+	e := task.Executor{
+		Dir:    dir,
+		Stdout: &buff,
+		Stderr: &buff,
+	}
+
+	assert.NoError(t, e.Setup())
+
+	var title string
+	e.ListAllTasks()
+	for _, title = range []string{
+		"foo",
+		"voo",
+		"doo",
+	} {
+		assert.Contains(t, buff.String(), title)
+	}
+}
+
+// task -al case 2: !listAll list some tasks (only those with desc)
+func TestListCanListDescOnly(t *testing.T) {
+	const dir = "testdata/list_mixed_desc"
+
+	var buff bytes.Buffer
+	e := task.Executor{
+		Dir:    dir,
+		Stdout: &buff,
+		Stderr: &buff,
+	}
+
+	assert.NoError(t, e.Setup())
+	e.ListTasksWithDesc()
+
+	var title string
+	assert.Contains(t, buff.String(), "foo")
+	for _, title = range []string{
+		"voo",
+		"doo",
+	} {
+		assert.NotContains(t, buff.String(), title)
+	}
+}
+
 func TestStatusVariables(t *testing.T) {
 	const dir = "testdata/status_vars"
 
@@ -529,6 +582,7 @@ func TestStatusVariables(t *testing.T) {
 	var buff bytes.Buffer
 	e := task.Executor{
 		Dir:     dir,
+		TempDir: filepath.Join(dir, ".task"),
 		Stdout:  &buff,
 		Stderr:  &buff,
 		Silent:  false,
@@ -542,7 +596,7 @@ func TestStatusVariables(t *testing.T) {
 	inf, err := os.Stat(filepath.Join(dir, "source.txt"))
 	assert.NoError(t, err)
 	ts := fmt.Sprintf("%d", inf.ModTime().Unix())
-	tf := fmt.Sprintf("%s", inf.ModTime())
+	tf := inf.ModTime().String()
 
 	assert.Contains(t, buff.String(), ts)
 	assert.Contains(t, buff.String(), tf)
@@ -550,20 +604,21 @@ func TestStatusVariables(t *testing.T) {
 
 func TestInit(t *testing.T) {
 	const dir = "testdata/init"
-	var file = filepath.Join(dir, "Taskfile.yml")
+	var file = filepath.Join(dir, "Taskfile.yaml")
 
 	_ = os.Remove(file)
 	if _, err := os.Stat(file); err == nil {
-		t.Errorf("Taskfile.yml should not exist")
+		t.Errorf("Taskfile.yaml should not exist")
 	}
 
-	if err := task.InitTaskfile(ioutil.Discard, dir); err != nil {
+	if err := task.InitTaskfile(io.Discard, dir); err != nil {
 		t.Error(err)
 	}
 
 	if _, err := os.Stat(file); err != nil {
-		t.Errorf("Taskfile.yml should exist")
+		t.Errorf("Taskfile.yaml should exist")
 	}
+	_ = os.Remove(file)
 }
 
 func TestCyclicDep(t *testing.T) {
@@ -571,8 +626,8 @@ func TestCyclicDep(t *testing.T) {
 
 	e := task.Executor{
 		Dir:    dir,
-		Stdout: ioutil.Discard,
-		Stderr: ioutil.Discard,
+		Stdout: io.Discard,
+		Stderr: io.Discard,
 	}
 	assert.NoError(t, e.Setup())
 	assert.IsType(t, &task.MaximumTaskCallExceededError{}, e.Run(context.Background(), taskfile.Call{Task: "task-1"}))
@@ -590,8 +645,8 @@ func TestTaskVersion(t *testing.T) {
 		t.Run(test.Dir, func(t *testing.T) {
 			e := task.Executor{
 				Dir:    test.Dir,
-				Stdout: ioutil.Discard,
-				Stderr: ioutil.Discard,
+				Stdout: io.Discard,
+				Stderr: io.Discard,
 			}
 			assert.NoError(t, e.Setup())
 			assert.Equal(t, test.Version, e.Taskfile.Version)
@@ -605,8 +660,8 @@ func TestTaskIgnoreErrors(t *testing.T) {
 
 	e := task.Executor{
 		Dir:    dir,
-		Stdout: ioutil.Discard,
-		Stderr: ioutil.Discard,
+		Stdout: io.Discard,
+		Stderr: io.Discard,
 	}
 	assert.NoError(t, e.Setup())
 
@@ -667,10 +722,11 @@ func TestDryChecksum(t *testing.T) {
 	_ = os.Remove(checksumFile)
 
 	e := task.Executor{
-		Dir:    dir,
-		Stdout: ioutil.Discard,
-		Stderr: ioutil.Discard,
-		Dry:    true,
+		Dir:     dir,
+		TempDir: filepath.Join(dir, ".task"),
+		Stdout:  io.Discard,
+		Stderr:  io.Discard,
+		Dry:     true,
 	}
 	assert.NoError(t, e.Setup())
 	assert.NoError(t, e.Run(context.Background(), taskfile.Call{Task: "default"}))
@@ -702,6 +758,35 @@ func TestIncludes(t *testing.T) {
 	tt.Run(t)
 }
 
+func TestIncludesMultiLevel(t *testing.T) {
+	tt := fileContentTest{
+		Dir:       "testdata/includes_multi_level",
+		Target:    "default",
+		TrimSpace: true,
+		Files: map[string]string{
+			"called_one.txt":   "one",
+			"called_two.txt":   "two",
+			"called_three.txt": "three",
+		},
+	}
+	tt.Run(t)
+}
+
+func TestIncludeCycle(t *testing.T) {
+	const dir = "testdata/includes_cycle"
+	expectedError := "task: include cycle detected between testdata/includes_cycle/Taskfile.yml <--> testdata/includes_cycle/one/two/Taskfile.yml"
+
+	var buff bytes.Buffer
+	e := task.Executor{
+		Dir:    dir,
+		Stdout: &buff,
+		Stderr: &buff,
+		Silent: true,
+	}
+
+	assert.EqualError(t, e.Setup(), expectedError)
+}
+
 func TestIncorrectVersionIncludes(t *testing.T) {
 	const dir = "testdata/incorrect_includes"
 	expectedError := "task: Import with additional parameters is only available starting on Taskfile version v3"
@@ -756,21 +841,21 @@ func TestIncludesCallingRoot(t *testing.T) {
 }
 
 func TestIncludesOptional(t *testing.T) {
-  tt := fileContentTest{
-    Dir:       "testdata/includes_optional",
-    Target:    "default",
-	  TrimSpace: true,
-	  Files: map[string]string{
-		  "called_dep.txt": "called_dep",
-	  }}
-  tt.Run(t)
+	tt := fileContentTest{
+		Dir:       "testdata/includes_optional",
+		Target:    "default",
+		TrimSpace: true,
+		Files: map[string]string{
+			"called_dep.txt": "called_dep",
+		}}
+	tt.Run(t)
 }
 
 func TestIncludesOptionalImplicitFalse(t *testing.T) {
 	e := task.Executor{
 		Dir:    "testdata/includes_optional_implicit_false",
-		Stdout: ioutil.Discard,
-		Stderr: ioutil.Discard,
+		Stdout: io.Discard,
+		Stderr: io.Discard,
 	}
 
 	err := e.Setup()
@@ -781,8 +866,8 @@ func TestIncludesOptionalImplicitFalse(t *testing.T) {
 func TestIncludesOptionalExplicitFalse(t *testing.T) {
 	e := task.Executor{
 		Dir:    "testdata/includes_optional_explicit_false",
-		Stdout: ioutil.Discard,
-		Stderr: ioutil.Discard,
+		Stdout: io.Discard,
+		Stderr: io.Discard,
 	}
 
 	err := e.Setup()
@@ -790,6 +875,43 @@ func TestIncludesOptionalExplicitFalse(t *testing.T) {
 	assert.Equal(t, "stat testdata/includes_optional_explicit_false/TaskfileOptional.yml: no such file or directory", err.Error())
 }
 
+func TestIncludesFromCustomTaskfile(t *testing.T) {
+	tt := fileContentTest{
+		Dir:        "testdata/includes_yaml",
+		Entrypoint: "Custom.ext",
+		Target:     "default",
+		TrimSpace:  true,
+		Files: map[string]string{
+			"main.txt":                         "main",
+			"included_with_yaml_extension.txt": "included_with_yaml_extension",
+			"included_with_custom_file.txt":    "included_with_custom_file",
+		},
+	}
+	tt.Run(t)
+}
+
+func TestSupportedFileNames(t *testing.T) {
+	fileNames := []string{
+		"Taskfile.yml",
+		"Taskfile.yaml",
+		"Taskfile.dist.yml",
+		"Taskfile.dist.yaml",
+	}
+	for _, fileName := range fileNames {
+		t.Run(fileName, func(t *testing.T) {
+			tt := fileContentTest{
+				Dir:       fmt.Sprintf("testdata/file_names/%s", fileName),
+				Target:    "default",
+				TrimSpace: true,
+				Files: map[string]string{
+					"output.txt": "hello",
+				},
+			}
+			tt.Run(t)
+		})
+	}
+}
+
 func TestSummary(t *testing.T) {
 	const dir = "testdata/summary"
 
@@ -804,7 +926,7 @@ func TestSummary(t *testing.T) {
 	assert.NoError(t, e.Setup())
 	assert.NoError(t, e.Run(context.Background(), taskfile.Call{Task: "task-with-summary"}, taskfile.Call{Task: "other-task-with-summary"}))
 
-	data, err := ioutil.ReadFile(filepath.Join(dir, "task-with-summary.txt"))
+	data, err := os.ReadFile(filepath.Join(dir, "task-with-summary.txt"))
 	assert.NoError(t, err)
 
 	expectedOutput := string(data)
@@ -877,6 +999,33 @@ func TestWhenDirAttributeItCreatesMissingAndRunsInThatDir(t *testing.T) {
 	_ = os.RemoveAll(toBeCreated)
 }
 
+func TestDynamicVariablesRunOnTheNewCreatedDir(t *testing.T) {
+	const expected = "created"
+	const dir = "testdata/dir/dynamic_var_on_created_dir/"
+	const toBeCreated = dir + expected
+	const target = "default"
+	var out bytes.Buffer
+	e := &task.Executor{
+		Dir:    dir,
+		Stdout: &out,
+		Stderr: &out,
+	}
+
+	// Ensure that the directory to be created doesn't actually exist.
+	_ = os.RemoveAll(toBeCreated)
+	if _, err := os.Stat(toBeCreated); err == nil {
+		t.Errorf("Directory should not exist: %v", err)
+	}
+	assert.NoError(t, e.Setup())
+	assert.NoError(t, e.Run(context.Background(), taskfile.Call{Task: target}))
+
+	got := strings.TrimSuffix(filepath.Base(out.String()), "\n")
+	assert.Equal(t, expected, got, "Mismatch in the working directory")
+
+	// Clean-up after ourselves only if no error.
+	_ = os.RemoveAll(toBeCreated)
+}
+
 func TestDynamicVariablesShouldRunOnTheTaskDir(t *testing.T) {
 	tt := fileContentTest{
 		Dir:       "testdata/dir/dynamic_var",
@@ -895,8 +1044,8 @@ func TestDynamicVariablesShouldRunOnTheTaskDir(t *testing.T) {
 func TestDisplaysErrorOnUnsupportedVersion(t *testing.T) {
 	e := task.Executor{
 		Dir:    "testdata/version/v1",
-		Stdout: ioutil.Discard,
-		Stderr: ioutil.Discard,
+		Stdout: io.Discard,
+		Stderr: io.Discard,
 	}
 	err := e.Setup()
 	assert.Error(t, err)
@@ -1026,6 +1175,31 @@ func TestRunOnlyRunsJobsHashOnce(t *testing.T) {
 	tt.Run(t)
 }
 
+func TestDeferredCmds(t *testing.T) {
+	const dir = "testdata/deferred"
+	var buff bytes.Buffer
+	e := task.Executor{
+		Dir:    dir,
+		Stdout: &buff,
+		Stderr: &buff,
+	}
+	assert.NoError(t, e.Setup())
+
+	expectedOutputOrder := strings.TrimSpace(`
+task: [task-2] echo 'cmd ran'
+cmd ran
+task: [task-2] exit 1
+task: [task-2] echo 'failing' && exit 2
+failing
+task: [task-2] echo 'echo ran'
+echo ran
+task: [task-1] echo 'task-1 ran successfully'
+task-1 ran successfully
+`)
+	assert.Error(t, e.Run(context.Background(), taskfile.Call{Task: "task-2"}))
+	assert.Contains(t, buff.String(), expectedOutputOrder)
+}
+
 func TestIgnoreNilElements(t *testing.T) {
 	tests := []struct {
 		name string
@@ -1033,6 +1207,7 @@ func TestIgnoreNilElements(t *testing.T) {
 	}{
 		{"nil cmd", "testdata/ignore_nil_elements/cmds"},
 		{"nil dep", "testdata/ignore_nil_elements/deps"},
+		{"nil include", "testdata/ignore_nil_elements/includes"},
 		{"nil precondition", "testdata/ignore_nil_elements/preconditions"},
 	}
 
@@ -1051,3 +1226,76 @@ func TestIgnoreNilElements(t *testing.T) {
 		})
 	}
 }
+
+func TestOutputGroup(t *testing.T) {
+	const dir = "testdata/output_group"
+	var buff bytes.Buffer
+	e := task.Executor{
+		Dir:    dir,
+		Stdout: &buff,
+		Stderr: &buff,
+	}
+	assert.NoError(t, e.Setup())
+
+	expectedOutputOrder := strings.TrimSpace(`
+task: [hello] echo 'Hello!'
+::group::hello
+Hello!
+::endgroup::
+task: [bye] echo 'Bye!'
+::group::bye
+Bye!
+::endgroup::
+`)
+	assert.NoError(t, e.Run(context.Background(), taskfile.Call{Task: "bye"}))
+	t.Log(buff.String())
+	assert.Equal(t, strings.TrimSpace(buff.String()), expectedOutputOrder)
+}
+
+func TestIncludedVars(t *testing.T) {
+	const dir = "testdata/include_with_vars"
+	var buff bytes.Buffer
+	e := task.Executor{
+		Dir:    dir,
+		Stdout: &buff,
+		Stderr: &buff,
+	}
+	assert.NoError(t, e.Setup())
+
+	expectedOutputOrder := strings.TrimSpace(`
+task: [included1:task1] echo "VAR_1 is included1-var1"
+VAR_1 is included1-var1
+task: [included1:task1] echo "VAR_2 is included-default-var2"
+VAR_2 is included-default-var2
+task: [included2:task1] echo "VAR_1 is included2-var1"
+VAR_1 is included2-var1
+task: [included2:task1] echo "VAR_2 is included-default-var2"
+VAR_2 is included-default-var2
+task: [included3:task1] echo "VAR_1 is included-default-var1"
+VAR_1 is included-default-var1
+task: [included3:task1] echo "VAR_2 is included-default-var2"
+VAR_2 is included-default-var2
+`)
+	assert.NoError(t, e.Run(context.Background(), taskfile.Call{Task: "task1"}))
+	t.Log(buff.String())
+	assert.Equal(t, strings.TrimSpace(buff.String()), expectedOutputOrder)
+}
+
+func TestErrorCode(t *testing.T) {
+	const dir = "testdata/error_code"
+
+	var buff bytes.Buffer
+	e := &task.Executor{
+		Dir:    dir,
+		Stdout: &buff,
+		Stderr: &buff,
+		Silent: true,
+	}
+	assert.NoError(t, e.Setup())
+
+	err := e.Run(context.Background(), taskfile.Call{Task: "test-exit-code"})
+	assert.Error(t, err)
+	casted, ok := err.(*task.TaskRunError)
+	assert.True(t, ok, "cannot cast returned error to *task.TaskRunError")
+	assert.Equal(t, 42, casted.ExitCode(), "unexpected exit code from task")
+}

taskfile/cmd.go

@@ -1,9 +1,5 @@
 package taskfile
 
-import (
-	"strings"
-)
-
 // Cmd is a task command
 type Cmd struct {
 	Cmd         string
@@ -11,6 +7,7 @@ type Cmd struct {
 	Task        string
 	Vars        *Vars
 	IgnoreError bool
+	Defer       bool
 }
 
 // Dep is a task dependency
@@ -23,11 +20,7 @@ type Dep struct {
 func (c *Cmd) UnmarshalYAML(unmarshal func(interface{}) error) error {
 	var cmd string
 	if err := unmarshal(&cmd); err == nil {
-		if strings.HasPrefix(cmd, "^") {
-			c.Task = strings.TrimPrefix(cmd, "^")
-		} else {
-			c.Cmd = cmd
-		}
+		c.Cmd = cmd
 		return nil
 	}
 	var cmdStruct struct {
@@ -41,6 +34,23 @@ func (c *Cmd) UnmarshalYAML(unmarshal func(interface{}) error) error {
 		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

taskfile/included_taskfile.go

@@ -12,6 +12,7 @@ type IncludedTaskfile struct {
 	Dir            string
 	Optional       bool
 	AdvancedImport bool
+	Vars           *Vars
 }
 
 // IncludedTaskfiles represents information about included tasksfiles
@@ -52,7 +53,7 @@ func (tfs *IncludedTaskfiles) Len() int {
 
 // Merge merges the given IncludedTaskfiles into the caller one
 func (tfs *IncludedTaskfiles) Merge(other *IncludedTaskfiles) {
-	other.Range(func(key string, value IncludedTaskfile) error {
+	_ = other.Range(func(key string, value IncludedTaskfile) error {
 		tfs.Set(key, value)
 		return nil
 	})
@@ -94,6 +95,7 @@ func (it *IncludedTaskfile) UnmarshalYAML(unmarshal func(interface{}) error) err
 		Taskfile string
 		Dir      string
 		Optional bool
+		Vars     *Vars
 	}
 	if err := unmarshal(&includedTaskfile); err != nil {
 		return err
@@ -102,5 +104,6 @@ func (it *IncludedTaskfile) UnmarshalYAML(unmarshal func(interface{}) error) err
 	it.Dir = includedTaskfile.Dir
 	it.Optional = includedTaskfile.Optional
 	it.AdvancedImport = true
+	it.Vars = includedTaskfile.Vars
 	return nil
 }

taskfile/merge.go

@@ -11,13 +11,13 @@ const NamespaceSeparator = ":"
 // Merge merges the second Taskfile into the first
 func Merge(t1, t2 *Taskfile, namespaces ...string) error {
 	if t1.Version != t2.Version {
-		return fmt.Errorf(`Taskfiles versions should match. First is "%s" but second is "%s"`, t1.Version, t2.Version)
+		return fmt.Errorf(`task: Taskfiles versions should match. First is "%s" but second is "%s"`, t1.Version, t2.Version)
 	}
 
 	if t2.Expansions != 0 && t2.Expansions != 2 {
 		t1.Expansions = t2.Expansions
 	}
-	if t2.Output != "" {
+	if t2.Output.IsSet() {
 		t1.Output = t2.Output
 	}
 
@@ -49,7 +49,7 @@ func Merge(t1, t2 *Taskfile, namespaces ...string) error {
 			dep.Task = taskNameWithNamespace(dep.Task, namespaces...)
 		}
 		for _, cmd := range v.Cmds {
-			if cmd.Task != "" {
+			if cmd != nil && cmd.Task != "" {
 				cmd.Task = taskNameWithNamespace(cmd.Task, namespaces...)
 			}
 		}

taskfile/output.go

@@ -0,0 +1,55 @@
+package taskfile
+
+import (
+	"fmt"
+)
+
+// Output of the Task output
+type Output struct {
+	// Name of the Output.
+	Name string `yaml:"-"`
+	// Group specific style
+	Group OutputGroup
+}
+
+// IsSet returns true if and only if a custom output style is set.
+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 {
+		s.Name = name
+		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
+}
+
+// OutputGroup is the style options specific to the Group style.
+type OutputGroup struct {
+	Begin, End string
+}
+
+// IsSet returns true if and only if a custom output style is set.
+func (g *OutputGroup) IsSet() bool {
+	if g == nil {
+		return false
+	}
+	return g.Begin != "" || g.End != ""
+}

taskfile/read/taskfile.go

@@ -15,18 +15,41 @@ import (
 )
 
 var (
-	// ErrIncludedTaskfilesCantHaveIncludes is returned when a included Taskfile contains includes
-	ErrIncludedTaskfilesCantHaveIncludes = errors.New("task: Included Taskfiles can't have includes. Please, move the include to the main Taskfile")
 	// ErrIncludedTaskfilesCantHaveDotenvs is returned when a included Taskfile contains dotenvs
 	ErrIncludedTaskfilesCantHaveDotenvs = errors.New("task: Included Taskfiles can't have dotenv declarations. Please, move the dotenv declaration to the main Taskfile")
+
+	defaultTaskfiles = []string{
+		"Taskfile.yml",
+		"Taskfile.yaml",
+		"Taskfile.dist.yml",
+		"Taskfile.dist.yaml",
+	}
 )
 
+type ReaderNode struct {
+	Dir        string
+	Entrypoint string
+	Optional   bool
+	Parent     *ReaderNode
+}
+
 // Taskfile reads a Taskfile for a given directory
-func Taskfile(dir string, entrypoint string) (*taskfile.Taskfile, error) {
-	path := filepath.Join(dir, entrypoint)
-	if _, err := os.Stat(path); err != nil {
-		return nil, fmt.Errorf(`task: No Taskfile found on "%s". Use "task --init" to create a new one`, path)
+// Uses current dir when dir is left empty. Uses Taskfile.yml
+// or Taskfile.yaml when entrypoint is left empty
+func Taskfile(readerNode *ReaderNode) (*taskfile.Taskfile, error) {
+	if readerNode.Dir == "" {
+		d, err := os.Getwd()
+		if err != nil {
+			return nil, err
+		}
+		readerNode.Dir = d
 	}
+	path, err := exists(filepath.Join(readerNode.Dir, readerNode.Entrypoint))
+	if err != nil {
+		return nil, err
+	}
+	readerNode.Entrypoint = filepath.Base(path)
+
 	t, err := readTaskfile(path)
 	if err != nil {
 		return nil, err
@@ -45,6 +68,7 @@ func Taskfile(dir string, entrypoint string) (*taskfile.Taskfile, error) {
 				Dir:            tr.Replace(includedTask.Dir),
 				Optional:       includedTask.Optional,
 				AdvancedImport: includedTask.AdvancedImport,
+				Vars:           includedTask.Vars,
 			}
 			if err := tr.Err(); err != nil {
 				return err
@@ -56,25 +80,33 @@ func Taskfile(dir string, entrypoint string) (*taskfile.Taskfile, error) {
 			return err
 		}
 		if !filepath.IsAbs(path) {
-			path = filepath.Join(dir, path)
+			path = filepath.Join(readerNode.Dir, path)
 		}
-
-		info, err := os.Stat(path)
+		path, err = exists(path)
 		if err != nil {
 			if includedTask.Optional {
 				return nil
 			}
 			return err
 		}
-		if info.IsDir() {
-			path = filepath.Join(path, "Taskfile.yml")
+
+		includeReaderNode := &ReaderNode{
+			Dir:        filepath.Dir(path),
+			Entrypoint: filepath.Base(path),
+			Parent:     readerNode,
+			Optional:   includedTask.Optional,
 		}
-		includedTaskfile, err := readTaskfile(path)
-		if err != nil {
+
+		if err := checkCircularIncludes(includeReaderNode); err != nil {
 			return err
 		}
-		if includedTaskfile.Includes.Len() > 0 {
-			return ErrIncludedTaskfilesCantHaveIncludes
+
+		includedTaskfile, err := Taskfile(includeReaderNode)
+		if err != nil {
+			if includedTask.Optional {
+				return nil
+			}
+			return err
 		}
 
 		if v >= 3.0 && len(includedTaskfile.Dotenv) > 0 {
@@ -84,12 +116,12 @@ func Taskfile(dir string, entrypoint string) (*taskfile.Taskfile, error) {
 		if includedTask.AdvancedImport {
 			for k, v := range includedTaskfile.Vars.Mapping {
 				o := v
-				o.Dir = filepath.Join(dir, includedTask.Dir)
+				o.Dir = filepath.Join(readerNode.Dir, includedTask.Dir)
 				includedTaskfile.Vars.Mapping[k] = o
 			}
 			for k, v := range includedTaskfile.Env.Mapping {
 				o := v
-				o.Dir = filepath.Join(dir, includedTask.Dir)
+				o.Dir = filepath.Join(readerNode.Dir, includedTask.Dir)
 				includedTaskfile.Env.Mapping[k] = o
 			}
 
@@ -97,6 +129,8 @@ func Taskfile(dir string, entrypoint string) (*taskfile.Taskfile, error) {
 				if !filepath.IsAbs(task.Dir) {
 					task.Dir = filepath.Join(includedTask.Dir, task.Dir)
 				}
+				task.IncludeVars = includedTask.Vars
+				task.IncludedTaskfileVars = includedTaskfile.Vars
 			}
 		}
 
@@ -110,7 +144,7 @@ func Taskfile(dir string, entrypoint string) (*taskfile.Taskfile, error) {
 	}
 
 	if v < 3.0 {
-		path = filepath.Join(dir, fmt.Sprintf("Taskfile_%s.yml", runtime.GOOS))
+		path = filepath.Join(readerNode.Dir, fmt.Sprintf("Taskfile_%s.yml", runtime.GOOS))
 		if _, err = os.Stat(path); err == nil {
 			osTaskfile, err := readTaskfile(path)
 			if err != nil {
@@ -141,3 +175,44 @@ func readTaskfile(file string) (*taskfile.Taskfile, error) {
 	var t taskfile.Taskfile
 	return &t, yaml.NewDecoder(f).Decode(&t)
 }
+
+func exists(path string) (string, error) {
+	fi, err := os.Stat(path)
+	if err != nil {
+		return "", err
+	}
+	if fi.Mode().IsRegular() {
+		return path, nil
+	}
+
+	for _, n := range defaultTaskfiles {
+		fpath := filepath.Join(path, n)
+		if _, err := os.Stat(fpath); err == nil {
+			return fpath, nil
+		}
+	}
+
+	return "", fmt.Errorf(`task: No Taskfile found in "%s". Use "task --init" to create a new one`, path)
+}
+
+func checkCircularIncludes(node *ReaderNode) error {
+	if node == nil {
+		return errors.New("task: failed to check for include cycle: node was nil")
+	}
+	if node.Parent == nil {
+		return errors.New("task: failed to check for include cycle: node.Parent was nil")
+	}
+	var curNode = node
+	var basePath = filepath.Join(node.Dir, node.Entrypoint)
+	for curNode.Parent != nil {
+		curNode = curNode.Parent
+		curPath := filepath.Join(curNode.Dir, curNode.Entrypoint)
+		if curPath == basePath {
+			return fmt.Errorf("task: include cycle detected between %s <--> %s",
+				curPath,
+				filepath.Join(node.Parent.Dir, node.Parent.Entrypoint),
+			)
+		}
+	}
+	return nil
+}

taskfile/task.go

@@ -5,25 +5,27 @@ type Tasks map[string]*Task
 
 // Task represents a task
 type Task struct {
-	Task          string
-	Cmds          []*Cmd
-	Deps          []*Dep
-	Label         string
-	Desc          string
-	Summary       string
-	Sources       []string
-	Generates     []string
-	Status        []string
-	Preconditions []*Precondition
-	Dir           string
-	Vars          *Vars
-	Env           *Vars
-	Silent        bool
-	Interactive   bool
-	Method        string
-	Prefix        string
-	IgnoreError   bool
-	Run           string
+	Task                 string
+	Cmds                 []*Cmd
+	Deps                 []*Dep
+	Label                string
+	Desc                 string
+	Summary              string
+	Sources              []string
+	Generates            []string
+	Status               []string
+	Preconditions        []*Precondition
+	Dir                  string
+	Vars                 *Vars
+	Env                  *Vars
+	Silent               bool
+	Interactive          bool
+	Method               string
+	Prefix               string
+	IgnoreError          bool
+	Run                  string
+	IncludeVars          *Vars
+	IncludedTaskfileVars *Vars
 }
 
 func (t *Task) Name() string {

taskfile/taskfile.go

@@ -9,7 +9,7 @@ import (
 type Taskfile struct {
 	Version    string
 	Expansions int
-	Output     string
+	Output     Output
 	Method     string
 	Includes   *IncludedTaskfiles
 	Vars       *Vars
@@ -25,7 +25,7 @@ func (tf *Taskfile) UnmarshalYAML(unmarshal func(interface{}) error) error {
 	var taskfile struct {
 		Version    string
 		Expansions int
-		Output     string
+		Output     Output
 		Method     string
 		Includes   *IncludedTaskfiles
 		Vars       *Vars

taskfile/taskfile_test.go

@@ -19,6 +19,8 @@ vars:
   PARAM1: VALUE1
   PARAM2: VALUE2
 `
+		yamlDeferredCall = `defer: { task: some_task, vars: { PARAM1: "var" } }`
+		yamlDeferredCmd  = `defer: echo 'test'`
 	)
 	tests := []struct {
 		content  string
@@ -41,6 +43,21 @@ vars:
 				},
 			}},
 		},
+		{
+			yamlDeferredCmd,
+			&taskfile.Cmd{},
+			&taskfile.Cmd{Cmd: "echo 'test'", Defer: true},
+		},
+		{
+			yamlDeferredCall,
+			&taskfile.Cmd{},
+			&taskfile.Cmd{Task: "some_task", Vars: &taskfile.Vars{
+				Keys: []string{"PARAM1"},
+				Mapping: map[string]taskfile.Var{
+					"PARAM1": taskfile.Var{Static: "var"},
+				},
+			}, Defer: true},
+		},
 		{
 			yamlDep,
 			&taskfile.Dep{},

taskfile/var.go

@@ -2,7 +2,6 @@ package taskfile
 
 import (
 	"errors"
-	"strings"
 
 	"gopkg.in/yaml.v3"
 )
@@ -37,7 +36,7 @@ func (vs *Vars) UnmarshalYAML(node *yaml.Node) error {
 
 // Merge merges the given Vars into the caller one
 func (vs *Vars) Merge(other *Vars) {
-	other.Range(func(key string, value Var) error {
+	_ = other.Range(func(key string, value Var) error {
 		vs.Set(key, value)
 		return nil
 	})
@@ -71,7 +70,7 @@ func (vs *Vars) Range(yield func(key string, value Var) error) error {
 // variables
 func (vs *Vars) ToCacheMap() (m map[string]interface{}) {
 	m = make(map[string]interface{}, vs.Len())
-	vs.Range(func(k string, v Var) error {
+	_ = vs.Range(func(k string, v Var) error {
 		if v.Sh != "" {
 			// Dynamic variable is not yet resolved; trigger
 			// <no value> to be used in templates.
@@ -108,11 +107,7 @@ type Var struct {
 func (v *Var) UnmarshalYAML(unmarshal func(interface{}) error) error {
 	var str string
 	if err := unmarshal(&str); err == nil {
-		if strings.HasPrefix(str, "$") {
-			v.Sh = strings.TrimPrefix(str, "$")
-		} else {
-			v.Static = str
-		}
+		v.Static = str
 		return nil
 	}
 

testdata/deferred/Taskfile.yml

@@ -0,0 +1,12 @@
+version: "3"
+
+tasks:
+  task-1:
+    - echo 'task-1 ran {{.PARAM}}'
+
+  task-2:
+    - defer: { task: "task-1", vars: { PARAM: "successfully" } }
+    - defer: echo 'echo ran'
+    - defer: echo 'failing' && exit 2
+    - echo 'cmd ran'
+    - exit 1

testdata/dir/dynamic_var_on_created_dir/Taskfile.yml

@@ -0,0 +1,10 @@
+version: '3'
+
+tasks:
+  default:
+    dir: created
+    cmds:
+      - echo {{.TASK_DIR}}
+    vars:
+      TASK_DIR:
+        sh: echo $(pwd)

testdata/error_code/Taskfile.yml

@@ -0,0 +1,6 @@
+version: '3'
+
+tasks:
+  test-exit-code:
+    cmds:
+      - exit 42

testdata/file_names/.gitignore

@@ -0,0 +1 @@
+*.txt

testdata/file_names/Taskfile.dist.yaml/Taskfile.dist.yaml

@@ -0,0 +1,4 @@
+version: '3'
+
+tasks:
+  default: echo "hello" > output.txt

testdata/file_names/Taskfile.dist.yml/Taskfile.dist.yml

@@ -0,0 +1,4 @@
+version: '3'
+
+tasks:
+  default: echo "hello" > output.txt

testdata/file_names/Taskfile.yaml/Taskfile.yaml

@@ -0,0 +1,4 @@
+version: '3'
+
+tasks:
+  default: echo "hello" > output.txt

testdata/file_names/Taskfile.yml/Taskfile.yml

@@ -0,0 +1,4 @@
+version: '3'
+
+tasks:
+  default: echo "hello" > output.txt

testdata/ignore_nil_elements/includes/Taskfile.yml

@@ -0,0 +1,9 @@
+version: '3'
+
+includes:
+  inc: inc.yml
+
+tasks:
+  default:
+    cmds:
+      - task: inc:default

testdata/ignore_nil_elements/includes/inc.yml

@@ -0,0 +1,7 @@
+version: '3'
+
+tasks:
+  default:
+    cmds:
+      - 
+      - echo "string-slice-1"