show version with branch and commit in help and -version

- add -version flag (besides --version and -V)
- help output includes the version
- commit and branch are set via ldflags by goreleaser; plain go build
  falls back to the VCS revision embedded by Go

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

.goreleaser.yaml

@@ -22,7 +22,7 @@ builds:
     flags:
       - -trimpath
     ldflags:
-      - -s -w -X main.version={{ .Version }}
+      - -s -w -X main.version={{ .Version }} -X main.commit={{ .ShortCommit }} -X main.branch={{ .Branch }}
     goos:
       - linux
       - darwin

README.md

@@ -2,6 +2,7 @@
 
 ```
 gosh - Go Shell
+Version: 0.2.1 (branch: main, commit: 03e791c)
 
 Built-in commands:
   cd [dir]       - Change directory (cd with no args goes to home)
@@ -22,11 +23,68 @@ 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
+  - 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);
+    disabled with $NO_COLOR, TERM=dumb or when output is not a terminal
   - Environment variable expansion ($VAR, ${VAR}, ${VAR:-default});
     using an unset variable is an error, use ${VAR:-} for an empty default
 
 ```
 
+### Farben
+
+Der Prompt wird über die Umgebungsvariable `GOSH_COLORS` eingefärbt. Sie besteht aus durch `:` getrennten Einträgen `schlüssel=code`:
+
+| Schlüssel | Teil des Prompts               | Standard            |
+|-----------|--------------------------------|---------------------|
+| `user`    | `user@host`                    | `1;32` (fett grün)  |
+| `root`    | `user@host`, wenn man root ist | `1;31` (fett rot)   |
+| `path`    | aktuelles Verzeichnis          | `1;34` (fett blau)  |
+
+Die Werte sind [ANSI-SGR-Codes](https://en.wikipedia.org/wiki/ANSI_escape_code#SGR_(Select_Graphic_Rendition)_parameters), mehrere werden mit `;` kombiniert:
+
+- `1` fett, `2` blass, `3` kursiv, `4` unterstrichen
+- `30`–`37` Vordergrund, `90`–`97` helle Vordergrundfarben, `40`–`47` Hintergrund
+- `38;5;N` eine der 256 Farben, `38;2;R;G;B` Truecolor (sofern das Terminal es kann)
+
+Nicht angegebene Schlüssel behalten ihre Standardfarbe, ein leerer Wert (`path=`) schaltet die Farbe für diesen Teil ab. Ungültige Werte werden ignoriert. Da nur Ziffern und `;` erlaubt sind, lassen sich über die Variable keine beliebigen Escape-Sequenzen ins Terminal schreiben. `NO_COLOR` schaltet alle Farben ab.
+
+Gesetzt wird die Variable z. B. in `~/.profile` oder direkt in gosh (wirkt ab dem nächsten Prompt):
+
+```bash
+export GOSH_COLORS='user=1;33:path=1;36'   # in ~/.profile
+set 'GOSH_COLORS=user=1;33:path=1;36'      # in gosh
+```
+
+Ein paar Kombinationen zum Ausprobieren:
+
+```bash
+# Solarized: gelb und cyan
+GOSH_COLORS='user=33:path=36'
+
+# Sonnenuntergang: orange und pink (256 Farben)
+GOSH_COLORS='user=1;38;5;208:path=38;5;205'
+
+# Matrix: hellgrün und blassgrün
+GOSH_COLORS='user=1;92:path=2;32'
+
+# Dracula: lila und pink (Truecolor)
+GOSH_COLORS='user=1;38;2;189;147;249:path=38;2;255;121;198'
+
+# Nord: frostblau und hellgrau (Truecolor)
+GOSH_COLORS='user=1;38;2;136;192;208:path=38;2;216;222;233'
+
+# Ozean: türkis und kursiv blau
+GOSH_COLORS='user=1;96:path=3;94'
+
+# Root-Warnung: weiß auf rotem Hintergrund
+GOSH_COLORS='root=1;97;41'
+
+# Dezent: nur das Verzeichnis unterstrichen
+GOSH_COLORS='user=:path=4'
+```
+
 ### Sicherheitshinweise
 
 - Die History liegt in `$XDG_STATE_HOME/gosh/history` (Standard: `~/.local/state/gosh/history`) und ist nur für den eigenen Benutzer lesbar (Verzeichnis `0700`, Datei `0600`). Mit `GOSH_HISTFILE` lässt sich ein anderer Pfad setzen, mit `GOSH_HISTFILE=` wird die History abgeschaltet.
@@ -45,6 +103,15 @@ _gosh is not meant for production use, it is just a proof of concept._
 go build ./
 ```
 
+Die Version lässt sich mit `gosh -version` (oder `--version`, `-V`) abfragen und steht auch in der Ausgabe von `help`:
+
+```
+$ gosh -version
+gosh 0.2.1 (branch: main, commit: 03e791c)
+```
+
+Version und Branch werden beim Bauen mit GoReleaser per `-ldflags` gesetzt. Bei einem einfachen `go build` steht dort `dev`, der Commit wird dann aus den von Go eingebetteten Git-Informationen gelesen (mit `-dirty`, falls es uncommittete Änderungen gab).
+
 ## Release
 
 Binaries sowie `.deb`- und `.rpm`-Pakete werden mit [GoReleaser](https://goreleaser.com) gebaut (Konfiguration: `.goreleaser.yaml`).

main.go

@@ -9,6 +9,7 @@ import (
 	"os/signal"
 	"os/user"
 	"path/filepath"
+	"runtime/debug"
 	"strings"
 	"unicode"
 	"unicode/utf8"
@@ -19,8 +20,51 @@ import (
 // ErrNoPath is returned when 'cd' was called without a second argument.
 var ErrNoPath = errors.New("path required")
 
-// version is set at build time via -ldflags "-X main.version=..."
-var version = "dev"
+// Build information, set at build time via
+// -ldflags "-X main.version=... -X main.commit=... -X main.branch=...".
+var (
+	version = "dev"
+	commit  = ""
+	branch  = ""
+)
+
+// versionInfo returns the version including branch and commit, e.g.
+// "0.2.1 (branch: main, commit: 03e791c)". Without ldflags (plain go build)
+// the commit is taken from the VCS information that Go embeds in the binary.
+func versionInfo() string {
+	c := commit
+	if c == "" {
+		if info, ok := debug.ReadBuildInfo(); ok {
+			var dirty bool
+			for _, s := range info.Settings {
+				switch s.Key {
+				case "vcs.revision":
+					c = s.Value
+				case "vcs.modified":
+					dirty = s.Value == "true"
+				}
+			}
+			if len(c) > 7 {
+				c = c[:7]
+			}
+			if c != "" && dirty {
+				c += "-dirty"
+			}
+		}
+	}
+
+	var details []string
+	if branch != "" {
+		details = append(details, "branch: "+branch)
+	}
+	if c != "" {
+		details = append(details, "commit: "+c)
+	}
+	if len(details) == 0 {
+		return version
+	}
+	return version + " (" + strings.Join(details, ", ") + ")"
+}
 
 // previousDir tracks the previous working directory for 'cd -' support
 var previousDir string
@@ -303,16 +347,98 @@ func getPrompt() string {
 		hostname = "unknown"
 	}
 	
-	// Shorten the path for display
-	// Use only the last component if in home directory
+	// Replace the home directory with ~
 	home := getHomeDir()
-	if home != "" && strings.HasPrefix(wd, home) {
-		// Replace home with ~
-		displayPath := "~" + strings.TrimPrefix(wd, home)
-		return sanitize(fmt.Sprintf("%s@%s:%s $ ", username, hostname, displayPath))
+	if home != "" && (wd == home || strings.HasPrefix(wd, home+"/")) {
+		wd = "~" + strings.TrimPrefix(wd, home)
 	}
 	
-	return sanitize(fmt.Sprintf("%s@%s:%s $ ", username, hostname, wd))
+	var colors *promptColors
+	if useColor() {
+		c := parseColors(os.Getenv("GOSH_COLORS"))
+		colors = &c
+	}
+	return buildPrompt(username, hostname, wd, os.Geteuid() == 0, colors)
+}
+
+// promptColors holds the SGR parameters (e.g. "1;32") for the parts of the
+// prompt. An empty value means no color for that part.
+type promptColors struct {
+	user string // user@host
+	root string // user@host when running as root
+	path string // working directory
+}
+
+// defaultColors: bold green user, bold red root, bold blue directory
+var defaultColors = promptColors{user: "1;32", root: "1;31", path: "1;34"}
+
+// parseColors reads a GOSH_COLORS value like "user=1;33:root=1;31:path=36"
+// and overrides the corresponding defaults. Unknown keys and values that are
+// not plain SGR parameters (digits and ';') are ignored, so the variable
+// cannot be used to write arbitrary escape sequences to the terminal.
+func parseColors(spec string) promptColors {
+	colors := defaultColors
+	for _, entry := range strings.Split(spec, ":") {
+		key, value, ok := strings.Cut(entry, "=")
+		if !ok || !isSGR(value) {
+			continue
+		}
+		switch key {
+		case "user":
+			colors.user = value
+		case "root":
+			colors.root = value
+		case "path":
+			colors.path = value
+		}
+	}
+	return colors
+}
+
+// isSGR reports whether s consists only of digits and ';'. The empty string
+// is allowed and disables the color.
+func isSGR(s string) bool {
+	for _, r := range s {
+		if (r < '0' || r > '9') && r != ';' {
+			return false
+		}
+	}
+	return true
+}
+
+// colorize wraps text in the SGR sequence for sgr, or returns it unchanged if
+// sgr is empty.
+func colorize(text, sgr string) string {
+	if sgr == "" {
+		return text
+	}
+	return "\x1b[" + sgr + "m" + text + "\x1b[0m"
+}
+
+// buildPrompt formats the prompt as user@host:path $. The parts are sanitized
+// before the color codes are added, so only our own escape sequences end up
+// in the prompt. colors == nil disables colors.
+func buildPrompt(username, hostname, path string, root bool, colors *promptColors) string {
+	userHost := sanitize(username + "@" + hostname)
+	path = sanitize(path)
+	if colors == nil {
+		return userHost + ":" + path + " $ "
+	}
+	userColor := colors.user
+	if root {
+		userColor = colors.root
+	}
+	return colorize(userHost, userColor) + ":" + colorize(path, colors.path) + " $ "
+}
+
+// useColor reports whether the prompt should be colored: stdout must be a
+// terminal, TERM must not be "dumb" and NO_COLOR (https://no-color.org) must
+// not be set.
+func useColor() bool {
+	if os.Getenv("NO_COLOR") != "" || os.Getenv("TERM") == "dumb" {
+		return false
+	}
+	return readline.IsTerminal(int(os.Stdout.Fd()))
 }
 
 // shellCompleter implements readline.AutoCompleter for contextual completion
@@ -486,10 +612,13 @@ func completeFilePath(line, prefix string) []string {
 }
 
 func main() {
-	if len(os.Args) > 1 && (os.Args[1] == "--version" || os.Args[1] == "-V") {
-		fmt.Println("gosh", version)
+	if len(os.Args) > 1 {
+		switch os.Args[1] {
+		case "-version", "--version", "-V":
+			fmt.Println("gosh", versionInfo())
 			return
 		}
+	}
 
 	// Ctrl+C sends SIGINT to the whole foreground process group. Catch it so
 	// that it only stops the running command and not the shell. (signal.Ignore
@@ -645,7 +774,7 @@ func execInput(input string) error {
 		os.Setenv(parts[0], parts[1])
 		return nil
 	case "help":
-		fmt.Println(`gosh - Go Shell
+		fmt.Println("gosh - Go Shell\nVersion: " + versionInfo() + `
 
 Built-in commands:
   cd [dir]       - Change directory (cd with no args goes to home)
@@ -666,6 +795,10 @@ 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
+  - 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);
+    disabled with $NO_COLOR, TERM=dumb or when output is not a terminal
   - Environment variable expansion ($VAR, ${VAR}, ${VAR:-default});
     using an unset variable is an error, use ${VAR:-} for an empty default`)
 		return nil
@@ -674,9 +807,13 @@ Features:
 	// Prepare the command to execute.
 	cmd := exec.Command(args[0], args[1:]...)
 
-	// Set the correct output device.
-	cmd.Stderr = os.Stderr
+	// 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.
 	return cmd.Run()

main_test.go

@@ -648,6 +648,21 @@ func TestExecInput_ExportNoArgs(t *testing.T) {
 	}
 }
 
