feat: wildcard matching for task names

args/args.go

@@ -7,13 +7,13 @@ import (
 )
 
 // Parse parses command line argument: tasks and global variables
-func Parse(args ...string) ([]ast.Call, *ast.Vars) {
-	calls := []ast.Call{}
+func Parse(args ...string) ([]*ast.Call, *ast.Vars) {
+	calls := []*ast.Call{}
 	globals := &ast.Vars{}
 
 	for _, arg := range args {
 		if !strings.Contains(arg, "=") {
-			calls = append(calls, ast.Call{Task: arg})
+			calls = append(calls, &ast.Call{Task: arg})
 			continue
 		}
 

args/args_test.go

@@ -14,20 +14,20 @@ import (
 func TestArgs(t *testing.T) {
 	tests := []struct {
 		Args            []string
-		ExpectedCalls   []ast.Call
+		ExpectedCalls   []*ast.Call
 		ExpectedGlobals *ast.Vars
 	}{
 		{
 			Args: []string{"task-a", "task-b", "task-c"},
-			ExpectedCalls: []ast.Call{
+			ExpectedCalls: []*ast.Call{
 				{Task: "task-a"},
 				{Task: "task-b"},
 				{Task: "task-c"},
 			},
 		},
 		{
 			Args: []string{"task-a", "FOO=bar", "task-b", "task-c", "BAR=baz", "BAZ=foo"},
-			ExpectedCalls: []ast.Call{
+			ExpectedCalls: []*ast.Call{
 				{Task: "task-a"},
 				{Task: "task-b"},
 				{Task: "task-c"},
@@ -45,7 +45,7 @@ func TestArgs(t *testing.T) {
 		},
 		{
 			Args: []string{"task-a", "CONTENT=with some spaces"},
-			ExpectedCalls: []ast.Call{
+			ExpectedCalls: []*ast.Call{
 				{Task: "task-a"},
 			},
 			ExpectedGlobals: &ast.Vars{
@@ -59,7 +59,7 @@ func TestArgs(t *testing.T) {
 		},
 		{
 			Args: []string{"FOO=bar", "task-a", "task-b"},
-			ExpectedCalls: []ast.Call{
+			ExpectedCalls: []*ast.Call{
 				{Task: "task-a"},
 				{Task: "task-b"},
 			},
@@ -74,15 +74,15 @@ func TestArgs(t *testing.T) {
 		},
 		{
 			Args:          nil,
-			ExpectedCalls: []ast.Call{},
+			ExpectedCalls: []*ast.Call{},
 		},
 		{
 			Args:          []string{},
-			ExpectedCalls: []ast.Call{},
+			ExpectedCalls: []*ast.Call{},
 		},
 		{
 			Args:          []string{"FOO=bar", "BAR=baz"},
-			ExpectedCalls: []ast.Call{},
+			ExpectedCalls: []*ast.Call{},
 			ExpectedGlobals: &ast.Vars{
 				OrderedMap: omap.FromMapWithOrder(
 					map[string]ast.Var{

cmd/task/task.go

@@ -291,7 +291,7 @@ func run() error {
 	}
 
 	var (
-		calls   []ast.Call
+		calls   []*ast.Call
 		globals *ast.Vars
 	)
 
@@ -304,7 +304,7 @@ func run() error {
 
 	// If there are no calls, run the default task instead
 	if len(calls) == 0 {
-		calls = append(calls, ast.Call{Task: "default"})
+		calls = append(calls, &ast.Call{Task: "default"})
 	}
 
 	globals.Set("CLI_ARGS", ast.Var{Value: cliArgs})

docs/docs/usage.md

@@ -1205,6 +1205,53 @@ tasks:
       - yarn {{.CLI_ARGS}}
 ```
 
+## Wildcard arguments
+
+Another way to parse arguments into a task is to use a wildcard in your task's
+name. Wildcards are denoted by an asterisk (`*`) and can be used multiple times
+in a task's name to pass in multiple arguments.
+
+Matching arguments will be captured and stored in the `.MATCH` variable and can
+then be used in your task's commands like any other variable. This variable is
+an array of strings and so will need to be indexed to access the individual
+arguments. We suggest creating a named variable for each argument to make it
+clear what they contain:
+
+```yaml
+version: '3'
+
+tasks:
+  echo-*:
+    vars:
+      TEXT: '{{index .MATCH 0}}'
+    cmds:
+      - echo {{.TEXT}}
+
+  run-*-*:
+    vars:
+      ARG_1: '{{index .MATCH 0}}'
+      ARG_2: '{{index .MATCH 1}}'
+    cmds:
+      - echo {{.ARG_1}} {{.ARG_2}}
+```
+
+```shell
+# This call matches the "echo-*" task and the string "hello" is captured by the
+# wildcard and stored in the .MATCH variable. We then index the .MATCH array and
+# store the result in the .TEXT variable which is then echoed out in the cmds.
+$ task echo-hello
+hello
+# You can use whitespace in your arguments as long as you quote the task name
+$ task "echo-hello world"
+hello world
+# And you can pass multiple arguments
+$ task run-foo-bar
+foo bar
+```
+
+If multiple matching tasks are found, an error occurs. If you are using included
+Taskfiles, tasks in parent files will be considered first.
+
 ## Doing task cleanup with `defer`
 
 With the `defer` keyword, it's possible to schedule cleanup to be run once the

errors/errors_task.go

@@ -65,15 +65,15 @@ func (err *TaskInternalError) Code() int {
 	return CodeTaskInternal
 }
 
-// TaskNameConflictError is returned when multiple tasks with the same name or
+// TaskNameConflictError is returned when multiple tasks with a matching name or
 // alias are found.
 type TaskNameConflictError struct {
-	AliasName string
+	Call      string
 	TaskNames []string
 }
 
 func (err *TaskNameConflictError) Error() string {
-	return fmt.Sprintf(`task: Multiple tasks (%s) with alias %q found`, strings.Join(err.TaskNames, ", "), err.AliasName)
+	return fmt.Sprintf(`task: Found multiple tasks (%s) that match %q`, strings.Join(err.TaskNames, ", "), err.Call)
 }
 
 func (err *TaskNameConflictError) Code() int {

internal/compiler/compiler.go

@@ -36,12 +36,12 @@ func (c *Compiler) GetTaskfileVariables() (*ast.Vars, error) {
 	return c.getVariables(nil, nil, true)
 }
 
-func (c *Compiler) GetVariables(t *ast.Task, call ast.Call) (*ast.Vars, error) {
-	return c.getVariables(t, &call, true)
+func (c *Compiler) GetVariables(t *ast.Task, call *ast.Call) (*ast.Vars, error) {
+	return c.getVariables(t, call, true)
 }
 
-func (c *Compiler) FastGetVariables(t *ast.Task, call ast.Call) (*ast.Vars, error) {
-	return c.getVariables(t, &call, false)
+func (c *Compiler) FastGetVariables(t *ast.Task, call *ast.Call) (*ast.Vars, error) {
+	return c.getVariables(t, call, false)
 }
 
 func (c *Compiler) getVariables(t *ast.Task, call *ast.Call, evaluateShVars bool) (*ast.Vars, error) {

internal/summary/summary.go

@@ -7,7 +7,7 @@ import (
 	"github.com/go-task/task/v3/taskfile/ast"
 )
 
-func PrintTasks(l *logger.Logger, t *ast.Taskfile, c []ast.Call) {
+func PrintTasks(l *logger.Logger, t *ast.Taskfile, c []*ast.Call) {
 	for i, call := range c {
 		PrintSpaceBetweenSummaries(l, i)
 		PrintTask(l, t.Tasks.Get(call.Task))

internal/summary/summary_test.go

@@ -163,7 +163,7 @@ func TestPrintAllWithSpaces(t *testing.T) {
 
 	summary.PrintTasks(&l,
 		&ast.Taskfile{Tasks: tasks},
-		[]ast.Call{{Task: "t1"}, {Task: "t2"}, {Task: "t3"}})
+		[]*ast.Call{{Task: "t1"}, {Task: "t2"}, {Task: "t3"}})
 
 	assert.True(t, strings.HasPrefix(buffer.String(), "task: t1"))
 	assert.Contains(t, buffer.String(), "\n(task does not have description or summary)\n\n\ntask: t2")

requires.go

@@ -7,7 +7,7 @@ import (
 	"github.com/go-task/task/v3/taskfile/ast"
 )
 
-func (e *Executor) areTaskRequiredVarsSet(ctx context.Context, t *ast.Task, call ast.Call) error {
+func (e *Executor) areTaskRequiredVarsSet(ctx context.Context, t *ast.Task, call *ast.Call) error {
 	if t.Requires == nil || len(t.Requires.Vars) == 0 {
 		return nil
 	}

status.go

@@ -9,7 +9,7 @@ import (
 )
 
 // Status returns an error if any the of given tasks is not up-to-date
-func (e *Executor) Status(ctx context.Context, calls ...ast.Call) error {
+func (e *Executor) Status(ctx context.Context, calls ...*ast.Call) error {
 	for _, call := range calls {
 
 		// Compile the task

task.go

@@ -80,7 +80,7 @@ type Executor struct {
 }
 
 // Run runs Task
-func (e *Executor) Run(ctx context.Context, calls ...ast.Call) error {
+func (e *Executor) Run(ctx context.Context, calls ...*ast.Call) error {
 	// check if given tasks exist
 	for _, call := range calls {
 		task, err := e.GetTask(call)
@@ -142,7 +142,7 @@ func (e *Executor) Run(ctx context.Context, calls ...ast.Call) error {
 	return nil
 }
 
-func (e *Executor) splitRegularAndWatchCalls(calls ...ast.Call) (regularCalls []ast.Call, watchCalls []ast.Call, err error) {
+func (e *Executor) splitRegularAndWatchCalls(calls ...*ast.Call) (regularCalls []*ast.Call, watchCalls []*ast.Call, err error) {
 	for _, c := range calls {
 		t, err := e.GetTask(c)
 		if err != nil {
@@ -159,7 +159,7 @@ func (e *Executor) splitRegularAndWatchCalls(calls ...ast.Call) (regularCalls []
 }
 
 // RunTask runs a task by its name
-func (e *Executor) RunTask(ctx context.Context, call ast.Call) error {
+func (e *Executor) RunTask(ctx context.Context, call *ast.Call) error {
 	t, err := e.FastCompiledTask(call)
 	if err != nil {
 		return err
@@ -296,7 +296,7 @@ func (e *Executor) runDeps(ctx context.Context, t *ast.Task) error {
 	for _, d := range t.Deps {
 		d := d
 		g.Go(func() error {
-			err := e.RunTask(ctx, ast.Call{Task: d.Task, Vars: d.Vars, Silent: d.Silent, Indirect: true})
+			err := e.RunTask(ctx, &ast.Call{Task: d.Task, Vars: d.Vars, Silent: d.Silent, Indirect: true})
 			if err != nil {
 				return err
 			}
@@ -307,7 +307,7 @@ func (e *Executor) runDeps(ctx context.Context, t *ast.Task) error {
 	return g.Wait()
 }
 
-func (e *Executor) runDeferred(t *ast.Task, call ast.Call, i int) {
+func (e *Executor) runDeferred(t *ast.Task, call *ast.Call, i int) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
@@ -316,15 +316,15 @@ func (e *Executor) runDeferred(t *ast.Task, call ast.Call, i int) {
 	}
 }
 
-func (e *Executor) runCommand(ctx context.Context, t *ast.Task, call ast.Call, i int) error {
+func (e *Executor) runCommand(ctx context.Context, t *ast.Task, call *ast.Call, i int) error {
 	cmd := t.Cmds[i]
 
 	switch {
 	case cmd.Task != "":
 		reacquire := e.releaseConcurrencyLimit()
 		defer reacquire()
 
-		err := e.RunTask(ctx, ast.Call{Task: cmd.Task, Vars: cmd.Vars, Silent: cmd.Silent, Indirect: true})
+		err := e.RunTask(ctx, &ast.Call{Task: cmd.Task, Vars: cmd.Vars, Silent: cmd.Silent, Indirect: true})
 		if err != nil {
 			return err
 		}
@@ -413,14 +413,30 @@ func (e *Executor) startExecution(ctx context.Context, t *ast.Task, execute func
 // GetTask will return the task with the name matching the given call from the taskfile.
 // If no task is found, it will search for tasks with a matching alias.
 // If multiple tasks contain the same alias or no matches are found an error is returned.
-func (e *Executor) GetTask(call ast.Call) (*ast.Task, error) {
+func (e *Executor) GetTask(call *ast.Call) (*ast.Task, error) {
 	// Search for a matching task
-	matchingTask := e.Taskfile.Tasks.Get(call.Task)
-	if matchingTask != nil {
-		return matchingTask, nil
+	matchingTasks := e.Taskfile.Tasks.FindMatchingTasks(call)
+	switch len(matchingTasks) {
+	case 0: // Carry on
+	case 1:
+		if call.Vars == nil {
+			call.Vars = &ast.Vars{}
+		}
+		call.Vars.Set("MATCH", ast.Var{Value: matchingTasks[0].Wildcards})
+		return matchingTasks[0].Task, nil
+	default:
+		taskNames := make([]string, len(matchingTasks))
+		for i, matchingTask := range matchingTasks {
+			taskNames[i] = matchingTask.Task.Task
+		}
+		return nil, &errors.TaskNameConflictError{
+			Call:      call.Task,
+			TaskNames: taskNames,
+		}
 	}
 
 	// If didn't find one, search for a task with a matching alias
+	var matchingTask *ast.Task
 	var aliasedTasks []string
 	for _, task := range e.Taskfile.Tasks.Values() {
 		if slices.Contains(task.Aliases, call.Task) {
@@ -431,7 +447,7 @@ func (e *Executor) GetTask(call ast.Call) (*ast.Task, error) {
 	// If we found multiple tasks
 	if len(aliasedTasks) > 1 {
 		return nil, &errors.TaskNameConflictError{
-			AliasName: call.Task,
+			Call:      call.Task,
 			TaskNames: aliasedTasks,
 		}
 	}
@@ -476,7 +492,7 @@ func (e *Executor) GetTaskList(filters ...FilterFunc) ([]*ast.Task, error) {
 		idx := i
 		task := tasks[idx]
 		g.Go(func() error {
-			compiledTask, err := e.FastCompiledTask(ast.Call{Task: task.Task})
+			compiledTask, err := e.FastCompiledTask(&ast.Call{Task: task.Task})
 			if err != nil {
 				return err
 			}