fix: handle shell built-ins like export in command execution

Shell built-ins (export, cd, source, alias, etc.) have no binary in
$PATH and fail with exec.Command. Wrap them with sh -c so they execute
in a subshell instead.

Closes #16

Author: edouard-claude

internal/engine/executor.go

@@ -17,11 +17,44 @@ type Result struct {
 	Duration time.Duration
 }
 
+// shellBuiltins lists commands that are shell built-ins and cannot be
+// executed directly via exec.Command.
+var shellBuiltins = map[string]bool{
+	"export":   true,
+	"unset":    true,
+	"source":   true,
+	"alias":    true,
+	"unalias":  true,
+	"cd":       true,
+	"eval":     true,
+	"set":      true,
+	"shopt":    true,
+	"declare":  true,
+	"local":    true,
+	"readonly": true,
+	"typeset":  true,
+	"ulimit":   true,
+	"umask":    true,
+}
+
+// makeCommand creates an exec.Cmd, wrapping shell built-ins with sh -c
+// so they can be executed. Shell built-ins like "export" have no binary
+// in $PATH and would fail with exec.Command directly.
+func makeCommand(command string, args []string) *exec.Cmd {
+	if shellBuiltins[command] {
+		shArgs := make([]string, 0, len(args)+3)
+		shArgs = append(shArgs, "-c", command+` "$@"`, "_")
+		shArgs = append(shArgs, args...)
+		return exec.Command("sh", shArgs...)
+	}
+	return exec.Command(command, args...)
+}
+
 // Execute runs a command, capturing stdout and stderr concurrently via goroutines.
 func Execute(command string, args []string) (*Result, error) {
 	start := time.Now()
 
-	cmd := exec.Command(command, args...)
+	cmd := makeCommand(command, args)
 	// Don't connect stdin for captured commands — prevents blocking on
 	// commands that don't read stdin (most filtered commands).
 	// Passthrough commands still get stdin via the Passthrough function.
@@ -74,7 +107,7 @@ func Execute(command string, args []string) (*Result, error) {
 
 // Passthrough runs a command with inherited stdio (no capture).
 func Passthrough(command string, args []string) (int, error) {
-	cmd := exec.Command(command, args...)
+	cmd := makeCommand(command, args)
 	cmd.Stdin = os.Stdin
 	cmd.Stdout = os.Stdout
 	cmd.Stderr = os.Stderr

internal/engine/executor_test.go

@@ -77,3 +77,51 @@ func TestPassthroughExitCode(t *testing.T) {
 		t.Errorf("exit code = %d, want 7", code)
 	}
 }
+
+func TestExecuteShellBuiltin(t *testing.T) {
+	if runtime.GOOS == "windows" {
+		t.Skip("skip on windows")
+	}
+	result, err := Execute("export", []string{"FOO=bar"})
+	if err != nil {
+		t.Fatalf("unexpected error executing shell builtin: %v", err)
+	}
+	if result.ExitCode != 0 {
+		t.Errorf("exit code = %d, want 0", result.ExitCode)
+	}
+}
+
+func TestPassthroughShellBuiltin(t *testing.T) {
+	if runtime.GOOS == "windows" {
+		t.Skip("skip on windows")
+	}
+	code, err := Passthrough("export", []string{"FOO=bar"})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if code != 0 {
+		t.Errorf("exit code = %d, want 0", code)
+	}
+}
+
+func TestMakeCommandBuiltin(t *testing.T) {
+	cmd := makeCommand("export", []string{"A=1", "B=2"})
+	if cmd.Path == "" {
+		t.Fatal("command path should not be empty")
+	}
+	// Should wrap with sh -c
+	if cmd.Args[0] != "sh" {
+		t.Errorf("expected sh wrapper, got %q", cmd.Args[0])
+	}
+	if cmd.Args[1] != "-c" {
+		t.Errorf("expected -c flag, got %q", cmd.Args[1])
+	}
+}
+
+func TestMakeCommandRegular(t *testing.T) {
+	cmd := makeCommand("git", []string{"status"})
+	// Should NOT wrap with sh
+	if len(cmd.Args) > 0 && cmd.Args[0] == "sh" {
+		t.Error("regular commands should not be wrapped with sh")
+	}
+}