+func TestVersionInfo(t *testing.T) {
+	origVersion, origCommit, origBranch := version, commit, branch
+	defer func() { version, commit, branch = origVersion, origCommit, origBranch }()
+
+	version, commit, branch = "1.2.3", "abc1234", "main"
+	if got := versionInfo(); got != "1.2.3 (branch: main, commit: abc1234)" {
+		t.Errorf("versionInfo() = %q", got)
+	}
+
+	branch = ""
+	if got := versionInfo(); got != "1.2.3 (commit: abc1234)" {
+		t.Errorf("versionInfo() without branch = %q", got)
+	}
+}
+
 func TestExecInput_Help(t *testing.T) {
 	// Just verify help doesn't return an error
 	// We can't easily capture stdout in a unit test without a pipe
@@ -1004,6 +1019,7 @@ func TestSanitize(t *testing.T) {
 }
 
 func TestGetPrompt_EscapesControlCharacters(t *testing.T) {
+	t.Setenv("NO_COLOR", "1")
 	origDir, _ := os.Getwd()
 	defer os.Chdir(origDir)
 
@@ -1024,6 +1040,68 @@ func TestGetPrompt_EscapesControlCharacters(t *testing.T) {
 	}
 }
 
+func TestBuildPrompt_Color(t *testing.T) {
+	got := buildPrompt("flow", "host", "~/src", false, &defaultColors)
+	want := "\x1b[1;32mflow@host\x1b[0m:\x1b[1;34m~/src\x1b[0m $ "
+	if got != want {
+		t.Errorf("buildPrompt() = %q, want %q", got, want)
+	}
+
+	got = buildPrompt("root", "host", "/", true, &defaultColors)
+	if !strings.HasPrefix(got, "\x1b[1;31mroot@host") {
+		t.Errorf("expected red user for root, got %q", got)
+	}
+
+	got = buildPrompt("flow", "host", "~/src", false, nil)
+	if got != "flow@host:~/src $ " {
+		t.Errorf("buildPrompt() without color = %q", got)
+	}
+
+	colors := promptColors{user: "38;5;208", path: ""}
+	got = buildPrompt("flow", "host", "~/src", false, &colors)
+	if got != "\x1b[38;5;208mflow@host\x1b[0m:~/src $ " {
+		t.Errorf("buildPrompt() with custom colors = %q", got)
+	}
+}
+
+func TestParseColors(t *testing.T) {
+	tests := []struct {
+		spec string
+		want promptColors
+	}{
+		{"", defaultColors},
+		{"user=1;33", promptColors{user: "1;33", root: "1;31", path: "1;34"}},
+		{"user=33:root=41;97:path=38;5;208", promptColors{user: "33", root: "41;97", path: "38;5;208"}},
+		{"path=", promptColors{user: "1;32", root: "1;31", path: ""}},
+		{"path=0m\x1b[2J", defaultColors}, // escape sequences are rejected
+		{"path=red", defaultColors},       // only numeric codes
+		{"foo=1:user", defaultColors},     // unknown key, missing value
+		{"user=35::path=36", promptColors{user: "35", root: "1;31", path: "36"}},
+	}
+	for _, tc := range tests {
+		if got := parseColors(tc.spec); got != tc.want {
+			t.Errorf("parseColors(%q) = %+v, want %+v", tc.spec, got, tc.want)
+		}
+	}
+}
+
+func TestBuildPrompt_ColorEscapesControlCharacters(t *testing.T) {
+	got := buildPrompt("flow", "host", "evil\x1b[2J\x07", false, &defaultColors)
+	if strings.Contains(got, "\x1b[2J") || strings.Contains(got, "\x07") {
+		t.Errorf("prompt contains control characters from path: %q", got)
+	}
+	if !strings.Contains(got, `evil\x1b[2J\x07`) {
+		t.Errorf("expected escaped path in prompt, got %q", got)
+	}
+}
+
+func TestUseColor_NoColor(t *testing.T) {
+	t.Setenv("NO_COLOR", "1")
+	if useColor() {
+		t.Error("expected no color when NO_COLOR is set")
+	}
+}
+
 func TestFilePathCompleter_SkipsControlCharacters(t *testing.T) {
 	dir := t.TempDir()
 	for _, name := range []string{"good", "go\x1b[31mred"} {
@@ -1158,3 +1236,34 @@ func TestShell_SIGINTKillsOnlyChild(t *testing.T) {
 		t.Errorf("child was not interrupted (took %v)", elapsed)
 	}
 }
+
+func TestExecInput_PassesStdin(t *testing.T) {
+	r, w, err := os.Pipe()
+	if err != nil {
+		t.Fatal(err)
+	}
+	origStdin := os.Stdin
+	os.Stdin = r
+	defer func() {
+		os.Stdin = origStdin
+		r.Close()
+	}()
+
+	if _, err := w.WriteString("hello\n"); err != nil {
+		t.Fatal(err)
+	}
+	w.Close()
+
+	out := filepath.Join(t.TempDir(), "out")
+	t.Setenv("GOSH_TEST_OUT", out)
+	if err := execInput(`sh -c 'read x; printf %s "$x" > "$GOSH_TEST_OUT"'`); err != nil {
+		t.Fatal(err)
+	}
+	got, err := os.ReadFile(out)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if string(got) != "hello" {
+		t.Errorf("command read %q from stdin, want %q", got, "hello")
+	}
+}