add wildcards (*, ?, [...])

- unquoted * ? and [...] (including [!...]) are expanded to the
  matching file names, sorted, per path component
- hidden files only match if the pattern starts with a dot, a trailing /
  only matches directories, a pattern without match is kept as is
- quoted or escaped characters and values of variables are never
  expanded
- redirections to a pattern must match exactly one file
- completion escapes * ? [ and $ in file names

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

README.md

@@ -23,6 +23,9 @@ Features:
     override with $GOSH_HISTFILE); lines starting with a space are not saved
   - Tab completion for commands and file paths
   - Tilde expansion (~, ~/path) at the start of unquoted words
+  - Wildcards: * ? [abc] [a-z] [!abc] match file names (not hidden files
+    unless the pattern starts with a dot); quoted wildcards and values of
+    variables are not expanded, a pattern without match is kept as is
   - Colored prompt (user@host green, red for root; directory blue),
     configurable with $GOSH_COLORS, e.g. GOSH_COLORS='user=1;33:path=36'
     (keys user, root, path; values are ANSI SGR codes, empty = no color);
@@ -31,6 +34,8 @@ Features:
     using an unset variable is an error, use ${VAR:-} for an empty default
   - Command lists: a ; b (run both), a && b (b only if a succeeded),
     a || b (b only if a failed); $? is the exit status of the last command
+  - Pipes (a | b) and redirections: < file, > file, >> file, 2> file,
+    2>> file, 2>&1, >&2, &> file (stdout and stderr), &>> file
   - Non-interactive use: gosh -c 'command', gosh script, command | gosh;
     the exit status is the one of the last command
 
@@ -55,7 +60,7 @@ gosh -version
 
 Ohne Terminal bricht gosh bei einem fehlgeschlagenen Befehl nicht ab und beendet sich mit dem Exit-Status des letzten Befehls: `127`, wenn ein Befehl nicht gefunden wurde, `126`, wenn er nicht ausführbar ist, `128+n`, wenn er durch Signal `n` beendet wurde. Leere Zeilen und Zeilen, die mit `#` beginnen, werden übersprungen, Skripte können also mit `#!/usr/bin/gosh` beginnen.
 
-Damit funktionieren auch `ssh host befehl`, `scp` und `rsync`, wenn gosh als Login-Shell gesetzt ist. Befehle lassen sich mit `;`, `&&` und `||` verketten (z. B. `ssh host 'cd /srv && git pull'`), Pipes und Umleitungen kennt gosh aber noch nicht.
+Damit funktionieren auch `ssh host befehl`, `scp` und `rsync`, wenn gosh als Login-Shell gesetzt ist. Befehle lassen sich mit `;`, `&&` und `||` verketten und mit Pipes verbinden, z. B. `ssh host 'cd /srv && git log | head'`.
 
 ### Befehlslisten und Exit-Status
 
@@ -81,6 +86,59 @@ Status 127
 
 Schlägt ein Programm fehl, gibt gosh selbst keine Meldung mehr aus (das Programm meldet den Fehler selbst), nur bei Fehlern von gosh, z. B. wenn ein Befehl nicht gefunden wird.
 
