Initial commit

.gitignore

@@ -0,0 +1 @@
+launcher

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 M-Ahall
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

commandset.go

@@ -0,0 +1,150 @@
+package main
+
+import (
+	// External
+	"gopkg.in/yaml.v2"
+
+	// Internal
+	"launcher/log"
+
+	// Standard
+	"fmt"
+	"io/ioutil"
+	"os/exec"
+	"regexp"
+)
+
+// Create reads the file and parses its YAML content.
+func CreateCommandSet(fName string) (*CommandSet, error) {
+	var commandSet CommandSet
+	fileContent, err := ioutil.ReadFile(fName)
+	if err != nil {
+		return nil, err
+	}
+
+	err = yaml.UnmarshalStrict(fileContent, &commandSet)
+	if err != nil {
+		return nil, err
+	}
+
+	return &commandSet, nil
+}
+
+// Dump marshals the struct and outputs it.
+func (cs *CommandSet) Dump() {
+	if str, err := yaml.Marshal(cs); err != nil {
+		fmt.Println(err)
+	} else {
+		fmt.Printf("%s\n", str)
+	}
+}
+
+// GetCommand returns the commands with names matching the given regex.
+func (cs *CommandSet) GetCommands(nameRegex string) ([]*CommandSet, error) {
+	var results []*CommandSet
+	re, err := regexp.Compile(nameRegex)
+	if err != nil {
+		return []*CommandSet{}, err
+	}
+
+	for _, cmd := range cs.Commands {
+		if re.MatchString(cmd.Name) {
+			// A commandset can be dynamic, which needs to run a script that generates YAML items.
+			if cmd.Dynamic != "" && !cmd.completed {
+				configData, err := exec.Command("/bin/bash", "-c", cmd.Dynamic).Output()
+				if err != nil {
+					if exErr, ok := err.(*exec.ExitError); ok {
+						return nil, fmt.Errorf("Script:\n%s", exErr.Stderr)
+					} else {
+						return nil, err
+					}
+				} else {
+					// Ignore the topmost name and add its commands instead,
+					// to prevent a forced extra level as we need one toplevel commandset.
+					var commandSet CommandSet
+					err = yaml.UnmarshalStrict(configData, &commandSet)
+					if err != nil {
+						return nil, err
+					}
+					for _, commands := range commandSet.Commands {
+						cmd.Commands = append(cmd.Commands, commands)
+					}
+					log.Print("dynamic data: %s", configData)
+					cmd.completed = true
+				}
+			}
+
+			results = append(results, cmd)
+		}
+	}
+	return results, nil
+}
+
+// Search takes a search string, splits it and iteratively walks along the
+// provided commandset.
+func (cs *CommandSet) Search(search string) ([]SearchResult, error) {
+	// Regex is much more flexible to search by than just string including
+	// searched text. It also makes it possible to use ^ and $ when search
+	// terms isn't conclusive.
+	re := regexp.MustCompile("\\s+")
+	words := re.Split(search, -1)
+	if words[len(words)-1] == "" {
+		words = words[:len(words)-1]
+	}
+
+	var results []SearchResult
+	currCommandset := cs
+
+	// We need to return everything when no search term is provided,
+	// as the search term is more akin to a filter.
+	if len(words) == 0 {
+		words = []string{""}
+	}
+
+	WordLoop:
+	for _, w := range words {
+		if cmds, err := currCommandset.GetCommands(w); err == nil {
+			switch len(cmds) {
+			// No more results, search is over.
+			case 0:
+				results = append(results, SearchResult{
+					Search:   w,
+					Commands: []*CommandSet{},
+				})
+				break WordLoop
+
+			// Only one result
+			case 1:
+				results = append(results, SearchResult{
+					Search:   w,
+					Commands: cmds,
+				})
+				currCommandset = cmds[0]
+
+			// Many results - return them to let user know what can be searched,
+			// but the search is over.
+			default:
+				results = append(results, SearchResult{
+					Search:   w,
+					Commands: cmds,
+				})
+				break WordLoop
+			}
+
+		} else {
+			// error in regex compilation or dynamic command execution
+			results = append(results, SearchResult{
+				Commands: []*CommandSet{},
+				Error:    err.Error(),
+			})
+			break
+		}
+	}
+
+	return results, nil
+}
+
+// refresh runs the dynamic script, parses the input and puts it into place.
+func (cs *CommandSet) refresh() error {
+	return nil
+}

