add aliases

- alias name=value defines aliases, alias lists or shows them in a form
  that can be read back, unalias removes them (unalias -a: all)
- the first word of every command (at the start and after ;, &, &&, ||
  and |) is replaced, the value is expanded again except for aliases
  that are already being expanded (alias ls='ls --color' works)
- a value ending with a blank makes the next word a command name too
- quoted or escaped words (\ll, 'll') skip the alias
- aliases are only expanded in interactive shells and their startup
  files, like in bash
- tab completion includes aliases

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

alias_test.go

@@ -0,0 +1,164 @@
+package main
+
+import (
+	"bytes"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// withAliases sets the aliases for a test and restores them afterwards.
+func withAliases(t *testing.T, defs map[string]string) {
+	t.Helper()
+	aliasMu.Lock()
+	saved := aliases
+	aliases = map[string]string{}
+	for name, value := range defs {
+		aliases[name] = value
+	}
+	aliasMu.Unlock()
+	t.Cleanup(func() {
+		aliasMu.Lock()
+		aliases = saved
+		aliasMu.Unlock()
+	})
+}
+
+func TestExpandAliases(t *testing.T) {
+	withAliases(t, map[string]string{
+		"ll":    "ls -l",
+		"ls":    "ls --color",
+		"..":    "cd ..",
+		"e":     "echo ",
+		"w":     "world",
+		"a":     "b",
+		"b":     "a",
+		"multi": "cd /tmp && ls",
+	})
+
+	tests := []struct {
+		input, want string
+	}{
+		{"ll", "ls --color -l"},
+		{"  ll -a", "  ls --color -l -a"},
+		{"ls", "ls --color"},
+		{"..", "cd .."},
+		// Only the command name is replaced
+		{"echo ll", "echo ll"},
+		{"ll ll", "ls --color -l ll"},
+		// ... also after ;, &&, ||, | and &
+		{"ll; ll && ll || ll | ll & ll", "ls --color -l; ls --color -l && ls --color -l || ls --color -l | ls --color -l & ls --color -l"},
+		// but not after redirections with &
+		{"ll 2>&1 ll", "ls --color -l 2>&1 ll"},
+		{"ll &> ll", "ls --color -l &> ll"},
+		// Quoted or escaped words are not replaced
+		{`\ll`, `\ll`},
+		{`'ll'`, `'ll'`},
+		{`"ll"`, `"ll"`},
+		{`echo "a; ll"`, `echo "a; ll"`},
+		{`echo 'a | ll'`, `echo 'a | ll'`},
+		// A trailing blank makes the next word a command name too
+		{"e w", "echo  world"},
+		{"e e w", "echo  echo  world"},
+		// Recursion stops at aliases that are already being expanded
+		{"a", "a"},
+		{"b", "b"},
+		// The value can contain several commands
+		{"multi", "cd /tmp && ls --color"},
+		// Comments are left alone
+		{"echo x # ll", "echo x # ll"},
+	}
+	for _, tc := range tests {
+		if got := expandAliases(tc.input); got != tc.want {
+			t.Errorf("expandAliases(%q) = %q, want %q", tc.input, got, tc.want)
+		}
+	}
+}
+
+func TestBuiltinAlias(t *testing.T) {
+	withAliases(t, nil)
+
+	run := func(args ...string) (string, error) {
+		var out bytes.Buffer
+		err := builtinAlias(append([]string{"alias"}, args...), &out)
+		return out.String(), err
+	}
+
+	if _, err := run("ll=ls -l", "q=echo it's", "..=cd .."); err != nil {
+		t.Fatal(err)
+	}
+	out, _ := run()
+	want := "alias ..='cd ..'\nalias ll='ls -l'\nalias q='echo it'\\''s'\n"
+	if out != want {
+		t.Errorf("alias = %q, want %q", out, want)
+	}
+	if out, _ := run("ll"); out != "alias ll='ls -l'\n" {
+		t.Errorf("alias ll = %q", out)
+	}
+	if _, err := run("nope"); err == nil || err.Error() != "alias: nope: not found" {
+		t.Errorf("alias nope: %v", err)
+	}
+	for _, name := range []string{"a/b", "a=b", "$x", "a b", ""} {
+		if isAliasName(name) {
+			t.Errorf("isAliasName(%q) = true", name)
+		}
+	}
+	if _, err := run("a/b=x"); err == nil || !strings.Contains(err.Error(), "invalid alias name") {
+		t.Errorf("alias a/b=x: %v", err)
+	}
+
+	if err := builtinUnalias([]string{"unalias", "ll", "nope"}); err == nil || err.Error() != "unalias: nope: not found" {
+		t.Errorf("unalias nope: %v", err)
+	}
+	if _, ok := lookupAlias("ll"); ok {
+		t.Error("ll still defined after unalias")
+	}
+	builtinUnalias([]string{"unalias", "-a"})
+	if names := aliasNames(); len(names) != 0 {
+		t.Errorf("aliases after unalias -a: %q", names)
+	}
+}
+
+func TestExecInput_Aliases(t *testing.T) {
+	withAliases(t, nil)
+	origDir, _ := os.Getwd()
+	defer os.Chdir(origDir)
+	dir := t.TempDir()
+	os.Chdir(dir)
+	defer func(saved bool) { interactiveShell = saved }(interactiveShell)
+
+	// Aliases are expanded in interactive shells only
+	interactiveShell = true
+	execInput(`alias say='echo hello' to=out`)
+	execInput("say world > out")
+	if got, _ := os.ReadFile("out"); string(got) != "hello world\n" {
+		t.Errorf("alias in interactive shell: out = %q", got)
+	}
+
+	interactiveShell = false
+	os.Remove("out")
+	if err := execInput("say world > out"); err == nil {
+		t.Error("alias was expanded in a non-interactive shell")
+	}
+
+	// alias works in pipelines (listing), unalias does not
+	interactiveShell = true
+	execInput("alias | grep say > out")
+	if got, _ := os.ReadFile(filepath.Join(dir, "out")); string(got) != "alias say='echo hello'\n" {
+		t.Errorf("alias | grep = %q", got)
+	}
+	if err := execInput("echo | unalias say"); err == nil {
+		t.Error("unalias in a pipeline must fail")
+	}
+}
+
+func TestShellCompleter_Aliases(t *testing.T) {
+	withAliases(t, map[string]string{"gst": "git status"})
+	t.Setenv("PATH", t.TempDir())
+	got, length := completeLine("gs")
+	if !reflect.DeepEqual(got, []string{"t "}) || length != 2 {
+		t.Errorf("completion of gs = %q, %d", got, length)
+	}
+}