+### Wildcards
+
+Wörter mit `*`, `?` oder `[...]` werden durch die passenden Dateinamen ersetzt, sortiert:
+
+| Muster    | passt auf                                           |
+|-----------|-----------------------------------------------------|
+| `*`       | beliebig viele Zeichen (auch keine)                 |
+| `?`       | genau ein Zeichen                                   |
+| `[abc]`   | eines der Zeichen `a`, `b`, `c`                     |
+| `[a-z]`   | ein Zeichen aus dem Bereich                         |
+| `[!abc]`  | ein Zeichen außer `a`, `b`, `c` (auch `[^abc]`)     |
+
+```
+$ ls *.go
+main.go  main_test.go
+$ cat logs/2026-*/error.log
+$ ls -d */            # nur Verzeichnisse
+```
+
+- Muster gelten pro Pfadteil, `*` passt nie auf `/`: `*/*.go` findet `.go`-Dateien eine Ebene tiefer.
+- Versteckte Dateien (mit `.` am Anfang) werden nur gefunden, wenn das Muster selbst mit `.` beginnt: `*` findet `.bashrc` nicht, `.*rc` schon.
+- Passt keine Datei, bleibt das Wort unverändert stehen (wie in `sh`), `ls *.xyz` meldet dann also `ls` den Fehler.
+- In Anführungszeichen oder mit `\` davor sind die Zeichen normale Zeichen: `echo "*"`, `echo '*.go'`, `echo \*`.
+- Werte von Variablen werden nicht als Muster behandelt (anders als in `sh`): Nach `set P=*.go` gibt `echo $P` wörtlich `*.go` aus. So kann ein Variablenwert nie unbemerkt auf viele Dateien passen. `echo $DIR/*.go` funktioniert dagegen, weil das `*` direkt in der Zeile steht.
+- Bei einer Umleitung muss das Muster genau eine Datei treffen (`> *.log`), sonst meldet gosh `ambiguous redirect`.
+
+### Pipes und Umleitungen
+
+```
+$ ls | sort -r | head -3
+$ make > build.log 2>&1
+$ grep -c error < build.log
+```
+
+| Syntax          | Bedeutung                                                  |
+|-----------------|------------------------------------------------------------|
+| `a \| b`        | stdout von `a` wird stdin von `b`                          |
+| `< datei`       | stdin aus `datei` lesen                                    |
+| `> datei`       | stdout in `datei` schreiben (wird überschrieben)           |
+| `>> datei`      | stdout an `datei` anhängen                                 |
+| `2> datei`      | stderr in `datei` schreiben (`2>>` hängt an)               |
+| `2>&1`          | stderr dorthin, wohin stdout gerade geht                   |
+| `>&2`           | stdout dorthin, wohin stderr gerade geht                   |
+| `&> datei`      | stdout und stderr in `datei` (`&>>` hängt an)              |
+| `> datei`       | ohne Befehl: legt `datei` an bzw. leert sie                |
+
+- Umleitungen werden von links nach rechts ausgewertet: `befehl > log 2>&1` schreibt beides in `log`, `befehl 2>&1 > log` schickt stderr dorthin, wo stdout vorher hinging (z. B. in eine Pipe).
+- Unterstützt werden die Dateideskriptoren 0, 1 und 2. Vor `>` und `<` zählt nur eine Zahl ohne Anführungszeichen als Deskriptor (`2>f`, aber nicht `x2>f` oder `"2">f`).
+- Operatoren in Anführungszeichen oder mit `\` davor sind normale Zeichen: `echo "a|b" 'c>d' e\>f`.
+- Der Exit-Status einer Pipeline ist der des letzten Befehls. Beendet sich ein Befehl am Ende (z. B. `head`), bekommt der schreibende Befehl davor `SIGPIPE`, `yes | head -1` endet also sofort.
+- Die Built-ins `pwd` und `help` lassen sich umleiten und in Pipes verwenden (`help | less`). `cd`, `set`, `export`, `exit` und `quit` verändern die Shell selbst und sind in einer Pipeline nicht erlaubt.
+- Ein einzelnes `&` (Hintergrundprozesse) gibt es noch nicht, es wird als normales Zeichen übergeben.
+
 ### Farben
 
 Der Prompt wird über die Umgebungsvariable `GOSH_COLORS` eingefärbt. Sie besteht aus durch `:` getrennten Einträgen `schlüssel=code`:

main.go

@@ -12,6 +12,7 @@ import (
 	"os/user"
 	"path/filepath"
 	"runtime/debug"
+	"sort"
 	"strconv"
 	"strings"
 	"syscall"
@@ -111,7 +112,18 @@ func expandTilde(path string) string {
 	return path
 }
 
-// splitWords splits input into words like a (very) simple POSIX shell:
+// token is a word or an operator of a command line.
+type token struct {
+	op      string // "" for a word, otherwise |, <, >, >>, >&, <&, &> or &>>
+	word    string // the word, if op == ""
+	pattern string // the word as glob pattern (quoted characters escaped)
+	glob    bool   // the word contains unquoted * ? or [ and is expanded
+	fd      int    // the redirected file descriptor (for redirections)
+	dup     int    // the target file descriptor of >& and <&
+}
+
+// tokenize splits input into words and operators like a (very) simple POSIX
+// shell:
 //   - words are separated by unquoted blanks, an unquoted # starts a comment
 //   - '...' is taken literally, nothing is expanded inside
 //   - "..." expands $VAR and ${VAR}; \ only escapes $ " \ and `
@@ -120,23 +132,40 @@ func expandTilde(path string) string {
 //     an unset variable is an error, so that e.g. "rm -rf $DIR/x" never runs
 //     with an empty $DIR
 //   - ~ and ~/... are expanded at the start of an unquoted word
+//   - unquoted |, <, >, >>, N<, N>, N>>, N>&M, N<&M, &> and &>> are operators
 //
 // Expanded values are never split into several words.
-func splitWords(input string) ([]string, error) {
+func tokenize(input string) ([]token, error) {
 	var (
-		words   []string
+		tokens   []token
 		b        strings.Builder
+		pat      strings.Builder // the word as glob pattern, quoted parts escaped
+		glob     bool            // the word contains unquoted * ? or [
 		inWord   bool            // a word has been started (even if it is still empty)
 		quote    byte
 		escaped  bool
+		rawStart = -1 // start of the current word in input
 	)
 
 	endWord := func() {
 		if inWord {
-			words = append(words, b.String())
+			tokens = append(tokens, token{word: b.String(), pattern: pat.String(), glob: glob})
 		}
 		b.Reset()
+		pat.Reset()
+		glob = false
 		inWord = false
+		rawStart = -1
+	}
+	// literal adds quoted, escaped or expanded text: it is never a pattern
+	literal := func(s string) {
+		b.WriteString(s)
+		pat.WriteString(escapeGlob(s))
+	}
+	startRaw := func(i int) {
+		if rawStart < 0 {
+			rawStart = i
+		}
 	}
 
 	for i := 0; i < len(input); i++ {
@@ -144,25 +173,29 @@ func splitWords(input string) ([]string, error) {
 		switch {
 		case escaped:
 			if quote == '"' && !strings.ContainsRune("$\"\\`", rune(ch)) {
-				b.WriteByte('\\')
+				literal("\\")
 			}
-			b.WriteByte(ch)
+			literal(string(ch))
 			inWord = true
 			escaped = false
 		case quote == '\'':
 			if ch == '\'' {
 				quote = 0
 			} else {
-				b.WriteByte(ch)
+				literal(string(ch))
 			}
 		case ch == '\\':
+			startRaw(i)
 			escaped = true
 		case ch == '$':
+			startRaw(i)
 			value, n, err := expandVar(input[i:])
 			if err != nil {
 				return nil, err
 			}
-			b.WriteString(value)
+			// Expanded values are never patterns (and never split), so that
+			// e.g. a * in a variable does not match files
+			literal(value)
 			// A literal "$" counts as content, an expansion that is empty does
 			// not (unless quoted), like in sh
 			if n == 1 || value != "" {
@@ -173,9 +206,10 @@ func splitWords(input string) ([]string, error) {
 			if ch == '"' {
 				quote = 0
 			} else {
-				b.WriteByte(ch)
+				literal(string(ch))
 			}
 		case ch == '"' || ch == '\'':
+			startRaw(i)
 			quote = ch
 			inWord = true
 		case ch == ' ' || ch == '\t' || ch == '\n':
@@ -183,16 +217,76 @@ func splitWords(input string) ([]string, error) {
 		case ch == '#' && !inWord && b.Len() == 0:
 			// Comment until the end of the line
 			i = len(input)
+		case ch == '|':
+			endWord()
+			tokens = append(tokens, token{op: "|"})
+		case ch == '&' && i+1 < len(input) && input[i+1] == '>':
+			// &> and &>> redirect stdout and stderr
+			endWord()
+			op := "&>"
+			if i+2 < len(input) && input[i+2] == '>' {
+				op = "&>>"
+			}
+			tokens = append(tokens, token{op: op, fd: 1})
+			i += len(op) - 1
+		case ch == '<' || ch == '>':
+			// A word consisting only of unquoted digits right before the
+			// operator is the file descriptor, e.g. 2>file
+			fd := 0
+			if ch == '>' {
+				fd = 1
+			}
+			if inWord && rawStart >= 0 && isDigits(input[rawStart:i]) {
+				fd, _ = strconv.Atoi(input[rawStart:i])
+				b.Reset()
+				pat.Reset()
+				glob = false
+				inWord = false
+				rawStart = -1
+			} else {
+				endWord()
+			}
+			t := token{op: string(ch), fd: fd}
+			switch {
+			case ch == '>' && i+1 < len(input) && input[i+1] == '>':
+				t.op = ">>"
+				i++
+			case i+1 < len(input) && input[i+1] == '&':
+				// N>&M and N<&M duplicate file descriptor M
+				j := i + 2
+				for j < len(input) && input[j] >= '0' && input[j] <= '9' {
+					j++
+				}
+				if j == i+2 {
+					return nil, syntaxError(input[i : i+2])
+				}
+				t.op = string(ch) + "&"
+				t.dup, _ = strconv.Atoi(input[i+2 : j])
+				i = j - 1
+			}
+			tokens = append(tokens, t)
 		case ch == '~' && !inWord && b.Len() == 0 &&
-			(i+1 == len(input) || strings.IndexByte("/ \t\n", input[i+1]) >= 0):
+			(i+1 == len(input) || strings.IndexByte("/ \t\n|<>", input[i+1]) >= 0):
+			startRaw(i)
 			home := getHomeDir()
 			if home == "" {
 				home = "~"
 			}
-			b.WriteString(home)
+			literal(home)
 			inWord = true
 		default:
+			startRaw(i)
 			b.WriteByte(ch)
+			switch {
+			case ch == '*' || ch == '?' || ch == '[':
+				glob = true
+				pat.WriteByte(ch)
+			case ch == '!' && strings.HasSuffix(pat.String(), "[") && !strings.HasSuffix(pat.String(), "\\["):
+				// POSIX [!...] is [^...] in Go
+				pat.WriteByte('^')
+			default:
+				pat.WriteByte(ch)
+			}
 			inWord = true
 		}
 	}
@@ -204,6 +298,152 @@ func splitWords(input string) ([]string, error) {
 		return nil, fmt.Errorf("unterminated %c quote", quote)
 	}
 	endWord()
+	return tokens, nil
+}
+
+// escapeGlob escapes the characters that are special in a glob pattern.
+func escapeGlob(s string) string {
+	var b strings.Builder
+	for i := 0; i < len(s); i++ {
+		if strings.IndexByte("*?[]\\", s[i]) >= 0 {
+			b.WriteByte('\\')
+		}
+		b.WriteByte(s[i])
+	}
+	return b.String()
+}
+
+// hasGlobMeta reports whether pattern contains an unescaped * ? or [.
+func hasGlobMeta(pattern string) bool {
+	for i := 0; i < len(pattern); i++ {
+		switch pattern[i] {
+		case '\\':
+			i++
+		case '*', '?', '[':
+			return true
+		}
+	}
+	return false
+}
+
+// unescapeGlob removes the escapes from a pattern without wildcards.
+func unescapeGlob(pattern string) string {
+	var b strings.Builder
+	for i := 0; i < len(pattern); i++ {
+		if pattern[i] == '\\' && i+1 < len(pattern) {
+			i++
+		}
+		b.WriteByte(pattern[i])
+	}
+	return b.String()
+}
+
+// expandGlob returns the paths matching pattern, sorted. Like sh, * and ?
+// do not match a leading dot (hidden files), unless the pattern component
+// starts with a dot, and a trailing / only matches directories. An invalid
+// pattern matches nothing.
+func expandGlob(pattern string) []string {
+	paths := []string{""}
+	if strings.HasPrefix(pattern, "/") {
+		paths = []string{"/"}
+	}
+	components := strings.Split(strings.Trim(pattern, "/"), "/")
+	join := func(dir, name string) string {
+		if dir == "" || strings.HasSuffix(dir, "/") {
+			return dir + name
+		}
+		return dir + "/" + name
+	}
+
+	for _, comp := range components {
+		if comp == "" {
+			continue // a//b
+		}
+		var next []string
+		for _, dir := range paths {
+			if !hasGlobMeta(comp) {
+				p := join(dir, unescapeGlob(comp))
+				if _, err := os.Lstat(p); err == nil {
+					next = append(next, p)
+				}
+				continue
+			}
+			readDir := dir
+			if readDir == "" {
+				readDir = "."
+			}
+			entries, err := os.ReadDir(readDir)
+			if err != nil {
+				continue
+			}
+			for _, e := range entries {
+				name := e.Name()
+				if strings.HasPrefix(name, ".") && !strings.HasPrefix(comp, ".") && !strings.HasPrefix(comp, "\\.") {
+					continue
+				}
+				ok, err := filepath.Match(comp, name)
+				if err != nil {
+					return nil
+				}
+				if ok {
+					next = append(next, join(dir, name))
+				}
+			}
+		}
+		paths = next
+	}
+
+	if strings.HasSuffix(pattern, "/") {
+		var dirs []string
+		for _, p := range paths {
+			if info, err := os.Stat(p); err == nil && info.IsDir() {
+				dirs = append(dirs, p+"/")
+			}
+		}
+		paths = dirs
+	}
+	sort.Strings(paths)
+	return paths
+}
+
+// expandWord returns the words a token expands to: the matching paths for
+// a pattern, or the word itself if it is no pattern or nothing matches (like
+// in sh).
+func expandWord(t token) []string {
+	if t.glob {
+		if matches := expandGlob(t.pattern); len(matches) > 0 {
+			return matches
+		}
+	}
+	return []string{t.word}
+}
+
+// isDigits reports whether s is a non-empty string of ASCII digits.
+func isDigits(s string) bool {
+	if s == "" {
+		return false
+	}
+	for i := 0; i < len(s); i++ {
+		if s[i] < '0' || s[i] > '9' {
+			return false
+		}
+	}
+	return true
+}
+
+// splitWords splits input into words (see tokenize). Operators are an error.
+func splitWords(input string) ([]string, error) {
+	tokens, err := tokenize(input)
+	if err != nil {
+		return nil, err
+	}
+	var words []string
+	for _, t := range tokens {
+		if t.op != "" {
+			return nil, fmt.Errorf("unexpected operator %s", t.op)
+		}
+		words = append(words, t.word)
+	}
 	return words, nil
 }
 
@@ -469,7 +709,10 @@ func newShellCompleter() *shellCompleter {
 // runes of the current word that are already typed.
 func (c *shellCompleter) Do(line []rune, pos int) ([][]rune, int) {
 	word, start, quote := currentWord(string(line[:pos]))
-	isFirstWord := strings.TrimSpace(string(line[:start])) == ""
+	// A command is expected at the start and after |, ;, && and ||
+	before := strings.TrimSpace(string(line[:start]))
+	isFirstWord := before == "" || strings.HasSuffix(before, "|") ||
+		strings.HasSuffix(before, ";") || strings.HasSuffix(before, "&&")
 
 	// Plain "~" -> "~/"
 	if word == "~" {
@@ -553,7 +796,8 @@ func currentWord(s string) (word string, start int, quote byte) {
 			}
 		case ch == '"' || ch == '\'':
 			quote = ch
-		case ch == ' ' || ch == '\t':
+		case ch == ' ' || ch == '\t' || strings.IndexByte(";|&<>", ch) >= 0:
+			// Blanks and operators end a word
 			b.Reset()
 			start = i + 1
 		default:
@@ -567,7 +811,7 @@ func currentWord(s string) (word string, start int, quote byte) {
 func escapeWord(s string) string {
 	var b strings.Builder
 	for _, r := range s {
-		if strings.ContainsRune(" \t\\'\"", r) {
+		if strings.ContainsRune(" \t\\'\";|&<>*?[$", r) {
 			b.WriteByte('\\')
 		}
 		b.WriteRune(r)
@@ -743,6 +987,14 @@ func exitStatus(err error) int {
 	if err == nil {
 		return 0
 	}
+	var statusErr statusError
+	if errors.As(err, &statusErr) {
+		return int(statusErr)
+	}
+	var synErr syntaxError
+	if errors.As(err, &synErr) {
+		return 2
+	}
 	var exitErr *exec.ExitError
 	if errors.As(err, &exitErr) {
 		if ws, ok := exitErr.Sys().(syscall.WaitStatus); ok && ws.Signaled() {
@@ -829,6 +1081,21 @@ func interactive() {
 // lastStatus is the exit status of the last command ($?).
 var lastStatus int
 
+// statusError is an error that only carries an exit status; the problem has
+// already been reported.
+type statusError int
+
+func (e statusError) Error() string {
+	return "exit status " + strconv.Itoa(int(e))
+}
+
+// syntaxError is a syntax error in the input (exit status 2, like sh).
+type syntaxError string
+
+func (e syntaxError) Error() string {
+	return "syntax error near unexpected token `" + string(e) + "'"
+}
+
 // errCommandNotFound is returned when an external command does not exist.
 var errCommandNotFound = errors.New("command not found")
 
@@ -836,8 +1103,11 @@ var errCommandNotFound = errors.New("command not found")
 // failed have already reported the problem themselves, only their exit
 // status is kept.
 func printError(err error) {
-	var exitErr *exec.ExitError
-	if err == nil || errors.As(err, &exitErr) {
+	var (
+		exitErr   *exec.ExitError
+		statusErr statusError
+	)
+	if err == nil || errors.As(err, &exitErr) || errors.As(err, &statusErr) {
 		return
 	}
 	fmt.Fprintln(os.Stderr, "gosh:", err)
@@ -872,7 +1142,7 @@ func splitList(input string) ([]listItem, error) {
 				if next == "" {
 					next = op
 				}
-				return fmt.Errorf("syntax error near unexpected token `%s'", next)
+				return syntaxError(next)
 			}
 			return nil
 		}
@@ -940,7 +1210,7 @@ scan:
 func execInput(input string) error {
 	items, err := splitList(input)
 	if err != nil {
-		lastStatus = 2
+		lastStatus = exitStatus(err)
 		return err
 	}
 
@@ -956,19 +1226,260 @@ func execInput(input string) error {
 	return lastErr
 }
 
-// execCommand executes a single simple command.
+// execCommand executes a pipeline of simple commands with redirections.
 func execCommand(input string) error {
-	// Split the input into the command and its arguments, expanding
-	// variables and ~ on the way.
-	args, err := splitWords(input)
+	// Split the input into words and operators, expanding variables and ~ on
+	// the way.
+	tokens, err := tokenize(input)
+	var synErr syntaxError
+	if errors.As(err, &synErr) {
+		return err
+	}
 	if err != nil {
 		return fmt.Errorf("invalid input: %w", err)
 	}
-	if len(args) == 0 {
+	stages, err := parsePipeline(tokens)
+	if err != nil {
+		return err
+	}
+	if len(stages) == 0 {
 		return nil
 	}
+	return runPipeline(stages)
+}
 
-	// Check for built-in commands.
+// redirect is a redirection of a simple command, e.g. 2>>file or 2>&1.
+type redirect struct {
+	op   string // <, >, >>, &>, &>>, >& or <&
+	fd   int    // the redirected file descriptor
+	dup  int    // the target file descriptor of >& and <&
+	file string // the file name for all other operators
+}
+
+// stage is a simple command of a pipeline.
+type stage struct {
+	args      []string
+	redirects []redirect
+}
+
+// parsePipeline groups tokens into the stages of a pipeline.
+func parsePipeline(tokens []token) ([]stage, error) {
+	var (
+		stages []stage
+		cur    stage
+	)
+	isEmpty := func(s stage) bool { return len(s.args) == 0 && len(s.redirects) == 0 }
+
+	for i := 0; i < len(tokens); i++ {
+		t := tokens[i]
+		switch t.op {
+		case "":
+			cur.args = append(cur.args, expandWord(t)...)
+		case "|":
+			if isEmpty(cur) {
+				return nil, syntaxError("|")
+			}
+			stages = append(stages, cur)
+			cur = stage{}
+		case ">&", "<&":
+			cur.redirects = append(cur.redirects, redirect{op: t.op, fd: t.fd, dup: t.dup})
+		default:
+			if i+1 == len(tokens) {
+				return nil, syntaxError("newline")
+			}
+			if next := tokens[i+1]; next.op != "" {
+				return nil, syntaxError(next.op)
+			}
+			i++
+			files := expandWord(tokens[i])
+			if len(files) > 1 {
+				return nil, fmt.Errorf("%s: ambiguous redirect", sanitize(tokens[i].word))
+			}
+			cur.redirects = append(cur.redirects, redirect{op: t.op, fd: t.fd, file: files[0]})
+		}
+	}
+
+	if isEmpty(cur) {
+		if len(stages) > 0 {
+			return nil, syntaxError("|")
+		}
+		return nil, nil
+	}
+	return append(stages, cur), nil
+}
+
+// runPipeline runs the stages of a pipeline concurrently, connecting the
+// stdout of each stage to the stdin of the next one. It returns the error of
+// the last stage (so $? is its exit status, like in sh); errors of the other
+// stages are printed.
+func runPipeline(stages []stage) error {
+	waits := make([]func() error, len(stages))
+	stdin := os.Stdin
+	for i, st := range stages {
+		stdout := os.Stdout
+		var next *os.File
+		if i < len(stages)-1 {
+			r, w, err := os.Pipe()
+			if err != nil {
+				// Let the stages that already run finish
+				if stdin != os.Stdin {
+					stdin.Close()
+				}
+				for _, wait := range waits[:i] {
+					printError(wait())
+				}
+				return err
+			}
+			stdout, next = w, r
+		}
+		waits[i] = startStage(st, stdin, stdout, len(stages) > 1)
+		stdin = next
+	}
+
+	var err error
+	for i, wait := range waits {
+		err = wait()
+		if i < len(waits)-1 {
+			printError(err)
+		}
+	}
+	return err
+}
+
+// startStage starts a stage of a pipeline with the given stdin and stdout and
+// returns a function that waits for it to finish. Pipe ends passed in are
+// closed by startStage once the stage no longer needs them, so that the
+// neighbors see EOF or get SIGPIPE.
+func startStage(st stage, stdin, stdout *os.File, inPipeline bool) func() error {
+	var owned []*os.File
+	if stdin != os.Stdin {
+		owned = append(owned, stdin)
+	}
+	if stdout != os.Stdout {
+		owned = append(owned, stdout)
+	}
+	closeOwned := func() {
+		for _, f := range owned {
+			f.Close()
+		}
+	}
+	result := func(err error) func() error {
+		return func() error { return err }
+	}
+
+	// Connect the command to the terminal unless redirected. Without Stdin
+	// the command would read from /dev/null, so interactive programs (su,
+	// vim, ssh, ...) would get EOF right away. readline only reads from stdin
+	// while a line is being edited, so it does not steal input.
+	fds := [3]*os.File{stdin, stdout, os.Stderr}
+	opened, err := applyRedirects(&fds, st.redirects)
+	owned = append(owned, opened...)
+	if err != nil || len(st.args) == 0 {
+		// A command without arguments only creates or truncates the files
+		closeOwned()
+		return result(err)
+	}
+
+	if builtin, ok := builtins[st.args[0]]; ok {
+		if inPipeline && builtin.changesState {
+			closeOwned()
+			return result(fmt.Errorf("%s: cannot be used in a pipeline", st.args[0]))
+		}
+		run := func() error {
+			defer closeOwned()
+			err := runBuiltin(st.args, fds[1])
+			if err != nil && fds[2] != os.Stderr {
+				// Report the error where stderr is redirected to
+				fmt.Fprintln(fds[2], "gosh:", err)
+				return statusError(1)
+			}
+			return err
+		}
+		if !inPipeline {
+			return result(run())
+		}
+		done := make(chan error, 1)
+		go func() { done <- run() }()
+		return func() error { return <-done }
+	}
+
+	cmd := exec.Command(st.args[0], st.args[1:]...)
+	cmd.Stdin, cmd.Stdout, cmd.Stderr = fds[0], fds[1], fds[2]
+	err = cmd.Start()
+	// The child has its own copies of the files now
+	closeOwned()
+	if errors.Is(err, exec.ErrNotFound) {
+		err = fmt.Errorf("%s: %w", sanitize(st.args[0]), errCommandNotFound)
+	}
+	if err != nil {
+		return result(err)
+	}
+	return cmd.Wait
+}
+
+// applyRedirects applies the redirections in order to fds (stdin, stdout,
+// stderr) and returns the files it opened.
+func applyRedirects(fds *[3]*os.File, redirects []redirect) ([]*os.File, error) {
+	var opened []*os.File
+	fail := func(err error) ([]*os.File, error) {
+		for _, f := range opened {
+			f.Close()
+		}
+		return nil, err
+	}
+
+	for _, r := range redirects {
+		if r.fd > 2 {
+			return fail(fmt.Errorf("%d: bad file descriptor", r.fd))
+		}
+		if r.op == ">&" || r.op == "<&" {
+			if r.dup > 2 {
+				return fail(fmt.Errorf("%d: bad file descriptor", r.dup))
+			}
+			fds[r.fd] = fds[r.dup]
+			continue
+		}
+
+		flags := os.O_WRONLY | os.O_CREATE | os.O_TRUNC
+		switch r.op {
+		case "<":
+			flags = os.O_RDONLY
+		case ">>", "&>>":
+			flags = os.O_WRONLY | os.O_CREATE | os.O_APPEND
+		}
+		f, err := os.OpenFile(r.file, flags, 0666)
+		if err != nil {
+			// "file: No such file or directory" with exit status 1, like sh
+			var pathErr *fs.PathError
+			if errors.As(err, &pathErr) {
+				err = fmt.Errorf("%s: %v", sanitize(r.file), pathErr.Err)
+			}
+			return fail(err)
+		}
+		opened = append(opened, f)
+		fds[r.fd] = f
+		if r.op == "&>" || r.op == "&>>" {
+			fds[2] = f
+		}
+	}
+	return opened, nil
+}
+
+// builtins lists the built-in commands. Commands that change the state of
+// the shell cannot be used in a pipeline, since there they would run
+// concurrently (sh runs them in a subshell where they have no effect).
+var builtins = map[string]struct{ changesState bool }{
+	"cd":     {changesState: true},
+	"pwd":    {},
+	"exit":   {changesState: true},
+	"quit":   {changesState: true},
+	"set":    {changesState: true},
+	"export": {changesState: true},
+	"help":   {},
+}
+
+// runBuiltin executes a built-in command, writing its output to stdout.
+func runBuiltin(args []string, stdout io.Writer) error {
 	switch args[0] {
 	case "cd":
 		// Save current directory before changing (for 'cd -')
@@ -1002,7 +1513,7 @@ func execCommand(input string) error {
 		return os.Chdir(path)
 	case "pwd":
 		wd, err := os.Getwd()
-		fmt.Println(wd)
+		fmt.Fprintln(stdout, wd)
 		return err
 	case "exit":
 		// exit with optional status code
@@ -1045,7 +1556,7 @@ func execCommand(input string) error {
 		os.Setenv(parts[0], parts[1])
 		return nil
 	case "help":
-		fmt.Println("gosh - Go Shell\nVersion: " + versionInfo() + `
+		fmt.Fprintln(stdout, "gosh - Go Shell\nVersion: " + versionInfo() + `
 
 Built-in commands:
   cd [dir]       - Change directory (cd with no args goes to home)
@@ -1066,6 +1577,9 @@ Features:
     override with $GOSH_HISTFILE); lines starting with a space are not saved
   - Tab completion for commands and file paths
   - Tilde expansion (~, ~/path) at the start of unquoted words
+  - Wildcards: * ? [abc] [a-z] [!abc] match file names (not hidden files
+    unless the pattern starts with a dot); quoted wildcards and values of
+    variables are not expanded, a pattern without match is kept as is
   - Colored prompt (user@host green, red for root; directory blue),
     configurable with $GOSH_COLORS, e.g. GOSH_COLORS='user=1;33:path=36'
     (keys user, root, path; values are ANSI SGR codes, empty = no color);
@@ -1074,26 +1588,11 @@ Features:
     using an unset variable is an error, use ${VAR:-} for an empty default
   - Command lists: a ; b (run both), a && b (b only if a succeeded),
     a || b (b only if a failed); $? is the exit status of the last command
+  - Pipes (a | b) and redirections: < file, > file, >> file, 2> file,
+    2>> file, 2>&1, >&2, &> file (stdout and stderr), &>> file
   - Non-interactive use: gosh -c 'command', gosh script, command | gosh;
     the exit status is the one of the last command`)
 		return nil
 	}
-
-	// Prepare the command to execute.
-	cmd := exec.Command(args[0], args[1:]...)
-
-	// Connect the command to the terminal. Without Stdin the command would
-	// read from /dev/null, so interactive programs (su, vim, ssh, ...) would
-	// get EOF right away. readline only reads from stdin while a line is
-	// being edited, so it does not steal input from the command.
-	cmd.Stdin = os.Stdin
-	cmd.Stdout = os.Stdout
-	cmd.Stderr = os.Stderr
-
-	// Execute the command return the error.
-	err = cmd.Run()
-	if errors.Is(err, exec.ErrNotFound) {
-		return fmt.Errorf("%s: %w", sanitize(args[0]), errCommandNotFound)
-	}
-	return err
+	return fmt.Errorf("%s: not a builtin", args[0])
 }

main_test.go

@@ -859,6 +859,15 @@ func TestShellCompleter_Do(t *testing.T) {
 		{"ls " + tmpDir + "/ma", []string{"in.go"}, 2},
 		{"ls xyz", nil, 3},
 		{"ls ~", []string{"/"}, 1},
+		// Commands are completed after |, ;, && and ||, files after redirections
+		{"ls | gi", []string{"tty "}, 2},
+		{"ls|gi", []string{"tty "}, 2},
+		{"true; gi", []string{"tty "}, 2},
+		{"true && gi", []string{"tty "}, 2},
+		{"false || gi", []string{"tty "}, 2},
+		{"ls > ma", []string{"in.go"}, 2},
+		{"ls 2>ma", []string{"in.go"}, 2},
+		{"cat <ma", []string{"in.go"}, 2},
 	}
 	for _, tt := range tests {
 		got, length := completeLine(tt.line)
@@ -1471,3 +1480,253 @@ func TestExecInput_CommandNotFound(t *testing.T) {
 		t.Errorf("$? = %d, want 127", lastStatus)
 	}
 }
+
+func TestTokenize_Operators(t *testing.T) {
+	tests := []struct {
+		input string
+		want  []token
+	}{
+		{"a | b", []token{{word: "a"}, {op: "|"}, {word: "b"}}},
+		{"a|b", []token{{word: "a"}, {op: "|"}, {word: "b"}}},
+		{"a > f", []token{{word: "a"}, {op: ">", fd: 1}, {word: "f"}}},
+		{"a >>f", []token{{word: "a"}, {op: ">>", fd: 1}, {word: "f"}}},
+		{"a < f", []token{{word: "a"}, {op: "<", fd: 0}, {word: "f"}}},
+		{"a 2>f", []token{{word: "a"}, {op: ">", fd: 2}, {word: "f"}}},
+		{"a 2>>f", []token{{word: "a"}, {op: ">>", fd: 2}, {word: "f"}}},
+		{"a 2>&1", []token{{word: "a"}, {op: ">&", fd: 2, dup: 1}}},
+		{"a >&2", []token{{word: "a"}, {op: ">&", fd: 1, dup: 2}}},
+		{"a 0<&2", []token{{word: "a"}, {op: "<&", fd: 0, dup: 2}}},
+		{"a &>f", []token{{word: "a"}, {op: "&>", fd: 1}, {word: "f"}}},
+		{"a &>>f", []token{{word: "a"}, {op: "&>>", fd: 1}, {word: "f"}}},
+		// Only a word of unquoted digits is a file descriptor
+		{"a x2>f", []token{{word: "a"}, {word: "x2"}, {op: ">", fd: 1}, {word: "f"}}},
+		{`a "2">f`, []token{{word: "a"}, {word: "2"}, {op: ">", fd: 1}, {word: "f"}}},
+		{"a 2 >f", []token{{word: "a"}, {word: "2"}, {op: ">", fd: 1}, {word: "f"}}},
+		// Quoted and escaped operators are words
+		{`echo "a|b" 'c>d' e\<f`, []token{{word: "echo"}, {word: "a|b"}, {word: "c>d"}, {word: "e<f"}}},
+		// A lone & is a word
+		{"a & b", []token{{word: "a"}, {word: "&"}, {word: "b"}}},
+		{"cat ~|x", []token{{word: "cat"}, {word: getHomeDir()}, {op: "|"}, {word: "x"}}},
+	}
+	for _, tc := range tests {
+		got, err := tokenize(tc.input)
+		if err != nil {
+			t.Errorf("tokenize(%q) returned error: %v", tc.input, err)
+			continue
+		}
+		// Patterns are tested in TestTokenize_Patterns
+		for i := range got {
+			got[i].pattern, got[i].glob = "", false
+		}
+		if !reflect.DeepEqual(got, tc.want) {
+			t.Errorf("tokenize(%q) = %+v, want %+v", tc.input, got, tc.want)
+		}
+	}
+}
+
+func TestExecInput_SyntaxErrors(t *testing.T) {
+	for _, input := range []string{"echo a |", "| echo a", "echo a | | b", "echo a >", "echo a > | b", "echo a >&", "echo a 2>&x", "; a"} {
+		err := execInput(input)
+		if err == nil || !strings.Contains(err.Error(), "syntax error") {
+			t.Errorf("execInput(%q) = %v, want syntax error", input, err)
+		}
+		if lastStatus != 2 {
+			t.Errorf("execInput(%q): $? = %d, want 2", input, lastStatus)
+		}
+	}
+}
+
+func TestExecInput_PipesAndRedirections(t *testing.T) {
+	origDir, _ := os.Getwd()
+	defer os.Chdir(origDir)
+	dir := t.TempDir()
+	os.Chdir(dir)
+
+	read := func(name string) string {
+		data, err := os.ReadFile(filepath.Join(dir, name))
+		if err != nil {
+			t.Errorf("reading %s: %v", name, err)
+		}
+		return string(data)
+	}
+
+	tests := []struct {
+		input  string
+		file   string
+		want   string
+		status int
+	}{
+		{`printf 'b\na\nc\n' | sort | head -n 2 > out`, "out", "a\nb\n", 0},
+		{"echo one > f1; echo two >> f1", "f1", "one\ntwo\n", 0},
+		{"echo one > f2; echo two > f2", "f2", "two\n", 0},
+		{"tr a-z A-Z < f1 > f3", "f3", "ONE\nTWO\n", 0},
+		{"sh -c 'echo out; echo err >&2' > f4 2>&1", "f4", "out\nerr\n", 0},
+		{"sh -c 'echo out; echo err >&2' &> f5", "f5", "out\nerr\n", 0},
+		{"sh -c 'echo err >&2' 2> f6", "f6", "err\n", 0},
+		// 2>&1 before >file sends stderr to the old stdout (the pipe)
+		{"sh -c 'echo out; echo err >&2' 2>&1 > /dev/null | cat > f7", "f7", "err\n", 0},
+		{"sh -c 'echo err >&2' 2>&1 | tr a-z A-Z > f8", "f8", "ERR\n", 0},
+		// Builtins write to redirections and pipes
+		{"pwd > f9", "f9", dir + "\n", 0},
+		{"pwd | cat > f10", "f10", dir + "\n", 0},
+		{"help | head -n 1 > f11", "f11", "gosh - Go Shell\n", 0},
+		// Errors of builtins go to the redirected stderr
+		{"cd /gosh/no/such/dir 2> f12", "f12", "gosh: chdir /gosh/no/such/dir: no such file or directory\n", 1},
+		// The status of a pipeline is the one of the last command
+		{"false | true > f13", "f13", "", 0},
+		{"true | false > f14", "f14", "", 1},
+		// A redirection without a command creates the file
+		{"> f15", "f15", "", 0},
+		// SIGPIPE ends the writer when the reader exits
+		{"yes | head -n 1 > f16", "f16", "y\n", 0},
+		// A command that is not found does not stop the pipeline
+		{"gosh-no-such-command | echo after > f17", "f17", "after\n", 0},
+		{"echo before | gosh-no-such-command 2> f18", "f18", "", 127},
+	}
+	for _, tc := range tests {
+		execInput(tc.input)
+		if lastStatus != tc.status {
+			t.Errorf("%q: $? = %d, want %d", tc.input, lastStatus, tc.status)
+		}
+		if got := read(tc.file); got != tc.want {
+			t.Errorf("%q: %s = %q, want %q", tc.input, tc.file, got, tc.want)
+		}
+	}
+}
+
+func TestExecInput_RedirectionErrors(t *testing.T) {
+	origDir, _ := os.Getwd()
+	defer os.Chdir(origDir)
+	os.Chdir(t.TempDir())
+
+	tests := []struct {
+		input   string
+		wantErr string
+	}{
+		{"cat < gosh-no-such-file", "gosh-no-such-file: no such file or directory"},
+		{"echo a > gosh-no-such-dir/f", "gosh-no-such-dir/f: no such file or directory"},
+		{"echo a 3> f", "3: bad file descriptor"},
+		{"echo a 2>&5", "5: bad file descriptor"},
+		{"echo a | cd /", "cd: cannot be used in a pipeline"},
+		{"echo a | exit 3", "exit: cannot be used in a pipeline"},
+	}
+	for _, tc := range tests {
+		err := execInput(tc.input)
+		if err == nil || err.Error() != tc.wantErr {
+			t.Errorf("execInput(%q) = %v, want %q", tc.input, err, tc.wantErr)
+		}
+		if lastStatus != 1 {
+			t.Errorf("execInput(%q): $? = %d, want 1", tc.input, lastStatus)
+		}
+	}
+	// The command is not run if a redirection fails
+	if _, err := os.Stat("f"); err == nil {
+		t.Error("file f must not be created for a bad file descriptor")
+	}
+}
+
+func TestTokenize_Patterns(t *testing.T) {
+	t.Setenv("GOSH_GLOB", "*.go")
+	tests := []struct {
+		input   string
+		pattern string
+		glob    bool
+	}{
+		{"*.go", "*.go", true},
+		{"a?c", "a?c", true},
+		{"[ab].go", "[ab].go", true},
+		{"[!a].go", "[^a].go", true},
+		{"plain", "plain", false},
+		// Quoted, escaped and expanded characters are literal
+		{`"*.go"`, `\*.go`, false},
+		{`'*'.go`, `\*.go`, false},
+		{`\*.go`, `\*.go`, false},
+		{`"x"*`, `x*`, true},
+		{"$GOSH_GLOB", `\*.go`, false},
+		{`'['!a].go`, `\[!a].go`, false},
+	}
+	for _, tc := range tests {
+		tokens, err := tokenize(tc.input)
+		if err != nil || len(tokens) != 1 {
+			t.Errorf("tokenize(%q) = %+v, %v", tc.input, tokens, err)
+			continue
+		}
+		if tokens[0].pattern != tc.pattern || tokens[0].glob != tc.glob {
+			t.Errorf("tokenize(%q): pattern %q, glob %v; want %q, %v",
+				tc.input, tokens[0].pattern, tokens[0].glob, tc.pattern, tc.glob)
+		}
+	}
+}
+
+func TestExpandGlob(t *testing.T) {
+	origDir, _ := os.Getwd()
+	defer os.Chdir(origDir)
+	dir := t.TempDir()
+	os.Chdir(dir)
+	for _, d := range []string{"sub/deep", "other"} {
+		os.MkdirAll(d, 0755)
+	}
+	for _, f := range []string{"a.go", "b.go", "c.txt", ".hidden.go", "with space.go", "[x].go", "sub/s1.go", "sub/deep/d.go", "other/o.go"} {
+		os.WriteFile(f, nil, 0644)
+	}
+
+	tests := []struct {
+		pattern string
+		want    []string
+	}{
+		{"*.go", []string{"[x].go", "a.go", "b.go", "with space.go"}},
+		{".*.go", []string{".hidden.go"}},
+		{"?.go", []string{"a.go", "b.go"}},
+		{"[ab].go", []string{"a.go", "b.go"}},
+		{"[^a].go", []string{"b.go"}},
+		{"*/*.go", []string{"other/o.go", "sub/s1.go"}},
+		{"*/", []string{"other/", "sub/"}},
+		{"sub/*/*.go", []string{"sub/deep/d.go"}},
+		{"./c*", []string{"./c.txt"}},
+		{dir + "/c*", []string{dir + "/c.txt"}},
+		{`\[x\].go`, []string{"[x].go"}},
+		{"*.xyz", nil},
+		{"[", nil},
+	}
+	for _, tc := range tests {
+		if got := expandGlob(tc.pattern); !reflect.DeepEqual(got, tc.want) {
+			t.Errorf("expandGlob(%q) = %q, want %q", tc.pattern, got, tc.want)
+		}
+	}
+}
+
+func TestExecInput_Wildcards(t *testing.T) {
+	origDir, _ := os.Getwd()
+	defer os.Chdir(origDir)
+	dir := t.TempDir()
+	os.Chdir(dir)
+	for _, f := range []string{"a.go", "b.go", "c.txt"} {
+		os.WriteFile(f, []byte(f+"\n"), 0644)
+	}
+
+	tests := []struct {
+		input string
+		want  string
+	}{
+		{"echo *.go > out", "a.go b.go\n"},
+		{"cat *.go > out", "a.go\nb.go\n"},
+		// No match: the word is passed on unchanged, like in sh
+		{"echo *.xyz > out", "*.xyz\n"},
+		{`echo "*.go" '?.go' \*.go > out`, "*.go ?.go *.go\n"},
+		// A redirection to a pattern with a single match uses that file
+		{"echo hi > *.txt; cat c.txt > out", "hi\n"},
+	}
+	for _, tc := range tests {
+		if err := execInput(tc.input); err != nil {
+			t.Errorf("execInput(%q) returned error: %v", tc.input, err)
+		}
+		if got, _ := os.ReadFile("out"); string(got) != tc.want {
+			t.Errorf("%q: got %q, want %q", tc.input, got, tc.want)
+		}
+	}
+
+	err := execInput("echo hi > *.go")
+	if err == nil || err.Error() != "*.go: ambiguous redirect" {
+		t.Errorf("expected ambiguous redirect error, got %v", err)
+	}
+}