dir.go

@@ -0,0 +1,77 @@
+package main
+
+import (
+	// Standard
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"regexp"
+	"runtime"
+)
+
+// getConfigDir figures out the path of the configuration directory.
+// Uses env variables appropriate for the OS, or uses the user provided path.
+func getConfigDir() (string, error) {
+	var envName string
+	var path []string
+
+	// User-provided directory takes priority over default directory.
+	if flagConfigDir != "" {
+		return flagConfigDir, nil
+	}
+
+	switch runtime.GOOS {
+	case "linux", "darwin":
+		envName = "HOME"
+		path = []string{".config", "launcher"}
+	case "windows":
+		envName = "USERPROFILE"
+		path = []string{"launcher"}
+	default:
+		return "", fmt.Errorf("Unknown OS: %s", runtime.GOOS)
+	}
+
+	home := os.Getenv(envName)
+	if home == "" {
+		return "", fmt.Errorf("%s is not set", envName)
+	}
+	path = append([]string{home}, path...)
+	configDir := filepath.Join(path...)
+	return configDir, nil
+}
+
+
+// getCommandsetFiles find the home directory and retrieves YAML files
+// not hidden.
+func getCommandsetFiles() ([]string, error) {
+	dir, err := getConfigDir()
+	if err != nil {
+		return nil, err
+	}
+
+	fileInfos, err := ioutil.ReadDir(dir)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "%s\n", err)
+		os.Exit(1)
+	}
+
+	// No filenamer starting with '.', and no filenames not ending in
+	// ".yaml" or ".yml".
+	var filenames []string
+	var filename string
+	for _, entry := range fileInfos {
+		fName := entry.Name()
+		// Shortest considered file would by something like 'a.yml',
+		// 5 characters.
+		if len(fName) < 5 || fName[0] == '.' {
+			continue
+		}
+
+		if m, _ := regexp.Match("(?i)\\.ya?ml", []byte(fName)); m {
+			filename = filepath.Join(dir, entry.Name())
+			filenames = append(filenames, filename)
+		}
+	}
+	return filenames, nil
+}

go.mod

@@ -0,0 +1,19 @@
+module launcher
+
+go 1.20
+
+require (
+	github.com/gdamore/tcell/v2 v2.2.0
+	github.com/mattn/go-runewidth v0.0.10
+	gopkg.in/yaml.v2 v2.4.0
+)
+
+require (
+	github.com/gdamore/encoding v1.0.0 // indirect
+	github.com/lucasb-eyer/go-colorful v1.2.0 // indirect
+	github.com/rivo/uniseg v0.2.0 // indirect
+	golang.org/x/sys v0.0.0-20210309074719-68d13333faf2 // indirect
+	golang.org/x/term v0.0.0-20210220032956-6a3ed077a48d // indirect
+	golang.org/x/text v0.3.5 // indirect
+	gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect
+)

go.sum

@@ -0,0 +1,32 @@
+github.com/gdamore/encoding v1.0.0 h1:+7OoQ1Bc6eTm5niUzBa0Ctsh6JbMW6Ra+YNuAtDBdko=
+github.com/gdamore/encoding v1.0.0/go.mod h1:alR0ol34c49FCSBLjhosxzcPHQbf2trDkoo5dl+VrEg=
+github.com/gdamore/tcell/v2 v2.2.0 h1:vSyEgKwraXPSOkvCk7IwOSyX+Pv3V2cV9CikJMXg4U4=
+github.com/gdamore/tcell/v2 v2.2.0/go.mod h1:cTTuF84Dlj/RqmaCIV5p4w8uG1zWdk0SF6oBpwHp4fU=
+github.com/kr/pretty v0.2.1 h1:Fmg33tUaq4/8ym9TJN1x7sLJnHVwhP33CNkpYV/7rwI=
+github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
+github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
+github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/lucasb-eyer/go-colorful v1.0.3/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
+github.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY=
+github.com/lucasb-eyer/go-colorful v1.2.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
+github.com/mattn/go-runewidth v0.0.10 h1:CoZ3S2P7pvtP45xOtBw+/mDL2z0RKI576gSkzRRpdGg=
+github.com/mattn/go-runewidth v0.0.10/go.mod h1:RAqKPSqVFrSLVXbA8x7dzmKdmGzieGRCM46jaSJTDAk=
+github.com/rivo/uniseg v0.1.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
+github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
+github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210309074719-68d13333faf2 h1:46ULzRKLh1CwgRq2dC5SlBzEqqNCi8rreOZnNrbqcIY=
+golang.org/x/sys v0.0.0-20210309074719-68d13333faf2/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/term v0.0.0-20201210144234-2321bbc49cbf/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/term v0.0.0-20210220032956-6a3ed077a48d h1:SZxvLBoTP5yHO3Frd4z4vrF+DBX9vMVanchswa69toE=
+golang.org/x/term v0.0.0-20210220032956-6a3ed077a48d/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.5 h1:i6eZZ+zk0SOf0xgBpEpPD18qWcJda6q1sxt3S0kzyUQ=
+golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
+gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
+gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=

