feat: add interactive TUI for task execution

Taskfile.yml

@@ -144,13 +144,13 @@ tasks:
     desc: Runs test suite with watch tests included
     deps: [sleepit:build, gotestsum:install]
     cmds:
-      - gotestsum -f '{{.GOTESTSUM_FORMAT}}' ./... -tags 'watch'
+      - gotestsum -f '{{.GOTESTSUM_FORMAT}}' -- -tags 'watch' ./...
 
   test:all:
     desc: Runs test suite with signals and watch tests included
     deps: [sleepit:build, gotestsum:install]
     cmds:
-      - gotestsum -f '{{.GOTESTSUM_FORMAT}}' -tags 'signals watch' ./...
+      - gotestsum -f '{{.GOTESTSUM_FORMAT}}' -- -tags 'signals watch' ./...
 
   bench:checksum:
     desc: Runs checksum benchmarks

call.go

@@ -8,4 +8,8 @@ type Call struct {
 	Vars     *ast.Vars
 	Silent   bool
 	Indirect bool // True if the task was called by another task
+
+	invocationID       uint64
+	parentInvocationID uint64
+	rootInvocationID   uint64
 }

cmd/task/task.go

@@ -16,6 +16,7 @@ import (
 	"github.com/go-task/task/v3/internal/filepathext"
 	"github.com/go-task/task/v3/internal/flags"
 	"github.com/go-task/task/v3/internal/logger"
+	"github.com/go-task/task/v3/internal/tui"
 	"github.com/go-task/task/v3/internal/version"
 	"github.com/go-task/task/v3/taskfile/ast"
 )