log/pkg.go

@@ -0,0 +1,23 @@
+package log
+
+import (
+	// Standard
+	"bufio"
+	"fmt"
+	"os"
+)
+
+var (
+	logFile os.File
+	log *bufio.Writer
+)
+
+func init() {
+	logFile, _ := os.OpenFile("/tmp/launcher.log", os.O_APPEND | os.O_CREATE | os.O_WRONLY, 0644)
+	log = bufio.NewWriter(logFile)
+}
+
+func Print(format string, params ...interface{}) {
+	fmt.Fprintf(log, format+"\n", params...)
+	log.Flush()
+}

main.go

@@ -0,0 +1,66 @@
+package main
+
+import (
+	// Standard
+	"bufio"
+	"flag"
+	"fmt"
+	"os"
+	"runtime"
+)
+
+var (
+	mainCommandset CommandSet
+	flagConfigDir string
+)
+
+func main() {
+	var defaultConfigDir string
+	switch runtime.GOOS {
+	case "linux", "darwin":
+		defaultConfigDir = "Default is $HOME/.config/launcher/."
+	case "windows":
+		defaultConfigDir = "Default is %USERPROFILE\\/launcher\\."
+	}
+	flag.StringVar(
+		&flagConfigDir,
+		"config",
+		"",
+		"Specify the directory containing configuration.\n"+
+		defaultConfigDir,
+	)
+	flag.Parse()
+
+	// Finding the files to parse commands from
+	files, err := getCommandsetFiles()
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+
+	// Actually reading and parsing the YAML files into the
+	// CommandSet structs
+	errors := false
+	for _, fName := range files {
+		cset, err := CreateCommandSet(fName)
+		if err != nil {
+			fmt.Printf("\x1b[31m%s:\x1b[0m\n%s\n\n", fName, err)
+			errors = true
+		} else {
+			mainCommandset.Commands = append(
+				mainCommandset.Commands,
+				cset,
+			)
+		}
+	}
+
+	if errors {
+		fmt.Printf("\x1b[33mPress enter to continue\x1b[0m\n")
+		bufio.NewReader(os.Stdin).ReadBytes('\n')
+		os.Exit(1)
+	}
+
+	// Screen needs to be initialized
+	InitUI()
+	LoopUI(&mainCommandset)
+}

run_linux.go

@@ -0,0 +1,29 @@
+// +build linux
+package main
+
+import (
+	// Standard
+	"os"
+	"os/exec"
+	"syscall"
+)
+
+func run(cmd *CommandSet) error {
+	screen.Fini()
+	c := exec.Command("/bin/bash", "-c", lastExecutableCommand.Exec)
+	if lastExecutableCommand.Inplace {
+		c.Stdin  = os.Stdin
+		c.Stdout = os.Stdout
+		c.Stderr = os.Stderr
+		if err := c.Run(); err != nil {
+			return err
+		}
+	} else {
+		c.SysProcAttr = &syscall.SysProcAttr{
+			Setpgid: true,
+			Pgid: 0,
+		}
+		c.Start()
+	}
+	return nil
+}

run_windows.go

@@ -0,0 +1,28 @@
+// +build windows
+package main
+
+import (
+	// Standard
+	"os"
+	"os/exec"
+)
+
+func run(cmd *CommandSet) error {
+	screen.Fini()
+	if lastExecutableCommand.Inplace {
+		c := exec.Command("cmd", "/C", cmd.Exec)
+		c.Stdin  = os.Stdin
+		c.Stdout = os.Stdout
+		c.Stderr = os.Stderr
+		if err := c.Run(); err != nil {
+			return err
+		}
+	} else {
+		c := exec.Command("cmd", "/C", "start /b "+cmd.Exec)
+		if err := c.Run(); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}

types.go

@@ -0,0 +1,18 @@
+package main
+
+type CommandSet struct {
+	Name     string
+	Exec     string
+	Inplace  bool
+	Dynamic  string
+	Commands []*CommandSet
+
+	// internal state
+	completed bool
+}
+
+type SearchResult struct {
+	Search   string
+	Error    string
+	Commands []*CommandSet
+}

ui.go

@@ -0,0 +1,245 @@
+package main
+
+import (
+	// External
+	tcell     "github.com/gdamore/tcell/v2"
+	runewidth "github.com/mattn/go-runewidth"
+
+	// Internal
+	"launcher/log"
+
+	// Standard
+	"fmt"
+	"os"
+	"sort"
+	"strings"
+)
+
+var (
+	screen tcell.Screen
+
+	styleDefault          tcell.Style
+	styleHeader           tcell.Style
+	styleResultRegular    tcell.Style
+	styleResultExecutable tcell.Style
+	styleResultInvalid    tcell.Style
+	styleError            tcell.Style
+
+	search string
+	searchRunes map[rune]struct{}
+
+	lastExecutableCommand *CommandSet
+)
+
+// Init initializes the screen with ANSI command codes.
+func InitUI() {
+	// The terminal screen needs to be initiated by tcell.
+	var err error
+	screen, err = tcell.NewScreen()
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "%s\n", err)
+		os.Exit(1)
+	}
+	if err := screen.Init(); err != nil {
+		fmt.Fprintf(os.Stderr, "%s\n", err)
+		os.Exit(1)
+	}
+
+	// Styles
+	styleDefault          = tcell.StyleDefault
+	styleHeader           = tcell.StyleDefault.Foreground(tcell.Color106)
+	styleError            = tcell.StyleDefault.Foreground(tcell.Color124)
+	styleResultRegular    = tcell.StyleDefault.Foreground(tcell.Color246)
+	styleResultExecutable = tcell.StyleDefault.Foreground(tcell.Color106)
+	styleResultInvalid    = tcell.StyleDefault.Foreground(tcell.Color124)
+
+	// The accepted runes map is used to lookup every keystroke
+	// before appended to the search string.
+	searchRunes = make(map[rune]struct{})
+	for _, r := range []rune{
+			'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
+			'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
+
+			'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
+			'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'Y', 'V', 'W', 'X', 'Y', 'Z',
+
+			'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+
+			'.', '-', '_', ':', '+', '@', '*', '^', '$', ' ',
+		} {
+		searchRunes[r] = struct{}{}
+	}
+
+	// Want to be sure to start with a clean screen.
+	screen.Clear()
+}
+
+// addString places a new string in the screen buffer.
+func addString(x, y int, style tcell.Style, str string) {
+	for _, c := range str {
+		var comb []rune
+		w := runewidth.RuneWidth(c)
+		if w == 0 {
+			comb = []rune{c}
+			c = ' '
+			w = 1
+		}
+		screen.SetContent(x, y, c, comb, style)
+		x += w
+	}
+}
+
+// renderScreen composes all application state into a rendered screen image.
+func renderScreen(cmd *CommandSet) {
+	screen.Clear()
+	lastExecutableCommand = nil
+
+	addString(0, 0, styleHeader, "Command:")
+	addString(0, 1, styleHeader, "   Path:")
+
+	addString(9, 0, styleDefault, search)
+
+	results, err := cmd.Search(search)
+	if err != nil {
+		addString(0, 3, styleError, err.Error())
+	} else {
+		pos := 9
+		last := len(results)-1
+		for i, result := range results {
+			// Search errors likely is a regex syntax error or output from dynamic script.
+			if result.Error != "" {
+				errorLines := strings.Split(result.Error, "\n")
+				for j, line := range errorLines {
+					addString(9, 3+j, styleError, line)
+				}
+				continue
+			}
+
+			switch len(result.Commands) {
+			case 0:
+				addString(pos, 1, styleResultInvalid, result.Search)
+				pos += len(result.Search) + 1
+
+			// A single result was returned.
+			// We add it to the path of uniquely matched commands, and displays all
+			// children if it is the last command, so the user will known what can
+			// be selected after this command.
+			case 1:
+				if i == last && result.Commands[0].Exec != "" {
+					addString(pos, 1, styleResultExecutable, result.Commands[0].Name)
+
+					// lastMatchedCommand is stored to be used for the enter key event,
+					// when the last displayed executable command is executed.
+					lastExecutableCommand = result.Commands[0]
+				} else {
+					addString(pos, 1, styleResultRegular, result.Commands[0].Name)
+				}
+
+				if i == last {
+					// Sorted output is more consistent for finding items
+					sort.SliceStable(result.Commands[0].Commands, func(i, j int) bool {
+						return result.Commands[0].Commands[i].Name < result.Commands[0].Commands[j].Name
+					})
+
+					for i, matchingCommand := range result.Commands[0].Commands {
+						addString( 9, 3+i, styleDefault, matchingCommand.Name)
+					}
+				}
+				pos += len(result.Commands[0].Name) + 1
+
+			// More than one command was returned.
+			// A list of them is displayed for the user to choose from.
+			default:
+				addString(pos, 1, styleResultInvalid, result.Search)
+
+				// Sorted output is more consistent for finding items
+				sort.SliceStable(result.Commands, func(i, j int) bool {
+					return result.Commands[i].Name < result.Commands[j].Name
+				})
+
+				for j, matchingCommand := range result.Commands {
+					addString( 9, 3+j, styleDefault, matchingCommand.Name)
+				}
+				pos += len(result.Search) + 1
+			}
+		}
+	}
+
+	screen.ShowCursor(9+len(search), 0)
+	screen.Show()
+}
+
+// Loop is the main input loop and never returns.
+func LoopUI(cmd *CommandSet) {
+	for {
+		switch ev := screen.PollEvent().(type) {
+		case *tcell.EventResize:
+			screen.Sync()
+			renderScreen(cmd)
+
+		case *tcell.EventKey:
+			// Program exits with escape.
+			if ev.Key() == tcell.KeyEscape {
+				screen.Fini()
+				os.Exit(0)
+			}
+
+			// Backspace, because of course!
+			if ev.Key() == tcell.KeyBackspace2 || ev.Key() == tcell.KeyBS {
+				if last := len(search)-1; last >= 0 {
+					search = search[:last]
+					renderScreen(cmd)
+				}
+			}
+
+			// Ctrl+W for removing last word is a must.
+			if ev.Key() == tcell.KeyCtrlW {
+				// It feels natural to remove all trailing whitespace
+				// along with the previous word.
+				search = strings.TrimRight(search, " ")
+
+				if idx := strings.LastIndex(search, " "); idx > -1 {
+					search = search[:idx+1]
+				} else {
+					// No space before cursor - first word on line.
+					search = ""
+				}
+
+				renderScreen(cmd)
+			}
+
+			// And sometimes it is nice to start from the beginning.
+			if ev.Key() == tcell.KeyCtrlU {
+				search = ""
+				renderScreen(cmd)
+			}
+
+			// To make it simple, a small subset of keys are
+			// allowed appending to the search string.
+			if _, ok := searchRunes[ev.Rune()]; ok {
+				search += string(ev.Rune())
+				renderScreen(cmd)
+			}
+
+			// Commands are executed with the Enter key.
+			if ev.Key() == tcell.KeyEnter {
+				if lastExecutableCommand != nil {
+					log.Print("%v", lastExecutableCommand.Exec)
+					err := run(lastExecutableCommand)
+					screen.Fini()
+					if err != nil {
+						fmt.Printf("%s\n", err)
+					}
+					os.Exit(0)
+				}
+			}
+		}
+	}
+}
+
+// Close sends ANSI sequences to close the screen and return the console to normal.
+func Close() {
+	if screen != nil {
+		screen.Fini()
+	}
+}