@@ -168,7 +169,7 @@ func run() error {
 	calls, globals := args.Parse(cliArgsPreDash...)
 
 	// If there are no calls, run the default task instead
-	if len(calls) == 0 {
+	if len(calls) == 0 && !flags.TUI {
 		calls = append(calls, &task.Call{Task: "default"})
 	}
 
@@ -198,6 +199,16 @@ func run() error {
 	if flags.Status {
 		return e.Status(ctx, calls...)
 	}
+	if flags.TUI {
+		ui, err := tui.New(e.Logger, tui.Options{
+			Status:        flags.TUIStatus,
+			TaskNavigator: flags.TUITaskNavigator,
+		})
+		if err != nil {
+			return err
+		}
+		return ui.Run(ctx, e, calls)
+	}
 
 	return e.Run(ctx, calls...)
 }

executor.go

@@ -68,6 +68,8 @@ type (
 		Compiler           *Compiler
 		Output             output.Output
 		OutputStyle        ast.Output
+		Listener           *Listener // Optional; observes execution and may draw the display
+		Prompter           Prompter  // Optional; answers the questions Task asks
 		TaskSorter         sort.Sorter
 		UserWorkingDir     string
 		EnableVersionCheck bool
@@ -81,6 +83,7 @@ type (
 		mkdirMutexMap        map[string]*sync.Mutex
 		executionHashes      map[string]*executionState
 		executionHashesMutex sync.Mutex
+		taskInvocationID     uint64
 		watchedDirs          *xsync.Map[string, bool]
 	}
 	TempDir struct {

go.mod

@@ -10,6 +10,7 @@ require (
 	github.com/Masterminds/semver/v3 v3.5.0
 	github.com/alecthomas/chroma/v2 v2.27.0
 	github.com/chainguard-dev/git-urls v1.0.2
+	github.com/charmbracelet/x/ansi v0.11.8
 	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc
 	github.com/dominikbraun/graph v0.23.0
 	github.com/elliotchance/orderedmap/v3 v3.1.1
@@ -69,7 +70,6 @@ require (
 	github.com/cespare/xxhash/v2 v2.3.0 // indirect
 	github.com/charmbracelet/colorprofile v0.4.3 // indirect
 	github.com/charmbracelet/ultraviolet v0.0.0-20260811164956-006e29f97886 // indirect
-	github.com/charmbracelet/x/ansi v0.11.8 // indirect
 	github.com/charmbracelet/x/term v0.2.2 // indirect
 	github.com/charmbracelet/x/termios v0.1.1 // indirect
 	github.com/charmbracelet/x/windows v0.2.2 // indirect

internal/flags/flags.go

@@ -70,6 +70,9 @@ var (
 	Concurrency         int
 	Dir                 string
 	Entrypoint          string
+	TUI                 bool
+	TUIStatus           string
+	TUITaskNavigator    string
 	Output              ast.Output
 	Color               bool
 	Interval            time.Duration
@@ -144,6 +147,9 @@ func init() {
 	pflag.BoolVarP(&ExitCode, "exit-code", "x", false, "Pass-through the exit code of the task command.")
 	pflag.StringVarP(&Dir, "dir", "d", "", "Sets the directory in which Task will execute and look for a Taskfile.")
 	pflag.StringVarP(&Entrypoint, "taskfile", "t", "", `Choose which Taskfile to run. Defaults to "Taskfile.yml".`)
+	pflag.BoolVarP(&TUI, "tui", "T", false, "Runs Task in an interactive terminal interface.")
+	pflag.StringVar(&TUIStatus, "tui-status", getConfig(config, "TUI_STATUS", func() *string { return config.TUI.Status }, ""), "Sets TUI task status style: [icons|labels].")
+	pflag.StringVar(&TUITaskNavigator, "tui-task-navigator", getConfig(config, "TUI_TASK_NAVIGATOR", func() *string { return config.TUI.TaskNavigator }, ""), "Sets TUI task navigator: [list|tree]. Defaults to tree.")
 	pflag.StringVar(&TempDir, "temp-dir", getConfig(config, "TEMP_DIR", func() *string { return config.TempDir }, ""), "Sets the directory used to store Task temporary files, such as checksums. Relative paths are relative to the root Taskfile.")
 	pflag.StringVarP(&Output.Name, "output", "o", getConfig(config, "OUTPUT", func() *string { return nil }, ""), "Sets output style: [interleaved|group|prefixed].")
 	pflag.StringVar(&Output.Group.Begin, "output-group-begin", getConfig(config, "OUTPUT_GROUP_BEGIN", func() *string { return nil }, ""), "Message template to print before a task's grouped output.")
@@ -213,16 +219,17 @@ func Validate() error {
 		return errors.New("task: You can't set both --global and --dir")
 	}
 
-	if Output.Name != "group" {
-		if Output.Group.Begin != "" {
-			return errors.New("task: You can't set --output-group-begin without --output=group")
-		}
-		if Output.Group.End != "" {
-			return errors.New("task: You can't set --output-group-end without --output=group")
-		}
-		if Output.Group.ErrorOnly {
-			return errors.New("task: You can't set --output-group-error-only without --output=group")
-		}
+	if err := validateOutputOptions(Output); err != nil {
+		return err
+	}
+	if err := validateTUIOptions(TUI, pflag.Lookup("tui-status").Changed, pflag.Lookup("tui-task-navigator").Changed); err != nil {
+		return err
+	}
+	if TUI && (List || ListAll || ListJson || Status || Summary || Watch) {
+		return errors.New("task: --tui cannot be combined with task listing, status, summary, or watch modes")
+	}
+	if err := validateTUIPrompting(TUI, Interactive, pflag.Lookup("interactive").Changed); err != nil {
+		return err
 	}
 
 	if List && ListAll {
@@ -249,6 +256,51 @@ func Validate() error {
 	return nil
 }
 
+func validateOutputOptions(output ast.Output) error {
+	if output.Name != "group" {
+		if output.Group.Begin != "" {
+			return errors.New("task: You can't set --output-group-begin without --output=group")
+		}
+		if output.Group.End != "" {
+			return errors.New("task: You can't set --output-group-end without --output=group")
+		}
+		if output.Group.ErrorOnly {
+			return errors.New("task: You can't set --output-group-error-only without --output=group")
+		}
+	}
+	return nil
+}
+
+// validateTUIPrompting rejects turning prompting off while the TUI is on.
+//
+// The interface asks in its own dialog, so it does not consult --interactive,
+// and passing it would be silently ignored. It cannot honour the flag either:
+// a task requiring a variable would then be unrunnable from the launcher,
+// which has nowhere to pass one.
+func validateTUIPrompting(tui, interactive, interactiveSet bool) error {
+	if tui && interactiveSet && !interactive {
+		return errors.New(
+			"task: You can't set --interactive=false with --tui: the interface asks in its own dialog")
+	}
+	return nil
+}
+
+// validateTUIOptions rejects the interface's display options without the
+// interface. Only the flags are rejected: the same settings in .taskrc.yml are
+// defaults for the runs that do use it, and must not fail the ones that don't.
+func validateTUIOptions(enabled, statusSet, navigatorSet bool) error {
+	if enabled {
+		return nil
+	}
+	if statusSet {
+		return errors.New("task: You can't set --tui-status without --tui")
+	}
+	if navigatorSet {
+		return errors.New("task: You can't set --tui-task-navigator without --tui")
+	}
+	return nil
+}
+
 // WithFlags is a special internal functional option that is used to pass flags
 // from the CLI into any constructor that accepts functional options.
 func WithFlags() task.ExecutorOption {

internal/flags/flags_test.go

@@ -0,0 +1,115 @@
+package flags
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/go-task/task/v3/taskfile/ast"
+)
+
+func TestValidateOutputOptions(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name      string
+		output    ast.Output
+		wantError string
+	}{
+		{
+			name:   "group options with group output",
+			output: ast.Output{Name: "group", Group: ast.OutputGroup{Begin: "begin", End: "end", ErrorOnly: true}},
+		},
+		{
+			name:      "group option without group output",
+			output:    ast.Output{Name: "interleaved", Group: ast.OutputGroup{Begin: "begin"}},
+			wantError: "--output-group-begin without --output=group",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			t.Parallel()
+
+			err := validateOutputOptions(test.output)
+			if test.wantError == "" {
+				require.NoError(t, err)
+				return
+			}
+			require.Error(t, err)
+			assert.Contains(t, err.Error(), test.wantError)
+		})
+	}
+}
+
+func TestValidateTUIOptions(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name         string
+		enabled      bool
+		statusSet    bool
+		navigatorSet bool
+		wantError    string
+	}{
+		{name: "TUI without options", enabled: true},
+		{name: "TUI with options", enabled: true, statusSet: true, navigatorSet: true},
+		{name: "status flag without TUI", statusSet: true, wantError: "--tui-status without --tui"},
+		{name: "navigator flag without TUI", navigatorSet: true, wantError: "--tui-task-navigator without --tui"},
+		// A .taskrc.yml default leaves the flags unchanged, so an ordinary run
+		// is not failed by settings that only apply to the interface.
+		{name: "options configured, TUI off"},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			t.Parallel()
+
+			err := validateTUIOptions(test.enabled, test.statusSet, test.navigatorSet)
+			if test.wantError == "" {
+				require.NoError(t, err)
+				return
+			}
+			require.Error(t, err)
+			assert.Contains(t, err.Error(), test.wantError)
+		})
+	}
+}
+
+func TestValidateTUIPrompting(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name           string
+		tui            bool
+		interactive    bool
+		interactiveSet bool
+		wantError      string
+	}{
+		{name: "TUI alone"},
+		{name: "TUI without the flag", tui: true},
+		{name: "TUI with prompting asked for", tui: true, interactive: true, interactiveSet: true},
+		{
+			name: "TUI with prompting turned off", tui: true, interactiveSet: true,
+			wantError: "--interactive=false with --tui",
+		},
+		// The flag defaults to false, so an unset flag must not be mistaken for
+		// a request to turn prompting off.
+		{name: "TUI with the flag left alone", tui: true, interactive: false},
+		// Without the TUI the flag means what it always has.
+		{name: "prompting turned off on its own", interactiveSet: true},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			t.Parallel()
+			err := validateTUIPrompting(test.tui, test.interactive, test.interactiveSet)
+			if test.wantError == "" {
+				require.NoError(t, err)
+				return
+			}
+			require.Error(t, err)
+			assert.Contains(t, err.Error(), test.wantError)
+		})
+	}
+}